Keywords: guide

Next: Scoprirne di più Up: Modificare file con Emacs Previous: Come essere ancora più

# Personalizzare Emacs

Emacs è così grande e complesso, che ha addirittura il suo proprio linguaggio di programmazione! Non sto scherzando: per poter personalizzare veramente Emacs, dovrete scrivere dei programmi in questo linguaggio; si chiama Emacs Lisp, ed è un dialetto del Lisp; se avete precedenti esperienze in Lisp lo troverete abbastanza facile.

Altrimenti, non vi preoccupate: non entrerò molto nei particolari, perché è meglio imparare facendo. Per imparare veramente ad usare Emacs, dovreste consultare la documentazione Info su Emacs Lisp, e leggere molto codice sorgente Emacs Lisp.

La maggior parte delle funzionalità di Emacs vengono definite nei file di Emacs Lisp8.9 La maggior parte di questi file vengono distribuiti con Emacs, e sono noti in generale come ``libreria Emacs Lisp''. Dove si trova questa libreria dipende da come Emacs è stato installato sul vostro sistema -- posti comuni sono `/usr/lib/emacs/lisp`, `/usr/lib/emacs/19.19/lisp/`, eccetera. ```19.19`'' è il numero di versione di Emacs, e sul vostro sistema può essere diverso.

Non avete bisogno di ricercare la libreria di Lisp nel vostro filesystem, perché Emacs ha questa informazione registrata al suo interno, nella variabile `load-path`. Per trovare il valore di questa variabile, bisogna valutarla, cioè bisogna far interpretare il suo valore dall'interprete Lisp di Emacs. In Emacs esiste una modalità speciale per valutare le espressioni Lisp, che si chiama `lisp-interaction-mode`. Di solito c'è un buffer che si chiama ```*scratch*`'' che è già in questa modalità. Se non lo trovate, create un nuovo buffer qualsiasi, e digitateci dentro `M-x lisp-interaction-mode`.

Ora avete un'area di lavoro dove interagire con l'interprete Emacs Lisp. Digitate:

130#130

e quando avete finito premete `C-j`. Nella modalità di interazione Lisp, `C-j` è collegato a `eval-print-last-sexp`. Una ```sexp`'' è un'```espressione-s`'', cioè un gruppo bilanciato di parentesi, che non ne include nessuna. Beh, così è un po' troppo semplificato, ma capirete di cosa si tratta lavorando con Emacs Lisp. Comunque, la valutazione di `load-path` dovrebbe essere una cosa del genere:

131#131

Non sarà la stessa su tutti i sistemi, naturalmente, dato che dipende da come è stato installato Emacs. L'esempio qui sopra viene da un sistema PC 386 con Linux. Come indica il testo qui sopra, `load-path` è un elenco di stringhe; il nome di ogni stringa indica una directory che può contenere file di Emacs Lisp. Quando Emacs deve caricare un file di codice Lisp, lo cerca in tutte queste directory, in ordine; se nell'elenco c'è una directory che non esiste nel filesystem, Emacs la ignora.

Quando lo avviate, Emacs cerca automaticamente di caricare il file `.emacs` dalla vostra home directory, quindi, se volete personalizzare Emacs, dovreste mettere i comandi di personalizzazione in `.emacs`. Le personalizzazioni più comuni sono quelle dei corrispondenti da tastiera, quindi ecco come si fanno:

132#132

