> 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/17-how-does-expandafter-work-a-detailed-macro-case-study.md). # Come funziona \expandafter: un caso di studio dettagliato sulle macro [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) ## Caso di studio: esempio di \expandafter da The $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Manuale Il $$\varepsilon\mathrm{\text{-}{\TeX}}$$ il motore di composizione tipografica è stato derivato dal software TeX di Knuth e originariamente inteso come un passo “intermedio” verso lo sviluppo del [Nuovo sistema di composizione tipografica](https://en.wikipedia.org/wiki/New_Typesetting_System) (NTS), scritto nel linguaggio di programmazione Java. $$\varepsilon\mathrm{\text{-}{\TeX}}$$ è stato sviluppato per la prima volta alla fine degli anni '90 per aggiungere una serie di nuovi comandi primitivi che forniscono funzionalità aggiuntive non disponibili nel programma originale di Knuth. Sebbene $$\varepsilon\mathrm{\text{-}{\TeX}}$$ abbia ricevuto aggiornamenti periodici sin dal suo rilascio iniziale, oggi non è ampiamente utilizzato come motore di composizione tipografica autonomo, sebbene le sue innovazioni siano state assorbite nelle generazioni successive di TeX: pdfTeX, XeTeX e LuaTeX. Il [$$\varepsilon\mathrm{\text{-}{\TeX}}$$ manual](http://mirror.ox.ac.uk/sites/ctan.org/systems/doc/etex/etex_man.pdf) contiene un esempio illuminante di una macro che fa un uso ingegnoso di `\\expandafter`: ``` \def\foo#1#2{\number#1 \ifnum#1<#2, \expandafter\foo \expandafter{\number\numexpr#1+1\expandafter}% \expandafter{\number#2\expandafter}% \fi} ``` `\foo` implementa un meccanismo di ciclo, in modo che `\foo{7}{13}` produce `7, 8, 9, 10, 11, 12, 13`; tuttavia, `\foo` non utilizza alcun *assegnazioni a variabili* per controllare il processo di ciclo—il che la rende una macro interessante da esplorare in un certo dettaglio. ### Alcune nozioni di base: espressioni e assegnazioni Un elemento importante di `\foo`del codice è il suo uso del comando `\numexpr`, un comando di un insieme di quattro primitivi correlati introdotti per la prima volta da $$\varepsilon\mathrm{\text{-}{\TeX}}$$: `\numexpr`, `\dimexpr`, `\glueexpr` e `\muexpr`. Il loro scopo è costruire le cosiddette *espressioni* che consentono il calcolo/la manipolazione di valori TeX di tipo number, dimen, glue o muglue (rispettivamente). Come discusso alle pagine 8–9 del $$\varepsilon\mathrm{\text{-}{\TeX}}$$ Manuale, una caratteristica importante di *espressioni* è che la loro valutazione (calcolo) non richiede che TeX esegua alcuna *assegnazione*. In termini di programmazione, l'assegnazione è il processo di impostare (assegnare) a una variabile un determinato valore; per esempio, assegnare `\count` registro `99` a contenere il valore `12345` tramite `\count99=12345`. Durante l'elaborazione di TeX avvengono molti altri tipi di assegnazione—come assegnare ai registri di token una serie di token, assegnare ai registri di box il contenuto di una box, e così via. Per eseguire un'assegnazione, come `\count99=12345`, TeX deve attivare (eseguire) il codice interno che implementa il comportamento di `\count` o di qualsiasi altro primitivo che esegua qualche tipo di assegnazione. Tuttavia, ci sono momenti in cui TeX sta eseguendo una pura *espansione* e, in quei momenti, tali assegnazioni non vengono eseguite—*a quel punto nell'elaborazione di TeX*. Esempi di questa situazione includono i seguenti comandi: * `\edef\command {*token list*}` il comando di definizione di macro “expanded definition” che espande i token nella *lista di token* e memorizza i risultati come definizione di `\command`. * `\write *number* {*token list*}` espande i token nella `*token list*` e li scrive in un file rappresentato da `*number*`. * `\directlua {*token list*}` questo comando primitivo di LuaTeX viene usato per passare codice Lua all'interprete Lua integrato. Tutti i token in `*token list*` vengono completamente espansi prima di essere passati all'interprete Lua per l'esecuzione. #### Breve esempio di \edef Se scriviamo le seguenti macro di base: ``` \def\mycount{\count99=12345} \edef\mymacro{\mycount} ``` `\edef` espanderà `\mycount` nei suoi token costitutivi, ma non va oltre: nessuno dei comandi contenuti nella definizione di `\mymacro` verrà eseguito: cioè, l'assegnazione di `12345` su `\count99` *non avviene a questo punto*; solo quando invochiamo `\mymacro` avverrà tale assegnazione mentre TeX esegue il codice per elaborare il `\count` primitivo. Quando TeX esegue attività di *sola espansione* eventuali assegnazioni verranno eseguite più tardi nell'elaborazione di TeX, non durante il processo di espansione stesso. #### Perché qui le assegnazioni sono importanti? Quando si scrive codice per eseguire un ciclo—in qualsiasi linguaggio di programmazione—è pratica comune avere una variabile designata a fungere da “contatore del ciclo”: usata per controllare quante volte un ciclo viene eseguito. Il ciclo è in genere controllato verificando se quella variabile contatore ha raggiunto un certo valore—tale variabile viene incrementata (o decrementata) a ogni iterazione del ciclo. Tuttavia, modificare una variabile contatore significa assegnarle un nuovo valore il che, per TeX, di solito richiede il comando primitivo `\advance` per incrementare (o decrementare) un valore memorizzato in un `\count` registro. Come abbiamo visto, durante il puro processo di espansione di TeX tali assegnazioni (incluso l'incremento di variabili) non possono avvenire: la macro `\foo` aggira abilmente questa limitazione. ### Torniamo a spiegare \foo La macro `\foo` è in grado di controllare il processo di ciclo *senza* senza dover assegnare valori ad alcuna variabile: controlla quante volte il ciclo ha luogo usando dati derivanti dall'espansione: valori di dati memorizzati in liste temporanee di token. Usando la nostra conoscenza dell'uso (creazione) da parte di TeX di liste temporanee di token possiamo dare un'occhiata più da vicino per vedere esattamente come `\foo` ottiene i suoi risultati. **Ricorda**: Stiamo esaminando l'esecuzione di una macro dopo che il testo originale della sua definizione—contenuto in un `.tex` file fisico—è stato scansionato (letto da TeX) e convertito in una lista di token che rappresenta la definizione della macro. In sostanza, stiamo seguendo l'elaborazione da parte di TeX di quei token memorizzati *token* mentre legge ed elabora i token nella definizione della macro contenuta da qualche parte nella memoria di TeX. Eventuali caratteri di spazio originariamente presenti nel codice TeX della definizione della macro (testo all'interno del `.tex` file) saranno stati assorbiti mentre TeX scansionava quel testo alla ricerca di comandi (gli spazi come terminatori), oppure saranno stati convertiti in token, come il carattere di spazio dopo la virgola (`,`) in `\ifnum#1<#2,` che è derivato dalla conversione del carattere di fine riga (`\r`) in uno spazio. Poiché il codice TeX in `\foo` usa più `\\expandafter` comandi, aiuteremo la nostra spiegazione aggiungendo pedici a ciascun `\\expandafter`, indicando a quale ci stiamo riferendo. Inoltre, estenderemo la notazione per i token elaborati da `\\expandafter` su $$\mathrm{T^i\_1}$$ e $$\mathrm{T^i\_2}$$, rappresentando i token $$\mathrm{T\_1}$$ e $$\mathrm{T\_2}$$ per `\expandafteri`: `\expandafteri` $$\mathrm{T^i\_1T^i\_2}$$ Ecco il codice della macro annotato: ``` \def\foo#1#2{\number#1 \ifnum#1<#2, \expandafter1\foo \expandafter2{\number\numexpr#1+1\expandafter3}% \expandafter4{\number#2\expandafter5}% \fi} ``` `\foo` inizia con `\number#1` che usa il comando espandibile `\number` per convertire il valore del primo argomento nella sua rappresentazione tipografica. Il `\number` comando funziona generando una lista temporanea di token contenente token di carattere che rappresentano le singole cifre contenute nel valore numerico su cui `\number` sta operando. Quella lista di token diventa la successiva sorgente di input di TeX. Qui, quella lista di token viene letta e i token vengono emessi per comporre tipograficamente il valore di `#1`. Successivamente, la macro esegue il test `\ifnum#1<#2` per verificare se l'argomento per `#1` è minore dell'argomento passato per `#2`. Se sì, una virgola (`,`) viene emesso (composizione tipografica), seguito da uno spazio generato dal token prodotto dal carattere di a capo dopo la virgola (`,`). Quel carattere di spazio è stato generato per la prima volta quando TeX ha letto questa riga dal `.tex` file. La macro continua elaborando la seguente sezione di codice, che è il cuore del suo funzionamento: ``` \expandafter1\foo \expandafter2{\number\numexpr#1+1\expandafter3}% \expandafter4{\number#2\expandafter5}% \fi} ``` In sostanza, questo codice genera una serie di liste temporanee di token che danno luogo a chiamate multiple della `\foo` macro, terminando quando il test if `\ifnum#1<#2` non è più vero. Ma *come* il ciclo è controllato perché non vengono eseguite assegnazioni: dov'è il “contatore del ciclo”? Iniziamo osservando il codice `\expandafter1\foo\expandafter2`. Si noti che useremo la notazione con pedice `token` (o `(token)`) per ricordarci che, qui, TeX sta leggendo/elaborando valori di token numerici (interi). Qui abbiamo i seguenti token come input per `\expandafter1`: * $$\mathrm{T^1\_1} =$$`\footoken` che viene letto e memorizzato per un uso successivo *reinserimento* nell'input * $$\mathrm{T^1\_2} =$$`\expandafter2 (token)` che viene espanso Per `\expandafter2` abbiamo: * $$\mathrm{T^2\_1} =$$`{token` che viene salvato per un successivo *reinserimento* nell'input * $$\mathrm{T^2\_2} =$$ `\numbertoken` che viene espanso **Nota:**`\number` è un comando espandibile il cui scopo è “convertire in token”: cioè, convertire una quantità numerica in una serie di token di carattere che rappresentano tale quantità. Quando `\number` viene espanso, la prima cosa che TeX fa è scansionare l'input alla ricerca di interi: un processo che innesca ulteriore espansione. **La chiave della storia:** Qui, `\number` sta agendo sull' *espressione* `\numexpr#1+1` che calcola il valore di `#1+1`. Il risultato di quel calcolo viene elaborato da `\number` per convertirlo in una lista temporanea di token contenente token di carattere che rappresentano il valore di `#1 + 1`. Quella lista temporanea di token, generata da `\number`, verrà infine letta come primo argomento di un'altra chiamata di `\foo`. Anziché incrementare un contatore del ciclo (tramite `\advance` e assegnazione), l'uso di `\numexpr` crea un nuovo valore senza che sia necessaria alcuna assegnazione. Attraverso questo meccanismo, la variabile che controlla il ciclo (`\foo`parametro di `#1`) viene incrementata e l'iterazione attraverso il ciclo è controllata e terminata: davvero ingegnoso! Successivamente, `\expandafter3` viene elaborato, producendo: * $$\mathrm{T^3\_1} =$$`}token` che viene salvato per un successivo *reinserimento* nell'input * $$\mathrm{T^3\_2} =$$`\expandafter4 (token)`, che viene espanso: Per `\expandafter4` abbiamo: * $$\mathrm{T^4\_1} =$$`{token` che viene salvato per un successivo *reinserimento* nell'input * $$\mathrm{T^4\_2} =$$`\numbertoken` che viene espanso e converte `#2` in un'altra lista temporanea di token. Infine,`\expandafter5` viene espanso: * $$\mathrm{T^5\_1} =$$`}token` che viene salvato per un successivo *reinserimento* nell'input * $$\mathrm{T^5\_2} =$$`\fitoken`, che è un comando espandibile. L'espansione di `\fi` termina di fatto il `\ifnum` e, di fatto, chiude questa iterazione della macro. TeX ora completa la reinserzione di tutti i token temporaneamente salvati dai molteplici `\\expandafter` comandi: ciò genera una serie di liste di token a singolo token derivanti dai token salvati da ciascun `\\expandafter`. Inoltre TeX ha anche creato liste di token da attraverso l'azione di `\number`. ### Assemblare le liste di token In sostanza, la `\foo` macro genera una sequenza di liste di token: puoi pensare a `\foo` come a una “fabbrica” di liste di token. Quelle liste di token vengono lette da TeX per diventare le successive sorgenti di input. La parte ingegnosa è contenuta in una delle azioni precedenti di `\foo`: ``` \expandafter1\foo\expandafter2 ``` attraverso cui `\foo` fa in modo di richiamarsi di nuovo ma con argomenti diversi che sono memorizzati in liste di token costruite da `\number`. Per far sì che queste liste di token si comportino complessivamente come una chiamata di macro, le parentesi graffe `{` e `}` sono state tutte salvate e reinserite nell'input (come liste a token singolo) dalle azioni dei `\\expandafter` comandi. ![liste di token generate dalla macro \foo](/files/8c6ce450a3b13771e757a1119fbc6f212e0ca55c) [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/17-how-does-expandafter-work-a-detailed-macro-case-study.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.