> 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/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md). # Cómo funciona \expandafter: una introducción a los tokens 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) ## Contexto para \expandafter: tokens de TeX y listas de tokens Como primer paso para entender cómo `\\expandafter` funciona realmente, echaremos un vistazo a dos componentes de TeX que son fundamentales para el funcionamiento de `\\expandafter`: los tokens de TeX (números enteros) y las listas de tokens (listas de enteros). A los lectores que deseen explorar esos temas con mucho más detalle les puede interesar leer los siguientes artículos publicados por Overleaf: * [¿Qué es un token de TeX?](/latex/es/articulos-en-profundidad/53-what-is-a-tex-token.md) * [¿Qué es una lista de tokens de TeX?](/latex/es/articulos-en-profundidad/54-what-is-a-tex-token-list.md)-[¿Cómo funcionan realmente las macros de TeX?](/latex/es/mas-temas/01-a-six-part-series-how-do-tex-macros-actually-work.md) ### ¿De dónde provienen los datos de los tokens? A lo largo de este artículo usamos valores reales de tokens calculados por TeX, datos a los que normalmente no pueden acceder los usuarios. Para los lectores curiosos por saber cómo se obtuvieron estos datos de valores de token, Overleaf dispone de compilaciones personalizadas de varios motores TeX que usamos para investigación. Esos motores se modifican para mostrar información sobre las actividades de procesamiento interno de TeX, lo que ayuda a proporcionar material de contexto adicional para algunos de los artículos que producimos. Al mostrar y comentar valores numéricos de tokens, nuestro objetivo es incluir detalles que, con suerte, ayuden a los lectores a comprender mejor los «tokens de TeX», haciendo que este concepto importante resulte un poco menos opaco. ## TeX Tokens 101 (y nociones de expansión) Cuando TeX procesa su archivo de entrada, lee el texto y convierte caracteres individuales y secuencias de caracteres (comandos) en los llamados *tokens*. Un token de TeX es simplemente un valor entero, calculado por TeX, que se utiliza para «codificar» los datos que TeX necesita almacenar sobre un elemento leído de su fuente de entrada actual. Piense en los tokens como pequeños paquetes de información que «empaquetan» juntos los datos que TeX necesita registrar, listos para pasarlos a la siguiente etapa del procesamiento. Internamente, TeX opera sobre esos valores enteros de los tokens; no utiliza las letras, símbolos, dígitos, etc. reales contenidas originalmente en su archivo de entrada: todo se convierte en un token (un entero) y TeX trabaja con ellos. ## Cómo calcula TeX los valores de los tokens Aquí vemos los cálculos de tokens usados en el TeX original de Knuth, e-TeX y pdfTeX; para otros motores TeX, particularmente XeTeX y LuaTeX, sus cálculos de tokens necesitan ser ligeramente diferentes para tener en cuenta el uso de Unicode, pero los métodos de cálculo son similares a los descritos a continuación. ### Tokens de caracteres (caracteres no activos) El cálculo de los valores de los tokens para caracteres no activos es sencillo: $$\text{character token} = 256\times \text{(category code)} + \text{character (ASCII) code}$$ **Ejemplo**La letra A con [código de categoría](/latex/es/mas-temas/43-table-of-tex-category-codes.md) 11, el código de carácter 65 es representado por TeX como el valor del token de carácter $$256\times 11 + 65 = 2881$$. Es posible que encuentre en la literatura sobre TeX descripciones que indican que, una vez que TeX ha leído un carácter, el valor de su código de categoría queda «vinculado permanentemente» a ese carácter: el cálculo anterior del valor del token muestra por qué eso es cierto. Sin embargo, más adelante en el procesamiento de TeX, este puede, y de hecho lo hace, «desempaquetar» los tokens de carácter para revelar el par constituyente (código de carácter, código de categoría) a partir del cual se construyó el token; cuando TeX hace ese «desempaquetado», tampoco alterará el código de categoría de ese carácter, simplemente utiliza esa información durante su procesamiento posterior. ### Tokens de comando El procesamiento de entrada y la generación de tokens de TeX reconocen dos tipos de comando: * comandos construidos a partir de uno o más caracteres que tienen código de categoría 11; * comandos de un solo carácter cuyo código de categoría no es 11: como `\$` o `\#`. En ambos casos, TeX excluye el carácter inicial `\` y utiliza el código de carácter de cada carácter restante para calcular un entero que TeX llama `curcs` (**cur**rent **c**ontrol **s**secuencia). Luego, TeX utiliza el valor de `curcs` para calcular un valor de token para el comando. #### Comandos formados por caracteres con código de categoría 11 Supongamos que nuestro comando (sin el carácter inicial `\` está compuesto por una secuencia de caracteres: $$\mathrm{C\_1C\_2C\_3...C\_N}$$ donde $$\mathrm{C}\_i$$ es el código de carácter de cada carácter; por ejemplo, el código de carácter de A es 65. TeX utiliza todos los códigos de carácter $$\mathrm{C}\_i$$ para calcular el entero `curcs` (usando una [función hash](https://en.wikipedia.org/wiki/Hash_function)). Una vez que TeX ha calculado el valor de `curcs` simplemente le suma 4095 a ese valor, para obtener el valor del token: $$\text{command token} = \text{curcs + 4095}$$ Nótese que la variable `curcs` desempeña un papel extremadamente importante en las actividades de procesamiento interno de TeX. #### Tokens de comando de un solo carácter Los tokens para representar comandos como `\$`, `\#` etc. están sujetos a un cálculo ligeramente diferente: el entero `curcs` ahora es el cálculo más sencillo: $$\text{curcs} = 257 + \text{character (ASCII) code}$$ Por ejemplo, con `\$`, $$\text{curcs}=257 + 36 = 293$$. TeX vuelve a sumar 4095 a este valor (usando $$\text{command token} = \text{curcs} + 4095$$) dando como resultado `\$` tener un valor de token $$293 + 4095 = 4388$$. En comparación con los comandos compuestos por caracteres con código de categoría 11, la única diferencia aquí es la forma en que TeX calcula el valor de `curcs`. **Nota**: el entero `curcs` no se calcula para los tokens de caracteres: siempre se establece en 0 cuando TeX está creando o trabajando con tokens de caracteres. #### Tokens de caracteres activos TeX tiene el concepto de los llamados *caracteres activos*: cualquier carácter asignado con código de categoría 13. Los tokens de esta clase especial de caracteres están sujetos a un cálculo diferente en comparación con los caracteres normales. El mecanismo de caracteres activos permite a TeX crear lo que, en efecto, son macros de un solo carácter que puede usar *sin* sin tener que anteponer al carácter activo un carácter de escape (normalmente `\`): el carácter aislado activará su comportamiento de macro. El ejemplo canónico es el carácter tilde (\~) que TeX/LaTeX usan para los espacios de no separación, que puede definirse/habilitarse así: ``` \catcode`~=13 %asignar el código de categoría 13 a ~ \def~{\penalty100000\ } % definir ~ para actuar como una macro ``` Cuando TeX posteriormente lee un `~` carácter, detectará que su código de categoría es 13 y lo procesará como una «mini macro». Para calcular un token que represente un carácter activo, TeX aplica otra variación para calcular `curcs`: $$\begin{align\*} \text{curcs} &= \text{character code} + 1\ \text{active character token} &= \text{curcs} + 4095\ \end{align\*}$$ Por ejemplo, el carácter \~ tiene el código de carácter 126, lo que significa que su representación del valor del token de carácter activo se calcula así: $$\begin{align\*} \text{curcs} &= 126 + 1\ \text{active character token} &= 127 + 4095\ &=4222\ \end{align\*}$$ Nótese que, al igual que los comandos, los tokens que representan caracteres activos son > 4095. ### Consecuencias/notas * Cualquier token cuyo valor exceda 4095 es inmediatamente identificable como un token de comando; por lo tanto, TeX puede detectar muy fácilmente si un token particular representa un carácter o un comando. * Para cualquier valor de token, TeX puede, cuando lo necesita, «desempaquetar» ese token para revelar el carácter (y su código de categoría), o el comando, originalmente presente en su `.tex` archivo, almacenado en una definición de macro o contenido en alguna otra lista de tokens. * La cantidad «intermedia» llamada `curcs`—que TeX utiliza para calcular los valores de los tokens de comando— desempeña un papel importante en el procesamiento de bajo nivel de TeX. `curcs` actúa como un «valor de índice» que TeX usa para almacenar/buscar el significado actual de un comando. Dado cualquier token de comando, $$\mathrm{T}$$, TeX simplemente resta 4095 para acceder al valor de `curcs`: $$\text{curcs} = \mathrm{T}-4095$$ Por cierto, TeX sí almacena la cadena legible por humanos de caracteres a partir de la cual se genera un token de comando; esto es esencial para la generación de errores y otros comandos como `\string` cuya expansión es la versión legible por humanos de un valor de token. Sin embargo, esas cadenas legibles por humanos de caracteres almacenadas dentro de TeX solo se usan/emiten cuando se solicita: para todo el demás procesamiento se usa el valor entero del token. ## Echando un vistazo a algunos tokens reales Solo para hacer que la noción de tokens parezca un poco menos opaca, definiremos la siguiente macro simple y echaremos un vistazo a los tokens que TeX produce: ``` \def\hello{Greetings, from \TeX. \hskip 10pt} ``` Para los `\hello` macro, TeX usa los caracteres `h`, `e`, `l`, `l`, `o` para calcular un valor de 3745 para `curcs`; TeX luego suma 4095 para crear un valor de token de $$3745 + 4095 = 7840$$ (para el TeX de Knuth, e-TeX o pdfTeX). Después de crear un token para representar `\hello`, la `\def` comando hace que TeX lea los tokens subsiguientes y los use para crear una lista de tokens que se almacena como el *definition* del `\hello` comando. Esa definición almacenada (lista de tokens) puede entonces recuperarse siempre que le indique a TeX que use el `\hello` comando. La siguiente tabla enumera los valores reales de los tokens creados para cada elemento (carácter, macro o primitiva) contenido en la `\hello` definición de macro: esta lista de tokens (enteros) es lo que TeX almacena en su memoria (como una estructura de datos conocida como una [lista enlazada](https://en.wikipedia.org/wiki/Linked_list)). A los lectores que deseen entender las listas de tokens con más detalle se les remite al artículo de Overleaf [¿Qué es una lista de tokens de TeX?](/latex/es/articulos-en-profundidad/54-what-is-a-tex-token-list.md) | | | | ------------------------- | ------------------------- | | **Valor de token de TeX** | **Elemento representado** | | 2887 | G | | 2930 | r | | 2917 | e | | 2917 | e | | 2932 | t | | 2921 | i | | 2926 | n | | 2919 | g | | 2931 | s | | 3116 | , | | 2592 | | | 2918 | f | | 2930 | r | | 2927 | o | | 2925 | m | | 2592 | | | 5235 | \TeX | | 3118 | . | | 2592 | | | 7943 | \hskip | | 3121 | 1 | | 3120 | 0 | | 2928 | p | | 2932 | t | En la lista de tokens anterior, los caracteres tienen códigos de categoría 10, 11 o 12. Por ejemplo: * los caracteres tienen código de categoría 10 y código de carácter 32, dando un valor de token de $$256\times 10 + 32 = 2592$$ * `,` y `.` tienen código de categoría 12 y códigos de carácter 44 y 46 respectivamente, dando tokens: * token para `,` $$= 256 \times 12 + 44 = 3116$$ * token para `.` $$= 256\times 12+ 46 = 3118$$ Siempre que TeX encuentre posteriormente el valor de token 7840 (que representa `\hello`) puede, si es necesario, «desempaquetar» ese token para extraer `curcs` mediante el simple cálculo $$\text{curcs} = \text{token value} - 4095$$ (véase arriba). Usando el valor de `curcs` TeX puede consultar sus tablas internas de datos para determinar que el token de comando 7840 representa un comando de macro. Además, de nuevo mediante `curcs`, TeX también puede buscar y recuperar la definición almacenada de `\hello`. Cuando TeX necesita procesar completamente el token 7840, es decir, ejecutar la `\hello` macro, ya no necesita el token 7840: ese token ya ha *cumplido su función*—es decir, provocó que TeX ejecutara la macro `\hello`. TeX ahora puede descartar el token 7840 y obtener los tokens que representan la definición (lista de tokens) almacenada en memoria. En efecto, el `\hello` de macro (token 7840) ha sido *eliminado* de la fuente de entrada actual de TeX y *reemplazado* por los tokens contenidos en la definición de `\hello`. Lo que acabamos de describir es una forma de *expansión de tokens*. El `\TeX` comando (valor de token 5235 listado arriba) usado dentro de `\hello` es en sí mismo una macro construida a partir de más tokens, por lo que su definición también se almacena como una lista de tokens: | | | | ------------------------- | ------------------------- | | **Valor de token de TeX** | **Elemento representado** | | 2900 | T | | 19598 | \kern | | 3117 | - | | 3118 | . | | 3121 | 1 | | 3126 | 6 | | 3126 | 6 | | 3127 | 7 | | 2917 | e | | 2925 | m | | 19597 | \lower | | 3118 | . | | 3125 | 5 | | 2917 | e | | 2936 | x | | 6175 | \hbox | | 379 | { | | 2885 | E | | 637 | } | | 19598 | \kern | | 3117 | - | | 3118 | . | | 3121 | 1 | | 3122 | 2 | | 3125 | 5 | | 2917 | e | | 2925 | m | | 2904 | X | Si reemplazáramos el `\hello` comando con la lista completa de tokens a partir de la cual está construido, incluyendo la `\TeX` macro, sería una lista bastante larga; es decir, si también *expandiéramos* la `\TeX` macro veríamos: ![Una lista de tokens almacenada en una macro de TeX](/files/9c33b6fc8ff1b3999c9ee2c38fd7803d88131217) Esencialmente, el valor de token único 7840 (para `\hello`) produciría, al expandirse completamente, un total de 51 tokens (enteros) que representan caracteres y comandos primitivos. En la siguiente lista, el carácter o comando representado por cada token está encerrado entre paréntesis «(...)»; estos no se almacenan directamente en las listas de tokens de TeX y se muestran para ayudar al lector: ``` 2887 (G), 2930 (r), 2917 (e), 2917 (e), 2932 (t), 2921 (i), 2926 (n), 2919 (g), 2931 (s), 3116 (,), 2592 (), 2918 (f), 2930 (r), 2927 (o), 2925 (m), 2592 (), 2900 (T), 19598 (\kern), 3117 (-), 3118 (.), 3121 (1), 3126 (6), 3126 (6), 3127 (7), 2917 (e), 2925 (m), 19597 (\lower), 3118 (.), 3125 (5), 2917 (e), 2936 (x), 6175 (\hbox), 379 ({), 2885 (E), 637 (}), 19598 (\kern), 3117 (-), 3118 (.), 3121 (1), 3122 (2), 3125 (5), 2917 (e), 2925 (m), 2904 (X), 3118 (.), 2592 (), 7943 (\hskip), 3121 (1), 3120 (0), 2928 (p), 2932 (t) ``` Para un lector humano esto es solo una serie de enteros, pero para TeX codifica mucha información. ## Leer los tokens ahora y guardarlos para después Mientras TeX lee su entrada, puede haber momentos en los que necesite (o se le indique) retrasar el procesamiento completo de algún conjunto particular de tokens. Si se le ordena hacerlo, TeX, hasta que se le diga que se detenga, continuará creando tokens a partir de la entrada pero los almacenará para usarlos más adelante; posteriormente los recuperará y procesará como parte de sus actividades de composición tipográfica. Esos tokens almacenados se guardan como las llamadas *listas de tokens* que, en efecto, son el único mecanismo interno de almacenamiento de datos de tokens de TeX. Ya hemos visto ejemplos de listas de tokens: las `\hello` y `\TeX` macros enumeradas arriba: la definición de esas macros se almacena en la memoria de TeX como listas de tokens. TeX solo procesará (accionará) dichas listas de tokens cuando usted decida llamar a esas macros. Recuerde también que cada token (valor entero) codifica suficiente información para que TeX determine fácilmente si cada token almacenado en una definición de macro representa un carácter o un comando. ### Guardar tokens con registros de tokens Otro ejemplo de almacenamiento de tokens es la creación explícita de listas de tokens que se guardan en los llamados *registros de tokens*: áreas de almacenamiento interno dedicadas que TeX proporciona a los usuarios para almacenar listas de tokens. La primitiva de TeX `\toksdef` es una forma de usar registros de tokens; por ejemplo, para usar el registro de tokens `100` y referenciarlo usando el comando `\mylist`: ``` \toksdef\mylist=100 \mylist={algunos \TeX{} tokens aquí} ``` `\mylist` es, en efecto, solo un nombre que usted asigna a una lista de tokens almacenada en la ubicación de registro `100`. Similar a una definición de macro, `\mylist` contiene la siguiente lista de tokens: | | | | ------------------------- | ------------------------- | | **Valor de token de TeX** | **Elemento representado** | | 2931 | s | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | 379 | { | | 637 | } | | 2592 | | | 2932 | t | | 2927 | o | | 2923 | k | | 2917 | e | | 2926 | n | | 2931 | s | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | **Nota**: para terminar la `\TeX` macro y evitar que absorba el siguiente `` carácter usamos un par de llaves `{}` inmediatamente después de `\TeX`—los tokens de `{` (379) y `}` (637) se almacenan en la lista de tokens. Otra opción es usar un token de «espacio de control» `\` que aparecería en la lista de tokens como se muestra a continuación (en negrita): | | | | ------------------------- | ------------------------- | | **Valor de token de TeX** | **Elemento representado** | | 2931 | s | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | **4384** | **\\** | | 2932 | t | | 2927 | o | | 2923 | k | | 2917 | e | | 2926 | n | | 2931 | s | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | Obsérvese que el `` el carácter se representa como un *token de carácter* con valor $$256\times 10 + 32 = 2592$$ pero `\` se trata como un comando de un solo carácter *token de comando* (valor 4384) que se calcula usando las fórmulas dadas arriba: \begin{align\*} \text{curcs} & = 257 + \text{código de carácter (ASCII)}\\\ & = 257 + 32\\\ &=289\\\ \text{token de comando para} \left<\text{\\\space}\right> & = \text{curcs + 4095}\\\ & = 289+4095\\\ &=4384\\\ \end{align\*} En esencia `\mylist={algunos \TeX{} tokens aquí}` le dice a TeX: por favor escanea mi archivo de entrada para convertir los siguientes caracteres/comandos en tokens y guárdalos para usarlos más adelante. TeX obedecerá y almacenará esos tokens en una ubicación de memoria a la que puede acceder escribiendo `\the\mylist`, indicando a TeX que inserte una copia de los tokens contenidos en el registro de tokens `\mylist`. Los motores TeX incluyen una serie de comandos primitivos que generan y almacenan explícitamente listas de tokens, como `\everyjob`, `\everypar`, `\mark`, y muchos otros. [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/19-how-does-expandafter-work-an-introduction-to-tex-tokens.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.