> 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/17-how-does-expandafter-work-a-detailed-macro-case-study.md). # Como funciona \expandafter: um estudo de caso detalhado de macros [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) ## Estudo de caso: \expandafter exemplo de The $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Manual O $$\varepsilon\mathrm{\text{-}{\TeX}}$$ motor de composição tipográfica foi derivado do software TeX de Knuth e originalmente pretendia ser uma etapa “intermédia” em direção ao desenvolvimento do [Novo Sistema de Composição Tipográfica](https://en.wikipedia.org/wiki/New_Typesetting_System) (NTS), escrito na linguagem de programação Java. $$\varepsilon\mathrm{\text{-}{\TeX}}$$ foi desenvolvido pela primeira vez no final da década de 1990 para adicionar um conjunto de novos comandos primitivos que oferecem funcionalidades adicionais não disponíveis no programa original de Knuth. Embora $$\varepsilon\mathrm{\text{-}{\TeX}}$$ tenha recebido atualizações periódicas desde o seu lançamento inicial, hoje não é amplamente utilizado como um motor de composição tipográfica independente, embora as suas inovações tenham sido absorvidas por gerações posteriores do TeX: pdfTeX, XeTeX e LuaTeX. O [$$\varepsilon\mathrm{\text{-}{\TeX}}$$ manual](http://mirror.ox.ac.uk/sites/ctan.org/systems/doc/etex/etex_man.pdf) contém um exemplo elucidativo de uma macro que faz uso inteligente de `\expandafter`: ``` \def\foo#1#2{\number#1 \ifnum#1<#2, \expandafter\foo \expandafter{\number\numexpr#1+1\expandafter}% \expandafter{\number#2\expandafter}% \fi} ``` `\foo` implementa um mecanismo de repetição, de modo que `\foo{7}{13}` produz `7, 8, 9, 10, 11, 12, 13`; no entanto, `\foo` não utiliza qualquer *atribuições a variáveis* para controlar o processo de repetição — o que a torna uma macro interessante para explorar em algum detalhe. ### Algum contexto: expressões e atribuições Um elemento importante do `\foo`do código é o uso do comando `\numexpr`, um comando de um conjunto de quatro primitivas relacionadas introduzidas pela primeira vez por $$\varepsilon\mathrm{\text{-}{\TeX}}$$: `\numexpr`, `\dimexpr`, `\glueexpr` e `\muexpr`. *expressões* que permitem o cálculo/manipulação de valores TeX do tipo number, dimen, glue ou muglue (respetivamente). Como discutido nas páginas 8–9 do The $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Manual, uma característica importante de *expressões* é que a sua avaliação (cálculo) não exige que o TeX execute quaisquer *atribuições*. Em termos de programação, atribuição é o processo de definir (atribuir) uma variável para ter um valor específico; por exemplo, atribuir `\count` registo `99` para conter o valor `12345` através de `\count99=12345`. Muitos outros tipos de atribuição ocorrem durante o processamento do TeX — como atribuir registos de tokens para conter uma série de tokens, atribuir registos de caixas para conter conteúdo de caixas, e assim por diante. Para efetuar uma atribuição, como `\count99=12345`, o TeX precisa de acionar (executar) o código interno que implementa o comportamento de `\count` ou qualquer outra primitiva que execute algum tipo de atribuição. No entanto, há momentos em que o TeX está a realizar pura *expansão* e, nesses momentos, tais atribuições não são acionadas —*nesse ponto do processamento do TeX*. Exemplos desta situação incluem os seguintes comandos: * `\edef\command {*token list*}` o comando de definição de macro “expanded definition”, que expande tokens em *lista de tokens* e armazena os resultados como a definição de `\command`. * `\write *number* {*token list*}` expande tokens em `*token list*` e escreve-os num ficheiro representado por `*number*`. * `\directlua {*token list*}` este comando primitivo do LuaTeX é usado para passar código Lua ao interpretador Lua incorporado. Todos os tokens em `*token list*` são totalmente expandidos antes de serem passados ao interpretador Lua para execução. #### Exemplo rápido de \edef Se escrevermos as seguintes macros básicas: ``` \def\mycount{\count99=12345} \edef\mymacro{\mycount} ``` `\edef` irá expandir `\mycount` nos seus tokens constituintes, mas não vai mais além: nenhum dos comandos contidos na definição de `\mymacro` será acionado: ou seja, a atribuição de `12345` para `\count99` *não acontece neste momento*; só quando chamarmos `\mymacro` é que essa atribuição ocorrerá à medida que o TeX executa o código para processar a `\count` primitiva. Quando o TeX está a realizar *atividades apenas de expansão* quaisquer atribuições serão acionadas mais tarde no processamento do TeX, e não durante o próprio processo de expansão. #### Por que motivo as atribuições são de interesse aqui? Ao escrever código para executar um ciclo — em qualquer linguagem de programação — é prática comum ter uma variável designada para agir como “contador do ciclo”: usada para controlar o número de vezes que um ciclo é executado. O ciclo é tipicamente controlado testando se essa variável designada como contador do ciclo atingiu um determinado valor — essa variável é incrementada (ou decrementada) em cada iteração do ciclo. No entanto, modificar uma variável de contador do ciclo significa atribuir-lhe um novo valor, o que, no TeX, normalmente requer o comando primitivo `\advance` para incrementar (ou decrementar) um valor armazenado num `\count` registo. Como vimos, durante o puro processo de expansão do TeX tais atribuições (incluindo incrementos de variáveis) não podem ocorrer: a macro `\foo` contorna habilmente esta restrição. ### De volta à explicação de \foo A macro `\foo` é capaz de controlar o processo de repetição *sem* sem necessidade de atribuir valores a quaisquer variáveis: controla a frequência com que o ciclo ocorre usando dados resultantes da expansão: valores de dados armazenados em listas temporárias de tokens. Usando o nosso conhecimento sobre o uso (criação) de listas temporárias de tokens no TeX, podemos observar mais de perto para ver exatamente como `\foo` alcança os seus resultados. **Lembre-se**: Estamos a analisar a execução de uma macro depois de o texto original da sua definição — contido num `.tex` ficheiro físico — ter sido examinado (lido pelo TeX) e convertido numa lista de tokens que representa a definição da macro. Em essência, estamos a acompanhar o processamento, pelo TeX, desses tokens armazenados *tokens* enquanto lê e processa tokens na definição da macro contida algures na memória do TeX. Quaisquer caracteres de espaço originalmente presentes no código TeX da definição da macro (texto dentro do `.tex` ficheiro) terão sido absorvidos enquanto o TeX examinava esse texto à procura de comandos (espaços como terminadores), ou terão sido convertidos em tokens, como o caráter de espaço após a vírgula (`,`) em `\ifnum#1<#2,` que resultou da conversão do caráter de fim de linha (`\r`) num espaço. Como o código TeX em `\foo` usa múltiplos `\expandafter` comandos, vamos ajudar a nossa explicação acrescentando subscritos a cada `\expandafter`, indicando a qual nos estamos a referir. Além disso, alargaremos a notação para os tokens processados por `\expandafter` para $$\mathrm{T^i\_1}$$ e $$\mathrm{T^i\_2}$$, representando tokens $$\mathrm{T\_1}$$ e $$\mathrm{T\_2}$$ para `\expandafteri`: `\expandafteri` $$\mathrm{T^i\_1T^i\_2}$$ Aqui está o código da macro anotado: ``` \def\foo#1#2{\number#1 \ifnum#1<#2, \expandafter1\foo \expandafter2{\number\numexpr#1+1\expandafter3}% \expandafter4{\number#2\expandafter5}% \fi} ``` `\foo` começa com `\number#1` que usa o comando expansível `\number` para converter o valor do primeiro argumento na sua representação composta. O `\number` comando funciona gerando uma lista temporária de tokens que contém tokens de caracteres que representam os dígitos individuais contidos no valor numérico sobre o qual `\number` está a operar. Essa lista de tokens torna-se a próxima fonte de entrada do TeX. Aqui, essa lista de tokens é lida e os tokens são produzidos para compor tipograficamente o valor de `#1`. De seguida, a macro realiza o teste `\ifnum#1<#2` para verificar se o argumento de `#1` é menor do que o argumento passado para `#2`. Se sim, uma vírgula (`,`) é produzida (composta tipograficamente), seguida de algum espaço resultante do token que foi gerado a partir do caráter de quebra de linha após a vírgula (`,`). Esse caráter de espaço foi gerado inicialmente quando o TeX leu esta linha do `.tex` ficheiro. A macro continua processando esta secção seguinte do código, que é o núcleo da sua operação: ``` \expandafter1\foo \expandafter2{\number\numexpr#1+1\expandafter3}% \expandafter4{\number#2\expandafter5}% \fi} ``` Em essência, este código gera uma série de listas temporárias de tokens que resultam em múltiplas chamadas à macro `\foo` macro, terminando quando o teste if `\ifnum#1<#2` já não é verdadeiro. Mas *como* o ciclo é controlado porque não estão a ocorrer atribuições: onde está o “contador do ciclo”? Comecemos por olhar para o código `\expandafter1\foo\expandafter2`. Note que usaremos a notação de subscrito `token` (ou `(token)`) para nos lembrar de que, aqui, o TeX está a ler/processar valores numéricos (inteiros) de tokens. Aqui, temos os seguintes tokens como entrada para `\\expandafter1`: * $$\mathrm{T^1\_1} =$$`\footoken` que é lido e armazenado para posterior *reinserção* de volta na entrada * $$\mathrm{T^1\_2} =$$`\\expandafter2 (token)` que é expandido Para `\\expandafter2` temos: * $$\mathrm{T^2\_1} =$$`{token` que é guardado para reinserção posterior *reinserção* de volta na entrada * $$\mathrm{T^2\_2} =$$ `\numbertoken` que é expandido **Nota:**`\number` é um comando expansível cujo propósito é “converter para tokens”: ou seja, converter uma quantidade numérica numa série de tokens de caracteres que representam essa quantidade. Quando `\number` é expandido, a primeira coisa que o TeX faz é examinar a entrada à procura de inteiros: um processo que desencadeia expansão adicional. **A chave da história:** Aqui, `\number` está a atuar sobre a *expressão* `\numexpr#1+1` que calcula o valor de `#1+1`. `\number` para o converter numa lista temporária de tokens contendo tokens de caracteres que representam o valor de `#1 + 1`. `\number`, acabará por ser lida como o primeiro argumento de outra chamada de `\foo`. `\advance` Em vez de incrementar um contador do ciclo (por meio de `\numexpr` e de atribuição), o uso de`\foo`cria um novo valor, mas sem ser necessária atribuição. Através deste mecanismo, a variável que controla o ciclo ( `#1`o parâmetro De seguida, `\\expandafter3` é processado, produzindo: * $$\mathrm{T^3\_1} =$$`}token` que é guardado para reinserção posterior *reinserção* de volta na entrada * $$\mathrm{T^3\_2} =$$`\expandafter4 (token)`, que é expandido: Para `\expandafter4` temos: * $$\mathrm{T^4\_1} =$$`{token` que é guardado para reinserção posterior *reinserção* de volta na entrada * $$\mathrm{T^4\_2} =$$`\numbertoken` que é expandido e converte `#2` noutra lista temporária de tokens. Por fim,`\expandafter5` é expandido: * $$\mathrm{T^5\_1} =$$`}token` que é guardado para reinserção posterior *reinserção* de volta na entrada * $$\mathrm{T^5\_2} =$$`\fitoken`, que é um comando expansível. A expansão de `\fi` efetivamente termina o `\ifnum` e, na prática, fecha esta iteração da macro. O TeX conclui agora a reinserção de todos os tokens temporariamente guardados pelos múltiplos `\expandafter` comandos: isto gera uma série de listas de tokens de um único token resultantes dos tokens guardados por cada `\expandafter`. Além disso, o TeX também criou listas de tokens por meio da ação de `\number`. ### Montando as listas de tokens Em essência, a `\foo` macro gera uma sequência de listas de tokens: pode pensar em `\foo` como uma “fábrica” de listas de tokens. Essas listas de tokens são lidas pelo TeX para se tornarem as próximas fontes de entrada. A parte engenhosa está contida numa das ações anteriores de `\foo`: ``` \expandafter1\foo\expandafter2 ``` através da qual `\foo` faz com que se chame novamente, mas com argumentos diferentes que são armazenados em listas de tokens construídas por `\number`. Para que estas listas de tokens se comportem coletivamente como uma chamada de macro, as chavetas `{` e `}` foram todas guardadas e reintroduzidas na entrada (como listas de um único token) pelas ações de `\expandafter` comandos. ![listas de tokens geradas pela macro \foo](/files/ffc2998a3df115b0401e7a7c4899e4ac90483661) [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/17-how-does-expandafter-work-a-detailed-macro-case-study.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.