> 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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md). # Como funciona \expandafter: dos princípios básicos à exploração do código-fonte 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) ## Introdução Já abordámos agora os tópicos de base necessários para uma exploração completa de `\expandafter`: * os fundamentos dos tokens TeX e de como são calculados; * os princípios por trás do processo de expansão do TeX; * a utilização/criação, pelo TeX, de listas temporárias de tokens durante o processamento de documentos; * como o TeX usa e “faz malabarismos” com várias fontes de entrada (incluindo listas temporárias de tokens). Neste artigo, vamos juntar estes tópicos/conceitos para explicar os mecanismos subjacentes ao `\expandafter` comando do TeX: em resumo, como funciona. ## E assim, para \expandafter A ideia por trás de `\expandafter` é forçar a expansão de um comando (token) antes de o TeX o fazer normalmente. Dados dois tokens, $$\mathrm{T\_1}$$ e $$\mathrm{T\_2}$$ a ação de `\expandafter` $$\mathrm{T\_1T\_2}$$ resulta no processamento, pelo TeX, da $$\mathrm{T\_1}\text{<}$$expansão de $$\mathrm{T\_2}\text{>}$$, onde $$\text{<}\dots\text{>}$$ indica uma lista de tokens. O TeX expande $$\mathrm{T\_2}$$ antecipadamente para que o token $$\mathrm{T\_1}$$ (por exemplo, um primitivo ou uma macro) consiga ver, ou possa agir sobre, os tokens resultantes da expansão de $$\mathrm{T\_2}$$. Se o token $$\mathrm{T\_2}$$ representa um elemento não expansível, como um carácter não ativo ou (a maioria dos) primitivos, a ação de `\expandafter` não altera nada: o TeX continuaria a processar os tokens $$\mathrm{T\_1T\_2}$$ da forma normal. ### Introdução à utilização de \expandafter Se nunca usou `\expandafter`, eis um exemplo da sua utilização com o primitivo `\uppercase{...}`. Suponhamos que queríamos compor o nome do nosso principal `.tex` ficheiro de entrada, mas em letras maiúsculas. Talvez conheçamos os seguintes comandos primitivos do TeX: * `\uppercase`: faz, como o nome sugere, a conversão de tokens de caracteres para o equivalente em maiúsculas (quando existir); * `\jobname`: como vimos, expande-se para dar o nome do principal `.tex` ficheiro. Supondo que o nosso ficheiro TeX se chama `mycode.tex` poderíamos razoavelmente esperar `\uppercase{\jobname}` para compor `MYCODE`. Mas não, compõe `mycode` em minúsculas. O que correu “mal”? Se escrevermos a utilização geral de `\uppercase` como ``` \uppercase{} ``` podemos dizer que `\uppercase` analisa `` e apenas atuará (alterará o caso) sobre *tokens de caracteres* que detetar dentro da ``: todos os tokens não caracter são *ignorados* porque `\uppercase` não irá “olhar para dentro” (expandir) tokens não caracter para ver o que contêm ou representam. Como um token é simplesmente um valor inteiro, tudo o que `\uppercase` tem de fazer é percorrer a lista de tokens para verificar se o valor numérico de cada token em `` está dentro do intervalo de valores que indica um token de carácter. A propósito, `\uppercase` também irá *alterar o caso de caracteres ativos* para criar um carácter ativo em maiúsculas que, por ainda ser ativo, também terá de estar definido; caso contrário, o TeX gerará um erro: `Sequência de controlo indefinida`, mas estamos a desviar-nos do assunto... Por exemplo, mesmo que definamos uma macro que seja apenas texto ``` \def\foo{some lower-case text} ``` então `\uppercase{\foo}` continua a compor `some lower-case text` e não `SOME LOWER-CASE TEXT` como esperaríamos, simplesmente porque a ação de `\uppercase` não tenta determinar o que `\foo` representa: vê `\foo` como um token de comando e ignora-o, tal como fez com `\jobname`. ### Como podemos corrigir isto? \expandafter para o resgate Para compor uma versão em maiúsculas do nome do ficheiro, precisamos de modificar `\uppercase{\jobname}` forçando o TeX a substituir `\jobname` pela sua expansão (uma sequência de tokens de caracteres) *antes de* `\uppercase` entrar em ação. Mais uma vez, a expansão está a ser usada para remover o `\jobname` token (comando) e substituí-lo pelo resultado da sua expansão (uma lista de tokens contendo tokens de caracteres). Assim, se escrevermos ``` \uppercase\expandafter{\jobname} ``` então funciona: `MYCODE` seria composto. O que acontece é que o TeX começa a processar `\uppercase` e verifica imediatamente o carácter de chaveta de abertura obrigatório (`{`); contudo, o TeX deteta um `\expandafter` comando, o que o leva a “desviar temporariamente a atenção” para o processamento de `\expandafter{\jobname}`. Se compararmos `\expandafter` $$\mathrm{T\_1T\_2}$$ com o nosso exemplo `\expandafter{\jobname}` podemos ver * $$\mathrm{T\_1} =\space$$`{`token * $$\mathrm{T\_2} =\space$$`\jobname`token Onde `{`token e `\jobname`token se refere aos valores de tokens calculados pelo TeX — a notação em subscrito token é usada para nos lembrarmos de que o TeX trabalha no mundo dos tokens inteiros. Escrever `\uppercase\expandafter{\jobname}` funciona porque, em traços gerais (os detalhes serão apresentados de seguida), `\expandafter` faz com que o TeX execute as seguintes tarefas: 1. ler e guardar a chaveta de abertura `{`token; 2. ler o token seguinte: `\jobname`token. O TeX reconhece que `\jobname`token representa um comando expansível e expande-o. `\jobname`token é substituído pela sua expansão — uma série de tokens de caracteres; 3. depois de expandir o `\jobname` comando, o TeX coloca o `{`$$\_\mathrm{token}$$ “de volta na entrada” e usa a lista de tokens resultante da expansão de `\jobname` para que o TeX leia `\uppercase{`token``lista de tokens (caracteres)`}`, e isto produz o resultado desejado. O diagrama seguinte mostra como o TeX processa `\uppercase\expandafter{\jobname}`— leia o gráfico de baixo para cima para seguir o fluxo do processo. ![Como \expandafter funciona](/files/7daa5304b390f8683218edca3f614796b99bd7e1) As notas seguintes explicam as várias etapas do processamento. 1. O TeX começa a processar `\uppercase` e verifica a chaveta de abertura obrigatória (`{`) mas deteta um `\expandafter` comando. 2. Se compararmos `\expandafter` $$\mathrm{T\_1T\_2}$$ para a nossa entrada de `\expandafter{\jobname}` podemos ver $$\mathrm{T\_1} =$$`{`token e $$\mathrm{T\_2} =$$`\jobname`token. Note que aqui usaremos o subscrito token para indicar que o TeX está a processar valores inteiros de tokens. 3. `\expandafter` lê e depois guarda temporariamente o `{`token ao armazenar esse valor inteiro do token numa variável interna. Mais tarde, o TeX voltará a inserir esse token na entrada, depois de processar o `\jobname` comando. 4. `\expandafter` lê o token seguinte, `\jobname`token, e expande o `\jobname` comando. 5. A expansão de `\jobname` cria uma lista temporária de tokens que contém uma sequência de tokens de caracteres que representam o `.tex` nome do ficheiro. Note que todos os tokens de caracteres gerados por `\jobname` são calculados usando o código de categoria 12. 6. Uma vez que `\jobname` tenha sido expandido, o TeX reinsere o token guardado no passo 3 (`{`token) e coloca-o de volta na entrada. O TeX faz isso criando outra lista de tokens que contém a *única* `{`token 7. O TeX terminou agora de processar `\expandafter`, resultando em duas listas de tokens prontas a serem usadas como fontes de entrada do TeX. O TeX regressa agora ao processamento de `\uppercase` mas configurou a sua entrada de forma a que as duas listas de tokens criadas por `\expandafter` se tornem a fonte de tokens para `\uppercase`— que agora vê `\uppercase{`token``lista de tokens (caracteres)`}`. `\uppercase` vê agora uma sequência de tokens de caracteres e pode produzir o resultado desejado. 8. Depois de ler todos os tokens de caracteres produzidos por `\jobname`, o TeX regressa a obter tokens da sua fonte de entrada anterior (o nosso ficheiro `.tex` ) de onde lerá o próximo token: a chaveta de fecho `}` necessária para terminar a lista de tokens a serem processados por `\uppercase`. ### \expandafter e listas internas de tokens As listas temporárias de tokens são um *elemento vital* do comportamento de processamento de `\expandafter`: compreender a utilização e a existência dessas listas de tokens pode ajudar a esclarecer como `\expandafter` alcança os seus resultados, particularmente ao tentar escrever, ou compreender, macros que fazem uso de vários `\expandafter` comandos \expandafter consecutivos para conseguir formas mais complexas de processamento de tokens: `\expandafter\expandafter\expandafter...` Outro elemento-chave do comportamento de `\expandafter`, especialmente com vários `\expandafter` comandos \expandafter consecutivos, é a utilização de *recursão* (dentro do próprio software TeX) — um tópico que consideraremos mais tarde neste artigo. Para ajudar ainda mais a nossa compreensão das listas temporárias de tokens, veremos mais um exemplo de `\expandafter`, desta vez com o `\the` comando. #### \expandafter e listas internas de tokens: exemplo 2 Neste exemplo veremos como `\expandafter` pode ser usado para influenciar tokens armazenados numa registo de tokens através do comando `\toks` Comando. Eis os primitivos do TeX que iremos usar: * `**\count** *registo*=*número*`: um primitivo do TeX usado para armazenar o valor `*número*` na localização do TeX `*registo*`; * `**\toks** *registo*={*lista de tokens*}`: um primitivo do TeX usado para armazenar `*lista de tokens*` na localização do registo de tokens `*registo*`— guardando uma sequência de tokens para utilização posterior; * `**\the** *token*`: um comando primitivo expansível do TeX que processa `*token*`, embora os resultados exatos dependam da natureza do `*token*` que está a ser processado. `\the` tem vários usos: entre eles está a composição do valor armazenado num parâmetro ou variável do TeX (por exemplo, um registo). Outros usos de `\the` incluem a inserção de uma cópia dos tokens armazenados num registo de tokens. Aqui, usaremos `\the` para compor o valor armazenado num `\count` registo. Começaremos com o seguinte código TeX para armazenar o valor `12345` no registo `\count` do TeX `99`: ``` \count99=12345 ``` Se quisermos compor o valor armazenado em `\count99` podemos usar `\the\count99` (ou `\number\count99`). De seguida, usaremos o `\toks` comando para armazenar alguns tokens no registo de tokens `99`: ``` \toks99={\the\count99 } ``` A lista de tokens armazenada no registo de tokens `99` teria o seguinte conteúdo: | | | | ------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | | **Valor do token do TeX** | **Item representado** | | 5382 | `\the` | | 7885 | `\count` | | 3129 | `9` (código de carácter 57 com código de categoria 12), resultando num valor de token de $$256 \times 12 + 57 = 3129$$ | | 3129 | `9` (código de carácter 57 com código de categoria 12), resultando num valor de token de $$256 \times 12 + 57 = 3129$$ | | 2592 | `` (código de carácter 32 com código de categoria 10), resultando num valor de token de $$256 \times 10 + 32 = 2592$$ | Note que a lista de tokens criada por `\toks99` não *contém* o valor efetivo dos dados armazenado em `\count99` porque o `\toks` comando não realiza expansão: limita-se a criar tokens e a armazená-los. No nosso exemplo, `\the` não é expandido, pelo que não processa `\count99`; aqui `\the` é simplesmente convertido num token (valor 5382) e armazenado na lista de tokens. Se quisermos que a `\toks99` lista de tokens contenha tokens que representem dados armazenados em `\count99` vamos precisar de alguma forma de criar esses tokens (torná-los disponíveis) para que o `\toks` comando possa aceder a eles. E, claro, `\expandafter` pode fazer isso por nós. Se escrevermos: ``` \toks99=\expandafter{\the\count99 } ``` a ação/processamento do `\toks` comando será “colocada em espera” enquanto `\expandafter` provoca (força) a expansão de `\the` que, por sua vez, atua sobre `\count` para gerar uma lista temporária de tokens contendo tokens de caracteres que representam dados armazenados em `\count99`. Um pequeno mas importante ponto é o `` carácter após os dígitos `99`: esse `` carácter atua para terminar o processo de leitura do TeX quando este está a procurar uma quantidade numérica. Aqui, a ação de `\expandafter` é muito semelhante à do `\jobname` exemplo. 1. Ler e guardar a abertura `{`token. 2. Ler o token seguinte, `\the`token, que representa um comando expansível, por isso o TeX expande-o. `\expandafter` força a expansão de `\the` que depois atua sobre `\count99` para converter os dados armazenados em `\count` do TeX `99` (o número 12345) numa lista temporária de tokens. Essa lista conterá tokens de caracteres que representam os dígitos `1`, `2`, `3`, `4` e `5`— tokens de caracteres com código de categoria 12. 3. Depois de expandir e processar `\the`, o TeX coloca o `{`token “de volta na entrada” e usa a lista de tokens resultante de `\the\count99` para que o TeX leia `\toks99={`token``lista de tokens (caracteres)`}` e isto produz o resultado desejado. Esta sequência de acontecimentos é resumida no diagrama seguinte — leia o gráfico de baixo para cima para seguir o fluxo do processo. ![Como \expandafter funciona](/files/69848e3f31e2bf891bd3780867cb82b3c6f6c135) 1. O TeX começa a processar `\toks`; vê o `=` sinal opcional, depois verifica a chaveta de abertura obrigatória (`{`, ou qualquer carácter com código de categoria 1) usada para indicar o início de uma lista de tokens. Contudo, o TeX deteta um `\expandafter` comando e prossegue antes para o executar. 2. Se compararmos `\expandafter` $$\mathrm{T\_1T\_2}$$ para a nossa entrada de `\expandafter{\the\count99 }` podemos ver $$\mathrm{T\_1} =$$ `{`token e $$\mathrm{T\_2} =$$ `\thetoken`. 3. `\expandafter` lê e depois guarda temporariamente o `{`token (o TeX armazena temporariamente esse valor inteiro do token numa variável interna). Mais tarde, o TeX voltará a inserir esse token na entrada, depois de processar `\the` 4. `\expandafter` lê o token seguinte, `\the`token e expandi-lo. 5. A expansão de `\the` cria uma lista temporária de tokens a partir do processamento de `\count99`— essa lista de tokens contém uma sequência de tokens de caracteres que representam o valor dos dados armazenado no `\count` do TeX `99`. 6. Uma vez que `\the` tenha sido expandido, o TeX reinsere o token guardado no passo 3 (`{`token) e coloca esse token de volta na entrada. O TeX faz isso criando outra lista de tokens que contém o *única* token `{`token. 7. O TeX terminou agora de processar `\expandafter` e produziu duas listas de tokens prontas a serem usadas como próximas fontes de entrada. O TeX regressa ao processamento de `\toks99=` mas agora o TeX configurou a sua entrada de modo a que as duas listas de tokens criadas por `\expandafter` se tornem a fonte de tokens para `\toks`— que agora vê `{`token``lista de tokens (caracteres)`}`. `\toks` possam agora aceder, e armazenar, a sequência de 5 tokens de caracteres que representam o valor dos dados (`12345`) armazenado em `\count99`: o resultado desejado. 8. Depois de ler todos os tokens de caracteres produzidos por `\the\count99`, o TeX regressa a obter tokens da sua fonte de entrada anterior (o nosso ficheiro `.tex` ) de onde lerá o próximo token: a chaveta de fecho `}` necessário para terminar a lista de tokens a ser guardada por `\toks99={...}`. ## Como \expandafter realmente funciona Nesta secção vamos fazer uma análise “de baixo nível” dentro do próprio TeX: explorando o código-fonte/as funções no TeX que implementam o comportamento de `\expandafter`. Os detalhes são expressos em pseudocódigo C, mas deverão ser acessíveis a qualquer pessoa familiarizada com outras linguagens de programação. O diagrama anotado seguinte explica como o TeX implementa `\expandafter` como parte de uma função maior chamada `expand()`— a função central que conduz o processamento de expansão do TeX. Na secção responsável por implementar `\expandafter` podemos ver [*recursivo* comportamento](https://en.wikipedia.org/wiki/Recursion) onde uma outra chamada à `expand()` função é usada para processar o segundo token lido, $$\mathrm{T\_2}$$, nos casos em que $$\mathrm{T\_2}$$ é expansível. Embora este código apareça no motor TeX de Knuth, os princípios básicos delineados por este gráfico são aplicáveis a todos os motores TeX. ![Como \expandafter funciona internamente no TeX](/files/3bd1afc6d1a34a41e8a8759a945c55c6610ece7a) A primeira tarefa de `expand()` é determinar se o comando a ser expandido é uma macro ou um primitivo, porque as macros têm um processo de expansão especializado, tratado por uma função chamada `macrocall()`. Se o comando a ser expandido for um primitivo, a `expand()` função usa o valor atual do código de comando (armazenado na variável global `curcmd`) para identificar qual primitivo em particular precisa de ser processado. Podemos ver estes pormenores numa listagem mais completa de `expand()`: ``` void expand(void) { //curcmd é uma variável global if(curcmd != macro) // curcmd < 111 { switch(curcmd) { case \expandafter: // Processar o comando \expandafter T1T2 { gettoken(); // Ler token T1 t = curtok; // Guardar o token T1 na variável local t gettoken(); // Ler token T2 if(curcmd > 100) // O token T2 é expansível? expand(); // Sim! T2 é expansível: // realizar a expansão de T2 por // fazendo uma chamada recursiva à função expand() else backinput(); // T2 não é expansível: coloque esse token // de volta na entrada para ser lido novamente (mais tarde) curtok = t ; // Restaurar a variável global curtok para o valor salvo de T1 backinput() ; // Colocar o token T1 de volta na entrada // antes dos tokens resultantes da expansão de T2 } break; // Código para processar outros comandos expansíveis case “comando “converter para texto””: // Qualquer um de \number, \string, \romannumeral, // \meaning, \fontname, \jobname // Eles compartilham o mesmo valor de curcmd break; case \noexpand: // Suprimir a expansão do próximo token ... break; case \csname: // Criar um nome de sequência de controle. ... break; case \the: // Inserir alguns tokens .... break; case “comando de teste “\if...””: // Processar um dos condicionais do TeX: // \if, \ifcat, \ifnum, \ifdim,\ifodd, \ifvmode, // \ifhmode, \ifmmode, \ifinner, \ifvoid, // \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, // \ifcase, \ifdefined, \ifcsname, \iffontchar ... break; case “\fi ou \else”: // Encerrar a condicional atual ... break; // etc. para quaisquer outros comandos primitivos expansíveis suportados por // o motor TeX } }else // Não é um primitivo expansível: é uma macro { macrocall() } //... mais código removido } ``` ### O apreço do TeX por variáveis globais Talvez refletindo sua idade e a era em que foi projetado, o código-fonte do TeX faz amplo uso das chamadas [variáveis globais](https://en.wikipedia.org/wiki/Global_variable)—na verdade, há centenas delas. Por sua própria natureza, variáveis globais podem ser alteradas/modificadas de qualquer lugar dentro do código-fonte do TeX — que, no TeX de Knuth, é um único arquivo monolítico contendo mais de 25.000 linhas de código e centenas de funções. Entender como o TeX funciona nem sempre é uma tarefa fácil... Para processar `\expandafter`, o TeX lê tokens da sua entrada atual usando uma função chamada `gettoken()` cuja ação é criar um token e definir o valor de várias variáveis globais importantes usadas em todo o código-fonte do TeX. Duas dessas variáveis, atualizadas pela ação de `gettoken()`, são usadas na implementação de `\expandafter`: * `curtok`: (token atual) o valor inteiro do token recém-lido; * `curcmd`: (código de comando atual) o código de comando do comando (ou caractere) representado pelo token `curtok`. Ao processar `\expandafter`$$\mathrm{T\_1T\_2}$$ o TeX lê token $$\mathrm{T\_1}$$ e salva temporariamente seu valor (um inteiro) em uma variável local chamada `t`. O TeX então lê $$\mathrm{T\_2}$$ e verifica se esse token representa um comando expansível — verificando se seu código de comando (`curcmd`) é > 100. Se for, o TeX precisa expandir o comando representado por $$\mathrm{T\_2}$$ e faz outra chamada à função `expand()`: este é um exemplo de *recursão* porque o `expand()` a função chamando a si mesma. Ter consciência da natureza recursiva da expansão, especialmente ao usar `\expandafter`, pode ajudar a entender como vários comandos consecutivos `\expandafter` comandos — isto é, `\expandafter\expandafter\expandafter...` produzem seus efeitos. Se o token $$\mathrm{T\_2}$$ é expansível, a expansão ocorre e, quando a chamada recursiva a `expand()` retorna, o código dentro da implementação de `\expandafter` reinsere o token $$\mathrm{T\_1}$$ de volta na entrada. A variável global `curtok` é reatribuída ao valor do token salvo — armazenado na variável local `t`, que é o valor do token $$\mathrm{T\_1}$$— e é feita uma chamada à função `backinput().` #### A função backinput() Como o nome sugere, essa função coloca um token “de volta na entrada”. Para fazer isso, o TeX usa o valor atual da variável global `curtok` para criar uma lista de tokens que contém um único token (cujo valor inteiro é fornecido por `curtok`). O TeX também organiza o tratamento da entrada para garantir que essa lista de um único token seja, no momento apropriado, relida pelo TeX como parte do processamento subsequente da entrada. Observe com atenção que o token $$\mathrm{T\_1}$$ é reinserido *depois que a expansão é concluída*, o que garante que o TeX lerá esse token reinserido *antes de* quando ler os tokens resultantes da expansão de $$\mathrm{T\_2}$$. ### Processando macros: a função macrocall() Como discutido anteriormente, todas as macros, juntamente com alguns comandos primitivos, são expansíveis e todo o processamento de expansão passa pela `expand()` função. No entanto, `expand()` cuida de usar o `curcmd` valor (comando atual) para distinguir entre primitivos expansíveis e macros, porque o processo de expansão de macros é tratado por uma função dedicada chamada `macrocall()`. As macros precisam de um processo de expansão especializado porque os argumentos da macro e os tokens delimitadores precisam ser buscados de maneira muito particular e rigorosa; consequentemente, esse processo é delegado a uma função projetada para fazer isso: `macrocall()`. #### Expansão de macro vs. execução de macro Macro *expansão* não é o mesmo processo que a *execução*: a expansão de uma macro é o processo pré-execução que o TeX realiza para deixar a macro *pronta para execução*. A “execução” de uma macro acontece quando o TeX está lendo e processando ativamente os tokens contidos na definição dessa macro (texto de substituição) e em seus argumentos (parâmetros). #### Expansão de macro Para expandir uma macro, o TeX primeiro verifica se a macro recebe argumentos; se receber, `macrocall()` vasculha com muito cuidado a entrada em busca de tokens destinados a se tornarem os argumentos da macro. Esse processo inclui verificar a entrada do usuário quanto a quaisquer tokens delimitadores usados na definição original da macro — o padrão de tokens usado em uma chamada de macro deve corresponder exatamente ao padrão de tokens contido na definição armazenada. No entanto, os tokens usados como delimitadores são simplesmente descartados pelo TeX: na prática, eles são apenas uma forma de “pontuação” que o TeX usa para determinar os tokens reais destinados a se tornarem os argumentos da macro — isto é, tokens que o usuário pretende que sejam processados pela macro. Para obter mais informações sobre tokens delimitadores, consulte [Como as macros do TeX realmente funcionam](/latex/overleaf-learn-latex-pt/mais-topicos/22-how-tex-macros-actually-work-part-4.md). Para cada parâmetro (`#1, #2...#9`) presente na definição original da macro, o TeX examina a chamada real da macro para identificar quais tokens fornecidos pelo usuário estão destinados a cada parâmetro (isto é, formam os argumentos da macro). Esse processo produz uma ou mais mini listas de tokens: uma para cada argumento da macro. Depois que quaisquer argumentos da macro tiverem sido detectados e suas listas de tokens tiverem sido preparadas, o TeX recupera a definição da macro (texto de substituição) armazenada em sua memória e organiza o processamento de sua entrada de modo que, sempre que o TeX estiver pronto para ler/processar mais tokens, ele os lerá do texto de substituição da macro, executando assim a macro. No ponto apropriado, durante a execução da macro, listas de tokens que representam os argumentos da macro serão inseridas no local correto dentro do texto de substituição da macro. Mais uma vez, expandir um comando de macro significa *remover* esse comando de macro (token) da entrada e *substituí-lo* pela lista de tokens armazenada como texto de substituição da macro. Para uma análise aprofundada do processamento de macros do TeX, veja a série de artigos em seis partes [Como as macros do TeX realmente funcionam?](/latex/overleaf-learn-latex-pt/mais-topicos/01-a-six-part-series-how-do-tex-macros-actually-work.md) [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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.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.