> 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/altri-argomenti/23-how-tex-macros-actually-work-part-5.md). # Come funzionano davvero le macro TeX: Parte 5 [Parte 1](/latex/it/altri-argomenti/19-how-tex-macros-actually-work-part-1.md) [Parte 2](/latex/it/altri-argomenti/20-how-tex-macros-actually-work-part-2.md) [Parte 3](/latex/it/altri-argomenti/21-how-tex-macros-actually-work-part-3.md) [Parte 4](/latex/it/altri-argomenti/22-how-tex-macros-actually-work-part-4.md) [Parte 5](/latex/it/altri-argomenti/23-how-tex-macros-actually-work-part-5.md) [Parte 6](/latex/it/altri-argomenti/24-how-tex-macros-actually-work-part-6.md) ## Introduzione e panoramica Nella Parte 4 abbiamo esaminato alcune proprietà di base delle macro TeX in preparazione ai due articoli successivi, in cui diamo uno sguardo da vicino ai meccanismi sottostanti delle macro TeX: le liste di token specializzate. In questi due articoli finali usiamo diagrammi, chiamati liste di nodi, preparati a partire da dati generati usando una versione appositamente modificata del software TeX originale di Knuth—tali modifiche erano pensate per accedere alle strutture dati interne di TeX, normalmente inaccessibili all'utente. “Agganciandoci” alle routine interne di elaborazione ed esecuzione delle macro di TeX è stato possibile scrivere dati grafici che consentono una discussione più dettagliata e accurata del comportamento di elaborazione delle macro di TeX. Overleaf spera che questi diagrammi aiutino i lettori a comprendere meglio come funzionano davvero le macro di TeX. ### Ulteriori letture di approfondimento possibili Overleaf ha già pubblicato due articoli relativi ai token che forniscono ulteriori informazioni di base sui token TeX e sulle liste di token TeX. Ti invitiamo a prenderli in considerazione se hai bisogno di colmare eventuali lacune nella tua comprensione e di trarre il massimo dalle Parti 5 e 6 di questa serie. * [Che cos'è un "token TeX"?](/latex/it/articoli-approfonditi/53-what-is-a-tex-token.md) * [Che cos'è una lista di token TeX?](/latex/it/articoli-approfonditi/54-what-is-a-tex-token-list.md) ## Macro come liste di token Quando TeX rileva un comando di creazione di macro (`\def`, `\edef`, `\gdef` o `\xdef`) nel flusso di input attiva un processo che converte entrambe le sezioni `` della definizione della nostra macro in un'unica lunga lista di token, ma di un tipo molto particolare di lista di token. Le liste di token delle macro sono leggermente diverse dalle altre liste di token usate all'interno di TeX perché contengono valori di token “speciali” che solo processi interni a TeX stesso possono creare/generare: quei token speciali non possono essere creati direttamente da alcun comando che puoi includere nel tuo file .tex. TeX crea e usa quei valori di token “speciali” per aiutare nell'elaborazione della chiamata alla macro, come esploreremo e spiegheremo di seguito. ### Una breve nota su come sono memorizzate le liste di token: i nodi Per memorizzare una lista di token (valori interi) TeX usa una struttura dati chiamata [lista concatenata](https://en.wikipedia.org/wiki/Linked_list), che, nel caso di TeX, è composta da un elenco di cosiddetti *nodi*. Puoi pensare a un nodo come a un piccolo pacchetto di memoria del computer che può essere usato per memorizzare una raccolta di elementi di dati. Per memorizzare una macro, questi nodi sono collegati tra loro come una catena, in cui ciascun nodo (anello della catena) può memorizzare diversi elementi di informazione—incluso un valore di token e l'indirizzo di memoria del nodo successivo nella lista. Per ulteriori informazioni, puoi leggere l'articolo [Che cos'è una lista di token TeX](/latex/it/articoli-approfonditi/54-what-is-a-tex-token-list.md) ma il diagramma seguente riassume le caratteristiche principali di una macro memorizzata come lista di token: ![Diagramma di una lista di token di una macro TeX memorizzata come lista di nodi concatenati](/files/0734cfddcafd7c9acd4c43531e03f762d476d985) ### Promemoria: le 4 parti di una definizione di macro Come discusso nella Parte 4, la struttura di qualsiasi macro può essere scritta come: ``` {} ``` dove: * `` = uno tra `\def`, `\edef`, `\gdef` o `\xdef`; * ``= il nome della tua macro, ad esempio `\foo`; * `` può essere “null” (non presente) oppure può essere una stringa di token delimitatori e token di parametro della macro; * `` è il corpo effettivo della tua macro: la sezione che viene “eseguita” quando richiami la macro. **NOTA**: (Come osservato anche nella Parte 4) durante tutta la discussione assumiamo che `` sarà seguito da un carattere spazio con codice di categoria 10 per fungere da delimitatore e terminare il ``. *non abbiamo* mostrato esplicitamente quel carattere spazio nel nostro testo/discussione, ma assumiamo che sia presente. In senso stretto, dovremmo rappresentarlo più o meno così: ``` {} ``` Tuttavia, ometteremo l'inclusione esplicita di un `` carattere e ne assumeremo implicitamente la presenza. **NOTA**: I caratteri `{` e `}` *non* entrano a far parte della lista di token della macro: il loro scopo è semplicemente indicare allo scanner di input di TeX (che crea i token) dove `` inizia e finisce. Quando TeX definisce una macro, le sezioni `` vengono convertite in un'unica lunga lista continua di token — il numero totale di token in quella lista dipende dalla complessità della macro. Come abbiamo visto, la sezione ha lo scopo specifico di fungere da “modello di token” o “progetto” che TeX usa per individuare i token che formano gli argomenti (valori) da usare con la macro effettiva: cioè, i token da inserire nel ``. Per consolidare queste idee, prendiamo una macro di esempio ma teniamola breve, così che i diagrammi successivi non diventino troppo affollati: ``` \def\foo A#1\fake{123 #1} ``` Per la nostra macro, `\foo` * `` = `A#1\fake` * `` = `123 #1` Sebbene questo esempio sia una macro semplice, contiene tutte le caratteristiche che dobbiamo esplorare. Come notato, TeX convertirà `` in un'unica lunga lista di token che puoi vedere nel diagramma qui sotto. Nel nostro esempio, i token formati da `A#1\fake{123 #1}` sono stati convertiti in una sequenza consecutiva di token memorizzata in una lista di token (come lista concatenata di nodi). ## Grafico che mostra una vera lista di token di macro Il diagramma seguente, che mostra come la macro `\def\foo A#1\fake{123 #1}` è memorizzata, usa dati reali provenienti dall'interno di un motore TeX. È stato creato usando una [versione personalizzata del TeX di Knuth](/latex/it/articoli-approfonditi/01-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how.md#how-can-you-study-tex-tokens3f) che è stata modificata con codice aggiuntivo per intercettare le chiamate alle macro, esaminare i dati interni di TeX ed esportarli in un formato da elaborare usando un programma grafico open source chiamato [Graphviz](https://www.graphviz.org/). Puoi scaricare il seguente grafico come [file PDF](https://assets.ctfassets.net/nrgyaltdicpt/N6gT757eXCxRV3FtdPPga/7ce120dc05ed05962bb911ff1124734b/annotatednodelist-plain.pdf) (675 KB) oppure [file SVG](https://images.ctfassets.net/nrgyaltdicpt/4PkmtHDhO8KF892ZDWuLHP/2c9c8385c6948fd122b228c5c780a3a6/annotatednodelist-plain.svg) (1,8 MB). ![Diagramma di una lista di token TeX annotata](/files/5e4b31c37f2f14cad6008987c2b848283118f7a3) #### Comprendere i nodi Nel diagramma sopra vedrai che ogni nodo contiene due elementi di dati chiamati **nodo successivo** e il **nodo corrente**. Si tratta solo di valori interi che rappresentano posizioni di memoria all'interno di TeX — posizioni in cui sono memorizzati altri nodi. I valori di **nodo successivo** e **nodo corrente** non sono importanti; memorizzano semplicemente le posizioni (indirizzi di memoria) che permettono di collegare i nodi tra loro in una lista. ![Il significato di nodo successivo e nodo corrente](/files/52a590464129b56638170d0e72f32a7f7c932cbe) #### Torniamo all'esempio Nel diagramma dei nodi, la lista di token formata da `A#1\fake{123 #1}` contiene diversi “token speciali” introdotti all'inizio di questo articolo. Inoltre, la lista di nodi che rappresenta la nostra macro inizia con un “primo nodo speciale”: esploreremo cosa sono e a cosa servono. Il primissimo elemento in una lista di token di macro (e in alcuni altri tipi di liste di token) non memorizza un valore di token, ma un elemento di dati chiamato *conteggio dei riferimenti* che TeX usa per tenere traccia dell'uso della macro. ![Un nodo di conteggio dei riferimenti è il primo in una lista di token](/files/54454c52e97e8ebf7a22fd73d98fb567094bfdae) Il primo token del `` è memorizzato nel nodo che segue immediatamente il conteggio dei riferimenti: puoi vedere che è un token che rappresenta la lettera `Un` con codice di categoria 11. Dalle discussioni nelle Parti 2 e 3 sappiamo che un token di carattere viene calcolato usando $$\text{token value}=256\times \text{category code} + \text{character code}$$ che, per una lettera `Un` con codice di categoria 11, è $$\text{token value}=256\times 11 + 65$$ dando il valore 2881, come mostrato nel nodo. #### Il “comando” \fake usato in \foo All'interno della nostra definizione di macro `\def\foo A#1\fake{123 #1}` uno dei delimitatori è un *non definito* comando `\fake` che è memorizzato all'interno della lista di token come parte della `` sezione. Come puoi vedere, all'interno della lista complessiva di token della macro `\fake` c'è un token il cui valore è `19491`—un valore intero calcolato da TeX usando la formula discussa nella Parte 3. Quando TeX tenta di eseguire `\foo` si aspetterà di trovare il `\fake` valore del token alla fine della `` sezione. TeX *non* cercherà di eseguire il `\fake` comando perché il suo ruolo è semplicemente quello di fornire una sorta di “punteggiatura” all'interno del `` “modello di token”. ![Usare un token di comando come delimitatore di macro](/files/1476e5e4370055eadaf2833aa7e6c77eb102aeaf) #### Token speciali nella lista di token **Il token di “fine corrispondenza”** Quando si richiama una macro, il primo compito di TeX è analizzare la macro così come digitata dall'utente e confrontare i token presenti nella `` sezione dell'utente con i token contenuti nel modello `` memorizzato in memoria (creato nel momento in cui la macro è stata definita). Poiché la definizione completa della macro, costruita a partire da `` è memorizzata come un'unica lunga lista consecutiva di token, TeX deve sapere dove, in quella lista di token, `` *termina* e dove `` *inizia*. **fine corrispondenza** token come ultimo token assoluto nell'insieme di token generati da ``. Il **fine corrispondenza** il token non può essere generato dai comandi dell'utente, solo TeX stesso può crearlo; pertanto TeX è certo di rilevare la fine del ``. ![Visualizzazione del token di fine corrispondenza in una lista di token TeX](/files/b4ec48c1cf74daeb8100fbc5c3149b178184815c) Qui possiamo vedere che il primo token che segue **fine corrispondenza** è un token che rappresenta la cifra `1` con codice di categoria 12. Questo è atteso perché il `` per la nostra macro `\foo` è `123 #1`—cioè, inizia con il token che rappresenta la cifra `1` (con codice di categoria 12). Dalla discussione nelle Parti 2 e 3 sappiamo che un token di carattere viene calcolato usando $$\text{token value}=256\times \text{category code} + \text{character code}$$ che, per una cifra `1` con codice di categoria 12, è $$\text{token value}=256\times 12 + 49$$ dando il valore del token 3121, come mostrato nel nodo. **token di “parametro di corrispondenza”** Quando TeX memorizza la definizione della macro, converte eventuali token di parametro (`#1`, `#2`… `#9`) `` in uno chiamato **parametro di corrispondenza** token. Questi token indicano a TeX che deve iniziare a cercare, all'interno della chiamata alla macro da parte dell'utente, i token che sono gli argomenti della macro. ![Visualizzazione del token di parametro di corrispondenza in una lista di token TeX](/files/bc14a099afe9f266dcaa63335016f9337b772b0e) ### Token speciali nella lista di token #### token di “parametro di output” Quando TeX ha elaborato tutto ed è pronto a eseguire davvero (espandere) la macro, i **parametro di output** token indicano a TeX le posizioni all'interno della `` in cui deve inserire i token che rappresentano gli argomenti forniti dall'utente quando la macro è stata richiamata. In pratica, “In questa posizione, inserisci i token che rappresentano l'argomento n dell'utente, dove n=1...9”. All'interno della `` sezione della lista di token della definizione di macro memorizzata ci sarà un **parametro di output** token corrispondente a ciascun `#1`, `#2`... `#9` presente nella definizione originale. ![Visualizzazione del token di parametro di output in una lista di token TeX](/files/e64389d0e377d69763b7de5e8b4a25a687658f47) Se guardiamo la nostra definizione di `\foo` (`\def\foo A#1\fake{123 #1}`) vediamo che c'è solo 1 parametro di macro (`#1`) nei file `` (`A#1\fake`) e di conseguenza compare solo 1 parametro di macro (`#1`) appare nella `` (`123 #1`): questo si traduce in un solo **parametro di output** token presente nella lista di token che rappresenta la ``. Osserva quanto segue nella lista di nodi che rappresenta `\foo`di ``: * il token immediatamente precedente al **parametro di output** token rappresenta un carattere spazio (codice di categoria 10, codice carattere 32) perché c'è uno spazio tra il `123` e il parametro della macro (`#1`) nella definizione originale di `\foo`; * il **parametro di output** è l'ultimo token nella lista: il **nodo successivo** ha un valore speciale di “null” (che significa “vuoto”) usato per terminare la lista: non ci sono più nodi dopo **parametro di output** perché è il token finale, che indica la fine del `` e quindi la fine della definizione della macro. ## Parte 6 Nella Parte 6 usiamo alcuni grafici dettagliati per spiegare ed esplorare il significato esatto dell'espansione delle macro e le conseguenze della tokenizzazione da parte di TeX degli argomenti delle macro prima di inserirli nel ``. [Parte 1](/latex/it/altri-argomenti/19-how-tex-macros-actually-work-part-1.md) [Parte 2](/latex/it/altri-argomenti/20-how-tex-macros-actually-work-part-2.md) [Parte 3](/latex/it/altri-argomenti/21-how-tex-macros-actually-work-part-3.md) [Parte 4](/latex/it/altri-argomenti/22-how-tex-macros-actually-work-part-4.md) [Parte 5](/latex/it/altri-argomenti/23-how-tex-macros-actually-work-part-5.md) [Parte 6](/latex/it/altri-argomenti/24-how-tex-macros-actually-work-part-6.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/altri-argomenti/23-how-tex-macros-actually-work-part-5.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.