> 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/22-how-tex-macros-actually-work-part-4.md). # Come funzionano davvero le macro TeX: Parte 4 [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 Nei Parti 1–3 abbiamo fatto un’analisi approfondita di alcuni dettagli di background di basso livello, in preparazione alla comprensione del funzionamento delle macro di TeX. In questo articolo andremo a “prendere una boccata d’aria” per rivedere alcuni principi pratici di base delle macro di TeX in vista di un’altra analisi approfondita nelle Parti 5 e 6. In tutto questo articolo mostreremo esempi di macro definite usando il comando primitivo di TeX `\def`: non useremo il comando LaTeX, forse più familiare, `\newcommand`. C’è una buona ragione per questo: il nostro obiettivo è comprendere i principi fondamentali alla base del comportamento delle macro di TeX, ma per farlo dobbiamo usare i comandi di base *incorporati nel* software TeX. I comandi LaTeX, come `\newcommand`, sono essi stessi macro: comandi con un comportamento programmato specifico che, in ultima analisi, sono costruiti da livelli di comandi primitivi di TeX di livello inferiore. Per comprendere meglio il comportamento fondamentale di TeX dobbiamo usare i primitivi di TeX, non le macro LaTeX. ### Dove stiamo andando? In sostanza, stiamo lavorando verso una spiegazione delle macro come forma specializzata di lista di token: quando istruisci TeX a definire una macro, crea una sequenza di token (una lista di token) e la memorizza nella sua memoria associandola a un nome che definisci. Nelle Parti 5 e 6 esamineremo le liste di token delle macro in un certo dettaglio, ma se preferisci passare da questo articolo a leggere alcune informazioni di base puoi trovarle in [Che cos'è una lista di token di TeX?](/latex/it/articoli-approfonditi/54-what-is-a-tex-token-list.md) Le liste di token per le macro, e i loro parametri, incorporano alcuni ulteriori aspetti che esamineremo in dettaglio—e usando molti esempi. Per comprendere meglio i comportamenti di elaborazione delle macro di TeX c’è davvero un fattore chiave da ricordare: TeX pensa solo ai caratteri nella fase più iniziale dell’elaborazione dell’input: da quel punto in poi sono tutti token! In questo, e nei restanti articoli di questa serie, esploreremo il ruolo che i token svolgono nelle macro di TeX. ## Le quattro parti di una macro ### Promemoria: parametri della macro e argomenti della macro Prima di iniziare vale la pena ricordare la differenza tra i *parametri* di una macro e gli *argomenti*, perché useremo entrambi i termini in tutto questo articolo. Supponiamo che tu definisca una macro \foo ``` \def\foo#1#2{Questo è #1, questo è #2} ``` Le strutture (token) `#1`, `#2` (fino a `#9`) sono chiamate *parametri*: pensali come “segnaposto” per i dati effettivi che userai quando richiami la macro: ``` \foo{alpha}{beta} ``` Qui, `alpha` e `beta` sono i *argomenti* utilizzati con questa chiamata di \foo: gli argomenti di una macro sono i valori effettivi immessi nei segnaposto dei parametri (`#1`, `#2`... `#9`) usati quando hai definito la macro. ### Definizione di macro: ha 4 elementi Inizieremo con quello che, forse, sembra una definizione di macro leggermente formale, ma fornisce una cornice utile per ulteriori discussioni. Qualsiasi definizione di macro è composta da 4 parti: ``` {} ``` dove: * ``: uno di `\def`, `\edef`, `\gdef` o `\xdef`; * ``: il nome assegnato al tuo comando macro, come `\foo`; * ``: questo può essere assente, ma, se è presente, è una serie di *token* che compaiono prima del `` testo di sostituzione della macro. Il `` può contenere parametri della macro (`#1`, `#2`... `#9`) e altri tipi di token. In sostanza, e come vedremo in dettaglio, il `` fornisce una sorta di *modello di token* che TeX usa per capire quali token l’utente vuole usare come argomenti della macro: quando richiami una macro, TeX inserisce i *argomento* token nella tua macro `` (che è anch’essa una lista di token); * `{}`: questo è il corpo effettivo della tua macro: è una sequenza di token in cui gli *argomenti* vengono “iniettati” quando la macro viene elaborata (espansa). Gli argomenti vengono inseriti nelle posizioni indicate dai parametri della macro usati nella definizione originale. **NOTA**: In tutta la discussione stiamo assumendo che `` sia 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. A rigor di termini, dovremmo rappresentarlo qualcosa del genere: ``` {} ``` Tuttavia, ometteremo l’inclusione esplicita di un carattere `` e ne assumeremo implicitamente la presenza. #### Note su {} Abbiamo mostrato l’uso di due parentesi graffe: `{` e `}` che racchiudono (delimitano) il corpo effettivo del testo di sostituzione della tua ``. Tuttavia, l’uso di `{` e `}` è solo una convenzione adottata perché ciò che TeX in realtà si aspetta è il testo della tua macro `` inizi con un carattere di codice di categoria 1 (“Inizio di un gruppo”) e termini con un carattere di codice di categoria 2 (“Fine di un gruppo”). Per convenzione, questi sono i `{` e `}` caratteri rispettivamente. Tuttavia, puoi, se vuoi, assegnare a qualsiasi coppia di caratteri questo ruolo. Per esempio ``` \catcode`\(=1 \catcode`\)=2 ``` Ora, puoi definire e usare macro in questo modo: ``` \def\foo #1(Hello, #1) \foo(World!) ``` E puoi ancora usare `{` e `}` perché non ne abbiamo cambiato i codici di categoria—più caratteri possono avere, e hanno, lo stesso codice di categoria, quindi potresti continuare a definire macro nel modo consueto: ``` \def\foo #1{Ciao, #1} \foo{Mondo!} ``` ### e {} Le componenti della definizione di una macro più rilevanti per la nostra discussione sono `` e `{}`. Quando definisci una macro il `` è, di fatto, un rigoroso modello di token che definisce come la macro deve essere usata. Come notato, `` può essere vuoto, ad es., `\def\foo{Qualche testo}` dove non compare nulla tra il nome del comando (`\foo`) e la parentesi graffa di apertura `{` che, qui, segnala l’inizio del ``. **Nota**Alcuni lettori potrebbero conoscere il meccanismo “hashquote” di TeX (`#{`) ma non lo tratteremo qui. ### e delimitatori delle macro Questo particolare articolo non è pensato come una rassegna esaustiva della scrittura di macro, ma vale la pena fare un breve ripasso, con alcuni esempi, mostrando che il `` può diventare complesso perché TeX consente `` di contenere: * **parametri della macro**: (`#1`, `#2`,... `#9`) che agiscono come “segnaposto” per i valori che l’utente fornirà quando esegue la macro—gli *argomenti*; * **token delimitatori**: token arbitrari, interposti nei/dintorni dei token dei parametri, e usati per specificare il confine tra i parametri della macro. Puoi pensare a quei delimitatori come a una sorta di “punteggiatura” che rende il `` un “modello di token” che dovrai seguire quando usi la macro. I token delimitatori non vengono stampati. Quindi cosa significa davvero questo—vediamo alcuni esempi. Il `` si trova tra il nome della macro e la parentesi graffa sinistra `{` della definizione della macro. #### Delimitatori: Esempio 1 Supponiamo di definire una macro di base `\foo` come segue: ``` \def\foo ABC{ciao, là} ``` * `` = `ABC` * Non ci sono token di parametro (`#1`, `#2`,... `#9`) * I delimitatori sono i *tre token di carattere* `ABC` ma, in questo esempio, sono in qualche modo superflui e usati solo come esempio. I tre token di carattere `ABC` sono trattati come delimitatori: non qualcosa da stampare ma “punteggiatura” che ci si aspetta sia presente quando la macro viene richiamata—quando usi la macro `\foo` devi fornire gli stessi delimitatori che erano presenti quando è stata definita. Se digiti `\foo ABC` nel tuo testo questo stamperà `ciao, là`—i token di carattere `ABC` non vengono stampati ma TeX ha, con molta attenzione, controllato che fossero presenti nella tua invocazione (chiamata) di `\foo`. TeX cerca quei delimitatori (“punteggiatura”) e li rimuove (assorbe) come puoi vedere nella seguente immagine dello schermo di Overleaf: `ABC` non viene stampato: ![Overleaf che esegue una macro TeX](/files/552edaa65d4241504b8d55c82337d35f239d72d9) Se provi a usare `\foo` senza i delimitatori `ABC` TeX si lamenterà `L’uso di \foo non corrisponde alla sua definizione.`: ![Mostra un errore TeX su Overleaf](/files/9c9f7a163e37f6ea6272d2f7e7f7d5ccf0304b02) Nell’esempio sopra, dopo aver rilevato `\foo` TeX si aspetta di vedere i tre token di carattere `ABC` ma non li vede: vede il token di carattere per `w` e rileva immediatamente che qualcosa non va. #### Delimitatori: Esempio 2 Un fatto interessante, e forse sorprendente, è che i delimitatori possono essere token di comando arbitrari—compresi comandi che non sono *nemmeno stati definiti*. Per esempio, potremmo definire `\foo` come: ``` \def\foo A\bob B\anne{Ciao \TeX{}} ``` * `` = `A\bob B\anne` * Non ci sono token di parametro (`#1`, `#2`,... `#9`) * I delimitatori sono i token `A\bob B\anne` ma anche in questo esempio sono superflui e servono solo a scopo di discussione. Nota che `\bob` e `\anne` sono comandi fittizi che erano *non definiti*—e non è necessario che lo siano. Quando richiami una macro, TeX controlla (scansiona) i `` che è presente *nella tua chiamata della macro* e lo confronta, token per token, con la versione “modello di token” *memorizzata nella memoria*—quella creata al momento in cui la macro è stata definita. TeX scansiona i *usati nella tua chiamata della macro* e converte semplicemente in valore numerico di token qualsiasi comando vi trovi: non sta cercando di eseguire quei comandi, quindi non importa che `\bob` e `\anne` non siano mai stati definiti. TeX sta semplicemente usando il modello di token memorizzato nella memoria come guida che gli permette di capire quali token nel `` della tua chiamata della macro sono gli argomenti effettivi da inserire nel ``. Come puoi vedere dal seguente frammento di schermo di Overleaf, nessuno dei token di carattere (`Un'` e `B`) all’interno di `A\bob B\anne` è stato stampato e i nostri comandi non definiti `\bob` e `\anne` non hanno causato alcun problema. Tutti questi token sono stati *assorbiti* da TeX mentre confrontava il tuo uso di `\foo` con la definizione (modello di token) di `\foo` (una lista di token) memorizzata nella memoria. ![Overleaf che esegue una macro TeX](/files/113f4428757556144a16551e2ed943110dae8806) #### Delimitatori: Esempio 3 Puoi intercalare vari delimitatori (token di carattere, token di comando) con parametri della macro, come in questo esempio: ``` \def\foo A\bob#1B\anne#2\jane#3ciao!{Ciao da \TeX{} a \#1=#1, \#2=#2 e \#3=#3} ``` * `` = `A\bob#1B\anne#2\jane#3ciao!` * Ci sono 3 token parametro della macro: `#1`, `#2`, `#3` * Questa volta, i parametri (`#1`, `#2`, `#3`) sono delimitati da una combinazione di token: `A\bob#1B\anne#2\jane#3ciao!` Qui, hai di fatto fornito a TeX un modello che cercherà molto attentamente di corrispondere e che si aspetterà di trovare quando richiami `\foo`: attraverserà la tua chiamata di macro, *token per token*, e si aspetterà di trovare (individuare): * i due token `Un'` e `\bob` prima `#1` * i due token `B` e `\anne` prima `#2` * il token `\jane` prima del parametro `#3` e il *quattro token di carattere* `b`, `y`,`e` e `!` dopo `#3`. **Ricorda**: TeX pensa in termini di token quindi `ciao!` è *quattro token di carattere*. Ci sono due modi in cui possiamo usare questa macro—potremmo mettere tra parentesi graffe eventuali argomenti composti da più token per fornire un gruppo: ``` \foo A\bob{Questo}B\anne{Quello}\jane{Altro}ciao! ``` Tuttavia, questo *non è necessario* perché la definizione della nostra macro ha dei delimitatori che forniscono un modello di token. TeX può usare quel modello per individuare i token di ciascun argomento tra token che sono puramente delimitatori. Possiamo usare la nostra macro così: ``` \foo A\bob QuestoB\anne Quello\jane Altrociao! ``` e TeX può individuare gli argomenti per produrre lo stesso risultato dell’uso dei gruppi `{...}`: ![Overleaf che esegue una macro TeX usando delimitatori](/files/67ce9e5c122d230b42806a52a73c336a5c13c2c7) Nota come TeX sia stato in grado di rilevare, con precisione, quali token corrispondevano ai parametri `#1` e `#3`: ![Overleaf che esegue una macro TeX usando delimitatori](/files/39eb4a3637ea98f35553607db4e66d1289547c3d) #### Delimitatori: Esempio 4 (è tutta una questione di token, non di caratteri!) Ecco un breve esempio per dimostrare che, quando si lavora con le macro, è importante ricordare che siamo davvero nel mondo dei *token* e **non** *caratteri*… Definiremo la seguente breve macro in cui A e B sono caratteri che agiscono da delimitatori ed entrambi hanno codice di categoria 11. Questo funziona senza problemi: ``` \documentclass{article} \begin{document} \def\foo A#1B{Ciao, #1} \foo AGrahamB \end{document} ``` e stampa `Ciao, Graham`. Tuttavia, se cambi il codice di categoria di A o B in qualcosa di diverso da 11, la chiamata della macro fallirà. Supponiamo di cambiare il codice di categoria di B in 12, usando ``\catcode`B=12`` e proviamo a richiamare di nuovo la macro, come prima: ``` \documentclass{article} \begin{document} \def\foo A#1B{Ciao, #1} \foo AGrahamB % Questo funziona \catcode`\B=12\relax \foo AGrahamB \end{document} ``` Fallisce con un errore piuttosto sconcertante: ``` Argomento in fuga? GrahamB \end {document} ! Il file è terminato mentre si scansionava l’uso di \foo. \par <*> main.tex Sospetto che tu abbia dimenticato una `}', facendomi leggere oltre il punto in cui volevi che mi fermassi. Cercherò di recuperare; ma se l’errore è serio, faresti meglio a digitare ora `E' o `X' e correggere il tuo file. ! Arresto di emergenza. <*> main.tex *** (lavoro interrotto, nessun \end valido trovato) ``` ![Overleaf che mostra un errore di macro TeX](/files/0c958ca3996d7b9432bce4025cca062745e0cbfc) Purtroppo, il suggerimento predefinito di TeX di ``Sospetto che tu abbia dimenticato una `}'`` è **errato**, non è causato da una parentesi graffa mancante (`}`). #### Cosa è successo? TeX sta cercando di corrispondere alla `\foo` macro *chiamata* con la `\foo` macro *definizione* che ha memorizzato nella memoria. Quando richiami una macro che necessita di uno o più argomenti, TeX deve esaminare (scansionare) l’uso della macro per capire gli *argomenti* che stai fornendo a quella macro. Qui, TeX si aspetta che l’argomento sia incastrato tra una A (codice di categoria 11) e una B (codice di categoria 11). Ricorda: TeX pensa in *token*, **non** *caratteri*. I valori di token per A e B, $$\mathrm{T\_A}$$ e $$\mathrm{T\_B}$$ rispettivamente, sono: $$\mathrm{T\_A = 256 \times 11 + 65 = 2881}$$ $$\mathrm{T\_B = 256 \times 11 + 66 =2882}$$ Tuttavia, mentre TeX continua la sua ricerca vede la B *ma* ora ha codice di categoria 12 e ciò produce un valore di token diverso: $$\mathrm{T'\_B= 256 \times 12 + 66 =3138}$$ Nella `\foo` nella definizione della macro, il valore di token per B (usato come delimitatore) era 2882 ma TeX ora vede un valore di token di 3138: pensa che questo sia solo un altro token destinato all’uso nel *argomento* fornito a `\foo`. Per quanto riguarda TeX, il token finale dell’argomento non è ancora stato trovato, quindi va a prendere un altro token nella sua ricerca di una B con codice di categoria 11. È allora, e per questo motivo, che la macro fallisce: nel suo tentativo di trovare l’argomento TeX “va oltre” e inizia a leggere token che non intendevi diventassero parte dell’argomento per la `\foo` chiamata della macro. Ciò che accade dopo dipende dai token che TeX scopre dopo la B—essi scateneranno vari `Argomento in fuga?` errori. Nel nostro esempio, TeX va oltre e consuma il flusso di token `\end {document}` e raggiunge rapidamente la fine del file, da cui il messaggio di errore: ``` ! Il file è terminato mentre si scansionava l’uso di \foo ``` ## Parte 5 Come abbiamo visto sopra, la `` sezione della definizione della nostra macro può variare da estremamente semplice a una miscela complessa di parametri della macro interposti con token di carattere e token di comando che fungono da delimitatori. TeX è in grado di elaborare le varie combinazioni di token presenti in `` per estrarre gli argomenti forniti a una macro—e rilevare quando cerchiamo di usare una macro in modo scorretto. Come lo fa è l’argomento del prossimo articolo della serie. [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/22-how-tex-macros-actually-work-part-4.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.