> 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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md). # Come funziona \expandafter: dai principi di base all'esplorazione del codice sorgente di 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) ## Introduzione Ora abbiamo coperto gli argomenti di contesto necessari per un'esplorazione completa di `\expandafter`: * le basi dei token di TeX e come vengono calcolati; * i principi alla base del processo di espansione di TeX; * l'uso/la creazione da parte di TeX di liste temporanee di token durante l'elaborazione del documento; * come TeX utilizza e “gioca con” più sorgenti di input (incluse le liste temporanee di token). In questo articolo metteremo insieme questi argomenti/conetti per spiegare i meccanismi alla base di TeX’s `\expandafter` comando: in breve, come funziona. ## E così, a \expandafter L'idea alla base di `\expandafter` è forzare l'espansione di un comando (token) prima di quanto TeX farebbe normalmente. Dati due token, $$\mathrm{T\_1}$$ e $$\mathrm{T\_2}$$ l'azione di `\expandafter` $$\mathrm{T\_1T\_2}$$ fa sì che TeX elabori $$\mathrm{T\_1}\text{<}$$l'espansione di $$\mathrm{T\_2}\text{>}$$, dove $$\text{<}\dots\text{>}$$ indica una lista di token. TeX espande $$\mathrm{T\_2}$$ in anticipo in modo che il token $$\mathrm{T\_1}$$ (ad es. un primitivo o una macro) possa vedere, o possa agire sui, token risultanti dall'espansione di $$\mathrm{T\_2}$$. Se il token $$\mathrm{T\_2}$$ rappresenta un elemento non espandibile come un carattere non attivo o (la maggior parte dei) primitivi, l'azione di `\expandafter` non cambia nulla: TeX continuerebbe a elaborare i token $$\mathrm{T\_1T\_2}$$ nel modo normale. ### Introduzione all'uso di \expandafter Se non hai mai usato `\expandafter`, ecco un esempio del suo uso con il primitivo `\uppercase{...}`. Supponiamo di voler comporre il nome del nostro file `.tex` di input principale ma in lettere maiuscole. Potremmo conoscere i seguenti comandi primitivi di TeX: * `\uppercase`: fa, come suggerisce il nome, converte i token di carattere nel corrispondente equivalente maiuscolo (dove esiste); * `\jobname`: come abbiamo visto, si espande restituendo il nome del principale `.tex` . Supponendo che il nostro file TeX si chiami `mycode.tex` potremmo ragionevolmente aspettarci `\uppercase{\jobname}` di comporre `MYCODE`. Ma no, compone `mycode` in minuscolo. Cosa è andato “storto”? Se scriviamo l'uso generale di `\uppercase` come ``` \uppercase{} ``` possiamo dire che `\uppercase` scorre attraverso `` e agirà solo (cambiando il maiuscolo/minuscolo) sui *token di carattere* che rileva all'interno di ``: tutti i token non di carattere sono *ignorati* perché `\uppercase` non “guarderà dentro” (non espanderà) i token non di carattere per vedere cosa contengono o rappresentano. Poiché un token è semplicemente un valore intero, tutto ciò che `\uppercase` deve fare è scorrere la lista di token per controllare se il valore numerico di ciascun token in `` rientra nell'intervallo di valori che indica un token di carattere. Per inciso, `\uppercase` farà anche *cambiare il maiuscolo dei caratteri attivi* per creare un carattere attivo maiuscolo che, poiché è ancora attivo, dovrà anche essere stato definito, altrimenti TeX genererà un errore: `Sequenza di controllo non definita`, ma stiamo divagando... Per esempio, anche se definiamo una macro che è solo testo ``` \def\foo{some lower-case text} ``` allora `\uppercase{\foo}` compone comunque `some lower-case text` e non `SOME LOWER-CASE TEXT` come ci aspetteremmo, semplicemente perché l'azione di `\uppercase` non cerca di determinare cosa `\foo` rappresenti: vede `\foo` come un token di comando e lo ignora, come ha fatto con `\jobname`. ### Come possiamo risolvere questo? \expandafter in soccorso Per comporre una versione in maiuscolo del nome del file, dobbiamo modificare `\uppercase{\jobname}` forzando TeX a sostituire `\jobname` con la sua espansione (una sequenza di token di carattere) *prima che* `\uppercase` entri in azione. Ancora una volta, l'espansione viene usata per rimuovere il `\jobname` token (comando) e sostituirlo con il risultato della sua espansione (una lista di token contenente token di carattere). Quindi, se scriviamo ``` \uppercase\expandafter{\jobname} ``` allora funziona: `MYCODE` verrebbe composto. Ciò che accade è che TeX inizia a elaborare `\uppercase` e controlla immediatamente la parentesi graffa di apertura obbligatoria (`{`); tuttavia, TeX rileva un `\expandafter` comando che lo porta a “dirottare temporaneamente la sua attenzione” sull'elaborazione di `\expandafter{\jobname}`. Se confrontiamo `\expandafter` $$\mathrm{T\_1T\_2}$$ con il nostro esempio `\expandafter{\jobname}` possiamo vedere * $$\mathrm{T\_1} =\space$$`{`token * $$\mathrm{T\_2} =\space$$`\jobname`token Dove `{`token e `\jobname`token si riferiscono ai valori dei token calcolati da TeX — la notazione in pedice token è usata per ricordarci che TeX lavora nel mondo dei token interi. Scrivere `\uppercase\expandafter{\jobname}` funziona perché, a grandi linee (i dettagli seguiranno), `\expandafter` fa sì che TeX esegua i seguenti compiti: 1. leggere e salvare l'apertura `{`token; 2. leggere il token successivo: `\jobname`token. TeX riconosce che `\jobname`token rappresenta un comando espandibile e lo espande. `\jobname`token viene sostituito con la sua espansione — una serie di token di carattere; 3. dopo aver espanso il `\jobname` comando, TeX rimette il `{`$$\_\mathrm{token}$$ “nell'input” e usa la lista di token derivante dall'espansione di `\jobname` in modo che TeX legga `\uppercase{`token``lista di token (caratteri)`}`, e questo produce il risultato desiderato. Il diagramma seguente mostra come TeX elabora `\uppercase\expandafter{\jobname}`—leggi il grafico dal basso e procedi verso l'alto per seguire il flusso del processo. ![Come funziona \expandafter](/files/98b01b1218385f734f7f398af19c3fa4384cfd81) Le seguenti note spiegano le varie fasi dell'elaborazione. 1. TeX inizia a elaborare `\uppercase` e controlla la parentesi graffa di apertura obbligatoria (`{`) ma rileva un `\expandafter` comando. 2. Se confrontiamo `\expandafter` $$\mathrm{T\_1T\_2}$$ al nostro input di `\expandafter{\jobname}` possiamo vedere $$\mathrm{T\_1} =$$`{`token e $$\mathrm{T\_2} =$$`\jobname`token. Nota che qui useremo il pedice token per indicare che TeX sta elaborando valori di token interi. 3. `\expandafter` legge, quindi salva temporaneamente, il `{`token memorizzando quel valore intero del token in una variabile interna. Più tardi, TeX reinserirà quel token nell'input, dopo aver elaborato il `\jobname` comando. 4. `\expandafter` legge il token successivo, `\jobname`token, e espande il `\jobname` comando. 5. L'espansione di `\jobname` crea una lista temporanea di token che contiene una sequenza di token di carattere che rappresentano il `.tex` nome del file. Nota che tutti i token di carattere generati da `\jobname` vengono calcolati usando il codice di categoria 12. 6. Una volta `\jobname` espanso, TeX reinserisce il token salvato al passo 3 (`{`token) e lo rimette nell'input. TeX lo fa creando un'altra lista di token contenente il *singolo* `{`token 7. TeX ha ora terminato l'elaborazione di `\expandafter`, ottenendo due liste di token pronte per essere usate come sorgenti di input di TeX. TeX ora torna a elaborare `\uppercase` ma ha configurato il proprio input in modo che le due liste di token create da `\expandafter` diventino la sorgente dei token per `\uppercase`—che ora vede `\uppercase{`token``lista di token (caratteri)`}`. `\uppercase` ora vede una sequenza di token di carattere e può produrre il risultato desiderato. 8. Dopo aver letto tutti i token di carattere prodotti da `\jobname`, TeX torna a ottenere token dalla sua precedente sorgente di input (il nostro file `.tex` ) da cui leggerà il token successivo: la parentesi graffa di chiusura `}` necessaria per terminare la lista di token da elaborare con `\uppercase`. ### \expandafter e liste interne di token Le liste temporanee di token sono un *elemento* vitale `\expandafter`del comportamento di elaborazione di `\expandafter` ’s: comprendere l'uso e l'esistenza di queste liste di token può aiutare a chiarire come `\expandafter` raggiunge i propri risultati, soprattutto quando si cerca di scrivere, o di capire, macro che fanno uso di più `\expandafter` Un altro elemento chiave del comportamento di `\expandafter`’s, specialmente con più `\expandafter` consecutivi, *è l'uso della* ricorsione (all'interno dello stesso software TeX)—un argomento che prenderemo in considerazione più avanti in questo articolo. `\expandafter`Per aiutare ulteriormente la nostra comprensione delle liste temporanee di token, esamineremo un altro esempio di `\the` comando. #### \expandafter e liste interne di token: esempio 2 In questo esempio vedremo come `\expandafter` possa essere usato per influenzare i token memorizzati in un registro di token tramite il comando `\toks` Ecco i primitivi di TeX che useremo: * `**\count** *registro*=*numero*`: un primitivo di TeX usato per memorizzare il valore `*numero*` nella locazione di TeX `*registro*`; * `**\toks** *registro*={*lista di token*}`: un primitivo di TeX usato per memorizzare `*lista di token*` nella locazione del registro di token `*registro*`—salvando una sequenza di token per un uso successivo; * `**\the** *token*`: un comando primitivo espandibile di TeX che elabora `*token*`, anche se i risultati esatti dipendono dalla natura del `*token*` elaborato. `\the` ha numerosi usi: tra questi c'è la composizione del valore memorizzato in un parametro o variabile di TeX (ad es. un registro). Altri usi di `\the` includono l'inserimento di una copia dei token memorizzati in un registro di token. Qui useremo `\the` per comporre il valore memorizzato in un `\count` registro. Inizieremo con il seguente codice TeX per memorizzare il valore `12345` nel registro `\count` di TeX `99`: ``` \count99=12345 ``` Se vogliamo comporre il valore memorizzato in `\count99` possiamo usare `\the\count99` (oppure `\number\count99`). Successivamente useremo il comando `\toks` per memorizzare alcuni token nel registro di token `99`: ``` \toks99={\the\count99 } ``` L'elenco di token memorizzato nel registro di token `99` conterrebbe quanto segue: | | | | ------------------------ | -------------------------------------------------------------------------------------------------------------------- | | **Valore del token TeX** | **Elemento rappresentato** | | 5382 | `\the` | | 7885 | `\count` | | 3129 | `9` (codice carattere 57 con codice di categoria 12) con un valore di token di $$256 \times 12 + 57 = 3129$$ | | 3129 | `9` (codice carattere 57 con codice di categoria 12), con un valore di token di $$256 \times 12 + 57 = 3129$$ | | 2592 | `` (codice carattere 32 con codice di categoria 10), con un valore di token di $$256 \times 10 + 32 = 2592$$ | Si noti che la lista di token creata da `\toks99` non *contiene* il valore effettivo dei dati memorizzato in `\count99` perché il comando `\toks` non esegue l'espansione: si limita a creare token e a memorizzarli. Nel nostro esempio, `\the` non viene espanso quindi non elabora `\count99`; qui `\the` si trasforma semplicemente in un token (valore 5382) e viene memorizzato nella lista di token. Se vogliamo che la `\toks99` lista di token contenga token che rappresentano i dati memorizzati in `\count99` avremo bisogno di qualche modo per creare quei token (renderli disponibili) in modo che il comando `\toks` possa accedervi. E naturalmente `\expandafter` può farlo per noi. Se scriviamo: ``` \toks99=\expandafter{\the\count99 } ``` l'azione/elaborazione del comando `\toks` verrà “messa in attesa” mentre `\expandafter` causa (forza) l'espansione di `\the` che, a sua volta, agisce su `\count` per generare una lista temporanea di token contenente token di carattere che rappresentano i dati memorizzati in `\count99`. Un piccolo ma importante dettaglio è il `` carattere dopo le cifre `99`: quel `` carattere serve a terminare il processo di scansione di TeX quando sta cercando una quantità numerica. Qui, l'azione di `\expandafter` è molto simile all'esempio `\jobname` . 1. Leggi e salva l'apertura `{`token. 2. Leggi il token successivo, `\the`token, che rappresenta un comando espandibile, quindi TeX lo espande. `\expandafter` forza l'espansione di `\the` che poi agisce su `\count99` per convertire i dati memorizzati in `\count` di TeX `99` (il numero 12345) in una lista temporanea di token. Quella lista conterrà token di carattere che rappresentano le cifre `1`, `2`, `3`, `4` e `5`—token di carattere con codice di categoria 12. 3. Dopo aver espanso ed elaborato `\the`, TeX mette il `{`token “di nuovo nell'input” e usa la lista di token derivante da `\the\count99` in modo che TeX legga `\toks99={`token``lista di token (caratteri)`}` e questo produce il risultato desiderato. Questa sequenza di eventi è riassunta nel diagramma seguente—leggi il grafico dal basso e procedi verso l'alto per seguire il flusso del processo. ![Come funziona \expandafter](/files/e889f9d97e310cccaa5eb7d6ecc54a5ab2b95c54) 1. TeX inizia a elaborare `\toks`; vede il segno `=` opzionale, quindi controlla la parentesi graffa di apertura obbligatoria (`{`, o qualsiasi carattere con codice di categoria 1) usata per indicare l'inizio di una lista di token. Tuttavia, TeX rileva un `\expandafter` comando e procede invece a eseguirlo. 2. Se confrontiamo `\expandafter` $$\mathrm{T\_1T\_2}$$ al nostro input di `\expandafter{\the\count99 }` possiamo vedere $$\mathrm{T\_1} =$$ `{`token e $$\mathrm{T\_2} =$$ `\thetoken`. 3. `\expandafter` legge, quindi salva temporaneamente, il `{`token (TeX memorizza temporaneamente quel valore intero del token in una variabile interna). Più tardi, TeX reinserirà quel token nell'input, dopo aver elaborato `\the` 4. `\expandafter` legge il token successivo, `\the`token e lo espande. 5. L'espansione di `\the` crea una lista temporanea di token dall'elaborazione di `\count99`—quella lista di token contiene una sequenza di token di carattere che rappresentano il valore dei dati memorizzato nel `\count` di TeX `99`. 6. Una volta `\the` espanso, TeX reinserisce il token salvato al passo 3 (`{`token) e rimette quel token nell'input. TeX lo fa creando un'altra lista di token contenente il *singolo* token `{`token. 7. TeX ha ora terminato l'elaborazione di `\expandafter` e ha prodotto due liste di token pronte per essere usate come prossime sorgenti di input. TeX torna a elaborare `\toks99=` ma ora TeX ha configurato il proprio input in modo che le due liste di token create da `\expandafter` diventino la sorgente dei token per `\toks`—che ora vede `{`token``lista di token (caratteri)`}`. `\toks` possa ora accedere, e memorizzare, la sequenza di 5 token di carattere che rappresentano il valore dei dati (`12345`) memorizzato in `\count99`: il nostro risultato desiderato. 8. Dopo aver letto tutti i token di carattere prodotti da `\the\count99`, TeX torna a ottenere token dalla sua precedente sorgente di input (il nostro file `.tex` ) da cui leggerà il token successivo: la parentesi graffa di chiusura `}` necessaria per terminare la lista di token da salvare tramite `\toks99={...}`. ## Come funziona davvero \expandafter In questa sezione daremo uno sguardo “a basso livello” all'interno dello stesso TeX: esplorando il codice sorgente/le funzioni all'interno di TeX che implementano il comportamento di `\expandafter`. I dettagli sono espressi in un pseudo-codice C ma dovrebbero essere accessibili a chiunque abbia familiarità con altri linguaggi di programmazione. Il seguente diagramma annotato spiega come TeX implementa `\expandafter` come parte di una funzione più ampia chiamata `expand()`—la funzione centrale che guida l'elaborazione di espansione di TeX. All'interno della sezione responsabile dell'implementazione di `\expandafter` possiamo vedere [*ricorsivo* comportamento](https://en.wikipedia.org/wiki/Recursion) dove un'altra chiamata alla funzione `expand()` viene usata per elaborare il secondo token letto, $$\mathrm{T\_2}$$, per quei casi in cui $$\mathrm{T\_2}$$ è espandibile. Sebbene questo codice appaia nel motore TeX di Knuth, i principi di base delineati da questo grafico sono applicabili a tutti i motori TeX. ![Come funziona \expandafter all'interno di TeX](/files/f7f4ca1b446b1b97f8aa313f30022f3af4bae942) Il primo compito di `expand()` è determinare se il comando da espandere è una macro o un primitivo, perché le macro hanno un processo di espansione specializzato che viene gestito da una funzione chiamata `macrocall()`. Se il comando da espandere è un primitivo, la `expand()` funzione usa il valore corrente del codice comando (memorizzato nella variabile globale `curcmd`) per identificare quale primitivo particolare deve essere elaborato. Possiamo vedere questi dettagli in un elenco più completo di `expand()`: ``` void expand(void) { //curcmd is a global variable if(curcmd != macro) // curcmd < 111 { switch(curcmd) { case \expandafter: // Elabora il comando \expandafter T1T2 { gettoken(); // Legge il token T1 t = curtok; // Salva il token T1 nella variabile locale t gettoken(); // Legge il token T2 if(curcmd > 100) // Il token T2 è espandibile? expand(); // Sì! T2 è espandibile: // esegue l'espansione di T2 tramite // effettuando una chiamata ricorsiva alla funzione expand() else backinput(); // T2 non è espandibile: rimetti quel token // indietro nell'input per essere letto di nuovo (in seguito) curtok = t ; // Ripristina la variabile globale curtok al valore salvato di T1 backinput() ; // Rimetti il token T1 nell'input // prima dei token derivanti dall'espansione di T2 } break; // Codice per elaborare altri comandi espandibili case “comando di test "converti in testo"”: // Qualsiasi tra \number, \string, \romannumeral, // \meaning, \fontname, \jobname // Condividono lo stesso valore di curcmd break; case \noexpand: // Sopprime l'espansione del token successivo ... break; case \csname: // Crea un nome di sequenza di controllo. ... break; case \the: // Inserisce alcuni token .... break; case “comando di test \if...” : // Elabora uno dei condizionali di TeX: // \if, \ifcat, \ifnum, \ifdim,\ifodd, \ifvmode, // \ifhmode, \ifmmode, \ifinner, \ifvoid, // \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, // \ifcase, \ifdefined, \ifcsname, \iffontchar ... break; case “\fi o \else”: // Termina il condizionale corrente ... break; // ecc. per qualsiasi altro comando primitivo espandibile supportato da // motore TeX } }else // Non è un primitivo espandibile: è una macro { macrocall() } //... altro codice rimosso } ``` ### L'amore di TeX per le variabili globali Forse riflettendo la sua età e l'epoca in cui è stato progettato, il codice sorgente di TeX fa ampio uso delle cosiddette [variabili globali](https://en.wikipedia.org/wiki/Global_variable)—in effetti ce ne sono centinaia. Per loro stessa natura, le variabili globali possono essere cambiate/modificate da qualsiasi punto del codice sorgente di TeX — che, per il TeX di Knuth, è un singolo file monolitico contenente oltre 25.000 righe di codice e centinaia di funzioni. Capire come funziona TeX non è sempre un compito facile... Per elaborare `\expandafter`, TeX legge i token dal suo input corrente usando una funzione chiamata `gettoken()` la cui azione consiste nel creare un token e impostare il valore di diverse variabili globali chiave usate in tutto il codice sorgente di TeX. Due di queste variabili, aggiornate dall'azione di `gettoken()`, sono usate nell'implementazione di `\expandafter`: * `curtok`: (token corrente) il valore intero del token appena letto; * `curcmd`curcmd: (codice di comando corrente) il codice di comando del comando (o carattere) rappresentato dal token `curtok`. Quando si elabora `\expandafter`$$\mathrm{T\_1T\_2}$$ TeX legge il token $$\mathrm{T\_1}$$ e ne salva temporaneamente il valore (un intero) in una variabile locale chiamata `t`. TeX poi legge $$\mathrm{T\_2}$$ e verifica se quel token rappresenta un comando espandibile — controllando se il suo codice di comando (`curcmd`) è > 100. Se sì, TeX deve espandere il comando rappresentato da $$\mathrm{T\_2}$$ e effettua un'altra chiamata alla funzione `expand()`: questo è un esempio di *è l'uso della* perché il comando `expand()` la funzione che chiama se stessa. Essere consapevoli della natura ricorsiva dell'espansione, soprattutto quando si usa `\expandafter`, può aiutare a capire come più `\expandafter` comandi consecutivi—cioè, `\expandafter` ottengono i loro effetti. Se il token $$\mathrm{T\_2}$$ è espandibile, l'espansione ha luogo e, quando la chiamata ricorsiva a `expand()` ritorna, il codice all'interno dell'implementazione di `\expandafter` re-inserisce il token $$\mathrm{T\_1}$$ nell'input. La variabile globale `curtok` viene riassegnata al valore del token salvato — memorizzato nella variabile locale `t`, che è il valore del token $$\mathrm{T\_1}$$— e viene effettuata una chiamata alla funzione `backinput().` #### La funzione backinput() Come suggerisce il nome, questa funzione rimette un token «nell'input». Per farlo, TeX usa il valore corrente della variabile globale `curtok` per creare una lista di token che contiene un singolo token (il cui valore intero è fornito da `curtok`). TeX dispone inoltre la gestione dell'input in modo da garantire che quella lista di un singolo token venga, al momento opportuno, riletta da TeX come parte della successiva elaborazione dell'input. Si noti attentamente che il token $$\mathrm{T\_1}$$ viene re-inserito *dopo che l'espansione è terminata*, il che garantisce che TeX leggerà quel token re-inserito *prima che* mentre legge i token derivanti dall'espansione di $$\mathrm{T\_2}$$. ### Elaborazione delle macro: la funzione macrocall() Come già discusso, tutte le macro, insieme ad alcuni comandi primitivi, sono espandibili e tutta l'elaborazione dell'espansione passa attraverso la `expand()` funzione. Tuttavia, `expand()` fa attenzione a usare il `curcmd` valore (comando corrente) per distinguere tra primitivi espandibili e macro, perché il processo di espansione delle macro è gestito da una funzione dedicata chiamata `macrocall()`. Le macro necessitano di un processo di espansione specializzato perché gli argomenti delle macro e i token delimitatori devono essere individuati in un modo molto particolare e rigoroso; di conseguenza, quel processo è delegato a una funzione progettata per farlo: `macrocall()`. #### Espansione delle macro vs. esecuzione delle macro Macro *espansione* non è lo stesso processo dell' *esecuzione*: l'espansione di una macro è il processo preliminare all'esecuzione che TeX esegue per rendere la macro *pronta per l'esecuzione*. L'«esecuzione» di una macro avviene quando TeX sta leggendo e elaborando attivamente i token contenuti nella definizione di quella macro (testo di sostituzione) e nei suoi argomenti (parametri). #### Espansione delle macro Per espandere una macro TeX verifica prima se la macro accetta argomenti; in tal caso, `macrocall()` esamina con molta attenzione l'input alla ricerca dei token destinati a diventare gli argomenti della macro. Quel processo include il controllo dell'input dell'utente per eventuali token delimitatori usati nella definizione originale della macro — il modello di token usato in una chiamata di macro deve corrispondere esattamente al modello di token contenuto nella definizione memorizzata. Tuttavia, i token usati come delimitatori vengono semplicemente scartati da TeX: in effetti, sono solo una forma di «punteggiatura» che TeX usa per determinare i token effettivi destinati a diventare gli argomenti della macro — cioè i token che l'utente intende far elaborare dalla macro. Per ulteriori informazioni sui token delimitatori, vedi [Come funzionano davvero le macro di TeX](/latex/it/altri-argomenti/22-how-tex-macros-actually-work-part-4.md). Per ogni parametro (`#1, #2...#9`) presente nella definizione originale della macro, TeX esamina la chiamata effettiva della macro per identificare quali token forniti dall'utente sono destinati a ciascun parametro (cioè formano gli argomenti della macro). Quel processo produce una o più mini liste di token: una per ogni argomento della macro. Dopo che eventuali argomenti della macro sono stati individuati e le loro liste di token sono state preparate, TeX recupera la definizione della macro (testo di sostituzione) memorizzata nella sua memoria e organizza l'elaborazione dell'input in modo che, ogni volta che TeX è pronto a leggere/elaborare altri token, li legga dal testo di sostituzione della macro, eseguendo così la macro. Al momento opportuno, durante l'esecuzione della macro, le liste di token che rappresentano gli argomenti della macro saranno inserite nella posizione corretta all'interno del testo di sostituzione della macro. Ancora una volta, l'espansione di un comando macro significa *rimuovere* quel comando macro (token) dall'input e *sostituirlo* con la lista di token memorizzata come testo di sostituzione della macro. Per un'analisi approfondita dell'elaborazione delle macro di TeX, vedi la serie di articoli in sei parti [Come funzionano davvero le macro di TeX?](/latex/it/altri-argomenti/01-a-six-part-series-how-do-tex-macros-actually-work.md) [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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.