`global-set-key` è una funzione di due argomenti: il tasto da collegare e la funzione a cui collegarlo. La parola ```global`'' significa che il collegamento è valido in tutte le modalità maggiori (esiste un'altra funzione, `local-set-key`, che collega un tasto ad una funzione in un singolo buffer). Qui sopra, ho collegato `C-c l` alla funzione `goto-line`. Il tasto viene descritto usando una stringa. La sintassi speciale ````\`C-<char>`'' sta a significare che il tasto 118#118 deve essere tenuto premuto mentre si preme il tasto `<char>`. Nello stesso modo, ````\`M-<char>`'' indica il tasto 127#127.

Va tutto bene, ma come facevo a sapere che il nome della funzione era ```goto-line`''? Potevo sapere solo di voler far corrispondere il tasto `C-c l` ad una funzione che richiede il numero di linea e sposta il cursore su quella linea, ma come facevo a sapere come si chiamava la funzione?

È qui che ci aiuta la guida in linea di Emacs: una volta che avete deciso che tipo di funzione state cercando, potete usare Emacs per ritrovare il suo nome esatto. Ecco un modo veloce e un po' sporco per farlo: dato che Emacs usa il completamento dei nomi delle funzioni, digitate semplicemente `C-h f` (che sta per `describe-function`, e quindi dà la descrizione di una funzione), e poi digitate 77#77 senza scrivere niente. In questo modo chiedete ad Emacs di completare una stringa vuota, e quindi Emacs elenca tutte le funzioni! Ci vorrà un po' per fare la lista completa, dato che Emacs ha molte funzioni interne, ma quando è pronto ne mostrerà tante quante ne entrano nello schermo.

A questo punto, premete `C-g` per uscire dalla funzione di descrizione. Sarà stato creato un buffer `*Completions*`'', che conterrà tutta la lista che avete generato. Passate a quel buffer. Ora potete usare `C-s` e `isearch` per cercare la funzione che vi interessa. Ad esempio, è probabile che una funzione che chiede il numero di una linea e passa a quella linea conterrà la stringa ```line`''. Quindi cercate la stringa ```line`'', e alla fine troverete quello che cercate.

Se volete usare un altro metodo, provate con `C-h a`, `command-apropos`, che mostra tutte le funzioni il cui nome contiene la stringa data. L'output di `command-apropos` è un po' più complicato da leggere di una lista semplice, a mio parere, ma forse la penserete in modo diverso. Provate entrambi i metodi e vedete quale vi piace di più.

C'è sempre la possibilità che Emacs non abbia nessuna funzione predefinita che faccia quello che volete. In questo caso, dovrete scrivervi la funzione da soli. Non vi parlerò di come farlo in questo libro--dovreste dare un'occhiata alla libreria Emacs Lisp e cercare degli esempi di definizioni di funzioni, e leggere le pagine Info su Emacs Lisp. Se per caso conoscete qualcuno che conosce bene Emacs, chiedetegli come fare; definire le proprie funzioni di Emacs non è molto difficile--per darvi un'idea, ne ho scritte 131 nell'ultimo anno. Richiede un po' di pratica, ma non è difficile da imparare.

Un'altra cosa che si fa spesso nel file `.emacs` è impostare alcune variabili a valori predefiniti. Per esempio, mettete questa linea nel vostro file `.emacs`, ed avviate una nuova copia di Emacs:
133#133
Emacs controlla il valore della variabile `inhibit-startup-message` per decidere se mostrare o no all'avvio determinate informazioni sulla versione e sulla mancanza di garanzia. L'espressione Lisp qui sopra usa il comando `setq` per impostare questa variabile al valore ``t`', uno speciale valore Lisp che significa vero (true). L'opposto di ``t`' e ``nil`', che è il valore predefinito per `falso' nell'Emacs Lisp. Ed ecco due cosette che ho nel mio `.emacs` e che possono essere utili:
134#134
La prima espressione non fa considerare le maiuscole nell ricerche (compreso `isearch`); cioè, la ricerca darà entrambe le versioni, con lettere maiuscole o minuscole, di un carattere, anche se la stringa di ricerca contiene solo le lettere minuscole. La seconda espressione imposta i rientri per le frasi del linguaggio C un po' più piccoli del normale--è solo un gusto personale; trovo che renda il codice C più leggibile.

Il carattere di commento nel Lisp è ```;`''. Emacs ignora qualsiasi cosa che segua un punto e virgola, così:
135#135
È una buona idea commentare i vostri cambiamenti ai file Lisp, in modo che anche dopo sei mesi vi ricorderete di cosa stavate pensando mentre li modificavate. Se il commento appare da solo su una linea, anteponetevi due punti e virgola; aiuta Emacs a far rientrare correttamente i file Lisp.

Potete trovare del materiale sulle variabili interne di Emacs nello stesso modo che avete usato per le funzioni. Usate `C-h v` e `describe-variable` per creare una lista dei completamenti, oppure usate `C-h C-a` `apropos`. `Apropos` si distingue da `C-h a`, `command-apropos` nel fatto che mostra le funzioni e le variabili invece che solo le funzioni.

L'estensione di default per i file Emacs Lisp è ```.el`'', come in ```c-mode.el`''. Comunque, per rendere più veloce il codice Lisp, Emacs permette di compilarlo byte per byte; questi file di codice Lisp compilato hanno estensione ```.elc`'' invece di ```.sl`''. L'eccezione a questa regola è il file ```.emacs`'', che non ha bisogno dell'estensione `.el` perché Emacs sa dove cercarlo all'avvio.

Per compilare un file di codice Lisp interattivamente, usate il comando `M-x load-file`. Vi chiederà il nome del file. Per caricare i file
136#136

Emacs aggiungerà per prima cosa l'estensione `.elc` al nome del file e proverà a cercarlo in qualche directory del `load-path`. Se non ci riesce, proverà con l'estensione `.sl`, oppure userà la stringa letterale che viene passata a `load`. Potete compilare byte per byte un file con il comando `M-x byte-compile-file`, ma se modificate il file spesso, probabilmente non vi conviene. Non dovreste mai compilare così il file `.emacs`, né dargli l'estensione `.el`. Dopo che sarà stato caricato `.emacs`, Emacs cercherà di caricare un file con nome `default.el`. Di solito si trova in una directory, nel load-path, che si chiama `site-lisp` o `local-elisp` o qualcosa del genere (vedere l'esempio di `load-path` che ho dato qualche pagina indietro). Chi mantiene Emacs su sistemi multiutente usa il default.el per apportare cambiamenti alle versioni di Emacs di tutti, dato che l'Emacs di ciascuno si carica dal proprio file `.emacs` personale. Nemmeno `default.el` dovrebbe essere compilato, dato che normalmente viene modificato abbastanza spesso. Se il `.emacs` di qualcuno contiene degli errori, Emacs non cerca di caricare `defaul.el`, ma si ferma, mandando un messaggio che dice ```Error in init file`'' (``Errore nel file di inizializzazione''). Se vedete un messaggio del genere, probabilmente c'è qualcosa di sbagliato nel file `.emacs`.

C'è ancora un tipo di espressione che si ritrova spesso nei file `.emacs`. La libreria di Emacs Lisp spesso offre dei pacchetti multipli per fare la stessa cosa in modi diversi; bisognerà così specificare quale volete usare (o dovrete usare il pacchetto di default, che non è sempre il migliore per tutti gli scopi). Un'area in cui si ha questo problema sono le caratteristiche di interazione di Emacs con Scheme: con Emacs vengono distribuite due diverse interfacce Scheme (almeno nella versione 19): `xscheme` e `cmuscheme`.
137#137
A me l'interfaccia di `cmuscheme` piace molto di più di quella di default, che è `xscheme`. Come posso far usare ad Emacs quella che piace di più a me? Mettendo queste linee in `.emacs`:
138#138
La funzione `autoload` prende come argomento il nome di una funzione (tra apici ```'`'', per ragioni che hanno a che fare con il Lisp) e dice ad Emacs che tale funzione è definita in un determinato file. Il file è il secondo argomento, una stringa (senza l'estensione ```.el`'' o ```.elc`'') che indica il nome del file da cercare nel `load-path`.

