> 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/it/articoli-approfonditi/53-what-is-a-tex-token.md). # Che cos'è un "token TeX"? ## Motivazione per una serie sui token di TeX e concetti correlati In questo articolo si discutono la motivazione e la metodologia utilizzate per realizzare una serie di articoli sui token di TeX e concetti correlati [Una nuova serie di articoli: token di TeX e concetti correlati—ma perché (e come)?](https://www.overleaf.com/blog/521-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how) Come notato in quell’articolo, in tutta questa serie basiamo le nostre discussioni e spiegazioni sulle intuizioni ottenute tramite una build personalizzata del programma TeX originale di Knuth—usandola per produrre una serie di articoli che mira a fornire descrizioni semplici e spiegazioni facili da seguire dei concetti chiave di TeX. ## Introduzione: qual è il nostro obiettivo? In questo articolo scopriamo esattamente che cos’è un token di TeX seguendo il percorso di elaborazione dai caratteri nel file di input fino alla creazione effettiva dei token di TeX. In pratica, è piuttosto complesso, quindi abbiamo ridotto il processo ai suoi elementi essenziali, cercando di renderlo facile da seguire e comprendere pur mantenendo l’accuratezza tecnica. Iniziamo introducendo alcuni importanti concetti interni di TeX: *primitivi*, *codici comando* e *modificatori del comando*. Da lì, usiamo un esempio di macro molto semplice per vedere esattamente come TeX elabora il comando `\def` e il token risultante che TeX crea per rappresentare quel comando. Concludiamo con un breve sguardo a come TeX crea token per rappresentare i caratteri e a come il `\catcode` di un carattere si attacchi effettivamente in modo permanente a un token di carattere—qualcosa spesso menzionato nei libri su TeX, ma qui vediamo esattamente come ciò viene ottenuto. Il grafico seguente mostra il percorso che riassumeremo—dal testo di input ai token di TeX: ![Il percorso dall’input di TeX al token di TeX.](/files/a78a43257d0b6e5387b72bde51452f6cc918e3d2) ## Ma prima: primitivi e codici comando Ogni motore TeX (Knuthian TeX, pdfTeX, XeTeX, LuaTeX) comprende una serie di comandi incorporati: i cosiddetti *primitivi*—i comandi fondamentali costitutivi che sono alla base della programmabilità di TeX. Sono chiamati “primitivi” perché, a differenza delle macro definite dall’utente, non sono costruiti da altri comandi e non possono essere ulteriormente ridotti a istruzioni più semplici. Per il TeX di Knuth ci sono circa 320 primitivi—anche se dobbiamo notare che altri motori TeX come pdfTeX, XeTeX e LuaTeX hanno tutti aggiunto nuovi comandi al programma originale di Knuth e contengono primitivi che non sono presenti nel software TeX di Knuth. Internamente, TeX assegna un *codice di comando* numerico a tutti i comandi—che si tratti di macro definite dall’utente o di primitivi incorporati. Questi codici comando non sono accessibili all’utente di TeX, sono semplicemente parte dei meccanismi interni di elaborazione di TeX, ma è utile conoscerli per la successiva discussione dei token di TeX. Gruppi di comandi che hanno funzionalità correlate condividono lo stesso codice comando. Per esempio, i `\def`, `\gdef`, `\edef` e `\xdef` primitivi sono tutti usati per definire macro e condividono il codice comando 97 (nel TeX di Knuth). Chiaramente, quei 4 comandi di definizione di macro creano ciascuno macro in un modo leggermente diverso; di conseguenza, durante l’elaborazione, TeX ha bisogno di un modo per distinguerli. Un codice comando da solo (come 97) non può dirti quale comando di creazione di macro si stia considerando; quindi, come prevedibile, a ogni comando TeX viene assegnato un ulteriore pezzo di informazione chiamato *modificatore del comando* (vedi gli esempi sotto). ### Modificatori del comando: due tipi I modificatori del comando si dividono in due categorie che chiameremo “Tipo 1” e “Tipo 2”—TeX non usa questa terminologia, è solo comodo farlo qui: * **Tipo 1**: Semplici valori interi che TeX può, se necessario, usare per distinguere tra comandi che condividono lo stesso codice comando. * **Tipo 2**: Un valore intero che è una posizione numerica nella memoria di TeX che indica a TeX dove deve andare per cercare le informazioni di quel comando. Per esempio, questo si applica ai comandi definiti dall’utente (macro), dove il modificatore del comando indica a TeX dove la definizione della macro è memorizzata in memoria. #### Modificatori del comando di Tipo 1 (un esempio) Come notato, nel TeX di Knuth i quattro comandi primitivi per definire macro: `\def`, `\gdef`, `\edef`, `\xdef` condividono tutti il codice comando 97: si distinguono tramite i loro modificatori del comando, elencati nella tabella seguente: | Comando | Codice\ncomando | Modificatore\ndel comando | | ------- | --------------- | ------------------------- | | `\def` | 97 | 0 | | `\gdef` | 97 | 1 | | `\edef` | 97 | 2 | | `\xdef` | 97 | 3 | Come secondo esempio, Knuth decise di implementare i comandi `\openout`, `\\write`, `\closeout`, `\special`, `\immediate` e `\setlanguage` come “estensioni” di TeX, unicamente per mostrare come si possano aggiungere nuovi primitivi a TeX. In questo caso, quei comandi in realtà non condividono una “funzionalità simile”, se non il fatto che Knuth decise di raggrupparli insieme per spiegare come estendere TeX. Quei 6 comandi sono classificati come “estensioni” e raggruppati insieme con il valore di codice comando 59, ma ciascuno ha un opportuno modificatore del comando per distinguerlo dagli altri: | Comando | Codice\ncomando | Modificatore\ndel comando | | -------------- | --------------- | ------------------------- | | `\openout` | 59 | 0 | | `\\write` | 59 | 1 | | `\closeout` | 59 | 2 | | `\special` | 59 | 3 | | `\immediate` | 59 | 4 | | `\setlanguage` | 59 | 5 | #### Modificatori del comando di Tipo 2 (una breve spiegazione) Sebbene tutti i modificatori del comando siano interi, i modificatori di Tipo 2 richiedono una spiegazione un po’ più ampia. Questi modificatori del comando sono chiamati in TeX “puntatori” perché puntano a una posizione in memoria dove TeX può trovare informazioni aggiuntive per quel comando. Questo può sembrare un po’ vago, ma il modo in cui TeX usa questi puntatori per cercare informazioni è piuttosto vario e una spiegazione più completa distrarrebbe dall’obiettivo principale di questo articolo. Un esempio può aiutare: le macro. Quando viene definito un comando macro, TeX dovrà memorizzare da qualche parte in memoria il testo di sostituzione. Come vedremo sotto, le macro definite dall’utente hanno codici comando tra 111 e 114 con un modificatore del comando che è un puntatore in memoria che indica a TeX dove è memorizzato il testo di sostituzione (la definizione della macro). ### Codici comando: espandibili e non espandibili Nel codice sorgente di TeX di Knuth i codici comando variano da 0 a 120—nota che alcuni codici all’interno di quell’intervallo sono destinati esclusivamente a uso interno specialistico e non sono assegnati a comandi accessibili all’utente. Vale la pena notare che altri motori TeX come pdfTeX, XeTeX e LuaTeX hanno tutti aggiunto nuovi comandi all’insieme originale di Knuth e contengono più primitivi, e corrispondenti codici comando; tuttavia, i principi qui delineati sono fondamentali per tutti i motori basati su TeX derivati dal codice sorgente di Knuth. La raccolta di codici comando è suddivisa in due insiemi principali: * *comandi non espandibili*: hanno codici comando minori o uguali a 100; * *comandi espandibili*: hanno codici comando maggiori di 100, fino a un valore massimo di 120. L’intervallo da 101 a 120 include macro definite dall’utente oltre a comandi come `\csname`, `\\expandafter` e `\the`. I comandi non espandibili in genere eseguono l’assegnazione di un valore a un parametro interno oppure producono direttamente materiale che può essere composto. I comandi espandibili in genere “iniettano” un flusso di token nell’attività di elaborazione corrente di TeX oppure modificano l’ordine di elaborazione dei token. Come notato sopra, tutte le macro (comandi definiti dall’utente) hanno codici comando compresi tra 111 e 114: i diversi valori riflettono se la macro è stata definita come `\long`, `\outer`, entrambe o nessuna delle due. Ecco un esempio: | Tipo di macro | Esempio | Commento | | -------------------- | ------------------------------ | ---------------------------- | | Non-lunga, non-outer | `\def\ohyeah{....}` | `\ohyeah` codice comando=111 | | Lunga, non-outer | `\long\def\ohyeah{....}` | `\ohyeah` codice comando=112 | | Non-lunga, outer | `\outer\def\ohyeah{....}` | `\ohyeah` codice comando=113 | | Lunga outer | `\long\outer\def\ohyeah{....}` | `\ohyeah` codice comando=114 | Come promemoria sui modificatori del comando, quando una macro viene definita TeX memorizzerà la definizione della macro in una qualche posizione della memoria: quella posizione (un puntatore) diventerà il modificatore del comando per il comando macro, che sarà memorizzato con un comando da 111 a 114 a seconda di come è stato definito. Il nome effettivo assegnato a una macro definita dall’utente non importa davvero: dopo l’elaborazione dell’input, a tutte verrà assegnato un codice comando variabile da 111 a 114 e, in definitiva, tutti i comandi che TeX legge dal tuo input, siano essi primitivi o macro definite dall’utente, vengono infine convertiti in una rappresentazione numerica chiamata un *token*. ## Il percorso dal testo di input ai token di TeX In questa sezione useremo un esempio di macro molto semplice per vedere esattamente come TeX elabora il comando `\def` per creare un token che rappresenta il `\def` comando. L’attività di elaborazione dettagliata di TeX può essere estremamente complessa, quindi non stiamo usando parametri di macro o delimitatori perché ciò aggiungerebbe complessità e distrarrebbe dal nostro percorso. Supponi che il tuo file di input TeX contenga la seguente riga: ```latex \def\ohyeah{Overleaf is cool!} ``` Quando TeX inizia a elaborare questa riga di input controlla il `\catcode` di ogni carattere e vede che il primo carattere è `\` (primo carattere di `\def`). Rileva (lo cerca in una tabella interna) che `\` ha `\catcode` 0 il che significa che introduce l’inizio di una *sequenza di controllo*. Naturalmente, puoi ridefinire qualsiasi carattere affinché abbia `\catcode` 0, ma assumiamo che si stiano usando le definizioni convenzionali di plain TeX o LaTeX. A rigor di termini, il termine *sequenza di controllo* ha due sottocategorie: *parola di controllo* e *simbolo di controllo*: * *parola di controllo*: una sequenza di caratteri con `\catcode` lettera (11); * *simbolo di controllo*: un singolo carattere il cui `\catcode` è *non* lettera (11). A questo punto, il `\` carattere ha fatto il suo lavoro ed è ora terminato. Nel rilevare un carattere di escape, la risposta di TeX è iniziare a leggere tutti i caratteri successivi nell’input con l’obiettivo di rilevare una parola di controllo o un simbolo di controllo. Dopo l’iniziale `\`, TeX rileva immediatamente il `d`: un carattere il cui `\catcode` è 11, il che dice a TeX che ha trovato la prima lettera di una *parola di controllo*. Continua a scansionare i caratteri successivi finché non rileva finalmente un carattere che *non* hanno `\catcode` lettera (11). Tutti i caratteri successivi (dopo l’iniziale `\`) con `\catcode` 11 (lettera) sono considerati formare il nome di una parola di controllo: cioè, il nome di un comando—forse una macro o un primitivo, ma TeX, per ora, non ha idea di quale tipo di comando sia. A questo punto è semplicemente una stringa di caratteri. Quindi, nel nostro esempio, TeX scansiona volentieri, controllando ogni carattere, finché non raggiunge l’iniziale `\` di `\ohyeah` che ha anch’esso `\catcode` 0. TeX riconosce di aver scansionato troppo avanti e cortesemente rimette quel `\` nello stream di testo così che diventi il prossimo carattere da vedere durante un’ulteriore scansione del testo. A questo punto, TeX ha identificato una stringa (`def`) che sa costituire il testo di una parola di controllo composta da tre caratteri, ciascuno con `\catcode` 11 (`d`, `e` e `f`). Ciò che TeX ora deve fare è scoprire che cosa `def` significa: che cosa deve fare? Come avrai intuito, TeX deve trovare il codice comando e l’identificatore del comando per `def` così da poter capire che cosa fare con questo comando. ## Fare un hash Dopo aver rilevato una parola di controllo (`def`), la prima cosa che TeX fa è “convertire” la stringa di caratteri (`def` nel nostro esempio) in un numero intero usando qualcosa chiamato funzione di hash. Non è necessario preoccuparsi troppo dei dettagli, una panoramica basta. In sostanza, TeX osserva ogni carattere nella parola di controllo appena rilevata e usa il valore del codice ASCII (o il valore Unicode per XeTeX/LuaTeX) di ciascun carattere per calcolare un numero chiamato valore di hash: è semplicemente un intero. Come parte di questo processo di calcolo dell’hash, TeX controllerà anche se la stringa di caratteri nella parola di controllo appena rilevata è già nota. Il testo leggibile dall’uomo di tutti i comandi, siano essi primitivi o macro definite dall’utente, viene conservato in un’area di memoria interna chiamata *pool delle stringhe*. TeX deve fare questo perché potrebbe aver bisogno di produrre in output il nome leggibile dall’uomo di un comando—per esempio, quando TeX deve segnalare un errore e fornire il nome del comando incriminato. Per esempio, la nostra macro `\def\ohyeah{Overleaf is cool!}` sta definendo un nuovo comando chiamato `\ohyeah` e TeX dovrà (in una fase successiva) non solo calcolare un valore di hash per `ohyeah` (*senza* il carattere iniziale `\` ) ma anche memorizzare la stringa di testo (leggibile dall’uomo) nel caso in cui debba usarla per la segnalazione di errori (o altre attività). Se desideri maggiori dettagli sui processi di gestione delle stringhe in TeX, ne ho scritto nel mio [blog personale](http://www.readytext.co.uk/?p=3590). Il risultato finale è che la stringa di caratteri che rappresenta il comando `def` viene trasformata nel valore numerico 1218 (che è il valore effettivamente calcolato da TeX). A questo punto i singoli caratteri `d`, `e` e `f` non fanno più parte della storia principale—sono stati letti dall’input e hanno fatto il loro dovere: da ora in poi si tratta solo di interi e *token*—presto vedremo che cosa sia realmente un token! Internamente, TeX si riferisce a questi numeri di valore hash come alla *sequenza di controllo corrente* ma nel codice sorgente quel termine è abbreviato in una variabile chiamata `curcs`. Il codice sorgente di TeX è pieno di nomi di variabili molto brevi, spesso piuttosto criptici. Ma che cosa fa davvero TeX *in realtà* con questo valore intero appena coniato di 1218? Come fa TeX a scoprire che la stringa originale `def`, ora rappresentata dall’intero 1218, in realtà si riferisce a un’istruzione per definire una macro? La risposta è che TeX ha una sorta di “schedario” interno in cui memorizza il significato e il valore correnti di ogni comando di cui sa attualmente—che si tratti di una macro definita dall’utente o di un primitivo incorporato. Il motivo per cui TeX si è preso la briga di convertire `def` nel valore di hash 1218 (ora memorizzato nella variabile chiamata `curcs`) è usarlo per cercare il *forma* di `def`. TeX, naturalmente, ripeterà questo esercizio di calcolo dell’hash per tutte le parole di controllo che rileva nell’input—anche se, naturalmente, parole di controllo diverse producono valori interi diversi dalla funzione di hash: è proprio questo il punto. Lo “schedario” interno di TeX si chiama *tabella degli equivalenti* ed è il tema della sezione successiva. ### Consultare la tabella degli equivalenti Solo per ricapitolare, vediamo cosa abbiamo imparato finora: * `\` introduce l’inizio di una sequenza di controllo (sia una *simbolo di controllo* o una *parola di controllo*). * Se il primo carattere dopo il `\` ha `\catcode` 11 (lettera) allora è l’inizio di una *parola di controllo*. * Per *parole di controllo* TeX scansiona per controllare tutti i caratteri di input successivi che hanno `\catcode` 11 e si fermerà non appena trova il primo carattere che non *non* ha un `\catcode` di 11. * La stringa di caratteri di input (che segue il `\`) che hanno `\catcode` 11 sono considerati essere una *parola di controllo* che l’utente ha digitato: un comando che chiede a TeX di “fare qualcosa”. * Per iniziare il processo di “fare qualcosa”, TeX converte la stringa di caratteri nella parola di controllo in un intero. Lo fa usando una cosiddetta funzione di hash che produce in output un intero. * L’intero (valore di hash calcolato) è indicato come *sequenza di controllo corrente*, ma TeX gli dà il nome più breve di `curcs`. * Nel nostro esempio, la parola di controllo `def` viene convertita nel valore 1218—che viene memorizzato in una variabile chiamata `curcs`: cioè, `curcs=1218`. TeX ora deve scoprire che cosa significa realmente la nuova *sequenza di controllo corrente* rilevata: che cosa ne fa TeX? #### Una nota sul raggruppamento: la necessità di salvare e ripristinare le informazioni Qui faremo una piccola deviazione per ricordarci che TeX ha la capacità di salvare e ripristinare informazioni: cioè, dispone di una qualche forma di “memoria” incorporata. Chiunque abbia scritto anche la macro più semplice dovrebbe conoscere il meccanismo di raggruppamento di TeX—for example, using `\def` per creare macro all’interno di un gruppo. A meno che tu non applichi il `\global` prefisso a `\def`macro create con \def definite all’interno di un gruppo, il valore o significato di quella macro persiste solo all’interno di quel gruppo (e di quelli al di sotto di esso): la sua definizione va persa quando il gruppo termina. Per esempio, se definisci una macro semplice all’interno di un gruppo, così: ```latex {\def\foo{Hello}} ``` e provi a usare `\foo` \foo ```latex {\def\foo{Hello}}% \foo definita all’interno di un gruppo (nota: nessun uso di \global) \foo %<--- non più definita, ora non definita ``` allora otteniamo il caro errore: `Sequenza di controllo non definita`. `\foo` ha significato solo all’interno del gruppo (e dei suoi sottogruppi) in cui è stata definita. Inoltre, quando ridefinisci una macro all’interno di un gruppo il nuovo valore può andare perso quando il gruppo termina e il significato precedente (che esisteva all’esterno del gruppo) viene ripristinato. ```latex \def\foo{Goodbye} \foo\par% Produce Goodbye {\def\foo{Hello}% Ridefinita all’interno di un gruppo: {All’interno del gruppo di 2° livello: \foo\par}}% Usata all’interno del gruppo di 2° livello: \foo produce Hello Fuori dal gruppo il vecchio valore viene ripristinato: \foo\par% Produce Goodbye ``` Lo scopo di questi semplici esempi è indicare che TeX dispone di una sorta di “meccanismo di archiviazione” o “memoria” che salva/ripristina il “significato” dei comandi—e, naturalmente, lo fa davvero. L’abbiamo accennato nella sezione precedente: quel “meccanismo di archiviazione” o “schedario” è una grande tabella interna chiamata *tabella degli equivalenti*. È lì che TeX memorizza il significato o i valori correnti di tutti i comandi che conosce attualmente—i primitivi incorporati e le macro definite dall’utente. ### La tabella degli equivalenti: per analogia Per spiegare la tabella degli equivalenti procederemo per analogia. Continueremo a usare l’idea di uno schedario con migliaia di piccoli cassetti, ciascuno etichettato con un intero univoco. A questo punto dell’elaborazione TeX dice, in sostanza: “OK, ho questo valore intero 1218 che ho appena calcolato e salvato in una variabile chiamata `curcs`. Ora devo scoprire che cosa significa: per farlo andrò a guardare nel cassetto numero 1218 del mio schedario per vedere che cosa c’è scritto dentro.” TeX usa 1218 per individuare il cassetto corretto e lì trova un piccolo promemoria che contiene tre pezzi di informazione i cui nomi sono quelli usati nel codice sorgente di TeX: * **`eq_level:`** il livello di raggruppamento in cui questa voce è stata definita (livello 1 = definita globalmente). Abbiamo visto sopra gli effetti del raggruppamento in azione: qui, nella tabella degli equivalenti, è dove vengono memorizzate tali informazioni sul livello di raggruppamento; * **`eq_type:`** il codice comando per questa voce; * **`equiv:`** “valore” corrente di questa voce—può essere un semplice intero come il modificatore del comando menzionato sopra, oppure un puntatore a un’area di memoria; per esempio, la posizione di memoria per la raccolta di token che rappresentano una definizione di macro. Quindi, il nostro valore di hash 1218 (salvato nella variabile `curcs`) è stato, in effetti, usato come *chiave* per accedere a un cassetto che contiene il significato e il valore correnti del comando che avevamo originariamente digitato come la stringa di lettere `\def`. Nel codice sorgente del programma TeX, il `eq_type` per qualsiasi comando è memorizzato usando una variabile chiamata `curcmd` e il valore di `equiv` è memorizzato in una variabile chiamata `curchr`. ### Cosa dice la tabella degli equivalenti per def? Come notato, il valore di hash calcolato per qualsiasi comando è salvato in una variabile chiamata `curcs`; quindi per `def` abbiamo `curcs=1218`. Guardando alla posizione 1218 nella tabella degli equivalenti, TeX troverà le seguenti informazioni: * `curcmd`=97. Questo è il codice comando per `\def`; * `curchr`=0. Questo è il modificatore del comando per `\def`. `\def` è un comando TeX primitivo (incorporato) e, a meno che non sia stato ridefinito da qualche parte, il terzo e ultimo pezzo di informazione dovrebbe essere `eq_level=1` che indica che il significato di `\def` è definito globalmente e non è limitato ad alcun livello di raggruppamento inferiore. Internamente, il valore di `eq_level` associato a un comando svolge un ruolo estremamente importante nel meccanismo di raggruppamento di TeX, ma non lo prenderemo ulteriormente in considerazione. Il grafico seguente riassume la spiegazione che abbiamo percorso: ![Il percorso dall’input di TeX al token di TeX.](/files/a78a43257d0b6e5387b72bde51452f6cc918e3d2) ## Token di TeX per i comandi Dopo aver attraversato le spiegazioni sopra, il calcolo effettivo dei token di TeX per le sequenze di controllo risulta in realtà davvero molto semplice. TeX usa il valore di `curcs` (1218) dalla funzione di hash per creare un semplice intero che chiama un *token*. Il calcolo per generare un token dal valore di `curcs` è: ```c curtok = 4095 + curcs ``` TeX memorizza il valore del token corrente (calcolato più di recente) in una variabile chiamata `curtok`. Quindi, in conclusione, il token di TeX che rappresenta il `\def` comando è `4095 + 1218 = 5313`. E questo è tutto per i token di TeX che rappresentano sequenze di comando: sono semplicemente un numero intero calcolato da un valore della tabella hash più 4095. ## Token di TeX per i caratteri Quando TeX deve creare un token che rappresenta un carattere usa il seguente calcolo, altrettanto semplice: ```c curtok = 256*catcode + (valore ASCII del carattere) ``` Nota che per motori compatibili con Unicode come LuaTeX si usano calcoli leggermente diversi. Per esempio, il token di TeX che rappresenta un carattere di spazio con `\catcode` 10 e valore ASCII 32 è: ```c 256*10 + 32 = 2592 ``` ### Liste di token contenenti caratteri Quando crei una semplice lista di token con, per esempio, ```latex \toks100={Hello} ``` TeX creerà la seguente lista di token e la memorizzerà in memoria per un uso successivo: * 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 Nel profondo della memoria di TeX il registro token 100 fornirà accesso alla posizione di archiviazione di “Hello”, salvata come 5 valori token: 2888, 2917, 2924, 2924, 2927. Nota che questi token combinano il codice ASCII di ciascun carattere e il valore del suo `\catcode`nel momento in cui vengono trasformati in token (tokenizzati). Una volta che i caratteri sono stati convertiti in token di carattere, il `\catcode` valore ad essi associato è permanente e viene memorizzato all’interno dei token per un uso successivo quando l’utente dice, per esempio, `\the\toks100`. Come notato, un token di carattere è calcolato da `256*catcode + (valore ASCII)` mentre un token di sequenza di controllo è calcolato da `4095 + curcs` dove `curcs` è il valore di hash della parola di controllo (stringa di testo di un comando digitato dall’utente) rilevata nell’input da TeX. Vale la pena notare che i token di carattere sono sempre minori di 4095. Quindi TeX può facilmente determinare se un particolare token rappresenta una sequenza di controllo (un comando) o un carattere e quindi capire quale sequenza di controllo o carattere e `\catcode` coppia è codificata in quel 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/it/articoli-approfonditi/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.