> 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/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md). # Como funciona \expandafter: uma introdução aos tokens 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) ## Contexto de \expandafter: tokens do TeX e listas de tokens Como primeiro passo para compreender como `\expandafter` funciona realmente, vamos analisar dois componentes do TeX que são fundamentais para o funcionamento de `\expandafter`: tokens do TeX (números inteiros) e listas de tokens (listas de inteiros). Os leitores que quiserem explorar esses tópicos com muito mais detalhe podem interessar-se por ler os seguintes artigos publicados pela Overleaf: * [O que é um token do TeX?](/latex/overleaf-learn-latex-pt/artigos-aprofundados/53-what-is-a-tex-token.md) * [O que é uma lista de tokens do TeX?](/latex/overleaf-learn-latex-pt/artigos-aprofundados/54-what-is-a-tex-token-list.md)-[Como é que as macros do TeX funcionam realmente?](/latex/overleaf-learn-latex-pt/mais-topicos/01-a-six-part-series-how-do-tex-macros-actually-work.md) ### De onde vieram os dados dos tokens? Ao longo deste artigo usamos valores reais de tokens calculados pelo TeX — dados que normalmente não estão acessíveis aos utilizadores. Para os leitores curiosos para saber como estes dados de valores de tokens foram obtidos, a Overleaf tem compilações personalizadas de vários motores TeX que usamos para investigação. Esses motores são modificados para produzir informações sobre as atividades internas de processamento do TeX — ajudando a fornecer material de contexto adicional para alguns dos artigos que produzimos. Ao mostrar/discutir valores numéricos de tokens, o nosso objetivo é incluir detalhes que, esperamos, ajudem os leitores a compreender melhor «tokens do TeX», tornando este importante conceito um pouco menos opaco. ## Tokens do TeX 101 (e noções de expansão) Quando o TeX processa o seu ficheiro de entrada, lê o texto e converte caracteres individuais e sequências de caracteres (comandos) em chamados *tokens*. ## Como o TeX calcula os valores dos tokens Aqui analisamos os cálculos de tokens usados no TeX original de Knuth, e-TeX e pdfTeX; para outros motores TeX, particularmente XeTeX e LuaTeX, os seus cálculos de tokens precisam de ser ligeiramente diferentes para ter em conta o uso de Unicode, mas os métodos de cálculo são semelhantes aos descritos abaixo. ### Tokens de caracteres (caracteres não ativos) O cálculo dos valores dos tokens para caracteres não ativos é simples: $$\text{character token} = 256\times \text{(category code)} + \text{character (ASCII) code}$$ **Exemplo**: A letra A com [código de categoria](/latex/overleaf-learn-latex-pt/mais-topicos/43-table-of-tex-category-codes.md) 11, o código de carácter 65 é representado pelo TeX como o valor do token de carácter $$256\times 11 + 65 = 2881$$. Pode encontrar descrições na literatura sobre TeX que observam que, uma vez que o TeX tenha lido um carácter, o seu valor de código de categoria fica «permanentemente ligado» a esse carácter: o cálculo acima do valor do token mostra por que isso é verdade. No entanto, mais tarde no processamento do TeX, ele pode, e de facto consegue, «desembalar» tokens de carácter para revelar o par constituinte (código de carácter, código de categoria) a partir do qual o token foi construído — quando o TeX faz esse «desembalamento» não alterará ainda assim o código de categoria desse carácter, apenas usa essa informação no processamento subsequente. ### Tokens de comando O processamento de entrada e a geração de tokens do TeX reconhecem dois tipos de comando: * comandos construídos a partir de um ou mais caracteres que têm código de categoria 11; * comandos de um único carácter cujo código de categoria desse carácter não é 11: como `\$` ou `\#`. Em ambos os casos, o TeX exclui o carácter inicial `\` e usa o código de carácter de cada carácter remanescente para calcular um inteiro que o TeX chama `curcs` (**corr**ente **c**ontrolo **lo**sequência). O TeX depois usa o valor de `curcs` para calcular um valor de token para o comando. #### Comandos formados por caracteres com código de categoria 11 Suponhamos que o nosso comando (sem o carácter inicial `\` o carácter) é composto por uma sequência de caracteres: $$\mathrm{C\_1C\_2C\_3...C\_N}$$ onde $$\mathrm{C}\_i$$ é o código de carácter de cada carácter — por exemplo, o código de carácter de A é 65. O TeX usa todos os códigos de carácter $$\mathrm{C}\_i$$ para calcular o inteiro `curcs` (usando uma [função hash](https://en.wikipedia.org/wiki/Hash_function)). Assim que o TeX calculou o valor de `curcs` basta-lhe somar 4095 a esse valor, para obter o valor do token: $$\text{command token} = \text{curcs + 4095}$$ Note-se que a variável `curcs` desempenha um papel extremamente importante nas atividades internas de processamento do TeX. #### Comandos de um único carácter Tokens para representar comandos como `\$`, `\#` etc. são sujeitos a um cálculo ligeiramente diferente: o inteiro `curcs` é agora o cálculo mais simples: $$\text{curcs} = 257 + \text{character (ASCII) code}$$ Por exemplo, com `\$`, $$\text{curcs}=257 + 36 = 293$$. O TeX volta a somar 4095 a este valor (usando $$\text{command token} = \text{curcs} + 4095$$) resultando em `\$` ter um valor de token $$293 + 4095 = 4388$$. Comparado com comandos compostos por caracteres com código de categoria 11, a única diferença aqui é a forma como o TeX calcula o valor para `curcs`. **Nota**: o inteiro `curcs` não é calculado para tokens de carácter: é sempre definido como 0 quando o TeX está a criar, ou a trabalhar com, tokens de carácter. #### Tokens de caracteres ativos O TeX tem o conceito de chamados *caracteres ativos*: qualquer carácter a que seja atribuído o código de categoria 13. Os tokens desta classe especial de caracteres estão sujeitos a um cálculo diferente em comparação com caracteres normais. O mecanismo de caracteres ativos permite ao TeX criar aquilo que, na prática, são macros de um único carácter que pode usar *sem* sem ter de prefixar o carácter ativo com um carácter de escape (normalmente `\`): o carácter isolado desencadeia o seu comportamento de macro. O exemplo canónico é o carácter til (\~) que o TeX/LaTeX usam para espaços sem quebra, que pode ser definido/ativado da seguinte forma: ``` \catcode`~=13 % atribua o código de categoria 13 a ~ \def~{\penalty100000\ } % defina ~ para atuar como uma macro ``` Quando o TeX depois lê um `~` carácter, detetará que o seu código de categoria é 13 e processá-lo-á como uma «mini macro». Para calcular um token que represente um carácter ativo, o TeX aplica outra variação para calcular `curcs`: $$\begin{align\*} \text{curcs} &= \text{character code} + 1\ \text{active character token} &= \text{curcs} + 4095\ \end{align\*}$$ Por exemplo, o carácter \~ tem o código de carácter 126, o que significa que a representação do valor do seu token de carácter ativo é calculada da seguinte forma: $$\begin{align\*} \text{curcs} &= 126 + 1\ \text{active character token} &= 127 + 4095\ &=4222\ \end{align\*}$$ Note-se que, tal como os comandos, os tokens que representam caracteres ativos são > 4095. ### Consequências/notas * Qualquer token cujo valor exceda 4095 é imediatamente identificável como um token de comando — assim, o TeX pode detetar muito facilmente se um determinado token representa um carácter ou um comando. * Para qualquer valor de token, o TeX pode, quando necessário, «desembalar» esse token para revelar o carácter (e o seu código de categoria), ou o comando, originalmente presente no seu `.tex` ficheiro, armazenado numa definição de macro ou contido noutra lista de tokens. * A quantidade «intermédia» chamada `curcs`—que o TeX usa para calcular valores de tokens de comando—desempenha um papel importante no processamento de baixo nível do TeX. `curcs` funciona como um «valor de índice» que o TeX usa para armazenar/procurar o significado atual de um comando. Dado qualquer token de comando, $$\mathrm{T}$$, o TeX simplesmente subtrai 4095 para aceder ao valor de `curcs`: $$\text{curcs} = \mathrm{T}-4095$$ A propósito, o TeX guarda a cadeia de caracteres legível por humanos a partir da qual um token de comando é gerado — isto é essencial para a apresentação de erros e para outros comandos como `\string` cuja expansão é a versão legível por humanos de um valor de token. No entanto, essas cadeias de caracteres legíveis por humanos armazenadas no interior do TeX só são usadas/produzidas quando solicitado: para todo o outro processamento é usado o valor inteiro do token. ## A analisar alguns tokens reais Só para tornar a noção de tokens um pouco menos opaca, vamos definir a seguinte macro simples e observar os tokens que o TeX produz: ``` \def\hello{Saudações, de \TeX. \hskip 10pt} ``` Para a `\hello` macro, o TeX usa os caracteres `h`, `e`, `l`, `l`, `o` para calcular um valor de 3745 para `curcs`; $$3745 + 4095 = 7840$$ (para o TeX de Knuth, e-TeX ou pdfTeX). Depois de criar um token para representar `\hello`, a `\def` comando faz com que o TeX leia os tokens subsequentes e os use para criar uma lista de tokens que é armazenada como a *definição* do `\hello` comando. Essa definição armazenada (lista de tokens) pode então ser recuperada sempre que pedir ao TeX para usar a `\hello` comando. A tabela seguinte lista os valores reais dos tokens criados para cada item (carácter, macro ou primitiva) contido na `\hello` definição da macro — esta lista de tokens (inteiros) é o que o TeX guarda na sua memória (como estrutura de dados conhecida como uma [lista ligada](https://en.wikipedia.org/wiki/Linked_list)). Os leitores que desejem compreender listas de tokens com mais detalhe são remetidos para o artigo da Overleaf [O que é uma lista de tokens do TeX?](/latex/overleaf-learn-latex-pt/artigos-aprofundados/54-what-is-a-tex-token-list.md) | | | | ------------------------- | --------------------- | | **Valor do token do TeX** | **Item representado** | | 2887 | G | | 2930 | r | | 2917 | e | | 2917 | e | | 2932 | t | | 2921 | i | | 2926 | n | | 2919 | g | | 2931 | lo | | 3116 | , | | 2592 | | | 2918 | f | | 2930 | r | | 2927 | o | | 2925 | m | | 2592 | | | 5235 | \TeX | | 3118 | . | | 2592 | | | 7943 | \hskip | | 3121 | 1 | | 3120 | 0 | | 2928 | p | | 2932 | t | Na lista de tokens acima, os caracteres têm códigos de categoria 10, 11 ou 12. Por exemplo: * os caracteres têm código de categoria 10 e código de carácter 32, dando um valor de token de $$256\times 10 + 32 = 2592$$ * `,` e `.` têm código de categoria 12 e códigos de carácter 44 e 46, respetivamente, dando tokens: * token para `,` $$= 256 \times 12 + 44 = 3116$$ * token para `.` $$= 256\times 12+ 46 = 3118$$ Sempre que o TeX subsequentemente encontra o valor de token 7840 (que representa `\hello`) `curcs` através do cálculo simples $$\text{curcs} = \text{token value} - 4095$$ (ver acima). Usando o valor de `curcs` o TeX pode consultar as suas tabelas de dados internas para determinar que o token de comando 7840 representa um comando de macro. Além disso, novamente através de `curcs`, o TeX também pode procurar e recuperar a definição armazenada de `\hello`. Quando o TeX precisa de processar totalmente o token 7840, ou seja, de executar a `\hello` macro, já não precisa do token 7840: esse token já *fez o seu trabalho*—isto é, desencadeou o TeX a executar a macro `\hello`. O TeX pode agora descartar o token 7840 e obter os tokens que representam a definição (lista de tokens) armazenada na memória. Na prática, o `\hello` comando de macro (token 7840) foi *removido* da fonte de entrada atual do TeX e *substituído* por tokens contidos na definição de `\hello`. *expansão de tokens*. O `\TeX` comando (valor de token 5235 listado acima) usado dentro de `\hello` é ele próprio uma macro construída a partir de mais tokens — por isso a sua definição também é armazenada como uma lista de tokens: | | | | ------------------------- | --------------------- | | **Valor do token do TeX** | **Item representado** | | 2900 | T | | 19598 | \kern | | 3117 | - | | 3118 | . | | 3121 | 1 | | 3126 | 6 | | 3126 | 6 | | 3127 | 7 | | 2917 | e | | 2925 | m | | 19597 | \lower | | 3118 | . | | 3125 | 5 | | 2917 | e | | 2936 | x | | 6175 | \hbox | | 379 | { | | 2885 | E | | 637 | } | | 19598 | \kern | | 3117 | - | | 3118 | . | | 3121 | 1 | | 3122 | 2 | | 3125 | 5 | | 2917 | e | | 2925 | m | | 2904 | X | Se substituíssemos o `\hello` comando pela lista completa de tokens a partir da qual é construído, incluindo o `\TeX` macro, seria uma lista bastante longa — ou seja, se também *expandidos* o `\TeX` a macro veríamos: ![Uma lista de tokens armazenada numa macro do TeX](/files/1a8cab258a6b16b6cb3d5213e5897d705d670afb) Essencialmente, o valor único de token 7840 (para `\hello`) produziria, quando totalmente expandido, um total de 51 tokens (inteiros) representando caracteres e comandos primitivos. Na lista seguinte, o carácter ou comando representado por cada token está entre parênteses «(...)» — estes não são armazenados diretamente nas listas de tokens do TeX e são mostrados para ajudar o leitor: ``` 2887 (G), 2930 (r), 2917 (e), 2917 (e), 2932 (t), 2921 (i), 2926 (n), 2919 (g), 2931 (s), 3116 (,), 2592 (), 2918 (f), 2930 (r), 2927 (o), 2925 (m), 2592 (), 2900 (T), 19598 (\kern), 3117 (-), 3118 (.), 3121 (1), 3126 (6), 3126 (6), 3127 (7), 2917 (e), 2925 (m), 19597 (\lower), 3118 (.), 3125 (5), 2917 (e), 2936 (x), 6175 (\hbox), 379 ({), 2885 (E), 637 (}), 19598 (\kern), 3117 (-), 3118 (.), 3121 (1), 3122 (2), 3125 (5), 2917 (e), 2925 (m), 2904 (X), 3118 (.), 2592 (), 7943 (\hskip), 3121 (1), 3120 (0), 2928 (p), 2932 (t) ``` Para um leitor humano, isto é apenas uma série de inteiros, mas para o TeX codifica uma enorme quantidade de informação. ## Leia tokens agora e guarde-os para mais tarde À medida que o TeX lê a sua entrada, pode haver alturas em que precise (ou lhe seja instruído) de adiar o processamento completo de um determinado conjunto de tokens. Se lhe for indicado para o fazer, o TeX continuará, até lhe ser dito para parar, a criar tokens a partir da entrada mas a guardá-los para uso posterior — recuperando-os e processando-os depois como parte das suas atividades de composição tipográfica. Esses tokens armazenados são guardados como chamadas *listas de tokens* que, na prática, são o único mecanismo interno de armazenamento de dados de tokens do TeX. Já vimos exemplos de listas de tokens — as `\hello` e `\TeX` macros listadas acima: a definição dessas macros é armazenada na memória do TeX como listas de tokens. O TeX só processará (atuará sobre) essas listas de tokens quando decidir chamar essas macros. Lembre-se também de que cada token (valor inteiro) codifica informação suficiente para o TeX determinar facilmente se cada token armazenado numa definição de macro representa um carácter ou um comando. ### Guardar tokens com registos de tokens Outro exemplo de armazenamento de tokens é a criação explícita de listas de tokens que são guardadas em chamados *registos de tokens*: áreas de armazenamento internas dedicadas que o TeX disponibiliza para os utilizadores guardarem listas de tokens. A primitiva do TeX `\toksdef` é uma forma de usar registos de tokens; por exemplo, para usar o registo de tokens `100` e referenciá-lo usando o comando `\mylist`: ``` \toksdef\mylist=100 \mylist={alguns \TeX{} tokens aqui} ``` `\mylist` é, na prática, apenas um nome que atribui a uma lista de tokens armazenada na localização de registo `100`. `\mylist` contém a seguinte lista de tokens: | | | | ------------------------- | --------------------- | | **Valor do token do TeX** | **Item representado** | | 2931 | lo | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | 379 | { | | 637 | } | | 2592 | | | 2932 | t | | 2927 | o | | 2923 | k | | 2917 | e | | 2926 | n | | 2931 | lo | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | **Nota**: para terminar a `\TeX` macro e impedir que absorva o seguinte `` carácter, usamos um par de chavetas `{}` imediatamente após `\TeX`—os tokens para `{` (379) e `}` (637) são armazenados na lista de tokens. Outra opção é usar um token de «espaço de controlo» `\` que apareceria na lista de tokens como mostrado abaixo (a negrito): | | | | ------------------------- | --------------------- | | **Valor do token do TeX** | **Item representado** | | 2931 | lo | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | **4384** | **\\** | | 2932 | t | | 2927 | o | | 2923 | k | | 2917 | e | | 2926 | n | | 2931 | lo | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | Note que o `` carácter é representado como um *token de caractere* com valor $$256\times 10 + 32 = 2592$$ mas `\` é tratado como um token de comando de um único *carácter* (valor 4384), que é calculado usando as fórmulas dadas acima: \begin{align\*} \text{curcs} & = 257 + \text{character (ASCII) code}\\\ & = 257 + 32\\\ &=289\\\ \text{command token for} \left<\text{\\\space}\right> & = \text{curcs + 4095}\\\ & = 289+4095\\\ &=4384\\\ \end{align\*} Em essência `\mylist={alguns \TeX{} tokens aqui}` diz ao TeX: por favor, analisa o meu ficheiro de entrada para converter os seguintes caracteres/comandos em tokens e guardá-los para uso posterior. O TeX atenderá e armazenará esses tokens numa localização de memória à qual pode aceder escrevendo `\the\mylist`, instruindo o TeX a inserir uma cópia dos tokens contidos no registo de tokens `\mylist`. Os motores TeX incluem uma série de comandos primitivos que geram e armazenam explicitamente listas de tokens — como `\everyjob`, `\everypar`, `\mark`, e muitos outros. [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/19-how-does-expandafter-work-an-introduction-to-tex-tokens.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.