Indici (nodi che contengono menù ampi)

Concetti Generali

Comandi Fondamentali

Comandi importanti che modificano il testo

Le strutture fondamentali di Emacs

Funzionalità avanzate

Risoluzione dei problemi

Qui di seguito sono riportati altri nodi che stanno ad un livello gerarchicamente inferiore a quelli già elencati, in modo da potervi accedere rapidamente in un solo passo.

--- Lista dettagliata dei nodi ---

Organizzazione dello schermo

Comandi di base

Il minibuffer

Aiuto

Il mark e le regioni

Tagliare ed eliminare

Incollare

Registri

Controllo dello schermo

Ricerche e sostituzioni

Sostituzioni

Comandi per correggere errori di digitazione.

Gestione dei file

Salvare file

Controllo di versione

Usare più buffer

Usare più finestre

I frame e X Window

Modi di supporto al modo Font Lock

Supporto di set di caratteri internazionali

Major Modes

Indentation

Commands for Human Languages

Filling Text

Editing Programs

Indentation for Programs

Tags Tables

Merging Files with Emerge

Compiling and Testing Programs

Running Debuggers Under Emacs

Abbrevs

Editing Pictures

Sending Mail

Reading Mail with Rmail

Dired, the Directory Editor

The Calendar and the Diary

Movement in the Calendar

Conversion To and From Other Calendars

The Diary

GNUS

Running Shell Commands from Emacs

Customization

Variables

Keyboard Macros

Customizing Key Bindings

The Init File, ~/.emacs

Dealing with Emacs Trouble

Reporting Bugs

Command Line Options and Arguments

Environment Variables

MS-DOS and Windows 95/98/NT

Nota del traduttore

Questa non è una traduzione letterale. Sebbene nelle intenzioni originarie vi fosse esattamente l'opposto, la traduzione letterale dei primi capitoli risultava in un qualcosa che non rendeva assolutamente giustizia né al testo originale, né alla lingua italiana, né a GNU Emacs nel suo complesso. Considerato che questo manuale ha anche scopi introduttivi, ed è quindi rivolto anche a principianti assoluti, ho preferito adottare alcuni criteri che permettessero di ottenere un testo leggibile senza assolutamente sacrificare i contenuti.

• Il testo all'interno dei singoli paragrafi è stato adattato per risultare più leggibile in Italiano. La struttura dei paragrafi, tuttavia, è rimasta immutata, visti i numerosi riferimenti incrociati.
• In linea di massima non sono stati tradotti termini come point, mark, buffer o frame, che identificano concetti precisi in Emacs e non hanno corrispondenti altrettanto efficaci in Italiano, ma che hanno una definizione all'interno del testo e sono formati da una sola parola. In particolare, i nomi dei comandi e delle variabili sono immutati rispetto all'originale.
• <RET> e <SPC> vengono indicati rispettivamente con <Invio> e <Spazio>.
• Sono stati tradotti, invece, termini come window, o minibuffer command, che hanno corrispondenza diretta in Italiano, o che sono composti da più parole.
• I termini erase, kill e yank (e derivati) sono stati tradotti rispettivamente con i più familiari elimina, taglia (o copia a seconda dei casi) ed incolla. Spero che i fedelissimi di Emacs non ne abbiano a male in questa piccola rivoluzione.
• Il termine face, che indica una particolare combinazione di attributi del testo (colori, font, etc.), è stato tradotto con stile.
• Per semplicità, i pulsanti del mouse sono indicati con pulsante sinistro, pulsante centrale e pulsante destro invece che con mouse-1, mouse-2 e mouse-3. Questa rappresenta la tipica configurazione dell'X Window System con un mouse a tre tasti usato con la mano destra ¹
• Per non creare problemi di comprensione, i vari -ring (quali kill-ring) sono diventati "liste" o "elenchi" (il che è tutto sommato corretto, visto che la rappresentazione interna di un ring è quasi sempre una lista, anche se gestita in modo circolare).
• Non è stato altres`i tradotto quanto marcato nei sorgenti texinfo come commento (@c) o come testo da ignorare (testo compreso tra blocchi @ignore e @end ignore), trattandosi questo di testo che non viene riportato nella documentazione finale.
• Le sezioni The GNU Manifesto, Distribution e GNU General Public Licence non sono state tradotte, e sono riportate esattamente come nell'originale. Chi disponga di traduzioni autorizzate dalla Free Software Foundation di quanto sopra è naturalmente incoraggiato a sostituirle nel testo (e di rimuovere di conseguenza questo ultimo punto).

Distribution

GNU Emacs is free software; this means that everyone is free to use it and free to redistribute it on certain conditions. GNU Emacs is not in the public domain; it is copyrighted and there are restrictions on its distribution, but these restrictions are designed to permit everything that a good cooperating citizen would want to do. What is not allowed is to try to prevent others from further sharing any version of GNU Emacs that they might get from you. The precise conditions are found in the GNU General Public License that comes with Emacs and also appears following this section.

One way to get a copy of GNU Emacs is from someone else who has it. You need not ask for our permission to do so, or tell any one else; just copy it. If you have access to the Internet, you can get the latest distribution version of GNU Emacs by anonymous FTP; see the file etc/FTP in the Emacs distribution for more information.

You may also receive GNU Emacs when you buy a computer. Computer manufacturers are free to distribute copies on the same terms that apply to everyone else. These terms require them to give you the full sources, including whatever changes they may have made, and to permit you to redistribute the GNU Emacs received from them under the usual terms of the General Public License. In other words, the program must be free for you when you get it, not just free for the manufacturer.

You can also order copies of GNU Emacs from the Free Software Foundation on CD-ROM. This is a convenient and reliable way to get a copy; it is also a good way to help fund our work. (The Foundation has always received most of its funds in this way.) An order form is included in the file etc/ORDERS in the Emacs distribution, and on our web site in <http://www.gnu.org/order/order.html>. For further information, write to

Free Software Foundation
59 Temple Place, Suite 330
Boston, MA  02111-1307 USA
USA

The income from distribution fees goes to support the foundation's purpose: the development of new free software, and improvements to our existing programs including GNU Emacs.

If you find GNU Emacs useful, please send a donation to the Free Software Foundation to support our work. Donations to the Free Software Foundation are tax deductible in the US. If you use GNU Emacs at your workplace, please suggest that the company make a donation. If company policy is unsympathetic to the idea of donating to charity, you might instead suggest ordering a CD-ROM from the Foundation occasionally, or subscribing to periodic updates.

GNU GENERAL PUBLIC LICENSE

Version 2, June 1991

Copyright © 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

Preamble

The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too.

When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.

To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.

For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.

We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.

Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.

Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.

The precise terms and conditions for copying, distribution and modification follow.

0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you".

   Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.

1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.

   You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.

2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:
   1. You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.
   2. You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.
   3. If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)

   These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.

   Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.

   In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.

3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:
   1. Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
   2. Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,
   3. Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)

   The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.

   If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.

4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.
5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.
7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.

   If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.

   It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.

   This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.

8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.

   Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.

10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

How to Apply These Terms to Your New Programs

If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.

To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.

one line to give the program's name and an idea of what it does.
Copyright (C) 19yy  name of author

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this when it starts in an interactive mode:

Gnomovision version 69, Copyright (C) 19yy name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
type `show w'.  This is free software, and you are welcome
to redistribute it under certain conditions; type `show c'
for details.

The hypothetical commands show w and show c should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than show w and show c; they could even be mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright
interest in the program `Gnomovision'
(which makes passes at compilers) written
by James Hacker.

signature of Ty Coon, 1 April 1989
Ty Coon, President of Vice

This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License.

Introduzione

Questo manuale documenta GNU Emacs, ovvero la versione GNU di quel programma visuale, avanzato, auto-documentante, in tempo reale, personalizzabile ed estensibile che va sotto il nome di Emacs.

Emacs viene definito visuale in quanto il testo su cui si lavora è normalmente visibile sullo schermo, ed esso viene automaticamente aggiornato a mano a mano che si introducono i vari comandi. See Display.

Emacs è avanzato in quanto fornisce funzionalità che vanno ben oltre il semplice inserimento e la cancellazione di testo: si parla di controllo di sub-processi, di formattazione automatica di codice sorgente, di visualizzazione di due o più file alla volta, di stesura di testo formattato, di gestione effettuata in termini di caratteri, parole, linee, frasi, paragrafi e pagine, come anche di gestione di espressioni e commenti in numerosi linguaggi di programmazione.

Auto-documentante significa che in ogni istante si può digitare un carattere speciale, ovvero Control-h, e vedere quali scelte sono a disposizione. È possibile inoltre servirsi di tale funzionalità per avere la documentazione di un comando, oppure per trovare tutti i comandi relativi ad un determinato argomento. See Help.

Personalizzabile significa che è possibile modificare con poco sforzo la definizione dei comandi di Emacs. Se ad esempio si usa un linguaggio di programmazione in cui i commenti iniziano con <** e terminano con **>, è possible modificare i comandi di manipolazione dei commenti in modo che usino le stringhe sopra indicate. (see Comments). Un altro tipo di personalizzazione consiste nella modifica dell'assegnamento dei comandi. Se si preferisce avere i quattro comandi base per il movimento del cursore (su, giù, sinistra e destra) in una configurazione a rombo sulla tastiera, è possibile ridefinire i tasti nel modo appropriato. See Customization.

Estensibile significa che è possibile andare oltre la semplice personalizzazione, e andare quindi a scrivere comandi completamente nuovi, ovvero programmi in linguaggio Lisp che sono eseguiti dall'interprete Lisp di Emacs. Emacs è un sistema "estensibile in linea", ovvero esso è diviso in numerose funzioni che si invocano l'un l'altra, ognuna delle quali è ridefinibile anche durante una sessione. Quasi tutte le componenti di Emacs possono essere sostituite senza che vi sia la necessità di fare una copia a parte di Emacs. La maggior parte dei comandi di Emacs sono stati scritti in Lisp; si sarebbero potute scrivere in Lisp anche le poche eccezioni esistenti, ma esse sono state scritte in C per questioni di efficienza. Sebbene solo dei programmatori siano in grado di scrivere un'estensione, essa può essere utilizzata in seguito da chiunque: a coloro che desiderino apprendere la programmazione in Emacs Lisp si raccomanda la lettura di Introduction to Emacs Lisp di Robert J. Chassell, anch'esso pubblicato dalla Free Software Foundation.

Emacs, quando eseguito all'interno dell'X Window System, offre i propri menù e provvede ad interpretare opportunamente le informazioni provenienti dal mouse. Tuttavia, Emacs può fornire molti dei benefici di un sistema grafico a finestre anche su terminali testuali: ad esempio, è possibile visualizzare o lavorare su numerosi file per volta, spostare e copiare testo tra file e lavorare sui file mentre si eseguono comandi della shell.

Organizzazione dello schermo

Se avviato in un terminale testuale, Emacs occupa l'intero schermo. Nell'X Window System, al contrario, Emacs si crea le proprie finestre grafiche. Il termine frame è utilizzato per indicare sia un'intera schermata in un terminale testuale che un'intera finestra di X Window, usata da Emacs. Entrambi i tipi di frame vengono usati allo stesso modo per visualizzare il testo su cui si sta lavorando. Appena avviato, Emacs visualizza un solo frame, ma se lo si desidera è possibile crearne altri. See Frames.

L'intero frame visualizzato quando si avvia Emacs è dedicato al testo su cui si sta lavorando, salvo che per le righe iniziali e quelle finali. L'area occupata dal testo è chiamata finestra. La prima riga è una barra dei menù, mentre l'ultima è una area messagi speciale, oppure una finestra di minibuffer ove compaiono le richieste ed é possibile inserire le proprie scelte o le proprie risposte. Più avanti nel testo vi sono informazioni più dettagliate su queste righe speciali.

La grande finestra contenente il testo è suddivisibile orizzontalmente o verticalmente in più finestre, ognuna delle quali può essere usata per un file differente. In questo manuale, la parola "finestra" si riferisce sempre ad una suddivisione di un frame di Emacs².

La finestra in cui si trova il cursore è la finestra selezionata, ed in essa è possibile effettuare modifiche. La maggior parte dei comandi di Emacs agisce implicitamente su tale finestra (i comandi provenienti dal mouse, tuttavia, agiscono generalmente sulla finestra in cui si è fatto click, anche se non è quella selezionata).

Quando non sono selezionate, le altre finestre mostrano del testo che può essere usato unicamente come riferimento. Se si utilizzano più frame nell'ambito dell'X Window System, la selezione di un frame provoca automaticamente la selezione di una delle finestre contenute in quel frame.

L'ultima riga di ogni finestra è una riga di stato che riassume ciò che sta accadendo in quella determinata finestra. Se il terminale può farlo, essa viene visualizzata in negativo, ovvero con il colore dei caratteri uguale al colore di sfondo e viceversa. Subito dopo aver avviato Emacs, essa inizia con --:--  *scratch*. La riga di stato mostra, ad esempio, informazioni relative al buffer mostrato nella finestra, quali modi primari e secondari sono in uso e se il buffer contiene delle modifiche non salvate.

• Point: Il punto nel testo ove operano i comandi di modifica.
• Echo Area: Brevi messaggi compaiono in fondo allo schermo.
• Mode Line: Interpretare la riga di stato.
• Menu Bar: Come usare la barra dei menù.

Il point

In Emacs, il cursore del terminale mostra il punto nel quale avranno effetto i comandi di modifica: esso viene chiamato point. Molti dei comandi di Emacs spostano il point attraverso il testo, cos`i da poter lavorare su parti differenti dello stesso. È possibile posizionare il point anche facendo click con il pulsante sinistro del mouse.

Sebbene il cursore sembri indicare un carattere, si dovrebbe pensare al point come un qualcosa che sta in mezzo a due caratteri: precisamente, esso sta prima del carattere che compare sotto il cursore. Ad esempio, se il testo è Pluto ed il cursore si trova sopra la lettera o, il point si trova tra la lettera t e la lettera o. Inserendo il carattere ! in tale posizione si ottiene Plut!o, con il point che ora si trova tra ! e o. Il cursore, pertanto, rimane sopra la lettera o.

Talvolta la gente parla del "cursore" quando intende indicare il "point", oppure parla di comandi che spostano il point in termini di comandi che "spostano il cursore".

Ogni terminale dispone di un solo cursore, e mentre si sta aggiornando lo schermo esso deve apparire nel luogo ove in quel momento si stanno visualizzando caratteri. Ciò non significa che il point si stia spostando: è solo che Emacs non ha modo di evidenziare il luogo dove sta il point se non quando ha finito di aggiornare lo schermo, ovvero quando il terminale è in attesa di dati³

Quando in Emacs si lavora su più file (ognuno aperto nel proprio buffer), la posizione del point è diversa per ciascun buffer. point. Un buffer momentaneamente non visibile conserva la propria posizione del point, in modo da poterla ripristinare qualora esso venga nuovamente visualizzato.

Se in un frame vi sono più finestre, ogni finestra conserva la propria posizione del point. Il cursore evidenzia la posizione del point nella finestra correntemente selezionata: ciò dà anche modo di sapere qual é la finestra selezionata. Se lo stesso buffer viene mostrato in piú di una finestra, ogni finestra memorizza la propria posizione del point all'interno del buffer.

Nel caso di più frame, ciascuno di essi può mostrare un cursore: il cursore nella finestra correntemente selezionata appare come un rettangolo pieno, mentre negli altri frame appare come un rettangolo vuoto (e tra l'altro compare nella finestra che sarebbe quella selezionata se quel frame fosse attivo).

Il termine `point' trova le sue origini nel carattere ., che era il comando di TECO (il linguaggio in cui era stato scritto l'Emacs originario) per accedere al valore ora chiamato `point'.

L'area messaggi

La riga in fondo al frame (subito sotto alla riga di stato) viene chiamata area messaggi: essa viene usata per mostrare brevi messaggi testuali.

Il termine inglese echoing indica il mostrare di volta in volta i caratteri digitati: al di fuori di Emacs, il sistema operativo normalmente mostra tutto ciò che viene digitato. Emacs gestisce la cosa in maniera differente.

In Emacs, i comandi costituiti da singoli caratteri non vengono mostrati, mentre quelli costituiti da più caratteri vengono mostrati solamente se si effettua una pausa mentre li si digita. Se si sta digitando un comando e si effettua una pausa per piú di un secondo, Emacs mostra nell'area messaggi tutti i caratteri relativi al comando che sono stati digitati fino a quel momento: ciò avviene per sollecitare l'immissione del resto del comando. Una volta che Emacs ha iniziato a mostrare il comando, il resto dello stesso viene visualizzato subito, a mano a mano che esso viene digitato. Questo comportamento è stato studiato per dare contemporaneamente tempi di risposta rapidi agli utenti che hanno familiarità con Emacs, e il maggior feedback possibile a coloro che non l'hanno. Questo comportamento può essere modificato impostando una variabile (see Display Vars).

Se un comando non può essere eseguito, esso può produrre un messaggio d'errore nell'area messaggi. I messaggi d'errore sono accompagnati da un suono o da un lampeggio dello schermo. Oltre a questo, nel caso si verifichi un errore, quanto digitato in precedenza relativamente al comando viene eliminato.

Alcuni comandi mostrano nell'area messaggi delle informazioni: essi possono sembrare simili a messaggi d'errore, ma non sono preannuciati da un suono, e quanto digitato in precedenza relativamente al comando non viene eliminato. Talvolta il messaggio contiene informazioni sulle modifiche che il comando ha prodotto, specie se esse non sono evidenti guardando il testo su cui si sta lavorando. Altre volte, invece, la sola funzione di un comando è quella di mostrare un messaggio che dia informazioni specifiche--ad esempio, C-x = visualizza un messaggio che descrive il carattere che segue il point e la sua posizione all'interno del testo. I comandi che impiegano molto tempo ad essere eseguiti spesso mostrano messaggi che terminano con ... mentre stanno procedendo, ed aggiungono done quando hanno finito.

I messaggi che compaiono nell'area messaggi sono conservati in un buffer chiamato *Messages* (fino ad ora non si è ancora parlato in dettaglio dei buffer; consultare Buffers per maggiori informazioni). Se si è perso qualche messaggio che è comparso brevemente sullo schermo, è possibile passare al buffer *Messages* per rivederlo (in tale buffer, i vari messaggi che indicano lo stato di avanzamento di un'operazione sono riuniti in un unico messaggio).

La dimensione di *Messages* è limitata ad un determinato numero di linee, specificato dalla variabile message-log-max: quando il buffer arriva a contenere tale numero di linee, per ogni riga aggiunta alla fine se ne cancella una all'inizio. See Variables per informazioni sull'impostazione di variabili come message-log-max.

L'area messaggi viene inoltre usata per mostrare il minibuffer, una finestra che serve per introdurre gli argomenti da passare ai comandi, come ad esempio il nome di un file da aprire. Quando il minibuffer è in uso, l'area messaggi presenta del testo che solitamente finisce con :, ed in essa compare il cursore (visto che in quel momento il minibuffer è anche la finestra selezionata). È sempre possibile uscire dal minibuffer digitando C-g. See Minibuffer.

La riga di stato

L'ultima riga di ogni finestra di testo è chiamata riga di stato, e descrive brevemente lo stato della finestra stessa. Quando vi è una sola finestra, la riga di stato è situata immediatamente al di sopra dell'area messaggi, ovvero è la penultima riga del frame. Se il terminale lo supporta, la riga di stato viene visualizzata in negativo, ed inizia e termina con dei trattini.

Normalmente, la riga di stato ha un aspetto simile al seguente:

-cs:ch  buffer   (m.primario m.secondari)--linea--posizione------

In essa sono fornite informazioni sul buffer visualizzato nella finestra: il nome del buffer, che modi primari e secondari sono in uso, se il buffer è stato cambiato e che parte del buffer si sta attualmente esaminando.

Se il buffer è stato modificato, ch contiene due asterischi **, altrimenti contiene --. Se il buffer è a sola lettura, ch contiene %* se esso è stato modificato, %% altrimenti.

buffer è il nome del buffer associato alla finestra. Nella maggior parte dei casi, è lo stesso nome del file su cui si sta lavorando. See Buffers.

Il buffer visualizzato nella finestra selezionata (la finestra in cui si trova il cursore) è anche il buffer selezionato, ovvero quello in cui è possibile effettuare modifiche. Quando si parla delle modifiche che un comando apporta "al buffer", ci si riferisce al buffer correntemente selezionato.

linea è una L seguta dal numero di riga ove si trova il point: è visualizzata quando il modo Line Number è attivato (normalmente lo è). Se lo si desidera, è possibile visualizzare anche il numero di colonna corrente attivando il modo Column Number (che è disabilitato per default in quanto è leggermente più lento). See Optional Mode Line.

posizione informa se vi è altro testo che precede o che segue quello visualizzato nella finestra. Se il buffer è piccolo ed è completamente visibile nella finestra, posizione appare come All. In caso contrario, è Top se si sta guardando l'inizio del buffer, Bot se si sta guardando la fine, oppure nn%, dove nn è la percentuale del buffer che si trova prima del testo attualmente visualizzato in finestra.

m.primario è il nome del modo primario attivo nel buffer. In ogni momento, ogni buffer utilizza uno e uno solo dei possibili modi primari. I modi primari disponibili includono il modo Fundamental (il meno specializzato), il modo Text, il modo Lisp, il modo C, il modo Texinfo e molti altri ancora. See Major Modes per informazioni su come selezionare un modo primario e in che cosa essi differiscono tra loro.

Alcuni modi primari mostrano di seguito al proprio nome delle informazioni aggiuntive. Ad esempio, i buffer Rmail mostrano il numero del messaggio corrente ed il numero totale di messaggi. I buffer Compilation e Shell mostrano lo stato del sub-processo.

m.seconadri è una lista di alcuni dei modi secondari che sono al momento attivati nel buffer. Ad esempio Fill indica che è attivo il modo Auto Fill. Abbrev indica che il modo Word Abbrev è attivato. Ovwrt indica che il modo Overwrite (sovrascrittura) è attivato. See Minor Modes per maggiori informazioni. Narrow significa che nel buffer visualizato è possible agire solo su una porzione di tutto il testo. Non si tratta di un modo secondario vero e proprio, ma è come se lo fosse. Def indica che si sta definendo una macro da tastiera. See Keyboard Macros.

Oltre a questo, se Emacs si trova in un livello di editing ricorsivo, attorno alle parentesi tonde che indicano i modi in uso compaiono delle parentesi quadre. Se Emacs si trova in un livello di editing ricorsivo annidato dentro un altro livello ricorsivo, compaiono delle doppie parentesi quadre e cos`i. Dato che i livelli di editing ricorsivi condizionano Emacs nella sua globalità, e non un solo buffer, le parentesi quadre compaiono nella riga di stato di tutte le finestre (oppure in nessuna). See Recursive Edit.

I terminali testuali possono mostrare solo un frame alla volta (see Frames), e in essi la riga di stato mostra di seguito a ch il nome del frame selezionato. Il nome del frame creato all'avvio è F1.

cs indica il sistema di codifica usato per il file su cui si sta lavorando. Il comportamento di default è indicato da un trattino, ovvero nessuna conversione (tranne per quanto riguarda i caratteri di ritorno a capo se il file ne contiene). = indica anch'esso che non vi è alcuna conversione. I sistemi di codifica più sofisticati sono rappresentati mediante varie lettere--ad esempio 1 indica l'ISO-Latin-1. See Coding Systems per maggiori informazioni. Se si sta usando un metodo di inserimento particolare, cs inizia con una stringa quale i>, dove i indentifica il metodo di input usato (alcuni metodi di input mostrano + o @ invece di >. See Input Methods.

Quando si usa un terminale testuale, cs usa tre caratteri per indicare rispettivamente il sistema di codifica per l'input da tastiera, quello per l'output sul terminale e quello usato nel file su cui si sta lavorando.

Se l'uso dei caratteri multibyte non è abilitato, cs non è visualizzata. See Enabling Multibyte.

In talune circostanze, al posto dei due punti che seguono cs vi può essere dell'altro: Emacs normalmente usa il carattere newline per separare le linee nel buffer, ma alcuni file usano convenzioni differenti per separare le linee, come la sequenza carriage-return linefeed (la convenzione MS-DOS) o semplicemente dei carriage-return (la convenzione Macintosh). Se il file nel buffer utilizza carriage-return linefeed, i due punti cambiano in una barra obliqua inversa (\) o DOS, a seconda del sistema operativo; se utilizza carriage-return e basta, i due punti diventano una barra obliqua (/) o Mac. Con alcuni sistemi operativi, Emacs visualizza Unix al posto dei due punti anche con file le cui linee sono separate da newline.

È possibile personalizzare il modo in cui la convenzione di separazione delle linee viene viene visualizzata sulla riga di stato impostando le variabili eol-mnemonic-unix, eol-mnemonic-dos, eol-mnemonic-mac e eol-mnemonic-undecided nel modo desiderato. See Variables, per spiegazioni su come impostare variabili.

See Optional Mode Line, per le funzionalità che aggiungono altre utili informazioni alla mode line, quali il numero di colonna in cui si trova il point, la data e l'ora correnti e se è arrivata posta elettronica.

La barra dei menù

Normalmente, ogni frame di Emacs ha (in prossimità del margine superiore) una barra dei menù che può essere usata per effettuare una serie di operazioni piuttosto comuni. Non è necessario elencarle qui, visto che è piú semplice vederle direttamente.

Quando si sta usando un ambiente grafico a finestre, è possible usare il mouse per scegliere un comando dalla barra dei menù. Una freccia che punta a destra a fianco della voce nel menù indica che la voce porta ad un sottomenù; una voce che termina con ... indica che il comando ha bisogno di argomenti ulteriori specificati da tastiera per essere eseguito.

Per vedere il nome completo di un comando e la documentazione relativa ad una voce nel menù, digitare C-h k e selezionare la barra dei menu con il mouse nel modo usuale (see Key Help).

Nei terminali testuali privi di mouse, è possible usare la barra dei menù digitando M-` o <F10> (viene avviato il comando tmm-menubar). Con questo comando si entra in un modo in cui è possibile selezionare da tastiera una voce del menù. Nell'area messaggi compare un elenco delle scelte possibili: è possibile usare i tasti cursore destro e sinistro per muoversi nel menù. Una volta trovata la voce desiderata, basta premere <Invio> per selezionarla.

A ogni voce nel menù corrisponde una lettera o una cifra: solitamente si tratta dell'iniziale di una parola contenuta nella voce. La lettera (o la cifra) è separata dalla voce da un =>, e digitandola si seleziona la voce corrispondente nel menù.

Alcuni dei comandi nella barra dei menù sono associati a delle sequenze di tasti: in questo caso, la sequenza di tasti corrispondente viene visualizzata tra parentesi tonde nel menù a fianco della voce stessa.

Tipi di input da parte dell'utente

GNU Emacs usa per l'input da tastiera una versione estesa del set di caratteri ASCII e riconosce come eventi azioni non corrispondenti a caratteri, inclusi i tasti funzione e i pulsanti del mouse.

Il set ASCII consiste in 128 codici che rappresentano caratteri: ad alcuni di questi ultimi sono assegnati simboli grafici, come a e =; i rimanenti sono caratteri di controllo, come Control-a (solitamente indicato per brevità come C-a, viene immesso tenendo premuto il tasto <CTRL> e premendo a).

Alcuni dei caratteri di controllo ASCII hanno nomi speciali, e la maggior parte dei terminali possiede tasti speciali con i quali è possibile produrli: ad esempio, <Invio>, <Tab>, <DEL> e <ESC>. Usualmente ci si riferisce al carattere "spazio" come <Spazio>, anche se, strettamente parlando, esso è un carattere il cui simbolo è vuoto. Alcune tastiere hanno un tasto "linefeed" che è un sostituto per C-j.

Emacs estende il set di caratteri ASCII con migliaia di caratteri stampabili (see International), caratteri di controllo addizionali ed alcuni modificatori che possono essere combinati con qualsiasi carattere.

I terminali ASCII permettono di usare solamente 32 caratteri di controllo, che corrispondono alle varianti di controllo delle lettere dell'alfabeto e dei caratteri @[]\^_. Oltre a questo, il tasto shift (maiuscolo) non ha significato con i caratteri di controllo: C-a e C-A sono lo stesso carattere, ed Emacs non può distinguerli.

Tuttavia, il set di caratteri di Emacs è abbastanza vasto da contenere le varianti di controllo di tutti i caratteri stampabili e da rendere possibile la distinzione tra C-a e C-A. L'X Window System rende possibile l'introduzione di tutti questi caratteri: ad esempio, C-- (Control-meno) e C-5 sono caratteri validi solo per Emacs funzionante sotto X.

Un'altra estensione di Emacs al set di caratteri consiste nell'uso di modificatori. È comunemente usato un solo modificatore: esso è chiamato Meta. Ogni carattere ha la sua variante Meta, ad esempio Meta-a (normalmente indicato come M-a per brevità), M-A (non è lo stesso carattere di M-a, ma normalmente hanno lo stesso significato in Emacs), M-<Invio>, e M-C-a. Per una questione di tradizione si usa indicare C-M-a invece di M-C-a; da un punto di vista logico non è importante l'ordine in cui i modificatori <CTRL> e <META> sono specificati.

Alcuni terminali hanno un tasto <META> e permettono di digitare caratteri Meta tenendolo premuto. Pertanto, Meta-a si ottiene tenendo premuto META e premendo a. Il tasto META funziona in modo molto simile al tasto SHIFT. Un tasto di questo tipo, tuttvavia, non sempre è indicato come META sulla tastiera, in quanto tale funzione è spesso un'opzione speciale per un tasto che ha un altro scopo primario.

Anche se non vi è un tasto <META>, è ancora possibile inserire caratteri Meta usando sequenze di due caratteri che iniziano con <ESC>. Pertanto, per inserire M-a, è possibile digitare <ESC> a. Per inserire C-M-a, si digita <ESC> C-a. L'uso di <ESC> è consentito anche su terminali che possiedono un tasto <META>, giusto nel caso ci si fosse abituati a usarlo.

X Window supporta diversi altri modificatori che possono essere applicati a ciascun carattere: <SUPER>, <HYPER> e <ALT>. L'uso di questi modificatori è indicato con s-, H- e A-. Pertanto, s-H-C-x è la forma breve per Super-Hyper-Control-x. Non tutti gli X terminal forniscono tasti per questi modificatori--di fatto, in molti terminali il tasto <ALT> è in realtà il tasto <META>. Le impostazioni di default della tastiera di Emacs non includono alcun carattere con questi modificatori, ma è possibile assegnar loro un significato personalizzando Emacs.

L'input da tastiera include tasti che non corrispondo affatto a caratteri, ad esempio i tasti funzione, i tasti cursore ed i pulsanti del mouse: è possibile modificare questi eventi con i modificatori CTRL, <META>, <SUPER>, <HYPER> e <ALT> esattamente come con i caratteri normali.

L'input costituito da caratteri e quello costituito da non-caratteri prendono collettivamente il nome di eventi di input. See Input Events per maggiori informazioni. Se non volete programmare in Lisp, ma semplicemente ridefinire il significato di alcuni eventi, consultate Customization.

I terminali ASCII non sono in grado di spedire nulla al computer se non caratteri ASCII, ed utilizzano una sequenza di caratteri per rappresentare i tasti funzione. Ciò è però trasparente all'utilizzatore di Emacs, in quanto le routine di input riconoscono queste sequenze speciali e le convertono negli eventi relativi ai tasti funzione prima che qualsiasi altra parte di Emacs li debba gestire.

Tasti

Una sequenza di caratteri (sequenza per brevità) è una serie di eventi di input che sono significativi se presi nell'insieme--come "un comando". Alcuni comandi di Emacs sono legati ad un solo carattere: ad esempio C-f è sufficiente per spostarsi in avanti di un carattere, ma Emacs ha inoltre comandi invocati dalla successione di due o più eventi.

Se una sequenza di eventi è sufficiente ad invocare un comando, essa è una sequenza completa. Esempi di sequenze complete sono C-a, X, <Invio>, <Page up> (un tasto funzione), <Sinistra> (un tasto cursore), C-x C-f e C-x 4 C-f. Se invece non è sufficiente, si tratta di un prefisso. Guardando gli esempi appena fatti, si vede che C-x e C-x 4 sono prefissi. Ogni sequenza possibile di caratteri è una sequenza completa oppure un prefisso.

Secondo le impostazioni di default di Emacs, la maggior parte dei singoli caratteri costituiscono sequenze complete; alcuni di essi, tuttavia, sono prefissi: un prefisso si combina con gli eventi di input che seguono per formare sequenze più lunghe, che possono essere a loro volta delle sequenze complete o dei prefissi. Ad esempio, C-x è un prefisso, e pertanto C-x e l'evento successivo si combinano per creare una sequenza di due caratteri. La maggior parte di queste sequenze sono sequenze complete, come C-x C-f o C-x b. Alcune, come C-x 4 o C-x r sono a loro volta dei prefissi a sequenze di tre caratteri. Non vi è limite alla lunghezza di una sequenza, ma in pratica si usano raramente sequenze più lunghe di quattro eventi.

Per contro, non è possible aggiungere altri eventi ad una sequenza completa. Ad esempio, la serie di due caratteri C-f C-k non è una sequenza in quanto C-f è già una sequenza completa. È impossbile dare a C-f C-k un significato indipendente, e C-f C-k sono due sequenze, non una.

Detto questo, i prefissi in Emacs sono C-c, C-h, C-x, C-x <Invio>, C-x @, C-x a, C-x n, C-x r, C-x v, C-x 4, C-x 5, C-x 6, <ESC>, M-g e M-j. Questa lista, tuttavia, non è immutabile: deriva unicamente dall'impostazione standard della tastiera di Emacs, e personalizzando Emacs è possibile creare nuovi prefissi, o eliminarli. See Key Bindings.

Creando o eliminando prefissi si cambia l'insieme delle possibili sequenze. Ad esempio, se si ridefinisce C-f come prefisso, C-f C-k diventa automaticamente una sequenza (completa, salvo che non venga a sua volta definita come un prefisso). Di concerto, se si rimuove il prefisso C-x 4, allora C-x 4 f (o C-x 4 qualsiasi cosa) non sono piú sequenze.

Se dopo aver immesso un prefisso si digita il carattere di aiuto (C-h o <F1>), viene mostrata una lista dei comandi che iniziano con quel prefisso. Vi sono alcuni prefissi per cui C-h non funziona--per ragioni storiche essi interpretano C-h in una maniera differente e non facile da cambiare, tuttavia <F1> dovrebbe funzionare con tutti i prefissi.

Sequenze e comandi

In questo manuale si trovano numerosissimi passaggi che spiegano cosa si ottiene digitando determinate sequenze di caratteri, ma Emacs non associa loro direttamente un significato. Esso, invece, attribuisce un significato a dei comandi e poi dà alle sequenze il loro significato associandole ai comandi.

Ogni comando ha un nome scelto dal programmatore. Il nome è solitamente composto da alcune parole in lingua inglese separate da trattini: ad esempio next-line o forward-word. Un comando è composto inoltre dalla definizione di una funzione, che consiste in un programma in Lisp che fa in modo che il programma agisca come deve. Di fatto, un comando in Emacs Lisp è un tipo particolare di funzione Lisp, ovvero un tipo di funzione in cui è specificato il modo in cui vanno letti gli argomenti e il modo in cui tale funzione deve essere invocata interattivamente. Per maggiori informazioni su comandi e funzioni, consultare What Is a Function (la definizione usata in questo manuale è leggermente semplificata).

Le associazioni tra le sequenze (di caratteri) ed i comandi sono memorizzate in diverse tabelle chiamate keymaps. See Keymaps.

Quando si afferma che "con C-n ci si sposta in basso di una linea", si sta glissando su una distinzione che è ininfluente nell'uso comune, ma che è fondamentale per comprendere le possibilità di personalizzazione di Emacs: è il comando next-line che è definito in maniera tale da spostare in basso di una linea. C-n produce questo effetto in quanto è associato a tale comando. Se si associa C-n al comando forward-word, allora C-n provocherà lo spostamento in avanti di una parola. Ridefinire le associazioni è un metodo comune di personalizzare Emacs.

Per mantenere le cose semplici, nel resto di questo manuale si sorvola su tale dettaglio. Per quanto riguarda le informazioni necessarie alla personalizzazione, dopo aver specificato una sequenza viene indicato il nome del comando che esegue il compito vero e proprio: ad esempio, con la frase "Il comando C-n (next-line) sposta il point in basso" si intende che next-line è un comando che sposta il point in basso e che C-n è una sequenza normalmente ad esso associata.

Già che si sta parlando di informazioni utili esclusivamente ai fini della personalizzazione, è questo il momento di introdurre le variabili. Nella descrizione di un comando si trovano spesso frasi del tipo "Per cambiare il comportamento, impostare la variabile mumble-pippo". Una variabile consiste in un nome usato per memorizzare un valore: la maggior parte delle variabili documentate in questo manuale esistono unicamente per facilitare la personalizzazione. Alcuni comandi, o altre componenti di Emacs, esaminano la variabile e si comportano in maniera differente a seconda del valore impostato. Se non si è interessati alla personalizzazione, è possibile ignorare le informazioni relative alle variabili. Se invece si è interessati, è consigliabile leggere la documentazione di base sulle variabili, per rendere più comprensibili le informazioni sulle singole variabili presenti più avanti nel testo. See Variables.

I caratteri usati per il testo

Il testo nei buffer di Emacs consiste in una sequenza di byte da 8 bit. Ogni byte può contenere un solo carattere ASCII: sono consentiti sia i caratteri di controllo ASCII (codici ottali da 000 a 037 e 0177) che i caratteri ASCII stampabili (codici da 040 a 0176). Tuttavia, caratteri di controllo non ASCII non possono comparire in un buffer. Non sono consentiti inoltre gli altri modificatori usati per l'input da tastiera, come ad esempio Meta.

Alcuni caratteri di controllo ASCII hanno un significato particolare nel testo ed hanno dei nomi speciali. Ad esempio, il carattere newline (codice ottale 012) viene usato nel buffer per terminare una linea, e il carattere tab (codice ottale 011) viene usato per l'allineamento alla prossima colonna di tabulazione (normalmente ogni 8 colonne). See Text Display.

Possono comparire in un buffer anche dei caratteri stampabili non ASCII. Quando sono abilitati i caratteri multibyte, è possibile usare uno qualsiasi dei caratteri non ASCII stampabili supportati da Emacs: questi ultimi hanno codici che iniziano da 256, 0400 in ottale, ed ognuno è rappresentato da una sequenza di due o più byte. See International.

Se si disabilitano i caratteri multibyte è possibile usare solo un alfabeto di caratteri non ASCII, ma questi devono stare tutti quanti in un byte: usano i codici da 0200 a 0377 (da 128 a 255). See Single-Byte European Support.

Avviare e chiudere Emacs

Il modo comune per avviare Emacs è tramite il comando di shell emacs. Emacs cancella lo schermo e mostra poi un messaggio di aiuto inizale e le informazioni di copyright. Alcuni sistemi operativi ignorano tutto ciò che viene digitato durante l'avvio di Emacs e non danno modo a Emacs di comportarsi diversamente. Prima di digitare i comandi, pertanto, è consigliabile aspettare fino a quando Emacs cancella lo schermo.

Se si vuole avviare Emacs da una shell sotto l'X Window System, è utile avviarlo in background tramite emacs&. Emacs, in questo modo, non tiene occupata la shell ed essa può quindi essere usata per avviare altri comandi, mentre Emacs continua a funzionare nella sua finestra di X. Appena si seleziona il frame di Emacs è possibile iniziare a digitare comandi.

Alla partenza, Emacs crea un buffer chiamato *scratch*, da cui si inizia. Il buffer *scratch* fa uso del modo primario Lisp Interaction; è possibile usarlo per immettere espressioni Lisp ed eseguirle, oppure si può ignorare questa possibilità ed utilizzarlo per prendere appunti (si può specificare un modo primario diverso per questo buffer impostando la variabile initial-major-mode nel file di inizializzazione. See Init File.).

Passando degli argomenti sulla riga di comando con cui si invoca Emacs è possibile specificare dei file da esaminare, dei file Lisp da caricare e delle funzioni da invocare. See Command Arguments. Si sconsiglia però di fare questo, in quanto tali funzionalità esistono sostanzialmente solo per motivi di compatibilità con altri editor.

Molti altri editor sono stati concepiti per essere avviati tutte le volte che si vuole lavorare con un file: si modifica un file e poi si esce dall'editor. In seguto, quando si vuole nuovamente lavorare con lo stesso file (o con un altro), occorre lanciare nuovamente l'editor. Con essi ha senso usare un argomento sulla linea di comando per specificare il file con cui lavorare.

Avviare Emacs ogni volta che si vuole lavorare su un file, invece, non ha senso: da un lato ciò sarebbe tremendamente lento, dall'altro non ci si avvantaggerebbe della possibilità di Emacs di operare su più file in una sola sessione e si perderebbe inoltre il contesto accumulato, come i registri, le informazioni per annullare le modifiche e i mark.

L'uso consigliato di Emacs consiste nell'avviarlo una sola volta, appena dopo il login, ed effettuare tutte le operazioni nella stessa sessione. Ogni volta che si vuole lavorare su un file diverso, si apre quest'ultimo con l'Emacs avviato che, eventualmente, ha già in sè diversi file pronti per essere modificati. Di solito non si chiude Emacs fino a quando non ci si vuole scollegare. See Files per maggiori informazioni sul come operare su più di un file.

Uscire da Emacs

Esistono due comandi per uscire da Emacs, poiché vi sono due tipi di uscita, che consistono nel sospendere Emacs e nel chiuderlo.

Sospendere significa fermare temporaneamente Emacs e ridare il controllo al processo che lo ha avviato (solitamente una shell), permettendo in seguito di riprendere il lavoro nella stessa sessione di Emacs con gli stessi buffer, lo stesso kill ring, le stesse informazioni sulle modifiche, etc. Questo è il modo usuale di uscire.

Chiudere Emacs significa terminare definitivamente il programma. È possibile riavviarlo nuovamente in seguito, ma si otterrà un Emacs nuovo: non c'e` modo di ripristinare esattamente la stessa sessione dopo che esso è stato chiuso.

C-z

Sospende Emacs (suspend-emacs) o iconifica un frame (iconify-or-deiconify-frame).

C-x C-c

Chiude Emacs (save-buffers-kill-emacs).

Per sospendere Emacs, digitare C-z (suspend-emacs): ciò riporta alla shell da cui Emacs è stato avviato. Nelle shell più comuni è possibile ritornare a Emacs con il comando %emacs.

Nei sistemi che non supportano la sospensione di un programma, C-z avvia una sottoshell che comunica direttamente con il terminale. Emacs rimane in attesa fin quando non si esce dalla sottoshell (il modo per farlo è probabilmente C-d oppure exit, ma dipende dalla shell che si sta usando). L'unico modo di tornare alla shell da cui Emacs è stato avviato (per disconnettersi, ad esempio) con tali sistemi operativi è quello di chiudere Emacs.

La sospensione fallisce anche nel caso in cui Emacs sia stato avviato da una shell che non supporti la sospensione di programmi, anche se il sistema operativo in sè la supporta. In tal caso è possibile impostare la variabile cannot-suspend ad un valore diverso da nil per forzare l'avvio di una subshell da parte di C-z.

C-z ha un significato diverso quando Emacs comunica direttamente con un X server e crea la propria finestra X dedicata. Sospendere un'applicazione che ha la propria finestra X non è utile e non ha nemmeno un significato. C-z, in questo caso, avvia il comando iconify-or-deiconify-frame che iconifica temporaneamente il frame di Emacs selezionato (see Frames). Per tornare ad una finestra contenente una shell si deve far uso del window manager.

Per chiudere Emacs basta digitare C-x C-c (save-buffers-kill-emacs); viene usata una sequenza di due caratteri per evitare che essa venga digitata per sbaglio. Questo comando offre la possibilità di salvare tutti i buffer modificati che contengono dei file. Se i file non vengono salvati, il comando chiede nuovamente conferma tramite yes prima di chiudere Emacs (visto che ogni modifica non salvata verrà persa per sempre). Se vi sono dei sottoprocessi ancora in funzione, C-x C-c chiede conferma anche per questi (visto che la chiusura di Emacs produce la loro terminazione immediata).

Una volta che Emacs viene chiuso non c'è modo di ripristinare esattamente la sessione; è però possibile far in modo che Emacs memorizzi alla chiusura alcune informazioni al riguardo, ad esempio l'elenco dei file su cui si stava lavorando, in modo che al prossimo avvio esso provi a riaprire gli stessi file. See Saving Emacs Sessions.

Solitamente il sistema operativo rimane in ascolto per determinati caratteri, il significato dei quali è chiudere o sospendere il programma in esecuzione. Tale caratteristica del sistema è disattivata mentre si sta usando Emacs. Il significato in Emacs di C-z e C-x C-c è ispirato all'uso fatto da diversi sistemi operativi di C-z e C-c per sospendere o chiudere un programma, ma questa è l'unica relazione esistente con il sistema operativo; è possibile personalizzare queste sequenze in modo da avviare qualsiasi comando si desideri (see Keymaps).

Comandi di editing fondamentali

Verranno ora date le basi sul come inserire del testo, effettuare correzioni e memorizzare il testo in un file. Se non si hanno esperienze precedenti al riguardo, è possibile apprendere facilmente tali operazioni tramite il tutorial di Emacs. Per avviare il tutorial, avviare Emacs e digitare Control-h t (help-with-tutorial).

Per aggiornare lo schermo, digitare C-l (recenter)

• Inserting Text: Inserire del testo, semplicemente digitandolo.
• Moving Point: Come spostare il cursore nel punto ove si vuole cambiare qualcosa.
• Erasing: Cancellare ed eliminare del testo.
• Undo: Annullare le modifiche recenti.
• Files: Visitare, creare e salvare del testo.
• Help: Ottenere aiuto.
• Blank Lines: Comandi per creare e cancellare linee vuote.
• Continuation Lines: Linee troppo lunghe per lo schermo.
• Position Info: In che pagina, linea, riga e colonna si trova il point?
• Arguments: Argomenti numerici per ripetere un comando.
• Repeating: Una scorciatoia per ripetere comandi.

Inserire del testo

Per inserire dei caratteri stampabili nel testo su cui si sta lavorando è sufficiente digitarli: in questo modo essi vengono inseriti nel buffer nella posizione in cui si trova il cursore (ovvero, dove si trova il point; see point). Il cursore viene spostato in avanti insieme al testo che si trova dopo di esso. Se il testo nel buffer fosse PLUTO con il cursore posizionato sulla lettera T, digitando XX si otterrebbe PLUXXTO con il cursore ancora posizionato sopra la T.

Per cancellare il testo appena inserito si usa <DEL>. <DEL> cancella il carattere che si trova prima del cursore (non quello su cui si trova il cursore; quello è il carattere che segue il point). Il cursore e tutti i caratteri che lo seguono vengono spostati all'indietro. Pertanto, se si digita un carattere stampabile e poi si preme <DEL>, esso viene cancellato⁴.

Per terminare una linea e iniziarne un'altra basta premere il tasto <Invio>: cos`i facendo si inserisce un carattere newline nel buffer. Se il point si trova nel mezzo di una linea, <Invio> la spezza in due, se si digita <DEL> quando il cursore si trova all'inizio di una linea, il newline precedente viene cancellato e la linea viene unita a quella precedente.

Emacs può andare a capo automaticamente nel caso le linee diventino troppo lunghe: ciò si ottiene attivando un modo secondario speciale, chiamato Auto Fill. See Filling per informazioni sul come usarlo.

Se si preferisce che i caratteri digitati sovrascrivano quelli esistenti (invece che spostarli a destra), è possibile abilitare il modo secondario Overwrite. See Minor Modes.

L'inserimento diretto funziona per i caratteri stampabili e per <Spazio>, ma gli altri caratteri non vengono inseriti e si comportano come comandi di editing. Se si deve inserire un carattere di controllo (o un carattere il cui codice ottale sia superiore a 200) occorre quotarlo⁵ digitando prima Control-q (quoted-insert) (il nome di questo carattere è normalmente abbreviato con C-q). Vi sono due modi di usare C-q:

• C-q seguito da un qualsiasi carattere non grafico (anche C-g) lo inserisce in modo letterale.
• C-q seguito da una sequenza di cifre ottali inserisce il carattere corrispondente. È possibile specificare un numero qualunque di cifre ottali: la sequenza è terminata da qualsiasi carattere che non sia una cifra. Se il carattere che termina la sequenza è <Invio>, esso è utilizzato unicamente per terminare la sequenza. Ogni altro carattere che non sia una cifra, invece, è usato anche come input dopo aver terminato la sequenza (se si usa il modo secondario Overwrite in file non binari, l'uso delle sequenze ottali è disabilitato per poter comodamente inserire una cifra invece di sovrascriverla).

Quando l'uso dei caratteri multibyte è abilitato, ai codici ottali che vanno da 0200 a 0377 (128 - 255 in decimale) non corrispondono caratteri validi: specificando un codice in questo intervallo, C-q presume che si voglia usare uno dei set di caratteri ISO Latin-n e quindi converte il codice specificato nel corrispondente codice di carattere Emacs. See Enabling Multibyte. Il set di caratteri ISO Latin utilizzato dipende dalla configurazione dell'ambiente relativa alla lingua (see Language Environments).

Per usare la notazione decimale o esadecimale al posto di quella ottale si può impostare la variabile read-quoted-char-radix a 10 oppure 16. Se la base è maggiore di 10, le lettere a partire dalla a sono utilizzate per comporre il codice esattamente come fossero delle cifre.

Un argomento numerico fornito a C-q specifica quante copie del carattere quotato vanno inserite (see Arguments).

Informazioni per la personalizzazione: DEL nella maggior parte dei modi primari e secondari invoca il comando delete-backward-char; Invio invoca il comando newline e i caratteri stampabili invocano il comando self-insert, il quale si limita ad inserire il carattere digitato per invocarlo. Alcuni modi primari assegnano DEL ad altri comandi.

Cambiare la posizione del point

Per fare qualcosa di più sofisticato dell'inserire caratteri occorre conoscere come spostare il point (see Point). Il modo più semplice di farlo è tramite i tasti cursore, oppure facendo click con il bottone del mouse nel punto ove si vuole andare.

Esistono caratteri di controllo e caratteri meta dedicati allo spostamento del cursore: alcuni di essi sono equivalenti ai tasti cursore (risalgono a tempi in cui i terminali non avevano ancora tali tasti), altri fanno cose più elaborate.

C-a

Sposta all'inizio della linea (beginning-of-line).

C-e

Sposta alla fine della linea (end-of-line).

C-f

Sposta in avanti di un carattere (forward-char).

C-b

Sposta indietro di un carattere (backward-char).

M-f

Sposta in avanti di una parola (forward-word).

M-b

Sposta indietro di una parola (backward-word).

C-n

Sposta in basso di una linea (next-line). Questo comando tenta di mantenere invariata la posizione orizzontale, cos`i, se ci si trova nel mezzo di una linea, si finisce nel mezzo della linea successiva. Quando ci si trova sull'ultima linea del testo, C-n crea una nuova linea e sposta in essa il point.

C-p

Sposta in alto di una linea (previous-line).

M-r

Sposta il point al margine sinistro, centrandolo verticalmente nella finestra (move-to-window-line). Il testo nella finestra non viene spostato.

Un argomento numerico specifica in quale linea dello schermo posizionare il point. Le linee vengono enumerate partendo dall'inizio della finestra (zero corrisponde alla prima linea), e un argomento negativo calcola le linee dalla fine (-1 per l'ultima).

M-<

Sposta all'inizio del buffer (beginning-of-buffer). Con un argomento numerico n sposta a n decimi a partire dall'inizio. See Arguments per maggiori informazioni sugli argomenti numerici.

M->

Sposta alla fine del buffer (end-of-buffer).

M-x goto-char

Legge un numero n e sposta il point alla posizione n nel buffer. La posizione 1 corrisponde all'inizio del buffer.

M-x goto-line

Legge un numero n e sposta il point alla linea numero n. La linea 1 si trova all'inizio del buffer.

C-x C-n

Imposta la colonna in cui si trova correntemente il point come colonna semipermanente di destinazione per C-n e C-p (set-goal-column). Cos`i facendo, ogni volta che si cambia linea i comandi suddetti posizionano il point sempre su tale colonna, o il più vicino possibile a seconda di quanto permette il contenuto della linea di destinazione. La colonna di destinazione rimane attiva fino a quando non viene disattivata.

C-u C-x C-n

Disattiva la colonna di destinazione, in modo che C-n e C-p cerchino nuovamente di mantenere la posizione orizzontale corrente come al solito.

Se si imposta la variabile track-eol ad un valore diverso da nil, C-n e C-p digitati alla fine di una linea spostano il point alla fine dell'altra linea. Normalmente, track-eol vale nil. See Variables per saperne di più sull'impostazione di variabili come track-eol.

Se digitato quando ci si trova sull'ultima linea di un buffer, C-n aggiunge normalmente una nuova linea. Se la variabile next-line-add-newlines vale nil, C-n in questa situazione produce invece un errore (come avviene con C-p quando si è sulla prima linea).

Cancellare del testo

<DEL>

Cancella il carattere che precede il point (delete-backward-char).

C-d

Cancella il carattere che segue il point (delete-char).

C-k

Cancella fino alla fine della linea (kill-line).

M-d

Cancella in avanti fino alla fine della parola (kill-word).

M-<DEL>

Cancella all'indietro fino all'inizio della parola (backward-kill-word).

Si è già parlato di DEL, che cancella il carattere che precede il point (ovvero, quello che precede il cursore). La sequenza Control-d (abbreviata C-d), al contrario, cancella il carattere che segue il point (ovvero quello su cui si trova il cursore). Ciò sposta a sinistra il resto del testo sulla lina. C-d digitato alla fine di una linea unisce quest'ultima alla linea successiva.

Per cancellare quantità maggiori di testo si può usare @kbdC-k, che cancella una linea intera alla volta. Se si digita C-k all'inizio o nel mezzo di una linea, il resto della linea viene cancellato. Se si digita C-k alla fine di una linea, essa viene unita alla linea successiva.

See Killing per modi più flessibili di cancellare del testo.

Annullare le modifiche recenti

È possibile annullare (fino a un certo punto) tutte le modifiche apportate di recente al testo contenuto nel buffer. Ogni buffer memorizza individualmente le modifiche, e il comando di annullamento si applica sempre al buffer corrente. Solitamente, ogni singolo comando produce una registrazione separata nell'elenco delle informazioni sulle modifiche, ma alcuni comandi come query-replace producono molte registrazioni, mentre i comandi molto semplici (come i caratteri che si auto-inseriscono) sono quasi sempre raggruppati al fine di rendere meno problematico l'annullamento.

C-x u

Annulla una modifica--solitamente un solo comando (undo).

C-_

Come sopra.

C-u C-x u

Annulla una modifica, purché essa sia all'interno della regione specificata.

Il comando C-x u o C-_ permette di annullare le modifiche effettuate. Quando viene digitato per la prima volta, esso annulla l'ultima modifica effettuata. Il point viene spostato nel punto ove esso si trovava prima che fosse immesso il comando che ha modificato il buffer.

Ripetizioni successive di C-_ o C-x u annullano modifiche via via precedenti, fino a raggiungere il limite delle informazioni di annullamento disponibili. Se tutte le modifiche di cui si era tenuto traccia sono già state annullate, il comando produce un messaggio d'errore e non fa nulla.

La sequenza di annullamento è interrotta da qualsiasi comando che non sia quello di annullamento: da quel momento in poi, i comandi di annullamento precedenti diventano normali modifiche, che sono a loro volta annullabili. Per eseguire nuovamente delle modifiche annullate è quindi sufficiente digitare C-f (o un comando qualsiasi che interrompa la sequenza di annullamento senza conseguenze rilevanti), e poi procedere nuovamente ad annullare.

L'annullamente ordinario si applica a tutte le modifiche apportate al buffer corrente. È anche possibile effettuare un annullamento selettivo, limitato alla regione correntemente selezionata: per farlo basta specificare la regione a cui si è interessati e poi digitare un comando di annullamento preceduto da un argomento (il valore dell'argomento non è importante): C-u C-x u o C-u C-_. Ciò annulla le modifiche recenti all'interno della regione. Per annullare ulteriori modifiche nella stessa regione basta ripetere il comando di annullamento (non è più necessario specificare un argomento). Nel modo secondario Transient Mark, l'annullamento è sempre selettivo, e non è necessario specificare un argomento.

Qualora si noti che un buffer sia stato modificato per sbaglio, il modo più semplice di ripristinarlo è quello di digitare ripetutamente C-_ fino a quando gli asterischi all'inizio della riga di stato non scompaiono: a questo punto tutte le modifiche effettuate sono state cancellate. Ogni volta che un comando di annullamento fa sparire gli asterischi dalla riga di stato vuol dire che il contenuto del buffer è lo stesso di quando il file è stato letto o salvato per l'ultima volta.

Se non ci si ricorda se il buffer è stato modificato intenzionalmente o no, basta digitare C-_ una volta sola. Una volta vista quale modifica era stata fatta, si può capire se essa era voluta o meno. Se si trattava di uno sbaglio, si può lasciare la modifica annullata. Se la modifica era voluta, si può riottenerla come descritto sopra.

Non tutti i buffer memorizzano informazioni sulle modifiche: i buffer il cui nome inizia con degli spazi non lo fanno (vengono usati internamente da Emacs e dalle sue estensioni per conservare del testo che gli utenti, solitamente, non sono interessati né a vedere, né a modificare).

Non si possono annullare semplici spostamenti del cursore: vengono memorizzate solo le modifiche riguardanti il contenuto dei buffer. Tuttavia alcuni comandi di spostamento del cursore impostano il mark, cos`i, se di tanto in tanto si usano tali comandi, è possibile ritornare nelle vicinanze di dove si era in precedenza. (see Mark Ring).

Quando le informazioni sulle modifiche effettuate in un buffer diventano troppo numerose, Emacs elimina di volta in volta quelle più vecchie (durante la garbage collection⁶). È possibile specificare quante informazioni mantenere impostando due variabili: undo-limit e undo-strong-limit. I loro valori sono espressi in byte.

La variabile undo-limit imposta un limite di guardia: Emacs mantiene una quantità di informazioni sulle modifiche fino a raggiungere questo limite, magari superandolo, ma non mantiene le informazioni ulteriori ed elimina quelle più vecchie. La variabile undo-strong-limit specifica un limite più severo: le modifiche che inducono un aumento delle dimensioni oltre questo limite non sono memorizzate affatto. Il valore di default è 30000.

Indipendentemente dal valore di queste variabili, la modifica più recente viene sempre memorizzata, cos`i non vi è pericolo che una garbage collection che avvenga subito dopo una modifica sostanziale impedisca a quest'ultima di essere annullata.

Il motivo per cui il comando di annullamento undo è assegnato alle due sequenze C-x u e C-_ risiede nel fatto che esso merita di essere assegnato ad una sequenza di un solo carattere, ma su alcune tastiere non è chiaro come digitare C-_. C-x u è un'alternativa che si può usare su qualunque terminale.

File

I comandi descritti in precedenza sono sufficienti per creare e modificare del testo in un buffer di Emacs; i comandi più avanzati rendono solamente le cose più semplici. Per salvare permanentemente del testo occorre però metterlo in un file. I file sono unità di testo memorizzate dal sistema operativo e identificate da un nome, in modo da poterle recuperate in un secondo tempo (tramite lo stesso nome). Per esaminare o fare uso del contenuto di un file, inclusa la modifica del file tramite Emacs, occorre specificare il suo nome.

Si consideri un file chiamato /usr/rms/pippo.c. Per iniziare a lavorare con questo file in Emacs basta digitare

C-x C-f /usr/rms/pippo.c <Invio>

In questo caso, il nome del file è passato come argomento al comando C-x C-f (find-file). Esso usa il minibuffer per leggere l'argomento, e va digitato <Invio> per terminare l'immissione (see Minibuffer).

Emacs esegue il comando aprendo il file, ovvero creando un buffer, copiando il contenuto del file nel buffer e poi mostrando il buffer pronto per essere modificato. Se si modifica il testo, è possibile salvare il nuovo testo digitando C-x C-s (save-buffer). Ciò rende le modifiche permanenti, ricopiando il contenuto modificato del buffer nel file /usr/rms/pippo.c. Fino a quando non si salva, le modifiche apportate esistono unicamente all'interno di Emacs, ed il file pippo.c rimane inalterato.

Per creare un file basta aprirlo con C-x C-f come se esistesse già: questa operazione crea un buffer in cui è possibile immettere il testo che si desidera inserire nel file. Il file viene creato quando il buffer viene salvato con C-x C-s.

Naturalmente, oltre a queste vi sono molte altre cose da sapere al riguardo dei file. See Files.

Aiuto

Tramite il carattere di Aiuto, che è C-h (o <F1>, un alias per C-h), è possibile sapere cosa fa una sequenza di tasti nel caso lo si dimentichi: è sufficiente digitare C-h k seguito dalla sequenza di cui si vuole sapere di più; ad esempio, C-h k C-n informa su cosa fa la sequenza C-n. C-h è un prefisso; C-h k è solo uno dei suoi sottocomandi (precisamente, il comando describe-key). Gli altri sottocomandi di C-h forniscono differenti tipi di aiuto. Per ottenere la descrizione di tutte le funzionalità di help basta digitare C-h due volte. See Help.

Linee vuote

Qui sono descritti comandi e tecniche speciali per inserire ed eliminare linee vuote.

C-o

Inserisce una o più linee vuote dopo il cursore (open-line).

C-x C-o

Cancella una serie di linee vuote consecutive, lasciandone una sola. (delete-blank-lines).

È possibile inserire una nuova linea di testo prima di una linea esistente digitandola e facendola seguire da Invio. Tuttavia, può risultare più semplice vedere cosa si sta facendo se prima si inserisce una linea vuota e poi si inserisce in essa il testo desderato: lo si può fare facilmente con C-o (open-line), che inserisce una nuova linea dopo il point ma lascia quest'ultimo posizionato prima del carattere di newline inserito. Dopo aver digitato C-o si può inserire direttamente il testo per la nuova linea⁷. C-o P I P P O ha lo stesso effetto di P I P P O <Invio>, tranne che per la posizione finale del point.

È possibile creare diverse linee vuote digitando più volte C-o, oppure specificando un argomento numerico che dica quante linee vuote inserire. See Arguments. Se si è impostato un prefisso di riempimento, C-o lo inserisce nella nuova riga se digitato all'inizio di una linea. See Fill Prefix.

Un modo semplice di eliminare linee vuote extra è tramite il comando C-x C-o (delete-blank-lines): digitato all'interno di una serie di linee vuote elimina queste ultime salvo una di esse. Se digitato quando si è in una linea vuota tra due linee di testo, C-x C-o cancella la linea vuota. Quando il point si trova su una linea non vuota, C-x C-o cancella le linee vuote che seguono.

Righe di continuazione

Se si aggiungono troppi caratteri ad una linea senza interromperla con <Invio>, questa aumenta in lunghezza fino ad occupare due (o più) righe sullo schermo, e vi è un \ all'estremo margine destro di tutte salvo che per l'ultima. \ informa che la riga successiva sullo schermo non è una linea distinta nel testo, ma solo la continuazione di una linea troppo lunga per stare nello schermo; questo comportamento si chiama anche line wrapping.

Talvolta è comodo fare in modo che Emacs vada a capo automaticamente quando una linea diventa troppo lunga. È bene tener presente che ciò è una cosa ben diversa dalle righe di continuazione, e che in questo caso va usato il modo Auto Fill (see Filling).

Come alternativa alla continuazione delle linee, Emacs può mostrare le linee troppo lunghe troncandole. Ciò significa che tutti i caratteri che non possono stare sulla stessa riga (in virtù della larghezza dello schermo o della finestra) non vengono affatto mostrati: rimangono nel buffer, temporaneamente invisibili. Nell'ultima colonna viene usato $ al posto di \ per infomare che la linea è stata troncata.

Si fa uso della troncatura delle linee tutte le volte che viene usato lo scorrimento orizzontale e, opzionalmente, in tutte le finestre affiancate (see Windows). È possibile abilitare la troncatura in un buffer impostando la variabile truncate-lines ad un valore diverso da nil per quel buffer (See Variables). Se si modifica il valore di truncate-lines, la modifica diventa locale al buffer corrente. Finchè non si modifica il valore, viene usato il valore di default, che inizialmente è nil. See Locals.

See Display Vars per altre variabili che influiscono su come il testo viene mostrato

Informazioni sulla posizione del cursore

Qui sotto sono elencati comandi per avere informazioni sulla grandezza e sulla posizione di parti del buffer e per contare linee.

M-x what-page

Mostra il numero della pagina in cui si trova il point ed il numero di linea all'interno della pagina.

M-x what-line

Mostra il numero di linea in cui si trova il point nel buffer.

M-x line-number-mode

Attiva/disattiva la visualizzazione automatica del numero di linea corrente.

M-=

Mostra il numero di linee presenti nella regione corrente (count-lines-region). See Mark per informazioni sulle regioni.

C-x =

Mostra il codice del carattere che si trova dopo il point, la posizione del point all'interno del buffer e il numero della colonna relativa (what-cursor-position).

Esistono due comandi che riguardano i numeri di linea: M-x what-line calcola il numero di linea corrente e lo mostra nell'area messaggi. Per saltare ad un determinato numero di linea si può usare M-x goto-line: esso richiede di specificare il numero di linea. Le linee vengono enumerate partendo da uno e dall'inizio del buffer.

Il numero di linea corrente è anche indicato nella riga di stato (See Mode Line). Se si restringe il buffer, il numero di linea nella riga di stato è relativo alla porzione accessibile dell buffer stesso (see Narrowing). Al contrario, what-line mostra sia il numero di linea relativo alla porzione accessibile, sia quello relativo all'intero buffer.

M-x what-page conta invece le pagine dall'inizio del file ed il numero di linea dall'inizio della pagina, mostrando entrambi i valori. See Pages.

Considerato il tema trattato, è utile citare anche M-= (count-lines-region) che mostra il numero di linee presenti nella regione selezionata (see Mark). See Pages per informazioni sul comando C-x l che conta il numero di linee nella pagina corrente.

Il comando C-x = (what-cursor-position) può essere usato per sapere in quale colonna si trova il cursore ed altre informazioni riguardanti il point; mostra nell'area messaggi una linea simile a questa:

Char: c (0143, 99, 0x63)  point=21044 of 26883(78%)  column 53

(di fatto, questo è il messaggio prodotto quando il point si trova prima di column nell'esempio).

I quattro valori che seguono Char: descrivono il carattere che segue il point e consistono nel carattere stesso e le rappresentazioni in base ottale, decimale ed esadecimale del suo codice. Nel caso si tratti di un carattere multibyte non ASCII, esse sono seguite da ext e dalla rappresentazione in base esadecimale del carattere secondo il sistema di codifica usato nel buffer, posto che esso codifichi il carattere in maniera non ambigua e usando un solo byte (see Coding Systems). Se il sistema di codifica usa invece più byte, Emacs visualizza ext ....

point= è seguito dalla posizione del point calcolata come numero di caratteri dall'inizio del buffer. L'inizio del buffer ha posizione 1, il carattere successivo ha posizione 2 e cos`i via. Ad esso segue un numero (più grande) che indica il numero totale di caratteri presenti nel buffer. Tra parentesi viene poi indicata la posizione espressa come percentuale sulla grandezza totale.

column è seguito dalla posizione orizzontale del point, espressa in colonne dal margine sinistro della finestra.

Se il buffer è stato ristretto, rendendo cos`i temporaneamente inaccessibile parte del testo che si trova all'inizio e alla fine, C-x = mostra ulteriori informazioni che descrivono l'intervallo al momento accessibile. Ad esempio, potrebbe mostrare un messaggio come questo:

Char: C (0103, 67, 0x43)  point=252 of 889(28%) <231 - 599>  column 0

dove i due numeri aggiuntivi indicano la più piccola e la più grande posizione che il point può assumere calcolata come numero di caratteri dall'inizio del buffer. I caratteri compresi tra queste due posizioni sono pertanto quelli accessibili. See Narrowing.

Se il point si trova alla fine del buffer (o alla fine della porzione accessibile), C-x = omette la descrizione del carattere che segue il point. Il messaggio potrebbe essere il seguente:

point=26957 of 26956(100%)  column 0

C-u C-x = mostra informazioni addizionali su un carattere: al posto delle informazioni sulla sua posizione nel buffer vengono visualizzati il nome del set di caratteri di cui fa parte ed il relativo codice (i caratteri ASCII sono identificati come appartenenti al set ASCII); viene inoltre mostrata (dopo ext) una rappresentazione completa della codifica di tale carattere, anche nel caso che essa sia più lunga di un byte. Ecco un esempio delle informazioni relative alla lettera A con accento grave (set Latin-1) usata in un buffer che usa il sistema di codifica iso-2022-7bit⁸:

Char: À (04300, 2240, 0x8c0, ext ESC , A @) (latin-iso8859-1 64)

Argomenti numerici

In matematica e nell'uso informatico, la parola argomento indica "dati forniti ad una funzione o ad un'operazione". Ad ogni comando di Emacs è possibile passare un argomento numerico (chiamato anche argomento prefisso). Alcuni comandi interpretano l'argomento come il numero di volte che l'operazione deve essere ripetuta: ad esempio, C-f con un argomento che vale dieci sposta in avanti di dieci caratteri invece che di un carattere solo. Con tali comandi, il non fornire alcun argomento equivale a fornire un argomento pari a uno. Argomenti negativi indicano a gran parte di questi comandi di spostare o agire nella direzione opposta.

Se la tastiera del terminale dispone di un tasto META, il modo più semplice di specificare un argomento numerico è quello di digitare le cifre e/o il segno "meno" tenendo premuto il tasto META. Ad esempio:

M-5 C-n

sposta in basso di cinque linee. I caratteri Meta-1, Meta-2 e cos`i via (cos`i come Meta--) agiscono in tal modo in quanto sono sequenze collegate a dei comandi (digit-argument e negative-argument) che sono definiti per fornire un argomento al comando che segue. Le cifre e - modificati con Control, oppure con Control e Meta, specificano anch'essi degli argomenti numerici.

Un altro modo di specificare un argomento è quello di usare il comando C-u (universal-argument) seguito dalle cifre dell'argomento. Con C-u è possibile digitare le cifre dell'argomento senza dover tenere premuto un tasto modificatore; C-u funziona su tutti i terminali. Per inserire un argomento negativo basta digitare - dopo C-u. Un - da solo senza cifre significa normalmente -1.

C-u seguito da un carattere che non sia né una cifra n´un - ha il significato speciale di "moltiplica per quattro", e, appunto moltiplica per quattro l'argomento per il comando che segue. C-u due volte di seguito lo moltiplica per sedici. Pertanto, C-u C-u C-f sposta in avanti di sedici caratteri: è una buona tecnica per spostarsi in avanti velocemente, dato che ci si sposta di circa 1/5 di lina con per uno schermo di larghezza usuale. Altre combinazioni utili sono C-u C-n, C-u C-u C-n (sposta in basso di una buona percentuale dello schermo). C-u C-u C-p (inserisce numerose linee vuote) e C-u C-k (elimina quattro righe).

Alcuni comandi si curano unicamente alla presenza o all'assenza di un argomento, e non al suo valore. Ad esempio, il comando M-q (fill-paragraph) senza argomenti compatta il testo, mentre con un argomento lo giustifica (See Filling per maggiori informazioni su M-q). Un C-u da solo è un modo comodo di fornire un argomento a tali comandi.

Alcuni comandi interpretano il valore dell'argomento come il numero di volte che l'azione deve essere ripetuta, ma si comportano in maniera particolare se non vi è un argomento. Il comando C-k (kill-line), ad esempio, elimina n linee se gli si passa un argomento n, inclusi i newline. Tuttavia, C-k senza argomenti è particolare: elimina il testo fino alla fine della linea, oppure, se il point si trova già al termine della linea, esso elimina il newline stesso. Pertanto due C-k senza argomenti eliminano una linea, esattamente come un solo C-k con un argomento che vale uno (See Killing per maggiori informazioni su C-k).

Alcuni comandi trattano C-u in maniera diversa da un argomento ordinario, altri possono invece trattare un argomento - diversamente da -1. Questi casi particolari saranno evidenziati a mano a mano che li incontreremo, ma essi esistono unicamente per questioni di comodità d'uso del comando stesso.

È possibile usare un argomento numerico per inserire più volte lo stesso carattere: l'operazione è banale, a meno che il carattere da inserire non sia proprio una cifra. Ad esempio, C-u 6 4 a inserisce 64 copie del carattere a, ma se al posto di a si vuole inserire 1 occorre usare un altro sistema, poiché C-u 6 4 1 indica un argomento che vale 641. Per separare la cifra da inserire dall'argomento basta digitare C-u un'altra volta: C-u 6 4 C-u 1 inserisce 64 copie del carattere 1.

Si usa il termine argomento prefisso nel senso di "argomento numerico prefisso ad un comando" per sottolineare il fatto che l'argomento va digitato prima del comando e per distinguere tali argomenti da quelli inseriti nel minibuffer dopo aver digitato il comando.

Ripetere un comando

Il comando C-x z (repeat) fornisce un altro modo di ripetere molte volte un comando di Emacs, ripetendo l'ultimo comando immesso, qualunque esso sia. Nel ripetere il comando vengono utilizzati gli stessi argomenti usati prima, senza richiedere ogni volta l'inserimento di nuovi argomenti.

Per ripetere ulteriormente il comando basta digitare z, che ripete il comando ancora una volta. La ripetizione termina quando viene digitato un carattere diverso da z o quando viene premuto un pulsante sul mouse.

Ad esempio, supponiamo di aver digitato C-u 2 0 C-d per cancellare 20 caratteri: è possibile ripetere il comando (incluso il suo argomento) tre volte per cancellare un totale di 80 caratteri digitando C-x z z z. Il primo C-x z ripete il comando una volta, ed ogni z seguente lo ripete una volta ancora.

Il minibuffer

Il minibuffer è lo strumento usato per passare ai comandi di Emacs degli argomenti che siano più complicati di un semplice numero. Gli argomenti introdotti nel minibuffer possono essere nomi di file, di buffer, di funzioni Lisp, di comandi Emacs, di espressioni Lisp e molte altre cose ancora, a seconda del comando in esecuzione. Per digitare il testo relativo all'argomento è possbile usare i consueti comandi di Emacs.

Quando il minibuffer è in uso, esso compare nell'area messaggi ed il cursore del terminale viene spostato lì. L'inizio della linea del minibuffer mostra un prompt che specifica quale tipo di dato si deve fornire e come esso verrà utilizzato; tale prompt deriva spesso dal nome del comando cui l'argomento è destinato, e, normalmente, termina con due punti.

Talvolta compare tra parentesi (e dopo i due punti) un argomento di default: anch'esso fa parte del prompt. Esso viene usato come argomento quando non si inserisce nulla (premendo il solo tasto Invio). Ad esempio, i comandi che necessitano del nome di un buffer mostrano sempre un valore di default: esso consiste nel nome del buffer che verrà usato se ci si limita a premere Invio.

Il modo più semplice di introdurre un argomento nel minibuffer è quello di digitare il testo voluto, terminandolo col tasto Invio (che fa uscire dal minibuffer). È possibile annullare il comando che richiede l'argomento (e uscire dal minibuffer) digitando C-g.

Il minibuffer occupa sullo schermo lo spazio destinato all'area messaggi, e quindi esso può entrare in conflitto con gli altri modi in cui Emacs fa uso di quest'ultima. Di seguito è spiegato come Emacs gestisce questi conflitti:

• Se un comando produce un errore mentre si è nel minibuffer, il minibuffer non viene cancellato; tuttavia l'area messaggi è necessaria per visualizzare il messaggio d'errore, pertanto il minibuffer viene nascosto per alcuni istanti, e viene nuovamente visualizzato dopo qualche secondo, o non appena si digita qualcosa.
• Se nel minibuffer si fa uso di un comando il cui unico scopo è quello di produrre un messaggio nell'area messaggi (come C-x =), il messaggio è visualizzato normalmente ed il minibuffer viene nascosto per qualche istante. Il minibuffer viene nuovamente visualizzato dopo qualche secondo, o non appena si digita qualcosa.
• Mentre si sta usando il minibuffer, la visualizzazione della sequenza tasti digitati è disattivata.

• File: Inserire dei nomi di file nel minibuffer.
• Edit: Come operare nel minbuffer.
• Completion: Una funzionalità di abbreviazione nel minibuffer.
• Minibuffer History: Riutilizzare nel minibuffer argomenti recenti.
• Repetition: Eseguire nuovamente dei comandi che hanno fatto uso del minibuffer.

Il minibuffer per i nomi di file

Talvolta il minibuffer contiene già del testo; ad esempio, quando si deve introdurre il nome di un file, il minibuffer contiene la directory di default che termina con una barra obliqua (/): ciò avviene per evidenziare la directory in cui verrà cercato il file se non ne viene specificata alcuna.

Ad esempio, il minibuffer può contenere quanto segue:

Find File: /u2/emacs/src/

dove Find File: è il prompt. Digitando buffer.c si specifica il file /u2/emacs/src/buffer.c. Per leggere file da directory vicine, si può usare ..: se si digita ../lisp/simple.el si specificherà pertanto il file /u2/emacs/lisp/simple.el. In alternativa, si possono eliminare i nomi delle directory non desiderate tramite M-<DEL> (see Words).

Se lo si desidera, è possibile eliminare completamente il default tramite C-a C-k. Ciò, tuttavia, non è necessario, in quanto si può semplicemente ignorarlo: è infatti sufficiente inserire (dopo la directory di default mostrata) un percorso assoluto, ovvero uno che inizi con una barra obliqua / o una tilde ~. Ad esempio, per specificare il file /etc/termcap è sufficiente digitare /etc/termcap. Il contenuto del minibuffer sarà il seguente:

Find File: /u2/emacs/src//etc/termcap

Due barre oblique consecutive in una riga che specifica il nome di un file non hanno normalmente significato, ma sono permesse da GNU Emacs. Esse significano "ignora tutto ciò che precede la seconda barra". /u2/emacs/src/ nell'esempio precedente viene ignorato, e si va ad indicare pertanto il file /etc/termcap.

Se si imposta insert-default-directory a nil, la directory di default non viene mostrata nel minibuffer, dunque questo è inizialmente vuoto. Il nome di file digitato, tuttavia, è ancora considerato relativo alla directory di default (a meno che non sia stato specificato un percorso assoluto).

Uso del minibuffer

Il minibuffer è un buffer di Emacs (sebbene un po' particolare), e per inserire il testo dell'argomento sono disponibili i consueti comandi di Emacs.

Dato che Invio digitato nel minibuffer produce l'uscita dallo stesso, non è possibile usare tale tasto per andare a capo. Per andare a capo occorre usare C-o, oppure C-q C-j (notare che un "a capo" è in realtà un carattere control-J).

Il minibuffer ha la propria finestra, che occupa sempre dello spazio sullo schermo e si comporta come se non esistesse quando il minibuffer non è utilizzato. Quando invece lo è, la finestra del minibuffer è come tutte le altre finestre: è possbile passare ad un'altra finestra con C-x C-o e modificare il testo in altre finestre (ed eventualmente aprire altri file prima di ritornare al minibuffer per inserire l'argomento). È anche possbile copiare del testo in un'altra finestra, ritornare alla finestra del minibuffer e infine incollarlo per usarlo come argomento. See Windows.

Esistono, tuttavia, alcune restrizioni sull'uso della finestra del minibuffer: non è possibile cambiare il buffer ad essa associato--il minibuffer e la sua finestra sono associati in modo permanente. Non è possibile inoltre dividerla in due, o chiuderla, ma la si può espandere verticalmente nel modo consueto, con C-x ^. Se si abilita il modo Resize-Minibuffer, la finestra si espande automaticamente quanto basta per visualizzare il testo immesso nel minibuffer. M-x resize-minibuffer-mode abilita o disabilita questo modo secondario (see Minor Modes).

Lo scorrimento orizzontale automatico è particolarmente adatto con la finestra del minibuffer: quando il minibuffer contiene una sola lunga riga di testo che non è visualizzabile per intero, lo scorrimento automatico mantiene una sovrapposizione di un determinato numero di caratteri tra le varie linee di continuazione. La variabile minibuffer-scroll-overlap specifica di quanti caratteri deve essere tale sovrapposizione: il default è 20.

Se si digita nel minibuffer un comando che mostri del testo di aiuto in un'altra finestra, è possibile far scorrere verticalmente tale testo digitando nel minibuffer il comando C-M-v: ciò funziona fin quando si rimane nel minibuffer stesso. Questa funzionalità è particolarmente utile se un minibuffer fornisce una lista di possibili completamenti See Other Window.

Normalmente, Emacs impedisce alla maggior parte dei comandi di far uso del minibuffer se quest'ultimo è già in uso da altri comandi: tale regola sussiste per evitare che dei minibuffer ricorsivi confondano gli utenti meno esperti. È necessario impostare la variabile enable-recursive-minibuffers ad un valore diverso da nil se si desidera far uso anche di tali comandi nel minibuffer.

Completamento

Per introdurre i dati relativi ad alcuni tipi di argomenti si può usare il completamento: ciè si può digitare la parte iniziale dell'argomento e lasciare che Emacs completi quella rimanente, o quantomeno aggiunga tutto ciò che può essere dedotto da quanto è stato digitato fino a quel momento.

Quando il completamento è disponibile, alcuni tasti--<TAB>, <Invio> e <Spazio>--sono riassegnati al completamento del testo presente nel minibuffer, in modo che si possa ottenere una stringa più lunga di testo la cui abbreviazione era quanto digitato in precedenza. Ciò avviene esaminando una serie di possibili completamenti, forniti a loro volta dal comando che ha richiesto l'argomento. ? ne mostra una lista.

Ad esempio, M-x usa il minibuffer per leggere il nome di un comando e fornisce nel contempo un elenco di tutti i comandi di Emacs disponibili per il completamento. I tasti di completamento confrontano il testo nel minibuffer con tale elenco, elaborano i caratteri da aggiungere in base a quanto già presente nel minibuffer e accodano infine questi ultimi a quelli già digitati. Ciò, ad esempio, rende possibile digitare M-x ins <Spazio> b <Invio> al posto di M-x insert-buffer <Invio>.

Normalmente, nel completamento viene fatta distinzione tra le lettere maiuscole e quelle minuscole, in quanto la maggior parte dei nomi completabili la fanno (nomi di buffer, di file e di comandi). Pertanto, pi non viene completato in Pippo. Il processo di completamento ignora tale distinzione per certi tipi di argomenti in cui la differenza tra maiuscole e minuscole non è significativa.

• Example:
• Commands:
• Strict Completion:
• Options:

Esempio di completamento

Può essere ora d'aiuto un esempio concreto: se si digita M-x au <TAB>, la pressione del tasto <TAB> provoca la ricerca di alternative (in questo caso nomi di comandi) inizianti per au: ne esistono diverse, incluse auto-fill-mode e auto-save-mode--ma esse hanno tutte in comune auto-, cos`i au nel minibuffer viene espanso in auto-.

Ora vi sono varie possibilità per il carattere successivo--potrebbe essere c, f, i, l, r, s--quindi non vengono aggiunti altri caratteri. Una nuova pressione di <TAB> mostra questa volta una lista (in un'altra finestra) di tutti i possibili completamenti.

Se si procede digitando f <TAB>, <TAB> ha a disposizione auto-f. L'unico comando il cui nome inizia in questo modo è auto-fill-mode, per cui il completamento provoca l'espansione in quest'ultimo. In conclusione, si è ottenuto auto-fill-mode nel minibuffer semplicemente digitando au <TAB> f <TAB>. È da notare che <TAB> produce questo effetto poiché, quando il completamento nel minibuffer è disponibile, esso viene associato al comando minibuffer-complete.

Comandi di completamento

Ecco una lista dei comandi di completamento usabili nel minibuffer (quando il completamento è disponibile):

<TAB>

Completa per quanto possibile il testo nel minibuffer (minibuffer-complete).

<Spazio>

Completa il testo nel minibuffer, ma non va oltre una singola parola (minibuffer-complete-word).

<Invio>

Assegna all'argomento il testo presente nel minibuffer, eventualmente completandolo come descritto in seguito (minibuffer-complete-and-exit).

?

Mostra una lista di tutti i possibili completamenti del testo presente nel minibuffer (minibuffer-list-completions).

<Spazio> produce un completamento simile a quello prodotto da <TAB>, ma non va mai oltre lo spazio o il trattino (-) successivo. Se nel minibuffer c'è auto-f e si digita <Spazio>, viene trovato il completamento auto-fill-mode, ma l'espansione si ferma a fill-. Il risultato ottenuto è quindi auto-fill-. Premendo un'altra volta <Spazio> si ottiene il completamento finale a auto-fill-mode. Quando il completamento è disponibile, <Spazio> nel minibuffer avvia il comando minibuffer-complete-word.

Ecco di seguito alcuni comandi che possono essere usati per scegliere un completamento dalla finestra che mostra l'elenco di quelli possibili:

Mouse-2

Un completamento può essere selezionato facendo click col tasto centrale del mouse su un completamento nella lista di quelli possibili (mouse-choose-completion). Questo comando normalmente si usa quando il point è nel minibuffer, tuttavia occorre fare click nella lista dei completamenti, non nel minibuffer.

<PRIOR>

M-v

Digitando <PRIOR> (o <PAGE-UP>, o M-v) nel minibuffer si seleziona la finestra che visualizza il buffer contenente la lista dei completamenti possibili (switch-to-completions): ciò facilita l'uso dei comandi che seguono (si può sempre selezionare tale finestra nel modo usuale, ma questo modo è molto più pratico).

<Invio>

Digitando <Invio> nel buffer contenente la lista dei completamenti si seleziona il quello su cui si trova il point, o quello immediatamente a fianco dello stesso (choose-completion). Per usare questo comando occorre prima selezionare la finestra che mostra la lista dei completamenti.

<RIGHT>

La pressione del tasto cursore destro <RIGHT> nel buffer contenente la lista dei completamenti provoca lo spostamento del point verso il completamento seguente (next-completition).

<LEFT>

La pressione del tasto cursore sinistro <LEFT> nel buffer contenente la lista dei completamenti provoca lo spostamento del point al completamento precedente, verso l'inizio del buffer (previous-completition).

Completamento rigoroso

A seconda dell'uso che viene fatto dell'argomento, <Invio> completa quanto è presente nel minibuffer in tre modi differenti:

• Il completamento rigoroso è usato quando occorre fornire un argomento che sia necessariamente presente in una lista di alternative note. Ad esempio, quando C-x k legge il nome del buffer da eliminare, ha senso solo fornire il nome di un buffer esistente. Nel completamento rigoroso, <Invio> non provoca l'uscita dal minibuffer se il testo in esso contenuto non può essere completato univocamente.
• Il completamento cauto è simile al completamento rigoroso, tranne nel fatto che <Invio> provoca l'uscita solo se il testo è già un argomento completo. Se il testo non costituisce un argomento completo, <Invio> non provoca l'uscita, ma induce il completamento del testo. Se l'espansione porta ad un argomento completo, una successiva pressione di <Invio> provocherà l'uscita dal minibuffer.

  Il completamento cauto viene usato nell'immissione di nomi di file che devono essere già esistenti.

• Il completamento permissivo viene usato quando qualsiasi stringa è significativa e la lista delle alternative di completamento ha solo valore indicativo. Ad esempio, quando C-x C-f legge il nome di un file da aprire, è possibile inserire un nome di file qualsiasi (per permettere di creare un file nuovo). Con il completamento permissivo, <Invio> inserisce il testo esattamente com'è stato digitato, senza completarlo.

Ogni volta che vi è più di una possibilità per il carattere successivo, i comandi di completamento mostrano in una finestra l'elenco di tutti i completamenti possibili. Oltre a questo, digitando ? si richiede esplicitamente la visualizzazione di tale elenco. Se esso risulta essere particolarmente lungo, è possibile scorrerlo con C-M-v (see Other Window).

Opzioni di completamento

Quando si effettua il completamento di nomi di file, alcuni file sono solitamente ignorati. La variabile completion-ignored-extensions contiene una lista di stringhe: ai fini del completamento, i file il cui nome termina per una qualsiasi di queste stringhe vengono ignorati. Il valore standard di questa variabile contiene diverse estensioni, incluse ".o", ".elc", ".dvi" and "~". L'effetto è quello per cui, ad esempio, pippo può essere completato direttamente in pippo.c anche se esiste pippo.o. Tuttavia, se tutti i completamenti possibili terminano con estensioni da ignorare, essi non sono ignorati. Le estensioni da ignorare non si applicano alla visualizzazione della lista dei completamenti--essa contiene sempre tutti i completamenti possibili.

Normalmente, quando un comando di completamento si rende conto dell'esistenza di più candidati per il carattere successivo, esso visualizza l'elenco dei completamenti possibili. Ciò non avviene se la variabile completion-auto-help è impostata a nil, ed occorre pertanto digitare ? per mostrarli.

La libreria complete implementa un tipo di completamento più ricco di funzioni, in grado di completare più parole alla volta. Ad esempio, essa può completare l'abbreviazione p-b in print-buffer, dato che esso è l'unico comando formato da due parole le cui iniziali siano p e b. Per usare questa libreria basta aggiungere (load "complete") nel proprio file ~/.emacs (see Init File).

Il modo Icomplete mostra costantemente un elenco aggiornato dei completamenti disponibili per il testo digitato. Il comando per abilitare o disabilitare tale modo secondario è M-x icomplete-mode.

L'history del minibuffer

Quanto digitato nel minibuffer viene memorizzato in una lista degli argomenti inseriti, cos`i da poterlo riutilizzare in seguito per altri argomenti. Dei comandi speciali sostituiscono il contenuto del minibuffer col testo di un argomento inserito in precedenza: si può pensare ad essi come a dei comandi che permettono di navigare attraverso l'elenco di quanto digitato in precedenza.

<UP>

M-p

Propone l'argomento precedente memorizzato nella lista degli argomenti inseriti (previous-history-element).

<DOWN>

M-n

Propone l'argomento successivo memorizzato nella lista degli argomenti inseriti (next-history-element).

M-r regexp <Invio>

Propone l'argomento precedente memorizzato nella lista degli argomenti inseriti che soddisfi l'espressione regolare regexp (previous-matching-history-element).

M-s regexp <Invio>

Propone l'argomento successivo memorizzato nella lista degli argomenti inseriti che soddisfi l'espressione regolare regexp (next-matching-history-element).

Il modo più semplice di riutilizzare quanto presente nella lista degli argomenti inseriti è quello di navigare in tale lista un elemento alla volta. Quando si è nel minibuffer si può usare M-p o il tasto cursore in alto (previous-history-element) per "saltare" all'argomento precedente, e M-n o il tasto cursore in basso (next-history-element) per quello successivo.

Quanto digitato in precedenza viene recuperato dalla lista degli argomenti inseriti e va a sostituire il contenuto del minibuffer. Per usarlo come argomento è sufficiente terminare l'immissione nel minibuffer nel modo consueto, ovvero con <Invio>. È inoltre possibile modificare il testo prima di riutilizzarlo: ciò non modifica l'elemento verso il quale ci si è "spostati", ma il nuovo argomento viene esso stesso aggiunto in fondo alla lista.

Per molti argomenti introdotti nel minibuffer esiste un valore di default: in alcuni casi, i comandi relativi alla lista degli argomenti inseriti sono a conoscenza del valore di default, per cui è possibile inserirlo nel minibuffer facendo uso di M-n per spostarsi "nel futuro". Si spera di poter rendere disponibile questa funzionalità ogniqualvolta il minibuffer avrà un valore di default.

Esistono inoltre comandi per effettuare ricerche in avanti e all'indietro attraverso la lista degli argomenti inseriti: essi ricercano gli elementi di tale lista che soddisfano un'espressione regolare specificata nel minibuffer. M-r (previous-matching-history-element) ricerca all'indietro, mentre M-s (next-matching-history-element) ricerca in avanti. Come eccezione alla regola, questi comandi possono far uso del minibuffer per leggere i loro argomenti sebbene ci si trovi già nel minibuffer quando li si digita. Esattamente come accade per la ricerca incrementale, si fa distinzione tra maiuscole e minuscole se l'espressione regolare contiene lettere maiuscole (see Search Case).

Il minibuffer registra sempre gli argomenti inseriti in una lista, ma esistono liste distinte per tipi distinti di argomenti. Ad esempio, esiste una lista per i nomi di file che è usata da tutti i comandi che leggono nomi di file (in particolare, questa lista memorizza né più né meno il nome assoluto del file, anche se esso non è stato introdotto in quel modo).

Vi sono molte altre liste specifiche, incluse una per i nomi dei comandi letti da M-x, una per i nomi dei buffer, una per gli argomenti di comandi come query-replace ed una per i comandi di compilazione letti da compile. Infine, esiste una lista "varie" usata per la maggior parte dei tipi di argomenti rimanenti.

La variabile history-length specifica la lunghezza massima di una lista di argomenti inseriti. Una volta che una lista raggiunge la lunghezza specificata, ogni aggiunta di un nuovo elemento provoca l'eliminazione dell'elemento più vecchio. Se il valore di history-length è t, tuttavia, non vi è lunghezza massima e gli elementi non vengono mai cancellati.

Ripetere i comandi nel minibuffer

Ogni comando che ha usato almeno una volta il minibuffer è memorizzato in una lista speciale insieme al valore dei suoi argomenti, cos`i da poter ripetere l'intero comando. In particolare, in questa lista è memorizzato ogni uso di M-x visto che M-x fa uso del minibuffer per leggere il nome del comando.

C-x <ESC> <ESC>

Esegue nuovamente un comando che ha usato recentemente il minibuffer (repeat-complex-command).

M-x list-command-history

Mostra l'intera lista dei comandi inseriti, visualizzando (a partire dal più recente) tutti i comandi che C-x <ESC> <ESC> è in grado di ripetere.

C-x <ESC> <ESC> è usato per eseguire nuovamente un comando che ha usato minibuffer. Senza argomenti ripete il più recente dei comandi memorizzati. Un argomento numerico indica invece quale comando ripetere: 1 indica l'ultimo, 2 il penultimo, e cos`i via per i comandi precedenti.

C-x <ESC> <ESC> opera trasformando il comando precedente in un'espressione Lisp e proponendola nel minibuffer. Se si digita <Invio>, il comando viene ripetuto. In ogni caso, l'espressione eseguita è quella effettivamente inserita. Il comando ripetuto è aggiunto alla lista dei comandi inseriti, a meno che non sia identico a quello più recente presente in lista.

Anche se non si conosce la sintassi del Lisp, è comunque facile capire il significato del comando mostrato. Se non si modifica il testo, il comando verrà ripetuto esattamente come prima.

Una volta entrati nel minibuffer con C-x <ESC> <ESC>, è possibile usare i comandi citati in precedenza, ovvero (M-p, M-n, M-r, M-s; see Minibuffer History) per navigare nella lista dei comandi già inseriti. Dopo essersi posizionati sul comando desiderato, è possibile modificarlo come al solito ed eseguirlo digitando <Invio>.

L'elenco dei comandi che hanno fatto uso del minibuffer è memorizzato in una lista Lisp contenuta nella variabile command-history: ogni elemento è un'espressione Lisp che descrive il comando ed i suoi argomenti. I programmi in Lisp possono esegure nuovamente un comando invocando eval con l'elemento di command-history desiderato.

Invocare comandi tramite il loro nome

Per questioni di praticità, i comandi più comuni di Emacs (o che devono essere di rapida invocazione) sono associati a delle sequenze di caratteri. I restanti comandi non sono invece associati a delle sequenze di caratteri: per invocarli occorre richiamarli per nome.

Per convenzione, il nome di un comando è composto da una o più parole separate da trattini (-), come auto-fill-mode o manual-entry. L'uso di parole inglesi fa s`i che i nomi dei comandi siano più semplici da ricordare rispetto ad una complicata sequenza di caratteri, anche se essi sono più lunghi da digitare.

Per invocare un comando tramite il suo nome si può digitare M-x seguito dal nome del comando e dal tasto <Invio>. M-x usa il minibuffer per leggere il nome del comando; <Invio> fa uscire dal minibuffer ed esegue il comando. Come prompt all'inizio del minibuffer compare la stringa M-x, per sollecitare l'inserimento del nome di un comando. See Minibuffer per maggiori informazioni sulle funzionalità del minibuffer.

Per introdurre il nome del comando si può far uso del completamento. Ad esempio, il comando forward-char può essere invocato per nome digitando

M-x forward-char <Invio>

oppure

M-x forw <TAB> c <Invio>

Notare che forward-char è lo stesso comando avviato dalla sequenza C-f. Con M-x è possibile avviare qualsiasi comando di Emacs, anche se esso è già associato ad una sequenza di caratteri.

Digitando C-g mentre si inserisce il nome del comando si annulla il comando M-x e si esce dal minibuffer.

Per passare un argomento numerico al comando che si vuole avviare con M-x è necessario specificare tale argomento prima di digitare M-x. Mentre si inserisce il nome del comando, il valore dell'argomento viene visualizzato nel prompt. M-x passa poi l'argomento al comando specificato.

Se il comando digitato era associato ad una sequenza di caratteri, Emacs mostra quest'ultima nell'area messaggi due secondi dopo che l'esecuzione del comando è terminata (purché non si digiti nient'altro nel frattempo). Digitando M-x forward-word ad esempio, il messaggio informa che è possibile avviare più rapidamente tale comando tramite M-f. Questi messaggi possono essere disabilitati impostando la variabile suggest-key-bindings a nil.

In questo manuale, nei punti ove si parla di comandi invocati tramite il loro nome, viene omessa l'indicazione esplicita di <Invio> (necessario per terminare l'inserimento del comando): al posto di M-x auto-fill-mode <Invio> viene pertanto indicato M-x auto-fill-mode. Il tasto <Invio> viene menzionato unicamente quando vi è la necessità di sottolineare la sua presenza, come quando il comando viene mostrato insieme suoi argomenti.

M-x avvia il comando execute-extended-command, che legge il nome di un comando dal minibuffer e poi lo esegue.

Aiuto

Emacs fornisce funzionalità di aiuto accessibili tramite il carattere C-h. La sequenza C-h è un prefisso dedicato esclusivamente ai comandi relativi alla documentazione: i caratteri digitabili di seguito a C-h sono chiamati convenzionalmente opzioni di aiuto. Uno di essi è proprio C-h, che serve per avere informazioni sull'utilizzo del sistema di aiuto. Per annullare è sufficiente digitare C-g. Il tasto funzione <F1> è equivalente a C-h.

C-h C-h (help-for-help) mostra un elenco di tutte le opzioni di aiuto disponibili, ognuna seguita da una breve descrizione. Prima di specificare un'opzione d'aiuto è possibile usare <Spazio> o <DEL> per scorrere il suddetto elenco.

C-h o <F1> fornisce un aiuto anche in diversi altri contesti: se digitati ad esempio nel mezzo dell'esecuzione di un comando query-replace, essi visualizzano le opzioni disponibili contestualmente a tale comando. Se digitati dopo un prefisso qualsiasi, essi visualizzano la lista delle possibili alternative che possono seguire tale prefisso (alcuni prefissi non supportano l'uso di C-h in quanto essi definiscono altri significati per tale carattere, ma tutti supportano <F1>).

La maggior parte dei buffer relativi alle informazioni d'aiuto usano un modo primario speciale, il modo Help, che permette di scorrerli agevolmente con i tasti <Spazio> e <DEL>.

• Help Summary: Breve elenco di tutti i comandi di aiuto.
• Key Help: Chiedere cosa fa una determinata sequenza di tasti in Emacs
• Name Help: Ottenere informazioni su un comando, su una variabile o su una funzione.
• Apropos: Ottenere informazioni relative ad un determinato argomento.
• Library Keywords: Cercare le librerie Lisp tramite parole chiave.
• Language Help: Informazioni sul supporto internazionale dei linguaggi.
• Help Mode: Funzionalità particolari dell'Help mode e dei buffer contenenti informazioni d'aiuto.
• Misc Help: Altri comandi di aiuto.

Ecco un sommario dei comandi d'aiuto disponibili:

C-h a regexp <Invio>

Mostra una lista di comandi che soddisfano l'espressione regolare regexp (apropos-command).

C-h b

Mostra una tabella di tutte le associazioni tra sequenze di caratteri e comadi che sono attive al momento, secondo il seguente ordine: associazioni relative al modo secondario corrente, associazioni relative al modo primario corrente e associazioni globali (describe-bindings).

C-h c sequenza di caratteri

Mostra il nome del comando associato alla sequenza di caratteri. (describe-key-briefly). La c sta per `carattere'. Si può usare C-h k per avere informazioni più dettagliate sul comando.

C-h f funzione <Invio>

Mostra la documentazione relativa alla funzione Lisp indicata (describe-function). Può essere inserito anche il nome di un comando, in quanto essi sono funzioni Lisp.

C-h h

Mostra il file hello, che contiene esempi di diversi insiemi di caratteri.

C-h i

Avvia Info, il prgramma per consultare i file di documentazione (info). Il manuale di Emacs è completamente disponibile in linea sotto forma di file Info.

C-h k sequenza di caratteri

Mostra il nome e la documentazione relativa al comando avviato dalla sequenza di caratteri specificata (describe-key).

C-h l

Mostra gli ultimi 100 caratteri digitati (view-lossage).

C-h m

Mostra la documentazione relativa al modo primario corrente (describe-mode).

C-h n

Mostra la documentazione relativa ai cambiamenti di Emacs tra una versione e l'altra. Le modfiche più recenti sono elencate per prime(view-emacs-news).

C-h p

Trova i packages tramite una parola chiave (finder-by-keyword).

C-h s

Mostra il contenuto corrente della tabella sintattica insieme alla descrizione degli elementi che la compongono (describe-syntax). See Syntax.

C-h t

Avvia il tutorial di Emacs (help-with-tutorial).

C-h v var <Invio>

Mostra la documentazione relativa alla variabile Lisp var (describe-variable).

C-h w comando <Invio>

Visualizza quali sequenze di caratteri avviano il comando specificato (where-is).

C-h C codifica <Invio>

Descrive il sistema di codifica specificato (describe-coding-system).

C-h C <Invio>

Descrive il sistema di codifica attualmente in uso.

C-h I metodo <Invio>

Descrive il metodo di input specificato (describe-input-method).

C-h L language-env <Invio>

Fornisce informazioni sul set di caratteri, sistema di codifica e metodi di inserimento usati per l'ambiente linguistico specificato (describe-language-environment).

C-h C-c

Mostra le condizioni riguardanti la redistribuzione di GNU Emacs.

C-h C-d

Mostra informzioni su come ottenere le nuove versioni di GNU Emacs.

C-h C-f funzione <Invio>

Avvia Info e mostra la pagina relativa alla funzione di Emacs indicata (Info-goto-emacs-command-node).

C-h C-k sequenza di caratteri

Avvia Info e mostra la pagina ove è documentata la sequenza di caratteri indicata (Info-goto-emacs-key-command-node).

C-h C-p

Mostra informazioni relative al progetto GNU.

C-h <TAB> simbolo <Invio>

Mosra la documentazione Info relativa al simbolo indicato, in base al linguaggio di programmazione che si sta usando (info-lookup-symbol).

Aiuto sulle sequenze di caratteri

Le opzioni di base di C-h sono C-h c (describe-key-briefly) e C-h k (describe-key). C-h c sequenza di caratteri mostra nell'area messaggi il nome del comando associato alla sequenza di caratteri indicata. Ad esempio, C-h c C-f mostra forward-char. Dato che i nomi dei comandi sono stati assegnati in modo da descrivere sinteticamente la funzione del comando, questo è un buon metodo per avere una descrizione molto breve di cosa produce la sequenza di caratteri indicata ⁹

C-h k key è simile, ma fornisce maggiori informazioni: essa mostra il nome del comando e la stringa di documentazione relativa. La quantità di informazioni è troppo grande per essere mostrata nell'area messaggi, per cui viene usata una finestra a parte.

C-h c e C-h k possono essere usati con qualsiasi sequenza di caratteri, inclusi i tasti funzione e gli eventi provenienti dal mouse.

Aiuto in base al nome del comando o della variabile.

C-h f (describe-function) legge il nome di una funzione Lisp dal minibuffer e poi mostra in una finestra a parte la stringa di documentazione della funzione. Dato che i comandi sono funzioni Lisp, è possibile ottenere in questo modo la documentazione di un comando, posto che se ne conosca il nome. Ad esempio:

C-h f auto-fill-mode <Invio>

mostra la documentazioen di auto-fill-mode. Questo è l'unico modo per ottenere la documentazione di un comando che non sia associato ad una sequenza di caratteri (comando che, normalmente, viene avviato tramite M-x).

C-h f è inoltre utile per le funzioni Lisp che si pensa di usare in un programma Lisp. Supponiamo ad esempio di aver appena scritto l'espressione (make-vector len) e di voler verificare che make-vector sia utilizzato correttamente: è sufficiente digitare C-h f make-vector <Invio>. Dato che C-h f accetta i nomi di tutte le funzioni (e quindi non solo i nomi dei comandi), è possibile che alcune delle abbreviazioni usate di solito con M-x non funzionino con C-h f, in quanto un'abbreviazione che è univoca rispetto ai nomi dei comandi non lo è necessariamente quando sono considerati anche i nomi delle funzioni.

Esiste un valore di default per il nome della funzione letto da C-f che viene usato quando si digita <Invio> lasciando il minibuffer vuoto. Tale valore consiste nel nome della funzione invocata dall'espressione Lisp più interna che contenga il point, a condizione che esso sia il nome di una funzione definita e valida. Ad esempio, se il point è situato di seguito a (make-vector (car x), la lista più interna che contiene il point è quella che inizia con (make-vector. Per default, quindi, viene descritta la funzione make-vector.

C-h f è spesso utile per verificare di aver digitato correttamente il nome della funzione. Se C-h f propone un nome di default, esso è sicuramente il nome di una funzione Lisp valida. Se questo era tutto ciò di cui si aveva bisogno di sapere, basta digitare C-g per annullare il comando C-h f e riprendere il lavoro.

C-h w comando <Invio> mostra nell'area messaggi una lista di tutte le sequenze di caratteri che sono associate ad un comando. Se il comando non è associato ad alcuna sequenza di caratteri, è necessario usare M-x per avviarlo. C-h w avvia il comando where-is.

C-h v (describe-variable) è analogo a C-h f, ma descrive variabili Lisp invece che funzioni. Ha per default il simbolo Lisp in cui si trova il point, oppure che precede il point, a condizione che esso sia il nome di una variabile Lisp nota. See Variables.

A proposito di...

Una domanda più complessa potrebbe essere "Quali sono i comandi che riguardano i file?". Per formulare questa domanda è sufficente digitare C-h a file <Invio>, che mostra un elenco di tutti i nomi di comandi che contengono la parola file, inclusi copy-file, find-file e cos`i via. Insieme al nome del comando viene visualizzata una breve descrizione dello stesso e le sequenze di caratteri ad esso associate (viene mostrato, ad esempio, che find-file può essere avviato digitando C-x C-f). La a in C-h a sta per `a proposito di'; C-h a invoca il comando apropos-command. Di norma questo comando prende in considerazione solo i comandi (funzione interattive); se si fornisce un qualsiasi argomento come prefisso, esso considera anche le funzioni non interattive.

Dato che C-h a va alla ricerca soltanto delle funzioni che contengono la stringa specificata, occorre un po' di intuito nel scegliere quest'ultima. Se si stanno cercando i comandi per eliminare del testo all'indietro e C-h a kill-backwards <Invio> non ne rileva alcuno, non bisogna scoraggiarsi subito: occorre invece insistere e provare con kill, o backwards, o semplicemente back. È da notare, comunque, che è possibile specificare come stringa di ricerca un'espressione regolare, la qual cosa permette maggiore flessibilità (see Regexps).

Ecco di seguito un elenco di possibli argomenti per C-h a che coprono buona parte delle classi di comandi di Emacs. Ciò è possibile in quanto esistono convenzioni rigorose sull'assegnazione dei nomi ai comandi standard di Emacs: esaminando l'elenco è possibile farsi un'idea di tali convenzioni e sviluppare una tecnica adeguata per scegliere gli argomenti da usare con C-h a.

char, line, word, sentence, paragraph, region, page, sexp, list, defun, rect, buffer, frame, window, face, file, dir, register, mode, beginning, end, forward, backward, next, previous, up, down, search, goto, kill, delete, mark, insert, yank, fill, indent, case, change, set, what, list, find, view, describe, default.

Per avere un elenco di tutte le variabili il cui nome soddisfa un'espressione regolare si può usare il comando M-x apropos-variable. Per default, questo comando mostra solo le variabili utente e le opzioni di personalizzazione; se si specifica un argomento come prefisso, il comando prende in considerazione tutte le variabili.

Per avere un elenco di tutti i nomi dei simboli Lisp che soddifano una certa espressione regolare, al posto di C-h a si può usare il comando M-x apropos . Per default, questo comando non mostra le sequenze di tasti associate ai comandi: occorre specificare un argomento come prefisso per far s`i che esse vengano incluse.

Il comando apropos-documentation è simile a apropos, tranne che esso effettua la ricerca anche nella stringa di documentazione oltre che nei nomi dei simboli.

Il comando apropos-value è analogo a apropos, tranne che esso effettua le ricerche nel valore dei simboli, mostrando tutto ciò che soddisfa l'espressione regolare specificata. Per default, questo comando non ricerca all'interno delle definizioni delle funzioni o all'interno delle liste di proprietà: è necessario specificare un argomento numerico come prefisso se si vuole che la ricerca avvenga anche in esse.

Se la variabile apropos-do-all ha un valore diverso da nil, i comandi sopra elencati si comportano sempre come se fosse stato specificato un argomento come prefisso.

Se si desiderano maggiori informazioni sulla definizione di una funzione, su una variabile o su una proprietà simbolica elencata nel buffer Apropos, è possibile far click su di essa con il pulsante centrale del mouse, o spostarsi su di essa e digitare <Invio>.

Ricerca per parole chiave nelle librerie Lisp

Il comando C-h p permete di effettuare ricerche per parola chiave all'interno delle librerie Lisp standard di Emacs. Ecco una lista (non completa) delle parole chiave utilizzabili:

abbrev --- gestione di abbreviazioni, scorciatoie, macro.
bib --- gestione di bibliografie bib.
c --- supporto ai linguaggi C e C++.
calendar --- gestione delle date e del  calendario.
comm --- supporto a telecomunicazioni, reti, accesso remoto ai file.
data --- supporto alla modifica di file di dati.
docs --- supporto alla documentazione di  Emacs.
emulations --- emulazione di altri editor.
extensions --- estensioni all'Emacs Lisp.
faces --- supporto all'uso degli stili (font e colori; see Faces).
frames --- supporto ai frame di  Emacs e al'ambiente a finestre ospitante.
games --- giochi, scherzi e cose divertenti.
hardware --- interfacciamento con hardware ``esotico''.
help --- il sistema di aiuto in linea.
hypermedia --- supporto a ipertesti, o ad altri media.
i18n --- internazionalizzazione e gestione di set di caratteri alternativi.
internal --- codice interno a Emacs, processo di build, valori di default.
languages --- modi specializzati per lavorare su file sorgenti.
lisp --- supporto al linguaggio Lisp (Emacs Lisp incluso).
local --- librerie locali.
maint --- supporto alla manutenzione di Emacs e al gruppo di sviluppo.
mail --- modi specializzati nella gestione della posta elettronica.
matching --- ricerche.
news --- supporto alla lettura/scrittura delle news via rete.
non-text --- supporto alla gestione di file non testuali.
oop --- supporto per la programmazione ad oggetti.
outlines --- visione strutturata di documenti.
processes --- supporto per processi, sub-shell, compilazione e job control.
terminals --- supporto ai vari tipi di terminali.
tex --- supporto al TeX.
tools --- tools per la programmazione.
unix --- front-end/assistenti/emulatori di funzionalità Unix.
vms --- codice di supporto al sistema operativo VMS.
wp --- word processing.

Aiuto sul supporto internazionale delle lingue.

Con il comando C-h L (describe-language-environment) è possibile avere informazioni riguardo al supporto di uno specifico ambiente linguistico, See Language Environments: esso mostra le lingue per cui l'ambiente specificato è adatto, i set di caratteri, i sistemi di codifica ed i metodi di input ad esso associati. Mostra inoltre del testo di esempio.

Il comando C-h h (view-hello-file) mostra il file etc/HELLO, che contiene "Ciao" in molte lingue.

Il comando C-h I (describe-input-method) fornisce informazioni relative a un metodo di input--relativamente a quello specificato o a quello correntemente in uso. See Input Methods.

Il comando C-h C (describe-coding-system) mostra informazioni relative a un sistema di codifica--relativamente al sistema di codifica specificato, o a quello correntemente in uso. See Coding Systems.

Comandi relativi al modo Help

I buffer di aiuto supportano i comandi del modo View (see Misc File Ops), con in aggiunta alcuni comandi specifici.

<Spazio>

Scorre in avanti.

<DEL>

Scorre indietro.

<Invio>

Segue il riferimento su cui si trova il point.

<TAB>

Sposta il point in avanti fino al prossimo riferimento.

S-<TAB>

Sposta il point indietro fino al riferimento precedente.

Tasto centrale del mouse

Segue il riferimento su cui si fa click con il mouse.

Quando nella documentazione appare il nome di un comando (see Running Commands by Name) o il nome di una variabile (see Variables), esso compare normalmente tra apici singoli. È possibile far click con il tasto centrale del mouse (o spostare il point e premere il tasto <Invio>) per visualizzare la documentazione relativa al comando o alla variabile selezionata. Per tornare sui propri passi si può usare la sequenza C-c C-b.

Esistono comandi utili per spostare il point tra i vari riferimenti nel testo di aiuto. Il tasto <TAB> (help-next-ref) sposta il point al riferimento successivo. Per andare invece al riferimento precedente si può usare il tasto S-<TAB> (help-previous-ref).

Altri comandi di aiuto

C-h i (info) avvia il programma Info, che viene usato per navigare nei file di documentazione. L'intero manuale di Emacs è disponibile nel sistema Info, ed eventualmente l'intera documentazione del sistema GNU. Digitando h dopo aver avviato Info si avvia un tutorial sull'uso di Info.

Se si specifica un argomento numerico come prefisso, C-h i richiede l'immissione del nome di un file di documentazione: in questo modo è possibile visualizzare un file anche se esso non ha una voce nel menù principale di Info che faccia riferimento ad esso. Questo è anche un sistema pratico per accedere velocemente a della documentazione una volta conosciuto il nome del file.

Esistono due comandi d'aiuto speciali per accedere alla documentazione di Emacs disponibile in Info: C-h C-f funzione <Invio> avvia Info e mostra direttamente la documentazione della funzione di Emacs funzione, mentre C-h C-k sequenza avvia Info e mostra la documentazione della sequenza di caratteri sequenza. Queste due sequenze avviano rispettivamente i comandi Info-goto-emacs-command-node e Info-goto-emacs-key-command-node.

Quando si sta lavorando sul sorgente di un programma e si ha a disposizione una versione Info del manuale relativo al linguaggio di programmazione usato, è possibile usare il comando C-h C-i per ottenere la documentazione di un simbolo (parola chiave, funzione o variabile). I dettagli implementativi di questo comando dipendono dal modo primario utilizzato.

Nel caso accadesse qualcosa di inaspettato e non si è sicuri di cosa si è digitato, è possibile usare C-h l (view-lossage) per vedere gli ultimi 100 caratteri digitati. Qualora si trovino dei comandi sconosciuti, è possibile usare C-h c per vedere la loro documentazione.

Emacs ha numerosi modi primari, ognuno dei quali ridefinisce alcune sequenze di caratteri ed induce alcuni cambiamenti nel comportamento. C-h m (describe-mode) mostra la documentazione relativa al modo primario attualmente in uso¹⁰ (che normalmente include una descrizione di tutti i comandi il cui comportamento viene modificato).

C-h b (describe-bindings) e C-h s presentano informazioni sullo stato di Emacs. C-h b mostra un elenco di tutte le associazioni tra sequenze di caratteri e comandi che sono attive al momento; vengono elencate per prime le associazioni locali definite dal modo secondario correntemente in uso, poi le associazioni locali definite dal modo primario e infine le associazioni globali (see Key Bindings). C-h s mostra invece il contenuto della tabella sintattica, con una spiegazione sulla sintassi di ogni carattere. (see Syntax).

È possibile ottenere un elenco di questo tipo per un particolare prefisso: è sufficiente digitare C-h dopo il prefisso. Esistono tuttavia alcuni prefissi con cui ciò non funziona--ovvero quelli che danno un significato particolare a C-h. Uno di questi è <ESC>, in quanto <ESC> C-h corrisponde di fatto a C-M-h, che seleziona la definizione di una funzione.

Le altre opzioni di C-h mostrano diversi file con informazioni utili. C-h C-w mostra i dettagli riguardanti l'assenza di garanzie su GNU Emacs. C-h n (view-emacs-news) mostra il file emacs/etc/NEWS che contiene informazioni ordinate cronologicamente sui cambiamenti apportati ad Emacs. C-h F (view-emacs-FAQ) mostra l'elenco delle FAQ di Emacs. C-h t (help-with-tutorial) avvia il tutorial di Emacs. C-h C-c (describe-copying) mostra il file emacs/etc/COPYING, che informa sulle condizioni di redistribuzione di Emacs. C-h C-d (describe-distribution) mostra il file emacs/etc/DISTRIB che informa sul come ordinare una copia dell'ultima versione di Emacs. C-h C-p (describe-project) mostra informazioni di carattere generale sul progetto GNU.

Il mark e le regioni

Molti comandi di Emacs operano su generiche aree contigue del buffer corrente. Per specificare l'area di testo su cui tali comandi devono operare è necessario impostare il mark ad un estremo della stessa, e poi spostare il point all'altro estremo. Il testo compreso tra il mark e il point è denominato regione. Se si abilita il modo Transient Mark, Emacs evidenzia la regione ogni volta che che ne viene definita una (see Transient Mark).

Il point e il mark possono essere spostati per ridefinire i confini di una regione. Non è importante quale dei due venga impostato per primo, o quale dei due preceda l'altro all'interno del testo: una volta impostato il mark in una determinata posizione, esso rimane in quella posizione fino a quando non lo si sposta da qualche altra parte. Ogni buffer di Emacs memorizza il proprio mark, cos`i da rendere possibile il posizionamento del mark nello stesso punto in cui si trovava quando si ritorna ad un buffer che in precedenza si era lasciato.

Molti comandi che inseriscono del testo, come C-y (yank) e M-x insert-buffer, posizionano il point e il mark agli opposti estremi del testo appena inserito, in modo che attorno ad esso sia definita una regione.

Oltre che per delimitare una regione, il mark è utile per fissare un punto al quale si vuole ritornare: per rendere più comoda questa funzionalità, ogni buffer memorizza nella lista dei mark impostati le ultime 16 posizioni assunte dal mark.

• Setting Mark: Commandi per impostare il mark.
• Transient Mark: Come fare in modo che Emacs evidenzi la regione-- quando ce n'è una.
• Using Region: Sommario dei modi di operare sul contenuto di una regione
• Marking Objects: Comandi per impostare la regione attorno a unità di testo
• Mark Ring: Le posizioni precedenti del mark sono memorizzate, in modo da poterci ritornare
• Global Mark Ring: Le posizioni precedenti del mark nei vari buffer

Impostare il mark

Ecco alcuni comandi per impostare il mark:

C-<Spazio>

Imposta il mark nel posizione ove si trova il point (set-mark-command).

C-@

Come sopra.

C-x C-x

Scambia tra loro le posizioni del mark e del point (exchange-point-and-mark).

Tasto sinistro del mouse

Imposta il point e il mark agli estremi del testo in cui si sta trascinando.

Tasto destro del mouse

Imposta il mark nella posizione in cui si trova il point, poi sposta il point nel punto ove viene fatto click con il tasto destro del mouse (mouse-save-then-kill).

Ad esempio, supponiamo che si voglia convertire in maiuscolo una parte del buffer mediante il comando C-x C-u (upcase-region), che opera sul testo nella regione. È possibile andare all'inizio del testo da trasformare, digitare C-<Spazio> per impostare il mark in quel punto, spostarsi alla fine e poi digitare C-x C-u. Oppure è possible impostare il mark alla fine del testo, spostarsi all'inizio e poi digitare C-x C-u.

Il modo più semplice di impostare il mark è quello di usare il comando C-<Spazio> (set-mark-command): esso imposta il mark nella posizione in cui si trova il point. In seguito è possibile spostare il point, lasciandosi cosi`i alle spalle il mark.

Esistono due modi di impostare il mark con il mouse: è possibile trascinare il puntatore del mouse (tenendo premuto il tasto sinistro) sopra un'area di di testo. Ciò provoca lo spostamento del point nel punto in cui si rilascia il pulsante del mouse e l'impostazione del mark all'altro estremo. Oppure è possibile usare il tasto destro del mouse, che imposta il mark nel punto in cui si trova il point (come C-<Spazio>) e poi sposta il point (come Mouse-1). Ambedue questi sistemi, oltre ad impostare il mark, copiano la regione negli appunti in modo da fornire un comportamento consistente con altre applicazioni grafiche. Se non si desidera modificare gli appunti, è necessario impostare il mark tramte i comandi da tastiera. See Mouse Commands.

I terminali, normalmente, hanno un solo cursore, pertanto Emacs non ha modo di mostrare la posizione del mark: occorre ricordarsela. La soluzione comune a questo problema consiste nell'impostare il mark e poi nell'usarlo subito, prima di dimenticarsi dove si trova. In alternativa, è possible vedere dove è posizionato il mark tramite il comando C-x C-x (exchange-point-and-mark), che scambia tra loro le posizioni del mark e del point, impostando il mark dove si trovava il point, e il point dove si trovava il mark. I confini della regione rimangono immutati, ma il cursore (e quindi il point) si trova dove prima stava il mark. Nel modo Transient Mark, questo comando riattiva il mark.

C-x C-x è inoltre utile quando il point è già posizionato correttamente e si vuole modificare la posizione del mark: basta usare C-x C-x per scambiare la posizione del point con quella del mark e poi spostare il point secondo necessità. Se necessario, C-x C-x usato una seconda volta imposta il mark alla nuova posizione e riporta il point alla sua posizione originaria.

Non esiste un carattere C-<Spazio> nella codifica ASCII: sulla maggior parte dei terminali esistenti, digitare <Spazio> tenendo premuto <CTRL> produce il carattere C-@. Questa sequenza è associata al comando set-mark-command. Fintantoché non si è cos`i sfortunati da avere un terminale ove C-<Spazio> non produce C-@, s può pensare a questo carattere esattamente come se fosse C-<Spazio>. Nell'X Window System, tuttavia, C-<Spazio> è un carattere distinto, ma esso viene ancora associato al comando set-mark-command.

Il modo Transient Mark

Emacs è in grado di evidenziare la regione corrente quando esso è in funzione all'interno dell'X Window System. Tuttavia, normalmente, ciò non viene fatto.

Il motivo risiede nel fatto che in Emacs evidenziare la regione non è molto funzionale, in quanto una volta impostato il mark in un buffer, esiste sempre una regione (in quel buffer), e evidenziare costantemente la regione sarebbe fastidioso.

È possibile abilitare l'evidenziazione della regione abilitando il modo Transient Mark: questa è una modalità di operare meno flessibile, in quanto la regione ha una "durata" temporanea, per cui diventa necessario definire una regione ogni volta che si fa uso di un comando che ne ha bisogno. Nel modo Transient Mark, per la maggior parte del tempo non vi è affatto una regione, per cui evidenziarla solo quando esiste è conveniente.

Per attivare il modo Transient Mark è sufficiente digitare il comando M-x transient-mark-mode. Questo comando attiva o disattiva il modo, pertanto è possibile ripeterlo per disattivarlo.

Ecco i dettagli relativi al modo Transient Mark:

• Per impostare il mark, digitare C-<Spazio> (set-mark-command): ciò rende attivo il mark. A mano a mano che si sposta il point si potrà veder cresere e restringersi la regione evidenziata.
• I comandi del mouse per specificare il mark rendono quest'ultimo attivo, e cos`i fanno pure i comandi da tastiera che specificano una regione, inclusi M-@, C-M-@, M-h, C-M-h, C-x C-p e C-x h.
• Quando il mark è attivo è possibile eseguire comandi che operano su una regione (come quelli che la copiano, ne calcolano i rientri o la scrivono su di un file).
• Ogni modifica apportata al buffer (come l'inserimento o la cancellazione di un carattere) disattiva il mark. Ciò significa che qualunque comando operante su una regione digitato successivamente provocherà un errore e si rifiuterà di procedere. È possibile riattivare nuovamente la regione digitando C-x C-x.
• Comandi come M-> e C-s (che oltre ad effettuare altre operazioni "si lasciano dietro un mark") non attivano il nuovo mark. È possibile attivare la nuova regione digitando C-x C-x (exchange-point-and-mark).
• Quando il mark è attivo, C-s non lo altera.
• Annullare un'operazione con C-g provoca la disattivazione del mark.

La regione viene evidenziata facendo uso dello stile region: è possible personalizzare il modo con cui essa è evidenziata modificando questo stile. See Face Customization.

Quando lo stesso buffer è visualizzato da più finestre, esse possono avere regioni differenti in quanto ogni finestra può avere una posizione del point diversa (sebbene tutte condividano una sola posizione del mark). Normalmente, solo la finestra selezionata evidenzia la propria regione (see Windows), tuttavia se la variabile highlight-nonselected-windows ha un valore diveso da nil ogni finestra evidenzia la propria regione (posto che sia in uso il modo Transient Mark e che il mark del buffer visualizzato nella finestra sia attivo).

Quando il modo Transient Mark non è in uso, ogni comando che imposta il mark attiva anche quest'ultimo e nulla più lo disattiva.

Se nel modo Transient Mark la variabile mark-even-if-inactive ha un valore diverso da nil, i comandi possono usare il mark e la regione anche quando il mark non è attivo. L'evidenziazione della regione appare e scompare come avviene normalmente nel modo Transient Mark, con l'eccezione che il mark non viene dimenticato quando l'evidenziazione della regione scompare.

Talvolta ci si riferisce al modo Transient Mark anche come "modo Zmacs", in quando l'editor Zmacs sulla macchina Lisp del MIT gestiva il mark in un modo similare.

Usare le regioni

Ecco un elenco di alcune delle operazioni applicabili ad una regione quando essa è definita ed il mark è attivo:

• "Tagliare" il testo di una regione con C-w (see Killing).
• Memorizzare la regione in un registro con C-x r s (see Registers).
• Memorizzare la regione in un buffer o in un file (see Accumulating Text).
• Cambiare le maiuscole in minuscole con C-x C-l e viceversa con C-x C-u (see Case).
• Calcolare i rientri di una regione con C-x <TAB> o C-M-\ (see Indentation).
• Giustificare il testo con M-x fill-region (see Filling).
• Stampare il contenuto della regione con M-x print-region (see Hardcopy).
• Valutare il contenuto della regione (eseguirla) come codice Lisp con M-x eval-region (see Lisp Eval).

La maggior parte dei comandi che operano sul testo di una regione contengono la parola region nel loro nome.

Comandi per selezionare oggetti testuali

Ecco un elenco di comandi per definire una regione attorno a oggetti testuali come parole, elenchi, paragrafi o pagine:

M-@

Imposta il mark immediatamente dopo la fine della parola seguente (mark-word). Questo comando non sposta il point.

C-M-@

Imposta il mark immediatamente dopo fine dell'espressione Lisp che segue (mark-sexp).

M-h

Imposta la regione attorno al paragrafo corrente. (mark-paragraph).

C-M-h

Imposta la regione intorno alla definizione della funzione Lisp corrente. (mark-defun).

C-x h

Imposta l'intero buffer come regione (mark-whole-buffer).

C-x C-p

Imposta l'intera pagina corrente come regione (mark-page).

M-@ (mark-word) imposta il mark di seguto alla parola su cui si trova il point (o che lo segue). C-M-@ (mark-sexp) fa lo stesso, ma con un'intera espressione Lisp. Questi comandi gestiscono gli argomenti esattamente come M-f e C-M-f.

Gli altri comandi impostano il point e il mark in modo da delimitare un oggetto nel buffer. Ad esempio, M-h (mark-paragraph) sposta il point all'inizio del paragrafo in cui si trova il point (o che lo segue, se il point non è in un paragrafo) e imposta il mark alla fine dello stesso (see Paragraphs): questo comando prepara una regione in modo da intervenire su un intero paragrafo.

Similarmente, C-M-h (mark-defun) imposta il point e il mark in modo da delimitare la definizione di una funzione (see Defuns). C-x C-p (mark-page) sposta il point all'inizio della pagina e imposta il mark alla fine (see Pages): il mark viene impostato di seguito al delimitatore di fine pagina (per includerlo), mentre il point viene spostato subito dopo il delimitatore di fine pagina della pagina precedente (per escluderlo). Un argomento numerico specifica una pagina successiva (se positivo) o una pagina precedente (se negativo) al posto della pagina corrente.

Infine, C-x h (mark-whole-buffer) imposta l'intero buffer come regione, impostando il point all'inizio ed il mark alla fine.

Quando il modo Transient Mark è in uso, ognuno dei comandi suddetti attiva il mark.

La lista dei mark impostati

Oltre che per delimitare una regione, il mark è utile per ricordarsi un punto nel testo a cui si vuole ritornare. Per rendere più comoda questa funzionalità, ogni buffer memorizza nella lista dei mark impostati le ultime 16 posizioni del mark. I comandi che impostano il mark, tra le altre cose, aggiungono a questa lista la posizione precedente del mark. Per ritornare ad una posizione memorizzata si può usare C-u C-<Spazio> (o C-u C-@); ciò corrisponde al comando set-mark-command con un argomento numerico. Esso sposta il point nella posizione in cui si trovava il mark e poi ripristina il mark dalla lista dei mark precedentemente impostati. L'uso ripetuto di questo comando, pertanto, sposta il point attraverso tutte le vecchie posizioni del mark, una per una. Le posizioni attraverso cui ci si muove non vengono dimenticate: esse sono semplicmente spostate in fondo alla lista.

Ogni buffer ha la propria lista dei mark impostati: tutti i comandi che operano sulle regioni usano la lista appartenente al buffer in cui vengono eseguiti. In particolare, C-u C-<Spazio> non provoca la selezione di buffer diversi da quello in correntemente in uso.

Molti comandi che spostano il point per lunghe distanze, come M-< (beginning-of-buffer), impostano il mark nella posizione in cui si trova il point e poi memorizzano la vecchia posizione del mark nella lista dei mark impostati: ciò viene fatto per agevolare un eventuale ritorno a quel punto. Da notare che quando le ricerche provocano lo spostamento del point, esse impostano il mark. Un comando che imposta il mark è riconoscibile in quanto mostra Mark Set nell'area messaggi.

Se tuttavia si vuole ritornare nello stesso punto per più volte, il mark può non risultare lo strumento più pratico: in questo caso è possibile memorizzare la posizione in un registro per poi poterla ripristinare in seguito (see RegPos).

La variabile mark-ring-max specifica il numero massimo di posizioni da memorizzare nella lista dei mark impostati. Se si raggiunge tale limite e viene aggiunta un'altra posizione, la posizione più vecchia viene dimenticata. L'uso ripetuto di C-u C-<Spazio> permette di ciclare attraverso tutte le posizioni memorizzate nella lista.

La variabile mark-ring contiene la lista dei mark impostati, partendo dal più recente. Questa variabile è locale al buffer.

La lista globale dei mark impostati.

Oltre alla lista locale ad ogni buffer, Emacs mantiene una lista globale dei mark impostati: essa memorizza una sequenza di buffer in cui si è impostato recentemente il mark, così da potervi ritornare.

L'impostazione del mark provoca sempre l'aggiunta di un elemento alla lista dei mark impostati specifica per ogni buffer: se si è cambiato buffer dall'ultima volta che si è impostato il mark, tale elemento viene aggiunto anche alla lista globale. Il risultato è quello di avere una lista globale che contiene una sequenza di buffer selezionati, e, per ogni buffer, una posizione in cui si è impostato il mark.

Il comando C-x C-<Spazio> (pop-global-mark) fa andare al buffer e alla posizione specificate dalla voce più recente nella lista globale dei mark impostati. Esso inoltre ruota la lista, in modo che l'uso ripetuto di C-x C-<Spazio> sposti a posizioni via via precedenti.

Cancellare e tagliare

La maggior parte dei comandi di cancellazione memorizza il testo nella lista degli appunti, cos`i da poterlo spostare o incollare in altre parti del buffer. Questi comandi sono indicati come comandi che tagliano del testo. I rimanenti comandi di cancellazione sono indicati invece come comandi che eliminano del testo, in quanto essi non lo memorizzano nella lista degli appunti (questa distinzione viene fatta solo per la cancellazione di testo nel buffer). Se si elimina o si taglia del testo per errore, è sempre possibile tornare sui propri passi tramite il comando C-x u (undo). (see Undo).

Tra i comandi che eliminano del testo si trovano C-d (delete-char) e <DEL> (delete-backward-char): essi eliminano un carattere alla volta. Oltre a questi due, vi sono tutti i comandi che eliminano esclusivamente spazi e caratteri di ritorno a capo. Generalmente, i comandi che possono cancellare quantità significative di dati significativi sono comandi che tagliano il testo. I nomi e le descrizioni dei comandi contengono le parole kill (taglia) e delete (elimina) per specificare il loro comportamento al riguardo.

• Deletion: Comandi per cancellare piccole quantità di testo e aree vuote.
• Killing by Lines: Come tagliare intere linee di testo.
• Other Kill Commands: Comandi per tagliare regioni vaste di testo e di unità sintattiche quali parole e frasi.

Eliminare testo

C-d

Elimina il carattere successivo (delete-char).

<DEL>

Elimina il carattere precedente (delete-backward-char).

M-\

Elimina gli spazi e i tab attorno al point (delete-horizontal-space).

M-<Spazio>

Elimina gli spazi e i tab attorno al point, lasciando un solo spazio (just-one-space).

C-x C-o

Elimina linee vuote attorno alla linea corrente (delete-blank-lines).

M-^

Unisce due linee, eliminando il carattere di ritorno a capo e gli eventuali rientri che dovessero seguire quest'ultimo (delete-indentation).

I più semplici comandi di eliminazione di testo sono C-d (delete-char) e <DEL> (delete-backward-char). C-d elimina il carattere che si trova subito dopo il point, ovvero quello su cui si trova il cursore. Questo comando non sposta il point. <DEL> elimina invece il carattere che precede il point, spostando il point all'indietro. È possibile eliminare i caratteri di ritorno a capo nello stesso modi in cui si elimina ogni altro carattere: eliminando un ritorno a capo si uniscono due linee. A dire il vero, C-d e <DEL> non sempre eliminano il testo: se usati con un argomento numerico come prefisso, essi tagliano il testo (in quanto possono cancellare ben più di un singolo carattere).

Gli altri comandi che eliminano il testo sono quelli che eliminano esclusivamente spazi bianchi: spazi, tabulazioni e i caratteri di ritorno a capo. M-\ (delete-horizontal-space) elimina tutti gli spazi e i caratteri di tabulazione che stanno attorno al point. M-<Spazio> (just-one-space) agisce in maniera simile, inserendo però uno spazio di seguito al point indipendentemente dal numero di spazi preesistenti (anche nessuno).

C-x C-o (delete-blank-lines) elimina tutte le linee vuote che seguono la linea corrente. Se la linea corrente è vuota, vengono eliminate anche eventuali linee vuote che la precedono, lasciandone solo una (la linea corrente).

M-^ (delete-indentation) unisce la linea corrente alla linea che la precede, eliminando il carattere di ritorno a capo e tutti gli spazi bianchi attigui a quest'ultimo, solitamente lasciando un solo spazio See M-^.

Tagliare linee

C-k

Taglia il resto della linea, oppure una o più linee (kill-line).

Il più semplice comando per tagliare è C-k. Digitandolo all'inizio di una linea di testo, esso taglia tutta la linea, lasciandola vuota. Se usato su una linea vuota, esso taglia l'intera linea, incluso il ritorno a capo. Per tagliare un'intera linea contenente del testo basta andare all'inizio della stessa e digitare C-k due volte.

Più generalmente, C-k taglia quanto si trova tra il point e la fine della linea, a meno che non ci si trovi già alla fine della linea. In quest'ultimo caso, C-k taglia il carattere di ritorno a capo, unendo la linea corrente con quella che segue. Nel decidere quale di queste due regole deve essere applicata, gli spazi e i tab alla fine della linea vengono ignorati, pertanto se il point sembra essere alla fine della linea si può essere certi che C-k tagli il ritorno a capo.

Quando a C-k viene passato un argomento numerico positivo come prefisso, esso taglia il numero specificato di linee e ritorni a capo che seguono il point (tuttavia, il testo sulla linea corrente che precede il point non viene considerato). Con un argomento negativo -n, C-k taglia le n linee che precedono la linea corrente (insieme al testo che precede il point sulla linea corrente). Ad esempio, digitando C-u - 2 C-k all'inizio di una linea si tagliano le due linee precedenti.

C-k con un argomento numerico pari a zero taglia il testo che si trova prima del point sulla linea corrente.

Se la variabile kill-whole-line ha un valore diverso da nil, digitando C-k all'inizio di una linea si taglia l'intera linea e anche il ritorno a capo. Solitamente, questa variabile ha un valore pari a nil.

Altri comandi che tagliano

C-w

Taglia la regione (dal point al mark) (kill-region).

M-d

Taglia una parola (kill-word). See Words.

M-<DEL>

Taglia una parola, ma all'indietro (backward-kill-word).

C-x <DEL>

Taglia fino all'inizio della frase (backward-kill-sentence). See Sentences.

M-k

Taglia fino alla fine della frase (kill-sentence).

C-M-k

Taglia un'intera espressione Lisp (kill-sexp). See Lists.

M-z char

Taglia il testo fino al prossimo carattere char (zap-to-char).

Un comando generale per tagliare del testo è C-w (kill-region), che taglia tutto quanto si trova tra il point e il mark. Con questo comando è possible tagliare una qualsiasi sequenza di caratteri contigui, posto che prima si sia definita una regione attorno ad essi.

Un modo comodo di tagliare del testo consiste nel combinare l'operazione di taglio con una funzione di ricerca: M-z (zap-to-char) dapprima richiede l'immissione di un carattere, poi taglia il testo che si trova tra il point e il primo carattere uguale a quello specificato (compreso). Un argomento numerico agisce come contatore per le ripetizioni. Un argomento negativo provoca la ricerca all'indietro, e di conseguenza il taglio del testo che si trova prima del point.

Oltre a quelle appena elencate, si possono tagliare anche altre unità sintattiche: si possono tagliare singole parole con M-<DEL> e M-d (see Words), intere espressioni Lisp con C-M-k (see Lists) e intere frasi con C-x <DEL> e M-k (see Sentences).

È possible tagliare del testo anche in buffer a sola lettura. I comandi di taglio, in questo caso, non modificano il buffer ed emettono un beep per avvertire del fatto. Essi tuttavia copiano il testo che si è tentato di tagliare, cos`i da poterlo incollare in altri buffer. La maggior parte dei comandi che tagliano del testo spostano il point attraverso il testo copiato, in modo che più comandi consecutivi di taglio producano un unico elemento nella lista degli appunti.

Incollare

Incollare significa inserire il testo che precedentemente era stato tagliato. Il modo comune per spostare del testo (o di copiarlo) è quello di tagliarlo e poi incollarlo da qualche altra parte uno o più volte.

C-y

Incolla l'ultimo testo tagliato (yank).

M-y

Sostituisce il testo appena incollato con del testo tagliato via via in precedenza (yank-pop).

M-w

Copia la regione (kill-ring-save).

C-M-w

Fa in modo che il prossimo testo tagliato o copiato venga unito negli appunti all'ultimo testo tagliato o copiato. (append-next-kill).

• Kill Ring: Il luogo ove è memorizzato il testo tagliato o copiato. Come incollare.
• Appending Kills: Diverse operazioni di taglio in fatte in una sola riga vengono incollate tutte insieme.
• Earlier Kills: Incollare qualcosa che era stato tagliato o molto tempo prima.

La lista degli appunti

Tutto il testo tagliato o copiato viene memorizzato nella lista degli appunti, una lista di blocchi di testo ritagliato. Esiste una sola lista degli appunti condivisa da tutti i buffer, cos`i da poter tagliare del testo in un buffer e copiarlo in un altro buffer. Questo è il metodo comunemente usato per spostare del testo da un file all'altro (See Accumulating Text per una descrizione di altri metodi).

Il comando C-y (yank) inserisce nel buffer il testo più recentemente tagliato: esso posiziona il point alla fine del testo e imposta il mark ll'inizio. See Mark.

C-u C-y posiziona invece il point all'inizio del testo e imposta il mark alla fine. Ciò avviene unicamente se l'argomento viene specificato con un semplice C-u senza nient'altro. Ogni altro argomento, inclusi un altro C-u o qualsiasi numero n, specifica l'ennesimo testo tagliato in precedenza (see Earlier Kills).

Per copiare un blocco di testo è possibile usare M-w (kill-ring-save), che copia la regione nella lista degli appunti senza rimuoverla dal buffer. Ciò equivale più o meno a digitare C-w seguito da C-x u, tranne che M-w non altera la lista delle modifiche e non modifica lo schermo.

Concatenare le operazioni di taglio

Di norma, ogni operazione di taglio inserisce nella lista degli appunti un nuovo elemento distinto dagli altri. Tuttavia, due o più operazioni di taglio effettuate sulla stessa riga vengono combinate in un elemento solo, in modo che un C-y incolli tutto come un unico blocco, proprio com'era prima che venisse tagliato.

In questo modo non è necessario tagliare un blocco di testo con un unico comando se si vuole poi incollarlo con un'unica operazione: è possibile tagliarlo progressivamente linea per linea (o parola per parola) e infine incollare il tutto con un solo comando.

I comandi che tagliano il testo che segue il point accodano tale testo di seguito a quanto tagliato in precedenza. I comandi che tagliano il testo che precede il point, invece, inseriscono quest'ultimo davanti al testo tagliato in precedenza. In questo modo, ogni sequenza di operazioni di taglio in avanti e all'indietro produce un blocco unico, in cui l'ordine viene mantenuto. Un eventuale argomento numerico non interrompe la sequenza di operazioni di taglio concatenate. Ad esempio, supponiamo che il buffer contenga quanto segue:

Questa è una linea -!-contenente del testo di esempio.

con la posizione del point indicata da -!-. Se si digita M-d M-<DEL> M-d M-<DEL>, tagliando quindi alternativamente in avanti e all'indietro, si ottiene nella lista degli appunti un unico blocco costituito da contenente del testo di, mentre a video rimane Questa è una linea esempio. (notare il doppio spazio, che si può eliminare con M-<Spazio> o M-q).

Un altro modo di tagliare lo stesso testo consiste nel muoversi indietro di due parole con M-b M-b e poi di tagliare tutte e quattro le parole che seguono con C-u M-d: ciò produce il medesimo risultato sia per quanto riguarda il buffer che per quanto riguarda la lista degli appunti. Il testo del blocco ritagliato mantiene l'ordine che aveva nel buffer prima che venisse ritagliato.

Se un comando di taglio è separato dall'ultimo comando di taglio da altri comandi (non semplici argomenti numerici), esso produce un nuovo blocco di testo nella lista degli appunti. Tuttavia, è possibile forzare la concatenazione digitando subito prima il comando C-M-w (append-next-kill). C-M-w fa in modo che il comando di taglio immediatamente successivo accodi il testo all'ultimo blocco di testo tagliato invece di produrre un nuovo blocco. Con C-M-w è quindi possibile tagliare diverse porzioni di testo, separate tra loro, e concatenarle nella lista degli appunti in modo da poterle incollare con un solo comando.

Un comando di taglio digitato dopo M-w non unisce automaticamente il testo a quello tagliato da M-w (occorre usare C-M-w).

Incollare testo tagliato in precedenza

Per recuperare un blocco di testo tagliato che non sia l'ultimo si può usare il comando M-y (yank-pop). Esso sostituisce il testo appena incollato con un blocco di testo tagliato via via in precedenza. Ad esempio, per incollare il penultimo blocco di testo tagliato si usa C-y per incollare l'ultimo blocco e poi M-y per sostituirlo con il penultimo. M-y funziona solo dopo aver incollato del testo con C-y, o dopo un altro M-y.

Può risutare più semplice pensare a M-y come a un puntatore al blocco da incollare contenuto nella lista degli appunti. Ogni volta che si taglia del testo, tale puntatore viene impostato in modo da indicare il blocco di testo appena aggiunto alla lista degli appunti. C-y incolla il blocco di testo indicato da tale puntatore, mentre M-y sposta tale puntatore in modo da indicare un blocco di testo diverso e il testo nel buffer viene cambiato di conseguenza. L'uso ripetuto di M-y sposta il puntatore attraverso tutti i blocchi contenuti nella lista degli appunti, cos`i da poter avere accesso a qualunque blocco. Se il puntatore raggiunge la fine della lista degli appunti, un altro M-x lo sposta nuovamente all'inizio.

M-y sposta il puntatore per tutta la lista degli appunti, ma esso non altera l'ordine dei blocchi di testo contenuti nella lista, la quale inizia sempre con il blocco più recente e termina con quello più vecchio tra quelli memorizzati.

A M-y si può passare un argomento numerico, che indica di quanti blocchi il puntatore deve essere spostato. Un argomento negativo sposta il puntatore verso l'inizio della lista. Oltrepassando l'inizio si prosegue circolarmente partendo dal fondo.

Una volta che il testo desiderato appare nel buffer, è possible smettere di usare M-y. Il testo nel buffer è solo una copia di quello contenuto nella lista degli appunti, per cui una modifica al buffer non modifica il blocco contenuto negli appunti. Fino a quando non viene eseguita un'altra operazione di taglio, il puntatore al blocco da incollare rimane invariato, per cui un successivo C-y incolla lo stesso testo.

Se si è già a conoscenza del numero di M-y che si devono digitare, è possible incollare direttamente il testo usando C-y con un argomento numerico. C-y con un argomento numerico incolla un blocco di testo antecedente all'ultimo tagliato. Pertanto, C-u 2 C-y incolla il penultimo blocco di testo, ed è equivalente a C-y M-y. C-y con un argomento numerico enumera i blocchi partendo dal puntatore al testo da incollare e imposta quest'ultimo al blocco che esso incolla.

La lunghezza della lista degli appunti é controllata dalla variabile kill-ring-max, che indica il numero massimo di blocchi memorizzabili.

Il contenuto della lista degli appunti è memorizzato in una variabile chiamata kill-ring. È possibile vederne il contenuto tramite il comando C-h v kill-ring.

Accumulare testo

Di solito si copia o si sposta del testo tagliandolo e poi incollando, ma esistono altri metodi per ricopiare un blocco di testo in punti diversi, o per copiare in una volta sola diversi blocchi. Per copiare un blocco in piu` posizioni è possible memorizzarlo in un registro (see Registers). Qui di seguito sono descritti i comandi per accumulare diversi blocchi discontinui di testo in un buffer o in un file.

M-x append-to-buffer

Aggiunge la regione al contenuto del buffer specificato.

M-x prepend-to-buffer

Inserisce la regione all'inizio del buffer specificato.

M-x copy-to-buffer

Copia la regione nel buffer specificato, cancellando il vecchio contenuto del buffer.

M-x insert-buffer

Inserisce il contenuto del buffer specificato nel buffer corrente, a partire dalla posizione in cui si trova il point.

M-x append-to-file

Aggiunge la regione alla fine del file specificato.

Per accumulare del testo in un buffer si può usare M-x append-to-buffer. Questo comando richiede l'immissione del nome di un buffer, e poi inserisce una copia della regione nel buffer specificato. Se si specifica un buffer non esistente, append-to-buffer crea il buffer. Il testo viene inserito nella posizione in cui si trova il point nel buffer specficato: se il point si trova in mezzo al buffer specificato, il testo verrà inserito nel mezzo del buffer.

Il point nel buffer di destinazione viene poi spostato al termine del testo inserito, in modo che usi successivi di append-to-buffer accumulino il testo nello stesso ordine in cui viene copiato. Strettamente parlando, append-to-buffer non sempre aggiunge il testo in fondo al buffer--lo aggiunge in fondo solo se il point si trova in fondo. Comunque, se si usa il solo comando append-to-buffer per modificare un buffer, il point in quel buffer si troverà sempre alla fine.

M-x prepend-to-buffer è simile a append-to-buffer, tranne nel fatto che il point nel buffer di destinazione è impostato all'inizio del testo copiato, pertanto l'uso ripetuto di M-x prepend-to-buffer aggiunge il testo ma in ordine inverso. M-x copy-to-buffer è ancora simile, tranne che tutto il testo precedentemente esistente nel buffer di destinaione viene cancellato, in modo che esso contenga solo il testo copiato.

Per recuperare il testo accumulato in un altro buffer è possibile usare il comando M-x insert-buffer. Anche questo comando richiede come argomento il nome di un buffer. Esso inserisce una copia del contenuto del buffer specificato nel buffer correntemente selezionato. In alternativa, è possibile selezionare il buffer da cui copiare il testo, tagliare il testo voluto e poi incollarlo. See Buffer per maggiori informazioni sui buffer.

Invece di accumulare testo in un buffer di Emacs, è possible aggiungere direttamente lo stesso al termine di un file con il comando M-x append-to-file, che richiede come argomento il nome di un file. Tale comando aggiunge la regione al termine del file specificato, ed il file viene subito aggiornato sul disco.

Sarebbe meglio usare append-to-file solo con file che non siano al momento aperti da Emacs. Usarlo con un file aperto produrrebbe una modifica nel file che non verrebbe riproposta nel buffer relativo, e ciò potrebbe causare una perdita di dati.

Rettangoli

I comandi qui descritti operano su porzioni rettangolari di testo, ovvero tutti i caratteri compresi tra due colonne, in un certo intervallo di linee. Vengono forniti comandi per tagliare rettangoli, incollare rettangoli tagliati, eliminare rettangoli, o riempirli con spazi o con del testo. Tali comandi sono utili per testi impaginati su più colonne, o per convertire del testo su più colonne in testo su una sola colonna e viceversa.

Per specificare un rettangolo di testo si imposta il mark in uno dei vertici e si imposta il point nel vertice opposto. Il rettangolo cos`i delimitato viene chiamato regione rettangolare, in quanto esso viene controllato più o meno allo stesso modo di una regione. Tuttavia occorre ricordare che una data combinazione di posizioni del point e del mark può essere sia interpretata come regione che come rettangolo, a seconda dei comandi che l'andranno a usare.

Se il point e il mark si trovano sulla stessa colonna, essi delimitano un rettangolo vuoto. Se si trovano sulla stessa linea, essi delimitano un rettangolo di una riga. Questa asimmetria tra linee e colonne deriva dal fatto che il point (e quindi anche il mark) si trova tra due colonne, ma in una linea determinata.

C-x r k

Taglia il testo della regione rettangolare, memorizzandolo come l'ultimo rettangolo tagliato (kill-rectangle).

C-x r d

Elimina il testo della regione rettangolare (delete-rectangle).

C-x r y

Incolla l'ultimo rettangolo tagliato, usando il point come angolo superiore sinistro (yank-rectangle).

C-x r o

Inserisce degli spazi nella regione rettangolare specificata (open-rectangle), spostando a destra il contenuto precedente del rettangolo.

M-x clear-rectangle

Cancella la regione rettangolare sostituendo il suo contenuto con degli spazi.

M-x delete-whitespace-rectangle

Elimina gli spazi da ognuna delle linee del rettangolo specificato, partendo dalla colonna che si trova in prossimità del margine sinistro del rettangolo.

C-x r t <Invio> stringai <RET>

Inserisce stringa su ciascuna linea della regione rettangolare (string-rectangle).

I comandi che operano con rettangoli si dividono in due categorie: comandi che eliminano o inseriscono rettangoli e comandi che svuotano rettangoli.

Esistono due modi per liberarsi del testo in un rettangolo: è possible cancellarlo (eliminarlo) o tagliarlo. I comandi relativi a queste due operazioni sono rispettivamente C-x r d (delete-rectangle) e C-x r k (kill-rectangle). In entrambi i casi, la porzione di linea che sta nei confini del rettangolo viene cancellata, provocando lo spostamento a sinistra dell'eventuale testo che segue.

È da notare che ritagliare un rettangolo non è un'operazione di taglio nel senso consueto del termine: il rettangolo non viene memorizzato nella lista degli appunti, ma viene memorizzato in un luogo particolare che mantiene solo l'ultimo rettangolo tagliato. Ciò avviene in quanto incollare un rettangolo è un'operazione cos`i differente dall'incollare del normale testo da richiedere l'uso di comandi specifici, e una lista degli appunti contenente rettangoli non avrebbe molto senso.

Per incollare il rettangolo tagliato in precedenza basta digitare C-x r y (yank-rectangle). Incollare un rettangolo è l'operazione opposta a quello di ritagliarlo. Il point indica il punto ove situare l'angolo superiore sinistro del rettangolo. La prima linea del rettangolo viene inserita in quel punto, la seconda linea viene inserita una posizione più in basso (nella linea successiva) e cos`i via. Il numero di linee coinvolte è determinato dal numero di linee che compongono il rettangolo ritagliato.

È possible convertire una lista su una colonna in una lista a due colonne tagliando e incollando rettangoli: basta tagliare la seconda metà della lista come rettangolo, e poi incollarla a fianco della prima linea della lista. See Two-Column per altri modi di operare su testi multicolonna.

È inoltre possible copiare rettangoli da e verso registri con C-x r r r e C-x r i r. See Rectangle Registers.

Esistono due comandi che si possono usare per svuotare un rettangolo: M-x clear-rectangle che svuota il testo esistente, e C-x r o (open-rectangle) che inserisce un rettangolo vuoto. Svuotare un rettangolo equivale a cancellarlo e poi ad inserire al suo posto un rettangolo vuoto della stessa grandezza.

Il comando M-x delete-whitespace-rectangle elimina gli spazi orizzontali a partire da una determinata colonna. Ciò avviene per ogni linea che compone il rettangolo, e la colonna di partenza viene specificata dal lato sinistro del rettangolo. Il lato destro del rettangolo non viene considerato da questo comando.

Il comando C-x r t (M-x string-rectangle) sostituisce il testo nel rettangolo con una stringa specificata (inserita una sola volta in ogni linea). La lunghezza della stringa non deve necessariamenta coincidere con la larghezza del rettangolo. Se la stringa è più corta, il testo che segue il rettangolo viene spostato a sinistra. Se la stringa è più lunga il testo che segue il rettangolo viene spostato a destra.

Registri

I registri di Emacs sono contenitori ove può essere memorizzato del testo, o delle posizioni, in modo da poterle usare in seguito. Una volta che si è memorizzato del testo (o un rettangolo) in un registro, è possible incollarlo nel buffer tutte le volte che lo si desidera. Nello stesso modo è possible spostare il point in una posizione memorizzata in un registro.

Ogni registro ha un nome costituito da un solo carattere. Un registro può contenere del testo, un rettangolo, una posizione, una configurazione di finestre o il nome di un file. In ogni caso, un dato registro può contenre una sola cosa alla volta. Tutto ciò che viene memorizzato in un registro rimane inalterato fino a quando non si memorizza qualcos'altro nello stesso registro. Per vedere il contenuto di un registro si può usare il comando M-x view-register.

M-x view-register <Invio> r

Mostra una descrizione del contenuto del registro r.

• Position: Memorizzare in un registro una posizione.
• Text: Memorizzare del testo in un registro.
• Rectangle: Memorizzare un rettangolo in un registro.
• Configurations: Memorizzare la configurazione delle finestre in un registro.
• Files: Nomi di file nei registri.
• Numbers: Numeri nei registri.
• Bookmarks: I segnalibri sono come i registri, ma sono permanenti.

Memorizzare una posizione in un registro

Memorizzare una posizione consiste nel memorizzare un punto preciso in un determinato buffer, in modo da poterci ritornare in seguito. Saltare ad una posizione memorizzata significa tornare al buffer relativo e spostare il point nella posizione memorizzata.

C-x r <Spazio> r

Memorizza la posizione del point nel registro r (point-to-register).

C-x r j r

Salta alla posizione memorizzata nel registro r (jump-to-register).

Per memorizzare la posizione corrente del point in un registro basta scegliere un nome r e digitare C-x r <Spazio> r. Il registro r mantiene la posizione memorizzata fino a quando non si memorizza qualcosa d'altro nello stesso registro.

Il comando C-x r j r sposta il point alla posizione memorizzata nel registro r. Il registro non viene alterato: esso continua a contenere la stessa posizione. È possibile saltare alla posizione memorizzata tutte le volte che lo si desidera.

Se si usa C-x r j per saltare ad una posizione memorizzata, ma il buffer relativo è stato eliminato, C-x r j tenta di ricreare il buffer aprendo nuovamente lo stesso file. Naturalmente, ciò è valido solo per buffer che visualizzavano il contenuto di un file.

Memorizzare del testo in un registro

Quando si vuole incollare più volte del testo ritagliato, la lista degli appunti può risultare scomoda, in quando ogni operazione di taglio successiva sposta il testo da incollare di una posizione all'interno della lista. Un'alternativa consiste nel memorizzare il testo in un registro per poi recuperarlo in seguito.

C-x r s r

Copia la regione nel registro r (copy-to-register).

C-x r i r

Incolla il testo contenuto nel registro r (insert-register).

C-x r s r memorizza una copia della regione nel registro r. Con un arcomento numerico, C-x r s r cancella inoltre il testo dal buffer.

C-x r i r inserisce nel buffer il testo contenuto nel registro r. Di norma, esso sposta il point all'inizio del testo inserito e posiziona il mark alla fine, ma, se invocato con un argomento numerico come prefisso, esso sposta il point alla fine e posiziona il mark all'inizio.

Memorizzare un rettangolo in un registro

Oltre che semplice testo, un registro può contenere un rettangolo. Il rettangolo viene rappresentato come una lista di stringhe. See Rectangles per informazioni sul come specificare un rettangolo nel buffer.

C-x r r r

Copia la regione rettangolare nel registro r. (copy-rectangle-to-register). Con un argomento numerico, elimina inoltre il rettangolo dal buffer.

C-x r i r

Incolla il rettangolo memorizzato nel registro r (purché contenga un rettangolo) (insert-register).

C-x r i r inserisce del testo se il registro contiene del testo, oppure un rettangolo se il registro contiene un rettangolo.

Può essere utile anche il comando sort-columns, che può essere visto come il modo di ordinare un rettangolo. See Sorting.

Memorizzare la configurazione delle finestre

È possible memorizzare in un registro la configurazione del frame selezionato, o addirittura la configurazione di tutte le finestre di tutti i frame, per poi ripristinarla in seguito.

C-x r w r

Memorizza nel registro r lo stato delle finestre del frame selezionato (window-configuration-to-register).

C-x r f r

Memorizza nel registro r lo stato di tutti i frame, incluse le loro finestre (frame-configuration-to-register).

Per ripristinare la configurazione dei frame o delle finestre si usa il comando C-x r j r, che è lo stesso usato per saltare ad una posizione in un buffer. Quando si ripristina la configurazione dei frame, ogni frame esistente che non sia incluso nella configurazione da ripristinare diventa invisibile. Se invece si vuole eliminare tali frame, basta usare C-u C-x r j r.

Memorizzare numeri in un registro.

Esistono comandi per memorizzare in un regstro un numero, per recuperare il numero e inserirlo nel buffer in notazione decimale e per incrementarlo. Questi comandi possono essere utili se usati in combinazione con le macro da tastiera (see Keyboard Macros).

C-u numero C-x r n reg

Memorizza numero nel registro reg (number-to-register).

C-u numero C-x r + reg

Incrementa di numero il numero contenuto nel registro reg (increment-register).

C-x r g reg

Inserisce nel buffer il numero contenuto nel registro reg.

C-x r g è lo stesso comando usato per inserire nel buffer qualsiasi altro tipo di contenuto del registro.

Memorizzare nomi di file in un registro

Se si aprono di frequente determinati file, è possibile aprirli più rapidamente se si memorizza il loro nome in un registro. Ecco il codice Lisp usato per memorizzare il nome di un file in un registro:

(set-register ?r '(file . nome))

Ad esempio:

(set-register ?z '(file . "/gd/gnu/emacs/19.0/src/ChangeLog"))

memorizza nel registro z il nome del file indicato.

Per aprire il file il cui nome si trova nel registro r basta digitare C-x r j r (questo è sempre lo stesso comando usato per saltare ad una posizione o ripristinare una configurazione di finestre o di frame).

Bookmarks

I Bookmarks (segnalibri) sono simili per certi versi ai registri, nel senso che essi memorizzano posizioni a cui si può tornare in seguito. A differenza dei registri, tuttavia, essi hanno nomi estesi e sono salvati tra una sessione di Emacs e l'altra. Il tipico uso dei bookmark consiste nel memorizzare "il punto a cui si è arrivati" di diversi file.

C-x r m <Invio>

Imposta un bookmark alla posizione in cui si trova il point per il file correntemente aperto.

C-x r m bookmark <Invio>

Imposta il bookmark chiamato bookmark alla posizione in cui si trova il point (bookmark-set).

C-x r b bookmark <Invio>

Salta al bookmark chiamato bookmark (bookmark-jump).

C-x r l

Visualizza la lista di tutti i bookmark (list-bookmarks).

M-x bookmark-save

Memorizza tutti i bookmark correnti nel file dei bookmark di default.

Il tipico uso che si fa dei bookmark consiste nel memorizzare una posizione all'interno di uno o più file. Il comando C-x r m, che imposta un bookmark, usa il nome del file aperto come valore di default per il nome del bookmark. Se si assegna un nome ad ogni bookmark in base al nome del file a cui esso si riferisce, risulta comodo in seguito ritornare con il solo comando C-x r b nello stesso punto di questi file in cui si era impostato il bookmark.

Per visualizzare in un buffer a parte una lista di tutti i bookmark basta digitare C-x r l (list-bookmarks). Se si passa a tale buffer, è possible modificare le definizioni dei bookmark, o aggiungere note e commenti. Digitando C-h m in tale buffer si possono ottenere maggiori informazioni sui comandi disponibili per la modifica.

Quando si chiude Emacs, se si è modificato qualche bookmark, viene proposta la possibilità di memorizzare i bookmark nel file dei bookmark di default ~/.emacs.bmk. È inoltre possibile memorizzare i bookmark in qualsiasi momento tramite il comando M-x bookmark-save. I comandi relativi ai bookmark caricano automaticamente il file dei bookmark di default. In questo modo, i bookmark vengono mantenuti tra una sessione e l'altra.

Se si imposta a 1 la variabile bookmark-save-flag, ogni comando che imposta (o modifica) un bookmark provvederà pure a memorizzarlo. In questo modo si ha la garanzia di non perdere alcun bookmark anche nel caso in cui Emacs dovesse terminare in modo anomalo. Il valore (se si tratta di un numero) indica quante singole modifiche ai bookmark devono essere permesse tra una memorizzazione e l'altra.

Le posizioni dei bookmark sono memorizzate insieme a informazioni riguardanti il contesto immediatamente attiguo ad esse, in modo che bookmark-jump possa ritrovare la posizione giusta anche se vi sono state leggere modifiche al file. La variabile bookmark-search-size indica quanti caratteri di contesto (che precedono e che seguono la posizione del bookmark) devono essere memorizzati.

Ecco altri comandi per lavorare con i bookmark:

M-x bookmark-load <Invio> nomefile <Invio>

Legge un file chamato nomefile che contiene un elenco di bookmark. È possibile usare questo comando (e bookmark-write) per lavorare con dei file di bookmark che non siano quello di default.

M-x bookmark-write <Invio> nomefile <Invio>

Memorizza i bookmark correnti nel file nomefile.

M-x bookmark-delete <Invio> bookmark <Invio>

Elimina il bookmark chiamato bookmark.

M-x bookmark-insert-location <Invio> bookmark <Invio>

Inserisce nel buffer il nome del file a cui punta il bookmark chiamato bookmark.

M-x bookmark-insert <Invio> bookmark <Invio>

Inserisce nel buffer il contenuto del file puntato dal bookmark chiamato bookmark.

Controllo della visualizzazione

Dato che una finestra può visualizzare solo parte di un buffer molto grande, Emacs cerca di mostrarne una parte che sia interessante. I comandi di controllo della visualizzazione permettono di specificare quale parte del testo si vuole vedere, e come essa va visualizzata.

• Scrolling: Scorrere il testo in alto e in basso in una finestra
• Horizontal Scrolling: Scorrere il testo a destra e a sinistra in una finestra.
• Follow Mode: Il modo Follow fa scorrere due finestre come se fossero una finestra sola.
• Selective Display: Nascondere le linee che hanno un certo rientro.
• Optional Mode Line: Opzioni di visualizzazione per la riga di stato.
• Text Display: Come vengono visualizzati i carattteri.
• Display Vars: Informazioni sulle variabili per personalizzare la visualizzazione

Scorrimento

Se un buffer contiene del testo che è troppo lungo per essere visualizzato interamente in una finestra, Emacs mostra solo una parte del testo. Il point si trova sempre nella la parte visualizzata.

Scorrere il testo significa spostare in alto o in basso il testo contenuto nella finestra, in modo che siano visibili differenti parti dello stesso. Scorrere in avanti significa spostare in alto il testo esistente e visualizzare del nuovo testo in fondo alla finestra. Scorrere all'indietro, al contrario, significa spostare in basso il testo esistente nella finestra e visualizzare il nuovo testo all'inizio della stessa.

Lo scorrimento avviene automaticamente quando si sposta il point oltre il margine inferiore o oltre il margine superiore della finestra. È inoltre possibile richiedere esplicitamente lo scorrimento del testo tramite i comandi descritti in questa sezione.

C-l

Cancella lo schermo e lo ridisegna, facendo scorrere la finestra selezionata in modo da centrare verticalmente il point al suo interno (recenter).

C-v

Scorre in avanti (di una finestra, o di uno specifico numero di linee) (scroll-up).

<NEXT>

Come sopra, scorre in avanti.

M-v

Scorre all'indietro (scroll-down).

<PRIOR>

Come sopra, scorre all'indietro.

arg C-l

Scorre il testo in modo che il point si trovi sulla riga arg (recenter).

C-M-l

Scorre il testo in maniera euristica, in modo da visualizzare informazione utile sullo schermo (reposition-window).

Il comando di scorrimento più semplice è C-l (recenter) avviato senza argomenti. Esso cancella lo schermo e ridisegna tutte le finestre. In aggiunta, esso fa scorrere la finestra correntemente selezionata in modo che il point si trovi centrato verticalmente rispetto ad essa.

I comandi di scorrimento C-v e M-v permettono di scorrere il testo in alto o in basso di un determinato numero di linee. C-v (scroll-up) con un argomento numerico mostra altrettante linee nuove in fondo alla finestra, spostando in alto il testo e il point come lo potrebbe fare C-l. C-v con un argomento negativo mostra altrettante linee all'inizio della finestra. M-v (scroll-down) è simile a C-v, tranne che esso fa scorrere nella direzione opposta. I tasti funzione <NEXT> e <PRIOR> sono equivalenti a C-v e a M-v.

I nomi dei comandi di scorrimento si basano sulla direzione in cui il testo viene spostato nella finestra. Il comando per scorrere in avanti viene chiamato pertanto scroll-up, in quando esso sposta il testo verso l'alto.

C-v usato senza argomenti fa scorrere il testo in alto per una quantità di linee pari alle dimensioni della finestra. Esso sposta vicino al margine superiore della finestra le ultime due linee che si trovavano vicino al margine inferiore, facendole segure da una serie di nuove linee che prima non erano visibili. Se il point si trovava in mezzo al testo che è "uscito" dalla finestra, esso viene spostato in prossimità del margine superiore. M-v senza argomenti fa scorrere in maniera analoga il testo verso il basso, mantenendo due linee di sovrapposizione. Il numero di linee di sovrapposizione da mantenere con C-v o M-v è controllabile tramite la variabile next-screen-context-lines. Per default, essa vale 2.

Alcuni utenti possono preferire che i comandi di scorrimento non modifichino la posizione del point all'interno del testo, ma piuttosto che venga conservata la stessa posizione sullo schermo. Per abilitare questo tipo di comportamento è sufficiente impostare la variabile scroll-preserve-screen-position ad un valore diverso da nil. Tale comportamento è comodo quando si vuole esaminare il testo di un file di schermata in schermata: se si ritorna al punto di partenza, il point si trova ancora nella sua posizione iniziale. Tuttavia, esso è scomodo quando si scorre il testo di una intera schermata per spostare in essa il point.

Un altro modo di scorrere è quello di usare C-l con un argomento numerico come prefisso. C-l, in questo caso, non ridisegna lo schermo, ma invece fa scorrere soltanto la finestra selezionata. Con un argomento positivo n, esso riposiziona il testo in modo che il point si trovi a n righe dal margine superiore della finestra. Un argomento pari a zero posiziona il point subito sotto il margine superiore. Il point non viene spostato rispetto al testo: entrambi vengono spostati insieme sullo schermo. C-l con un argomento negativo sposta il testo in modo da avere il point ad altrettante righe dal margine inferiore della finestra. Ad esempio C-u - 1 C-l fa in modo che il point si trovi sulla riga più in basso della finestra. Se l'argomento è solo C-u (come in C-u C-l), esso si limita a riposizionare il testo in modo che il point sia centrato verticalmente nella finestra (senza che essa venga ridisegnata).

Il comando C-M-l (reposition-window) scorre in maniera euristica il testo della finestra, in modo che sullo schermo vengano visualizzate informazioni significative. Ad esempio, in un file sorgente Lisp, questo comando tenta di visualizzare l'intera definizione della funzione sullo schermo (se possibile).

Lo scorrimento avviene automaticamente se il point si sposta al di fuori della porzione visibile del testo mostrato. Normalmente, lo scorrimento automatico centra il point verticalmente all'interno della finestra. Tuttavia, impostando la variabile scroll-conservatively ad un numero piccolo n, Emacs scorre il testo quel tanto che basta per riportare il point sullo schermo qualora si tenti di spostarlo di poco al di fuori della finestra--meno di n linee. Per default scroll-conservatively vale 0.

La variabile scroll-margin imposta la distanza minima (espressa in righe) a cui il point si può trovare dal margine superiore o dal margine inferiore di una finestra. Se il point si trova entro questa determinata distanza dai margini, Emacs scorre il testo centrando il point. Per default scroll-margin vale 0.

Scorrimento orizzontale

Scorrere orizzontalmente significa traslare lateralmente le linee di una finestra--in modo che parte del testo che si trova in prossimità del margine sinistro non sia visibile.

C-x <

Fa scorrere a sinistra il testo nella finestra corrente (scroll-left).

C-x >

Fa scorrere il testo a destra (scroll-right).

Quando il testo in una finestra è stato fatto scorrere orizzontalmente, le linee di testo vengono troncate invece che essere visualizzate con righe di continuazione (see Continuation Lines). Un $ appare nella prima colonna delle righe ove vi è del testo troncato a sinistra, ed anche nell'ultima colonna delle righe ove vi è del testo troncato a destra.

Il comando C-x < (scroll-left) con un argomento numerico n fa scorrere a sinistra il testo contenuto nella finestra di un numero n di colonne. Ciò sposta la parte iniziale di ogni linea al di là del margine sinistro della finestra. Senza argomenti, esso fa scorrere il testo per quasi l'intera larghezza della finestra (meno due colonne, per essere precisi).

C-x > (scroll-right) fa scorrere il testo in modo simile, ma a destra. Una volta che il testo è visualizzato normalmente (con ogni linea che inizia al margine sinistro della finestra), non è possibile far scorrere a destra ulteriormente il testo. Tentativi in tal senso vengono ignorati. Ciò significa che non occorre essere precisi nel calcolo dell'argomento da passare a C-x >: ogni argomento abbastanza grande ripristinerà una visualizzazione normale.

È possibile ottenere lo scorrimento automatico a sinistra o a destra abilitando il modo Hscroll. Quando esso è abilitato, Emacs fa scorrere orizzontalmente il testo nella finestra tutte le volte che diventa necessario al fine di mantenere visibile (e non troppo distante dai margini sinistro o destro) il point. Il comando per abilitare o disabilitare tale modo è M-x hscroll-mode.

Il modo Follow

Il modo Follow è un modo secondario che fa s`i che due finestre visualizzanti lo stesso buffer scorrano come se si trattasse di un'unica "finestra virtuale" più alta. Per usare il modo Follow basta andare in un frame che abbia una sola finestra, dividere con C-x 3 tale finestra in due finestre affiancate e poi digitare M-x follow-mode. In seguto è possibile modificare il buffer o scorrere il testo in ciascuna delle due finestre: l'altra finestra "segue" e si adegua.

Per disabilitare il modo Follow basta digitare M-x follow-mode una seconda volta.

Visualizzazione selettiva

Emacs ha la capacità di nascondere le linee che abbiano dei rientri dal margine sinistro di larghezza superiore ad un determinato numero di colonne (specificabile dall'utente). È possibile usare tale capacità per avere una visione complessiva di parte di un programma.

Per nascondere le linee basta digitare C-x $ (set-selective-display) con un argomento numerico n. In seguito, tutte le linee che hanno un rientro dal margine sinistro di dimensioni superiori ad n colonne scompaiono dallo schermo. L'unica indicazione della loro presenza è costituita da tre puntini (...) che compaiono alla fine di ciascuna linea visibile che sia seguita da una o più linee nascoste.

I comandi C-n e C-p si spostano attraverso le linee nascoste come se esse non esistessero.

Le linee nascoste, tuttavia, sono ancora presenti nel buffer, e la maggior parte dei comandi di modifica le trattano normalmente, pertanto è anche possibile che il point si trovi nel mezzo di una serie di linee nascoste. Quando ciò accade, il cursore viene mostrato al termine della riga visibile precedente, subito dopo i tre puntini. Se il point si trova al termine della linea visibile, prima del ritorno a capo che la termina, il cursore appare prima dei tre puntini.

Per rendere nuovamente visibili tutte le linee è sufficiente digitare C-x $ senza argomenti.

Se si imposta la variabile selective-display-ellipses a nil, non vengono mostrati i tre puntini al termine delle linee che precedono delle linee invisibili. In questo modo non vi è indicazione visibile del fatto che vi siano linee nascoste. Tale variabile diventa automaticamente locale quando viene impostata.

Opzioni di visualizzazione per la modeline

Quando il modo Line Number è abilitato, nella riga di stato appare il numero di linea su cui si trova il point. Per attivare o disattivare questo modo è sufficiente usare il comando M-x line-number-mode. Normalmente esso è attivato. Il numero di linea appare subito prima della posizione in percentuale nel buffer, e inizia con la lettera L per indicare di che cosa si tratta. See Minor Modes per informazioni sui modi secondari e sull'uso di questo comando.

Se il buffer è molto grande (più grande del valore di line-number-display-limit), il numero di linea corrente non viene mostrato. Emacs non calcola il numero di linea corrente quando il buffer è molto grande, in quanto ciò sarebbe troppo lento. Se il buffer è stat ristretto (see Narrowing), il numero di linea mostrato è relativo all'area accessibile del buffer.

È inoltre possibile mostrare il numero di colonna corrente attivando il modo Column Number: esso mostra il numero di colonna corrente preceduto dalla lettera C. Per abilitare o disabilitare questo modo è sufficiente usare il comando Type M-x column-number-mode.

Emacs può visualizzare nella riga di stato l'ora e il carico di lavoro del sistema: per abilitare questa funzionalità è sufficiente digitare M-x display-time. L'informazione aggiunta alla riga di stato solitamente appare dopo il nome del buffer e prima dei nomi dei modi (e delle loro parentesi). Essa un aspetto simile al seguente:

hh:mmpm l.ll

Qui hh e mm indicano le ore e i minuti, seguiti da am o pm. l.ll è il numero medio di processi recentemente in esecuzione sul sistema (alcuni campi possono mancare se il sistema operativo sottostante non ha supporto per essi). Se si preferisce avere l'ora indicata con il formato a 24 ore, è sufficiente impostare la variabile display-time-24hr-format a t.

Se vi è arrivata posta elettronica che non è stata ancora letta, di seguito al livello di carico del sistema compare la parola Mail.

Come viene visualizzato il testo

I caratteri stampabili ASCII (codici ottali da 040 a 0176) vengono visualizzati con la loro rappresentazione grafica. Lo stesso avviene anche per i caratteri non-ASCII multibyte stampabili (codici ottali superiori a 0400).

Alcuni caratteri di controllo ASCII vengono visualizzati in modo speciale: il carattere di ritorno a capo (codice ottale 012) viene visualizzato iniziando una nuova riga. Il carattere tab (codice ottale 011) viene visualizzato con uno spostamento al punto di tabulazione successivo (normalmente ogni 8 colonne).

I rimanenti caratteri di controllo ASCII sono visualizzati con un accento circonflesso (^) seguito dalla versione normale del carattere. Pertanto, control-A viene mostrato come ^A.

I caratteri non ASCII da 0200 a 0377 sono visualizzati con sequenze di escape ottali, pertanto il carattere di codice 0243 (ottale) è mostrato come \243. Tuttavia, se si abilita la visualizzazione europea, gran parte di essi diventano caratteri stampabili non-ASCII, e sono mostrati con la loro rappresentazione grafica (posto che il terminale sia in grado di farlo). See Single-Byte European Support.

Variabili che controllano la visualizzazione

Questa sezione contiene esclusivamente informazioni sulla personalizzazione. Gli utenti che non abbiano ancora esperienza possono passare direttamente alla sezione successiva.

Il valore della variabile mode-line-inverse-video stabilisce se la riga di stato deve essere visualizzata in negativo (posto che il terminale sia in grado di farlo): nil indica di non farlo. See Mode Line. Se si specifica un colore di primo piano per lo stile della riga di stato ed il valore di mode-line-inverse-video è diverso da nil, il colore di sfondo per tale stile è il normale colore di primo piano. See Faces.

Se la variabile inverse-video ha un valore diverso da nil, Emacs tenta di visualizzare in negativo tutte le linee.

Se la variabile visible-bell ha un valore diverso da nil, Emacs tenta di far lampeggiare l'intero schermo invece di produrre un suono. Questa variabile non viene considerata se il terminale usato non è in grado di far lampeggiare lo schermo.

Quado si ritorna a Emacs dopo averlo sospeso, esso normalmente pulisce lo schermo e ridisegna le finestre. Con alcuni terminali, con più di una pagina di memoria, è possibile modificare le voci ti e te (output sul terminale quando rispettivamente si entra e si esce da Emacs) in modo da scambiare tra loro le pagine di memoria, cos`i da usare una pagina per Emacs e un'altra pagina per gli altri output. In questo caso è possibile impostare la variabile no-redraw-on-reenter ad un valore diverso da nil: ciò induce Emacs a suppore che la pagina che sta usando contenga ancora quello che vi aveva scritto prima di essere interrotto.

La variabile echo-keystrokes controlla la visualizzazione nell'area messaggi delle sequenze composte da più caratteri: il suo valore consiste nel numero di secondi di pausa richiesti prima di visualizzare la sequenza di caratteri. Un valore pari a zero disattiva la visualizzazione. See Echo Area.

Se la variabile ctl-arrow vale nil, i caratteri di controllo nel buffer vengono visualizzati come sequenze di escape ottali, tranne che per il carattere di ritorno a capo e tab. L'impostazione di tale variabile rende la stessa locale al buffer corrente. Il valore di default è inizialmente t. See Display Tables.

Normalmente, un tab viene visualizzato nel buffer come uno spazio che si estende fino alla prossimo punto di tabulazione, ed essi sono normalmente intervallati alla distanza di otto caratteri l'uno dall'altro. Il numero di spazi per tab è controllato dalla variabile tab-width, che diventa locale impostandola, proprio come ctl-arrow. È da sottolineare il fatto che il modo con cui viene visualizzato il carattere tab nel buffer non ha niente a che vedere con la definizione del tasto <TAB> in quanto comando. La variabile tab-width può assumere un valore intero tra 1 e 1000 (compresi).

Se la variabile truncate-lines ha un valore diverso da nil, ogni linea di testo occupa esattamente una riga dello schermo. Se la linea è troppo lunga, Emacs ne visualizza solo una parte. Se truncate-lines ha un valore pari a nil, le linee di testo lunghe vengono visualizzate su più righe, tante quanto basta per visualizzare l'intera linea. See Continuation Lines. L'impostazione di questa variabile rende quest'ultima locale al buffer corrente. Il valore di default è nil.

Se la variabile truncate-partial-width-windows ha un valore diverso da nil, il troncamento viene usato in ogni finestra che sia più stretta dell'intera larghezza del frame, indipendentemente dal valore di truncate-lines. Per informazioni su finestre affiancate, consultare Split Window. Consultare inoltre Display.

La varabile baud-rate contiene la velocità di output del terminale per quanto Emacs ne può essere a conoscenza. L'impostazione di questa variabile non modifica la velocità di trasmissione, ma il valore viene usato per calcolare parametri come il padding. Esso influenza inoltre le decisioni sullo scorrere una finestra piuttosto che ridisegnarla--anche quando si sta usando un sistema grafico (Emacs è stato progettato in questo modo, nonostante il fatto che un sistema grafico non abbia una vera e propria "velocità di output", per permettere di avere un controllo fine su tali decisioni).

È possibile personalizzare il modo in cui un qualsiasi codice di carattere viene visualizzato tramite l'uso di una display table. See Display Tables.

Ricerche e sostituzioni

Come avviene per altri editor, Emacs fornisce comandi per ricercare una stringa di testo. Il comando principale di ricerca differisce da quelli comuni in quanto esso è incrementale, ovvero inizia ad effettuare la ricerca ancor prima che la stringa che si sta ricercando sia stata digitata completamente. Esistono comunque anche comandi di ricerca non incrementali che funzionano in maniera analoga a quelli degli altri editor.

In aggiunta all'usuale comando replace-string, che sostituisce tutte le occorrenze di una stringa con un'altra, Emacs fornisce un potente comando di sostituzione chiamato query-replace, che chiede interattivamente quali occorrenze vanno sostituite.

• Incremental Search: La ricerca avviene a mano a mano che si digita la stringa.
• Nonincremental Search: Specificare per intero la stringa e poi avviare la ricerca.
• Word Search: Ricerca di una sequenza di parole.
• Regexp Search: Ricerca di testo che soddisfi un'espressione regolare .
• Regexps: Sintassi delle espressioni regolari.
• Search Case: Ignorare o meno la differenza tra maiuscole e minuscole nelle ricerche.
• Replace: Ricercare e sostituire tutte o solo alcune delle occorrenze.
• Other Repeating Search: Operazioni effettuabili su tutte le occorrenze di un'espressione regolare.

Ricerca incrementale

La ricerca incrementale ha inizio non appena si digitano i primi caratteri della stringa da ricercare. A mano a mano che essa viene inserita, Emacs mostra il punto ove si trova la stringa digitata fino a quel momento. Una volta inseriti caratteri a sufficienza per trovare il punto interessato è possible fermarsi. A seconda di ciò che si vuole fare in seguito, può essere necessario o meno terminare esplicitamente la stringa di ricerca con <Invio>.

C-s

Ricerca incrementale in avanti (isearch-forward).

C-r

Ricerca incrementale all'indietro (isearch-backward).

C-s avvia una ricerca incrementale. C-s legge caratteri dalla tastiera e posiziona il cursore alla prima occorrenza dei caratteri inseriti. Se si digita C-s e poi P, il cursore viene spostato alla prima occorrenza di P. In seguito, digitando I il cursore viene spostato subito dopo la prima occorrenza di PI. Digitando ancora P P O, il cursore viene posizionato subito dopo la prima occorrenza di PIPPO che segua il punto in cui la ricerca ha avuto inizio. Ad ogni passo, la stringa di ricerca viene mostrata nell'area messaggi, e, se il terminale è in grado di farlo, il testo nel buffer corrispondente alla stringa digitata viene evidenziato.

Se si commettono errori nel digitare la stringa di ricerca è possibile cancellare caratteri tramite il tasto <DEL>. Ogni pressione di <DEL> cancella l'ultimo carattere della stringa di ricerca: ciò non avviene fin quando Emacs non è pronto a leggere un altro carattere dalla tastiera: prima di cancellare il carattere, Emacs deve aver già trovato (o aver fallito nel cercare) il carattere che si sta per cancellare. Se non si vuole attendere, si può usare C-g come descritto più avanti.

Quando la posizione mostrata è quella che si stava cercando, è sufficiente premere il tasto <Invio>, che interrompe la ricerca e lascia il cursore ove la ricerca l'aveva posizionato. La ricerca viene interrotta anche da ogni comando che non sia significativo per la ricerca in sè, ed il comando stesso viene eseguito. Pertanto, C-a fa terminare la ricerca e provoca lo spostamento all'inizio della linea. <Invio> è indispensabile solo nel caso in cui il comando che si vuole digitare in seguito sia un carattere stampabile, oppure <DEL>, <Invio> o un altro carattere di controllo che abbia un significato particolare durante le ricerche (C-q, C-w, C-r, C-s, C-y, M-y, M-r, o M-s).

Può capitare di cercare PIPPO e di trovarlo, ma l'occorrenza potrebbe non essere quella desiderata, in quanto esiste una seconda occorrenza di PIPPO di cui ci si era dimenticati. In questo caso è sufficiente digitare C-s un'altra volta per spostarsi all'occorenza successiva: tale operazone può essere ripetuta per un numero qualsiasi di volte. Se per errore si oltrepassa il punto desiderato, è possibile annullare i C-s di troppo con il tasto <DEL>.

Dopo essere usciti da una ricerca è possibile ricercare nuovamente la stessa stringa semplicemente digitando C-s C-s: il primo C-s è la sequenza che avvia la ricerca incrementale, mentre il secondo C-s significa "cerca nuovamente".

Per riutilizzare stringe di ricerca digitate in precedenza si può far uso della lista delle ricerche: i comandi M-p e M-n permettono di spostarsi attraverso tale lista per trovare la stringa da ricercare. Questi comandi lasciano nel minibuffer una copia della stringa selezionata, in modo da poterla modificare. Una volta modificata, è sufficiente digitare C-s o C-r per avviare la ricerca.

Se la stringa non viene trovata, nell'area messaggi compare Failing I-Search e il cursore rimane posizionato di seguito al testo che corrisponde per quanto possibile a quanto ricercato. Pertanto, se si cerca PORTAEREI e non vi è nessuna parola PORTAEREI nel testo, è possibile che il cursore venga posizionato dopo PORTA di PORTAMENTO. Giunti a questo punto è possbile intraprendere diverse azioni: se si sono commessi errori nel digitare la stringa si possono cancellare i caratteri sbagliati e correggerli; se si è giunti nel lugo desiderato si può digitare <Invio> o qualche altro comando di Emacs per "accettare quanto trovato". Oppure si può digitare C-g per rimuovere dalla stringa tutti i caratteri che non possono essere trovati (EREI in PORTAEREI), lasciando quelli che invece erano stati trovati (PORTA in PORTAMENTO). Un secondo C-g digitato a questo punto annulla l'intera ricerca, provocando lo spostamento al punto in cui la ricerca aveva avuto inizio.

Se nella stringa di ricerca sono presenti lettere maiuscole, la ricerca avviene differenziando le maiuscole dalle minuscole. Se tutte le lettere maiuscole vengono cancellate dalla stringa di ricerca, tale differenza non viene più presa in considerazione. See Search Case.

Se l'esito di una ricerca è negativo e la si ripete digitando C-s un'altra volta, la ricerca ricomincia dall'inizio del buffer. Se si ripete una ricerca all'indietro non andata a buon fine digitando un'altra volta C-r, la ricerca riparte dalla fine del buffer. Tale comportamento viene definito ciclico, e in questi casi nel prompt di ricerca comare la parola Wrapped. Se si arriva a oltrepassare il punto in cui si è iniziata la ricerca, nel prompt appare la parola Overwrapped, che indica che si stanno esaminando nuovamente posizioni già visitate in precedenza.

Il carattere C-g si comporta in modo particolare quando viene digitato durante una ricerca, a seconda del contesto. Se si è trovato quanto si desiderava e Emacs è in attesa di altri caratteri da ricercare, C-g annulla l'intera ricerca e il cursore viene riportato nel punto ove essa aveva avuto inizio. Se si digita C-g quando vi sono caratteri nella stringa di ricerca che non sono stati ancora trovati--o perché essi non sono presenti nel testo, o perché Emacs deve ancora completare la loro ricerca--essi vengono rimossi dalla stringa di ricerca. Senza di essi, la ricerca va necessariamente a buon fine, pertanto un secondo C-g annulla l'intera ricerca.

Per ricercare un ritorno a capo occorre inserire C-j. Per ricercare un carattere di controllo (come control-S) occorre quotarlo, digitando prima C-q. La funzione espletata da C-q nelle ricerche è analoga a quella usata per l'inserimento di testo: esso fa in modo che il carattere digitato subito dopo venga considerato esattamente allo stesso modo di un carattere "normale" nello stesso contesto. È inoltre possibile specificare un carattere tramite il suo codice ottale: è sufficiente digitare C-q seguito da una serie di cifre ottali.

È possibile cambiare direzione di ricerca ed effettuare ricerche all'indietro tramite C-r: esso è utile qualora una ricerca in avanti fallisca in quanto essa ha avuto inizio oltre il punto che si sta ricercando. L'uso ripetuto di C-r provoca la ricerca all'indietro di occorrenze via via precedenti. Digitando in seguto C-s si riprende la ricerca in avanti. C-r in una ricerca può essere cancellato tramite il tasto DEL.

Se si sa già che il punto da ricercare si trova prima nel testo, al posto di C-s è possibile usare C-r, in quanto C-r è associato a un comando (isearch-backward) che inizia una ricerca all'indietro. Una ricerca all'indietro trova esclusivamente occorrenze che siano interamente prima del punto di inizio della rierca, esattamente come una ricerca in avanti prende in considerazione solo ciò che sta dopo.

Mentre si sta effettuando una ricerca incrementale è possible usare C-w e C-y per aggiungere alla stringa di ricerca del testo copiato dal buffer: ciò rende comodo ricercare occorrenze ulteriori del testo che si trova di seguito al point. C-w aggiunge nella stringa di ricerca la parola che segue il point, e sposta il point dopo di essa, per cui digitando C-s si procederà ad effettuare una ricerca comprendente tale parola. C-y agisce in maniera simile a C-w, ma aggiunge tutta la parte rimanente della linea. Se la ricerca non tiene conto della differenza tra maiuscole e minuscole, C-w e C-y convertono il testo in minuscolo prima di aggiungerlo alla stringa di ricerca, in modo che la ricerca continui a non considerare la differenza.

M-y aggiunge alla stringa di ricerca del testo prelevato dalla lista degli appunti: esso è lo stesso che, al di fuori dell'ambito di una ricerca, verrebbe normalmente incollato tramite C-y. See Yanking.

Quando una ricerca incrementale ha termine, il mark viene impostato nel punto ove la ricerca ha avuto inizio, permettendo quindi di potervi tornare comodamente. Nel modo Transient Mark, la ricerca incrementale provoca lo spostamento del mark, ma non la sua attivazione. Ciò avviene unicamente se il mark non è attivo.

Per personalizzare i caratteri speciali utilizzati dalla ricerca incrementale è possible modificare le loro associazioni nella mappa isearch-mode-map. Per una lista delle associazioni si può consultare la documentazione di isearch-mode tramite C-h f isearch-mode <Invio>.

Ricerche incrementali con terminali lenti

La ricerca incrementale su terminali lenti usa uno stile di visualizzazione diverso, pensato per essere più rapido. Invece di ridisegnare l'intero buffer ad ogni occorrenza trovata, Emacs crea una nuova finestra di una sola riga che viene usata per mostrare la linea di testo contenente l'occorrenza trovata. Tale finestra viene mostrata non appena la ricerca provoca lo spostamento del point oltre i margini del testo già visibile.

Una volta terminata la ricerca, questa mini-finestra viene rimossa e Emacs aggiorna la finestra in cui la ricerca aveva avuto inizio, in modo da mostrare la nuova posizione del point.

Lo stile di visualizzazione per ricerche incrementali con terminali lenti viene utilizzato quando la velocità in baud¹¹ del terminale è uguale o inferiore al valore della variabile search-slow-speed (inizialmente essa vale 1200).

Il numero di linee da visualizzare nella mini-finestra è controllato dalla variabile search-slow-window-lines. Normalmente, essa vale 1.

Ricerche non incrementali

Emacs dispone anche di comandi per effettuare normali ricerche non incrementali, le quali richiedono di digitare l'intera stringa prima di iniziare la ricerca.

C-s <Invio> stringa <Invio>

Ricerca stringa in avanti.

C-r <Invio> stringa <Invio>

Ricerca stringa all'indietro.

Per effettuare una ricerca non incrementale basta digitare C-s <Invio>: nel minibuffer viene richiesta la stringa da ricercare. Terminandola con <Invio>, la ricerca ha inizio. Se la stringa non viene trovata, la ricerca produce un errore.

C-s <Invio> ha questo effetto in quanto C-s avvia una ricerca incrementale, la quale avvia a sua volta una ricerca non incrementale se la stringa di ricerca è vuota (una stringa di ricerca vuota non è di alcuna utilità). C-r <Invio> funziona in maniera analoga.

C-s <Invio>, tuttavia, non invoca direttamente la ricerca non incrementale, in quanto viene prima controllato se il carattere digitato subito dopo è C-w: in questo caso viene avviata la ricerca per parole.

Le ricerche non incrementali sono implementate tramite i comandi search-forward e search-backward: essi possono essere associati a delle sequenze di tasti nel modo usuale. Il fatto che a essi si acceda tramite i comandi di ricerca incrementale è dovuto a motivi storici (e anche per evitare di dover loro assegnare sequenze di tasti specifiche).

Ricerca per parole

La ricerca per parole ricerca sequenze di parole senza badare a come esse sono separate. Più precisamente, è possibile digitare una serie di parole separate da singoli spazi e trovare un'occorrenza anche se nel testo esse sono separate da più spazi, ritorni a capo o altro tipo di punteggiatura.

La ricerca per parole è utile con documenti di testo prodotti con un sistema di impaginazione: se si lavora osservando la versione impaginata del testo non è possible sapere dove i ritorni a capo sono posizionati nei sorgenti. Utilizzando la ricerca per parole non vi è la necessità di saperlo.

C-s <Invio> C-w parole <Invio>

Ricerca le parole in avanti, ignorando i dettagli riguardanti la punteggiatura.

C-r <Invio> C-w parole <Invio>

Ricerca le parole all'indietro, ignorando i dettagli riguardanti la punteggiatura.

La ricerca per parole è un caso particolare della ricerca non incrementale, ed è invocata tramite C-s <Invio> C-w. Di seguito occorre digitare le parole da ricercare, terminandole con <Invio>: dato che la ricerca non è incrementale, essa non ha inizio fin quando non si ha finito di inserire l'argomento. Essa opera costruendo un'espressione regolare e poi effettuando una ricerca delle occorrenze della stessa (vedere Regexp Search).

Tramite C-r <Invio> C-w è possible effettuare una ricerca per parole all'indietro.

Le ricerche per parole sono implementate dai comandi word-search-forward e word-search-backward. essi possono essere associati a delle sequenze di tasti nel modo usuale. Il fatto che a essi si acceda tramite i comandi di ricerca incrementale è dovuto a motivi storici (e anche per evitare di dover loro assegnare sequenze di tasti specifiche).

Ricerca di espressioni regolari

Un'espressione regolare (abbreviata in regexp) è un modello che definisce una serie (anche infinita) di possibili stringhe da ricercare. In GNU Emacs è possibile ricercare un'espressione regolare sia in modo incrementale che in modo non incrementale.

La ricerca incrementale di un'espressione regolare avviene digitando C-M-s (isearch-forward-regexp): questo comando legge una stringa di ricerca esattamente come C-s, ma essa viene considerata come un'espressione regolare invece che come una semplice stringa di cui si devono ricercare occorrenze identiche nel testo. Ogni volta che si aggiunge del testo alla stringa di ricerca, si allunga l'espressione regolare, ed essa viene ricercata all'interno del testo. Un altro modo di avviare la ricerca di un'espressione regolare è quello di digitare C-s preceduto da un argomento (il valore non importa). Per cercare un'espressione regolare all'indietro si può usare C-M-r (isearch-backward-regexp) oppure C-r preceduto da un argomento.

Tutti i caratteri di controllo che sono speciali nella ricerca incrementale normale hanno la stesa funzione anche nella ricerca incrementale di espressioni regolari. Digitando C-s o C-r immediatamento dopo aver iniziato una ricerca permette di riutilizzare l'ultima espressione regolare ricercata: in parole povere, le ricerche incrementali di espressioni regolari e le ricerche incrementali di normali stringhe hanno valori di default indipendenti tra loro. Esse dispongono anche di liste indipendenti tra loro per quanto riguarda le stringhe o le espressioni regolari ricercate in precedenza, liste accessibili tramite M-p e M-n.

A uno spazio digitato in un'espressione regolare corrisponde una qualsiasi sequenza di spazi, inclusi tab e ritorni a capo¹². Se si vuole che ad esso corrisponda esattamente un singolo spazio occorre digitare C-q <Spazio>.

Occorre notare che l'aggiunta di nuovi caratteri all'espressione regolare durante una ricerca incrementale può far riprendere la ricerca dal punto di partenza. Ad esempio, se si è specificato pippo e poi si aggiunge \|topolino, il cursore viene prima riportato al punto di partenza nel caso che il primo topolino preceda il primo pippo.

Le ricerche non incrementali di espressioni regolari sono effettuate dai comandi re-search-forward e re-search-backward. Essi possono essere invocati tramite M-x, o assegnati a delle sequenze di tasti, o avviati passando per la ricerca incrementale con C-M-s <Invio> and C-M-r <Invio>.

Se i comandi per la ricerca incrementale di espressioni regolari sono preceduti da un argomento, essi effettuano la ricerca di normali stringhe, esattamente come fanno i comandi isearch-forward e isearch-backward. See Incremental Search.

Sintassi delle espressioni regolari

La sintassi delle espressioni regolari è tale per cui vi sono alcuni caratteri che rappresentano costrutti speciali, mentre tutti i rimanenti sono caratteri ordinari. Un carattere ordinario costituisce una semplice espressione regolare a cui corrisponde solo quel carattere e null'altro. I caratteri speciali sono $, ^, ., *, +, ?, [, ] e \. Tutti gli altri caratteri che compaiono in un'espressione regolare sono ordinari, a meno che non siano preceduti da \.

Ad esempio, f non è un carattere speciale, ma è ordinario, per cui f costituisce un'espressione regolare che viene soddisfatta esclusivamente dalla stringa f (non soddisfa la stringa ff). Nello stesso modo, o è un'espressione regolare che può essere soddisfatta solo da o. (Se non si sta tenendo condo della differenza tra maiuscole e minuscole, queste espressioni regolari vengono soddisfatte pure da F e da O, ma questa viene considerata una generalizzazione del concetto di "stringa identica" invece che un'eccezione).

Due espressioni regolari qualsiasi a e b possono essere contatenate. Il risultato è un'espressione regolare che viene soddisfatta da una stringa solo se l'inizio della stringa soddisfa a e il resto della stringa soddisfa b.

Ad esempio, è possibile concateneare le espressioni regolari f e o per ottenere l'espressione regolare fo, che viene soddisfatta solo dalla stringa fo. Fin qui tutto è molto semplice. Per operazioni più complesse occorre usare dei caratteri speciali. Ecco un elenco:

. (Punto)

è un carattere speciale che viene soddisfatto da qualsiasi carattere tranne il ritorno a capo. Tramite la concatenazione è possibile creare espressioni regolari come a.b che vengono soddisfatte da qualsiasi stringa di tre caratteri che inizi con a e termini con b.

*

non è un costrutto in sè, ma è un operatore postfisso che indica che l'espressione regolare che lo precede va soddisfatta ripetutamente per un numero indefinito di volte. Pertanto, o* viene soddisfatta da un numero qualsiasi di o consecutive (anche nessuna).

Il motore della ricerca gestisce il costrutto con * cercando di soddisfarlo immediatamente con quante più ripetizioni possono essere trovate, e poi cerca di soddisfare il resto dell'espressione. Se il resto dell'espressione non viene soddisfatto, viene effettuato un passo indietro, scartando alcune delle soluzioni al costrutto con * nel caso che ciò renda possibile soddisfare il resto dell'espressione. Ad esempio, nel vedere se l'espressione pip*po viene soddisfatta dalla stringa pippo, a p* vengono fatte corrispondere entrambe le p centrali, ma il resto dell'espressione è po, e rimane solo o disponibile per soddisfarla, per cui il tentativo fallisce. L'alternativa seguente è quella per cui p* viene soddisfatta solo dalla prima delle due p centrali. In questo caso, il resto dell'espressione viene soddisfatto.

+

è un operatore postfisso simile a *, tranne che l'espressione regolare che lo precede va soddisfatta almeno una volta. Ad esempio, pip+po viene soddisfatta dalla stringa pippo e pipppppo, ma non dalla stringa pipo, mentre pip*po viene soddisfatta da tutte e tre le stringhe.

?

è un operatore postfisso simile a *, tranne che l'espressione regolare che lo precede va soddisfatta una sola volta, oppure nessuna. Ad esempio, pip?po viene sodddisfatta esclusivamente da pippo o da pipo.

[ ... ]

è un insieme di caratteri che inizia con [ e termina con ]. Nel caso più semplice, esso viene soddisfatto da uno qualsiasi dei caratteri che si trovano tra le parentesi quadre.

Pertanto, [ad] viene soddisfatta sia da una a o da una d, e [ad]* viene soddisfatta da una stringa qualsiasi composta solo di a e di d (inclusa la stringa nulla). Da ciò segue che pi[pl]*po viene soddisfatta da pipo, pippo, pilpo, pippllpo, eccetera.

È inoltre possible definire interi insiemi di caratteri specificando il primo e l'ultimo con un - tra di loro. Pertanto, [a-z] viene soddisfatto da qualsiasi lettera dell'alfabeto minuscola. Gli intervalli possono essere usati liberamente insieme a singoli caratteri, come in [a-z$%.], che viene soddisfatta da qualsiasi lettera ASCII minuscola o da $, % o da un punto.

Occorre notare che i caratteri speciali dele espressioni regolari non sono più consderati speciali nella definizione di un insieme: i caratteri speciali nell'ambito degli insiemi sono ], - e ^.

Per includere ] in un insieme di caratteri occorre specificarlo per primo. Ad esempio, []a] viene soddisfatta sia da ] che da a. Per includere un - nell'insieme, occorre specificarlo per primo o per ultimo, o subito dopo la definizione di un intervallo. Pertanto []-] viene soddisfatta sia da ] che da -.

Per includere un ^ nell'insieme occorre specificarlo in una posizione che non sia la prima.

Quando si definiscono degli intervalli nell'ambito di una ricerca che non tenga conto della differenza tra maiuscole e minuscole, è bene specificare entrambi gli estremi dell'intervallo in maiuscolo, oppure entrambi in minuscolo, oppure usare estremi diversi da lettere. Il comportamento di un intervallo i cui estremi sono di natura mista (come A-z) è indefinito, e può variare nelle future versioni di Emacs.

[^ ... ]

[^ indica un insieme complementare di caratteri, che viene soddisfatto da qualsiasi carattere che non sia tra quelli specificati. Pertanto, [^a-z0-9A-Z] viene soddisfatta da qualsiasi carattre tranne lettere e numeri.

^ è speciale solo quando è il primo carattere dell'insieme. Il carattere che segue ^ viene considerato come se fosse il primo carattere dell'insieme (in altre parole, un ] o un - al secondo posto non vengono considerati speciali).

Un insieme complementare di caratteri può essere soddisfatto da un ritorno a capo, a meno che il ritorno a capo non sia fra i caratteri da escludere. Ciò è in contrasto con la gestione delle espressioni regolari effettuata da programmi come grep.

^

è un carattere speciale che viene soddisfatto da una stringa vuota, ma solo se essa si trova all'inizio della linea nel testo esaminato, altrimenti non viene soddisfatto. Pertanto ^pippo viene soddifatto da pippo solo se esso compare all'inizio della linea.

$

è simile a ^, ma viene soddisfatto dalla stringa vuota solo se essa si trova al termine della linea. Pertanto, x+$ viene soddisfatta da una stringa che ha una o più x alla fine della linea.

\

ha due funzioni: esso quota i caratteri speciali (\ stesso incluso) e funge da introduzione per altri costrutti speciali.

Dato che \ quota i caratteri speciali, \$ è un'espressione regolare che viene soddisfatta dal solo carattere $, e \[ è un'espressione regolare soddisfatta solo da [ e cos`i via.

Nota: per compatibilità con le versioni precedenti, i caratteri speciali sono trattati come caratteri ordinari se essi si trovano in contesti ove il loro particolare significato non ha senso. Ad esempio, *pippo considera * come un carattere ordinario dato che non vi è nessua espressione su cui * possa agire. È pratica poco raccomandabile fare affidamento su tale comportamento: è molto meglio quotare sempre il carattere speciale, indipendentemente dalla posizione in cui appare.

Nella maggior parte dei casi, \ seguito da un qualsiasi carattere viene soddisfatta solo da quel particolare carattere. Vi sono tuttavia numerose eccezioni consistenti in sequenze di due caratteri inizianti con \, che hanno un significato particolare. Il secondo carattere è sempre un carattere ordinario quando usato da solo. Ecco un elenco dei costrutti che iniziano con \:

\|

specifica un'alternativa. Due espressioni regolari a e b con un \| tra loro formano un'espressione che viene soddisfatta se il testo in esame soddisfa a oppure b, ovvero verificando se a viene soddisfatta, e in caso contrario verificando se viene soddisfatta b.

Pertanto, pippo\|topolino viene soddisfatta sia da pippo che da topolino, ma non da qualsiasi altra stringa.

\| si applica alle espressioni che la circondano, considerando quelle più lunghe possibili. Solo un raggruppamento tramite \( ... \) può limitare il potere raggruppante di \|.

Emacs ha una completa capacità di effettuare backtracking per gestire l'uso di più \| in un'espressione.

\( ... \)

è un costrutto di raggruppamento che serve per i tre scopi che seguono:

1. Raggruppare (per altri scopi) un insieme di alternative definite con \| Ad esempio, \(pippo\|topolino\)x viene soddisfatta sia da pippox che da topolinox.
2. Raggruppare un'espressione complessa per gli operatori postfissi *, + e ?. Ad esempio, ba\(na\)* viene soddisfatta da banana, bananana, eccetera, con un numero qualsiasi (zero o più) di na.
3. Memorizzare la sottostringa che soddisfa l'espressione per farvi riferimento in seguito.

Quest'ultima applicazione non è conseguenza dell'idea di un raggruppamento tramte parentesi: si tratta di una funzionalità separata che fornisce un secondo significato allo stesso costrutto \( ... \). In pratica, non vi è conflitto fra i due significati.

\d

viene soddisfatta dalla stessa stringa che ha soddisfatto il d-esimo costrutto \( ... \).

Dopo aver verficato un costrutto \( ... \), l'inizio e la fine del testo che lo ha soddisfatto vengono memorizzati. In seguito, più in avanti nell'espressione regolare, è possible usare \ seguto da una cifra d che viene soddisfatto dallo stesso testo che ha soddisfatto il d-esimo costrutto \( ... \).

Alle stringhe che soddisfano i primi nove costrutti \( ... \) in un'espressione regolare vengono assegnati i numeri da uno a nove, nell'ordine in cui le parentesi aperte compaiono nell'espressione regolare. È quindi possibile fare rifermento più avanti a tali stringhe con i costrutti che vanno da \1 a \9.

Ad esempio, \(.*)\1 viene soddifatta da ogni stringa senza ritorni a capo che sia composta di due metà identiche. \(.*) viene soddisfatta dalla prima metà (che può essere qualsiasi cosa), e \1 deve essere soddifatta da esattamente lo stesso testo.

Se un costrutto \( ... \) viene soddisfatto più volte (cosa che accade spesso se esso viene seguto da un *), solo l'ultimo testo viene memorizzato.

\`

viene soddisfatto da una stringa vuota, ma solo se essa si trova all'inizio del buffer o della stringa in esame.

\'

viene soddisfatto da una stringa vuota, ma solo se essa si trova alla fine del buffer o della stringa in esame.

\=

viene soddisfatto da una stringa vuota, ma solo se essa si trova nella posizione in cui si trova il point.

\b

viene soddisfatto da una stringa vuota, ma solo se essa si trova all'inizio o alla fine di una parola. Pertanto, \bpippo\b viene soddisfatto da una qualsiasi occorrenza di pippo come parola separata. \btramai?\b viene soddisfatta sia da trama che da tramai, considerate come parole distinte.

\b viene soddisfatto sia all'inizio che alla fine del buffer, indipendentemente dal testo che ha accanto.

\B

viene soddisfatto da una stringa vuota, purchè non all'inizio o alla fine di una parola.

\<

viene soddisfatto da una stringa vuota, purchè essa si trovi all'inizio di una parola. \< viene soddisfatto dall'inizio del buffer, purchè il buffer inizi con un carattere che faccia parte di una parola.

\>

viene soddisfatto da una stringa vuota, purchè essa si trovi al termine di una parola. \< viene soddisfatto dal termine del buffer, purchè il buffer termini con un carattere che faccia parte di una parola.

\w

viene soddisfatto da qualsiasi carattere che faccia parte di una parola. La tabella sintattica determina l'insieme di tali caratteri. See Syntax.

\W

viene soddisfatto da qualsiasi carattere che non faccia parte di una parola.

\sc

viene soddisfatto da qualsiasi carattere la cui sintassi sia c. c è un carattere che rappresenta un codice sintattico, come w per i caratteri facenti parte di una parola, - per gli spazi, ( per le parentesi aperte, etc. Un carattere di spaziatura (che può essere anche un ritorno a capo) può essere rappresentato sia con - che con uno spazio vero e proprio.

\Sc

viene soddisfatto da qualsiasi carattere la cui sintassi non sia c.

I costrutti che riguardano le parole e la sintassi sono controllati dalle impostazione della tabella sintattitca (see Syntax).

Ecco un'espressione regolare complessa, usata da Emacs per identificare la fine di una frase insieme ad ogni spaziatura ad essa seguente. È scritta con la sintassi del Lisp per permettere di distinguere gli spazi dai tab. Con la sintassi Lisp, le costanti di tipo stringa iniziano e terminano con apici doppi. \" indica un doppio apice all'interno dell'espressione regolare, \\ una barra rovescia, \t un carattere di tabulazione e \n un ritorno a capo.

"[.?!][]\"')]*\\($\\|\t\\|  \\)[ \t\n]*"

Essa è composta da quattro parti: un insieme di caratteri che viene soddisfatto da un punto, da ? o da !; un insieme di caratteri che soddisfa delle parentesi tonde, quadre o graffe chiuse ripetute per un numero qualsiasi di volte; un'alternativa raggruppata in parentesi che viene soddisfatta da un fine linea, da un tab o da due spazi; un insieme di caratteri che viene soddisfatto da spazi vuoti ripetuti un numero qualsiasi di volte.

Per immettere la stessa espressione in maniera interattiva, si dovrebbe digitare <TAB> per inserire un tab e C-j per il ritorno a capo. Dovrebbero essere inoltre usate barre rovesce singole (\) al posto di quelle doppie (\\).

Ricerche e maiuscole/minuscole

Normalmente, le ricerche incrementali in Emacs non fanno distinzione tra maiuscole e minuscole nel testo in esame se tutte le lettere nella stringa di ricerca sono minuscole. Pertanto, se si specifica pippo come stringa di ricerca, essa viene soddisfatta sia da pippo che da Pippo. La ricerca di espressioni regolari, ed in particolare gli insiemi di caratteri, sono inclusi: [ab] viene soddisfatta da a, da A, da b o da B.

Una lettera maiuscola in una posizione qualsiasi della stringa di ricerca rende la ricerca sensibile alla differenza tra maiuscole e minuscole. Pertanto, la ricerca di Pippo non tiene in considerazione pippo o PIPPO. Ciò si applica sia alle ricerche di espressioni regolari che alle ricerche di normali stringhe. La distinzione non ha più luogo se si eliminano tutte le lettere maiuscole dalla stringa di ricerca.

Se si imposta la variabile case-fold-search a nil, le lettere ricercate devono corrispondere esattamente, anche per quanto riguarda le minuscole e le maiuscole. Questa è una variabile locale al buffer: la sua modifica si ripercuote solo sul buffer corrente, tuttavia vi è un valore di default che può essere cambiato. See Locals. Tale variabile influenza anche le ricerche non incrementali, incluse quelle effettuate dai comandi di sostituzione (see Replace) e dai meccanismi di riutilizzo di espressioni digitati in precedenza nel minibuffer (see Minibuffer History).

Comandi di sostituzione

In Emacs, le operazioni globali di ricerca con sostituzione non sono altrettanto indispensabili come lo sono in altri editor ¹³, tuttavia esse sono disponibili. Oltre al semplice comando M-x replace-string (sostituzione di testo), che è simile a quanto si trova nella maggior parte di altri editor, esiste un comando M-x query-replace che, per ogni occorrenza di quanto ricercato, chiede se occorre sostiture il testo oppure no.

I comandi di sostituzione normalmente operano sul testo nel buffer che va dal point fino alla fine del buffer. Tuttavia, se ci si trova nel modo Transient Mark e il mark è attivo, essi operano sulla regione. Tutti i comandi di sostituzione sostituiscono una stringa (o un'espressione regolare) con un'altra stringa. È possibile effettuare numerose sostituzioni in parallelo tramite il comando expand-region-abbrevs (see Expanding Abbrevs).

• Unconditional Replace: Sostituire tutte le occorrenze di una stringa.
• Regexp Replace: Sostituire ciò che soddisfa un'espressione regolare.
• Replacement and Case: Come vengono trattate le maiuscole e le minuscole nelle sostituzioni.
• Query Replace: Sostituzione in maniera interattiva.

Sostituzione incondizionata

M-x replace-string <Invio> stringa <Invio> nuovastringa <Invio>

Sostituisce tutte le occorrenze di stringa con nuovastringa.

M-x replace-regexp <Invio> regexp <Invio> nuovastringa <Invio>

Sostituisce tutto ciò che soddisfa regexp con nuovastringa.

Per sostituire con topolino ogni occorrenza di pippo che segua il point è possibile usare il comando M-x replace-string con i due argomenti pippo e topolino. La sostituzione avviene solo nel testo che segue il point, pertanto occorre andare all'inizio del buffer se si vuole effettuare l'operazione sull'intero buffer. Normalmente vengono sostituite tutte le occorrenze fino alla fine del buffer; se si vuole limitare la sostituzione solo ad una parte del buffer si può restringere il buffer prima di effettuare la sostituzione (see Narrowing). Nel modo Transient Mark, quando la regione è attiva, la sostituzione è limitata al testo contenuto nella regione (see Transient Mark).

Quando replace-string termina, il point viene lasciato nella posizione in cui è stata effettuata l'ultima sostituzione, ed il mark viene impostato alla posizione in cui prima si trovava il point (il punto in cui la sostituzione è stata avviata). Per ritornare in tale punto si può usare C-u C-<Spazio>.

Un argomento numerico restringe la sostituzione alle occorrenze che iniziano e terminano con parole intere (ovvero occorrenze precedute e seguite da delimitatori di parola). Il valore dell'argomento è ininfluente.

Sostituzione di espressioni regolari

Il comando M-x replace-string sostituisce le occorrenze di una stringa. Similarmente, il comando M-x replace-regexp sostituisce il testo che soddisfa un'espressione regolare.

Con replace-regexp, la nuova stringa non deve essere necessariamente una costante: essa può fare riferimento a quanto soddisfa l'espressione regolare. \& nella nuova stringa viene espanso con tutto il testo che soddisfa l'espressione regolare. \d nella nuova stringa, dove d è una cifra, viene espanso con quanto soddisfa la d-esima espressione tra parentesi nell'espressione regolare. Per includere \ nella nuova stringa occorre inserire \\. Ad esempio:

M-x replace-regexp <Invio> c[ad]+r <Invio> \&-safe <Invio>

sostituirebbe cadr con cadr-safe e cddr con cddr-safe.

M-x replace-regexp <Invio> \(c[ad]+r\)-safe <Invio> \1 <Invio>

effettuerebbe la sostituzione inversa.

Maiuscole e minuscole nelle sostituzioni

Se il primo argomento di un comando di sostituzione è completamente scritto in minuscolo, Emacs ignora la differenza tra maiuscole e minuscole nell'effettuare la ricerca della stringa da sostituire--posto che case-fold-search sia diverso da nil, altrimenti tale differenza viene presa in considerazione in tutte le ricerche.

Inoltre, se la stringa da sostituire a quella cercata è scritta completamente (o in parte) in minuscolo, il comando preserva le maiuscole quando effettua una sostituzione. Pertanto, il comando

M-x replace-string <Invio> pippo <Invio> topolino <Invio>

sostituisce pippo in minuscolo con topolino, PIPPO in maiuscolo con TOPOLINO e Pippo con l'iniziale maiuscola con Topolino (questi tre casi--tutto minuscolo, tutto maiuscolo e iniziale maiuscola--sono gli unici riconosciuti da replace-string).

Se nel secondo argomento compaiono lettere maiuscole, esse non vengono modificate (ma possono esserlo le lettere minuscole). Se nel primo argomento compaiono lettere maiuscole, il secondo argomento viene inserito senza alcuna modifica, senza conversioni tra maiuscole e minuscole. Similarmente, se la variabile case-replace è impostata a nil, non vengono effettuate conversioni nella sostituzione. Se case-fold-search è impostata a nil, viene presa in considerazione la differenza tra maiuscole e minuscole nella ricerca, ma non viene effettuata alcuna conversione sostituendo la stringa.

Sostituzione interattiva

M-% stringa <Invio> nuovastringa <Invio>

M-x query-replace <Invio> stringa <Invio> nuovastringa <Invio>

Sostituisce alcune occorrenze di stringa con nuovastringa.

C-M-% regexp <Invio> nuovastringa <Invio>

M-x query-replace-regexp <Invio> regexp <Invio> newstring <Invio>

Sostituisce alcune delle occorrenze che soddisfano regexp con nuovastringa.

Non è possibile usare replace-string per sostituire solo alcune delle occorrenze di pippo con topolino. Si può usare invece M-% (query-replace): questo comando ricerca ad una a una ogni occorrenze di pippo, la mostra e chiede se occorre sostituirla. Con un argomento numerico, query-replace prende in considerazione solo le occorrenze che iniziano o terminano con parole intere (sono cioè circondate da delimitatori di parola. Il comando effettua la conversione tra maiuscole e minuscole esattamente come replace-string, posto che case-replace abbia un valore diverso da nil.

Tranne che per il fatto di essere interattiva, query-replace funziona nello stesso modo di replace-string, e query-replace-regexp funziona nello stesso modo di replace-regexp. Questo comando è invocato tramite C-M-%.

Le azioni che si possono intraprendere una volta che viene mostrata un'occorrenza di stringa o di regexp sono:

<Spazio>

per sostituire l'occorrenza con nuovastringa.

<DEL>

per saltare all'occorrenza successiva senza modificare quella corrente.

, (Virgola)

per sostituire l'occorrenza e mostrare il risultato. In seguito, Emacs rimane in attesa di un altro carattere che specifichi quale azione intraprendere. Dato che la sostituzione è già stata effettuata, <DEL> e <Spazio> sono equivalenti in questo contesto: entrambi fanno passare all'occorrenza successiva.

È possibile digitare invece C-r (vedi più avanti) per modificare il testo sostituito. È inoltre possibile digitare C-x u per annullare la sostituzione: ciò provoca l'uscita da query-replace, pertanto occorre digitare C-x <ESC> <ESC> <Invio> per riprendere la sostituzione (see Repetition).

<Invio>

per uscire senza effettuare sostituzioni.

. (Punto)

per sostituire l'occorrenza e poi uscire.

!

per sostituire tutte le occorrenze rimanenti senza chiedere conferma.

^

per tornare indietro alla posizione dell'occorrenza precedente, nel caso la si fosse sostituita per errore. La cosa avviene mediante la consultazione della lista dei mark. Ha senso usare solo un ^ alla volta, in quanto query-replace memorizza solo l'ultima delle sostituzioni effettuate in precedenza.

C-r

per entrare in un livello di editing ricorsivo, nel caso che si voglia modificare l'occorrenza a mano invece di sostituirla con nuovastringa. Una volta terminato, si esce dal livello ricorsivo tramite C-M-c e si procede alla prossima occorrenza. See Recursive Edit.

C-w

per cancellare l'occorrenza ed entrare in un livello di editing ricorsivo come con C-r: in questo modo è possibile digitare del testo che andrà a sostituire l'occorrenza. Una volta terminato, si esce dal livello ricorsivo tramite C-M-c e si procede alla prossima occorrenza.

C-l

per ridisegnare lo schermo. In seguito occorre digitare un altro carattere per specificare l'azione da intraprendere.

C-h

per mostrare un messaggio d'aiuto che riassuma queste opzioni. In seguito occorre digitare un altro carattere per specificare l'azione da intraprendere.

Vi sono altri caratteri che sono equivalenti a quelli sopra elencati: y, n e q sono equivalenti rispettivamente a <Spazio>, <DEL> e a <Invio>.

Tutti gil altri caratteri provocano l'uscita da query-replace, ed essi vengono presi in considerazione come parte di una sequenza di tasti. Pertanto, digitando C-k si esce da query-replace e si cancella la parte rimanente della linea.

Per riprendere un query-replace interrotto si può usare C-x <ESC> <ESC>, che ripete il comando query-replace in quanto quest'ultimo usa il minibuffer per leggere i suoi argomenti. See C-x ESC ESC.

Vedere inoltre Transforming File Names per i comandi di Dired che rinominano, copiano o creano link tramite la sostituzione di espressioni regolari nei nomi dei file.

Altre ricerche

Ecco di seguito altri comandi che trovano occorrenze di un'espressione regolare. Essi operano tutti sul testo compreso tra il point e la fine del buffer, ed ignorano la differenza tra maiuscole e minuscole se l'espressione ricercata non contiene lettere maiuscole e la variabile case-fold-search ha un valore diverso da nil.

M-x occur <Invio> regexp <Invio>

Mostra un elenco delle linee nel buffer che contengono del testo che soddisfa l'espressione regolare regexp. Un argomento numerico specifica il numero di linee contestuali da mostrare prima e dopo ogni linea trovata (il default è nessuna linea). Per limitare la ricerca ad una parte del buffer si può restringere il buffer (see Narrowing).

Il buffer *Occur* contenente l'elenco può essere usato come un menù per andare alle singole occorrenze: è sufficiente fare click con il pulsante centrale del mouse su una delle occorrenza elencate, oppure posizionare su di essa il point e poi premere <Invio>: ciò seleziona il buffer in cui si era effettuata la ricerca e sposta il point nella posizione in cui si trova l'occorrenza selezionata.

M-x list-matching-lines

Sinonimo di M-x occur.

M-x count-matches <Invio> regexp <Invio>

Calcola in numero di occorrenze di seguito al point che soddisfano regexp.

M-x flush-lines <Invio> regexp <Invio>

Cancella ogni linea che segue il point e che contiene un'occorrenza che soddisfa regexp.

M-x keep-lines <Invio> regexp <Invio>

Cancella ogni linea che segue il point e che non contiene un'occorrenza che soddisfa regexp.

Oltre a ciò, è possibile usare grep dall'interno di Emacs per effettuare ricerche su un insieme di file e poi aprire i file che contengono delle occorrenze in sequenza o in un qualsiasi ordine. See Grep Searching.

Comandi per correggere errori

In questo capitolo vengono descritti i comandi che sono particolarmente utili quando si scopre un errore nel testo appena inserito, o quando si cambia idea mentre si sta componendo il testo.

Il comando fondamentale per la correzione di errori di digitazione è quello di annullamento, C-x u o C-_. Esso annulla un solo comando, oppure una parte di un comando (nel caso di query-replace), oppure una serie consecutiva di caratteri auto-inserenti (i normali caratteri digitati che compongono il testo). L'uso ripetuto di C-_ o C-x u provoca l'annullamento di modifiche via via precedenti, fino a raggiungere il limite delle informazioni di annullamento disponibili. See Undo per maggiori informazioni.

• Kill Errors: Comandi per eliminare del testo appena inserito.
• Transpose: Scambiare tra loro due caratteri, parole, linee, liste...
• Fixing Case: Correggere le maiuscole e le minuscole dell'ultima parola digitata.
• Spelling: Usare un correttore ortografico con una parola o con un intero testo.

Eliminare gli errori di digitazione

<DEL>

Elimina l'ultimo carattere immesso (delete-backward-char).

M-<DEL>

Cancella l'ultima parola immessa (backward-kill-word).

C-x <DEL>

Cancella il testo fino all'inizio della frase (backward-kill-sentence).

Il tasto <DEL> (delete-backward-char) è il principale comando di correzione: esso cancella il carattere che si trova prima del point. Quando <DEL> segue il comando relativo ad un carattere auto-inserente, si può pensare ad esso come a qualcosa che cancella tale comando. Tuttavia non bisogna commettere l'errore di pensare che <DEL> sia un modo generico per annullare gli effetti un comando!

Quando l'errore è più lungo di un paio di caratteri, può risultare più conveniente l'uso di M-<DEL> o C-x <DEL>. M-<DEL> cancella il testo fino all'inizio dell'ultima parola inserita, mentre C-x <DEL> elimina il testo fino all'inizio dell'ultima frase. C-x <DEL> è particolarmente utile quando si cambia idea sulla costruzione di una frase nel testo che si sta scrivendo. Sia M-<DEL> che C-x <DEL> copiano il testo cancellato nella lista degli appunti, in modo da poterlo recuperare con C-y e M-y. See Yanking.

M-<DEL> è utile anche quando l'errore è di pochi caratteri, specialmente quando non si sente sicuri di quanto digitato. In tal caso, la correzione mediante <DEL> richiederebbe di osservare lo schermo per vedere cosa si è digitato. Spesso, invece, è più semplice cancellare l'intera parola e riscriverla.

Scambiare testo

C-t

Scambia tra loro due caratteri (transpose-chars).

M-t

Scambia tra loro due parole (transpose-words).

C-M-t

Scambia tra loro due espressioni bilanciate (transpose-sexps).

C-x C-t

Scambia tra loro due linee (transpose-lines).

L'errore comune che consiste nel digitare due caratteri invertiti può essere corretto mediante il comando C-t (transpose-chars). Normalmente, C-t scambia tra loro i caratteri che si trovano sui due lati del point. Tuttavia, quando usato alla fine di una linea, invece di scambiare tra loro l'ultimo carattere ed il carattere di ritorno a capo (che non sarebbe utile), C-t scambia gli ultimi due caratteri della linea. Pertanto, se ci si accorge subito dell'errore è possibile correggerlo immediatamente con C-t. Se non ci si accorge subito è prima necessario posizionare il point tra i due caratteri. Se per sbaglio si è scambiato uno spazio con l'ultimo carattere di una parola, i comandi di spostamento per parole costituiscono un mezzo comodo per posizionare correttamente il point. Negli altri casi, una ricerca inversa (C-r) è probabilmente la miglore soluzione. See Search.

M-t (transpose-words) scambia la parola che si trova prima del point con quella che si trova dopo. Esso sposta il point in avanti di una parola, trascinano con sè anche la parola che precede il point. I caratteri di punteggiatura che si trovano tra le parole non vengono spostati. Ad esempio PIPPO, TOPOLINO viene scambiato in TOPOLINO, PIPPO invece che in TOPOLINO PIPPO,.

C-M-t (transpose-sexps) è un comando analogo che scambia tra loro due espressioni (see Lists), mentre C-x C-t (transpose-lines) scambia intere linee. Essi funzionano come M-t, tranne per quanto riguarda le unità sintattiche considerate.

Un argomento numerico fornito ad un comando di scambio indica quante volte ripetere il comando, ovvero fa in modo che il comando di scambio sposti in avanti il carattere (o parola, o espressione, o linea) che si trova prima del point di altrettanti caratteri (o parole, o espressioni, o linee). Ad esempio, C-u 3 C-t sposta di tre caratteri più in avanti il carattere che si trova prima del point, e quindi p-!-ippo viene trasformato in ipppo. Ciò è equivalente a digitare C-t tre volte. C-u - 4 M-t sposta la parola che precede il point indietro di quattro parole. C-u - C-M-t annulla invece l'effetto di un C-M-t senza argomenti.

Ad un argomento numerico pari a zero viene dato un significato particolare (in quanto un comando con zero ripetizioni non farebbe nulla): esso provoca lo scambio del carattere (o parola, o espressione o linea) che si trova dopo il point con quello che si trova dopo il mark.

Conversioni tra maiuscole e minuscole

M-- M-l

Converte in minuscolo la parola che precede il point. Notare che Meta-- è Meta-meno.

M-- M-u

Converte in maiuscolo la parola che precede il point.

M-- M-c

Converte la parola che precede il point in minuscolo con l'iniziale maiuscola.

Un errore molto comune consiste nel digitare delle parole sbagliando l'uso delle maiuscole o delle minuscole. Per ovviare ad esso si possono usare i comandi M-l, M-u e M-c con un argomento negativo come prefisso: in questo caso essi agiscono sulla parola che precede il point, senza spostarlo. In questo modo, non appena ci si accorge di aver digitato male l'ultima parola, è possibile correggere subito l'uso delle maiuscole/minuscole e procedere con la digitazione. See Case.

Controllo e correzione ortografica

Questa sezione descrive i comandi disponibili per controllare la correttezza dell'ortografia di una parola o di una parte di un buffer. Questi comandi operano in abbinamento col correttore ortografico Ispell, che non fa parte di Emacs.

M-x flyspell-mode

Abilita il modo Flyspell, che evidenzia tutte le parole errate.

M-$

Controlla e corregge l'ortografia della parola che si trova in prossimità del point (ispell-word).

M-<TAB>

Completa la parola che si trova prima del point basandosi su un dizionario (ispell-complete-word).

M-x ispell-buffer

Controlla e corregge ortograficamente ogni parola nel buffer.

M-x ispell-region

Controlla e corregge ortograficamente ogni parola nella regione.

M-x ispell-message

Controlla e corregge ortograficamente ogni parola in un messaggio di posta, con l'esclusione del testo citato.

M-x ispell-change-dictionary <Invio> dizionario <Invio>

Fa ripartire il processo di Ispell, usando dizionario come dizionario.

M-x ispell-kill-ispell

Ferma il processo di Ispell.

Il modo Flyspell effettua un controllo automatico dell'ortografia. Esso agisce controllando le parole a mano a mano che esse vengono inserite o modificate: quando viene trovata una parola non riconosciuta, essa viene evidenziata. Ciò non interferisce con le normali attività, ma quando si vede la parola evidenziata è possibile andare subito a correggerela. Per abilitare (o disabilitare) tale modo è sufficiente digitare M-x flyspell-mode.

Quando il modo Flyspell evidenzia una parola come errata, è possibile fare click su di essa con il tasto centrale del mouse per avere un menù di possibili correzioni e azioni da intraprendere. È comunque possibile correggere a mano la parola nel modo preferito.

Le altre funzionalità di controllo ortografico offerte da Emacs effettuano controlli solo quando lo si richiede esplicitamente, ovvero digitando un comando in tal senso. Effettuare il controllo ortografico di un intero buffer o di parte di esso è utile specialmente quando si sta lavorando su del testo che non è stato scritto nella sessione corrente di Emacs, e che può pertanto contenere un qualsiasi numero di errori ortografici.

Per controllare l'ortografia di una parola in prossimità del point (e, opzionalmente, correggerla) si può usare il comando M-$ (ispell-word). Se la parola non è corretta, il comando offre diverse alternative per quanto riguarda l'azione da intraprendere.

Per controllare l'intero buffer corrente si può usare il comando M-x ispell-buffer, mentre si può usare M-x ispell-region per controllare la regione. Per controllare l'ortografia in un messaggio di posta si può usare M-x ispell-message: esso controlla l'intero buffer, ma non controlla le linee di testo che iniziano con degli spazi, o che comunque appaiano come citate da altri messaggi.

Ogni volta che tali comandi incontrano una parola non corretta, essi si fermano e chiedono quale azione va intrapresa, mostrando una lista di alternative che spesso includono diversi "suggerimenti"--parole simili a quella controllata. A questo punto è necessario digitare un carattere; ecco un elenco delle scelte possibili:

<Spazio>

Ignora la parola--essa continua a essere considerata scorretta, ma essa non viene cambiata.

r nuovaparola <Invio>

Sostituisce la parola (solo per questa occorrenza) con nuovaparola.

R nuovaparola <Invio>

Sostituisce la parola con nuovaparola, e avvia il comando query-replace in modo da sostituirla negli altri punti del buffer se lo si desidera.

cifra

Sostituisce la parola (solo per questa occorrenza) con uno dei suggerimenti mostrati. Ogni suggerimento è accompagnato da una cifra, cos`i da dover solamente digitare tale cifra per inserirla.

a

Accetta la parola scorretta--essa viene trattata come se fosse corretta, ma solo per la sessione corrente.

A

Accetta la parola scorretta--essa viene trattata come se fosse corretta, ma solo per la sessione corrente e per il buffer corrente.

i

Inserisce la parola nel dizionario utente, in modo che Ispell d'ora in poi la consideri corretta, anche in sessioni future.

u

Inserisce la versione in minuscolo di questa parola nel dizionario utente.

m

È simile a i, ma è possibile modificare la parola da inserire nel dizionario.

l parola <Invio>

Ricerca nel dizionario le parole corrispondenti a parola. Esse divengono la nuova lista di "suggerimenti". È in seguito possibile selezionare una di esse digitando una cifra. In parola è possibile usare * come carattere jolly.

C-g

Sospende la sessione di controllo ortografico. È possibile in seguito riprenderla con C-u M-$.

X

Come C-g.

x

Termina la sessione di controllo ortografico e sposta il point nella posizione in cui si trovava prima di iniziare il controllo ortografico.

q

Termina la sessione di controllo ortografico ed elimina il processo di Ispell.

C-l

Ridisegna lo schermo.

C-z

Questo carattere ha il significato usuale di sospendere Emacs o ridurre a icona il frame.

Il comando ispell-complete-word, che nel modo Text e in quelli relativi è associato alla sequenza M-<TAB>, mostra una lista di completamenti basati sulla correzione ortografica. È sufficiente inserire la parte iniziale di una parola e poi digitare M-<TAB>¹⁴; il comando mostra una finestra di possibili completamenti. Per selezionarne uno è sufficiente fare click con il pulsante centrale del mouse, oppure spostare il cursore sopra una parola in tale finestra e digitare <Invio>. See Text Mode.

Una volta iniziato, il processo di Ispell rimane in funzione (rimanendo in attesa di lavoro da svolgere), in modo che successivi comandi di controllo ortografico vengano eseguiti più velocemente. Se si vuole eliminare tale processo si può usare il comando M-x ispell-kill-ispell: ciò solitamente non è necessario, in quanto il processo non consuma risorse se non mentre si effettuano correzioni ortografiche.

Ispell fa uso di due dizionari: un dizionario standard e un dizionario utente. La variabile ispell-dictionary specifica il nome del file da usare come dizionario standard: nil indica di usare il dizionario di default. Il comando M-x ispell-change-dictionary permette di impostare la variabile e poi di far ripartire il processo di Ispell, in modo che esso usi un dizionario diverso.

Gestione dei file

Il sistema operativo memorizza i dati in maniera persistente utilizzando dei file. La maggior parte dei testi modificati da Emacs, pertanto, provengono da un file e vengono memorizzati all'interno di file.

Per lavorare con un file è necessario dire a Emacs di leggerlo e di preparare un buffer che contenga una copia del suo contenuto. Tale operazione viene indicata come aprire¹⁵ un file. Normalmente, i comandi operano sul testo contenuto nel buffer, ovvero sulla copia contenuta in Emacs: le modifiche vengono riportate sul file solo quando si salva il contenuto del buffer nel file.

Oltre che aprire e salvare file, Emacs può cancellare file, copiarli, rinominarli, aggiungere informazioni in fondo ad essi, mantenere più versioni di uno o più file e gestire directory.

• File Names: Come digitare e modificare argomenti che sono nomi di file.
• Visiting: Aprire un file prepara Emacs alla modifica dello stesso.
• Saving: Salvare rende le modifiche persistenti.
• Reverting: La rilettura di un file annulla tutte le modifiche non salvate.
• Auto Save: Il savataggio automatico periodico previene le perdite di dati.

• File Aliases: Gestire file con più nomi.
• Version Control: Sistemi di controllo versione (RCS, CVS and SCCS).
• Directories: Creare, cancellare e visualizzare directory.
• Comparing Files: Trovare differenze tra due file.
• Misc File Ops: Altre cose che si possono fare con i file.
• Compressed Files: Uso di file compressi.
• Remote Files: Uso di file su sistemi remoti.
• Quoted File Names: Uso di caratteri speciali nei nomi dei file.

Nomi di file

La maggior parte dei comandi di Emacs che operano sui file richiedono di introdurre il nome di un file (fanno eccezione il salvataggio e la rilettura, in quanto il buffer ha già in sè il nome del file da usare per queste operazioni): essi vengono specificati tramite il minibuffer (see Minibuffer). Per agevolare l'introduzione di nomi lunghi, è disponibile un meccanismo di completamento. See Completion.

Per la maggior parte delle operazioni esiste un nome di default, usato quando ci si limita a digitare <Invio> con un argomento vuoto. Il nome di default normalmente coincide col nome del file aperto nel buffer: ciò semplifica l'utilizzo dei comandi di Emacs dedicati ai file.

Ogni buffer ha una propria directory di default, normalmente la stessa che contiene il file aperto nel buffer: essa viene usata quando si introduce il nome di un file senza specificare la directory. Se si specifica una directory in maniera relativa (con un nome che non inizi con /), essa viene interpretata relativamente alla directory di default. La directory di default viene memorizzata nella variabile default-directory, che è specifica per ogni buffer.

Ad esempio, se il nome di default per il file è /u/rms/gnu/gnu.tasks, la directory di default è /u/rms/gnu/. Se si digita solamente pippo (non specificando il nome di una directory), esso viene considerato come un'abbreviazione di /u/rms/gnu/pippo. In questo caso, ../../.login indica il file /u/rms/.login, e new/pippo indica il file /u/rms/gnu/new/pippo.

Il comando M-x pwd mostra il nome della directory di default per il buffer corrente, mentre M-x cd lo imposta (ad un valore letto tramite il minibuffer). La directory di default di un buffer viene modificata solo tramite il comando cd. La directory di default di un buffer contenente un file aperto viene inizializzata con la directory che contiene tale file: se si crea un buffer con C-x b, la directory di default viene copiata da quella del buffer in cui è stato digitato il comando.

Quando il minibuffer viene usato per introdurre il nome di un file, in esso viene automaticamente inserita la directory di default. In questo modo si visualizza qual è la directory di default, in modo da poter digitare il nome di un file in modo relativo ed essere certi di avere indicato il file voluto, e si permette di modificare la directory di default per indicarne un'altra. L'inserimento nel minibuffer della directory di default può tuttavia essere inibito impostando la variabile insert-default-directory a nil.

È possibile digitare nel minibuffer un nome di file assoluto, ignorando la presenza della directory di default. Il contenuto finale del minibuffer può sembrare non valido, ma in realtà esso lo è: ad esempio, se il minibuffer contiene /usr/tmp e di seguito si inserisce /x1/rms/pippo si ottiene /usr/tmp//x1/rms/. Emacs, tuttavia, ignora tutto il testo fino alla prima delle due barre oblique (`/') consecutive. Il risultato è quindi /x1/rms/pippo. See Minibuffer File.

Il carattere $ viene usato nei nomi di file per la sostituzione di variabili d'ambiente. Ad esempio, se si è usato in precedenza il comando di shell export PIPPO=rms/hacks per impostare una variabile d'ambiente chiamata PIPPO, è possibile usare /u/$PIPPO/test.c o /u/${PIPPO}/test.c come abbreviazione di /u/rms/hacks/test.c. Il nome della variabile d'ambiente consiste in tutti i caratteri alfanumerici che seguono $; in alternativa, il nome può essere incluso tra parentesi graffe di seguito a $. Occorre tener presente che i comandi di shell che agiscono sulle variabili d'ambiente hanno effetto solo se invocati prima dell'esecuzione di Emacs.

Per accedere ad un file che contenga un carattere $ nel suo nome occorre digitare $$. Questa coppia viene convertita in un singolo $ nel momento in cui viene effettuata la sostituzione di variabili d'ambiente. In alternativa, è possibile quotare l'intero nome del file tramite /: (see Quoted File Names).

La funzione Lisp che effettua la sostituzione è substitute-in-file-name. La sostituzione viene effettuata solo sui nomi di file inseriti tramite il minibuffer.

È infine possibile includere caratteri non ASCII nei nomi di file impostando la variabile file-name-coding-system ad un valore diverso da nil. See Specify Coding.

Aprire file

C-x C-f

Apre un file (find-file).

C-x C-r

Apre un file in sola lettura, impedendo che esso venga modificato (find-file-read-only).

C-x C-v

Apre un file differente al posto di quello aperto l'ultima volta (find-alternate-file).

C-x 4 f

Apre un file in un'altra finestra (find-file-other-window). Non modifica la finestra corrente.

C-x 5 f

Apre un file in un nuovo frame (find-file-other-frame). Non modifica il frame corrente.

M-x find-file-literally

Apre un file senza effettuare conversioni sul suo contenuto.

Aprire un file significa copiare il suo contenuto in un buffer di Emacs, in modo che si possa modificarlo. Emacs crea un nuovo buffer per ogni file che viene aperto: il nome del buffer viene costruito a partire dal nome del file, eliminando le parti che riguardano le directory e mantenendo quindi solo il nome proprio del file. Ad esempio, un file chiamato /usr/rms/emacs.tex viene aperto in un buffer chiamato emacs.tex. Se un buffer con tale nome esiste già, viene generato un nome univoco aggiungedo in fondo <2>, <3>, etc., usando il più piccolo numero che produca il nome di un buffer che non sia già in uso.

La mode line di ogni finestra mostra il nome del buffer visualizzato in essa, in modo da poter sempre sapere cosa si sta modificando.

Le modifiche apportate tramite i vari comandi vengono effettuate nel buffer di Emacs: esse non vengono riportate nel file aperto (o in qualsiasi altro luogo persistente) fino a quando non si salva il buffer. Salvare il buffer significa andare a scrivere il contenuto del buffer nel file ad esso associato. See Saving.

Se un buffer contiene modifiche che non sono state salvate, si dice che il buffer è stato modificato. Ciò è importante, in quanto le modifiche andranno perse se il buffer non viene salvato. Se il buffer è stato modificato, la mode line mostra due asterischi vicino al margine sinistro.

Per aprire un file si può usare il comando C-x C-f (find-file), facendolo seguire con il nome del file che si vuole aprire terminato da <Invio>.

Il nome del file viene letto usando il minibuffer (see Minibuffer), con il consueto default e meccanismo di completamento (see File Names). Fintantoché si è nel minibuffer, è possible annullare il comando C-x C-f digitando C-g.

La conferma della corretta esecuzione di C-x C-f si ha con la visualizzazione del nuovo testo sullo schermo e con la presenza di un nuovo nome di buffer nella mode line. Se il file specificato non esiste e non può essere creato, oppure non può essere letto, nell'area messaggi viene visualizzato un errore.

Se si apre un file già aperto da Emacs, C-x C-f non ne apre un'altra copia, ma semplicemente seleziona il buffer che già lo contiene. Tuttavia, prima di fare questo, Emacs controlla che il file stesso non sia stato modificato da altri programmi dall'ultima volta che lo si è aperto o salvato. Se il file è cambiato viene visualizzato un messaggio d'avvertimento. See Simultaneous Editing.

Per creare un nuovo file è sufficiente aprirlo: Emacs visualizza (New File) nell'area messaggi, ma per tutti gli altri aspetti si comporta come se si fosse aperto un file vuoto. Se si effettuano modifiche e poi le si salva, il file verrà creato.

Emacs riconosce quale convenzione viene usata per separare le linee a partire dal contenuto del file--newline (usati su GNU/Linux e Unix), carriage-return linefeed (usati su sistemi Microsoft), oppure carriage-return e basta (usati su sistemi Macintosh)--e lo converte usando la propria convenzione (newline). Ciò fa parte delle funzionalità di conversione dei sistemi di codifica (see Coding Systems), e permette di lavorare in maniera trasparente con file provenienti da diversi sistemi operativi. Se si modifica il testo e si salva il file, Emacs effettua l'operazione inversa, trasformando nuovamente i newline nel separatore opportuno.

Se il file specificato è una directory, C-x C-f avvia Dired, il browser di Emacs per le directory, cos`i da poter "modificare il contenuto" della directory (see Dired). Dired costituisce un mezzo comodo per cancellare, esaminare o operare in altro modo sui file nella directory specificata. Tuttavia, se la variabile find-file-run-dired vale nil, il tentativo di apertura di una directory provoca un'errore.

Se il nome specificato contiene dei caratteri jolly¹⁶, Emacs apre tutti i file corrispondenti. See Quoted File Names, nel caso si voglia aprire un file il cui nome contiene caratteri jolly.

Se si apre un file che il sistema operativo non permette di modificare, Emacs imposta il buffer a sola lettura, in modo da impedire modifiche che poi risulterebbero problematiche da salvare. È possibile comunque rendere modificabile il buffer tramite C-x C-q (vc-toggle-read-only). See Misc Buffer.

Talvolta si può voler aprire un file in sola lettura per evitare di apportare modifiche accidentali. Ciò può essere fatto con il comando C-x C-r (find-file-read-only).

Se si è aperto un file inesistente per sbaglio (perchè ci si è sbagliati a digitarne il nome) si può usare il comando C-x C-v (find-alternate-file) per aprire il file giusto. C-x C-v è simile a C-x C-f, ma esso prima elimina il buffer corrente (chiedendo prima se si vogliono salvare eventuali modifiche apportate). Nel minibuffer, inoltre, viene inserito per intero il nome del file, con il point posizionato subito dopo la parte indicante la directory: ciò permette di effettuare comodamente le correzioni del caso qualora sia fatto solo un piccolo errore nel digitare il nome.

Se si tenta di aprire un file esistente ma che non può essere letto¹⁷, C-x C-f genera un errore.

C-x 4 f (find-file-other-window) è simile a C-x C-f, tranne che il buffer contenente il file specificato viene visualizzato in un'altra inestra. La finestra che era selezionata prima di digitare C-x 4 f continua a mostrare lo stesso buffer di prima. Se questo comando viene usato quando sullo schermo vi è una sola finestra, essa viene divisa in due, con una finestra che mostra lo stesso buffer di prima e l'altra che mostra il buffer con il file specificato. See Windows.

C-x 5 f (find-file-other-frame) è simile, ma crea un nuovo frame, oppure visualizza un eventuale frame già esistente che contenga il file desiderato. Tale funzionalità è disponibile solo quando si usa un sistema grafico. See Frames.

Se si vuole modificare un file considerandolo come una sequenza di caratteri senza che venga effettuata alcuna decodifica o conversione si può usare il comando M-x find-file-literally. Esso apre un file similarmente a C-x C-f, ma non vengono effettuate conversioni di formato (see Formatted Text), conversioni di codifica (see Coding Systems) o decompressione automatica (see Compressed Files). Se il file specificato è già stato aperto nel modo normale (non letterale), questo comando chiede se si desidera invece riaprirlo senza effettuare conversioni.

Esistono due punti di aggancio particolari che permettono a delle estensioni di modificare l'operazione di apertura di un file. Il tentativo di apertura di un file non esistente avvia le funzioni elencate in find-file-not-found-hooks; questa variabile contiene un elenco di funzioni che vengono invocate una dopo l'altra, fino a quando una di esse ritorna un valore diverso da nil. Ogni tentativo di apertura di un file, indipendentemente dal fatto che esso esista o meno, avvia una dopo l'altra tutte le funzioni elencate in find-file-hooks. In entrambi i casi le funzioni non ricevono alcun parametro, e quelle contenute in find-file-not-found-hooks vengono eseguite per prime. Queste due variabili non sono normali punti d'aggancio, e il loro nome termina in -hooks invece che in -hook per indicare il fatto. See Hooks.

Esistono inoltre diversi modi per specificare automaticamente il modo primario da usare con un determinato file (see Choosing Modes) e per specificare variabili locali relative ad un certo file (see File Variables).

Salvare un file

In Emacs, salvare un buffer significa andare a scrivere il suo contenuto nel file che era stato aperto in quel buffer.

C-x C-s

Salva il buffer corrente nel file ad esso associato (save-buffer).

C-x s

Salva tutti i buffer (o solo alcuni) nei loro rispettivi file (save-some-buffers).

M-~

Marca il buffer corrente come non modificato (not-modified).

C-x C-w

Salva il buffer corrente in un determinato file (write-file).

M-x set-visited-file-name

Imposta il nome con cui verrà salvato il file correntemente aperto.

Quando si desidera salvare il buffer e rendere permanenti le modifiche è sufficiente digitare C-x C-s (save-buffer). Una volta terminata l'operazione, C-x C-s mostra nell'area messaggi un messaggio simile al seguente:

Wrote /u/rms/gnu/gnu.tasks

Se il buffer selezionato non è modificato (non sono state effettuate modifiche da quando è stato aperto o da quando è stato salvato l'ultima volta), il salvataggio non viene effettuato in quanto non avrebbe alcun effetto. C-x C-s mostra invece nell'area messaggi un messaggio come il seguente:

(No changes need to be saved)

Il comando C-x s (save-some-buffers) propone di salvare tutti o alcuni dei buffer modificati: per ogni buffer, esso chiede quale azione intraprendere. Le risposte possibili sono analoghe a quelle di query-replace:

y

Salva questo buffer e prosegui con gli altri.

n

Non salvare questo buffer, ma prosegui con gli altri.

!

Salva questo buffer e tutti gli altri senza fare altre domande.

<Invio>

Esci da save-some-buffers senza salvare i file rimanenti.

.

Salva questo buffer e poi esci da save-some-buffers senza proseguire con gli altri buffer.

C-r

Visualizza il buffer in esame. Una volta usciti dal modo View, si ritorna nuovamente a save-some-buffers, il quale richiede nuovamente quale azione va intrapresa.

C-h

Mostra un messaggio d'aiuto relativo alle opzioni possibili.

C-x C-c (la sequenza di tasti per uscire da Emacs) invoca save-some-buffers e, pertanto, propone le stesse domande.

Se si è alterato un buffer ma non si vogliono salvare le modifiche, è opportuno prestare un po' di attenzione, altrimenti ogni volta che si usa C-x s o C-x C-c si può salvare tale buffer per sbaglio. Una delle precauzioni possibili consiste nell'usare M-~ (not-modified), che marca il buffer come non modificato. Cos`i facendo, nessuno dei comandi di salvataggio vedrà la necessità di salvare il buffer (~ viene spesso usato come simbolo matematico per indicare `non', per cui M-~ è un `meta-non'). Un'alra precauzione consiste nell'usare set-visited-file-name (vedi più avanti) per cambiare il nome del file nel nome di un qualche file che non contenga alcunché di importante. In alternativa, si possono annullare tutte le modifiche apportate al file da quando esso era stato aperto o salvato l'ultima volta, rileggendolo. Questa operazione viene chiamata rilettura See Reverting. È anche possibile annullare tutte le modifiche usando più volte il comando C-x u, tuttavia rileggere un file è più semplice.

M-x set-visited-file-name modifica il nome del file associato al buffer corrente: esso legge il nuovo nome tramite il minibuffer. Esso poi lo imposta nel buffer e modifica opportunamente il nome del buffer (a meno che il nuovo nome non sia già in uso). Di per sè, set-visited-file-name non salva il contenuto del buffer, ma si limita a modificare le informazioni interne nel caso lo si voglia salvare in seguito. A questo proposito, esso marca come modificato il buffer, in modo che che C-x C-s lo salvi sicuramente.

Se si vuole modificare il nome del file associato al buffer e contemporaneamente salvarlo, si può usare C-x C-w (write-file). Esso è del tutto equivalente a set-visited-file-name seguito da C-x C-s. C-x C-s usato su un buffer che non contenga alcun file aperto ha lo stesso effetto di C-x C-w, ovvero viene richiesto il nome di un file, associa tale nome al buffer e lo salva. Il nome di default di un buffer che non contenga alcun file aperto è costruito combinando la directory di default di quel buffer con il nome del buffer stesso.

Se il nuovo nome di file implica l'uso di un modo primario diverso da quello in uso, C-x C-w provoca nella maggior parte dei casi il pasaggio al nuovo modo primario. Anche il comando set-visited-file-name si comporta in tal senso. See Choosing Modes.

Se Emacs sta per salvare un buffer e nota che la data dell'ultima versione presente su disco non corrisponde alla data in cui il file è stato aperto o salvato l'ultima volta, Emacs notifica il fatto, in quanto probabilmente ciò indica un problema causato dall'uso simultaneo del file da parte di più programmi e la cosa richiede l'attenzione dell'utilizzatore. See Simultaneous Editing.

Se la variabile require-final-newline ha un valore diverso da nil, ogni volta che si salva un file Emacs aggiunge un carattere di ritorno a capo alla fine del testo, posto che esso non sia già presente. Il valore di default è nil.

• Backup: Emacs conserva la versione precedente di un file.
• Interlocking: Emacs protegge contro l'uso simultaneo di un file da parte di più utenti o programmi.

File di backup

Nella maggior parte dei sistemi operativi, la riscrittura di un file distrugge automaticamente ciò che il file conteneva in precedenza, pertanto il salvataggio di un file in Emacs provoca la distruzione del suo contenuto precedente--o meglio, lo provocherebbe, ma Emacs copia il vecchio contenuto del file in un altro file, definito come file di backup prima di salvare.

Nella maggior parte dei casi, la variabile make-backup-files determina se è il caso di creare dei file di backup; il suo valore di default è t su quasi tutti i sistemi operativi supportati (per cui Emacs crea file di backup).

Con i file gestiti da un sistema di controllo di versione (see Version +Control), è invece la variabile vc-make-backup-file a determinare tale comportamento; essa ha nil come valore di default, in quanto i file di backup sono superflui quando si memorizzano tutte le versioni precedenti con un sistema di controllo di versione. See VC Workfile Handling.

Il valore di default della variabile backup-enable-predicate evita che vengano creati backup di file che stanno nella directory /tmp.

Se lo si desidera, Emacs può mantenere per ogni file un solo file di backup, oppure una serie di file di backup numerati.

Emacs crea un file di backup per un determinato file solo quando il buffer contenente tale file viene salvato per la prima volta. Indipendentemente dal numero di volte che un file viene salvato, il suo file di backup continua a contenere ciò che conteneva prima di essere aperto. Normalmente ciò significa che il file di backup contiene ciò che il file conteneva prima della sessione corrente di Emacs, tuttavia se si elimina il buffer e poi si apre nuovamente il file, al prossimo salvataggio verrà creato un nuovo file di backup.

È inoltre possibile richiedere esplicitamente la creazione di un file di backup anche se il buffer è già stato salvato. Se si salva il buffer con C-u C-x C-s, tale versione diverrà la copia di backup al prossimo salvataggio. C-u C-u C-x C-s salva il buffer, ma prima fa una copia di backup di quanto il file conteneva in precedenza. C-u C-u C-u C-x C-s fa entrambe le cose: crea una copia di backup di ciò che il file conteneva in precedenza, salva il file e fa in modo che al prossimo salvataggio il contenuto divenga la nuova copia di backup.

• Names: Come sono costruiti i nomi dei file di backup; scegliere tra file di backup singoli o numerati.
• Deletion: Emacs elimina i backup numerati oltre un certo livello.
• Copying: Si possono creare backup copiando o rinominando file.

File di backup singoli e numerati

Se si sceglie di avere un solo file di backup (questo è il comportamento di default), il nome del file di backup è costruito aggiungendo ~ al nome del file su cui si sta lavorando. Il file di backup di eval.c, pertanto, sarebbe eval.c~.

Se si sceglie di avere una serie di file di backup numerati, i nomi dei file di backup vengono invece costruiti aggiungendo .~, un numero e poi un altro ~. I nomi dei file di backup per eval.c sarebbero, pertanto, eval.c.~1~, eval.c.~2~ e cos`i via, fino a nomi come eval.c.~259~ e oltre.

Se non è possibile scrivere i file di backup utilizzando tali nomi, il file di backup viene scritto nella home directory con il nome di %backup%. Può esserci un solo file %backup% alla volta, per cui in questo caso è disponibile solo il backup più recente.

La scelta tra un file di backup singolo e una serie di file di backup numerati è controllata dalla variabile version-control, che può assumere i seguenti valori:

t

Crea una serie di backup numerati.

nil

Crea backup numerati per i file per cui esistono già file di backup numerati, altrimenti crea file di backup singoli.

never

Non creare mai file di backup numerati, ma crea sempre file di backup singoli.

È possibile impostare version-control in modo locale a un buffer, in modo da controllare la creazione di backup relativi al file contenuto in un certo buffer. Ad esempio, il modo Rmail imposta version-control a never per assicurarsi che ci sia sempre e solo una copia di backup di un file Rmail. See Locals.

Se si imposta la variabile d'ambiente VERSION_CONTROL per dire alle varie utility GNU come comportarsi con i file di backup, Emacs si adegua impostando opportunamente la variabile version-control all'avvio. Se il valore della variabile d'ambiente è t o numbered, version-control diventa t. Se il valore è nil o existing, version-control viene impostata a nil. Se il valore è never o simple, version-control viene impostata a never.

Cancellazione automatica dei backup

Al fine di evitare un utilizzo eccessivo dello spazio su disco, Emacs può cancellare automaticamente alcuni dei file di backup che costituiscono una serie di backup numerati. Generalmente, Emacs conserva i primi e gli ultimi backup di una serie, eliminando quelli che stanno nel mezzo. Ciò avviene tutte le volte che si crea un nuovo file di backup.

Le due variabili kept-old-versions e kept-new-versions controllano il modo con cui vengono elmininati tali file: i loro valori rappresentano rispettivamente il numero di backup più vecchi (quelli con il numero più basso) da conservare e il numero di backup più recenti (quelli con il numero più alto) da conservare ogni volta che si crea un nuovo file di backup. Tali numeri vengono utilizzati subito dopo che un nuovo file di backup è stato creato, per cui il backup più recente deve essere incluso nel conteggio effettuato con kept-new-versions. Il valore di default di entrambe le variabili è 2.

Se la variabile delete-old-versions ha un valore diverso da nil, i file di backup in eccesso vengono silenziosamente eliminati. Se vale nil, invece, viene richiesta conferma dell'operazione. Il valore di default è nil.

Il comando . (Punto) di Dired può essere usato per cancellare vecchie versioni. See Dired Deletion.

Copiare o rinominare?

I file di backup possono essere creati copiando il vecchio file, oppure rinominandolo. Ciò comporta una differenza nel momento in cui il vecchio file ha più di un nome¹⁸: se il vecchio file viene rinominato nel file di backup, i nomi alternativi finiscono con l'indicare il file di backup. Se il file viene copiato, i nomi alternativi indicano il nuovo file.

Il metodo utilizzato per creare la copia di backup può inoltre modificare il proprietario ed il gruppo del file. Se il file di backup viene creato per copia, tali attributi non vengono modificati. Se il file di backup viene creato rinominando il vecchio file, il nuovo file diventa di proprietà dell'utente che lo ha modificato, ed il gruppo diventa quello di default (sistemi operativi diversi usano valori differenti per il gruppo di default).

Il fatto che il proprietario cambi è generalmente una buona cosa, in quanto diventa subito evidente chi ha modificato per l'ultima volta il file. Diventa evidente pure chi ha effettuato modifiche in precedenza, in quanto è sufficiente guardare a chi appartengono le copie di backup. Può accadere talvolta di dover lavorare su file il cui proprietario non deve essere modificato: è buona norma in questo caso che i file in questione contengano una lista di variabili locali che imposti backup-by-copying-when-mismatch per quei file (see File Variables).

La scelta tra il copiare e il rinominare è controllata da tre variabili. La creazione di backup rinominando il vecchio file è il comportamento di default. Se la variabile backup-by-copying ha un valore diverso da nil, il file di backup viene creato copiando il vecchio file. Altrimenti, se la variabile backup-by-copying-when-linked ha un valore diverso da nil, allora si utilizza la copia per i file che hanno più di un nome, mentre per quelli che hanno un nome solo vengono rinominati. Se infine la variabile backup-by-copying-when-mismatch ha un valore diverso da nil, allora i file di backup vengono creati per copia ogniqualvolta ciò comporterebbe altrimenti la modifica del proprietario o del gruppo di appartenenza. backup-by-copying-when-mismatch viene impostata automaticamente a t quando Emacs viene avviato dall'amministratore.

Emacs non crea normalmente dei backup per i file gestiti con un sistema di controllo di versione (see Version Control). Le operazioni di check-in e check-out sono di fatto alquanto simili alla creazione di backup come finora descritto. Purtroppo tali operazioni tipicamente invalidano file con nomi multipli, sganciando il file esaminato dagli altri. Ciò non ha nulla a che vedere con Emacs--è il sistema di controllo di versione che opera in tal senso.

Protezione dalla modifica simultanea

La modifica simultanea avviene quando due utenti aprono e modificano lo stesso file, e poi entrambi lo salvano. Se nessuno viene informato del fatto, chiunque abbia salvato per primo le sue modifiche scoprirebbe in seguito che esse sono andate perse.

Su alcuni sistemi, Emacs è in grado di accorgersi subito quando il secondo utente inizia a effettuare modifiche, e lo avvisa immediatamente del fatto. Su tutti i sistemi, comunque, Emacs effettua un controllo all'atto del salvataggio del file, e avvisa se si sta per sovrascrivere le modifiche di un altro utente. È possibile in questo modo prevenire la perdita di dati di altri utenti, scegliendo la giusta azione correttiva invece che procedere per il salvataggio.

Quando si effettua la prima modifica in un buffer di Emacs che contiene un file aperto, Emacs memorizza il fatto che tale file è bloccato da un certo utente (ciò viene fatto creando un link simbolico nella stessa directory con un nome diverso). Emacs elimina il blocco quando si salvano le modifiche. L'idea di fondo è quella per cui il file è bloccato ogni volta che esiste un buffer di Emacs in cui esso è stato aperto e in cui vi sono delle modifiche non ancora salvate.

Se si inizia a modificare il buffer mentre il file aperto è bloccato da altri, ciò comporta una collisione. Quando Emacs si accorge della collisione, esso chiede come deve procedere, invocando la funzione Lisp ask-user-about-lock. È possibile ridefinire questa funzione, in modo da adattarla alle proprie esigenze. La definizione standard di questa funzione richiede la scelta tra tre possibili azioni:

s

"Ruba" il blocco. Chiunque stesse modificando il file perde il blocco dello stesso, che viene dato a chi lo ha "rubato".

p

Procedi. Prosegui e modifica il file, anche se è bloccato da altri.

q

Termina. Ciò provoca un errore (file-locked) e le modifiche che si cercava di apportare al buffer vengono annullate.

Occorre notare che il meccanismo di bloccaggio si basa sul nome del file; se il file ha più nomi, Emacs non si rende conto che i due nomi indicano lo stesso file e non può impedire che due utenti lo modifichino usando due nomi diversi. Tuttavia, basandosi sui nomi è possibile gestire anche le collisioni che si verrebbero a creare con file nuovi (i quali non vengono creati finché non sono salvati).

Alcuni sistemi non sono configurati in maniera tale da permettere ad Emacs di bloccare i file, e vi sono casi in cui i file che indicano un blocco non possono essere creati. In questi casi, Emacs non è in grado di notare subito la collisione, ma esso è ancora in grado di rilevarla nel momento in cui si cerca di salvare un file che è stato modificato nel frattempo da altri.

Se Emacs o il sistema operativo stesso terminano in modo anomalo, possono rimanere dei file spuri che indicano un blocco. È possibile quindi avere occasionalmente dei messaggi riguardanti false collisioni. In questo caso, una volta appurato che la collisione è spuria, è sufficiente usare p per dire ad Emacs di proseguire comunque.

Ogni volta che Emacs salva il contenuto di un buffer, esso controlla innanzitutto la data di ultima modifica del file su disco, verificando che essa non sia diversa da quella in cui il file è stato aperto o salvato per l'ultima volta. Se le date non coincidono, ciò implica che in qualche modo sono state effettuate modifiche nel frattempo, ed esse possono andare perse se si prosegue con il salvataggio. Per prevenire questa situazione, Emacs avverte l'utente con un messaggio e chiede conferma prima di proseguire con il salvataggio. Vi possono essere situazioni in cui già si conoscono i motivi per cui il file è stato modificato, ed un salvataggio non arreca danni: è sufficiente quindi digitare yes e procedere. Altrimenti, è il caso di annullare il salvataggio con C-g e investigare ulteriormente.

La prima cosa da fare quando si è avvertiti di una collisione è quella di esaminare il contenuto della directory con C-u C-x C-d (see Directories). Il proprietario del file mostra chiaramente l'autore delle modifiche. Sarebbe quindi il caso di contattarlo per avvisarlo del fatto. Spesso, il passo successivo consiste nel salvare il contenuto del buffer di Emacs in un file diverso, e usare diff per confrontare i due file.

Rileggere un file

Se si sono effettuate numerose modifiche ad un file e poi si cambia idea, è possibile annullarle tutte in una volta andando a rileggere la versione precedente del file dal disco. Per fare questo si può usare M-x revert-buffer, che agisce sul buffer corrente. Dato che rileggere un buffer per errore può portare alla perdita di una grande quantità di modifiche, è necessario confermare l'operazione digitando yes.

revert-buffer mantiene il point alla stessa distanza (misurata in caratteri) dall'inizio del file. Se il file era stato modificato solo leggermente, ci si troverà più o meno nello stesso punto di prima. Se invece si sono fatte numerose modifiche, è possibile ritrovarsi in un punto del testo completamente diverso.

La rilettura imposta il buffer come "non modificato", fino a quando non si effettua un'altra modifica.

Possono essere riletti anche alcuni tipi di buffer il cui contenuto, invece che file, riflette delle basi di dati, come i buffer di Dired. Per questi, la rilettura implica il ricalcolo del loro contenuto a partire dal contenuto della base di dati. I buffer creati esplicitamente con C-x b ¹⁹ non possono essere riletti: revert-buffer produce un errore qualora si tenti di farlo.

Quando si sta lavorando ad un file che cambia automaticamente e di frequente--ad esempio un file di log di un processo in esecuzione--può essere utile fare in modo che Emacs lo rilegga senza chiedere conferma quando si riapre nuovamente il file con C-x C-f.

Per ottenere questo comportamento è sufficiente impostare la variabile revert-without-query ad una lista di espressioni regolari. Quando il nome di un file soddisfa una di queste espressioni regolari, find-file e revert-buffer lo rileggeranno automaticamente se esso è cambiato--posto che il buffer stesso non si stato modificato (se il buffer è stato modificato, sarebbe sbagliato annullare le modifiche).

Salvataggio automatico

Emacs salva autonomamente di tanto in tanto tutti i file aperti (basandosi sul numero di tasti digitati): ciò viene indicato come salvataggio automatico. Ciò limita notevolmente la quantità di lavoro perso nell'eventualità di una terminazione anomala di Emacs o del blocco del sistema.

Ogni volta che Emacs determina che è ora di effettuare un salvataggio automatico, esso prende in considerazione ciascun buffer, verifica che il salvataggio automatico sia abilitato per il buffer e che esso sia stato modificato dall'ultimo salvataggio automatico. In caso positivo, Emacs procede al salvataggio automatico e mostra il messaggio Auto-Saving... nell'area messaggi. Gli errori che si verificano durante il salvataggio automatico sono intercettati in modo da non interferire con l'esecuzione dei comandi che si stanno digitando.

• Files: I file dove vengono salvate automaticamente le modifiche effettuate fino a quando non si salva esplicitamente il file.
• Control: Controllare come e quando salvare automaticamente.
• Recover: Ripristinare il testo dai file salvati automaticamente.

I file di salvataggio automatico

Il salvataggio automatico normalmente non salva le modifiche direttamente nel file su cui si sta lavorando, in quanto non è desiderabile salvare un programma che si trovi in uno stato inconsistente (ad esempio, dopo aver fatto solo la metà delle modifiche pianificate). Il salvataggio automatico viene invece effettuato in un file diverso, ed il file aperto viene modificato solo quando si richiede esplicitamente il salvataggio (ad esempio con C-x C-s).

Normalmente, il nome del file usato dal salvataggio automatico viene costruito aggiungendo # all'inizio e alla fine del nome del file aperto. Ad esempio, un buffer che contiene il file pippo.c viene salvato automaticamente nel file #pippo.c#. La maggior parte dei buffer che non contengono file aperti effettuano il salvataggio automatico solo dietro esplicita indicazione. Quando essi vengono salvati automaticamente, il nome del file viene costruito aggiungendo #% all'inizio del nome del buffer e # alla fine. Ad esempio, il buffer *mail* in cui si compongono i messaggi da spedire per posta viene salvato automaticamente nel file #%*mail*#. I nomi vengono generati in questo modo fintantoché non si ridefinisce parte di Emacs per produrre qualcosa di differente (le funzioni make-auto-save-file-name e auto-save-file-name-p). Il nome del file da usare per il salvataggio automatico di un determinato buffer viene determinato quando si attiva il salvataggio automatico in quel buffer.

Quando si elimina una grande quantità del testo presente in un buffer molto grande, il salvataggio automatico viene disabilitato. Ciò avviene in quanto, se si è cancellato il testo per sbaglio, il file di salvataggio automatico può tornare utile se contiene il testo cancellato. Per abilitare nuovamente il salvataggio automatico in seguito a questo, è sufficiente salvare il buffer con C-x C-s, oppure usare C-u 1 M-x auto-save.

Se si vuole che il salvataggio automatico venga effettuato direttamente nel file aperto, è sufficiente impostare la variabile auto-save-visited-file-name ad un valore diverso da nil. In questo caso non vi è nessuna differenza tra il salvataggio automatico ed il salvataggio esplicito.

Il file di salvataggio automatico di un determinato buffer viene cancellato quando si salva esplicitamente il file. Per impedire ciò è necessario impostare a nil la variabile delete-auto-save-files. Se si modifica il nome del file aperto tramite C-x C-w o set-visited-file-name, il nome del file di salvataggio automatico viene modificato di conseguenza.

Configurare il salvataggio automatico

Se il valore della variabile auto-save-default è diverso da nil, ogni volta che si apre un file viene attivato nel il salvataggio automatico per quel file (ciò tuttavia non avviene se Emacs è in modalità batch; see Entering Emacs). Il valore di default di questa variabile è t, per cui viene effettuato il salvataggio automatico dei buffer che contengono file aperti. Il salvataggio automatico può essere abilitato o disablitato per un qualsiasi buffer con il comando M-x auto-save-mode. Come per gli altri comandi relativi ai modi secondari, M-x auto-save-mode con un argomento positivo abilita il salvataggio automatico, con un argomento negativo lo disabilita e senza argomenti inverte lo stato.

Emacs effettua il salvataggio automatico basandosi sul numero di caratteri digitati dall'ultimo salvataggio automatico. Tale numero è specificato dalla variabile auto-save-interval, che ha 300 come default.

Il salvataggio automatico viene eseguito anche quando si interrompe la digitazione per un certo periodo di tempo. La variabile auto-save-timeout indica quanti secondi Emacs deve attendere prima di effettuare un salvataggio automatico (e magari effettuare una garbage collection²⁰). Di fatto, l'intervallo è più lungo se il buffer è molto grande; questo approccio euristico mira a minimizzare il disturbo provocato dal salvataggio automatico di file molto estesi, operazione che richiede una quantità di tempo apprezzabile. Il salvataggio automatico effettuato durante le pause permette di essere certi che il lavoro venga salvato se ci si allontana dal terminale, e permette anche di evitare alcuni dei salvataggi automatici mentre si sta digitando.

Emacs effettua un salvataggio automatico ogni volta che termina con un errore fatale: ciò include la terminazione del job di Emacs da shell tramite comandi come kill %emacs, o la disconnessione della linea telefonica o della connessione di rete.

È infine possibile richiedere esplicitamente un salvataggio automatico tramite il comando M-x do-auto-save.

Ripristinare i dati salvati automaticamente

È possibile ripristinare i dati persi usando il contenuto di un file salvato automaticamente: ciò avviene tramite il comando M-x recover-file <Invio> file <Invio>, che provoca l'apertura di file e (dopo aver chiesto conferma) il ripristino del contenuto a partire dal file #file#. È in seguito possibile salvare il contenuto ripristinato tramite C-x C-s. Ad esempio, per ripristinare il file pippo.c a partire dal file salvato automaticamente #pippo.c#:

M-x recover-file <Invio> pippo.c <Invio>
yes <Invio>
C-x C-s

Prima di chiedere conferma, M-x recover-file mostra un elenco che descrive il file specificato e il file di salvataggio automatico, in modo da poter confrontare le loro date e le loro dimensioni. Se il file salvato automaticamente è più vecchio del file specificato, esso non viene mostrato.

Se Emacs o il sistema terminano in modo anomalo, è possibile ripristinare tutti i file su cui si stava lavorando a partire dai file salvati automaticamente mediante il comando M-x recover-session. Esso mostra inizialmente un elenco delle sessioni interrotte: basta spostare il point sulla sessione desiderata e digitare C-c C-c.

In seguito, per ognuno dei file su cui si stava lavorando nella sessione interrotta, recover-session chiede come procedere, proponendo di ripristinare il file. Se si risponde y, viene invocato recover-file, che procede nel modo usuale (mostrando il file originale e il file salvato automaticamente, e chiede ancora conferma del ripristino).

Una volta che recover-session ha terminato, i file che si è deciso di recuperare sono presenti nei buffer di Emacs. Sarebbe il caso a questo punto di salvarli: solo così facendo--salvandoli--essi vengono aggiornati.

Lo stato delle sessioni interrotte in modo anomalo viene memorizzato in file chiamati ~/.saves-pid-hostname, in modo da ripristinare una sessione. La parte ~/.saves di questi nomi è definita nella variabile auto-save-list-file-prefix: modificandola (nel proprio file .emacs), è possibile modificare la directory ove vengono memorizzati i file di sessione, tuttavia sarà necessario ridefinire anche la funzione recover-session in modo che vada a cercarli nel nuovo posto. Se si imposta auto-save-list-file-prefix a nil nel proprio file .emacs, non vengono crati file di sessione.

Alias per i nomi di file

I link simbolici e gli hard link rendono possibile l'accesso allo stesso file usando nomi diversi. Gli hard link sono nomi alternativi che si riferiscono direttamente al file; tutti i nomi sono egualmente validi, e nessuno di essi viene preferito agli altri. Al contrario, un link simbolico è una sorta di alias: quando il file pippo è un link simbolico al file topolino, è possibile fare riferimento al file tramite entrambi i nomi, ma topolino è il vero nome, mentre pippo è solamente un alias. Casi più complessi si presentano quando un link simbolico punta ad una directory.

Se si apre due volte lo stesso file con due nomi diversi, normalmente Emacs crea due buffer, ma avverte della situazione.

Se si vuole evitare di aprire lo stesso file in due buffer diversi con due nomi diversi, è sufficiente impostare la variabile find-file-existing-other-name ad un valore diverso da nil. In questo caso, find-file usa il buffer già esistente, indipendentemente da quale nome viene specificato per il file.

Se la variabile find-file-visit-truename ha un valore diverso da nil, allora il nome di file associato ad un buffer è il vero nome (ottenuto sostituendo il nome dei link simbolici con quello a cui essi puntano) invece del nome specificato. Impostare find-file-visit-truename in tal modo implica anche gli effetti di find-file-existing-other-name.

Controllo di versione

I sistemi di controllo di versione sono applicativi in grado di memorizzare più versioni di un file sorgente, solitamente memorizzando una volta sola le parti non modificate. I sistemi di controllo di versione memorizzano inoltre informazioni storiche, quali la data in cui è stata creata ogni versione, l'autore e una descrizione di cosa è stato cambiato in tale versione.

L'interfaccia di Emacs a tali sistemi si chiama VC. I suoi comandi operano con tre sistemi di controllo di versione--RCS, CVS e SCCS. Il progetto GNU raccomanda RCS e CVS, che sono free software e sono disponibili presso la Free Software Foundation.

• Introduction to VC: Come funziona in generale il controllo di versione.
• VC Mode Line: La mode line mostra le informazioni sulla versione.
• Basic VC Editing: Come lavorare su file sotto controllo di versione.
• Old Versions: Esaminare e confontare vecchie versioni.
• Secondary VC Commands: Comandi usati meno frequentemente.
• Branches: Più linee di sviluppo.
• Snapshots: Insiemi di file trattati come un'unità.
• Miscellaneous VC: Vari altri comandi e funzionalità di VC.
• Customizing VC: Variabili che influenzano il comportamento di VC.

Introduzione al controllo di versione Version Control

VC permette di usare da Emacs un sistema di controllo di versione, integrando le operazioni di modifica con quelle di versionamento. VC fornisce un'interfaccia unificata ai sistemi di controllo di versione, in modo da poterli usare nello stesso modo indipendentemente dal particolare sistema in uso.

Questa sezione presenta un introduzione generale al controllo di versione ed ai sistemi supportati da VC. È possibile saltare questa sezione se si ha già familiarità con i sistemi che si intendono usare.

• Version Systems: Sistemi di controllo di versione supportati.
• VC Concepts: Parole e concetti riguardanti il controllo di versione.

Sistemi di controllo di versione supportati

Attualmente, VC può funzionare con tre diversi sistemi di controllo di versione, o "back-end": RVS, CVS e SCCS.

RCS è un sistema di controllo versione free che è disponibile presso la Free Software Foundation. È forse il più maturo dei back-end supportati, ed i comandi di VC sono concettualmente molto vicini a RCS. Quasi tutto ciò che si può fare con RCS è accessibile tramite VC.

CVS utilizza RCS come base²¹, e lo estende in maniera da permettere una gestione più sofisticata dei rilasci e l'utilizzo concorrente da parte di più utenti. Quando usato con CVS, VC offre supporto per le operazioni più comuni, tuttavia per alcune operazioni meno comuni è ancora necessario utilizzare CVS da riga di comando. Occorre tener presente inoltre che prima di usare CVS occorre preparare un repository, (e questo è un soggetto troppo complesso per essere trattato in questa sede).

SCCS è un sistema di controllo di versione proprietario, tuttavia molto usato. In termini di funzionalità è il meno ricco dei tre sistemi supportati da VC: VC compensa la mancanza di alcune di esse (gli snapshot, ad esempio) implementandole al suo interno, ma altre funzionalità (quali i branch multipli) non sono disponibili con SCCS. È consigliabile usare SCCS solo se per qualche motivo non si può usare RCS.

Concetti di base sul controllo di versione

Quando un file si trova sotto controllo di versione, si dice anche che esso è registrato nel sistema di controllo di versione. Ogni file registrato ha un master file corrispondente, che rappresenta lo stato attuale del file con in aggiunta le informazioni sulle modifiche effettuate--quanto basta per ricostruire la versione corrente o una qualsiasi delle versioni precedenti. Solitamente, nel master file vengono memorizzate anche informazioni di log per ogni versione: esse descrivono a parole cosa è stato modificato in tale versione.

Il file che viene mantenuto sotto controllo di versione è talvolta indicato come il file di lavoro corrispondente ad un determinato master file. Il file di lavoro viene utilizzato e modificato come un comune file (con SCCS e RCS è necessario bloccare il file prima di iniziare a modificarlo): dopo aver apportato una serie di modifiche, si effettua il check-in del file, operazione che memorizza le modifiche nel master file insieme ad una voce di log.

Con CVS vi sono solitamente più file di lavoro che corrispondono ad un unico master file--spesso, ogni utente ha la propria copia. È possibile usare RCS in questo modo, tuttavia non è la procedura usuale.

Un sistema di controllo di versione ha tipicamente un meccanismo per coordinare vari utenti che desideraino apportare modifiche allo stesso file. Un metodo consiste nel bloccare il file²² (analogo al meccanismo usato da Emacs per rilevare l'utilizzo simultaneo di un file da parte di più utenti, ma ben distinto da esso). Un altro metodo consiste nell'unire le modifiche con quelle effettuate da altri utenti quando si effettua il check-in.

Utilizzando il primo metodo, i file di lavoro sono normalmente a sola lettura, in modo da non poterli modificare, e si chiede al sistema di controllo di versione di preparare un file di lavoro modificabile, bloccandolo: solo un utente alla volta può effettuare tale operazione. Quando si effettua il check-in delle modifiche, il file viene sbloccato ed esso torna ad essere a sola lettura. Ciò permette ad altri utenti di bloccare il file e di effettuare ulteriori modifiche. SCCS blocca sempre i file; normalmente, ciò viene fatto anche da RCS.

L'alternativa per RCS consiste nel permettere ad ogni utente di modificare il file di lavoro in qualsiasi momento. In questo caso non è più necessario bloccare il file, anche se comunque ciò è effettuabile. La registrazione di una nuova versione viene in ogni caso effettuata tramite il check-in del file.

CVS normalmente permette ad ogni utente di modificare la propria copia del file di lavoro, ma richiede che tali modifiche vengano unite a quelle degli altri utenti quando si effettua il check-in. CVS, tuttavia, può essere configurato in modo da richiedere il blocco dei file (see Backend Options).

VC e la mode line

Se si apre un file che è gestito da un sistema di controllo di versione, Emacs indica il fatto sulla mode line. Ad esempio, RCS-1.3 significa che tale file viene gestito con RCS, e che la versione corrente è la 1.3.

Il carattere che sta tra il nome del back-end e il numero di versione indica lo stato del file dal punto di vista del sistema di controllo di versione: - significa che il file di lavoro non è stato bloccato, oppure non è stato modificato (a seconda che sia necessario o meno bloccare il file per modificarlo). : indica che il file è stato bloccato, oppure che è stato modificato. Se il file è bloccato da un altro utente (ad esempio rossi), ciò viene mostrato come RCS:rossi:1.3.

Operazioni di base con VC

Il comando principale di VC è un comando "tuttofare" che effettua sia il blocco di un file che il check-in, a seconda del contesto.

C-x C-q

C-x v v

Effettua sul file l'operazione logicamente successiva per ciò che riguarda il controllo di versione.

A dire il vero, il comando per questa operazione è vc-next-action, associato normalmente a C-x v v, tuttavia il normale significato di C-x C-q è quello di rendere modificabile un buffer a sola lettura e viceversa; tale comando è stato esteso in modo da effettuare la corretta operazione nel caso si lavori su un file sotto controllo di versione. Digitare C-x C-q su un file registrato è come digitare C-x v v.

L'operazione effettuata con questo comando dipende dallo stato in cui si trova il file e dal fatto che il sistema di contrllo di versione richieda o meno di bloccare i file. SCCS e RCS normalmente lo richiedono, a differenza di CVS che, normalmente, non lo richiede.

• VC with Locking: RCS nel suo modo di default, SCCS e, opzionalmente, CVS.
• Without Locking: Il modo di default per CVS.
• Log Buffer: Funzionalità disponibili nei buffer relativi alle informazioni di log.

Controllo di versione con blocco dei file

Se è richiesto il blocco dei file (come con SCCS, o con RCS nel suo modo di default), C-x C-q blocca il file, oppure ne effettua il check-in:

• Se il file non è bloccato, C-x C-q lo blocca e lo rende scrivibile, in modo da poterlo modificare.
• Se il file è bloccato e contiene modifiche, C-x C-q effettua il check-in delle modifiche. Per fare questo, viene prima richiesta l'introduzione delle informazioni di log per la nuova versione. See Log Buffer.
• Se il file è bloccato ma non sono state effettuate modifiche, C-x C-q sblocca il file e lo rende nuovamente a sola lettura.
• Se il file è bloccato da un altro utente, C-x C-q chiede se occorre "rubare il blocco" all'altro utente. Se si risponde in maniera affermativa, il file bloccato diventa di proprietà di chi lo ha "rubato", e viene spedito un messaggio a colui che lo aveva bloccato in precedenza per informarlo dell'accaduto.

Queste regole vengono applicate anche quando si usa CVS con il blocco dei file, tranne che non vi è il concetto di "rubare" un blocco.

Controllo di versione senza blocco

Quando non è richiesto il blocco dei file di lavoro--il comportamento di default per CVS--tali file sono sempre modificabili: non è necessario effettuare alcuna operazione prima di modificare un file. L'indicatore di stato sulla mode line è - se non sono ancora state apportate modifiche, e diventa : non appena si salvano quelle eventualmente apportate.

Ecco come si comporta C-x C-q con CVS:

• Se un altro utente ha effettuato il check-in delle modifiche nel master file, Emacs chiede se si vogliono incorporare tali modifiche nel proprio file di lavoro (see Merging). Ciò è necessario prima di poter effettuare il check-in delle proprie modifiche.
• Se non ci sono nuove modifiche nel master file, ma si sono effettuate modifiche nel proprio file di lavoro, C-x C-q effettua il check-in delle modifiche. Per fare questo, viene prima richiesta l'immissione delle informazioni di log per la nuova versione. See Log Buffer.
• Se il file non è stato modificato, C-x C-q non fa nulla.

Queste regole vengono applicate anche quando si usa RCS nella modalità che non richiede il blocco dei file, tuttavia l'incorporazione automatica delle modifiche effettuate nel master file non è implementata: sfortunatamente ciò significa che non si viene informati se un altro utente ha effettuato il check-in di modifiche effettuate dopo che si aveva cominciato a modificare il file. In questo caso, il check-in delle proprie modifiche provocherebbe la perdita delle modifiche effettuate dall'altro utente (tuttavia esse rimangono memorizzate nella versione precedente, per cui non vanno perse del tutto). È necessario quindi verificare che la versione corrente non sia stata modificata da altri prima di effettuare il check-in. Si spera comunque di poter implementare nelle future versioni di Emacs un meccanismo adeguato che elimini tale rischio.

In aggiunta a ciò, è possibile bloccare il file anche se RCS viene usato in questa modalità, sebbene ciò non sia necessario: C-x C-q su un file non modificato blocca tale file, esattamente come avviene con RCS con il suo modo di default.

Funzionalità del buffer di log

Quando si effettua il check-in delle modifiche, C-x C-q richiede l'immissione delle informazioni di log: viene visualizzato un buffer chiamato *VC-Log* nel quale esse andranno digitate. Una volta terminato, è sufficiente digitare C-c C-c in tale buffer per effettuare l'operazione di check-in vera e propria.

Per non effettuare il check-in è sufficiente non digitare C-c C-c in tale buffer. Si può passare ad altri buffer e continuare normalmente il proprio lavoro. Fintantoché non si tenta di effettuare il check-in di un altro file, il buffer *VC-Log* non viene alterato, e vi si può tornare in qualsiasi momento per effettuare il check-in.

Se si effettuano modifiche su diversi file per lo stesso motivo, è spesso utile specificare le stesse informazioni di log per ognuno di essi. A tale scopo sono disponibili i comandi M-n, M-p, M-s e M-r, che permettono di recuperare informazioni di log usate di recente (in maniera similare a quanto avviene per i comandi digitati in precedenza nel minibuffer, con la differenza che in questo caso essi sono disponibili al di fuori di esso).

Tutte le volte che si effettua il check-in di un file, il buffer contenente le informazioni di log viene impostato con il modo primario VC Log, cosa che comporta l'esecuzione delle funzioni specificate in text-mode-hook e vc-log-mode-hook. See Hooks.

Esaminare e confrontare versioni precedenti

Una delle funzionalità più utili di un sistema di controllo di versione è la possibilità di esaminare una versione qualsiasi di un file, o di confrontare due versioni.

C-x v ~ versione <Invio>

Esamina in un buffer a parte la versione specificata del file aperto.

C-x v =

Confronta il contenuto del buffer corrente con l'ultima versione del file di cui si è fatto il check-in

C-u C-x v = file <Invio> v. vecchia <Invio> v. nuova <Invio>

Confronta le due versioni di file specificate.

C-x v g

Mostra a colori il risultato del comando CVS annotate.

Per esaminare in toto una vecchia versione è sufficiente aprire il file e poi digitare C-x v ~ versione <Invio> (vc-version-other-window). Ciò pone il testo della vecchia versione in un file chiamato nomefile.~versione~, che poi viene aperto in un buffer in una finestra a parte (con RCS è inoltre possilbile selezionare una vecchia versione e poi creare un branch a partire da essa. See Branches).

Di solito, comunque, è più utile confrontare due versioni del file tramite il comando C-x v = (vc-diff). Senza argomenti, C-x v = effettua il confronto tra il contenuto attuale del buffer (salvandolo se necessario) e l'ultima versione di cui si è effettuato il check-in. C-u C-x v = (con un argomento numerico) richiede invece l'introduzione del nome di un file e di due versioni dello stesso, e poi procede a confrontarle.

Se invece del nome di un file registrato si specifica il nome di una directory, C-u C-x v = effettua il confronto tra le due versioni specificate di tutti i file registrati che si trovano in quella directory e nelle sue sottodirectory.

È possibile specificare la versione tramite il suo numero; non specificando nulla si indica il contenuto corrente del file di lavoro (che può essere differente da tutte le altre versioni). Al posto di una o di entrambe le versioni è possibile inoltre specificare il nome di uno snapshot (see Snapshots).

Questo comando esegue l'utility diff, utilizzando le opzioni indicate nella variabile diff-switches. Esso mostra il risultato in un buffer a parte in un'altra finestra. A differenza di M-x diff, il comando C-x v = non cerca di trovare le differenze tra versioni di cui si è fatto il check-in, perchè esse normalmente non esistono sotto forma di file quando si vuole confrontarle. Esse, di fatto, esistono unicamente all'interno del master file. See Comparing Files per maggiori informazioni su come confrontare file diversi.

Per i file controllati da CVS è possibile mostrare il risultato del comando CVS "annotate", usando colori per facilitare la lettura: è sufficiente digitare il comando M-x vc-annotate. Il colore rosso indica le cose più recenti, il blu quelle più vecchie e i colori intermedi indicano versioni intermedie. Un argomento numerico n indica un fattore di scala per quanto riguarda il tempo: esso fa s`i che ogni colore copra un periodo n volte più ampio.

Altri comandi di VC

Questa sezione tratta i comandi di VC usati meno frequentemente, ad esempio una volta al giorno.

• Registering: Porre un file sotto controllo di versione.
• VC Status: Vedere lo stato dei file.
• VC Undo: Annullare le modifiche prima o dopo un check-in.
• VC Dired Mode: Vedere quali sono i file sotto controllo di versione.
• VC Dired Commands: Comandi disponibili in un buffer di VC Dired.

Registrare un file sotto VC

È possible porre un qualsiasi file sotto controllo di versione semplicemente aprendolo e poi digitando C-x v i (vc-register).

C-x v i

Registra sotto contollo di versione il file aperto.

Per porre un file sotto controllo di versione, Emacs deve sapere quale sistema di controllo di versione deve essere usato. È possibile specificare una scelta impostando la variabile vc-default-back-end a RCS, CVS o SCCS. Altrimenti, se esiste una sottodirectory chiamata RCS, o SCCS o CVS, Emacs usa il rispettivo sistema di controllo. In assenza di altre indicazioni, Emacs usa RCS se esso è installato, altrimenti SCCS.

Se il sistema di controllo di versione richiede il blocco dei file di lavoro, C-x v i lascia il file sbloccato e a sola lettura, ed è quindi necessario digitare C-x C-q se si vuole iniziare a modificarlo. Con CVS è necessario invece effettuare il check-in della prima versione del file, sempre digitando C-x C-q.

La versione iniziale per un file appena registrato è per default 1.1. È possibile specificare un valore differente impostando la variabile vc-default-init-version, oppure è possibile passare un argomento numerico a C-x v i, facendo in modo che esso richieda l'immissione nel minibuffer di un particolare numero di versione iniziale.

Se vc-initial-comment ha un valore diverso da nil, C-x v i richiede l'immissione di un commento iniziale che descriva il contenuto del file. L'immissione del commento iniziale avviene in modo identico all'immisione delle informazioni di log (see Log Buffer).

Comandi per vedere lo stato di VC

C-x v l

Mostra lo stato riguardante il controllo di versione e le informazioni riguardanti lo stato delle modifiche.

Per visualizzare dettagliatamente lo stato di versionamento di un file è sufficiente digitare C-x v l (vc-print-log). Esso mostra in un buffer a parte l'elenco riassuntivo delle modifiche effettuate al file corrente, incluso il testo delle informazioni di log.

Annullare operazioni di VC

C-x v u

Ripristina il buffer e il file all'ultima versione di cui si è fatto il check-in.

C-x v c

Rimuove dal master file l'ultimo cambiamento di cui si è fatto il check-in. Di fatto, annulla l'ultimo check-in.

Per annullare tutte le modifiche apportate e ritornare all'ultima versione di cui si è fatto il check-in si può usare il comando C-x v u (vc-revert-buffer). Esso lascia sbloccato il file, per cui (se necessario) occorre bloccare nuovamente il file prima di modificarlo. C-x v u chiede conferma, a meno che non sia stata effettuata alcuna modifica rispetto alla versione che si vuole ripristinare.

C-x v u è inoltre il comando da usare per sbloccare un file qualora lo si sia bloccato e poi si decida di non volerlo modificare.

Per annullare una modifica di cui si è già fatto il check-in è necessario usare il comando C-x v c (vc-cancel-version). Questo comando rimuove tutte le informazioni riguardanti l'ultima versione posta in check-in. C-x v c propone inoltre di ripristinare il buffer ed il file di lavoro a partire dalla penultima versione posta in check-in (quella che precede la versione eliminata).

Se si riponde no, VC mantiene le modifiche nel buffer e blocca il file. Ciò è utile quando si è effettuato il check-in di una modifica ed in seguito si scopre di aver commesso un errore banale. È quindi possibile annullare il check-in, correggere l'errore e quindi effettuare nuovamente il check-in.

Quando C-x v c non ripristina il buffer, viene annullata l'espansione di tutte le intestazioni di versionamento (see Version Headers), in quanto il contenuto del buffer non corrisponde più ad alcuna versione esistente. Se si effettua nuovamente il check-in, le intestazioni verranno nuovamente espanse con il numero di versione opportuno.

È tuttavia impossibile annullare automaticamente l'espansione delle intestazioni $Log$ di RCS. Se si fa uso di tale funzionalità, è necessario procedere a mano, cancellando la voce relativa alla versione appena eliminata.

Occorre prestare attenzione nell'usare C-x v c, in quanto è facile perdere quantità significative di lavoro. Per limitare i rischi, esso richiede sempre conferma tramite yes. Notare che questo comando è disabilitato con CVS, in quanto la cancellazione di versioni è molto pericolosa e sconsigliata con tale sistema.

Dired e VC

Quando si sta lavorando su un progetto molto vasto, risulta spesso utile trovare quali siano i file cambiati in un intero ramo di directory, o vedere tutto in una volta lo stato di tutti i file sotto controllo di versione ed effettuare operazioni su insiemi di file. È possibile usare il comando C-x v d (vc-directory) per ottenere un elenco di file significativi dal punto di vista del controllo di versione.

C-x v d crea un bufer che usa il modo VC Dired. Esteriormente, esso è simile ad un comune buffer Dired (see Dired), tuttavia esso mostra solo file degni di attenzione (quelli bloccati, o quelli non aggiornati). Questa modalità viene chiamata vista rapida. Se si imposta la variabile vc-dired-terse-display a nil, VC Dired mostra tutti i file significativi--quelli gestiti dal sistema di controllo di versione e tutte le sottodirectory (vista completa). Il comando v t in un buffer in modo VC Dired permette di passare dalla vista rapida a quella completa (see VC Dired Commands).

Per default, VC Dired mostra un elenco dei file degni di attenzione ottenuto esaminando ricorsivamente la directory indicata e le sue sottodirectory. È possibile modificare tale comportamento impostatndo a nil la variabile vc-dired-recurse, nel qual caso VC Dired considera solo i file presenti nella directory indicata.

In ogni linea in cui è elencato un file compaiono (al posto del numero di hard link, proprietario, gruppo e dimensioni) le informazioni riguardanti lo stato di versionamento del file. Se il file non è stato modificato, ed è quindi allineato con il master file, le informazioni sullo stato sono vuote. Altrimenti, viene mostrato del testo tra parentesi: con RCS e SCCS viene mostrato il nome dell'utente che ha bloccato il file. Con CVS viene mostrata una versione abbreviata del risultato del comando cvs status. Ecco un esempio ove si usa RCS:

  /home/jim/project:

  -rw-r--r-- (andrea)   Apr  2 23:39 file1
  -r--r--r--            Apr  5 20:21 file2

I file file1 e file2 sono sotto controllo di versione, file1 è stato bloccato da andrea, e file2 non è bloccato.

Ecco un esempio con CVS:

  /home/joe/develop:

  -rw-r--r-- (modified) Aug  2  1997 file1.c
  -rw-r--r--            Apr  4 20:09 file2.c
  -rw-r--r-- (merge)    Sep 13  1996 file3.c

file1.c è modificato rispetto al repository, mentre file2.c non lo è. file3.c è modificato, ma altre modifiche sono state apportate nel repository--occorre quindi unirle alle proprie prima di poter fare il check-in del file di lavoro.

Quando VC Dired mostra le sottodirectory (nella vista completa), esso ne omette alcune che non devono mai contenere file sotto controllo di versione. Per default, esse includono directory come RCS o CVS; è possibile personalizzare la cosa impsotando la variabile vc-directory-exclusion-list.

È possibile modificare il modo in cui VC Dired visualizza i file digitando C-u C-x v d--come per Dired, ciò permette di specificare ulteriori opzioni da usare con il comando ls.

I comandi di VC Dired

Tutti i normali comandi di Dired funzionano allo stesso modo in VC Dired, tranne per v, che viene usato come prefisso per i comandi riguardanti le operazioni di controllo di versione. È possibile invocare comandi di VC come vc-diff e vc-print-log digitando v = o v l e cos`i via. La maggior parte di questi comandi si applica sul file specificato nella linea corrente.

Il comando v v (vc-next-action) opera su tutti i file selezionati, in modo da bloccare o da effettuare il check-in di numerosi file in un'unica operazione. Quando esso opera su più di un file, esso gestisce ogni singolo file in base al suo stato attuale, per cui può bloccare un file e effettuare invece il check-in di un altro. Ciò può confondere le idee: è compito dell'utente evitare questa situazione, selezionando quindi solo file che si trovano in uno stato omogeneo.

Se uno o più file devono essere posti in check-in, v v richiede l'immissione una sola volta delle informazioni di log, che poi vengono usate per tutti i file. Ciò è comodo quando si vogliono registrare o mettere in check-in più file alla volta, come facenti parte dello stesso insieme di modifiche.

È possibile passare dalla visione rapida (solo i file bloccati o non aggiornati) alla visione completa e viceversa digitando v t vc-dired-toggle-terse-mode. Esiste poi un comando speciale * l (vc-dired-mark-locked), che seleziona tutti i file che al momento sono bloccati (o, nel caso di CVS, che sono stati modificati rispetto all'ultima versione). * l t k, pertanto, è un altro modo per cancellare dal buffer tutti i file che non sono bloccati.

Più branch di un file

I sistemi di controllo di versione vengono usati anche per mantenere più versioni "correnti" di un file. Ad esempio, è possibile avere più versioni di un programma in cui si stanno aggiungendo diverse funzionalità non ancora implementate in modo completo. Ognuna delle linee di sviluppo sopracitate viene chiamata branch. VC permette di creare dei branch, passare da un branch all'altro e unire le modifiche apportate in un branch con quelle presenti in un altro branch. Occorre sottolineare, tuttavia, che i branch sono al momento supportati solo con RCS.

La linea di sviluppo principale di un file è solitamente chiamata ramo principale. Le sue versioni sono solitamente indicate come 1.1, 1.2, 1.3 e cos`i via. In ognuna delle suddette versioni è possibile creare un branch indipendente. Un branch che parta dalla versione 1.2 avrebbe il numero di versione 1.2.1.1, e le successive versioni sarebbero 1.2.1.2, 1.2.1.3, 1.2.1.4 e cos`i via. Se vi fosse un altro branch che parta dalla versione 1.2, esso consisterebbe delle versioni 1.2.2.1, 1.2.2.2, 1.2.2.3 cos`i via.

Se si omette la parte finale di un numero di versione, si ottiene quello che viene definito come numero del branch. Esso si riferisce alla versione con numero più alto esistente su quel branch--la più aggiornata su quel determinato branch. Considerando gli esempi appena proposti, essi hanno 1.2.1 e 1.2.2 come numero di branch.

• Switching Branches: Come passare a un altro branch.
• Creating Branches: Come iniziare un nuovo branch.
• Merging: Unire le modifiche in un branch con quelle presenti in un altro branch.
• Multi-User Branching: Più utenti lavorano contemporaneamente su più branch.

Cambiare branch

Per passare da un branch all'altro è sufficiente digitare C-u C-x C-q e specificare il numero di versione desiderato. Tale versione del file viene poi aperta senza bloccarla (protetta in scrittura), in modo da poterla esaminare prima di bloccarla. È possibile cambiare branch in questo modo solo se il file non è bloccato.

È possibile omettere l'ultima componente del numero della versione, specificando pertanto un numero di branch. Ciò porta a lavorare sulla versione più recente presente sul branch indicato. Se invece si digita solo <Invio>, si specifica la versione più recente presente sul ramo principale.

Dopo essere passati ad un branch qualsiasi (incluso il ramo principale), vi si rimane (per quanto riguarda i comandi di VC) fin quando non si passa esplicitamente ad un altro branch.

Creare nuovi branch

Per creare un nuovo branch a partire dalla versione più recente presente sul branch corrente occorre innanzitutto selezionare tale versione (se necessario), bloccarla con C-x C-q ed effettuare le modifiche necessarie. Quando si effettua poi il check-in delle modifiche, occorre usare C-u C-x C-q: ciò permette di specificare il numero di versione. A questo punto è sufficiente specificare un numero di branch adeguato per ottenere un branch che parta dalla versione corrente. Ad esempio, se il numero di versione corrente è 2.5, il numero di branch specificato potrebbe essere 2.5.1, 2.5.2 e cos`i via, a seconda del numero di branch già esistenti che partano da tale versione.

Per creare un nuovo branch a partire da una versione meno recente (una che non sia la più recente di un branch), occorre prima selezionare tale versione (see Switching +Branches), poi bloccarla con C-x C-q. Verrà a questo punto richiesta conferma di voler creare un nuovo branch--se non viene data conferma, viene invece offerta la possibilità di bloccare l'ultima versione.

A questo punto è possibile effettuare le modifiche del caso e poi digitare C-x C-q per effettuare il check-in della nuova versione e creare automaticamente un branch a partire dalla versione selezionata. Non è necessario specificare esplicitamente che si desidera creare un nuovo branch, in quanto ciò costituisce l'unico modo di aggiungere una nuova versione in un punto che non sia la versione più recente presente sul branch corrente.

Dopo aver creato il branch, vi si "rimane", nel senso che i check-in successivi creano nuove versioni su tale branch. Per lasciare il branch occorre esplicitamente selezionare un'altra versione con C-u C-x C-q. Per trasferire delle modifiche da un branch all'altro si può usare il comando descritto nella sezione che segue.

Unire dei branch

Una volta che si ha finito di apportare modifiche su un determinato branch è spesso desiderabile incorporare queste ultime nella linea principale di sviluppo (il ramo principale). Questa non è un'operazione banale, in quanto lo sviluppo può essere andato avanti anche sul ramo principale, per cui occorre unire le modifiche a quelle già apportate in altra sede. VC permette di effettuare questa operazione (ed altre) tramite il comando vc-merge.

C-x v m (vc-merge)

Incorpora nel file di lavoro delle modifiche.

C-x v m (vc-merge) prende un blocco di modifiche e lo incorpora nella versione corrente del file di lavoro. Esso richiede l'immissione nel minibuffer di un numero di branch, opure di una coppia di versioni, e poi va alla ricerca delle differenze esistenti rispetto al branch specificato, o a quelle esistenti tra le due versioni specificate, e le incorpora nella versione corrente del file su cui si sta lavorando.

Ad esempio, supponiamo che si abbia finito di implementare una certa funzionalità sul branch 1.3.1. Nel frattempo, lo sviluppo sul ramo principale è proseguito fino alla versione 1.5. Per incorporare nel ramo principale le modifiche presenti nel branch occorre quindi selezionare l'ultima versione del ramo principale, digitando C-u C-x C-q <Invio>. A questo punto, la versione 1.5 diventa la versione corrente. Se è il caso, occorre bloccare il file con C-x C-q, in modo da poterlo modificare. Digitando in seguito C-x v m 1.3.1 <Invio> si incorporano nella versione corrente tutte le modifiche presenti sul branch 1.3.1 (a partire dalla versione 1.3 fino all'ultima versione presente sul branch). A questo punto è possibile effettuare il check-in del file, creando quindi la versione 1.6 contenente tutte le modifiche.

È anche possibile modificare il file prima di effettuare il check-in, ma solitamente è consigliabile effettuare subito un check-in del file in cui sono state incorporate le modifiche, per poi bloccarlo e iniziare solo a questo punto ad apportare ulteriori modifiche. In questo modo si potrà tener traccia in un modo più completo delle modifiche apportate.

Quando si incorporano modifiche in un file che a sua volta è stato modificato, le modifiche possono sovrapporsi. Questa situazione presenta un conflitto, e l'operazione di apportare le modifiche necessarie in questo caso è definita come risoluzione di un conflitto.

Se mentre si incorporano delle modifiche si verifica un conflitto, VC ne prende atto, avvisa l'utente con un messaggio nell'area messaggi e chiede se occorre aiuto per risolvere il conflitto. Rispondendo yes viene avviata una sessione di Ediff (see Top).

Se invece si risponde no, le modifiche in conflitto tra loro vengono entrambe inserite nel file, evidenziate da delimitatori di conflitto. L'esempio che segue mostra l'aspetto di una zona contenente un conflitto. Il file si chiama nome e la versione corrente del master file che contiene le modifiche effettuate dall'utente B è la 1.11.

<<<<<<< nome
  User A's version
=======
  User B's version
>>>>>>> 1.11

A questo punto è possibile risolvere il conflitto apportando manualmente le modifiche necessarie. Oppure si può digitare M-x vc-resolve-conflicts per aprire una sessione di Ediff.

Branch con più utenti

Spesso è utile avere più sviluppatori che lavorano simultaneamente su più branch dello stesso file. Le impostazioni di default di CVS permettono questa situazione. Con RCS, ciò è possibile creando più directory per i sorgenti: ogni directory deve contenere un link chiamato RCS che punti ad una directory in comune contenente i master file. Cos`i facendo, in ogni singola directory può essere selezionata una versione differente, ma tutte condividono gli stessi dati per quanto riguarda le informazioni di versionamento.

Questa tecnica è affidabile e viene usata automaticamente, posto che i file sorgenti contengano delle intestazioni di RCS con il numero di versione (see Version Headers). Le intestazioni permettono ad Emacs di essere certo in ogni momento del numero di versione relativo al file su cui si sta lavorando.

Se il file non contiene tali intestazioni, occorre informare esplicitamente a Emacs al riguardo, specificando ad ogni sessione il branch su cui si sta lavorando. Ciò può essere fatto aprendo il file e poi digitando C-u C-x C-q seguito dal numero di branch corretto. Ciò assicura che Emacs sia in grado di sapere su quale branch si sta lavorando in questa particolare sessione.

Snapshots

Uno snapshot²³ è un insieme di determinate versioni di file (una versione per ogni file registrato) che possono essere considerate come un'unità. Tali insiemi sono identificati da dei nomi. Il rilascio è un tipo particolare di snapshot, in quanto le versioni che lo compongono vanno a formare una versione (teoricamente) stabile del sistema, pronta per essere distributita agli utenti.

• Making Snapshots: Le funzionalità disponibili per creare snapshot.
• Snapshot Caveats: Cose a cui bisogna prestare attenzione quando si usano degli snapshot.

Creare e usare degli snapshot

Fondamentalmente, esistono due comandi relativ agli snapshot: uno crea uno snapshot con un determinato nome, mentre l'altro recupera uno snapshot in base al nome fornito.

C-x v s nome <Invio>

Crea uno snapshot chiamato nome e formato dalle ultime versioni di ogni file registrato che si trova nella directory corrente, o in una delle sue sottodirectory (vc-create-snapshot).

C-x v r nome <Invio>

Per ogni file registrato che si trova nella directory corrente o in una sua sottodirectory seleziona la versione che corrisponde a quella dello snapshot chiamato nome (vc-retrieve-snapshot).

Questo comando produce un errore se uno o più dei file registrati è bloccato, e in questo caso non cambia nulla. Ciò avviene per evitare di sovrascrivere delle modifiche non ancora poste in check-in.

Uno snapshot richiede una quantità minima di risorse--solo quanto basta per memorizzare la lista dei nomi dei file che lo compongono, insieme all'elenco delle versioni, per cui è il caso di procedere senza indugi a creare degli snapshot qualora essi siano d'aiuto.

È possibile fornire il nome di uno snapshot a C-x v = e a C-x v ~ (see Old Versions), per cui è possibile usare questi due compandi per confrontare uno snapshot con le versioni correnti dei file, oppure per confrontare tra loro due snapshot, o ancora per confrontare uno snapshot con una data versione.

Possibili problemi con gli snapshot

Le funzionalità di VC per gestire gli snapshot sono modellate sul supporto che RCS offre nativamente all'uso di versioni definite da un nome. VC fa un uso diretto di tale supporto, per cui in esso sono visibili anche gli snapshot effettuati usando direttamene RCS senza passare per VC.

Per quanto riguarda SCCS, VC implementa in esso gli snapshot. I file usati contengono delle triple nome/file/versione, e gli snapshot sono usabili solo tramite VC.

Uno snapshot è un insieme di versioni poste in check-in, per cui occorre assicurarsi che tutti i file siano stati posti in check-in e che non siano bloccati quando si crea uno snapshot.

Cambiare nome ad dei file, o cancellane alcuni, può creare problemi con gli snapshot. Questo non è un problema specifico di VC, ma è un problema più generale nella progettazione di sistemi di controllo di versione che non è ancora stato sviscerato definitivamente.

Se si cambia il nome di un file registrato, occorre cambiare il nome anche al master file relativo (vc-rename-file effettua questa operazione automaticamente). Se si sta usando SCCS, occorre inoltre aggiornare i dati relativi agli snapshot, in modo da indicare il file con il suo nuovo nome (vc-rename-file effettua pure questa operazione, se necessaria). Uno snapshot che faccia riferimento ad un master file che non esiste più con il nome con cui era stato creato non è valido: VC non è più in grado di ripristinarlo. È oltre gli scopi di questo manuale entrare nei dettagli di funzionamento di RCS e SCCS quanto basta per spiegare come aggiornare a mano lo snapshot.

L'uso di vc-rename-file permette di mantenere validi gli snapshot, ma non risolve tutti i problemi. Ad esempio, alcuni dei file all'interno dello snapshot si riferiscono ad altri mediante il loro nome. Quantomeno, il makefile probabilmente contiene un riferimento al file a cui è stato cambiato nome. Se si seleziona uno snapshot, il file viene recuperato usando il nuovo nome, e non quello che il makefile si aspetta, per cui il programma non è subito utilizzabile.

Altri comandi e funzionalità di VC

Questa sezione riguarda le funzionalità di VC usate più di rado.

• Change Logs and VC: Generare un file di log delle modifiche a partire dalle informazioni di log.
• Renaming and VC: Un comando per cambiare nel modo corretto il nome sia al sorgente che al master file.
• Version Headers: Inserire intestazioni di versione nei file di lavoro.

Log delle modifiche e VC

Se si usa RCS o CVS per un progetto e si mantiene un file di log delle modifiche (see Change Log), è possibile generare delle voci per questo file in modo automatico a partire dalle informazioni di log fornite dal sistema di controllo di versione:

C-x v a

Apre il file di log delle modifiche presente nella directory corrente e, per i file registrati contenuti in tale directory, genera nuove voci relativamente alle versioni che sono state poste in check-in dopo la data della voce più recente presente nel file di log (vc-update-change-log).

Questo comando funziona solo con RCS e CVS, non con SCCS.

C-u C-x v a

Come sopra, ma genera voci solo per quanto riguarda il file correntemente aperto nel buffer.

M-1 C-x v a

Come sopra, ma genera voci per tutti i file attualmente aperti che sono sotto controllo di versione. Questo funziona solo con RCS, e le nuove voci vengono inserite nel file di log della directory di default (che può non essere appropriato).

Ad esempio, supponiamo che la prima linea del file ChangeLog sia datata 1999-04-10, e che l'unico check-in da allora sia stato effettuato da Nathaniel Bowditch il 1999-05-22 sul file rcs2log, con le informazioni di log Ignore log messages that start with `#'.. C-x v a apre il file ChangeLog ed inserisce del testo simile al seguente:

1999-05-22  Nathaniel Bowditch  <nat@apn.org>

        * rcs2log: Ignore log messages that start with `#'.

È possibile modificare ulteriormente la voce, se lo si desidera.

Purtroppo, nel file ChangeLog vengono memorizzate esclusivamente le date (anno, mese e giorno) senza l'ora, per cui è può capitare che vengano aggiunte informazioni che erano già presenti nel file, e che andranno rimosse manualmente.

Normalmente, la voce riguardante il file pippo viene generata come * pippo: informazioni di log. I due punti : che seguono pippo vengono omessi se il testo delle informazioni di log inizia con (nome_funzione): . Ad esempio, se le informazioni di log per vc.el sono (vc-do-command): Check call-process status., allora il testo generato appare simile al seguente:

1999-04-01  Nathaniel Bowditch  <nat@apn.org>

        * vc.el (vc-do-command): Check call-process status.

Quando C-x v a deve aggiungere più voci in una sola volta, esso raggruppa le voci qualora i check-in siano stati effettuati dallo stesso utente a breve distanza tra loro. Informazioni di log identiche tra loro vengono raggruppate inoltre in un'unica voce. Ad esempio, supponiamo che le informazioni di log relative ai check-in più recenti siano le seguenti:

• For vc.texinfo: Fix expansion typos. • For vc.el: Don't call expand-file-name. • For vc-hooks.el: Don't call expand-file-name.

In ChangeLog viene generato quanto segue:

1999-04-01  Nathaniel Bowditch  <nat@apn.org>

        * vc.texinfo: Fix expansion typos.

        * vc.el, vc-hooks.el: Don't call expand-file-name.

Normalmente, C-x v a separa le voci con una linea vuota, ma è possible etichettare diverse informazioni di log in modo che esse vengano raggruppate (senza che venga inserita una linea vuota) iniziando il testo con un'etichetta nella forma {nome_etichetta} . L'etichetta non viene inserita in ChangeLog. Ad esempio, supponiamo che le informazioni di log siano le seguenti:

• For vc.texinfo: {expand} Fix expansion typos. • For vc.el: {expand} Don't call expand-file-name. • For vc-hooks.el: {expand} Don't call expand-file-name.

Il testo inserito in ChangeLog pertanto sarà:

Wed Apr  1 08:57:59 1992  Nathaniel Bowditch  <nat@apn.org>

        * vc.texinfo: Fix expansion typos.
        * vc.el, vc-hooks.el: Don't call expand-file-name.

Un'informazione di log il cui testo inizi con # non viene inserita nel file ChangeLog. Ad esempio, se si correggono soltanto dei semplici errori ortografici, è possibile inserire un'informazione di log iniziante con # in modo da evitare di inserire questa informazione in ChangeLog.

Cambiare nome ai file di VC

Quando si cambia il nome ad un file registrato è necessario cambiare nome anche al master file relativo. Il comando vc-rename-file permette di effettuare queste opeazioni nel modo corretto. Esso inoltre aggiorna tutti gli snapshot che fanno riferimento a tale file, in modo che essi usino il nuovo nome. Nonostante ciò, lo snapshot cos`i modificato può non essere del tutto funzionale. (see Snapshot Caveats).

vc-rename-file non può essere usato su un file che sia bloccato da un altro utente.

Inserire le intestazioni di versione.

Talvolta è utile inserire nei file di lavoro delle stringhe che identifichino una versione. Alcune stringhe speciali, chiamate intestazioni di versione vengono sostituite in ogni versione successiva con il numero della versione.

Se si sta usando RCS e vi sono intestazioni di versione nei file di lavoro, Emacs può usarle per determinare la versione e lo stato di tali file. Ciò è molto più affidabile rispetto al fare riferimento al master file, cosa che viene fatta quando non vi sono intenstazioni di versione. Occorre tenere presente che in un ambiente ove vi siano più branch, le intestazioni di versione sono necessarie affinché VC si comporti correttamente (see Multi-User Branching).

La ricerca di intestazioni di versione è controllata dalla variabile vc-consult-headers. Se essa ha un valore diverso da nil, Emacs va alla ricerca delle intestazioni per determinare il numero di versione su cui si sta lavorando. Impostandola a nil, tale comportamento viene inibito.

È possibile inserire un'intestazione di versione appropriata mediante il comando C-x v h (vc-insert-headers).

C-x v h

Inserisce nel file un'intestazione adatta ad essere usata col sistema di controllo di versione in uso.

L'intestazione di default è $Id$ con RCS e %W% con SCCS. È possibile specificare altre intestazioni da inserire impostando la variabile vc-header-alist. Essa contiene una lista di elementi nella forma (programma . stringa), dove programma è RCS o SCCS e stringa è la stringa da usare.

Al posto di un'unica stringa è possibile specificare una lista di stringhe. In questo caso, ogni stringa nella lista viene inserita come un'intestazione a parte, in linee differenti.

È spesso necessario inserire delle barre oblique rovescie \ "superflue" quando si specificano le stringhe da immettere in questa variabile. Ciò deve essere fatto per evitare che la stringa in sè venga essa stessa interpretata come un'intestazione se il file Emacs Lisp che la contiene viene gestito con un sistema di controllo di versione.

Ogni intestazione viene inserita facendola precedere e seguire da dei caratteri di tabulazione, entro dei delimitatori di commento, in una nuova linea creata ove si trova il point. Normalmente, vengono usati i delimitatori di commento specifici del modo primario in uso, ma, per certi modi, vi sono delimitatori specifici per questo scopo specificati dalla lista contenuta nella variabile vc-comment-alist. Ogni elemento di questa lista ha la forma di (modo inizio fine).

La variabile vc-static-header-alist specifica ulteriori stringhe da aggiungere in base al nome del buffer. Il suo valore dovrebbe essere una lista di elementi nella forma (regexp . formato). Tutte le volte che regexp viene soddisfatta dal nome del buffer, formato viene inserito come parte dell'intestazione. Viene inserita una linea di intestazione per ogni elemento che soddisfi il nome del buffer, e per ogni stringa specificata in vc-header-alist. La linea di intestazione viene costruita usando la stringa specificata in vc-header-alist con il formato dell'elemento. Il valore di default di vc-static-header-alist è il seguente:

(("\\.c$" .
  "\n#ifndef lint\nstatic char vcid[] = \"\%s\";\n\
#endif /* lint */\n"))

Esso produce l'inseriemento del testo che segue:

#ifndef lint
static char vcid[] = "string";
#endif /* lint */

Notare che il testo inizia con una linea vuota.

Se si usa più di un'intestazione di versione in un file, è consigliabile porle vicine tra loro, in quanto il meccanismo usato da revert-buffer per preservare i marcatori può non essere in grado gestire quelli presenti tra due intestazioni di versione.

Personalizzare VC

VC è largamente personalizzabile: le opzioni impostabili rientrano in quattro categorie, descritte nelle sezioni seguenti.

• Backend Options: Personalizzare i backend.
• VC Workfile Handling: Diverse opzioni riguardanti i file di lavoro.
• VC Status Retrieval: Come VC determina lo stato di un file sotto controllo di versione e come personalizzare tale processo.
• VC Command Execution: I comandi eseguiti da VC e il modo in cui essi vengono invocati.

Personalizzazione dei backend di VC

È possibile configurare RCS e CVS in modo che richiedano o meno il blocco dei file (see VC Concepts). VC riconosce automaticamente la configurazione impostata, e si comporta di conseguenza.

La configurazione di default di RCS richiede il blocco dei file, ma esiste anche una modalità (chiamata non-strict locking) in cui è possibile effettuare il check-in delle modifiche senza che il file debba essere bloccato, attivabile usando rcs -U sui file desiderati. Per dettagli ulteriori si rimanda alla documentazione di RCS.

La configurazione di default di CVS invece non richiede il blocco dei file, e chiunque può effettuare modifiche in qualunque momento sui file di lavoro. Esistono tuttavia modi per limitare questa liberà, in modo da avere un comportamento simile a quello in cui è richiesto il blocco.

Ad esempio è possibile assegnare un valore alla variabile d'ambiente CVSREAD (il valore non è importante), definendola; in questo caso, CVS crea dei file di lavoro a sola lettura, e in Emacs occorre quindi digitare C-x C-q per iniziare ad effettuare le modifiche, in maniera simile a quanto avviene quando è richiesto il blocco dei file. Occorre notare, tuttavia, che i file non vengono bloccati, per cui diversi utenti possono andare contemporaneamente a effettuare modifiche. Quando si imposta CVSREAD per la prima volta, è il caso di effettuare il check-out di tutti i moduli, in modo che i permessi sui file di lavoro vengano impostati correttamente.

Un altro modo di ottenere un comportamento simile a quello in cui è richiesto il blocco consiste nell'usare la funzionalità watch di CVS: anche in questo caso i file vengono resi a sola lettura, ed è necessario usare C-x C-q prima di iniziare ad effettuare modifiche. In questo caso, VC invoca il comando cvs edit, e CVS si prende cura di notificare agli altri sviluppatori l'intenzione di modificare il file. Per dettagli ulteriori si rimanda alla documentazione di CVS.

È possibile disabilitare l'uso di VC per i file gestiti da CVS impostando la variabile vc-handle-cvs a nil: in questo caso, Emacs tratta i file come se essi non fossero registrati, ed i comandi di VC non sono più disponibili, per cui occorre effettuare manualmente tutte le operazioni con CVS.

Gestione dei file di lavoro con VC

Emacs normalmente non crea file di backup per i file che sono sotto controllo di versione, ma se si desidera averli anche in questo caso è sufficiente impostare la variabile vc-make-backup-files ad un valore diverso da nil.

Di norma, i file di lavoro esistono sempre, indipendentemente dal fatto che essi siano bloccati o meno; impostando a nil la variabile vc-keep-workfiles, il check-in delle modifiche tramite C-x C-q provoca la cancellazione del file di lavoro, che viene comunque rigenerato se si tenta di aprire nuovamente il file. Con CVS i file di lavoro non vengono mai cancellati.

Lavorare su un file sotto controllo di versione riferendosi ad esso tramite un link simbolico è un'operazione rischiosa: di fatto si scavalca il sistema di controllo di versione--è possibile modificare il file senza bloccarlo, e poi non riuscire più a effettuare il check-in. Le modifiche effettuate, inoltre, possono andare a sovrascrivere quelle di un altro utente. Per evitare questa spiacevole situazione, Emacs effettua delle verifiche tutte le volte che si apre un file tramite un link simbolico per vedere se esso è sotto controllo di versione.

Impostando la variabile vc-follow-symlinks si specifica come comportarsi in questo caso: se vale nil, VC mostra solo un messaggio d'avvertimento. Se invece vale t, VC segue il link simbolico e apre il file da esso indicato, avvertendo della cosa tramite un messaggio nell'area messaggi. Se il valore è ask (il default), VC chiede ogni volta se deve seguire il link simbolico.

Come VC determina lo stato di un file

Per determinare se un file è bloccato o meno, VC controlla innanzitutto se in esso esiste un'intestazione di versione di RCS (see Version Headers). In caso negativo, o se si sta usando SCCS, VC esamina i permessi d'accesso del file di lavoro; questa è un'operazione rapida, ma vi possono essere situazioni in cui i permessi d'accesso di un file non sono attendibili, e in questo caso deve essere consultato il master file (operazione che è più impegnativa). Il master file può comunque dire solamente se esiste un blocco sul file di lavoro, ma non se esso contenga realmente la versione bloccata.

Impostando a nil la variabile vc-consult-headers si può fare in modo che VC non usi le intestazioni di versione, e che vada invece a controllare i permessi di accesso del file di lavoro (se essi sono attendibili) o il master file.

È possibile specificare il criterio da usare nello stabilire se i permessi d'accesso sono attendibili impostando la variabile vc-mistrust-permissions: il suo valore può essere t (i permessi vengono sempre considerati inattendibili, per cui si va sempre a controllare sul master file), nil (i permessi vengono considerati sempre attendibili), o una funzione che prenda un argomento e che effettui la decisione. L'argomento passato è il nome della sottodirectory RCS, o CVS o SCCS, e un valore di ritorno diverso da nil indica che i permessi non sono da considerare attendibili. Se ci si accorge che i permessi dei file di lavoro sono stati cambiati per sbaglio, è il caso di impostare a t la variabile set vc-mistrust-permissions, in modo che VC vada sempre a effettuare il controllo sul master file.

I comandi eseguiti da VC

Se vc-suppress-confirm ha un valore diverso da nil, C-x C-q e C-x v i non chiedono conferma prima di salvare il buffer, ed anche C-x v u opera senza chiedere conferma (tuttavia, questa variabile non influenza C-x v c, che effettua un'operazione cos`i drastica da richiedere sempre conferma).

Il modo primario VC effettua le sue operazioni eseguendo tramite una shell i comandi opportuni di RCS, o CVS, o SCCS. Se vc-command-messages ha un valore diverso da nil, VC mostra dei messaggi indicanti il comando eseguito e il risultato.

È possibile specificare directory aggiuntive ove andare a cercare gli eseguibili dei programmi di controllo di versione impostando la variabile vc-path: esse vengono esaminate prima di quelle specificate dal percorso di ricerca usuale, tuttavia i programmi appropriati vengono nella maggior parte delle volte trovati automaticamente.

Le directory

Nel filesystem, i file vengono raggruppati in directory. Emacs dispone di comandi per creare e cancellare directory e per produrre elenchi del loro contenuto, sia in forma sintetica (solo i nomi dei file) che in forma completa (con le dimensioni, le date e i proprietari). Esiste inoltre un browser di directory chiamato Dired (see Dired).

C-x C-d directory o pattern <Invio>

Mostra un elenco sintetico del contenuto della directory (list-directory).

C-u C-x C-d directory o pattern <Invio>

Mostra un elenco completo del contenuto di della directory.

M-x make-directory <Invio> nome <Invio>

Crea una nuova directory chiamata nome.

M-x delete-directory <Invio> nome <Invio>

Elimina la directory chiamata dirname; essa deve essere vuota altrimenti viene generato un errore.

C-x C-d mostra il contenuto di una directory (list-directory): esso richiede l'immissione nel minibuffer del nome della directory o di un pattern con dei caratteri jolly che specifichi i file da elencare. Ad esempio:

C-x C-d /u2/emacs/etc <Invio>

visualizza un elenco dei file contenuti in /u2/emacs/etc. Ecco invece un esempio usando un pattern:

C-x C-d /u2/emacs/src/*.c <Invio>

Normalmente, C-x C-d produce un elenco sintetico composto solo dai nomi dei file, ma usando un argomento numerico come prefisso (il valore non è importante) viene prodotto un elenco completo, con incluse le dimensioni, le date e i proprietari dei file (come con ls -l).

L'elenco viene prodotto invocando il comando ls come sottoprocesso, e le opzioni ad esso passate sono specificate dalle variabili list-directory-brief-switches (quelle da usare per gli elenchi sintetici, "-CF" per default) e list-directory-verbose-switches (quelle da usare per gli elenchi completi, "-l" per default).

Confrontare file

Il comando M-x diff confronta due file, mostrando le differenze in un buffer di Emacs chiamato *Diff*. Esso opera avviando il programma diff con le opzioni indicate nella variabile diff-switches (il cui valore consiste in una stringa).

Il buffer *Diff* usa il modo primario Compilation, in modo da poter usare C-x ` per aprire i file ed esaminare in sequenza le posizioni in cui si trovano le differenze; è anche possibile spostare il point su una differenza in particolare e poi premere <Invio>, o C-c C-c o il pulsante centrale del mouse per saltare alla riga corrispondente nei file esaminati. È infine possibile usare anche gli altri comandi del modo Compilation: <Spazio> e <DEL> per scorrere in alto e in basso, M-p e M-n per spostare il point. See Compilation.

Il comando M-x diff-backup confronta un file con il suo backup più recente. Specificando il nome di un file di backup, lo confronta con il file di cui esso è il backup.

Il comando M-x compare-windows confronta il testo nella finestra corrente con quello della finestra successiva; il confronto inizia a partire dalle rispettive posizioni del point nelle due finestre, e le posizioni di partenza vengono memorizzate nella liste dei mark impostati dei due buffer. Il confronto prosegue carattere per carattere, e termina quando si trova la prima differenza. See Windows per maggiori informazioni sulle finestre di Emacs.

Se a compare-windows viene usato con un argomento numerico come prefisso (il valore non è importante), i cambiamenti riguardanti gli spazi vuoti vengono ignorati. Vengono pure ignorate le differenze tra le maiuscole e le minuscole se la variabile compare-ignore-case ha un valore diverso da nil.

Vedere inoltre Emerge per unire due file simili tra loro.

Altre operazioni sui file

Emacs fornisce comandi per effettuare numerose altre operazioni sui file: essi oprano tutti su singoli file, e non accettano pertanto pattern contenenti caratteri jolly.

M-x view-file permette di esaminare un file una pagina per volta: richiede l'immissione del nome di un file tramite il minibuffer, e dopo averlo aperto ne mostra la parte iniziale. È possibile usare <Spazio> per scorrere in avanti di una pagina, e <DEL> per scorrere indietro. Vi sono altri comandi che permettono di spostarsi all'interno del file, nessuno dei quali apporta modifiche, di cui si può ottenere un elenco digitando ? (per la maggior parte essi corrispondono ai normali comandi di Emacs per spostare il point). Per uscire è sufficiente digitare q. I comandi sono definiti all'interno di un modo primario chiamato View.

Il comando M-x view-buffer permette di esaminare un buffer già esistente. See Misc Buffer.

M-x insert-file inserisce nel buffer corrente il contenuto di un file specificato a partire dalla posizione del point, senza che esso venga spostato, e con il mark impostato alla fine del file inserito.

M-x write-region è l'opposto di M-x insert-file, in quanto salva il contenuto della regione nel file specificato. M-x append-to-file, agisce in modo simile, aggiungendo però la regione in fondo al file specificato. See Accumulating Text.

M-x delete-file cancella un file in maniera simile al comando rm della shell. Se si desidera cancellare più file in una directory può essere più comodo usare Dired (see Dired).

M-x rename-file richiede l'immissione di due nomi di file nel minibuffer, e poi cambia il nome del primo nel secondo; se già esiste un file con il nuovo nome, occorre confermare digitando yes, in quanto il suo contenuto andrà completamente perso. Se il nuovo nome appartiene ad un filesystem differente rispetto a quello vecchio, il file viene prima copiato con il nuovo nome e poi quello vecchio viene cancellato.

Similarmente, il comando M-x add-name-to-file viene usato per aggiungere un altro nome ad un file²⁴ senza rimuovere quello preesistente. Entrambi i nomi devono appartenere allo stesso filesystem.

M-x copy-file legge un file specificato e lo copia in un altro file. Viene richiesta conferma se esiste già il file su cui si vuole copiare, poichè il contenuto preesistente verrebbe completamente sovrascritto.

M-x make-symbolic-link richiede l'immissione di due nomi di file, il primo indicante la destinazione e l'altro il link da creare, e provvede poi a creare un link simbolico: tentando in seguito di aprire il link, verrà aperto il file a cui esso punta (se esiste), o altrimenti si otterrà un messaggio d'errore.

Viene richiesta conferma se il nome del link è già in uso; notare che non tutti i sistemi supportano i link simbolici.

Usare file compressi

Emacs viene fornito con una libreria che può decomprimere automaticamente i file compressi quando vengono aperti, e comprimerli nuovamente quando vengono modificati e salvati. Per abilitare questa funzionalità basta digitare il comando M-x auto-compression-mode.

Quando la compressione automatica è attiva (che implica anche la decompressione automatica), Emacs riconosce i file compressi in base al suffisso presente nei loro nomi: file che terminano con .gz indicano file compressi con gzip, mentre altri suffissi indicano altri programmi di compressione.

La compressione e la decompressione automatica avvengono in tutte le operazioni in cui Emacs usa il contenuto di un file, incluse l'apertura, il salvataggio, l'inserimento del contenuto in un buffer, il caricamento e la compilazione di sorgenti Emacs Lisp.

File remoti

È possibile usare file residenti su una macchina remota (connessa in rete) usando una sintassi speciale:

/host:nomefile
/utente@host:nomefile

In questo caso, Emacs usa il programma FTP per leggere e scrivere i file sull'host remoto, effettuando il login tramite FTP con il nome dell'utente corrente, o nomeutente, ed eventualmente chiedendo una password di quando in quando.

Se non si specifica un nome utente nel nome di file remoto, viene usato il nome dell'utente corrente, tuttavia è possibile impostare la variabile ange-ftp-default-user con una stringa che indica l'utente da usare (il package che implementa l'accesso ai file tramite FTP è ange-ftp).

È possibile disabilitare completamente questa funzionalità impostando a nil la variabile file-name-handler-alist.

Quotare nomi di file

È possibile quotare un nome di file assoluto in modo da impedire che dei caratteri speciali lo modifichino; per farlo è sufficiente aggiungere /: all'inizio.

Ad esempio, è possible quotare un nome di file locale che appare nella forma di un nome di file remoto, in modo da evitare che si tenti di accedere ad esso tramite FTP: ad esempio, è possibile accedere al file pluto nella directory /paperino: specificandolo come /:/paperino:/pluto.

/: impedisce inoltre che il carattere ~ venga considerato in alcuni casi come un'abbreviazione della home directory dell'utente corrente. Ad esempio, /:/tmp/~hack si riferisce ad un file il cui nome è ~hack nella directory /tmp.

Allo stesso modo, /: permette di inserire nel minibuffer il nome di un file che contenga il carattere $. In ogni caso, /: deve essere all'inizio del nome del file perchè ciò avvenga.

È infine possibile usare /: per quotare i caratteri jolly, nel caso si voglia aprire un file che li contenga nel nome; ad esempio, /:/tmp/pippo*paperino indica il file /tmp/pippo*paperino. Nella maggior parte dei casi, comunque, ciò non è necessario, ad esempio quando l'unico file in /tmp che inizia con pippo e termina con paperino è /tmp/pippo*paperino.

Usare più buffer

In Emacs, il testo su cui si lavora risiede in un oggetto chiamato buffer: ogni volta che si apre un file, viene creato un buffer per contenere il testo; ogni volta che si avvia Dired, viene creato un buffer per mantenere il contenuto della directoryM se si spedisce un messaggio con C-x m, viene creato il buffer *mail*, destinato a contenere il testo del messaggio; quando si richiede la documentazione di un comando, essa appare in un buffer chiamato *Help*.

In ogni momento vi è uno e un solo buffer selezionato, detto anche buffer corrente. In questo manuale si afferma spesso che un comando agisce "nel buffer", come se ne esistesse uno soloi, ma in realtà si intende il buffer selezionato.

Se vi sono più finestre, ognuna di essa visualizza un buffer, ma vi è una sola finestra selezionata alla volta, ed il buffer in essa contenuto è quello selezionato. Nella riga di stato di ogni finestra compare il nome del buffer che essa contiene (see Windows).

Ogni buffer ha un nome (di qualsiasi lunghezza), ed è possibile selezionare un buffer in base al suo nome. La maggior parte dei buffer vengono creati aprendo dei file, i nomi dei quali vengono usati per impostare il nome del buffer; è però possibile creare dei buffer vuoti con un nome qualsiasi. Appena avviato, Emacs presenta un buffer chiamato *scratch* che può essere usato per eseguire espressioni Lisp. La differenza tra maiuscole e minuscole è significativa nei nomi dei buffer.

Ogni buffer memorizza il nome del file contenuto, se è stato modificato, e il modo primario e i modi secondari in uso (see Major Modes). Ogni variabile può essere resa locale ad un buffer, ovvero il suo valore in un buffer può differire da quello di un altro buffer. See Locals.

• Select Buffer: Creare un nuovo buffer, o selezionarne uno esistente.
• List Buffers: Ottenere un elenco dei buffer esistenti.
• Misc Buffer: Come cambiare nome a un buffer, o renderlo a sola lettura, o copiare del testo.
• Kill Buffer: Eliminare i buffer non più necessari.
• Several Buffers: Come navigare nella lista di tutti i buffer ed effettuare operazioni su più buffer.
• Indirect Buffers: Un buffer indiretto condivide il testo di un altro buffer.

Creare e selezionare dei buffer

C-x b buffer <Invio>

Crea o seleziona un buffer chiamato buffer (switch-to-buffer).

C-x 4 b buffer <Invio>

Come sopra, ma seleziona il buffer in un'altra finestra (switch-to-buffer-other-window).

C-x 5 b buffer <Invio>

Come sopra, ma seleziona il buffer in un frame a parte (switch-to-buffer-other-frame).

Per selezionare un buffer chiamato nomebuffer basta digitare C-x b nomebuffer <Invio>, che avvia il comando switch-to-buffer con nomebuffer come parametro. Per inserire il nome del buffer si possono usare il completamento e le abbreviazioni (see Completion); se non si fornisce nulla, C-x b seleziona il buffer selezionato più di recente che non sia visualizzato in nessuna finestra.

La maggior parte dei buffer viene creata aprendo dei file, o tramite dei comandi di Emacs che hanno bisogno di mostrare parecchio testo; se ne può comunque creare uno esplicitamente digitando C-x b nomebuffer <Invio>, che crea un nuovo buffer vuoto e poi lo seleziona. Tali buffer sono usati per prendere appunti e note, e se si cerca di salvarli viene richiesto il nome di file da usare. Il modo primario attivo nel nuovo buffer dipende dal valore di default-major-mode (see Major Modes). Notare che C-x C-f e tutti gli altri comandi che aprono file possono essere usati anche per selezionare un buffer esistente in cui sia aperto un file See Visiting.

Emacs si riserva per uso interno i buffer i cui nomi iniziano con uno spazio, trattandoli in maniera leggermente diversa dagli altri (ad esempio, per default non vengono memorizzate informazioni di annullamento), ed è quindi consigliabile evitare di usare questi nomi.

Elencare i buffer esistenti

C-x C-b

Elenca i buffer esistenti (list-buffers).

Per avere una lista di tutti i buffer esistenti basta digitare C-x C-b: ogni linea mostra il nome di un buffer, il modo primario in uso e il nome del file aperto. Essi sono elencati nell'ordine in cui sono stati selezionati, con quelli selezionati più recentemente per primi.

Un asterisco * all'inizio di una linea indica che il buffer è stato modificato: se diversi buffer sono modificati, può essere il caso di salvarne alcuni con C-x s (see Saving). Un % indica invece che il buffer è a sola lettura, mentre . indica il buffer corrente. Ecco qui sotto un esempio di lista dei buffer:

 MR Buffer         Size  Mode           File
 -- ------         ----  ----           ----
.*  emacs.tex      383402 Texinfo       /u2/emacs/man/emacs.tex
    *Help*         1287  Fundamental
    files.el       23076 Emacs-Lisp     /u2/emacs/lisp/files.el
  % RMAIL          64042 RMAIL          /u/rms/RMAIL
 *% man            747   Dired          /u2/emacs/man/
    net.emacs      343885 Fundamental   /u/rms/net.emacs
    fileio.c       27691 C              /u2/emacs/src/fileio.c
    NEWS           67340 Text           /u2/emacs/etc/NEWS
    *scratch*	   0	 Lisp Interaction

Notare che il buffer *Help* è stato creato effettuando una richiesta d'aiuto, e non contiene alcun file aperto; il buffer man, invece, è stato creato da Dired a partire dalla directory /u2/emacs/man.

Varie operazioni sui buffer

C-x C-q

Rende a sola lettura un buffer, o lo rende modificabile (vc-toggle-read-only).

M-x rename-buffer <Invio> nome <Invio>

Cambia il nome al buffer corrente.

M-x rename-uniquely

Cambia il nome al buffer corrente, aggiungendogli <numero> alla fine.

M-x view-buffer <Invio> buffer <Invio>

Attiva il modo View nel buffer specificato.

Un buffer può essere a sola lettura, ovvero in esso non sono permessi i comandi che vanno a modificarlo: la riga di stato evidenzia il fatto mostrando %% o %* in prossimità del margine sinistro. I buffer a sola lettura vengono solitamente creati da sottosistemi quali Dired o Rmail, che hanno comandi specifici per operare sul testo, o aprendo dei file su cui non si hanno i permessi di scrittura.

Se si desidera modificare un buffer a sola lettura occorre usare il comando C-x C-q (vc-toggle-read-only), che rende modificabile un buffer a sola lettura e viceversa. Nella maggior parte dei casi ciò avviene impostando opportunamente la variabile buffer-read-only, che è locale ad ogni buffer e che rende a sola lettura un buffer se ha un valore diverso da nil; con i file sotto controllo di versione, inoltre, viene invocato il sistema di controllo di versione, in modo da rendere o meno modificabile sia il file che il buffer. See Version Control.

M-x rename-buffer modifica il nome del buffer corrente, richiedendo il nuovo nome tramite il minibuffer (non vi è alcun valore di default). Se si specifica il nome di un altro buffer già esistente, viene prodotto un errore e il comando non viene eseguito.

M-x rename-uniquely modifica il nome del buffer corrente e lo rende univoco aggiungendo un suffisso numerico. Questo comando non ha bisogno di argomenti, ed è utile, ad esempio, per creare più buffer di shell: se si rinomina in questo modo il buffer *Shell*, è in seguito possibile usare M-x shell nuovamente (ottenendo un altro buffer *Shell*), ma il vecchio buffer continua ad esistere con il suo nuovo nome. È utile anche con i buffer relativi alla posta elettronica, quelli di compilazione, e in generale tutti quelli che i comandi di Emacs creano con un nomi specifici.

M-x view-buffer è simile a M-x view-file (see Misc File Ops), tranne che opera su un buffer già esistente. Il modo View fornisce comandi per esaminare comodamente il testo, ma non per modificarlo. Uscendo da esso con q si ritorna al buffer e alla posizione precedenti, mentre uscendo con e il buffer viene selezionato con la nuova posizione.

I comandi M-x append-to-buffer e M-x insert-buffer possono essere usati per copiare del testo da un buffer all'altro.See Accumulating Text.

Eliminare dei buffer

In una sessione prolungata è facile ritrovarsi con un gran numero di buffer, per cui può essere comodo eliminare quelli che non servono più. Con la maggior parte dei sistemi operativi, ciò comporta il rilascio delle risorse occupate dal buffer, in modo che altri programmi possano usarle. Ecco alcuni comandi per eliminare dei buffer:

C-x k nomebuffer <Invio>

Elimina il buffer nomebuffer (kill-buffer).

M-x kill-some-buffers

Propone di eliminare ad uno ad uno i buffer esistenti.

C-x k (kill-buffer) elimina il buffer specificato nel minibuffer, o quello corrente se si preme direttamente <Invio> senza specificarne alcuno. Se si elimina il buffer corrente, viene selezionato quello usato più recente ma che non compare in nessuna finestra; se si elimina un buffer contenente un file aperto con delle modifiche (non salvate), occorre confermare l'operazione con yes.

Il comando M-x kill-some-buffers propone di eliminare ad uno a uno i buffer esistenti: rispondendo y, il buffer viene eliminato. Se si elimina il buffer corrente viene selezionato un altro buffer, ed eliminandone uno che contiene modifiche non salvate viene chiesta conferma (come con kill-buffer).

Il menù dei buffer (see Several Buffers) offre un modo comodo per eliminare numerosi buffer.

Se si desidera effettuare qualche operazione speciale ogni volta che viene eliminato un buffer, è possibile aggiungere funzioni alla variabile d'aggancio kill-buffer-hook (see Hooks).

Se la sessione di Emacs dura da diversi giorni (come spesso succede), ci si può ritrovare con innumerevoli buffer non usati da molto tempo. Il comando M-x clean-buffer-list è un modo comodo per eliminarli: esso normalmente elimina i buffer ordinari non modificati che non sono stati visualizzati per tre giorni, tuttavia è possibile indicare buffer da non eliminare automaticamente, o anche buffer da eliminare appena dopo un'ora di inutilizzo.

È possibile far eseguire periodicamente questo comando tramite il modo Midnight, che agisce ogni giorno a mezzanotte: esso normalmente avvia clean-buffer-list, o comunque qualsiasi funzione impostata nella variabile d'aggancio midnight-hook (see Hooks).

Per abilitare il modo Midnight si può usare il buffer di personalizzazione per impostare a t la variabile midnight-mode. See Easy Customization.

Agire su più buffer

Il menù dei buffer è una sorta di "Dired per i buffer", e permette di effettuare operazioni su numerosi buffer tramite uno che contiene una lista di quelli esistenti. È possibile salvare i buffer, eliminarli (operazione indicata qui come cancellazione, per coerenza con Dired) o visualizzarli.

M-x buffer-menu

Crea o visualizza un buffer che elenca tutti i buffer esistenti.

Il comando buffer-menu produce un buffer chiamato *Buffer List* contenente l'elenco di tutti i buffer esistenti, e lo seleziona, attivando in esso il modo Buffer Menu: esso è a sola lettura, e può essere modificato solo tramite i comandi descritti in questa sezione (sono comunque disponibili i normali comandi di spostamento del point).

I comandi che seguono si applicano al buffer indicato sulla linea corrente:

d

Marca un buffer per la cancellazione (con una D prima del nome), e poi passa alla linea successiva. La cancellazione vera e propria avviene quando si digita il comando x.

C-d

Come sopra, ma passa invece alla linea precedente.

s

Marca un buffer per il salvataggio (con una S), che avviene digitando il comando x. È possibile marcare lo stesso buffer sia per la cancellazione che per il salvataggio.

x

Salva e cancella i buffer marcati in tal senso.

u

Rimuove tutte le marcature dalla linea corrente, e passa poi alla linea successiva.

<DEL>

Passa alla linea precedente e rimuove le marcature.

I comandi d, C-d, s e u impostano o rimuovono dei flag (marcature), e poi spostano il point alla linea successiva (o a quella precedente): essi possono essere ripetuti più volte passando loro un argomento numerico come prefisso.

I comandi che seguono, invece, hanno effetto immediato (sul buffer indicato dalla linea corrente):

~

Marca il buffer come "non modificato".

%

Rende a sola lettura (o viceversa) il buffer.

t

Usa il buffer come una tabella di tag. See Select Tags Table.

Esistono inoltre comandi per selezionare altri buffer:

q

Fa uscire dal menù dei buffer--selezionando e visualizzando al suo posto il buffer usato più di recente. L'effetto è immediato.

<Invio>

f

Passa immediatamente al buffer indicato.

o

Seleziona e visualizza in un'altra finestra il buffer indicato, come con C-x 4 b, lasciando visibile il menù dei buffer.

C-o

Come sopra, ma il buffer non viene selezionato.

1

Passa al buffer indicato, usando una finestra a tutto schermo.

2

Prepara due finestre e passa al buffer indicato: in una finestra viene visualizzato l'ultimo buffer selezionato (diverso da *Buffer List*), nell'altra il buffer indicato.

b

Sposta il buffer indicato in fondo alla lista.

m

Marca con un > all'inizio della riga il buffer indicato, in modo che esso venga visualizzato in un'altra finestra se si esce con il comando v. Un buffer non può essere marcato contemporaneamente per la visualizzazione e la cancellazione.

v

Seleziona il buffer indicato, mostrando in altre finestre i buffer marcati in precedenza con il comando m. Se non ne sono stati marcati, questo comando è equivalente a 1.

Il comando buffer-menu non fa altro che creare e selezionare un buffer appropriato, attivando il modo Buffer Menu, mentre il resto è implementato tramite dei comandi speciali definiti in tale modo primario: una conseguenza è quella per cui è possibile passare dal buffer *Buffer List* ad un altro e continuare il proprio lavoro. In seguito è possibile riselezionare *Buffer List* per completare le operazioni, oppure lo si può eliminare, o semplicemente ignorarlo.

L'unica differenza tra buffer-menu e list-buffers sta nel fatto che il primo mostra il buffer *Buffer List* nella finestra corrente, mentre il secondo lo mostra in un'altra finestra. Se si invoca list-buffers (con C-x C-b) e si seleziona manualmente la finestra, è possibile usare tutti i comandi prima descritti.

Il buffer *Buffer List* non viene aggiornato automaticamente quando si creano o si eliminano dei buffer. Per farlo, è sufficiente usare in esso il comando g (revert-buffer), o invocare nuovamente il comando buffer-menu.

Buffer indiretti

Un buffer indiretto condivide il testo con un altro buffer, detto buffer di base dello stesso: per certi versi, ciò è l'analogo con i buffer dei link simbolici tra file.

M-x make-indirect-buffer buffer-di-base <Invio> nome-indiretto <Invio>

Crea un buffer indiretto chiamato nome-indiretto usando buffer-di-base come base.

Il testo nel buffer indiretto è sempre identico a quello nel suo buffer di base: le modifiche apportate in uno sono sempre visibili immediatamente nell'altro. Per tutti gli altri aspetti, comunque, essi sono due buffer completamente separati: essi hanno nomi diversi, memorizzano diverse posizioni del point e del mark, possono essere ristretti in zone diverse, avere modi primari diversi e variabili locali diverse.

Non si può aprire un file in un buffer indiretto, ma è possibile farlo nel suo buffer di base; se si tenta di salvare un buffer indiretto, si va a salvare il buffer di base; se si elimina il buffer di base, anche il buffer indiretto viene eliminato, ma non viceversa.

Uno dei modi di usare dei buffer indiretti consiste nell'usare più viste di un outline. See Outline Views.

Indice delle sequenze di caratteri

• <TAB> (Help mode): Help Mode
• C-@: Setting Mark
• C-_: Undo
• C-a: Moving Point
• C-b: Moving Point
• C-d: Deletion
• C-e: Moving Point
• C-f: Moving Point
• C-h: Help
• C-h a: Apropos
• C-h b: Misc Help
• C-h c: Key Help
• C-h C-c: Misc Help
• C-h C-d: Misc Help
• C-h C-f: Misc Help
• C-h C-h: Help
• C-h C-k: Misc Help
• C-h C-p: Misc Help
• C-h C-w: Misc Help
• C-h F: Misc Help
• C-h f: Name Help
• C-h i: Misc Help
• C-h k: Key Help
• C-h l: Misc Help
• C-h m: Misc Help
• C-h n: Misc Help
• C-h p: Library Keywords
• C-h t: Basic
• C-h w: Name Help
• C-k: Killing by Lines
• C-l: Scrolling
• C-M-%: Query Replace
• C-M-l: Scrolling
• C-M-r: Regexp Search
• C-M-s: Regexp Search
• C-M-t: Transpose
• C-M-w: Appending Kills
• C-n: Moving Point
• C-o: Blank Lines
• C-p: Moving Point
• C-q: Inserting Text
• C-r: Incremental Search
• C-s: Incremental Search
• C-SPC: Setting Mark
• C-t: Transpose
• C-u: Arguments
• C-u C-@: Mark Ring
• C-u C-SPC: Mark Ring
• C-u C-x u: Undo
• C-v: Scrolling
• C-w: Other Kill Commands
• C-x $: Selective Display
• C-x 4 b: Select Buffer
• C-x 4 f: Visiting
• C-x 5 b: Select Buffer
• C-x 5 f: Visiting
• C-x <: Horizontal Scrolling
• C-x =: Position Info
• C-x >: Horizontal Scrolling
• C-x b: Select Buffer
• C-x C-<SPC>: Global Mark Ring
• C-x C-b: List Buffers
• C-x C-c: Exiting
• C-x C-d: Directories
• C-x C-f: Visiting
• C-x C-n: Moving Point
• C-x C-o: Blank Lines
• C-x C-q: Misc Buffer
• C-x C-q (Version Control): Basic VC Editing
• C-x C-r: Visiting
• C-x C-s: Saving
• C-x C-t: Transpose
• C-x C-v: Visiting
• C-x C-w: Saving
• C-x C-x: Setting Mark
• C-x ESC ESC: Repetition
• C-x h: Marking Objects
• C-x k: Kill Buffer
• C-x r +: RegNumbers
• C-x r b: Bookmarks
• C-x r d: Rectangles
• C-x r f: RegConfig
• C-x r i: RegText
• C-x r j: RegPos
• C-x r k: Rectangles
• C-x r l: Bookmarks
• C-x r m: Bookmarks
• C-x r n: RegNumbers
• C-x r o: Rectangles
• C-x r r: RegRect
• C-x r s: RegText
• C-x r SPC: RegPos
• C-x r t: Rectangles
• C-x r w: RegConfig
• C-x r y: Rectangles
• C-x s: Saving
• C-x u: Undo
• C-x v =: Old Versions
• C-x v a: Change Logs and VC
• C-x v c: VC Undo
• C-x v d: VC Dired Mode
• C-x v g: Old Versions
• C-x v h: Version Headers
• C-x v i: Registering
• C-x v l: VC Status
• C-x v m: Merging
• C-x v r: Making Snapshots
• C-x v s: Making Snapshots
• C-x v u: VC Undo
• C-x v v: Basic VC Editing
• C-x v ~: Old Versions
• C-x z: Repeating
• C-y: Kill Ring
• C-z: Exiting
• DEL: Deletion
• DOWN: Moving Point
• F1: Help
• F10: Menu Bar
• Help: Help
• LEFT: Moving Point
• M-$: Spelling
• M-%: Query Replace
• M--: Arguments
• M-- M-c: Fixing Case
• M-- M-l: Fixing Case
• M-- M-u: Fixing Case
• M-1: Arguments
• M-<: Moving Point
• M-=: Position Info
• M->: Moving Point
• M-\: Deletion
• M-`: Menu Bar
• M-n (minibuffer history): Minibuffer History
• M-p (minibuffer history): Minibuffer History
• M-r: Moving Point
• M-r (minibuffer history): Minibuffer History
• M-s (minibuffer history): Minibuffer History
• M-SPC: Deletion
• M-t: Transpose
• M-v: Scrolling
• M-w: Kill Ring
• M-x: M-x
• M-y: Earlier Kills
• M-z: Other Kill Commands
• M-~: Saving
• NEXT: Scrolling
• PRIOR: Scrolling
• RET: Inserting Text
• RET (Occur mode): Other Repeating Search
• RIGHT: Moving Point
• S-<TAB> (Help mode): Help Mode
• SPC: Completion Commands
• TAB (completion): Completion Example
• UP: Moving Point

Indice dei comandi e delle funzioni

• add-name-to-file: Misc File Ops
• append-next-kill: Appending Kills
• append-to-buffer: Accumulating Text
• append-to-file: Accumulating Text
• apropos: Apropos
• apropos-command: Apropos
• apropos-documentation: Apropos
• apropos-value: Apropos
• apropos-variable: Apropos
• ask-user-about-lock: Interlocking
• auto-compression-mode: Compressed Files
• auto-save-mode: Auto Save Control
• backward-char: Moving Point
• beginning-of-buffer: Moving Point
• beginning-of-line: Moving Point
• bookmark-delete: Bookmarks
• bookmark-insert: Bookmarks
• bookmark-insert-location: Bookmarks
• bookmark-jump: Bookmarks
• bookmark-load: Bookmarks
• bookmark-save: Bookmarks
• bookmark-set: Bookmarks
• bookmark-write: Bookmarks
• buffer-menu: Several Buffers
• cd: File Names
• choose-completion: Completion Commands
• clean-buffer-list: Kill Buffer
• clear-rectangle: Rectangles
• column-number-mode: Optional Mode Line
• compare-windows: Comparing Files
• copy-file: Misc File Ops
• copy-rectangle-to-register: RegRect
• copy-to-buffer: Accumulating Text
• copy-to-register: RegText
• count-lines-region: Position Info
• count-matches: Other Repeating Search
• delete-backward-char: Deletion
• delete-blank-lines: Blank Lines
• delete-char: Deletion
• delete-file: Misc File Ops
• delete-horizontal-space: Deletion
• delete-matching-lines: Other Repeating Search
• delete-non-matching-lines: Other Repeating Search
• delete-rectangle: Rectangles
• delete-whitespace-rectangle: Rectangles
• describe-bindings: Misc Help
• describe-copying: Misc Help
• describe-distribution: Misc Help
• describe-function: Name Help
• describe-key: Key Help
• describe-key-briefly: Key Help
• describe-mode: Misc Help
• describe-no-warranty: Misc Help
• describe-project: Misc Help
• diff: Comparing Files
• diff-backup: Comparing Files
• digit-argument: Arguments
• display-time: Optional Mode Line
• do-auto-save: Auto Save Control
• end-of-buffer: Moving Point
• end-of-line: Moving Point
• exchange-point-and-mark: Setting Mark
• execute-extended-command: M-x
• find-alternate-file: Visiting
• find-file: Visiting
• find-file-literally: Visiting
• find-file-other-frame: Visiting
• find-file-other-window: Visiting
• find-file-read-only: Visiting
• finder-by-keyword: Library Keywords
• flush-lines: Other Repeating Search
• flyspell-mode: Spelling
• forward-char: Moving Point
• frame-configuration-to-register: RegConfig
• goto-char: Moving Point
• goto-line: Moving Point
• help-command: Help
• help-for-help: Help
• help-next-ref: Help Mode
• help-previous-ref: Help Mode
• help-with-tutorial: Basic
• hscroll-mode: Horizontal Scrolling
• increment-register: RegNumbers
• info: Misc Help
• Info-goto-emacs-command-node: Misc Help
• Info-goto-emacs-key-command-node: Misc Help
• insert-file: Misc File Ops
• insert-register: RegText
• isearch-backward: Incremental Search
• isearch-backward-regexp: Regexp Search
• isearch-forward: Incremental Search
• isearch-forward-regexp: Regexp Search
• ispell-buffer: Spelling
• ispell-complete-word: Spelling
• ispell-kill-ispell: Spelling
• ispell-region: Spelling
• ispell-word: Spelling
• jump-to-register: RegPos
• just-one-space: Deletion
• keep-lines: Other Repeating Search
• kill-buffer: Kill Buffer
• kill-line: Killing by Lines
• kill-rectangle: Rectangles
• kill-region: Other Kill Commands
• kill-ring-save: Kill Ring
• kill-some-buffers: Kill Buffer
• line-number-mode: Optional Mode Line
• list-bookmarks: Bookmarks
• list-buffers: List Buffers
• list-command-history: Repetition
• list-directory: Directories
• list-matching-lines: Other Repeating Search
• make-indirect-buffer: Indirect Buffers
• make-symbolic-link: Misc File Ops
• mark-whole-buffer: Marking Objects
• minibuffer-complete: Completion Example
• minibuffer-complete-word: Completion Commands
• mouse-choose-completion: Completion Commands
• move-to-window-line: Moving Point
• negative-argument: Arguments
• newline: Inserting Text
• next-completion: Completion Commands
• next-history-element: Minibuffer History
• next-line: Moving Point
• next-matching-history-element: Minibuffer History
• not-modified: Saving
• number-to-register: RegNumbers
• occur: Other Repeating Search
• open-line: Blank Lines
• open-rectangle: Rectangles
• point-to-register: RegPos
• pop-global-mark: Global Mark Ring
• prepend-to-buffer: Accumulating Text
• previous-completion: Completion Commands
• previous-history-element: Minibuffer History
• previous-line: Moving Point
• previous-matching-history-element: Minibuffer History
• pwd: File Names
• query-replace: Query Replace
• query-replace-regexp: Query Replace
• quoted-insert: Inserting Text
• re-search-backward: Regexp Search
• re-search-forward: Regexp Search
• recenter: Scrolling
• recover-file: Recover
• recover-session: Recover
• rename-buffer: Misc Buffer
• rename-file: Misc File Ops
• repeat: Repeating
• repeat-complex-command: Repetition
• replace-regexp: Unconditional Replace
• replace-string: Unconditional Replace
• reposition-window: Scrolling
• resize-minibuffer-mode: Minibuffer Edit
• revert-buffer: Reverting
• save-buffer: Saving
• save-buffers-kill-emacs: Exiting
• save-some-buffers: Saving
• scroll-down: Scrolling
• scroll-left: Horizontal Scrolling
• scroll-right: Horizontal Scrolling
• scroll-up: Scrolling
• search-backward: Nonincremental Search
• search-forward: Nonincremental Search
• self-insert: Inserting Text
• set-goal-column: Moving Point
• set-mark-command: Setting Mark
• set-selective-display: Selective Display
• set-visited-file-name: Saving
• string-rectangle: Rectangles
• substitute-in-file-name: File Names
• suspend-emacs: Exiting
• switch-to-buffer: Select Buffer
• switch-to-buffer-other-frame: Select Buffer
• switch-to-buffer-other-window: Select Buffer
• switch-to-completions: Completion Commands
• tmm-menubar: Menu Bar
• transient-mark-mode: Transient Mark
• transpose-chars: Transpose
• transpose-lines: Transpose
• transpose-sexps: Transpose
• transpose-words: Transpose
• undo: Undo
• universal-argument: Arguments
• vc-annotate: Old Versions
• vc-cancel-version: VC Undo
• vc-create-snapshot: Making Snapshots
• vc-diff: Old Versions
• vc-directory: VC Dired Mode
• vc-dired-mark-locked: VC Dired Commands
• vc-dired-toggle-terse-mode: VC Dired Commands
• vc-insert-headers: Version Headers
• vc-merge: Merging
• vc-next-action: Basic VC Editing
• vc-print-log: VC Status
• vc-register: Registering
• vc-rename-file: Renaming and VC
• vc-retrieve-snapshot: Making Snapshots
• vc-revert-buffer: VC Undo
• vc-toggle-read-only: Misc Buffer, Basic VC Editing
• vc-update-change-log: Change Logs and VC
• vc-version-other-window: Old Versions
• view-buffer: Misc Buffer
• view-emacs-FAQ: Misc Help
• view-emacs-news: Misc Help
• view-file: Misc File Ops
• view-lossage: Misc Help
• view-register: Registers
• what-cursor-position: Position Info
• what-line: Position Info
• what-page: Position Info
• where-is: Name Help
• window-configuration-to-register: RegConfig
• word-search-backward: Word Search
• word-search-forward: Word Search
• write-file: Saving
• write-region: Misc File Ops
• yank: Kill Ring
• yank-pop: Earlier Kills
• yank-rectangle: Rectangles
• zap-to-char: Other Kill Commands