I restanti argomenti sono in genere opzionali, ma in questo caso necessari: il terzo è una stringa di documentazione per la funzione, in modo che se chiamate `describe-function` sulla funzione avete delle informazioni che vi possono servire. Il quarto dice ad Emacs che questa funzione autoavviabile può essere richiamata interattivamente (cioè usando `M-x`). In questo caso quest'ultimo argomento è molto importante, dato che bisogna poter digitare `M-x run-scheme` per avviare un processo di scheme sotto Emacs.

Adesso che `run-scheme` è stata definita come funzione autoavviabile, cosa succede quando digito `M-x run-scheme`? Emacs cerca la funzione `run-scheme`, vede che è impostata per venire autoavviata, e carica il file indicato dall'autoavviamento (in questo caso, ```cmuscheme`''). Il file compilato byte per byte `cmuscheme.elc` esiste, quindi Emacs lo caricherà. Questo file deve definire la funzione `run-scheme`, o ci sarà un errore nell'autocaricamento. Per fortuna lo fa, quindi tutto va liscio, ed io ottengo la mia interfaccia Scheme preferita8.10.

Un ``autocaricamento'' è come una promessa fatta ad Emacs che, quando sarà il momento, potrà trovare la funzione specificata nel file in cui gli si dice di guardare; e voi potete controllare quello che viene caricato. Inoltre, l'autocaricamento vi aiuta a diminuire la memoria usata da Emacs, evitando di caricare determinate caratteristiche finché non vengono richieste. La maggior parte dei comandi non sono definiti come funzioni quando Emacs parte; piuttosto, sono semplicemente impostati come autocaricamento da determinati file. Se non invocate il comando, non viene mai caricato. Questo modo di salvare spazio è vitale per il funzionamento di Emacs: se caricasse tutti i file disponibili nella libreria Lisp, ci vorrebbero venti minuti per avviarlo, ed occuperebbe la maggior parte della memoria disponibile sul sistema. Non vi preoccupate, non dovete impostare tutti questi autocaricamenti nel file `.emacs`: sono stati preimpostati all'interno di Emacs stesso.

Next: Scoprirne di più Up: Modificare file con Emacs Previous: Come essere ancora più