% Linux Guida dell'Utente                   -*- TeX -*-
% emacs.tex
% Copyright (c) 1993, 1994 by Larry Greenfield
%
% Traduzione di Eugenia Franzoni, 1997
%
% Questo file e' liberamente distribuibile, ma si deve preservare questo
% avviso di copyright su tutte le copie, e deve essere distribuito solo come
% parte di "Linux Guida dell'Utente". L'uso di questo file e'
% protetto dal copyright dell'intero documento, nel file "copyright.tex".


% Titolo del capitolo
\chapter{Modificare file con Emacs}
\label{emacs-chapter}

% FUNNY SOMETHING OR OTHER


\bttindex{emacs}
\section{Cos'\`e Emacs?}

Per poter fare qualsiasi cosa con un computer, avete bisogno di un modo per
inserire del testo in un file, e un modo per modificare il testo gi\`a
inserito nei file; si fa con dei programmi detti {\bf
editor}\index{editor}.
{\tt Emacs} \`e uno degli editor pi\`u popolari---anche perch\'e \`e molto
semplice per un principiante poter lavorarci bene (l'editor classico
di \unix, {\tt vi}, \`e spiegato nell'appendice~\ref{vi-chapter}).

Per imparare {\tt emacs}, avete bisogno di un file di testo semplice
(lettere, numeri e simili); copiatelo nella vostra home
directory\footnote{Per esempio, {\tt cp /usr/src/linux/README ./README}}
(non vogliamo modificare il file originale, se esso contiene
informazioni
importanti), e richiamate Emacs sul file:

\begin{screen}
   \begin{tt}
{\tt /home/larry\$ emacs README}
   \end{tt}
\end{screen}

(Naturalmente, se volete copiare {\tt /etc/inittab} o un qualsiasi
altro file,
sostituite quel nome di file a {\tt README}. Per esempio {\tt cp
/etc/inittab \verb+~+/inittab} e poi {\tt emacs inittab}.)

\xwarn ``Richiamare'' Emacs pu\`o avere effetti diversi a seconda di
quale
ambiente state usando. Da una semplice console di testo,
Emacs user\`a l'intera console. Se lo richiamate da X, Emacs
creer\`a una sua propria finestra. Presumer\`o che lo facciate dalla
console testo, ma
\`e valido tutto anche nella versione X~Window---basta sostituire la parola
``schermo'' con la parola ``finestra''. Ricordatevi anche che dovete muovere
il puntatore del mouse nella finestra di Emacs per scriverci!

Lo schermo (o finestra, se state usando X) dovrebbe ora assomigliare alla
figura~\ref{emacs-shot-1}. Gran parte dello schermo contiene il vostro
documento, ma quello che vi interessa particolarmente, se volete
imparare ad usare Emacs, sono le ultime due righe.
La penultima linea (quella con una serie di
trattini) si chiama {\bf riga di stato}.

\begin{figure}[tbh]\label{emacs-shot-1}
\begin{center}
\leavevmode \epsfxsize=5in
\epsfbox{ps-files/screen-shot-1.ps}
\end{center}
\caption{Emacs appena avviato con {\tt emacs README}}
\end{figure}

Nella riga di stato vedrete ``Top''. Potrebbe essere anche ``All'', ed avere altre
leggere differenze (molti hanno l'ora corrente visualizzata
nella linea
di stato). La riga immediatamente sotto alla riga di stato \`e chiamata {\bf
minibuffer}, o a volte {\bf area eco}. Emacs usa quest'area per
mandarvi dei
messaggi e qualche volta, quando serve, per leggere il vostro input.
Per adesso Emacs vi sta chiedendo ``{\tt For information about the GNU
Project and its goals, type C-h C-p}''. Ignoratelo per adesso, non parleremo
dell'uso del minibuffer per un po'. 

Prima di effettuare qualsiasi modifica del testo nel file, dovete
imparare come spostarvi nel testo. Il cursore dovrebbe trovarsi
all'inizio del file,
nell'angolo in alto a sinistra dello schermo. Per spostarvi in 
avanti,
premete
{\tt C-f} (cio\`e, tenete premuto il tasto \key{Control} e premete
\key{f}, per ``forward''). Il cursore si sposter\`a
di un carattere alla volta, e se
mantenete premuti i tasti il sistema ripeter\`a automaticamente lo
spostamento circa ogni mezzo
secondo. Notate che quando arrivate alla fine della riga il
cursore passa automaticamente nella riga sottostante. {\tt C-b} (per
``backward'') ha il
significato opposto. E, visto che siamo in argomento, {\tt C-n} e {\tt C-p}
spostano il cursore rispettivamente nella riga successiva e
precedente.\footnote{Nel
caso non l'abbiate gi\`a notato molti dei comandi di spostamento di
Emacs
consistono nella combinazione del tasto \key{Control} con una singola
lettera mnemonica.}

Usare i tasti di controllo \`e generalmente il modo pi\`u veloce di
spostarsi 
mentre state scrivendo. Lo scopo di Emacs \`e di mantenere le vostre mani sui
tasti alfanumerici della tastiera, dove viene fatta la maggior parte 
del lavoro.
Comunque, se volete, i tasti freccia dovrebbero funzionare comunque.

\xwarn In effetti, quando state usando X, dovreste riuscire a posizionare il
puntatore del mouse e cliccare con il pulsante sinistro per spostare 
il
cursore dove volete; questa operazione \`e per\`o molto lenta---dovete
portare la vostra mano sul mouse ogni volta! La maggior parte delle persone che
usano Emacs usano
principalmente la tastiera per spostarsi.

Usate {\tt C-p} e {\tt C-b} per tornare fino all'angolo superiore
sinistro.
Adesso mantenete premuto {\tt C-b} per un po'; dovreste sentire il suono del
cicalino e vedere il messaggio ``{\tt Beginning of buffer}'' (inizio del
buffer) apparire nel minibuffer. A questo punto potreste essere
sorpresi:
``Ma cos'\`e un buffer?''

Quando Emacs lavora su un file, non lavora proprio sul file, ma ne
copia il contenuto in una speciale area di lavoro chiamata {\bf
buffer}, dove potete modificarlo. Quando avete finito di
lavorare, comunicate ad Emacs di salvare il buffer---in altre parole,
di
scrivere il contenuto del buffer nel file corrispondente. Finch\'e non
lo fate,
il file rimane 
invariato, e il contenuto del buffer esiste
solamente dentro Emacs.

Con questo in mente, preparatevi ad inserire i vostri primi caratteri nel
buffer. Fino ad ora, tutto quello che abbiamo fatto \`e stato
``non-distruttivo'', cos\`{\i} questo \`e un grande momento. Potete scegliere
qualsiasi carattere preferite, ma se volete farlo con stile, suggerisco di
usare un bell'``X'' maiuscolo. Mentre lo digitate, guardate l'inizio
della
riga di stato in fondo allo schermo. Quando modificate il buffer in modo che
il suo contenuto non sia pi\`u uguale al file su disco, Emacs mostra due
asterischi all'inizio della riga di stato, per farvi sapere che il buffer \`e
stato modificato:

\begin{screen}
   \begin{verbatim}
--**-Emacs: file.txt        (Fundamental)--Top------------------------
\end{verbatim}
\end{screen}

Questi due asterischi vengono visualizzati non appena modificate il
buffer, e
rimangono visibili finch\'e non lo salvate. Potete salvare pi\`u volte il buffer
durante una stessa sessione di scrittura---il comando per farlo \`e
{\tt C-x~C-s}
(tener premuto il tasto \key{Control} e premere ``x'' e ``s''\ldots ok,
probabilmente avrete gi\`a capito come funziona!). \`E volutamente semplice da
digitare, perch\'e salvare il buffer \`e una cosa che \`e meglio fare
presto e spesso.

Elencher\`o ora alcuni comandi, insieme a quelli che avete gi\`a
imparato, e
che potete provare: suggerisco di familiarizzare con questi prima di andare
avanti:

\begin{tabular}{ll}
{\bf {\tt C-f}}     & Muove avanti di un carattere. \\
{\bf {\tt C-b}}     & Muove indietro di un carattere. \\
{\bf {\tt C-n}}     & Va alla riga successiva. \\
{\bf {\tt C-p}}     & Va alla riga precedente. \\
{\bf {\tt C-a}}     & Va all'inizio della riga. \\
{\bf {\tt C-e}}     & Va alla fine della riga. \\
{\bf {\tt C-v}}     & Va alla pagina/schermata di testo successiva.
\\
{\bf {\tt C-l}}     & Ridisegna lo schermo, con la riga corrente al
centro. \\
{\bf {\tt C-d}}     & Elimina il carattere sotto il cursore (provate 
ad usarlo). \\
{\bf {\tt C-k}}     & Elimina il testo dal cursore alla fine della riga. \\
{\bf {\tt C-x C-s}} & Salva il buffer nel file corrispondente.\\
\key{Backspace}     & Elimina il carattere precedente (quello appena
digitato). \\
\end{tabular}



\section{Iniziare velocemente con X}

\xwarn Se volete solo 
modificare velocemente
dei file ed usate X,
potete farlo usando solo i men\`u in cima alla
finestra:

\begin{center}
\leavevmode \epsfxsize=\textwidth \epsfbox{ps-files/screen-shot-2.ps}
\end{center}

Questi men\`u non sono disponibili in modalit\`a testo.

Quando avviate Emacs per la prima volta avrete quattro men\`u in cima alla
finestra: {\sf Buffers}, {\sf File}, {\sf Edit} e {\sf Help}. Per usare un
men\`u, semplicemente spostate il puntatore del mouse sopra il nome (ad esempio 
{\sf
File}), premete e tenete premuto il pulsante sinistro del mouse, poi
spostate il puntatore sul comando che volete usare e rilasciate il
pulsante. Se
cambiate idea, spostate il puntatore lontano dai men\`u e rilasciate il
pulsante.

Il men\`u {\sf Buffers} elenca i diversi file che state modificando in questa
sessione di Emacs: il men\`u {\sf File} comprende una serie di comandi per
caricare e salvare file---molti di questi saranno descritti pi\`u avanti. Il
men\`u {\sf Edit} contiene alcuni comandi per modificare i buffer, e il men\`u
{\sf Help} dovrebbe dare la documentazione in linea.

Potete notare che i corrispondenti da tastiera sono elencati a destra
delle
voci nei men\`u. Dovreste cercare di impararli se contate di 
diventare pi\`u veloci; inoltre molte delle funzionalit\`a di Emacs sono
disponibili {\em solamente\/} attraverso la tastiera---quindi vi sar\`a utile
leggere il resto di questo capitolo.


\section{Modificare pi\`u file contemporaneamente}

Emacs pu\`o lavorare su pi\`u di un file alla volta. In effetti, il solo limite
alla quantit\`a di buffer che Emacs pu\`o contenere dipende dalla memoria
disponibile nella macchina. Il comando per aprire un nuovo file nel buffer
di Emacs \`e {\tt C-x~C-f}. Quando lo digitate, vi verr\`a chiesto il
nome di un file nel minibuffer:

\begin{screen}
   \begin{verbatim}
Find file: ~/
   \end{verbatim}
\end{screen}

La sintassi usata qui \`e la stessa usata per specificare i file dal prompt
della shell; la barra rappresenta le subdirectory, \verb+~+ indica la vostra
home directory. Potete ottenere anche il completamento automatico, nel senso
che se quello che avete scritto al prompt \`e sufficiente per
identificare univocamente un
file, potete semplicemente premere \key{Tab} per completarlo (o per
vedere i possibili completamenti, se ce ne sono pi\`u di uno). Anche
\key{Spazio} ha un ruolo nel completamento dei nomi dei file, 
simile a \key{Tab},
ma vi lascio provare per vedere le differenze. Una volta che avete
completato il nome del file
nel minibuffer, premete \ret, ed Emacs vi presenter\`a un
buffer contenente quel file. In Emacs, questo processo \`e noto come
{\bf finding} (ricerca) di un file. Andiamo avanti, troviamo qualche altro
file di testo e carichiamolo in Emacs (fatelo dal buffer originale {\tt
file.txt}). Adesso avete un nuovo buffer; poniamo che si chiami
{\tt altro\_file.txt}, dato che non posso vedere la vostra linea di
stato.

Il vostro buffer originale sembra scomparso---vi starete
probabilmente
chiedendo dove sia finito. \`E ancora dentro Emacs, e potete attivarlo
nuovamente con {\tt C-x~b}. Quando lo digitate, vedrete
nel
minibuffer una richiesta per sapere quale buffer attivare, e propone un nome
di default. Il buffer di default \`e quello a cui passate se premete solamente
\ret, senza scrivere un nome. Il buffer di default \`e sempre quello
che avete lasciato per ultimo,
cos\`{\i} quando state lavorando molto tra due
buffer, {\tt C-x~b} permette di passare per default all'altro buffer
(facendovi
risparmiare di scriverne il nome). Anche se il buffer di default \`e quello
che volete, potete comunque tentare di scrivere il suo nome.

Notate che avete la possibilit\`a di sfruttare il completamento automatico
come quando cercate un file: premendo \key{Tab} viene completato quanto
possibile. Ogni volta che viene chiesto qualcosa nel minibuffer, \`e una buona
idea vedere se Emacs riesce a fare il completamento: sfruttare la
possibilit\`a del completamento quando viene offerta permette di
risparmiare
parecchie digitazioni. Emacs generalmente esegue il completamento quando
state scegliendo una voce da una lista predefinita.

Tutto quello che avete imparato su come spostarvi e modificare il 
testo nel primo
buffer si applica anche agli altri. Andate avanti e cambiate un
po' di
testo nel nuovo buffer, ma non salvatelo (cio\`e non premete {\tt C-x~C-s}).
Assumiamo che voi vogliate annullare le vostre modifiche senza salvarle nel
file; il comando per farlo \`e {\tt C-x~k}, che ``uccide'' (kill) il
buffer.
Digitatelo ora: per prima cosa vi viene chiesto quale buffer eliminare,
ma
quello di default \`e il buffer corrente, e di solito si elimina quello, 
quindi premete semplicemente \ret; poi vi viene chiesto se
volete {\em
realmente\/} eliminare il buffer---Emacs controlla sempre prima di
eliminare un buffer che contiene modifiche non salvate. 
Digitate semplicemente ``yes'' e premete \ret, se volete eliminarlo.

Andate avanti e fate pratica caricando file, modificandoli, salvandoli e
eliminando i loro buffer. Assicuratevi di non modificare nessun file
importante di
sistema, in modo da non provocare disastri,\footnote{Se non siete l'utente
``root'' (il supervisore) nella macchina, non dovreste avere la
possibilit\`a di
danneggiare il sistema, ma fate lo stesso attenzione.} ma cercate comunque
di aprire almeno cinque buffer contemporaneamente, in modo da capire
come commutare tra un buffer e un altro.


\section{Terminare una sessione di Scrittura}

Quando avete finito di lavorare con Emacs, assicuratevi che le modifiche
in tutti i buffer siano state salvate, e uscite con {\tt C-x~C-c}.
A volte {\tt C-x~C-c} vi pone un paio di
domande nel minibuffer prima di
lasciarvi---non allarmatevi, semplicemente rispondete in modo ovvio. Se
pensate di dover ritornare in Emacs pi\`u tardi, non usate {\tt C-x~C-c};
usate {\tt C-z}, che lo sospender\`a. Potete tornarvi nuovamente
con il
comando della shell ``{\tt fg}'': \`e pi\`u efficiente di
chiudere e far ripartire Emacs diverse volte, specialmente se dovete
modificare di nuovo lo stesso file pi\`u tardi.

\xwarn Sotto X, premere {\tt C-z} iconizza
semplicemente la finestra.
Guardate la sezione sull'iconizzazione nel capitolo~\ref{x-chapter}. Questo
vi d\`a due modi per iconizzare Emacs, il modo solito offerto dal
vostro gestore di finestre, e {\tt C-z}. Ricordatevi, quando iconizzate, un semplice
{\tt fg} non fa riapparire la finestra---dovete ricorrere al gestore di finestre.


\section{Il Tasto Meta}

Avete gi\`a imparato un tasto ``modificatore'' in Emacs, il tasto
\key{Control}: ne esiste un secondo, il tasto {\bf Meta}, che \`e
usato
altrettanto frequentemente. Comunque, non tutte le tastiere hanno il 
tasto Meta nello stesso posto, e alcune non ce l'hanno proprio; la prima
cosa che dovete fare \`e trovare dove si trova sulla vostra tastiera. \`E
possibile che i tasti \key{Alt} della tastiera siano anche tasti Meta, se
state usando un PC IBM o altre tastiere che hanno un tasto \key{Alt}.

Il modo per provarlo \`e tenere premuto un tasto che pensate possa
essere un tasto Meta e premere ``x''. Se vedete apparire un piccolo
prompt
nel minibuffer (tipo: {\tt M-x}) allora l'avete trovato. Per togliere il
prompt e tornare al buffer di Emacs, premete {\tt C-g}.

Se non riuscite a ottenere un prompt, allora c'\`e un'altra soluzione: potete
usare come tasto Meta il tasto \key{Esc}, ma invece di tenerlo premuto
mentre scrivete la lettera successiva, dovete premerlo e rilasciarlo
rapidamente, e {\em successivamente\/} digitare la lettera. Questo metodo
funziona sia che abbiate un vero tasto Meta sia che non lo abbiate,
dunque \`e
il metodo pi\`u semplice. Provate adesso a premere \key{Esc} e poi a 
premere
``x''. Dovreste ottenere nuovamente il piccolo prompt. Usate semplicemente
{\tt C-g} per annullarlo. {\tt C-g}\index{emacs!interrompere} \`e il modo pi\`u
generale in Emacs per uscire da qualcosa che non volevate fare: generalmente
fa un beep per avvisare che avete interrotto qualcosa, ma 
va bene, dato che
\`e quello che volevate fare premendo {\tt
C-g}!\footnote{Talvolta solo un {\tt C-g} non \`e sufficiente
per
convincere Emacs che volete interrompere quello che state facendo.
Ripremetelo, e Emacs vi dar\`a ascolto.}

La notazione {\tt M-x} \`e analoga a {\tt C-x} (dove ``{\tt x}'' \`e un 
carattere qualsiasi). Se avete trovato un tasto Meta, usate
quello, altrimenti
usate il tasto \key{Esc}. Scriver\`o semplicemente {\tt M-x} e saprete che
dovrete usare il vostro tasto Meta.


\section{Tagliare, Incollare, Eliminare}

Emacs, come tutti i buoni editor, permette di tagliare e incollare
blocchi
di testo. Per farlo avete bisogno di un modo per definire l'inizio e
la
fine del blocco: in Emacs si fa impostando due punti nel buffer,
chiamati {\bf mark}\index{emacs!mark} e {\bf point}\index{emacs!point}. Per
impostare il mark (inizio), andate alla posizione in cui volete
che inizi il
blocco e premete {\tt C-SPC} (``{\tt SPC}'' indica il tasto \key{Spazio}).
Dovreste vedere il messaggio ``Mark set'' (Mark impostato) nel
minibuffer.\footnote{Su alcuni terminali, {\tt C-SPC} non funziona, e
dovete usare {\tt C-@}.} Il mark \`e stato impostato in
quel punto; non ci sono particolari evidenziazioni che lo indicano, ma voi sapete
dove lo avete messo, ed \`e questo che importa.

Che dire di {\bf point}? Beh, viene impostato ogni volta che muovete
il
cursore, in quanto ``point'' si riferisce semplicemente alla
posizione corrente nel
buffer. In termini pi\`u formali, point \`e il punto dove verrebbe 
inserito il
testo quando digitate qualcosa. Impostando il mark e spostandovi alla fine
del testo avete definito un blocco di testo, detto anche
{\bf regione}\index{emacs!regione}. La regione indica sempre l'area tra mark
e point.

La semplice definizione di una regione non la rende disponibile per
incollarla, ma dovete comunicare ad Emacs di copiarla.
Per copiare la regione, assicuratevi che mark e point siano
correttamente impostati e premete {\tt M-w}. La regione \`e stata copiata in
Emacs. Per incollarla altrove, andate in quella posizione e premete {\tt
C-y} (per ``yanking'').

Se volete spostare il testo della regione altrove, usate {\tt C-w} al posto
di {\tt M-w}. Questo {\bf eliminer\`a}\index{emacs!eliminare} la
regione---tutto il testo sparir\`a. In effetti \`e stato salvato allo stesso
modo di {\tt M-w}. Potete riportarlo indietro
con {\tt C-y}, incollandolo
come al solito. Il posto in cui Emacs salva tutto questo testo si
chiama
{\bf kill-ring}. Alcuni editor lo chiamano ``clipboard'' (appunti) o
``buffer di incolla''.

C'\`e un altro modo per tagliare e incollare: ogni volta che usate {\tt C-k}
per eliminare fino alla fine della linea, il testo eliminato finisce nel
kill-ring. Se eliminate pi\`u di una riga, 
queste vengono salvate tutte insieme nel
kill-ring, in modo che la prossima volta che incollate, incollerete
tutte le linee insieme. 
Grazie a questa caratteristica, 
spesso \`e
pi\`u veloce usare ripetutamente {\tt C-k} per eliminare del testo che
impostare
esplicitamente mark e point e usare {\tt C-w}; comunque, entrambi i sistemi
funzionano, ed \`e una preferenza personale quale dei due usare.


\section{Cercare e Sostituire}

Ci sono parecchi modi per cercare del testo in un file con Emacs; molti sono
abbastanza complessi e non li vedremo qui. Il modo pi\`u semplice e
divertente \`e usare {\bf isearch}\bindex{emacs!ricerca}: ``isearch''
sta per ``ricerca incrementale''. Supponiamo che vogliate cercare la
stringa ``leone'' nel seguente testo:

\begin{quote}\begin{em}
Gli animali sono creature molto interessanti. Il mio animale preferito
\`e la tigre, un terrificante animale con grandi denti.  Mi piace anche
il leone---non \`e di certo un erbivoro! 
\end{em}\end{quote}

Dovete spostarvi all'inizio del buffer, o almeno in un punto che
sapete precedere la prima ricorrenza della parola da cercare,
``leone'', e premere {\tt C-s}: questo vi pone in modalit\`a
ricerca. Adesso iniziate a scrivere la parola che volete trovare,
``leone''. Appena scrivete ``l'', vedrete che Emacs salta alla
prima ricorrenza di ``l'' nel testo; se il testo precedente \`e tutto il
contenuto del buffer, allora questa \`e la lettera ``l'' della parola
``Gli''.  Premete ora ``e'' di ``leone'', e Emacs arriver\`a ad
``animale'', che \`e la prima ricorrenza di ``le''. La ``o'' far\`a
arrivare Emacs a ``leone'', senza farvi
scrivere l'intera parola. 

Quello che si fa durante una ricerca incrementale \`e definire
una stringa da cercare. Ogni volta che aggiungete un carattere alla
fine della stringa il numero di corrispondenze si riduce, finch\'e
non avrete inserito abbastanza caratteri da definire la stringa in
modo univoco. Una volta trovata la corrispondenza che cercavate,
potete uscire dalla modalit\`a ricerca con il tasto \ret\ o qualsiasi
dei tasti di movimento. Se pensate che la stringa da cercare sia
indietro nel buffer, allora dovreste usare {\tt C-r}, che esegue la
ricerca nella direzione inversa. 

Se incontrate una corrispondenza, ma non \`e quella che cercavate,
premete {\tt C-s} nuovamente mentre siete ancora in modalit\`a
ricerca: ogni volta che premerete questo tasto vi sposterete nella successiva 
corrispondenza completa.
Se non ci sono pi\`u
corrispondenze, Emacs dir\`a che la ricerca \`e fallita, ma se premete
nuovamente {\tt C-s}, la ricerca ripartir\`a dall'inizio
del buffer. Vale anche per {\tt C-r}---ripartir\`a dalla fine del
buffer. 

Provate a prendere un buffer di testo semplice ed eseguite la ricerca
per la stringa ``{\tt gli}''. Digitate innanzitutto quello che
cercate, quindi usate ripetutamente {\tt C-s} per andare a tutte le
ripetizioni di ``gli''. Notate che questo corrisponde anche a parole
che
contengono la stringa ``gli''. Per cercare unicamente ``gli'', dovete
aggiungere uno spazio alla fine della stringa da cercare. Potete
aggiungere caratteri nuovi alla stringa in qualsiasi punto della
ricerca, anche dopo aver premuto ripetutamente {\tt C-s} per trovare
le corrispondenze successive. Potete usare anche \key{Backspace} o
\key{Delete} (\key{Canc}) per rimuovere caratteri dalla stringa di
ricerca in qualsiasi momento; premendo \ret si esce dalla modalit\`a
ricerca, lasciandovi all'ultima corrispondenza trovata. 

Emacs vi permette anche di sostituire tutte le ripetizioni di una
stringa
con qualche altra stringa---si chiama {\bf
cerca-sostituisci}. Per richiamarlo, digitate {\tt M-x query-replace}
e
premete \ret. Il completamento viene fatto anche sul nome del
comando,
quindi una volta che avete inserito ``query-re'', potete premere
\key{Tab} per completarlo. Diciamo che volete sostituire tutte le
ricorrenze di ``leone'' con ``tigre''. Al prompt ``{\tt Query
replace}'' digitate ``leone'' e premete \ret; vi viene
richiesto
nuovamente dell'input, e dovete inserire ``tigre''. Emacs quindi
scorrer\`a il
testo, si fermer\`a ad ogni ricorrenza della parola ``leone'', e vi
chieder\`a se volete sostituirla. Premete semplicemente ``{\tt y}'' o
``{\tt n}'' ogni volta, per ``Yes'' o ``No'', finch\'e non
finisce. Se non avete capito leggendolo, provateci. 
\eindex{emacs!ricerca}


\section{Ma che succede veramente?}

In realt\`a, le combinazioni di tasti che avete imparato sono
scorciatoie per delle funzioni di Emacs. Per esempio, {\tt C-p} \`e un modo
breve per
dire a Emacs di eseguire la funzione interna {\tt previous-line} (linea
precedente). Tutte queste funzioni interne possono essere
richiamate anche
per nome, usando {\tt M-x}; se vi dimenticate che {\tt previous-line} \`e
associata a {\tt C-p}, potete semplicemente digitare {\tt M-x previous-line}
\ret, e vi muoverete verso l'alto di una linea. Provatelo adesso, per capire
come {\tt M-x previous-line} e {\tt C-p} sono realmente la stessa cosa.

Chi ha progettato Emacs \`e partito dalla base, definendo prima un
intero set di
funzioni interne, e poi associando delle combinazioni di tasti a
quelle pi\`u
utilizzate. A volte \`e pi\`u semplice richiamare
esplicitamente una funzione con
{\tt M-x} invece di ricordarsi a quale tasto \`e associata. La funzione
{\tt
query-replace}, per esempio,
\`e associata in alcune versioni di Emacs
a {\tt M-\%}. Ma
come si fa a ricordarsi una combinazione cos\`{\i} strana?
A meno che non usiate
molto spesso cerca-sostituisci, \`e pi\`u semplice richiamarla con {\tt
M-x}.

La maggior parte dei tasti che digitate sono lettere, che devono
essere nel testo del buffer; quindi ognuno di questi tasti \`e {\bf
associato} alla funzione {\tt
self-insert-command}, che non fa nient'altro che inserire quella
lettera nel
buffer. Le combinazioni che usano il tasto \key{Control} con una
lettera
generalmente sono associate a funzioni che fanno altre cose, come lo
spostamento. Per esempio, {\tt C-v} \`e associato alla funzione chiamata {\tt
scroll-up}, che fa scorrere il buffer in alto di una schermata
(in modo che la
vostra posizione nel buffer si sposta in {\em basso},
naturalmente).

Se volete inserire un carattere Control nel buffer, come
potete
fare? Dopo tutto, i caratteri Control sono caratteri {\tt ASCII},
anche se vengono
usati raramente, e potreste doverli
inserire in un file. C'\`e un modo per evitare che Emacs interpreti i
caratteri Control come comandi: il
tasto {\tt C-q}\footnote{Chiamiamo {\tt C-q} ``tasto'', anche se \`e prodotto
tenendo premuto \key{Control} e premendo ``q'', perch\'e \`e un singolo
carattere {\tt ASCII}.} \`e associato ad una funzione speciale 
chiamata {\tt
quote-insert}. Tutto quello che fa {\tt quote-insert} \`e leggere il
tasto seguente ed inserirlo letteralmente nel buffer, senza tentare
di
interpretarlo come comando. Questo \`e il modo per inserire caratteri Control
nei file con Emacs. Naturalmente per inserire un C-q bisogna premere
{\tt
C-q} due volte!

Emacs ha anche molte funzioni che non sono associate a nessun tasto. Per
esempio, se state scrivendo un messaggio lungo, non dovete
premere
\ret alla fine di ogni linea; potete farlo fare ad Emacs 
(gli si pu\`o far fare qualsiasi cosa)---il comando per farlo \`e
{\tt auto-fill-mode}, ma non \`e normalmente associato a nessun tasto. Per
richiamare questo comando \`e sufficiente digitare ``{\tt
M-x~auto-fill-mode}''.
``{\bf\tt M-x}'' \`e il tasto usato per richiamare le funzioni per
nome. Potete
usarlo anche per richiamare funzioni come {\tt next-line} e {\tt
previous-line}, ma sarebbe molto poco efficiente, dato che gi\`a sono
associate a {\tt C-n} e {\tt C-p}!

Ad ogni modo, se guardate la riga di stato dopo aver richiamato {\tt
auto-fill-mode}, noterete che \`e stata aggiunta la parola ``Fill'' sul
lato
destro. Fintanto che rimane l\`{\i}, Emacs suddivider\`a
automaticamente il testo in linee. Potete sospendere questa funzione 
premendo nuovamente ``{\tt
M-x~auto-fill-mode}''---\`e un comando di commutazione.

Il lato negativo di digitare lunghi nomi di funzioni nel minibuffer \`e
minimo, dato che
Emacs completa
i nomi delle funzioni nello stesso
modo che i nomi dei file, quindi raramente vi capiter\`a di dover
scrivere per intero il nome della funzione.
Se non siete sicuri se
potete usare il completamento automatico, premete \key{Tab}. Non
preoccupatevi, nel peggiore dei casi vi mostrer\`a l'elenco dei comandi
possibili, altrimenti, se siete fortunati, completer\`a il comando voluto.


\section{Chiedere aiuto ad Emacs}

Emacs ha una guida molto esauriente---tanto esauriente, in effetti,
che ne possiamo appena accennare il contenuto. Le caratteristiche
basilari della
guida sono accessibili premendo {\tt C-h} e poi una singola
lettera. Per esempio, {\tt C-h~k} fornisce la guida su un tasto 
(vi chiede di premere un tasto e vi dice cosa fa). {\tt C-h~t} vi
porta in un breve manuale di Emacs.
{\tt C-h~C-h} apre la guida della guida, per dirvi cosa \`e
disponibile una volta premuto il tasto {\tt C-h} la prima volta. Se
sapete il nome di una funzione di Emacs ({\tt save-buffer}, per
esempio), ma non vi ricordate a quale sequenza di tasti \`e associata, 
allora usate {\tt C-h~w}, per ``{\tt where-is}'' (dov'\`e), e
digitate il nome della funzione. Oppure, se volete sapere cosa fa
una funzione in dettaglio, usate {\tt C-h~f}, che vi chiede il nome di
una funzione.

Ricordatevi, dato che Emacs esegue il completamento del nome delle
funzioni, non dovete essere sicuri del nome di una funzione per
richiedere la relativa pagina della guida: 
se pensate di poter indovinare come inizia
il
nome, digitatelo e premete \key{Tab} per vedere se il completamento fa
qualcosa, altrimenti tornate indietro e riprovate con
qualcos'altro. Lo stesso vale per i nomi dei file: anche se non vi
ricordate tutto il nome che avete dato ad un file che non toccate da
tre mesi, potete provare ad usare il completamento per trovare
il nome giusto. Imparate ad usare il completamento anche per chiedere
informazioni, non solo come un modo per risparmiare digitazioni.

Ci sono altri caratteri che potete digitare dopo {\tt C-h}, e ognuno
vi d\`a una guida di tipo diverso. Quelli che userete pi\`u spesso
sono
{\tt C-h~k}, {\tt C-h~w} e {\tt C-h~f}. Quando avrete pi\`u familiarit\`a
con Emacs, un altro da provare \`e {\tt C-h~a}, che chiede una stringa e
vi comunica tutte le funzioni il cui nome contiene quella stringa
(``a'' sta per ``apropos'', a proposito di\dots).

Un'altra sorgente di informazioni \`e il lettore di  documentazione {\bf
Info}. Info \`e un argomento troppo complesso da approfondire qui, ma se
vi interessa esplorarlo da soli, digitate {\tt C-h~i} e
leggete il paragrafo in cima allo schermo, che vi dir\`a come
ottenere maggiore aiuto.


\section{I buffer specializzanti: le modalit\`a}\label{emacs-mail-mode}
 
I buffer di Emacs hanno delle {\bf modalit\`a} associate ad
essi\footnote{Per
renderla un po' pi\`u complicata, esistono delle ``modalit\`a maggiori''
e delle
``modalit\`a minori'', ma ancora non vi serve saperlo.}; la ragione \`e
che
avete bisogno di cose diverse
se state scrivendo una mail o, ad
esempio, se state scrivendo un programma. Invece di cercare di fare
un editor che venisse sempre incontro ai bisogni di tutti (che
sarebbe impossibile), il progettista di Emacs\footnote{Richard
Stallman\index{Stallman, Richard}, noto anche come 
  ``{\tt rms}'', che \`e il suo nome di login.} ha scelto di far
comportare Emacs in modo diverso a seconda di cosa state facendo in
ciascun buffer. Quindi, i buffer hanno delle modalit\`a, ciascuna
progettata per un'attivit\`a specifica. La caratteristica principale
che distingue una modalit\`a dall'altra sono i corrispondenti da
tastiera, ma ci possono essere anche altre differenze.
 
La modalit\`a pi\`u semplice \`e la {\tt fondamentale}, che non ha nessun
comando speciale. In effetti, ecco cosa dice Emacs della Modalit\`a
Fondamentale:
 
\begin{tt}
   \begin{verbatim}
Fundamental Mode:
 
Major mode not specialized for anything in particular.
Other major modes are defined by comparison with this one.
\end{verbatim}
\end{tt}

Cio\`e:

\begin{tt}
	\begin{verbatim}
(Modalita' fondamentale:

Principale modalita', non specializzata per niente in particolare. 
Le altre modalita' maggiori vengono definite in confronto ad essa.)
\end{verbatim}
\end{tt}
 
Per avere queste informazioni ho fatto cos\`{\i}: ho digitato {\tt C-x~b},
che corrisponde a {\tt switch-to-buffer} (passa al buffer), ed ho digitato ``pippo''
quando mi ha chiesto il nome del buffer a cui passare. Dato che non
esisteva un buffer che si chiamava ``pippo'', Emacs lo ha creato e ci
\`e passato. Per default era in modalit\`a fondamentale, ma se non lo
fosse stato avrei potuto digtare ``{\tt M-x~fundamental-mode}'' per
portarcelo.  Tutti i nomi delle modalit\`a hanno un comando ``{\tt
<nome-modalit\`a>-mode} che porta il buffer corrente in quella
modalit\`a. Poi, per avere le informazioni sulla modalit\`a maggiore del
buffer, ho digitato  {\tt C-h~m}, che d\`a la guida sulla modalit\`a
maggiore corrente del buffer in cui vi trovate.
 
C'\`e una modalit\`a leggermente pi\`u utile che si chiama {\tt text-mode},
che ha i comandi speciali {\tt M-S}, per {\tt center-paragraph},
(centra-paragrafo), e {\tt M-s}, che richiama {\tt center-line}
(centra-linea). {\tt M-S}, in ogni caso, significa proprio quello che
pensate: tenete premuti il tasto \key{Meta} ed il tasto \key{Shift},
e premete ``S''.
 
Non vi fidate di me---create un buffer nuovo, portatelo in
modalit\`a testo ({\tt
text-mode}), e digitate {\tt C-h~m}.  Forse non capirete tutto quello
che Emacs vi dir\`a, ma dovreste ricavarne delle informazioni utili.
 
Ecco un'introduzione ad alcune delle modalit\`a usate pi\`u comunemente.
Se le usate, assicuratevi di digitare {\tt C-h~m} in tutte, per avere
altre informazioni su tutte le modalit\`a.

\section{Modlit\`a di programmazione}
 
\subsection{Modalit\`a C}
 
Se usate Emacs per programmare in linguaggio C\index{C}, gli potete
far rientrare le linee automaticamente. I file con nomi che finiscono
per ``{\tt .c} '' o ``{\tt .h}'' vengono aperti automaticamente in
modalit\`a {\tt c-mode}, in cui sono disponibili alcuni comandi
speciali, utili per scrivere programmi in C. In modalit\`a C, \key{Tab}
corrisponde al comando {\tt c-indent-command}, cio\`e, premendo il tato
\key{Tab} non si inserisce un carattere di tabulazione vero e
proprio, ma la linea viene rientrata a seconda della sua posizione
nel programma. Questo implica che Emacs conosce qualcosa della
sintassi del C, ed \`e vero, anche se non sa niente della
semantica---non pu\`o fare in modo che il vostro programma non contenga
errori!
 
Per calcolare il rientro della linea {\tt emacs} assume che le linee precedenti siano rientrate
correttamente. Se nella linea precedente manca una parentesi tonda o 
graffa, un
punto e virgola, o qualcos'altro del genere, Emacs rientrer\`a la linea
in maniera sbagliata. Quando vedrete che fa cos\`{\i}, saprete che dovete
controllare la punteggiatura della linea precedente.
 
Potete usare questa caratteristica per controllare la punteggiatura
dei programmi---invece di leggere il programma intero cercando gli
errori, fate rientrare le linee dall'inizio del programma usando
\key{Tab}, e quando vedete che i rientri sono strani, controllate le
linee precedenti. In altre parole, fate lavorare Emacs!
 
 
\subsection{Modalit\`a Scheme}
% kff: larry, I include this because people at our school are using
% this document too, and they need scheme for classes.  Also, with 
% the
% availability of SCM, scheme seems to be gaining some popularity
% among linuxers.  Feel free to remove this subsection if you think
% it's not necessary, though.  Is there a way to do a conditional
% include in LaTeX?  Would you like me to make this multifile and use
% \include and \includeonly ?
 

\`E una modalit\`a maggiore che non vi servir\`a a niente se non avete un
compilatore o un interprete per il linguaggio di programmazione
Scheme. Averlo non \`e cos\`{\i} frequente come, ad esempio, avere un
compilatore C, ma sta diventando molto comune, quindi ne parleremo
lo stesso. Molto di ci\`o che vale per la modalit\`a Scheme\index{Scheme}
vale anche per la modalit\`a Lisp, se preferite scrivere in
Lisp\index{lisp}.

Beh, per farla complicata, Emacs ha due modalit\`a Scheme diverse,
perch\'e ci sono due diverse correnti di pensiero. Quella che
descriver\`o si chiama  {\tt cmuscheme}\ttindex{cmuscheme}, e poi,
nella sezione sulla personalizzazione di Emacs, parler\`o di come ci
possano essere due modalit\`a Scheme diverse, e come usarle. Per adesso
non vi preoccupate se quello che succede sul vostro Emacs non
corriponde perfettamente a quello che dico qui. Un editor
personalizzabile \`e per forza imprevedibile, e non c'\`e niente da fare! 
 
% todo: this won't work unless Emacs knows where to find the scheme
% interpreter.  Should we talk about that?  Yes, in the section on
% elisp, mention setting scheme-program-name.
 
In Emacs potete far girare un processo Scheme interattivo, con il
comando {\tt M-x run-scheme}.  Questo comando crea un buffer con nome 
``{\tt *scheme*}'', che contiene il normale prompt di Scheme. Al
prompt potete inserire espressioni Scheme, premere \key{Invio}, e
Scheme le valuter\`a e mostrer\`a la risposta. Poi, per poter interagire
con il processo Scheme, potete inserire tutte le definizioni di
funzioni e le applicazioni che volete. Probabilmente avete gi\`a
scritto del codice sorgente Scheme in qualche file, e sarebbe pi\`u
facile lavorare su quel file e mandare le definizioni al buffer del
processo di Scheme, se necessario.
 
Se i file sorgente finisce per ``{\tt .ss}'' o ``{\tt .scm}'',
verr\`a aperto automaticamente in {\bf modalit\`a Scheme} quando lo
trovate con {\tt C-x~C-f}. Se per qualche ragione non viene aperto in
modalit\`a Scheme, si pu\`o fare a mano con il comando {\tt M-x scheme-mode}.  
Questa modalit\`a {\tt scheme-mode} non \`e la stessa cosa del buffer in
cui gira il processo Scheme; piuttosto, il codice sorgente che si
trova in {\tt scheme-mode} ha dei comandi speciali per comunicare con
il buffer del processo.

Se vi mettete all'interno di una definizione di funzione nel buffer
del codice sorgente Scheme e digitate {\tt C-c~C-e}, quella
definizione verr\`a ``inviata'' al buffer del processo --- esattamente
come se ce l'aveste digitata dentro. {\tt C-c~M-e} invia la
definizione e poi vi porta nel buffer del processo per fare il lavoro
interattivo. {\tt C-c~C-l} carica un file di codice Scheme 
(funziona sia per il buffer del processo che per il buffer del codice
sorgente). Inoltre, come per le altre modalit\`a di programmazione,
digitare \key{Tab} in qualsiasi punto di una linea di codice fa
rientrare correttamente la linea.

Se siete al prompt del buffer del processo, potete usare {\tt M-p} e
{\tt M-n} per spostarvi tra i comandi che avete dato in precedenza
({\bf storia di input}). Cos\`{\i}, se state facendo il debug della
funzione {\tt `rotate'}, e l'avete gi\`a applicata a degli argomenti
del buffer del processo, cos\`{\i}:
 
\begin{screen}
   \begin{tt}
{\tt > (rotate '(a b c d e))}
   \end{tt}
\end{screen}
 
potete richiamare questo comando digitando {\tt M-p} al prompt.
Non ci dovrebbe essere bisogno di ridigitare espressioni lunghe al
prompt di Scheme --- abituatevi ad usare la storia di input e
risparmierete un sacco di tempo.
 
Emacs conosce un bel po' di linguaggi di programmazione: C, C++, Lisp
e Scheme sono solo alcuni. In genere, sa come fare i rientri delle
linee in modo intuitivo.
 
\subsection{Modalit\`a posta}
 
Con Emacs si possono anche creare e mandare messaggi di posta
elettronica\index{e-mail}.  Per entrare in un buffer di posta,
digitate {\tt C-x~m}. Dovete riempire i campi {\tt To:} e {\tt
Subject:}, ed usare C-n per scendere sotto la linea separatrice e
scrivere il corpo del messaggio (che inizialmente \`e vuoto). Non
modificate o cancellate la linea separatrice, o Emacs non potr\`a
spedire il messaggio---usa quella linea per distinguere
l'intestazione del messaggio, che gli dice dove spedirlo, dal vero
contenuto del messaggio stesso.

Sotto la linea separatrice potete scrivere quello che volete. Quando
siete pronti a spedire, digitate {\tt C-c~C-c}, ed Emacs spedir\`a il
messaggio e canceller\`a il buffer della posta.
 
\section{Come essere ancora pi\`u efficienti}
 
Gli utenti esperti di Emacs sono fanatici dell'efficienza. In
effetti, perderanno spesso un sacco di tempo per cercare dei modi per
essere pi\`u efficienti! Anche se non voglio che succeda anche a voi,
ecco alcuni facili suggerimenti per diventare un utente di Emacs pi\`u
bravo. Talvolta gli utenti esperti fanno sentire i novellini degli
scemi perch\'e non conoscono questi trucchi---per qualche strana
ragione, la gente diventa quasi ``religiosa'' per usare Emacs
``correttamente''; condannerei questo tipo di elitarismo, se non ne
fossi colpevole anche io. Ecco qui:

Quando vi spostate nel testo, usate il modo pi\`u veloce. Sapete che
{\tt C-f} sta per {\tt forward-char} (avanti di un
carattere)---riuscite ad indovinare che {\tt M-f} sta per {\tt
forward-word} (avanti di una parola)? {C-b} sposta indietro di un
carattere. Cosa far\`a {\tt M-b}? E non \`e tutto: vi potete spostare in
avanti di una frase alla volta con {\tt M-e}, se alla fine di una
frase mettete almeno due spazi dopo il punto finale (altrimenti Emacs
non si accorge di dove finisce la frase e ne inizia un'altra). {\tt
M-a} sposta indietro di una frase.
 
Se vi ritrovate ad usare {\tt C-f} multipli per arrivare alla fine
della linea, vergognatevi e la prossima volta usate {\tt C-e}, e {\tt
C-a} per andare all'inizio della linea. Se usate molti {\tt C-n} per
spostarsi in gi\`u schermata per schermata, vergognatevi e d'ora in poi
usate {\tt C-v}. Se usate ripetutamente {\tt C-p} per scorrere in
alto di parecchie pagine, vergognatevi di farvi vedere in pubblico ed
usate {\tt M-v}.

Se siete quasi alla fine di una linea e vi accorgete che avete
sbagliato qualcosa all'inizio della linea, {\em non usate}
\key{Backspace} o \key{Canc} per tornare indietro\dots dovreste
cancellare delle intere parole scritte bene! Invece, usate delle
combinazioni di {\tt M-b}, {\tt C-b}, e {\tt C-f} per spostarsi
sull'errore, correggetelo, e poi usate {\tt C-e} per spostarvi di
nuovo alla fine della linea.
 
Quando dovete digitare il nome di un file, non inseritelo mai tutto.
Digitate abbastanza caratteri per identificarlo univocamente, e fate
fare il resto al completamento di Emacs premendo \key{Tab} o
\key{Spazio}. Perch\'e sprecare digitazioni se invece potete sprecare
cicli di CPU?
 
Se state digitando del testo semplice, e il testo non vi va a capo,
usate {\tt M-q}, che corrisponde a {\tt fill-paragraph} nelle normali
modalit\`a di testo. Vi ``aggiuster\`a'' il paragrafo come se foste
andati a capo linea per linea a mano. {\tt M-q} funziona solo da
dentro il paragrafo, o dal suo inizio o dalla fine.

Qualche volta aiuta usare  {\tt C-x~u}, ({\bf undo}), che cercher\`a di
annullare gli ultimi cambiamenti fatti. Emacs tira ad indovinare
quanti passaggi annullare; di solito \`e molto intelligente. Richiamare
il comando pi\`u volte annuller\`a sempre pi\`u comandi, finch\'e Emacs non
si ricorder\`a pi\`u quali cambiamenti sono stati fatti.
 
\section{Personalizzare Emacs}
 
% Dang it, I *am* going to talk about elisp.  They're gonna become
% pros if it kills them!
 
% todo: need to talk about xscheme vs. cmuscheme and what load-path,
% .emacs, default.el and the distribution lisp dir have to do with
% it,
% the elisp info manual, setting keys, binding variables.  Defining
% functions?  Should we cover things like `let', or tell people to go
% learn Lisp first?

Emacs \`e {\em cos\`{\i}\/} 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 \`e un dialetto del Lisp; se avete precedenti esperienze
in Lisp lo troverete abbastanza facile.

Altrimenti, non vi preoccupate: non entrer\`o molto nei particolari, perch\'e \`e
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\`a di Emacs vengono definite nei file di
Emacs Lisp\footnote{Talvolta chiamate non ufficialmente ``Elisp''.} 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 \`e stato installato sul vostro sistema --- posti comuni sono
{\tt /usr/lib/emacs/lisp}, {\tt /usr/lib/emacs/19.19/lisp/}, eccetera.
``{\tt 19.19}'' \`e il numero di versione di Emacs, e sul vostro sistema pu\`o
essere diverso.

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

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

\begin{screen}
   \begin{tt}
load-path
   \end{tt}
\end{screen}

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

\begin{screen}
   \begin{tt}
load-path\key{C-j} \\
("/usr/lib/emacs/site-lisp/vm-5.35" "/home/kfogel/elithp" \\
 "/usr/lib/emacs/site-lisp" "/usr/lib/emacs/19.19/lisp")
   \end{tt}
\end{screen}

Non sar\`a la stessa su tutti i sistemi, naturalmente, dato che dipende da
come \`e stato installato Emacs. L'esempio qui sopra viene da un sistema PC
386 con Linux. Come indica il testo qui sopra, {\tt load-path} \`e un elenco
di stringhe; il nome di ogni stringa indica una directory che pu\`o 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'\`e una directory
che non esiste nel filesystem, Emacs la ignora.

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

\begin{screen}
   \begin{tt}
(global-set-key "\verb+\+C-cl" 'goto-line)
   \end{tt}
\end{screen}

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

Va tutto bene, ma come facevo a sapere che il nome della funzione era  
``{\tt goto-line}''?  Potevo sapere solo di voler far corrispondere
il tasto {\tt 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?

\`E 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 {\tt C-h~f} (che sta per {\tt
describe-function}, e quindi d\`a la descrizione di una funzione), e
poi digitate \key{Tab} senza scrivere niente. In questo modo chiedete
ad Emacs di completare una stringa vuota, e quindi Emacs elenca tutte
le funzioni! Ci vorr\`a un po' per fare la lista completa, dato che
Emacs ha molte funzioni interne, ma quando \`e pronto ne mostrer\`a tante
quante ne entrano nello schermo.

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

Se volete usare un altro metodo, provate con {\tt C-h~a}, {\tt
command-apropos}, che mostra tutte le funzioni il cui nome contiene
la stringa data. L'output di {\tt command-apropos} \`e un po' pi\`u
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\`u. 

C'\`e sempre la possibilit\`a che Emacs non abbia nessuna funzione
predefinita che faccia quello che volete. In questo caso, dovrete
scrivervi la funzione da soli. Non vi parler\`o 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 \`e
molto difficile---per darvi un'idea, ne ho scritte 131 nell'ultimo
anno. Richiede un po' di pratica, ma non \`e difficile da imparare.

Un'altra cosa che si fa spesso nel file {\tt .emacs} \`e impostare
alcune variabili a valori predefiniti. Per esempio, mettete  questa
linea nel vostro file {\tt .emacs}, ed avviate una nuova copia di
Emacs:
 
\begin{screen}
   \begin{tt}
(setq inhibit-startup-message t)
   \end{tt}
\end{screen}
 
Emacs controlla il valore della variabile {\tt 
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 {\tt setq} per
impostare questa variabile al valore `{\tt  t}', uno speciale valore
Lisp che significa {\bf vero} (true). L'opposto di `{\tt t}' e `{\tt
nil}', che \`e il valore predefinito per `{\bf falso}' nell'Emacs
Lisp. Ed ecco due cosette che ho nel mio {\tt .emacs} e che possono
essere utili:
 
\begin{screen}
   \begin{tt}
(setq case-fold-search nil) ; non considera le maiuscole nelle
ricerche\\
;; fa rientrare i programmi C come piace a me: \\
(setq c-indent-level 2)
   \end{tt}
\end{screen}
 
La prima espressione non fa considerare le maiuscole nell ricerche
(compreso {\tt isearch}); cio\`e, la ricerca dar\`a 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\`u piccoli del normale---\`e solo un gusto personale; trovo che renda
il codice C pi\`u leggibile.

Il carattere di commento nel Lisp \`e ``{\tt ;}''. Emacs ignora
qualsiasi cosa che segua un  punto e virgola, cos\`{\i}:
 
\begin{screen}
   \begin{tt}
;; queste due linee vengono ignorate dall'interprete Lisp, ma\\
;; l'espressione seguente viene valutata appieno:\\
(setq una-stringa-letterale "Una strana pausa; per nessun motivo.")
   \end{tt}
\end{screen}
 
\`E 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 {\tt C-h~v} e {\tt
describe-variable} per creare una lista dei completamenti, oppure usate
{\tt C-h~C-a} {\tt apropos}. {\tt Apropos} si distingue da {\tt C-h~a},
{\tt 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 \`e ``{\tt .el}'', come in
``{\tt c-mode.el}''. Comunque, per rendere pi\`u veloce il codice Lisp,
Emacs permette di compilarlo byte per byte; questi file di codice Lisp
compilato hanno estensione ``{\tt .elc}'' invece di ``{\tt .sl}''.
L'eccezione a questa regola \`e il file  ``{\tt .emacs}'', che non ha
bisogno dell'estensione {\tt .el} perch\'e Emacs sa dove cercarlo all'avvio. 

Per compilare un file di codice Lisp interattivamente, usate il comando
{\tt M-x load-file}. Vi chieder\`a il nome del file. Per caricare i file
 
\begin{screen}
   \begin{tt}
(load "c-mode") ; forza Emacs a caricarlo in c-mode.el o .elc
   \end{tt}
\end{screen}

Emacs aggiunger\`a per prima cosa l'estensione {\tt .elc} al nome del file e
prover\`a a cercarlo in qualche directory del {\tt load-path}. Se non ci
riesce, prover\`a con l'estensione  {\tt .sl}, oppure user\`a la stringa
letterale che viene passata a {\tt load}. Potete compilare byte per byte
un file con il comando {\tt M-x byte-compile-file}, ma se modificate il
file spesso, probabilmente non vi conviene. Non dovreste mai compilare
cos\`i il file {\tt .emacs}, n\'e dargli l'estensione {\tt .el}.
 
Dopo che sar\`a stato caricato {\tt .emacs}, Emacs cercher\`a di caricare un
file con nome {\tt default.el}. Di solito si trova in una directory, nel
load-path, che si chiama {\tt site-lisp} o {\tt local-elisp} o qualcosa
del genere (vedere l'esempio di {\tt 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 {\tt .emacs} personale. Nemmeno
{\tt default.el} dovrebbe essere compilato, dato che normalmente viene
modificato
abbastanza spesso.
 
Se  il {\tt .emacs} di qualcuno contiene degli errori, Emacs non cerca di
caricare  {\tt defaul.el}, ma si ferma, mandando un messaggio che dice
``{\tt Error in init file}'' (``Errore nel file di inizializzazione''). Se
vedete un messaggio del genere, probabilmente c'\`e qualcosa di sbagliato
nel file {\tt .emacs}.

C'\`e ancora un tipo di espressione che si ritrova spesso nei
file {\tt .emacs}.
La libreria di Emacs Lisp spesso offre dei pacchetti multipli per
fare la stessa cosa in modi diversi; bisogner\`a cos\`{\i} specificare quale
volete usare (o dovrete usare il pacchetto di default, che non \`e 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):
{\tt xscheme} e {\tt cmuscheme}.
 
\begin{screen}
   \begin{verbatim}
prompt> ls /usr/lib/emacs/19.19/lisp/*scheme*
/usr/lib/emacs/19.19/lisp/cmuscheme.el
/usr/lib/emacs/19.19/lisp/cmuscheme.elc
/usr/lib/emacs/19.19/lisp/scheme.el
/usr/lib/emacs/19.19/lisp/scheme.elc
/usr/lib/emacs/19.19/lisp/xscheme.el
/usr/lib/emacs/19.19/lisp/xscheme.elc
   \end{verbatim}
\end{screen}
 
A me l'interfaccia di {\tt cmuscheme} piace molto di pi\`u di quella di
default, che \`e {\tt xscheme}. Come posso far usare ad Emacs quella che
piace di pi\`u a me? Mettendo queste linee in {\tt .emacs}:
 
\begin{screen}
   \begin{tt}
;; notate come l'espressione pu\`o essere spezzata in pi\`u linee. Il Lisp\\
;; in genere ignora gli spazi vuoti:\\
(autoload 'run-scheme "cmuscheme" \\
        "Avvia uno Scheme inferiore, come lo voglio io." t)
   \end{tt}
\end{screen}
 
La funzione {\tt autoload} prende come argomento il nome di una funzione
(tra apici ``{\tt '}'', per ragioni che hanno a che fare con il Lisp) e
dice ad Emacs che tale funzione \`e definita in un determinato file. Il
file \`e il secondo argomento, una stringa (senza l'estensione ``{\tt .el}''
o ``{\tt .elc}'') che indica il nome del file da cercare nel
{\tt load-path}.

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

Adesso che {\tt run-scheme} \`e stata definita come funzione autoavviabile,
cosa succede quando digito {\tt M-x run-scheme}? Emacs cerca la funzione
{\tt run-scheme}, vede che \`e impostata per venire autoavviata, e carica il
file indicato dall'autoavviamento (in questo caso, ``{\tt cmuscheme}'').
Il file compilato byte per byte {\tt cmuscheme.elc} esiste, quindi Emacs
lo caricher\`a. Questo file {\em deve\/} definire la funzione {\tt
run-scheme}, o ci sar\`a un errore nell'autocaricamento. Per fortuna lo fa,
quindi tutto va liscio, ed io ottengo la mia interfaccia Scheme
preferita\footnote{Tra l'altro, {\tt cmuscheme} era l'interfaccia di cui
stavo parlando pi\`u indietro, nella sezione su come lavorare con Scheme,
quindi se volete usare il materiale di quel capitolo, dovete assicurarvi
di stare usando {\tt cmuscheme}.}.

Un ``autocaricamento'' \`e come una promessa fatta ad Emacs che, quando
sar\`a il momento, potr\`a 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\'e 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 \`e 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 {\tt .emacs}:
sono stati preimpostati all'interno di Emacs stesso.
 
\section{Scoprirne di pi\`u}
 
Non vi ho detto tutto quello che c'\`e da sapere su Emacs. In effetti, non
credo di avervene detto nemmeno l'1\%. Anche se ne sapete abbastanza per
andare avanti, ci sono ancora moltissimi trucchetti per salvare tempo e
cose comode che dovreste trovare. Il miglior modo di farlo \`e aspettare
finch\'e non vi serve qualcosa, e poi cercare una funzione che la faccia.

Non potr\`o mai sottolineare abbastanza l'importanza di saper usare la guida
in linea di Emacs. Ad esempio, supponiamo che vogliate inserire il
contenuto di un file in un buffer gi\`a aperto su un file diverso, in modo
che il buffer li contenga entrambi. Beh, se tiraste ad indovinare che c'\`e
un comando che si chiama {\tt insert-file}, ci indovinereste. Per
controllare, digitate {\tt C-h~f}. Al prompt del minibuffer, digitate il
nome della funzione su cui volete la guida. Dato che sapete che esiste il
completamento dei nomi delle funzioni, e potete indovinare che il comando
che state cercando inizia per ``insert'', digitate insert e premete
\key{Tab}; vi verranno mostrati tutti i nomi delle funzioni che cominciano
per ``insert'', tra cui anche ``insert-file''.
 
Completate quindi il nome della funzione e leggete come funziona, e poi
usate {\tt M-x insert-file}. Se vi state chiedendo se \`e collegata ad un
tasto, digitate {\tt C-h~w~insert-file} \key{Invio}, e scopritelo. Pi\`u
cose sapete della guida di Emacs, pi\`u facilmente gli potete porre domande.
La capacit\`a di farlo, unita ad uno spirito di esplorazione ed alla volont\`a
di imparare nuovi modi di fare le cose vi porteranno a risparmiare un
sacco di tempo.

Per ordinare una copia del manuale per l'utente di Emacs e/o del manuale
della programmazione Lisp per Emacs, scrivete a: 
 
\begin{samepage}
   \begin{quote}
Free Software Foundation \\
675 Mass Ave \\
Cambridge, MA 02139 \\
USA
   \end{quote}
\end{samepage}
 
Entrambi questi manuali sono distribuiti elettronicamente con Emacs, in
forma leggibile usando il lettore di documentazione Info ({\tt C-h~i}), ma
pu\`o essere pi\`u facile usare la versione ad albero che quella in linea.
Inoltre, il prezzo \`e ragionevole, e i soldi vanno per una giusta
causa---software libero di qualit\`a! Una volta o l'altra dovreste leggere
le condizioni di copyright di Emacs con {\tt C-h~C-c}. \`E pi\`u
interessante di quanto pensiate, e vi aiuter\`a a chiarirvi il concetto di
software libero. Se pensate che il termine ``software libero'' (``free
software'') vuol dire semplicemente che il programma \`e gratis, per favore
leggete il copyright appena ne avete il tempo!
 
\ettindex{emacs}
 
% Local Variables:
% mode: latex
% TeX-master: "guide"
% End:
