> 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/53-what-is-a-tex-token.md). # O que é um "token TeX"? ## Motivação para uma série sobre tokens do TeX e conceitos relacionados A motivação, e a metodologia usada, para produzir uma série de artigos sobre tokens do TeX e conceitos relacionados é discutida neste artigo [Uma nova série de artigos: Tokens TeX e conceitos relacionados — Mas porquê (e como)?](https://www.overleaf.com/blog/521-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how) Como referido nesse artigo, ao longo desta série baseamos as nossas discussões e explicações nas perceções obtidas através de uma compilação personalizada do programa TeX original de Knuth — usando-o para produzir uma série de artigos que visa fornecer descrições simples e explicações fáceis de seguir dos principais conceitos do TeX. ## Introdução: qual é o nosso objetivo? Neste artigo descobrimos exatamente o que é um token do TeX, seguindo o percurso de processamento desde os caracteres no ficheiro de entrada até à criação efetiva de tokens do TeX. Na prática, é bastante complexo, por isso reduzimos o processo ao essencial, procurando torná-lo fácil de acompanhar e de compreender, preservando ao mesmo tempo a precisão técnica. Começamos por introduzir alguns conceitos internos importantes do TeX: *primitivos*, *códigos de comando* e *modificadores de comando*. A partir daí, usamos um exemplo de macro muito simples para ver exatamente como o TeX processa o comando `\def` e o token resultante que o TeX cria para representar esse comando. Concluímos com uma breve análise de como o TeX cria tokens para representar caracteres e de como o `\catcode` de um carácter torna-se, de facto, permanentemente associado a um token de carácter — algo frequentemente mencionado em livros sobre TeX, mas aqui vemos exatamente como isso é conseguido. O gráfico seguinte mostra o percurso que resumiremos — do texto de entrada aos tokens do TeX: ![O percurso da entrada do TeX até ao token do TeX.](/files/ac29b921d0945408a3f595d34ca4f49f663cccac) ## Mas primeiro: primitivas e códigos de comando Todos os motores TeX (TeX de Knuth, pdfTeX, XeTeX, LuaTeX) entendem uma série de comandos incorporados: as chamadas *primitivos*—os comandos fundamentais de construção que sustentam a programabilidade do TeX. São chamados “primitivos” porque, ao contrário das macros definidas pelo utilizador, não são construídos a partir de outros comandos e não podem ser reduzidos ainda mais a instruções mais simples. No TeX de Knuth existem aproximadamente 320 primitivas — embora devamos notar que outros motores TeX, como pdfTeX, XeTeX e LuaTeX, acrescentaram novos comandos ao programa original de Knuth e contêm primitivas que não estão presentes no software TeX de Knuth. Internamente, o TeX atribui um *código de comando* numérico a todos os comandos — sejam macros definidas pelo utilizador ou primitivas incorporadas. Estes códigos de comando não estão acessíveis ao utilizador do TeX; são simplesmente parte da mecânica interna do processamento do TeX, mas é útil conhecê-los para uma discussão posterior sobre tokens do TeX. Os grupos de comandos que têm funcionalidade relacionada partilham o mesmo código de comando. Por exemplo, as `\def`, `\gdef`, `\edef` e `\xdef` primitivas são todas usadas para definir macros e partilham o código de comando 97 (no TeX de Knuth). Claramente, esses 4 comandos de definição de macros criam macros cada um de uma forma ligeiramente diferente; consequentemente, durante o processamento, o TeX precisa de uma forma de os distinguir. Um código de comando por si só (como 97) não lhe pode dizer qual o comando de criação de macro em causa; por isso, como seria de esperar, a cada comando do TeX é atribuído um elemento adicional de informação chamado o seu *modificador de comando* (ver exemplos abaixo). ### Modificadores de comando: dois tipos Os modificadores de comando dividem-se em duas categorias às quais nos referiremos como “Tipo 1” e “Tipo 2” — o TeX não usa esta terminologia; aqui, isso é apenas conveniente: * **Tipo 1**: Valores inteiros simples que o TeX pode, se necessário, usar para distinguir entre comandos que partilham o mesmo código de comando. * **Tipo 2**: Um valor inteiro que é uma localização numérica na memória do TeX, dizendo ao TeX para onde precisa de ir para procurar informação sobre esse comando. Por exemplo, isto aplica-se a comandos definidos pelo utilizador (macros), em que o modificador de comando indica ao TeX onde a definição da macro está armazenada na memória. #### Modificadores de comando do Tipo 1 (um exemplo) Como referido, no TeX de Knuth os quatro comandos primitivos para definir macros: `\def`, `\gdef`, `\edef`, `\xdef` partilham todos o código de comando 97: são diferenciados através dos seus modificadores de comando, que estão listados na tabela seguinte: | Comando | Código de\ncomando | Modificador de\ncomando | | ------- | ------------------ | ----------------------- | | `\def` | 97 | 0 | | `\gdef` | 97 | 1 | | `\edef` | 97 | 2 | | `\xdef` | 97 | 3 | Como segundo exemplo, Knuth decidiu implementar os comandos `\openout`, `\write`, `\closeout`, `\special`, `\immediate` e `\setlanguage` como “extensões” ao TeX, apenas para mostrar como se podem acrescentar novas primitivas ao TeX. Neste caso, esses comandos não partilham realmente “funcionalidade semelhante”, exceto pelo facto de Knuth ter decidido agrupá-los para efeitos de explicar como estender o TeX. Esses 6 comandos são classificados como “extensões” e agrupados com o valor de código de comando 59, mas cada um tem um modificador de comando apropriado para o diferenciar dos outros: | Comando | Código de\ncomando | Modificador de\ncomando | | -------------- | ------------------ | ----------------------- | | `\openout` | 59 | 0 | | `\write` | 59 | 1 | | `\closeout` | 59 | 2 | | `\special` | 59 | 3 | | `\immediate` | 59 | 4 | | `\setlanguage` | 59 | 5 | #### Modificadores de comando do Tipo 2 (uma breve explicação) Embora todos os modificadores de comando sejam inteiros, os modificadores de Tipo 2 precisam de um pouco mais de explicação. No TeX, estes modificadores de comando são referidos como “ponteiros” porque apontam para uma localização na memória onde o TeX pode encontrar informação adicional para esse comando. Isto pode parecer um pouco vago, mas a forma como o TeX usa estes ponteiros para procurar informação é bastante variada e uma explicação mais completa desviaria a atenção do objetivo central deste artigo. Um exemplo pode ajudar: macros. Quando um comando de macro é definido, o TeX precisará de armazenar o texto de substituição algures na memória. Como veremos abaixo, as macros definidas pelo utilizador têm códigos de comando entre 111 e 114, com um modificador de comando que é um ponteiro para a memória, dizendo ao TeX onde o seu texto de substituição (a definição da macro) está armazenado. ### Códigos de comando: expansíveis e não expansíveis No código-fonte de Knuth para o TeX, os códigos de comando variam de 0 a 120 — note que alguns códigos dentro desse intervalo são exclusivamente para uso interno especializado e não são atribuídos a comandos acessíveis ao utilizador. Vale a pena notar que outros motores TeX, como pdfTeX, XeTeX e LuaTeX, acrescentaram novos comandos ao conjunto original de Knuth e contêm mais primitivas, e códigos de comando correspondentes; no entanto, os princípios aqui descritos são fundamentais para todos os motores baseados em TeX derivados do código-fonte de Knuth. O conjunto de códigos de comando divide-se em dois conjuntos principais: * *comandos não expansíveis*: têm códigos de comando menores ou iguais a 100; * *comandos expansíveis*: têm códigos de comando maiores que 100, até um valor máximo de 120. O intervalo 101 a 120 inclui macros definidas pelo utilizador, além de comandos como `\csname`, `\expandafter` e `\the`. Os comandos não expansíveis normalmente realizam a atribuição de um valor a um parâmetro interno ou produzem diretamente material que pode ser composto. Os comandos expansíveis normalmente “injetam” um fluxo de tokens na atividade de processamento atual do TeX ou modificam a ordem de processamento de tokens. Como referido acima, todas as macros (comandos definidos pelo utilizador) recebem códigos de comando entre 111 e 114: os diferentes valores refletem se a macro foi definida como `\long`, `\outer`, ambas ou nenhuma. Aqui está um exemplo: | Tipo de macro | Exemplo | Comentário | | -------------------- | ------------------------------ | ------------------------------- | | Não longa, não outer | `\def\ohyeah{....}` | `\ohyeah` código de comando=111 | | Longa, não outer | `\long\def\ohyeah{....}` | `\ohyeah` código de comando=112 | | Não longa, outer | `\outer\def\ohyeah{....}` | `\ohyeah` código de comando=113 | | Longa, outer | `\long\outer\def\ohyeah{....}` | `\ohyeah` código de comando=114 | Como lembrete sobre modificadores de comando, quando uma macro é definida, o TeX armazenará a definição da macro numa localização qualquer na memória: essa localização (um ponteiro) tornar-se-á o modificador de comando para o comando da macro, que será armazenado com um comando de 111 a 114, dependendo de como foi definida. O nome efetivo atribuído a uma macro definida pelo utilizador não importa realmente: após o processamento da entrada, todas serão atribuídas a um código de comando variando de 111–114 e, em última análise, todos os comandos que o TeX lê da sua entrada, sejam primitivas ou macros definidas pelo utilizador, acabam por ser convertidos numa representação numérica chamada um *token*. ## A viagem do texto de entrada aos tokens do TeX Nesta secção usaremos um exemplo de macro muito simples para ver exatamente como o TeX processa o comando `\def` para criar um token que representa o `\def` comando. A atividade detalhada de processamento do TeX pode ser extremamente complexa, por isso não estamos a usar parâmetros de macro ou delimitadores, porque isso acrescentaria complexidade e desviaria a atenção da nossa viagem. Suponha que o seu ficheiro de entrada do TeX contém a seguinte linha: ```latex \def\ohyeah{Overleaf is cool!} ``` À medida que o TeX começa a processar esta linha de entrada, verifica o `\catcode` de cada carácter e vê que o primeiro carácter é `\` (primeiro carácter de `\def`). Deteta (procura numa tabela interna) que `\` tem `\catcode` 0, o que significa que introduz o início de uma *sequência de controlo*. Claro que pode redefinir qualquer carácter para ter `\catcode` 0, mas vamos assumir que estão a ser usadas as definições convencionais do TeX puro ou LaTeX. Estritamente falando, o termo *sequência de controlo* tem duas subcategorias: *palavra de controlo* e *símbolo de controlo*: * *palavra de controlo*: uma sequência de caracteres com `\catcode` carácter (11); * *símbolo de controlo*: um único carácter cujo `\catcode` é *contém* carácter (11). Neste ponto, o `\` carácter escape já cumpriu a sua função e agora está terminado. Ao detetar um carácter de escape, a resposta do TeX é começar a ler todos os caracteres subsequentes da entrada com vista a detetar uma palavra de controlo ou um símbolo de controlo. Após o inicial `\`, o TeX deteta imediatamente o `d`: um carácter cujo `\catcode` é 11, o que diz ao TeX que encontrou a primeira letra de uma *palavra de controlo*. Continua a analisar os caracteres subsequentes até detetar finalmente um carácter que *não* têm `\catcode` letra (11). Todos os caracteres subsequentes (depois do inicial `\`) com `\catcode` 11 (letra) são considerados como formando o nome de uma palavra de controlo: isto é, o nome de um comando — talvez uma macro ou uma primitiva, mas o TeX ainda não sabe que tipo de comando é. Neste ponto, é simplesmente uma cadeia de caracteres. Assim, no nosso exemplo o TeX analisa felizmente a sequência, verificando cada carácter, até chegar ao inicial `\` de `\ohyeah` que também tem `\catcode` 0. O TeX reconhece que analisou demasiado e devolve educadamente esse `\` de volta ao fluxo de texto, para que se torne o próximo carácter a ser visto numa análise posterior do texto. Neste ponto, o TeX identificou uma cadeia (`def`) que sabe formar o texto de uma palavra de controlo composta por três caracteres, cada um com `\catcode` 11 (`d`, `e` e `f`). O que o TeX agora precisa de fazer é descobrir o que `def` significa: o que é que faz? Como talvez já tenha adivinhado, o TeX precisa de encontrar o código de comando e o identificador de comando para `def` para que possa perceber o que fazer com este comando. ## Gerando um hash Depois de detetar uma palavra de controlo (`def`), a primeira coisa que o TeX faz é “converter” a cadeia de caracteres (`def` no nosso exemplo) num número inteiro usando algo chamado função de hashing. Não precisamos de nos preocupar demasiado com os detalhes; um esboço chega. Em essência, o TeX olha para cada carácter da palavra de controlo que acabou de detetar e usa o valor do código ASCII (ou o valor Unicode no caso de XeTeX/LuaTeX) de cada carácter para calcular um número chamado valor de hash: é apenas um inteiro simples. Como parte deste processo de cálculo do hash, o TeX também verificará se a cadeia de caracteres na palavra de controlo recém-detetada já lhe é conhecida. O texto legível por humanos de todos os comandos, sejam primitivas ou macros definidas pelo utilizador, é armazenado numa área interna de armazenamento chamada o *pool de strings*. O TeX tem de fazer isto porque poderá precisar de produzir o nome legível por humanos de um comando — por exemplo, quando o TeX precisa de reportar um erro e fornecer o nome do comando que o causou. Por exemplo, a nossa macro `\def\ohyeah{Overleaf is cool!}` está a definir um novo comando chamado `\ohyeah` e o TeX irá (numa fase posterior) não só precisar de calcular um valor de hash para `ohyeah` (*sem* o inicial `\` carácter), mas também armazenar a forma em texto (legível por humanos) caso precise de a usar para reporte de erros (ou outras tarefas). Se quiser mais detalhes sobre os processos de tratamento de strings do TeX, escrevi sobre isso no meu [blogue pessoal](http://www.readytext.co.uk/?p=3590). O resultado final é que a cadeia de caracteres que representa o comando `def` é transformada no valor numérico 1218 (esse é o valor efetivamente calculado pelo TeX). Neste ponto, os caracteres individuais `d`, `e` e `f` já não fazem parte da história principal — foram lidos da entrada e cumpriram a sua função: a partir de agora, trata-se tudo de inteiros e *tokens*—veremos em breve o que é realmente um token! Internamente, o TeX refere-se a estes números de valor hash como o *sequência de controlo atual* mas, no código-fonte, esse termo é abreviado para uma variável chamada `curcs`. O código-fonte do TeX está cheio de nomes de variáveis muito curtos, muitas vezes bastante enigmáticos. Mas o que é que o TeX *realmente faz* com este valor inteiro recém-criado de 1218? Como é que o TeX descobre que a cadeia original `def`, agora representada pelo inteiro 1218, se refere na verdade a uma instrução para definir uma macro? A resposta é que o TeX tem uma espécie de “arquivo” interno onde armazena o significado e o valor atuais de cada comando que conhece atualmente — seja esse comando uma macro definida pelo utilizador ou uma primitiva incorporada. O motivo pelo qual o TeX se deu ao trabalho de converter `def` no valor de hash 1218 (agora armazenado na variável chamada `curcs`) é usá-lo para procurar *significado* de `def`. O TeX, naturalmente, repete este exercício de cálculo de hash para todas as palavras de controlo que deteta na entrada — embora, claro, palavras de controlo diferentes produzam valores inteiros diferentes a partir da função de hashing: essa é toda a ideia. O “arquivo” interno do TeX chama-se *tabela de equivalentes* e é o tema da secção seguinte. ### Consultando a tabela de equivalentes Só para recapitular, vejamos o que aprendemos até agora: * `\` introduz o início de uma sequência de controlo (uma *símbolo de controlo* ou uma *palavra de controlo*). * Se o primeiro carácter após o `\` tem `\catcode` for um carácter *palavra de controlo*. * Para *palavras de controlo* O TeX analisa para verificar todos os caracteres de entrada subsequentes que têm `\catcode` 11 e pára de analisar assim que encontra o primeiro carácter que não *contém* tenha um `\catcode` de 11. * A cadeia de caracteres de entrada (a seguir ao `\`) que têm `\catcode` 11 é considerada uma *palavra de controlo* que o utilizador digitou: um comando que pede ao TeX para “fazer alguma coisa”. * Para começar o processo de “fazer alguma coisa”, o TeX converte a cadeia de caracteres da palavra de controlo num inteiro. Faz isso usando uma chamada função de hashing, que produz um inteiro. * O inteiro (valor de hash calculado) é referido como o *sequência de controlo atual*, mas o TeX dá-lhe o nome mais curto de `curcs`. * No nosso exemplo, a palavra de controlo `def` é convertida no valor 1218 — que é armazenado numa variável chamada `curcs`: isto é, `curcs=1218`. O TeX agora precisa de descobrir o que a *sequência de controlo atual* recém-detetada realmente significa — o que é que o TeX faz com ela? #### Uma nota sobre agrupamento: a necessidade de guardar e restaurar informação Aqui, faremos um pequeno desvio para nos lembrarmos de que o TeX tem a capacidade de guardar e restaurar informação: isto é, tem alguma forma de “memória” incorporada. Qualquer pessoa que tenha escrito sequer a macro mais simples deve estar ciente do mecanismo de agrupamento do TeX — por exemplo, usando `\def` para criar macros dentro de um grupo. A menos que aplique o prefixo `\global` a macros criadas com `\def`e definidas dentro de um grupo, o valor ou significado dessa macro só persiste dentro desse grupo (e dos que estão abaixo dele): a sua definição perde-se quando o grupo termina. Por exemplo, se definir uma macro simples dentro de um grupo, assim: ```latex {\def\foo{Hello}} ``` e tentar usar `\foo` fora do grupo ```latex {\def\foo{Hello}}% \foo definido dentro de um grupo (nota: sem uso de \global) \foo %<--- já não definido, agora indefinido ``` então obtemos o querido erro: `Sequência de controlo indefinida`. `\foo` só tem significado dentro do grupo (e dos seus subgrupos) em que foi definida. Além disso, quando redefine uma macro dentro de um grupo, o novo valor pode perder-se quando o grupo termina e o significado anterior (que existia fora do grupo) é restaurado. ```latex \def\foo{Goodbye} \foo\par% Produz Goodbye {\def\foo{Hello}% Redefinida dentro de um grupo: {Dentro do grupo de 2.º nível: \foo\par}}% Usado dentro do grupo de 2.º nível: \foo produz Hello Fora do grupo, o valor antigo é restaurado: \foo\par% Produz Goodbye ``` O objetivo destes exemplos simples é apontar para o facto de o TeX ter algum tipo de “mecanismo de armazenamento” ou “memória” que guarda/restaura o “significado” dos comandos — e, claro, tem. Já sugerimos isso na secção anterior: esse “mecanismo de armazenamento” ou “arquivo” é uma grande tabela interna chamada *tabela de equivalentes*. É ali que o TeX armazena o significado ou os valores atuais de todos os comandos de que atualmente tem conhecimento — as primitivas incorporadas e as macros definidas pelo utilizador. ### A tabela de equivalentes: por analogia Para explicar a tabela de equivalentes, procederemos por analogia. Continuaremos a usar a noção de um arquivo com milhares de pequenas gavetas, cada uma etiquetada com um inteiro único. Nesta fase do processamento o TeX diz, na prática: “OK, tenho este valor inteiro 1218 que acabei de calcular e guardar numa variável chamada `curcs`. Agora preciso de descobrir o que significa: para isso, vou olhar na gaveta número 1218 do meu arquivo para ver o que lá está.” O TeX usa 1218 para localizar a gaveta correta e lá encontra uma pequena nota que contém três peças de informação cujos nomes são os usados no código-fonte do TeX: * **`eq_level:`** o nível de agrupamento em que esta entrada foi definida (nível 1 = definido globalmente). Vimos acima os efeitos do agrupamento em ação: é aqui, na tabela de equivalentes, que essa informação de nível de agrupamento é armazenada; * **`eq_type:`** o código de comando para esta entrada; * **`equiv:`** “valor” atual desta entrada — pode ser um inteiro simples, como o modificador de comando mencionado acima, ou um ponteiro para uma área na memória; por exemplo, a localização na memória para o conjunto de tokens que representam uma definição de macro. Assim, o nosso valor de hash 1218 (guardado na variável `curcs`) foi, na prática, usado como a *chave* para aceder a uma gaveta que contém o significado e o valor atuais do comando que originalmente introduzimos como a cadeia de letras `\def`. No código-fonte do programa TeX, o `eq_type` de qualquer comando é armazenado usando uma variável chamada `curcmd` e o valor de `equiv` é armazenado numa variável chamada `curchr`. ### O que é que a tabela de equivalentes diz para def? Como referido, o valor de hash calculado para qualquer comando é guardado numa variável chamada `curcs`; portanto, para `def` temos `curcs=1218`. Ao olhar para a localização 1218 na tabela de equivalentes, o TeX encontrará a seguinte informação: * `curcmd`=97. Este é o código de comando para `\def`; * `curchr`=0. Este é o modificador de comando para `\def`. `\def` é um comando primitivo (incorporado) do TeX e, a menos que tenha sido redefinido algures, a terceira e última peça de informação deve ser `eq_level=1` indicando que o significado de `\def` está definido globalmente e não está restrito a algum nível inferior de agrupamento. Internamente, o valor de `eq_level` associado a um comando desempenha um papel extremamente importante no mecanismo de agrupamento do TeX, mas não consideraremos isso mais adiante. O gráfico seguinte resume a explicação que percorremos: ![O percurso da entrada do TeX até ao token do TeX.](/files/ac29b921d0945408a3f595d34ca4f49f663cccac) ## Tokens do TeX para comandos Depois de termos passado pelas explicações acima, o cálculo efetivo dos tokens do TeX para sequências de controlo revela-se realmente muito simples. O TeX usa o valor de `curcs` (1218) da função de hash para criar um inteiro simples a que chama um *token*. O cálculo para gerar um token a partir do valor de `curcs` é: ```c curtok = 4095 + curcs ``` O TeX armazena o valor do token atual (o mais recentemente calculado) numa variável chamada `curtok`. Assim, em conclusão, o token do TeX que representa a `\def` comando é `4095 + 1218 = 5313`. E isso é tudo para tokens do TeX que representam sequências de comandos: são simplesmente um número inteiro calculado a partir de um valor de tabela de hash mais 4095. ## Tokens do TeX para caracteres Quando o TeX precisa de criar um token que represente um carácter, usa o seguinte cálculo igualmente simples: ```c curtok = 256*catcode + (valor ASCII do carácter) ``` Note que são usados cálculos ligeiramente diferentes para motores compatíveis com Unicode, como o LuaTeX. Por exemplo, o token do TeX que representa um carácter de espaço com `\catcode` 10 e valor ASCII 32 é: ```c 256*10 + 32 = 2592 ``` ### Listas de tokens contendo caracteres Quando cria uma lista simples de tokens com, por exemplo, ```latex \toks100={Hello} ``` o TeX criará a seguinte lista de tokens e armazená-la-á na memória para uso posterior: * H→ 256 × 11 + 72 = 2888 * e→ 256 × 11 + 101 = 2917 * l→ 256 × 11 +108 = 2924 * l→ 256 × 11 +108 = 2924 * o→256 × 11 + 111 = 2927 No fundo da memória do TeX, o registo de tokens 100 fornecerá acesso à localização de armazenamento de “Hello”, guardado como 5 valores de token: 2888, 2917, 2924, 2924, 2927. Note que estes tokens combinam o código ASCII de cada carácter e o valor do seu `\catcode`no ponto em que são transformados em tokens (tokenizados). Uma vez convertidos em tokens de carácter, o `\catcode` valor associado a eles é permanente e é armazenado dentro dos tokens para uso posterior quando o utilizador diz, por exemplo, `\the\toks100`. Como referido, um token de carácter é calculado a partir de `256*catcode + (valor ASCII)` enquanto um token de sequência de controlo é calculado a partir de `4095 + curcs` onde `curcs` é o valor de hash da palavra de controlo (cadeia de texto de um comando introduzido pelo utilizador) detetada na entrada pelo TeX. Vale a pena notar que os tokens de carácter são sempre inferiores a 4095. Assim, o TeX pode determinar facilmente se um determinado token representa uma sequência de controlo (um comando) ou um carácter e, em seguida, descobrir qual sequência de controlo ou carácter e `\catcode` par está codificado nesse token. --- # 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/53-what-is-a-tex-token.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.