> 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/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md). # Come funziona \expandafter: un'introduzione ai token TeX [Parte 1](/latex/it/articoli-approfonditi/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Parte 2](/latex/it/articoli-approfonditi/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Parte 3](/latex/it/articoli-approfonditi/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Parte 4](/latex/it/articoli-approfonditi/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Parte 5](/latex/it/articoli-approfonditi/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Parte 6](/latex/it/articoli-approfonditi/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) ## Contesto per \expandafter: token TeX ed elenchi di token Come primo passo per capire come `\\expandafter` funziona davvero, daremo un’occhiata a due componenti di TeX che sono fondamentali per il funzionamento di `\\expandafter`: i token TeX (numeri interi) e gli elenchi di token (elenchi di interi). I lettori che desiderano esplorare questi argomenti in modo molto più dettagliato potrebbero essere interessati a leggere i seguenti articoli pubblicati da Overleaf: * [Che cos’è un token TeX?](/latex/it/articoli-approfonditi/53-what-is-a-tex-token.md) * [Che cos'è una lista di token di TeX?](/latex/it/articoli-approfonditi/54-what-is-a-tex-token-list.md)-[Come funzionano davvero le macro TeX?](/latex/it/altri-argomenti/01-a-six-part-series-how-do-tex-macros-actually-work.md) ### Da dove provengono i dati dei token? In tutto questo articolo usiamo valori reali dei token calcolati da TeX—dati che di solito non sono accessibili agli utenti. Per i lettori curiosi di sapere come sono stati ottenuti questi dati sui valori dei token, Overleaf dispone di versioni personalizzate di diversi motori TeX che usiamo per la ricerca. Questi motori sono modificati per produrre informazioni sulle attività di elaborazione interna di TeX—aiutando a fornire materiale di contesto aggiuntivo per alcuni degli articoli che produciamo. Mostrando/discutendo valori numerici dei token, il nostro obiettivo è includere dettagli che, ci auguriamo, aiutino i lettori a comprendere meglio i “token TeX”, rendendo questo importante concetto un po’ meno opaco. ## Token TeX 101 (e nozioni di espansione) Quando TeX elabora il tuo file di input, legge il testo e converte i singoli caratteri e le sequenze di caratteri (comandi) nei cosiddetti *token*. Un token TeX è semplicemente un valore intero, calcolato da TeX, usato per “codificare” i dati che TeX deve memorizzare riguardo a un elemento letto dalla sua sorgente di input corrente. Pensa ai token come a piccoli pacchetti di informazione che “impacchettano insieme” i dati che TeX deve registrare, pronti per essere passati alla fase successiva di elaborazione. Internamente, TeX opera su quei valori interi dei token—non usa le lettere, i simboli, le cifre ecc. effettivi contenuti originariamente nel tuo file di input: tutto viene convertito in un token (un intero) e TeX lavora con quelli. ## Come TeX calcola i valori dei token Qui esaminiamo i calcoli dei token usati nel TeX originale di Knuth, e-TeX e pdfTeX; per altri motori TeX, in particolare XeTeX e LuaTeX, i loro calcoli dei token devono essere leggermente diversi per tener conto dell’uso di Unicode, ma i metodi di calcolo sono simili a quelli descritti qui sotto. ### Token di carattere (caratteri non attivi) Il calcolo dei valori dei token per i caratteri non attivi è semplice: $$\text{character token} = 256\times \text{(category code)} + \text{character (ASCII) code}$$ **Esempio**: La lettera A con [codice di categoria](/latex/it/altri-argomenti/43-table-of-tex-category-codes.md) 11, il codice di carattere 65 è rappresentato da TeX come il valore di token del carattere $$256\times 11 + 65 = 2881$$. Potresti incontrare descrizioni nella letteratura su TeX che notano che, una volta che TeX ha acquisito un carattere, il suo valore di codice di categoria diventa “permanentemente vincolato” a quel carattere: il calcolo del valore del token mostrato sopra spiega perché ciò sia vero. Tuttavia, più avanti nell’elaborazione di TeX, esso può effettivamente “scomporre” i token di carattere per rivelare la coppia costituente (codice di carattere, codice di categoria) dalla quale il token è stato costruito—quando TeX fa questa “scomposizione” non altera comunque il codice di categoria di quel carattere, usa semplicemente quell’informazione durante l’elaborazione successiva. ### Token di comando L’elaborazione dell’input e la generazione dei token di TeX riconoscono due tipi di comando: * comandi costruiti da uno o più caratteri con codice di categoria 11; * comandi a singolo carattere in cui il codice di categoria di quel carattere non è 11: come `\$` o `\#`. In entrambi i casi, TeX esclude il carattere iniziale `\` e usa il codice di carattere di ciascun carattere rimanente per calcolare un intero che TeX chiama `curcs` (**sequenza**di controllo **c**corrente **s**equence). TeX poi usa il valore di `curcs` per calcolare un valore di token per il comando. #### Comandi composti da caratteri con codice di categoria 11 Supponiamo che il nostro comando (meno il carattere iniziale `\` carattere) sia composto da una sequenza di caratteri: $$\mathrm{C\_1C\_2C\_3...C\_N}$$ dove $$\mathrm{C}\_i$$ è il codice di carattere di ciascun carattere—ad esempio, il codice di carattere di A è 65. TeX usa tutti i codici di carattere $$\mathrm{C}\_i$$ per calcolare l’intero `curcs` (usando un [funzione hash](https://en.wikipedia.org/wiki/Hash_function)). Una volta che TeX ha calcolato il valore di `curcs` aggiunge semplicemente 4095 a quel valore, per ottenere il valore di token: $$\text{command token} = \text{curcs + 4095}$$ Nota che la variabile `curcs` svolge un ruolo estremamente importante nelle attività di elaborazione interne di TeX. #### Comandi a singolo carattere I token per rappresentare comandi come `\$`, `\#` ecc. sono soggetti a un calcolo leggermente diverso: l’intero `curcs` ora è il calcolo più semplice: $$\text{curcs} = 257 + \text{character (ASCII) code}$$ Per esempio, con `\$`, $$\text{curcs}=257 + 36 = 293$$. TeX aggiunge di nuovo 4095 a questo valore (usando $$\text{command token} = \text{curcs} + 4095$$) ottenendo `\$` con un valore di token $$293 + 4095 = 4388$$. Rispetto ai comandi composti da caratteri con codice di categoria 11, l’unica differenza qui è il modo in cui TeX calcola il valore di `curcs`. **Nota**: l’intero `curcs` non viene calcolato per i token di carattere: è sempre impostato su 0 quando TeX crea o usa token di carattere. #### Token di carattere attivo TeX ha il concetto dei cosiddetti *caratteri attivi*: qualsiasi carattere a cui sia assegnato il codice di categoria 13. I token di questa speciale classe di caratteri sono soggetti a un calcolo diverso rispetto ai caratteri normali. Il meccanismo dei caratteri attivi consente a TeX di creare quelle che, in effetti, sono macro a singolo carattere che puoi usare *senza* senza dover anteporre al carattere attivo un carattere di escape (tipicamente `\`): il carattere isolato attiverà il suo comportamento da macro. L’esempio canonico è il carattere tilde (\~) che TeX/LaTeX usano per gli spazi non divisibili, che può essere definito/abilitato come segue: ``` \catcode`~=13 %assegna il codice di categoria 13 a ~ \def~{\penalty100000\ } % definisci ~ in modo che agisca come una macro ``` Quando TeX legge successivamente un `~` carattere, rileverà che il suo codice di categoria è 13 e lo elaborerà come una “mini macro”. Per calcolare un token che rappresenti un carattere attivo, TeX applica un’altra variante per calcolare `curcs`: $$\begin{align\*} \text{curcs} &= \text{character code} + 1\ \text{active character token} &= \text{curcs} + 4095\ \end{align\*}$$ Per esempio, il carattere \~ ha codice di carattere 126, il che significa che la rappresentazione del suo valore di token come carattere attivo è calcolata come segue: $$\begin{align\*} \text{curcs} &= 126 + 1\ \text{active character token} &= 127 + 4095\ &=4222\ \end{align\*}$$ Nota che, come i comandi, i token che rappresentano caratteri attivi sono > 4095. ### Conseguenze/note * Qualsiasi token il cui valore superi 4095 è immediatamente identificabile come token di comando—quindi TeX può rilevare molto facilmente se un determinato token rappresenta un carattere o un comando. * Per qualsiasi valore di token, TeX può, quando necessario, “scomporre” quel token per rivelare il carattere (e il suo codice di categoria), oppure il comando, originariamente presente nel tuo `.tex` file, memorizzato in una definizione di macro o contenuto in un altro elenco di token. * La quantità “intermedia” chiamata `curcs`—che TeX usa per calcolare i valori dei token di comando—svolge un ruolo importante nell’elaborazione di basso livello di TeX. `curcs` funge da “valore indice” che TeX usa per memorizzare/recuperare il significato corrente di un comando. Dato qualsiasi token di comando, $$\mathrm{T}$$, TeX semplicemente sottrae 4095 per accedere al valore di `curcs`: $$\text{curcs} = \mathrm{T}-4095$$ Tra l’altro, TeX memorizza la stringa di caratteri leggibile dall’uomo da cui viene generato un token di comando—questo è essenziale per la segnalazione degli errori e per altri comandi come `\string` la cui espansione è la versione leggibile dall’uomo di un valore di token. Tuttavia, quelle stringhe di caratteri leggibili dall’uomo memorizzate all’interno di TeX vengono usate/mostrate solo quando richiesto: per tutta l’altra elaborazione si usa il valore intero del token. ## Guardando alcuni token reali Solo per rendere la nozione di token un po’ meno opaca, definiremo la seguente semplice macro e daremo un’occhiata ai token che TeX produce: ``` \def\hello{Saluti, da \TeX. \hskip 10pt} ``` Per la `\hello` macro, TeX usa i caratteri `h`, `e`, `l`, `l`, `o` per calcolare un valore di 3745 per `curcs`; TeX poi aggiunge 4095 per creare un valore di token di $$3745 + 4095 = 7840$$ (per il TeX di Knuth, e-TeX o pdfTeX). Dopo aver creato un token per rappresentare `\hello`, il `\def` il comando fa sì che TeX legga i token successivi e li usi per creare un elenco di token che viene memorizzato come *definizione* della `\hello` comando. Quella definizione memorizzata (elenco di token) può poi essere recuperata ogni volta che dici a TeX di usare la `\hello` comando. La tabella seguente elenca i valori effettivi dei token creati per ciascun elemento (carattere, macro o primitiva) contenuto nella `\hello` definizione della macro—questo elenco di token (interi) è ciò che TeX memorizza nella sua memoria (come struttura dati nota come una [lista concatenata](https://en.wikipedia.org/wiki/Linked_list)). I lettori che desiderano comprendere più nel dettaglio gli elenchi di token sono rimandati all’articolo di Overleaf [Che cos'è una lista di token di TeX?](/latex/it/articoli-approfonditi/54-what-is-a-tex-token-list.md) | | | | ------------------------ | -------------------------- | | **Valore del token TeX** | **Elemento rappresentato** | | 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 | | | 5235 | \TeX | | 3118 | . | | 2592 | | | 7943 | \hskip | | 3121 | 1 | | 3120 | 0 | | 2928 | p | | 2932 | t | Nell’elenco di token sopra, i caratteri hanno codici di categoria 10, 11 o 12. Per esempio: * i caratteri hanno codice di categoria 10 e codice di carattere 32, dando un valore di token di $$256\times 10 + 32 = 2592$$ * `,` e `.` hanno codice di categoria 12 e codici di carattere 44 e 46 rispettivamente, dando i token: * token per `,` $$= 256 \times 12 + 44 = 3116$$ * token per `.` $$= 256\times 12+ 46 = 3118$$ Ogni volta che TeX incontra successivamente il valore di token 7840 (che rappresenta `\hello`) può, se necessario, “scomporre” quel token per estrarre `curcs` tramite il semplice calcolo $$\text{curcs} = \text{token value} - 4095$$ (vedi sopra). Usando il valore di `curcs` TeX può consultare le sue tabelle interne dei dati per determinare che il token di comando 7840 rappresenta un comando macro. Inoltre, ancora tramite `curcs`, TeX può anche cercare e recuperare la definizione memorizzata di `\hello`. Quando TeX deve elaborare completamente il token 7840, cioè eseguire la `\hello` macro, non ha più bisogno del token 7840: quel token ha *compiuto il suo lavoro*—cioè ha fatto sì che TeX eseguisse la macro `\hello`. TeX può ora scartare il token 7840 e recuperare i token che rappresentano la definizione (elenco di token) memorizzata in memoria. In effetti, il `\hello` comando di macro (token 7840) è stato *rimosso* dalla sorgente di input corrente di TeX e *sostituito* con i token contenuti nella definizione di `\hello`. Quello che abbiamo appena descritto è una forma di *espansione dei token*. Il `\TeX` comando (valore di token 5235 elencato sopra) usato all’interno di `\hello` è essa stessa una macro costruita da altri token—quindi la sua definizione è anch’essa memorizzata come un elenco di token: | | | | ------------------------ | -------------------------- | | **Valore del token TeX** | **Elemento rappresentato** | | 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 dovessimo sostituire il `\hello` comando con l’elenco completo dei token da cui è costruito, compresa la `\TeX` macro, sarebbe un elenco piuttosto lungo—cioè, se anche *espandessimo* le `\TeX` macro vedremmo: ![Un elenco di token memorizzato in una macro TeX](/files/682d85df2631a2aaddc5beded4ca02f1a175b575) In sostanza, il singolo valore di token 7840 (per `\hello`) produrrebbe, una volta completamente espanso, un totale di 51 token (interi) che rappresentano caratteri e comandi primitivi. Nell’elenco seguente, il carattere o comando rappresentato da ciascun token è racchiuso tra parentesi “(...)”—questi non sono memorizzati direttamente negli elenchi di token di TeX e sono mostrati per aiutare il lettore: ``` 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) ``` Per un lettore umano questa è solo una serie di interi, ma per TeX codifica una grande quantità di informazioni. ## Leggi i token ora e salvali per dopo Mentre TeX legge il tuo input, potrebbero esserci momenti in cui ha bisogno (o gli viene ordinato) di rimandare l’elaborazione completa di un particolare insieme di token. Se gli viene detto di farlo, TeX, finché non gli viene detto di fermarsi, continuerà a creare token dall’input ma li memorizzerà per un uso successivo—recuperandoli ed elaborandoli in seguito come parte delle sue attività di composizione. Quei token memorizzati vengono salvati come cosiddetti *elenchi di token* che sono, in effetti, l’unico meccanismo interno di TeX per l’archiviazione dei dati dei token. Abbiamo già visto esempi di elenchi di token—le `\hello` e `\TeX` macro elencate sopra: la definizione di quelle macro è memorizzata nella memoria di TeX come elenchi di token. TeX elaborerà (agirà su) tali elenchi di token solo quando decidi di richiamare quelle macro. Ricorda inoltre che ogni token (valore intero) codifica informazioni sufficienti affinché TeX possa facilmente stabilire se ciascun token memorizzato in una definizione di macro rappresenti un carattere o un comando. ### Salvare i token con i registri di token Un altro esempio di memorizzazione dei token è la creazione esplicita di elenchi di token che vengono salvati nei cosiddetti *registri di token*: aree di memorizzazione interne dedicate che TeX mette a disposizione degli utenti per memorizzare elenchi di token. La primitiva TeX `\toksdef` è un modo per usare i registri di token; per esempio, per usare il registro di token `100` e farvi riferimento usando il comando `\mylist`: ``` \toksdef\mylist=100 \mylist={alcuni \TeX{} token qui} ``` `\mylist` è, in effetti, solo un nome che assegni a un elenco di token memorizzato nella locazione del registro `100`. Simile a una definizione di macro, `\mylist` contiene il seguente elenco di token: | | | | ------------------------ | -------------------------- | | **Valore del token TeX** | **Elemento rappresentato** | | 2931 | s | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | 379 | { | | 637 | } | | 2592 | | | 2932 | t | | 2927 | o | | 2923 | re | | 2917 | e | | 2926 | n | | 2931 | s | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | **Nota**: per terminare la `\TeX` macro e impedirle di assorbire il seguente `` carattere abbiamo usato una coppia di parentesi graffe `{}` subito dopo `\TeX`—i token per `{` (379) e `}` (637) sono memorizzati nell’elenco di token. Un’altra opzione è usare un token di “spazio di controllo” `\` che apparirebbe nell’elenco di token come mostrato di seguito (in grassetto): | | | | ------------------------ | -------------------------- | | **Valore del token TeX** | **Elemento rappresentato** | | 2931 | s | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | **4384** | **\\** | | 2932 | t | | 2927 | o | | 2923 | re | | 2917 | e | | 2926 | n | | 2931 | s | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | Nota che il `` carattere è rappresentato come un *token di carattere* con valore $$256\times 10 + 32 = 2592$$ ma `\` viene trattato come un *token di comando* (valore 4384) che viene calcolato usando le formule date sopra: \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\*} In sostanza `\mylist={alcuni \TeX{} token qui}` dice a TeX: per favore scansiona il mio file di input per convertire i seguenti caratteri/comandi in token e salvali per usarli in seguito. TeX acconsentirà e memorizzerà quei token in una locazione di memoria a cui puoi accedere scrivendo `\the\mylist`, indicando a TeX di inserire una copia dei token contenuti nel registro di token `\mylist`. I motori TeX includono una serie di comandi primitivi che generano e memorizzano esplicitamente elenchi di token—come `\everyjob`, `\everypar`, `\mark`, e molti altri. [Parte 1](/latex/it/articoli-approfonditi/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Parte 2](/latex/it/articoli-approfonditi/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Parte 3](/latex/it/articoli-approfonditi/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Parte 4](/latex/it/articoli-approfonditi/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Parte 5](/latex/it/articoli-approfonditi/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Parte 6](/latex/it/articoli-approfonditi/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/it/articoli-approfonditi/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.