> 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/overleaf-learn-latex-pt/mais-topicos/21-how-tex-macros-actually-work-part-3.md).
# Como é que as macros TeX funcionam realmente: Parte 3
[Parte 1](/latex/overleaf-learn-latex-pt/mais-topicos/19-how-tex-macros-actually-work-part-1.md) [Parte 2](/latex/overleaf-learn-latex-pt/mais-topicos/20-how-tex-macros-actually-work-part-2.md) [Parte 3](/latex/overleaf-learn-latex-pt/mais-topicos/21-how-tex-macros-actually-work-part-3.md) [Parte 4](/latex/overleaf-learn-latex-pt/mais-topicos/22-how-tex-macros-actually-work-part-4.md) [Parte 5](/latex/overleaf-learn-latex-pt/mais-topicos/23-how-tex-macros-actually-work-part-5.md) [Parte 6](/latex/overleaf-learn-latex-pt/mais-topicos/24-how-tex-macros-actually-work-part-6.md)
## Hora de fazer uma pausa!
Antes de avançarmos para a próxima parte desta história, precisamos de fazer uma recapitulação: relembrar para onde estamos a ir e organizar as nossas ideias para garantir que todas as ideias-chave estão no lugar. Só um lembrete, o nosso exemplo trabalhado baseia-se na suposição de que o TeX leu uma linha de texto contendo `Olá Mundo \\jobname` e que o TeX está a compor isto para construir um parágrafo.
### O objetivo final
O nosso objetivo é desenvolver uma melhor (mais profunda) compreensão da natureza das macros do TeX e de como funcionam. No entanto, para chegar lá, primeiro precisamos de entender como o TeX lê um ficheiro de entrada e processa os caracteres dentro dele. Aqui está um resumo dos tópicos abordados até agora.
* O TeX lê (analisa) cada carácter na sua entrada e, para cada carácter, o TeX tem duas informações:
* **código de carácter**: um número inteiro usado para identificar esse carácter, por exemplo, quando armazenado num ficheiro de entrada .tex;
* **código de categoria**: outro número inteiro, interno ao TeX, que usa para atribuir significado a cada carácter lido da entrada.
* Assim que um carácter é lido pelo TeX, o código de categoria de cada carácter torna-se *permanentemente* associado a esse carácter individual através da criação de um token de carácter:
* O TeX usa uma fórmula simples para “empacotar” um código de carácter e o respetivo código de categoria num inteiro chamado token de carácter.
* Pode alterar o significado de qualquer carácter que o TeX ainda tenha *ainda não tenha lido* atribuindo um código de categoria diferente a qualquer carácter cujo comportamento queira alterar — ou seja, modificar a forma como o TeX trata esse carácter.
* A redefinição (remapeamento) dos códigos de categoria é feita usando o primitivo do TeX `\catcode` comando.
* Quando o TeX vê um código de categoria 0, muda para um modo especial de leitura e começa a procurar um comando: seja uma (potencialmente) *palavra de controlo* ou um símbolo único de *símbolo de controlo*.
Até agora, vimos o processo de leitura de entrada do TeX à medida que identifica caracteres individuais e usa o código de categoria de cada carácter para determinar o que fazer a seguir. Alguns caracteres são apenas itens normais de texto para composição tipográfica (por ex., código de categoria 11), mas também vimos caracteres de espaço (código de categoria 10) e caracteres de escape (código de categoria 0). Há outros códigos de categoria que, por brevidade, não analisámos — como o código de categoria 1 (“início de grupo”, por ex., `{`), código de categoria 2 (“fim de grupo”, por ex., `}`) e outros. Cada código de categoria desempenha o seu próprio papel na leitura da entrada do TeX e no processamento subsequente pelos processos/algoritmos de software dentro do TeX.
### Tokens: uma revisão rápida
O conceito de “tokens” é central para a forma como o TeX funciona: verá “tokens” mencionados ou referenciados ao longo de livros, artigos e comunidades online relacionados com o TeX, por isso vale a pena rever brevemente este tema — pode encontrar mais pormenores num artigo publicado anteriormente [O que é um "token TeX"?](/latex/overleaf-learn-latex-pt/artigos-aprofundados/53-what-is-a-tex-token.md)
Já vimos que o TeX converte caracteres de entrada em tokens ao combinar o código do carácter e o código de categoria num único inteiro composto. O TeX faz algo semelhante com os comandos: usando o nome do comando calcula um inteiro chamado um *token de comando* (vamos explorar isto com mais detalhe). Como orientação, pode pensar nos tokens como o método do TeX para “empacotar” os itens que leu da entrada, tornando-os prontos para serem encaminhados para a próxima fase do processamento do TeX. Ter todos os itens (caracteres ou comandos) cuidadosamente embrulhados numa única representação numérica facilita o seu processamento mais adiante na cadeia. Por exemplo, quando o TeX quer armazenar parte da sua entrada para usar mais tarde, como uma definição de macro, o TeX só precisa de guardar a sua definição de macro, por mais complexa que seja, como uma série de inteiros, em que cada inteiro é um token que representa um carácter ou um comando que faz parte de (está contido em) a definição da sua macro.
## Então, o que se segue?
Na secção final da Parte 2 vimos como um carácter de escape (código de categoria 0) coloca o TeX num modo especial de processamento em que procura o nome de um comando. No nosso exemplo, o TeX detetou a sequência de caracteres `jobname` e terminámos a Parte 2 no ponto em que o TeX ia “fazer alguma coisa” com essa sequência de caracteres (nome de um comando). Nesta parte veremos, em detalhe, o que o TeX faz a seguir.
Assim que o TeX identificou que uma determinada sequência de caracteres no seu ficheiro de entrada representa o nome de um comando (aqui, `jobname`) o TeX pode, dependendo do que estiver a fazer, precisar de executar esse comando. Dizemos “pode precisar de” porque há momentos em que o TeX não tentará executar imediatamente um comando: por exemplo, quando está a definir uma macro (o TeX está a construir listas de tokens) — tópicos que discutiremos mais tarde. No entanto, continuaremos a seguir o nosso exemplo em que o TeX está a compor um parágrafo e *irá*, nesta situação, precisar de executar `\jobname`.
### De uma sequência de caracteres para executar um comando: como?
Primeiro, revisitemos o Gráfico 5b da Parte 2, no qual o TeX identificou que uma determinada sequência de caracteres dentro da entrada constitui o nome de um comando: `jobname`. O Gráfico 5b indica que o TeX tem de “verificar tabelas internas...”. O que é que isso *na verdade significa*?
Outra descrição, mais detalhada, de como o TeX “verifica tabelas internas” para fazer a transição de ter uma sequência de caracteres (por ex., `jobname`) para descobrir exatamente qual é o comando e o que significa, pode ser encontrada num artigo anterior [O que é um "token TeX"?](/latex/overleaf-learn-latex-pt/artigos-aprofundados/53-what-is-a-tex-token.md) Aqui, resumiremos as ideias-chave tentando evitar repetições excessivas.
Comecemos por uma analogia. Suponha que está a ler um livro e se depara com uma palavra desconhecida: o que faz? Hoje, é quase certamente “recorrer ao Google”, mas vamos assumir que prefere um método mais antigo: pega num dicionário que lista palavras e fornece o(s) seu(s) significado(s). O TeX tem um mecanismo análogo: um “dicionário” interno que lista todos os comandos atualmente conhecidos pelo TeX — e o “significado” desses comandos. Por “significado” referimo-nos ao tipo de comando: o que faz, além de qualquer outra informação de que o TeX possa precisar para executar esse comando. Note também que o termo “comando” inclui quaisquer macros de TeX/LaTeX escritas por utilizadores/programadores de TeX e os [centenas de comandos primitivos incorporados](/latex/overleaf-learn-latex-pt/mais-topicos/46-tex-primitives-listed-by-tex-engine.md).
Continuando a nossa analogia com o dicionário. Quando, como leitor humano, precisamos de procurar o significado de uma palavra, pesquisamos no dicionário usando a lista alfabética de palavras fornecida pelo dicionário — mas, claro, o TeX não funciona bem assim. Voltando ao nosso exemplo original, `jobname` como é que o TeX encontra, no seu “dicionário”, o “significado” de `jobname`— e o que é que esse “significado” realmente fornece ao TeX?
Em vez de fornecer uma “lista alfabética” interna de todos os comandos que o TeX conhece, faz algo um pouco diferente. O TeX converte toda a sequência de caracteres — presente no nome de um comando — num único inteiro, que será usado para identificar (representar) esse comando. Internamente, o TeX mantém um grande “dicionário” de todos os comandos conhecidos, no qual guarda/armazena os *inteiros* calculados a partir dos nomes dos comandos — note que esse dicionário não armazena os próprios nomes reais dos comandos como sequências de letras (chamadas *strings*). O TeX usa esse dicionário para todos os seus comandos incorporados (primitivos) *e* e também o utilizará para armazenar detalhes de qualquer macro (comando) criada por utilizadores: o nome da sua macro é transformado num inteiro e esse inteiro é “registado” dentro do dicionário do TeX.
Sempre que o TeX deteta um comando usado na sua entrada e precisa de saber algo sobre esse comando, converte a sequência de caracteres do nome do comando num inteiro “equivalente” e usa esse inteiro para procurar o comando no seu “grande dicionário”. Os programadores entre vocês talvez queiram saber que o TeX usa uma forma de [função hash](https://en.wikipedia.org/wiki/Hash_function) função hash
### Gráfico 6: Dos caracteres ao significado do comando
O gráfico seguinte mostra o percurso que um comando percorre à medida que o TeX converte a sequência de caracteres num inteiro equivalente, a que chama **curcs**, e usa esse inteiro para procurar o significado do comando no “grande dicionário” do TeX. O resultado dessa pesquisa é constituído por duas informações: dois inteiros, chamados **curcmd** e **curchr**, que o TeX pode usar para determinar exatamente o que o comando faz e como o executar em seguida.
Internamente, o TeX mantém uma variável chamada **curcs** (**atu**al **c**contro **lo**sequência) que é usada para armazenar o valor inteiro do comando em que o TeX está atualmente a trabalhar — ou seja, **curcs** armazena o inteiro calculado a partir do nome do comando. Isso não é toda a história porque há mais um pormenor: se o TeX acabou de ler/processar um carácter, e não um comando, definirá **curcs** com o valor 0, para se lembrar de que a última coisa lida foi um carácter, e não um comando.
### O que os comandos significam para o TeX
Se olharmos para o conjunto de [comandos incorporados fornecidos pelos motores de TeX](/latex/overleaf-learn-latex-pt/mais-topicos/46-tex-primitives-listed-by-tex-engine.md) podemos ver que alguns desses comandos estão intimamente relacionados: executam tarefas semelhantes; por exemplo, há 4 comandos primitivos que todos os motores de TeX usam para definir (criar) macros: `\def`, `\gdef`, `\edef`, `\xdef`. Esses 4 comandos definem todos macros, mas, claro, cada um o faz de forma ligeiramente diferente. Se pensarmos nisto do ponto de vista da programação: aqui temos 4 comandos de definição de macros que, em termos gerais, fazem a mesma coisa, mas precisamos de escolher entre eles para acomodar o seu comportamento individual.
Para lidar com isso, o TeX atribui dois valores a cada comando e esses dois valores são o que o TeX entende como o “significado” de um comando (o seu papel/o que faz) — esses dois valores são internos ao TeX, nas profundezas do software, e fazem parte da “maquinaria interna” que não é acessível aos utilizadores. Cada comando TeX, seja um primitivo incorporado ou um comando definido pelo utilizador, recebe dois valores que, para o TeX, definem/classificam o seu comportamento — o que significa para o TeX. Quando o TeX usa o seu “grande dicionário” para procurar um comando, encontra essas duas informações vitais:
* **código de comando**: uma espécie de “classificação geral” que indica que “tipo” de comando é — por exemplo, um comando de “definição de macro” (um dos `\def`, `\gdef`, `\edef`, `\xdef`); um comando de “criação de caixas” (um dos `\hbox`, `\vbox` ou `\vcenter`) e assim por diante para as centenas de comandos suportados pelos motores de TeX. As macros (comandos definidos pelo utilizador) também recebem um código de comando.
* **modificador de comando**: Esta é informação complementar que fornece ao TeX informação específica sobre um comando. As macros (comandos definidos pelo utilizador) também recebem um modificador de comando — embora, com as macros, o modificador de comando desempenhe um papel ligeiramente diferente daquele que desempenha para os primitivos (para as macros, o modificador de comando indica onde a definição da macro está armazenada na memória).
Tomados em conjunto, o código de comando e o modificador de comando identificam univocamente cada comando. Aqui estão os códigos de comando e os modificadores de comando para os comandos de definição de macros conforme usados pelo software TeX original de Knuth — note que outros motores de TeX podem usar valores diferentes, mas seguem exatamente o mesmo princípio:
| | | |
| ----------- | ---------------------------------------------------------- | --------------------------------------------------------------- |
| **Comando** | Comando
código
| Comando
modificador
|
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
### Recapitulação: dar sentido a todas estas variáveis/valores
Neste ponto estamos inundados com muita informação sobre valores, variáveis, valores de comandos e todo o tipo de pormenores — pode tornar-se rapidamente confuso, por isso vamos fazer o balanço do que sabemos. Quando o TeX lê algo da sua entrada, isso é ou um carácter ou um comando. Sempre que o TeX lê algo da entrada, precisa de armazenar informação sobre o que acabou de ler (analisar):
* Para **caracteres**: precisa de registar o código do carácter e o código de categoria. Também precisa de criar e armazenar o valor do token que o TeX calcula usando esses valores.
* Para **comandos**: o TeX precisa de conhecer o equivalente numérico, **curcs**, que calculou a partir do nome do comando. Também pode precisar de armazenar o “significado” que obteve ao procurar o comando no “dicionário” do TeX: o código de comando e o modificador de comando. Além disso, o TeX também terá de calcular um valor de token que represente esse comando.
Sim, é confuso: muitas variáveis e ideias de token a circular, por isso vamos tentar dar sentido a isto.
Internamente, o TeX usa quatro variáveis globais para armazenar informação sobre o último item que o TeX leu (ou em que está atualmente a “trabalhar”) — não vamos discutir essas variáveis em grande detalhe, mas saber da sua existência ajuda a fornecer um pouco mais de contexto para entender o que realmente acontece:
* **curcmd**: (comando atual) uma variável inteira. É usada para armazenar o *comando atual* valor do comando que está a ser processado *ou* armazena o valor atual *código de categoria* do carácter que está a ser processado;
* **curchr**: (carácter atual) uma variável inteira, mas o que armazena depende do que o TeX acabou de ler da sua entrada:
* **carácter**: Se o item lido mais recentemente for um carácter, **curchr** armazena o código do carácter atual *código de carácter*.
* **comando**: Se o item lido mais recentemente for um comando, **curchr** armazena o *modificador de comando*: informação adicional que o TeX usa para apoiar/esclarecer **curcmd**— porque, como vimos acima, alguns comandos partilham o mesmo valor de **curcmd**
* **curcs**: (sequência de controlo atual) uma variável inteira que armazena o valor calculado a partir da sequência de caracteres no nome de um comando. **curcs** = 0 se o último item lido foi um carácter individual e não o nome de uma sequência de controlo (um nome de comando);
* **curtok**: (token atual) uma variável inteira que contém o valor do token atual — que pode ser um token de comando ou um token de carácter.
Aqui está a informação acima apresentada numa tabela:
| | | |
| ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Variável global usada internamente no TeX:** | **Quando o TeX analisa um carácter:** | **Quando o TeX analisa um comando:** |
| **curcmd** | Armazena o código de categoria do carácter atual | Armazena o *código de comando*— que identifica o “tipo” do comando atual |
| **curchr** | Armazena o código do carácter atual | Armazena dados suplementares (chamados *modificador de comando*) que fornecem informação adicional sobre o comando atual |
| **curcs** | 0 | Um inteiro positivo não nulo que é calculado (através de uma função hash) usando a sequência de caracteres presente no nome do comando. É usado para aceder ao “dicionário” do TeX e procurar o significado atual de um comando — para obter o seu código de comando e o modificador de comando. |
| **curtok** | Para motores TeX de 8 bits, um *token de carácter* é calculado usando a fórmula: $$\text{curtok}=256\times \text{curcmd} + \text{curchr}$$ onde $$\text{curcmd}$$ é o código de categoria do carácter e $$\text{curchr}$$ é o código do carácter | Para motores TeX de 8 bits, um *token de comando* é calculado usando a fórmula: $$\text{curtok}=4095 + \text{curcs}$$ |
### Notas adicionais sobre o token atual
Para caracteres, o valor máximo possível de um token é obtido usando o maior código de categoria (15) e o maior código de carácter que, para motores TeX de 8 bits, é 255. Em teoria (para motores TeX de 8 bits), o valor máximo de um token de carácter, $$\text{curtok}\_{\text{max}}$$, é:
$$\text{curtok}\_{\text{max}}= 256\times 15 + 255 = 4095$$
Note-se que “em teoria” porque o código de categoria 15 é usado para representar um “carácter inválido” que faz o TeX gerar um erro: um carácter inválido nunca passa pelo processo de leitura de entrada do TeX e, por isso, nunca chega a tornar-se um token de carácter.
Para comandos, o token atual ($$\text{curtok}$$) é calculado a partir de $$\text{curtok}=4095 + \text{curcs}$$ mas para comandos $$\text{curcs}$$ é *sempre* não nulo, pelo que o TeX pode facilmente determinar o que um token representa:
* Se $$\text{curtok} > 4095$$ então é um token de comando;
* Se $$\text{curtok} < 4095$$ é um token de carácter.
Na prática, o TeX usa tokens, um simples valor inteiro, para “empacotar” toda a informação que precisa de saber sobre um item lido da entrada.
## Parte 4
Na Parte 4 exploramos uma gama de macros de exemplo para demonstrar o papel e o propósito da `` secção para atuar como um “modelo de token” que pode ser construído através do uso de tokens delimitadores.
[Parte 1](/latex/overleaf-learn-latex-pt/mais-topicos/19-how-tex-macros-actually-work-part-1.md) [Parte 2](/latex/overleaf-learn-latex-pt/mais-topicos/20-how-tex-macros-actually-work-part-2.md) [Parte 3](/latex/overleaf-learn-latex-pt/mais-topicos/21-how-tex-macros-actually-work-part-3.md) [Parte 4](/latex/overleaf-learn-latex-pt/mais-topicos/22-how-tex-macros-actually-work-part-4.md) [Parte 5](/latex/overleaf-learn-latex-pt/mais-topicos/23-how-tex-macros-actually-work-part-5.md) [Parte 6](/latex/overleaf-learn-latex-pt/mais-topicos/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/overleaf-learn-latex-pt/mais-topicos/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.