> 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/artigos-aprofundados/22-how-does-expandafter-work-the-meaning-of-expansion.md).
# Como funciona \expandafter: o significado da expansão
[Parte 1](/latex/overleaf-learn-latex-pt/artigos-aprofundados/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Parte 2](/latex/overleaf-learn-latex-pt/artigos-aprofundados/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Parte 3](/latex/overleaf-learn-latex-pt/artigos-aprofundados/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Parte 4](/latex/overleaf-learn-latex-pt/artigos-aprofundados/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Parte 5](/latex/overleaf-learn-latex-pt/artigos-aprofundados/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Parte 6](/latex/overleaf-learn-latex-pt/artigos-aprofundados/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)
## Apresentando o conceito de “expansão” do TeX
Tendo revisado [tokens e listas de tokens do TeX](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true), o próximo tópico de apoio em nossa lista para `\expandafter` é o conceito do TeX de *expansão*: o processo central do TeX `\expandafter` foi projetado para funcionar com.
### Sobre o desafio de explicar a expansão...
Para a maioria de nós, o conceito de expansão do TeX, e as razões/mecanismos por trás dele, podem ser confusos — não são fáceis de *completamente* explicar de forma simples e concisa. Muitas das operações/processos internos do TeX estão inter-relacionados de maneiras bastante complexas, o que pode apresentar desafios ao tentar “dissecar” certos aspectos das operações do TeX: tentar discuti-los isoladamente do programa como um todo. A expansão é certamente um conceito que se enquadra nessa categoria porque é um *aspeto* elemento do comportamento do TeX, e profundamente embutido em seus processos internos. No entanto, este artigo tenta construir uma explicação da expansão, oferecendo uma base sobre a qual os leitores possam se apoiar.
Para explicar o mecanismo de expansão do TeX, prosseguiremos passo a passo, examinando uma série de tópicos relacionados/relevantes e reunindo-os para desenvolver uma compreensão deste elemento crucial do comportamento do TeX. Mais adiante no artigo, e para o leitor mais intrépido que gosta de detalhes, damos uma olhada no próprio TeX, resumindo o código-fonte principal que conduz o processo de expansão.
### Pontos-chave sobre tokens do TeX
Ao longo da discussão a seguir, é importante lembrar que o TeX pode obter seu próximo item de entrada de duas fontes:
1. **arquivos de texto físicos**: gerando *de novos tokens* ao ler/escanear caracteres e comandos dentro desses arquivos, ou
2. **listas de tokens**: obtendo entrada ao ler de uma lista de itens existentes, *pré-preparados*, tokens armazenados na memória do TeX.
Lembre também que o TeX usa tokens como uma forma conveniente de “empacotar” de maneira organizada informações sobre qualquer item (caractere ou comando) que ele tenha lido.
Quando o TeX está gerando *de novos tokens* ele irá, *no momento da produção do token*, ter acesso imediato a informações sobre o item cujo valor de token está calculando. Por exemplo, ao gerar novos tokens de comando, o TeX primeiro calcula um valor chamado `curcs` que permite ao TeX localizar informações sobre o comando cujo token está prestes a produzir.
No entanto, se o TeX estiver lendo de listas de tokens (sequências de *tokens armazenados*) ele primeiro precisaria “desempacotar” qualquer token nessa lista antes de poder determinar o que cada token representa. Por exemplo, o TeX poderia estar lendo tokens armazenados como parte de uma definição de macro: esses tokens teriam sido gerados a partir de texto que já foi lido há muito tempo, convertido em tokens e armazenado. O tipo de token (caractere ou comando) determina o que o “desempacotamento” do TeX realmente significa:
* para *tokens de comando* (valor do token é > 4095): calcular `curcs` através de $$\text{curcs}=\text{token value}-4095$$ e usar `curcs` para localizar informações sobre o comando;
* para *tokens de caracteres* (valor do token < 4095): dividir o token de caractere em seu par constituinte de (código do caractere, código de categoria).
### No início...
Para começar nossa exploração da expansão, veremos como os motores TeX classificam, ou categorizam, o conjunto de comandos que eles podem processar. Por enquanto, assuma que “expansível” é simplesmente alguma “propriedade” de um comando do TeX, ainda não explicada.
### A noção de comandos “expansíveis”
Todos os programas de composição tipográfica baseados em TeX (“motores” TeX) entendem duas “classes” principais de comando:
* comandos embutidos no próprio executável do motor: os chamados *primitivos*;
* comandos definidos pelo usuário: os chamados *macros*.
Os motores TeX também usam “ser expansível”, um tipo de “comportamento” de comando, como mecanismo para classificar todos os comandos em dois grupos:
* comandos expansíveis;
* comandos não expansíveis.
Assim, podemos considerar que o conjunto de todos os comandos (primitivos mais macros) pode ser classificado como mostrado no gráfico a seguir:
Embora ainda não saibamos o que expansão/expansível realmente significa, é possível ver que:
* todas as macros são classificadas como comandos expansíveis;
* alguns comandos primitivos (embutidos) também são classificados como expansíveis (a grande maioria não é).
**Nota sobre caracteres ativos**: Além de primitivos e macros, há uma terceira classe de item “expansível”: caracteres ativos — quaisquer caracteres atribuídos com código de categoria 13 também são considerados “expansíveis” porque são processados como “mini-macros”.
#### Como o TeX sabe se um comando é “expansível”?
Da nossa [discussão sobre tokens do TeX](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true) sabemos que tokens nada mais são do que inteiros que o TeX calcula e usa para “empacotar” informações sobre um item de entrada: um caractere ou um comando. Também observamos que, dado qualquer valor de token (inteiro), o TeX pode, se/quando necessário, reverter o processo de tokenização para “desempacotar” um token e revelar dados sobre o comando ou caractere que ele representa.
Usando dados produzidos quando o TeX cria um novo token, ou dados extraídos de um token existente — por exemplo, um armazenado em uma macro ou em outra lista de tokens — o TeX pode verificar suas tabelas internas de armazenamento de dados para encontrar informações detalhadas sobre o comando (ou caractere) representado por esse token. O gráfico a seguir resume o processo de criação de um token de comando (“empacotamento”) e depois, quando o TeX precisa de alguma informação, a reversão do processo (“desempacotamento” do token) para obter dados sobre o comando representado por um determinado valor de token.
### Códigos de comando
Parte das informações que o TeX armazena sobre cada comando (primitivo ou macro) é algo chamado seu *código de comando*: um valor inteiro que os motores TeX usam (internamente) para classificar comandos — comandos com comportamento/funcionalidade semelhante compartilham o mesmo código de comando.
**Nota**: Para um único *não ativos*, caractere, seu código de comando é o *código de categoria* que lhe foi atribuído no momento em que foi lido (escaneado) pelo TeX. Note também que, exceto para caracteres, os códigos de comando são puramente internos ao TeX: não são acessíveis por meio de macros ou comandos primitivos — para ver esses detalhes, você precisará ler o código-fonte do TeX!
Aqui estão alguns exemplos de códigos de comando:
* `\hbox`, `\vbox`, `\vtop`, `\vcenter`, `\box` (e outros) são todos classificados como comandos de “construção de caixas” e compartilham o código de comando 20;
* `\def`, `\edef`, `\gdef`, `\xdef` são todos comandos de “definição de macros” e compartilham o código de comando 97;
* todas as macros são classificadas com um dos códigos de comando 111, 112, 113 ou 114: os diferentes códigos de comando são determinados pelo uso de `\long` ou `\outer` ao definir a macro:
* 111: código de comando para uma macro não-long, não-outer (por exemplo, `\\def\\foo{...}`)
* 112: código de comando para uma macro long, não-outer (por exemplo, `\\long\\def\\foo{...}`)
* 113: código de comando para uma macro não-long, outer (por exemplo, `\\outer\\def\\foo{...}`)
* 114: código de comando para uma macro long, outer (por exemplo, `\\long\\outer\\def\\foo{...}`)
O TeX também usa códigos de comando para identificar o subconjunto de comandos classificados como “expansíveis”. Para isso, o TeX associa comandos expansíveis a valores de código de comando que excedem o valor-limite de 100 (o valor usado pelo TeX original de Knuth, e-TeX e pdfTeX). Consequentemente:
* *não expansíveis* comandos (a grande maioria) têm um código de comando <= 100
* *expansíveis* comandos têm um código de comando > 100
Portanto, se o TeX busca os detalhes de um determinado comando e detecta um código de comando > 100, o TeX sabe imediatamente que ele é expansível. Todas as macros e um pequeno número de primitivos (comandos embutidos) recebem um código de comando indicando que são expansíveis: mas por que o TeX se preocupa com essa classificação “expansível”? Como você pode suspeitar, isso simplesmente significa que esses comandos são um tanto “especiais”; isto é, eles podem ser submetidos ao processo do TeX de *expansão*.
**Nota (caracteres)**: A menos que um caractere tenha sido definido como ativo (código de categoria 13), todos os caracteres são não expansíveis. Os caracteres ativos podem ser vistos como “mini macros” de uma única letra.
## Sim, sim, mas o que é expansão???
Observamos que valores de token maiores que 4095 são usados para representar comandos; consequentemente, o TeX pode, se/quando necessário, “desempacotar” esse token para acessar informações sobre o comando do TeX representado por ele. O TeX pode consultar o valor do código de comando desse comando para determinar se ele se enquadra na categoria especial de ser expansível. Mas o que o TeX faz com essa informação e o que significa “ser expansível”, isto é, expansão, *realmente significa*?
### Expansão: um termo geral para um conjunto de operações
Em certos pontos durante o processamento do TeX ele precisa saber se um token representa um comando expansível:
* **Não**: Se esse token de comando *não* não cair na categoria expansível, o TeX simplesmente “o passa adiante” para a próxima etapa do processamento.
* **Sim**: Se esse token de comando *não* cair na categoria expansível, você pode pensar que o TeX precisa agir de modo que resulte em “filtrar” esse token específico realizando um processo que o TeX chama de “expandir esse token”, ou realizar expansão.
Em essência, a expansão envolve o TeX *remover* removendo *substituí-lo* esse token de sua entrada e
substituindo-o por tokens provenientes do “processo de expansão” específico para aquele comando ou grupo de comandos que compartilham o mesmo código de comando.
#### Quais comandos são expansíveis?
Se você olhar para uma lista de comandos primitivos (embutidos) que os motores TeX classificam como expansíveis (por exemplo, páginas 212–215 do TeXbook), fica aparente que, na prática, expansão é um termo bastante geral que o TeX usa para descrever o comportamento de um grupo de comandos um tanto eclético. Os resultados da expansão de um determinado comando (expansível) variam e podemos ver isso listando um conjunto de comandos expansíveis — agrupados por sua funcionalidade. A semântica precisa dos comandos individuais não é importante aqui; o mais interessante são as consequências gerais de suas ações — o que sua expansão realmente *faz ou alcança*.
| **Comando** | **Descrição** | **Comportamento da expansão** |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | Uma sequência armazenada de tokens de comando/caractere | Na prática, a expansão de macro significa inserir uma lista de tokens para o TeX ler. Isso envolve:
- criar listas de tokens para quaisquer argumentos da macro — esse processo inclui identificar/absorver tokens delimitadores;
- recuperar uma lista de tokens armazenados (a definição da macro) e preparar a inserção, na definição da macro, dos tokens de parâmetro criados na primeira etapa.
Efetivamente, a expansão de macro remove o token da macro da entrada e o substitui pelos tokens contidos na definição.
|
| | Alterar a ordem da expansão | Filtragem/reordenação de tokens |
| | Impedir a expansão (sim, surpreendentemente, é classificado como um comando expansível) | Atrasar a expansão (uma espécie de filtragem de tokens) |
| \input, \endinput, \scantokens
| Relacionado à entrada de uma nova fonte de tokens via arquivos de origem — sim, `\scantokens` nesta categoria devido ao uso de assim chamados “pseudo-arquivos” | Agir como fonte de novos tokens |
| \if, \ifcat, \ifnum, \ifdim, \ifodd, \ifvmode, \ifhmode, \ifmmode, \ifinner, \ifvoid, \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, \ifcase, \ifdefined, \ifcsname, \iffontchar
| Iniciar uma expressão condicional | Iniciar a “filtragem” de tokens: decidir quais dos tokens a seguir processar. |
| | Encerrar uma expressão condicional | Parar a “filtragem” de tokens: decidir quais tokens processar |
| | Construir/gerar um token de comando | Converter uma série de tokens em um único token de comando |
| \number, \romannumeral, \string, \meaning, \fontname, \jobname, \eTeXrevision
| Converter algo em uma sequência de tokens | Gerar alguns tokens (que representam uma quantidade ou valor interno) |
| \the, \unexpanded, \detokenize
| `\the` tem vários usos, incluindo inserção de tokens; `\detokenize` converte uma lista de tokens em uma lista de tokens de caracteres; `\unexpanded` impede a expansão de tokens | Inserir/gerar alguns tokens ou controlar a expansão |
| \topmark, \firstmark, \botmark, \splitfirstmark, \splitbotmark, \topmarks, \firstmarks, \botmarks, \splitfirstmarks, \splitbotmarks
| Comandos para acessar listas de tokens que têm usos especializados | Acessar uma fonte de tokens armazenados (listas de tokens) |
Com base na lista acima, é possível extrair algum “comportamento geral” dessa coleção de comandos — para refinar ainda mais nossa compreensão da expansão? De forma razoavelmente aproximada, os resultados da expansão de um comando se encaixam em algumas atividades-chave:
* geração de tokens
* inserção de tokens
* filtragem de tokens
* alteração/controle da expansão do próximo token
### E finalmente: o significado de expansão?
Podemos considerar que a expansão de um token de comando (incluindo caracteres ativos) envolve o TeX **remover** esse token de comando da entrada e **substituí-lo** esse token por outros tokens que surgem do seu comportamento de expansão: gerando/inserindo tokens, filtrando tokens ou alterando/controlando a expansão do próximo token. Uma vez que um token tenha sido expandido, o TeX continuaria a ler/processar quaisquer tokens que pudessem surgir do processo de expansão. Exatamente quando ou onde o TeX realizará a expansão é uma questão muito diferente: devido às nuances e complexidades do processamento do TeX, é algo que não podemos esperar abordar totalmente neste artigo, mas podemos dar uma visão geral do principal comportamento de processamento de entrada do TeX.
## Expansão e a estrutura do TeX
Poder-se-ia argumentar que a melhor maneira de ver como/onde o TeX distingue entre comandos expansíveis e não expansíveis é olhar para o código-fonte do TeX.
Internamente, o TeX é um software extremamente complexo; consequentemente, é impraticável tentar uma descrição completa dos muitos comportamentos sutis inerentes ao funcionamento do TeX. Como mencionado, exatamente quando ou onde o TeX realmente realizará expansão ao ler tokens é “um pouco complexo”; consequentemente, a discussão a seguir pressupõe que o TeX está em um estado que exige que a expansão ocorra. Situações em que o TeX estaria lendo/gerando tokens, mas não realizando expansão, incluem criar/armazenar tokens para o `\def` comando de definição de macro ou armazenar tokens em um `\toks` registro.
O diagrama a seguir fornece uma visão geral simplificada das partes centrais da estrutura do TeX que lidam com entrada e processamento de tokens: o objetivo é destacar a maneira como tokens expansíveis e não expansíveis são “filtrados” durante o processamento de entrada do TeX. A linguagem de programação C é usada para descrever as várias funções-chave, mas, esperamos, a estrutura básica ficará clara mesmo que você não esteja familiarizado com a linguagem C.
### Explicação do diagrama da estrutura do TeX
Em linhas gerais, o processamento do TeX é conduzido por uma função chamada `maincontrol()` que, no código-fonte do TeX, Knuth se refere como o “chefe executivo” e descreve da seguinte maneira:
> “Chegamos agora à rotina `maincontrol` , que contém o interruptor mestre que faz todas as várias partes do TeX fazerem suas coisas, na ordem certa… este é o grande clímax do programa… Estamos agora no centro da teia, o sistema nervoso central que toca a maior parte das outras partes e as amarra.”
A descrição a seguir é um pouco simplificada, mas dá um “sabor” da estrutura subjacente do software baseado em TeX: como comandos expansíveis são identificados (“interceptados”) e filtrados durante o processamento de entrada do TeX.
Em essência, durante o estágio mais inicial do processamento de entrada do TeX ele usa o valor do código de comando do comando (token) atual para detectar comandos expansíveis (macros, primitivas expansíveis e caracteres ativos); se um for identificado, tais comandos são “interceptados” e “pré-processados” — por meio da expansão. Por meio desse processo de filtragem (expansão), o TeX remove comandos expansíveis da entrada e os substitui por tokens provenientes de seu respectivo comportamento de expansão. Uma vez que o processo de expansão esteja concluído, o TeX lerá quaisquer tokens produzidos por essa expansão. Somente itens não expansíveis são passados para a próxima etapa do processamento do TeX: o “grande interruptor” onde o TeX executará todos os comandos primitivos não expansíveis e comporá caracteres.
### Entendendo maincontrol()
O `maincontrol()` A função contém um grande chamado [instrução switch](https://en.wikipedia.org/wiki/Switch_statement)—Knuth o chama de “grande interruptor”—que o TeX usa para executar todos os *não expansíveis* comandos primitivos: aqueles com um código de comando <=100.
Para executar um determinado comando (ou caractere), essa instrução “grande interruptor” usa uma combinação do modo atual do TeX:
* modo vertical interno/externo, ou
* modo horizontal restrito/de parágrafo, ou
* modo matemático em linha/em destaque
*mais* o valor do código de comando para cada primitivo ou caractere — o código de comando de um *não ativos* caractere é seu *código de categoria* valor. Para registro, todos os 6 modos do TeX recebem um valor inteiro que pode ser usado pelo TeX para salvar e restaurar seu modo atual enquanto alterna entre compor vários construtos — matemática, parágrafos, caixas e assim por diante. Aqui estão os inteiros atribuídos aos vários modos do TeX:
| | | |
| ----------------------------- | ------------------------------------------ | ----------------- |
| **Modo** | **Significado** | **Valor do modo** |
| Vertical externo | Entre parágrafos (construindo páginas) | 1 |
| Vertical interno | Imediatamente dentro de uma `\vbox{...}` | -1 |
| Horizontal | Ao compor/construir parágrafos | 102 |
| Horizontal restrito | Imediatamente dentro de um `\hbox{...}` | -102 |
| Matemática em destaque | Composição de *exibição* equações/fórmulas | 203 |
| Matemática em linha (fórmula) | Composição de *linha* equações/fórmulas | -203 |
Observe o uso de valores negativos para o complemento dos vários modos, como modo vertical interno vs. externo. Ao processar comandos em `maincontrol()`, o TeX usa o valor absoluto do modo atual — ou seja, ignora o sinal negativo. Assim, por exemplo, se o TeX estiver em qualquer um de seus modos horizontais e precisar processar um caractere com código de categoria 11, ele usaria a soma $$102 + 11 = 113$$ dentro de seu “grande interruptor” para desviar para o código que processa esses caracteres em qualquer modo horizontal (construindo parágrafos ou dentro de um `\hbox`).
#### Obtendo o próximo token
O `maincontrol()` a função chama a função `getxtoken()` para obter o próximo token de entrada; por sua vez, `getxtoken()` chama a função de entrada de nível mais baixo `getnext()`. Depois que `getnext()` conclui seu trabalho, e define o valor das principais *variáveis globais*, `getxtoken()` testa se o item recém-lido representa uma macro ou uma primitiva expansível.
Algumas notas sobre `getnext()` e `getxtoken()`:
* **`getnext()`**: esta é a função central de entrada do TeX. Ela lê e processa caracteres de entrada de um arquivo físico ou lê tokens de uma lista de tokens. Observe que `getnext()` não calcula de fato valores de token, mas define um número de importantes *globais* variáveis (por exemplo, o código de comando e `curcs`) que são usadas posteriormente no processamento.
* **`getxtoken()`**: “obter token expandido” usa `getnext()` para ler o próximo item de entrada. Em seguida, testa o código de comando do item recém-lido para verificar se esse item representa um comando expansível: se sim, ele é expandido ou a macro é chamada. Para itens não expansíveis, `getxtoken()` calcula um valor de token e esses detalhes são passados para a próxima etapa do processamento: o “grande interruptor” onde primitivas não expansíveis são executadas e caracteres são compostos.
Em essência, é por meio de `getxtoken()` que todos os itens expansíveis são “filtrados” antes de serem processados em `maincontrol()`: isso faz com que o “grande interruptor” do TeX processe apenas comandos primitivos não expansíveis.
Mais uma vez, enfatizamos que o diagrama acima é uma simplificação porque outras áreas do processamento do TeX também farão com que tokens sejam expandidos; por exemplo:
* quando o TeX está procurando (escaneando) por valores numéricos, ele acionará a expansão em sua busca por inteiros (chamando `getxtoken()`) ;
* o comando primitivo `\romannumeral` causa expansão — veja o artigo [Expansão usando `\romannumeral`](https://www.texdev.net/2011/07/05/expansion-using-romannumeral/) para um uso mais sutil desse fato;
* O `\edef` (“definição expandida”) comando de definição de macro força expansão total;
* o TeX expandirá tokens em certos pontos ao processar o preâmbulo de um `\halign` ou `\valign` (ambos os comandos estão relacionados aos algoritmos de composição de tabelas do TeX).
[Parte 1](/latex/overleaf-learn-latex-pt/artigos-aprofundados/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Parte 2](/latex/overleaf-learn-latex-pt/artigos-aprofundados/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Parte 3](/latex/overleaf-learn-latex-pt/artigos-aprofundados/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Parte 4](/latex/overleaf-learn-latex-pt/artigos-aprofundados/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Parte 5](/latex/overleaf-learn-latex-pt/artigos-aprofundados/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Parte 6](/latex/overleaf-learn-latex-pt/artigos-aprofundados/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/overleaf-learn-latex-pt/artigos-aprofundados/22-how-does-expandafter-work-the-meaning-of-expansion.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.