> 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/21-how-tex-macros-actually-work-part-3.md).
# Cómo funcionan realmente las macros de TeX: Parte 3
[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)
## ¡Hora de hacer una pausa!
Antes de pasar a la siguiente parte de esta historia, necesitamos hacer un repaso: recordar hacia dónde vamos y ordenar nuestras ideas para asegurarnos de que todas las ideas clave están en su sitio. Solo un recordatorio: nuestro ejemplo resuelto se basa en la suposición de que TeX ha leído una línea de texto que contiene `Hello World \jobname` y que TeX está componiendo esto para construir un párrafo.
### El objetivo final
Nuestro objetivo es desarrollar una comprensión mejor (más profunda) de la naturaleza de las macros de TeX y de cómo funcionan. Sin embargo, para llegar ahí primero necesitamos entender cómo TeX lee un archivo de entrada y procesa los caracteres que contiene. Aquí tienes un resumen de los temas tratados hasta ahora.
* TeX lee (explora) cada carácter de tu entrada y, para cada carácter, TeX tiene dos piezas de información:
* **código de carácter**: un número entero usado para identificar ese carácter, por ejemplo, cuando se almacena en un archivo de entrada .tex;
* **código de categoría**: otro número entero, interno a TeX, que usa para asignar un significado a cada carácter leído de la entrada.
* En cuanto TeX lee un carácter, el código de categoría de cada carácter pasa a quedar *permanentemente* asociado con ese carácter individual mediante la creación de un token de carácter:
* TeX usa una fórmula sencilla para «empaquetar» un código de carácter y su código de categoría correspondiente en un entero llamado token de carácter.
* Puedes cambiar el significado de cualquier carácter que TeX haya *aún no haya leído* asignando un código de categoría diferente a cualquier carácter cuyo comportamiento desees cambiar; es decir, modificando la forma en que TeX trata ese carácter.
* La redefinición (reasignación) de los códigos de categoría se consigue usando el primitivo de TeX `\catcode` comando.
* Cuando TeX ve un código de categoría 0, cambiará a un modo especial de exploración y empezará a buscar un comando: ya sea una *palabra de control* o un *símbolo de control*.
Hasta ahora, hemos examinado el proceso de exploración de la entrada de TeX a medida que identifica caracteres individuales y usa el código de categoría de cada carácter para determinar qué hacer a continuación. Algunos caracteres son simplemente elementos ordinarios de texto para la composición tipográfica (por ejemplo, código de categoría 11), pero también hemos visto caracteres de espacio (código de categoría 10) y caracteres de escape (código de categoría 0). Hay otros códigos de categoría que, por brevedad, no hemos examinado, como el código de categoría 1 («inicio de grupo», por ejemplo, `{`) `}`) y otros. Cada código de categoría desempeña su propio papel en la exploración de la entrada de TeX y en el procesamiento posterior por los procesos/algoritmos de software dentro de TeX.
### Tokens: repaso rápido
El concepto de «tokens» es fundamental para la forma en que funciona TeX: verás «tokens» mencionados o citados a lo largo de libros, artículos y comunidades en línea relacionadas con TeX, así que merece la pena repasar brevemente este tema —puedes encontrar más detalles en un artículo publicado anteriormente [¿Qué es un "token de TeX"?](/latex/es/articulos-en-profundidad/53-what-is-a-tex-token.md)
Ya hemos visto que TeX convierte los caracteres de entrada en tokens combinando el código de carácter y el código de categoría en un único entero compuesto. TeX hace algo similar con los comandos: usando el nombre del comando calcula un entero llamado un *token de comando* (lo exploraremos con más detalle). Como guía, puedes pensar en los tokens como el método de TeX para «empaquetar» los elementos que ha leído de la entrada, dejándolos listos para enviarlos a la siguiente etapa del procesamiento de TeX. Tener todos los elementos (caracteres o comandos) bien envueltos en una única representación numérica facilita procesarlos más adelante en la cadena. Por ejemplo, cuando TeX quiere almacenar parte de tu entrada para usarla más tarde, como una definición de macro, TeX solo necesita guardar tu definición de macro, por compleja que sea, como una serie de enteros, donde cada entero es un token que representa un carácter o un comando que forma parte de (está contenido dentro de) la definición de tu macro.
## Entonces, ¿qué sigue?
En la sección final de la Parte 2 vimos cómo un carácter de escape (código de categoría 0) cambia TeX a un modo especial de procesamiento en el que busca el nombre de un comando. En nuestro ejemplo, TeX detectó la cadena de caracteres `jobname` y terminamos la Parte 2 en el punto en que TeX iba a «hacer algo» con esa cadena de caracteres (nombre de un comando). En esta parte veremos, en detalle, qué hace TeX a continuación.
Una vez que TeX ha identificado que una secuencia concreta de caracteres en tu archivo de entrada representa el nombre de un comando (aquí, `jobname`) TeX podría, dependiendo de lo que esté haciendo, necesitar ejecutar ese comando. Decimos «podría necesitar» porque hay ocasiones en que TeX no intentará ejecutar un comando de inmediato: por ejemplo, cuando está definiendo una macro (TeX está construyendo listas de tokens), temas que discutiremos más adelante. Sin embargo, continuaremos siguiendo nuestro ejemplo en el que TeX está componiendo un párrafo y *va a*, en esta situación, necesita ejecutar `\\jobname`.
### De una cadena de caracteres a la ejecución de un comando: ¿cómo?
En primer lugar, volvamos a la Gráfica 5b de la Parte 2, en la que TeX ha identificado que una determinada cadena de caracteres dentro de la entrada constituye el nombre de un comando: `jobname`. La Gráfica 5b indica que TeX tiene que «comprobar las tablas internas...». ¿Qué significa eso *realmente*?
Otra descripción, más detallada, de cómo TeX «comprueba las tablas internas» para hacer la transición de tener una cadena de caracteres (por ejemplo, `jobname`) a determinar exactamente qué comando es y qué significa, puede encontrarse en un artículo anterior [¿Qué es un "token de TeX"?](/latex/es/articulos-en-profundidad/53-what-is-a-tex-token.md) Aquí resumiremos las ideas clave tratando de evitar una duplicación excesiva.
Empecemos con una analogía. Supón que estás leyendo un libro y te encuentras con una palabra desconocida: ¿qué haces? Hoy en día, casi con toda seguridad «acudir a Google», pero supongamos que prefieres un método más antiguo: recurres a un diccionario que enumera palabras y proporciona su(s) significado(s). TeX tiene un mecanismo análogo: un «diccionario» interno que enumera todos los comandos conocidos actualmente por TeX y el «significado» de esos comandos. Por «significado» nos referimos a qué tipo de comando es: qué hace, además de cualquier otra información que TeX pueda necesitar para ejecutar ese comando. Ten en cuenta también que el término «comando» incluye cualquier macro de TeX/LaTeX escrita por usuarios/programadores de TeX y los [cientos de comandos primitivos integrados](/latex/es/mas-temas/46-tex-primitives-listed-by-tex-engine.md).
Continuando con nuestra analogía del diccionario. Cuando, como lectores humanos, necesitamos buscar el significado de una palabra, utilizamos el diccionario consultando el orden alfabético de las palabras que ofrece el propio diccionario, pero, por supuesto, TeX no funciona exactamente así. Volviendo a nuestro original `jobname` ejemplo, ¿cómo encuentra TeX, dentro de su «diccionario», el «significado» de `jobname`—y qué le proporciona realmente ese «significado» a TeX?
En lugar de ofrecer un «listado alfabético» interno de todos los comandos que TeX conoce, hace algo un poco distinto. TeX convierte toda la secuencia de caracteres —presente en el nombre de un comando— en un único entero, que se usará para identificar (representar) ese comando. Internamente, TeX mantiene un gran «diccionario» de todos los comandos conocidos en el que guarda/almacena los *enteros* calculados a partir de los nombres de los comandos—obsérvese que ese diccionario no almacena los nombres reales de los comandos como secuencias de letras (llamadas *cadenas*). TeX usa ese diccionario para todos sus comandos integrados (primitivos) *y* y lo usará para almacenar los detalles de cualquier macro (comando) creada por los usuarios: el nombre de tu macro se convierte en un entero y ese entero se «registra» dentro del diccionario de TeX.
Cada vez que TeX detecta un comando usado en tu entrada y necesita saber algo acerca de ese comando, convierte la serie de caracteres del nombre del comando en un entero «equivalente» y usa ese entero para buscar el comando dentro de su «gran diccionario». A los programadores entre vosotros quizá les interese saber que TeX usa una forma de [función hash](https://en.wikipedia.org/wiki/Hash_function) función hash para realizar esa conversión.
### Gráfica 6: De los caracteres al significado del comando
La siguiente gráfica muestra el recorrido que realiza un comando a medida que TeX convierte la cadena de caracteres en un entero equivalente, que se llama **curcs**, y usa ese entero para buscar el significado del comando en el «gran diccionario» de TeX. El resultado de esa búsqueda son dos piezas de información: dos enteros, llamados **curcmd** y **curchr**, que TeX puede usar para determinar exactamente qué hace el comando y cómo ejecutarlo posteriormente.
Internamente, TeX mantiene una variable llamada **curcs** (**cur**rent **c**ontrol **s**secuencia) que se usa para almacenar el valor entero del comando en el que TeX está trabajando actualmente; es decir, **curcs** almacena el entero calculado a partir del nombre del comando. Eso no es toda la historia porque hay un detalle más: si TeX acaba de leer/procesar un carácter, no un comando, establecerá **curcs** a un valor de 0 para recordar que lo último leído fue un carácter, no un comando.
### Qué significan los comandos para TeX
Si observamos el conjunto de [comandos integrados proporcionados por los motores de TeX](/latex/es/mas-temas/46-tex-primitives-listed-by-tex-engine.md) podemos ver que algunos de esos comandos están estrechamente relacionados: realizan tareas similares; por ejemplo, hay 4 comandos primitivos que todos los motores de TeX usan para definir (crear) macros: `\def`, `\gdef`, `\edef`, `\xdef`. Esos 4 comandos definen macros, pero, por supuesto, cada uno lo hace de manera ligeramente distinta. Si lo pensamos desde un punto de vista de programación: aquí tenemos 4 comandos de definición de macros que, en líneas generales, hacen lo mismo, pero necesitamos elegir entre ellos para adaptarnos a su comportamiento individual.
Para tratar con esto, TeX asigna dos valores a cada comando y esos dos valores son lo que TeX entiende como el «significado» de un comando (su función/lo que hace); esos dos valores son internos a TeX, profundos dentro del software, y forman parte de la «maquinaria interna» que no es accesible para los usuarios. A cada comando de TeX, ya sea un primitivo integrado o un comando definido por el usuario, se le asignan dos valores que, para TeX, definen/clasifican su comportamiento: lo que significa para TeX. Cuando TeX usa su «gran diccionario» para buscar un comando, encontrará esas dos piezas de información vitales:
* **código de comando**: una especie de «clasificación general» que indica qué «tipo» de comando es, por ejemplo, un comando de «definición de macro» (uno de `\def`, `\gdef`, `\edef`, `\xdef`); un comando de «creación de cajas» (uno de `\hbox`, `\vbox` o `\vcenter`) y así sucesivamente para los cientos de comandos que admiten los motores de TeX. A las macros (comandos definidos por el usuario) también se les asigna un código de comando.
* **modificador de comando**: Esta es información auxiliar que proporciona a TeX información específica sobre un comando. A las macros (comandos definidos por el usuario) también se les asigna un modificador de comando, aunque, con las macros, el modificador de comando cumple un papel ligeramente distinto al de los primitivos (para las macros, el modificador de comando indica dónde se almacena la definición de la macro en memoria).
Tomados en conjunto, el código de comando y el modificador de comando identifican de forma única cada comando. Aquí están los códigos de comando y los modificadores de comando para los comandos de definición de macros tal como los usa el software original TeX de Knuth; observa que otros motores de TeX pueden usar valores diferentes, pero siguen exactamente el mismo principio:
| | | |
| ----------- | ---------------------------------------------------------- | --------------------------------------------------------------- |
| **Comando** | Comando
código
| Comando
modificador
|
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
### Resumen: dar sentido a todas estas variables/valores
En este punto estamos inundados de mucha información sobre valores, variables, valores de comandos y todo tipo de detalles; puede volverse confuso rápidamente, así que hagamos balance de lo que sabemos. Cuando TeX lee algo de tu entrada, eso es o bien un carácter o bien un comando. Cada vez que TeX lee algo de la entrada necesita almacenar información sobre lo que acaba de leer (explorar):
* Para **caracteres**: necesita registrar el código de carácter y el código de categoría. También necesita crear y almacenar el valor del token que TeX calcula usando esos valores.
* Para **comandos**: TeX necesita conocer el equivalente numérico, **curcs**, que calculó a partir del nombre del comando. También puede que necesite almacenar el «significado» que recuperó al buscar el comando en el «diccionario» de TeX: el código de comando y el modificador de comando. Además de esto, TeX también tendrá que calcular un valor de token que represente este comando.
Sí, es confuso: hay muchas variables e ideas de tokens flotando por ahí, así que tratemos de darle sentido.
Internamente, TeX usa cuatro variables globales para almacenar información sobre el último elemento que TeX ha leído (o con el que está «trabajando» actualmente); no entraremos en gran detalle sobre esas variables, pero saber que existen ayuda a proporcionar un poco más de contexto para entender lo que realmente ocurre:
* **curcmd**: (comando actual) una variable entera. Se usa para almacenar el *comando actual* valor del comando que se está procesando *o* almacena el *código de categoría* del carácter que se está procesando;
* **curchr**: (carácter actual) una variable entera, pero lo que almacena depende de lo que TeX acaba de leer de su entrada:
* **carácter**: Si el elemento leído más recientemente es un carácter, **curchr** almacena el *código de carácter*.
* **comando**: Si el elemento leído más recientemente es un comando, **curchr** almacena el *modificador de comando*: información adicional que TeX usa para apoyar/aclarar **curcmd**—porque, como vimos arriba, algunos comandos comparten el mismo valor de **curcmd**
* **curcs**: (secuencia de control actual) una variable entera que almacena el valor calculado a partir de la cadena de caracteres del nombre de un comando. **curcs** = 0 si el último elemento leído era un carácter individual y no el nombre de una secuencia de control (un nombre de comando);
* **curtok**: (token actual) una variable entera que contiene el valor del token actual, que puede ser un token de comando o un token de carácter.
Aquí está la información anterior mostrada en forma de tabla:
| | | |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Variable global usada dentro de TeX:** | **Cuando TeX explora un carácter:** | **Cuando TeX explora un comando:** |
| **curcmd** | Almacena el código de categoría del carácter actual | Almacena el *código de comando*—que identifica el «tipo» del comando actual |
| **curchr** | Almacena el código de carácter del carácter actual | : Almacena datos complementarios (llamados el *modificador de comando*) que proporciona información adicional sobre el comando actual |
| **curcs** | 0 | Un entero positivo distinto de cero que se calcula (mediante una función hash) usando la cadena de caracteres presente en el nombre del comando. Se usa para acceder al «diccionario» de TeX y buscar el significado actual de un comando: recuperar su código de comando y su modificador de comando. |
| **curtok** | Para motores de TeX de 8 bits, se *token de carácter* calcula usando la fórmula: $$\text{curtok}=256\times \text{curcmd} + \text{curchr}$$ donde $$\text{curcmd}$$ es el código de categoría del carácter y $$\text{curchr}$$ es el código de carácter | Para motores de TeX de 8 bits, se *token de comando* calcula usando la fórmula: $$\text{curtok}=4095 + \text{curcs}$$ |
### Notas adicionales sobre el token actual
Para los caracteres, el valor máximo posible del token se obtiene usando el mayor código de categoría (15) y el mayor código de carácter que, para motores de TeX de 8 bits, es 255. En teoría (para motores de TeX de 8 bits), el valor máximo del token de carácter, $$\text{curtok}\_{\text{max}}$$, es:
$$\text{curtok}\_{\text{max}}= 256\times 15 + 255 = 4095$$
Decimos «en teoría» porque el código de categoría 15 se usa para representar un «carácter inválido» que hace que TeX genere un error: un carácter inválido nunca superará el proceso de exploración de la entrada de TeX, por lo que nunca llegará a convertirse en un token de carácter.
Para los comandos, el token actual ($$\text{curtok}$$) se calcula a partir de $$\text{curtok}=4095 + \text{curcs}$$ pero para los comandos $$\text{curcs}$$ es *siempre* es distinto de cero; por tanto, TeX puede determinar fácilmente qué representa un token:
* Si $$\text{curtok} > 4095$$ entonces es un token de comando;
* Si $$\text{curtok} < 4095$$ es un token de carácter.
En efecto, TeX usa tokens, un simple valor entero, para «empaquetar» toda la información que necesita saber sobre un elemento leído de la entrada.
## Parte 4
En la Parte 4 exploramos una serie de macros de ejemplo para demostrar el papel y el propósito de la `` sección como una «plantilla de tokens» que puede construirse mediante el uso de tokens delimitadores.
[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/21-how-tex-macros-actually-work-part-3.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.