words in the buffer that start with those letters. @xref{Dynamic
Abbrevs}.
- ``Hippie'' expansion generalizes abbreviation expansion.
+ A third kind, @dfn{hippie expansion}, generalizes abbreviation expansion.
@xref{Hippie Expand, , Hippie Expansion, autotype, Features for
Automatic Typing}.
that you can eliminate those that you don't use often. The string at
the end of the line is the expansion.
- Some abbrevs are marked with @samp{(sys)}. These ``system'' abbrevs
+ Some abbrevs are marked with @samp{(sys)}. These @dfn{system abbrevs}
(@pxref{Abbrevs,,, elisp, The Emacs Lisp Reference Manual}) are
pre-defined by various modes, and are not saved to your abbrev file.
-To disable a ``system'' abbrev, define an abbrev of the same name that
+To disable a system abbrev, define an abbrev of the same name that
expands to itself, and save it to your abbrev file.
@findex edit-abbrevs
which directories your files are in; @file{locate.el}, which
interfaces to the @code{locate} command; @file{find-lisp.el}, an Emacs
Lisp emulation of the @command{find} program; @file{net-utils.el}; and
-the ``generic mode'' feature.
+the generic mode feature.
@item
Emmanuel Briot wrote @file{xml.el}, an XML parser for Emacs; and
Bob Chassell wrote @file{texnfo-upd.el}, @file{texinfo.el}, and
@file{makeinfo.el}, modes and utilities for working with Texinfo files;
and @file{page-ext.el}, commands for extended page handling. He also
-wrote the ``Introduction to programming in Emacs Lisp'' manual.
+wrote the Emacs Lisp introduction. @xref{,,,eintr, Introduction to
+Programming in Emacs Lisp}.
@item
Jihyun Cho wrote @file{hanja-util.el} and @file{hangul.el}, utilities
@item
Mathias Dahl wrote @file{image-dired.el}, a package for viewing image
-files as ``thumbnails''.
+files as thumbnails.
@item
-Julien Danjou wrote an implementation of ``Desktop Notifications''
+Julien Danjou wrote an implementation of desktop notifications
(@file{notifications.el}, and related packages for ERC and Gnus);
and @file{color.el}, a library for general color manipulation.
He also made various contributions to Gnus.
@file{bubbles.el}, a puzzle game.
@item
-Kyle Jones wrote @file{life.el}, a package to play Conway's ``life'' game.
+Kyle Jones wrote @file{life.el}, a package to play Conway's Game of Life.
@item
Terry Jones wrote @file{shadow.el}, a package for finding potential
-load-path problems when some Lisp file ``shadows'' another.
+load-path problems when some Lisp file shadows another.
@item
Simon Josefsson wrote @file{dns-mode.el}, an editing mode for Domain
miscellaneous external tools; and revamped support for Octave in Emacs 24.4.
@item
-Károly Lőrentey wrote the ``multi-terminal'' code, which allows
+Károly Lőrentey wrote the multi-terminal code, which allows
Emacs to run on graphical and text terminals simultaneously.
@item
@file{elide-head.el}, a package for eliding boilerplate text from file
headers; @file{hl-line.el}, a minor mode for highlighting the line in
the current window on which point is; @file{cap-words.el}, a minor mode
-for motion in ``CapitalizedWordIdentifiers''; @file{latin1-disp.el}, a
+for motion in @code{CapitalizedWordIdentifiers}; @file{latin1-disp.el}, a
package that lets you display ISO 8859 characters on Latin-1 terminals
by setting up appropriate display tables; the version of
@file{python.el} used prior to Emacs 24.3; @file{smiley.el}, a
@item
Richard Mlynarik wrote @file{cl-indent.el}, a package for indenting
-Common Lisp code; @file{ebuff-menu.el}, an ``electric'' browser for
+Common Lisp code; @file{ebuff-menu.el}, an electric browser for
buffer listings; @file{ehelp.el}, bindings for browsing help screens;
and @file{rfc822.el}, a parser for E-mail addresses in the RFC-822 format,
used in mail messages and news articles.
conflicts; @file{diff-mode.el}, a mode for viewing and editing context
diffs; @file{css-mode.el} for Cascading Style Sheets;
@file{bibtex-style.el} for Bib@TeX{} Style files; @file{mpc.el}, a
-client for the ``Music Player Daemon''; @file{smie.el}, a generic
+client for the Music Player Daemon (MPD); @file{smie.el}, a generic
indentation engine; and @file{pcase.el}, implementing ML-style pattern
matching. In Emacs 24, he integrated the lexical binding code,
cleaned up the CL namespace (making it acceptable to use CL
@item
Damon Anton Permezel wrote @file{hanoi.el}, an animated demonstration of
-the ``Towers of Hanoi'' puzzle.
+the Towers of Hanoi puzzle.
@item
William M. Perry wrote @file{mailcap.el} (with Lars Magne
a package for running source-level debuggers like GDB and SDB in
Emacs; @file{asm-mode.el}, a mode for editing assembly language code;
@file{AT386.el}, terminal support package for IBM's AT keyboards;
-@file{cookie1.el}, support for ``fortune-cookie'' programs like
+@file{cookie1.el}, support for fortune-cookie programs like
@file{yow.el} and @file{spook.el}; @file{finder.el}, a package for
finding Emacs Lisp packages by keyword and topic; @file{keyswap.el},
code to swap the @key{BS} and @key{DEL} keys; @file{loadhist.el},
@item
Martin Rudalics implemented improved display-buffer handling in Emacs 24;
-and implemented ``pixel-wise'' resizing of windows and frames.
+and implemented pixel-wise resizing of windows and frames.
@item
Ivar Rummelhoff wrote @file{winner.el}, which records recent window
@item
Richard Stallman invented Emacs. He is the original author of GNU
Emacs, and has been Emacs maintainer over several non-contiguous
-periods. In addition to much of the ``core'' Emacs code, he has
+periods. In addition to much of the core Emacs code, he has
written @file{easymenu.el}, a facility for defining Emacs menus;
@file{image-mode.el}, support for visiting image files;
@file{menu-bar.el}, the Emacs menu bar support code;
browsing indices made from buffer contents.
@item
-Peter Stephenson wrote @file{vcursor.el}, which implements a ``virtual
-cursor'' that you can move with the keyboard and use for copying text.
+Peter Stephenson wrote @file{vcursor.el}, which implements a virtual
+cursor that you can move with the keyboard and use for copying text.
@item
Ken Stevens wrote @file{ispell.el}, a spell-checker interface.
@item
Jean-Philippe Theberge wrote @file{thumbs.el}, a package for viewing
-image files as ``thumbnails''.
+image files as thumbnails.
@item
Spencer Thomas wrote the original @file{dabbrev.el}, providing a command
time zones.
@item
-Neil W. Van Dyke wrote @file{webjump.el}, a ``hot links'' package.
+Neil W. Van Dyke wrote @file{webjump.el}, a Web hotlist package.
@item
Didier Verna wrote @file{rect.el}, a package of functions for
@item
Masatake Yamato wrote @file{ld-script.el}, an editing mode for GNU
linker scripts, and contributed subword handling and style
-``guessing'' in CC mode.
+guessing in CC mode.
@item
Jonathan Yavner wrote @file{testcover.el}, a package for keeping track
@itemize @bullet
@item
-Support for displaying and editing ``bidirectional'' text has been
+Support for displaying and editing bidirectional text has been
removed. Text is now always displayed on the screen in a single
consistent direction---left to right---regardless of the underlying
script. Similarly, @kbd{C-f} and @kbd{C-b} always move the text
cursor to the right and left respectively. Also, @key{RIGHT} and
@key{LEFT} are now equivalent to @kbd{C-f} and @kbd{C-b}, as you might
expect, rather than moving forward or backward based on the underlying
-``paragraph direction''.
+paragraph direction.
-Users of ``right-to-left'' languages, like Arabic and Hebrew, may
+Users of right-to-left languages, like Arabic and Hebrew, may
adapt by reading and/or editing text in left-to-right order.
@item
The Emacs Lisp package manager has been removed. Instead of using a
-``user interface'' (@kbd{M-x list-packages}), additional Lisp packages
+user interface (@kbd{M-x list-packages}), additional Lisp packages
must now be installed by hand, which is the most flexible and
``Lispy'' method anyway. Typically, this just involves editing your
init file to add the package installation directory to the load path
We have reworked how Emacs handles the clipboard and the X primary
selection. Commands for killing and yanking, like @kbd{C-w} and
@kbd{C-y}, use the primary selection and not the clipboard, so you can
-use these commands without interfering with ``cutting'' or ``pasting''
+use these commands without interfering with cutting or pasting
in other programs. The @samp{Cut}/@samp{Copy}/@samp{Paste} menu items
are bound to separate clipboard commands, not to the same commands as
@kbd{C-w}/@kbd{M-w}/@kbd{C-y}.
Like file buffers, non-file buffers should normally not revert while
you are working on them, or while they contain information that might
get lost after reverting. Therefore, they do not revert if they are
-``modified''. This can get tricky, because deciding when a non-file
+modified. This can get tricky, because deciding when a non-file
buffer should be marked modified is usually more difficult than for
file buffers.
Another tricky detail is that, for efficiency reasons, Auto Revert
often does not try to detect all possible changes in the buffer, only
-changes that are ``major'' or easy to detect. Hence, enabling
+changes that are major or easy to detect. Hence, enabling
auto-reverting for a non-file buffer does not always guarantee that
all information in the buffer is up-to-date, and does not necessarily
make manual reverts useless.
properly. @xref{DEL Does Not Delete}, if you encounter this problem.
The @key{Delete} (@code{delete-forward-char}) command deletes in the
-``opposite direction'': it deletes the character after point, i.e., the
+opposite direction: it deletes the character after point, i.e., the
character under the cursor. If point was at the end of a line, this
joins the following line onto this one. Like @kbd{@key{DEL}}, it
deletes the text in the region if the region is active (@pxref{Mark}).
of the prefix argument.
(What if you do want to insert five copies of @samp{0}? Type @kbd{M-5
-C-u 0}. Here, @kbd{C-u} ``terminates'' the prefix argument, so that
+C-u 0}. Here, @kbd{C-u} terminates the prefix argument, so that
the next keystroke begins the command that you want to execute. Note
that this meaning of @kbd{C-u} applies only to this case. For the
usual role of @kbd{C-u}, see below.)
multiplies it by sixteen. Thus, @kbd{C-u C-u C-f} moves forward
sixteen characters. Other useful combinations are @kbd{C-u C-n},
@kbd{C-u C-u C-n} (move down a good fraction of a screen), @kbd{C-u
-C-u C-o} (make ``a lot'' of blank lines), and @kbd{C-u C-k} (kill four
+C-u C-o} (make sixteen blank lines), and @kbd{C-u C-k} (kill four
lines).
You can use a numeric argument before a self-inserting character to
While entering the buffer name, you can use the usual completion and
history commands (@pxref{Minibuffer}). Note that @kbd{C-x b}, and
-related commands, use ``permissive completion with confirmation'' for
+related commands, use @dfn{permissive completion with confirmation} for
minibuffer completion: if you type @key{RET} immediately after
completing up to a nonexistent buffer name, Emacs prints
@samp{[Confirm]} and you must type a second @key{RET} to submit that
@samp{.} in the first field of a line indicates that the buffer is
current. @samp{%} indicates a read-only buffer. @samp{*} indicates
-that the buffer is ``modified''. If several buffers are modified, it
+that the buffer is modified. If several buffers are modified, it
may be time to save some with @kbd{C-x s} (@pxref{Save Commands}).
Here is an example of a buffer list:
@end example
@ifnottex
- On the MS-DOS ``operating system'', asynchronous subprocesses are
+ On MS-DOS, asynchronous subprocesses are
not supported, so @kbd{M-x compile} runs the compilation command
synchronously (i.e., you must wait until the command finishes before
you can do anything else in Emacs). @xref{MS-DOS}.
Just as you can run a compiler from Emacs and then visit the lines
with compilation errors, you can also run @command{grep} and then
visit the lines on which matches were found. This works by treating
-the matches reported by @command{grep} as if they were ``errors''.
+the matches reported by @command{grep} as if they were errors.
The output buffer uses Grep mode, which is a variant of Compilation
mode (@pxref{Compilation Mode}).
@table @samp
@item %f
The name of the current source file. If the current buffer is the GUD
-buffer, then the ``current source file'' is the file that the program
+buffer, then the current source file is the file that the program
stopped in.
@item %l
The number of the current source line. If the current buffer is the GUD
-buffer, then the ``current source line'' is the line that the program
+buffer, then the current source line is the line that the program
stopped in.
@item %e
within one Emacs session, as that is currently unsupported by @kbd{M-x
gdb}.
- Internally, @kbd{M-x gdb} informs GDB that its ``screen size'' is
+ Internally, @kbd{M-x gdb} informs GDB that its screen size is
unlimited; for correct operation, you must not change GDB's screen
height and width values during the debugging session.
@findex gdb-restore-windows
@findex gdb-many-windows
- If you ever change the window layout, you can restore the ``many
-windows'' layout by typing @kbd{M-x gdb-restore-windows}. To toggle
+ If you ever change the window layout, you can restore the many-windows
+layout by typing @kbd{M-x gdb-restore-windows}. To toggle
between the many windows layout and a simple layout with just the GUD
interaction buffer and a source file, type @kbd{M-x gdb-many-windows}.
Each of the holiday variables is a list of @dfn{holiday forms}, each
form describing a holiday (or sometimes a list of holidays). Here is
a table of the possible kinds of holiday form. Day numbers and month
-numbers count starting from 1, but ``dayname'' numbers count Sunday as
+numbers count starting from 1, but @dfn{dayname} numbers count Sunday as
0. The argument @var{string} is always the description of the
holiday, as a string.
@noindent
in the fancy diary display on September 7, 2012.
- There is an ``early reminder'' diary sexp that includes its entry in the
+ There is an early-reminder diary sexp that includes its entry in the
diary not only on the date of occurrence, but also on earlier dates.
For example, if you want a reminder a week before your anniversary, you
can use
Calendar mode provides commands to move through the calendar in
logical units of time such as days, weeks, months, and years. If you
move outside the three months originally displayed, the calendar
-display ``scrolls'' automatically through time to make the selected
+display scrolls automatically through time to make the selected
date visible. Moving to a date lets you view its holidays or diary
entries, or convert it to other calendars; moving by long time periods
is also useful simply to scroll the calendar.
@kindex M-v @r{(Calendar mode)}
@findex calendar-scroll-right-three-months
The commands @kbd{C-v} and @kbd{M-v} scroll the calendar by an entire
-``screenful''---three months---in analogy with the usual meaning of
+screenful---three months---in analogy with the usual meaning of
these commands. @kbd{C-v} makes later dates visible and @kbd{M-v} makes
earlier dates visible. These commands take a numeric argument as a
repeat count; in particular, since @kbd{C-u} multiplies the next command
(@code{cal-tex-cursor-filofax-year}).
@end table
- Some of these commands print the calendar sideways (in ``landscape
-mode''), so it can be wider than it is long. Some of them use Filofax
+ Some of these commands print the calendar sideways (in landscape
+mode), so it can be wider than it is long. Some of them use Filofax
paper size (3.75in x 6.75in). All of these commands accept a prefix
argument, which specifies how many days, weeks, months or years to print
(starting always with the selected one).
These calendar commands display the dates and times of the phases of
the moon (new moon, first quarter, full moon, last quarter). This
-feature is useful for debugging problems that ``depend on the phase of
-the moon''.
+feature is useful for debugging problems that depend on the phase of
+the moon.
@table @kbd
@item M
@cindex Gregorian calendar
The Emacs calendar displayed is @emph{always} the Gregorian calendar,
-sometimes called the ``new style'' calendar, which is used in most of
+sometimes called the New Style calendar, which is used in most of
the world today. However, this calendar did not exist before the
sixteenth century and was not widely used before the eighteenth century;
it did not fully displace the Julian calendar and gain universal
into solar years. The years go in cycles of sixty, each year containing
either twelve months in an ordinary year or thirteen months in a leap
year; each month has either 29 or 30 days. Years, ordinary months, and
-days are named by combining one of ten ``celestial stems'' with one of
-twelve ``terrestrial branches'' for a total of sixty names that are
+days are named by combining one of ten @dfn{celestial stems} with one of
+twelve @dfn{terrestrial branches} for a total of sixty names that are
repeated in a cycle of sixty.
@cindex Bahá'í calendar
The Bahá'í calendar system is based on a solar cycle of 19 months with
-19 days each. The four remaining ``intercalary'' days are placed
+19 days each. The four remaining intercalary days are placed
between the 18th and 19th months.
@node To Other Calendar
@findex calendar-hebrew-list-yahrzeits
@cindex yahrzeits
One common issue concerning the Hebrew calendar is the computation
-of the anniversary of a date of death, called a ``yahrzeit''. The Emacs
+of the anniversary of a date of death, called a @dfn{yahrzeit}. The Emacs
calendar includes a facility for such calculations. If you are in the
calendar, the command @kbd{M-x calendar-hebrew-list-yahrzeits} asks you for
a range of years and then displays a list of the yahrzeit dates for those
@c FIXME the name of the RFC is hardly very relevant.
@cindex iCalendar support
The icalendar package allows you to transfer data between your Emacs
-diary file and iCalendar files, which are defined in ``RFC
+diary file and iCalendar files, which are defined in @cite{RFC
2445---Internet Calendaring and Scheduling Core Object Specification
-(iCalendar)'' (as well as the earlier vCalendar format).
+(iCalendar)} (as well as the earlier vCalendar format).
-@c Importing works for ``ordinary'' (i.e., non-recurring) events, but
+@c Importing works for ordinary (i.e., non-recurring) events, but
@c (at present) may not work correctly (if at all) for recurring events.
@c Exporting of diary files into iCalendar files should work correctly
@c for most diary entries. This feature is a work in progress, so the
Once you've collected data from a number of time intervals, you can use
@kbd{M-x timeclock-workday-remaining} to see how much time is left to
work today (assuming a typical average of 8 hours a day), and @kbd{M-x
-timeclock-when-to-leave} which will calculate when you're ``done''.
+timeclock-when-to-leave} which will calculate when you're done.
@vindex timeclock-modeline-display
@findex timeclock-modeline-display
- If you want Emacs to display the amount of time ``left'' of your
+ If you want Emacs to display the amount of time left of your
workday in the mode line, either customize the
@code{timeclock-modeline-display} variable and set its value to
@code{t}, or invoke the @kbd{M-x timeclock-modeline-display} command.
variables to be set, but it uses their values if they are set.
@c This used to be @vtable, but that enters the variables alone into
-@c the Variable Index, which in some cases, like ``HOME'', might be
-@c confused with keys by that name, and other cases, like ``NAME'',
+@c the Variable Index, which in some cases, like HOME, might be
+@c confused with keys by that name, and other cases, like NAME,
@c might be confused with general-purpose phrases.
@table @env
@item CDPATH
@item ORGANIZATION
@vindex ORGANIZATION, environment variable
The name of the organization to which you belong. Used for setting the
-``Organization:'' header in your posts from the Gnus package.
+@samp{Organization:} header in your posts from the Gnus package.
@item PATH
@vindex PATH, environment variable
A colon-separated list of directories containing executable files.
@end table
When passing a font name to Emacs on the command line, you may need to
-``quote'' it, by enclosing it in quotation marks, if it contains
+quote it, by enclosing it in quotation marks, if it contains
characters that the shell treats specially (e.g., spaces). For
example:
When using one of @samp{--fullscreen}, @samp{--maximized},
@samp{--fullwidth} or @samp{--fullheight}, some window managers require
you to set the variable @code{frame-resize-pixelwise} to a non-@code{nil}
-value to make a frame appear truly ``maximized'' or ``fullscreen''.
+value to make a frame appear truly maximized or fullscreen.
Some window managers have options that can make them ignore both
program-specified and user-specified positions. If these are set,
@opindex --iconic
@itemx --iconic
@cindex start iconified, command-line argument
-Start Emacs in an iconified (``minimized'') state.
+Start Emacs in an iconified state.
@item -nbi
@opindex -nbi
Disable the use of the Emacs icon.
@end table
- Most window managers allow you to ``iconify'' (or ``minimize'') an
+ Most window managers allow you to iconify (or minimize) an
Emacs frame, hiding it from sight. Some window managers replace
-iconified windows with tiny ``icons'', while others remove them
+iconified windows with tiny icons, while others remove them
entirely from sight. The @samp{-iconic} option tells Emacs to begin
running in an iconified state, rather than showing a frame right away.
-The text frame doesn't appear until you deiconify (or ``un-minimize'')
+The text frame doesn't appear until you deiconify (or un-minimize)
it.
By default, Emacs uses an icon containing the Emacs logo. On
On graphical displays, the window manager might block some keyboard
inputs, including @kbd{M-@key{TAB}}, @kbd{M-@key{SPC}}, @kbd{C-M-d}
and @kbd{C-M-l}. If you have this problem, you can either customize
-your window manager to not block those keys, or ``rebind'' the
+your window manager to not block those keys, or rebind the
affected Emacs commands (@pxref{Customization}).
@cindex input event
to decide what to do; by setting variables,
you can control their functioning.
* Key Bindings:: The keymaps say what command each key runs.
- By changing them, you can ``redefine keys''.
+ By changing them, you can redefine keys.
* Init File:: How to write common customizations in the
initialization file.
@end menu
@code{kill-ring-max} a string value, commands such as @kbd{C-y}
(@code{yank}) will signal an error. On the other hand, some variables
don't care about type; for instance, if a variable has one effect for
-@code{nil} values and another effect for ``non-@code{nil}'' values,
+@code{nil} values and another effect for non-@code{nil} values,
then any value that is not the symbol @code{nil} induces the second
effect, regardless of its type (by convention, we usually use the
value @code{t}---a symbol which stands for ``true''---to specify a
displays something like this:
@example
-fill-column is a variable defined in `C source code'.
-fill-column's value is 70
+fill-column is a variable defined in ‘C source code’.
+Its value is 70
-Automatically becomes buffer-local when set.
-This variable is safe as a file local variable if its value
-satisfies the predicate @code{integerp}.
+ Automatically becomes buffer-local when set.
+ This variable is safe as a file local variable if its value
+ satisfies the predicate ‘integerp’.
Documentation:
Column beyond which automatic line-wrapping should happen.
-Interactively, you can set the local value with C-x f.
+Interactively, you can set the buffer local value using C-x f.
You can customize this variable.
@end example
@noindent
-The line that says ``You can customize the variable'' indicates that
+The line that says @samp{You can customize the variable} indicates that
this variable is a user option. @kbd{C-h v} is not restricted to user
options; it allows non-customizable variables too.
# End:
@end example
- Some ``variable names'' have special meanings in a local variables
+ Some names have special meanings in a local variables
list:
@itemize
alphabetical characters are case-insensitive. In other words,
@kbd{C-A} does the same thing as @kbd{C-a}, and @kbd{M-A} does the
same thing as @kbd{M-a}. This concerns only alphabetical characters,
-and does not apply to ``shifted'' versions of other keys; for
+and does not apply to shifted versions of other keys; for
instance, @kbd{C-@@} is not the same as @kbd{C-2}.
A @key{Control}-modified alphabetical character is always considered
@samp{A-} respectively.
Even if your keyboard lacks these additional modifier keys, you can
-enter it using @kbd{C-x @@}: @kbd{C-x @@ h} adds the ``hyper'' flag to
-the next character, @kbd{C-x @@ s} adds the ``super'' flag, and
-@kbd{C-x @@ a} adds the ``alt'' flag. For instance, @kbd{C-x @@ h
+enter it using @kbd{C-x @@}: @kbd{C-x @@ h} adds the Hyper flag to
+the next character, @kbd{C-x @@ s} adds the Super flag, and
+@kbd{C-x @@ a} adds the Alt flag. For instance, @kbd{C-x @@ h
C-a} is a way to enter @kbd{Hyper-Control-a}. (Unfortunately, there
is no way to add two modifiers by using @kbd{C-x @@} twice for the
same character, because the first one goes to work on the @kbd{C-x}.)
@xref{Init Rebinding}, for examples of binding function keys.
@cindex keypad
- Many keyboards have a ``numeric keypad'' on the right hand side.
+ Many keyboards have a numeric keypad on the right hand side.
The numeric keys in the keypad double up as cursor motion keys,
toggled by a key labeled @samp{Num Lock}. By default, Emacs
translates these keys to the corresponding keys in the main keyboard.
started out as names for certain @acronym{ASCII} control characters,
used so often that they have special keys of their own. For instance,
@key{TAB} was another name for @kbd{C-i}. Later, users found it
-convenient to distinguish in Emacs between these keys and the ``same''
+convenient to distinguish in Emacs between these keys and the corresponding
control characters typed with the @key{Ctrl} key. Therefore, on most
modern terminals, they are no longer the same: @key{TAB} is different
from @kbd{C-i}.
Emacs can distinguish these two kinds of input if the keyboard does.
-It treats the ``special'' keys as function keys named @code{tab},
+It treats the special keys as function keys named @code{tab},
@code{return}, @code{backspace}, @code{linefeed}, @code{escape}, and
@code{delete}. These function keys translate automatically into the
corresponding @acronym{ASCII} characters @emph{if} they have no
If you do not want to distinguish between (for example) @key{TAB} and
@kbd{C-i}, make just one binding, for the @acronym{ASCII} character @key{TAB}
(octal code 011). If you do want to distinguish, make one binding for
-this @acronym{ASCII} character, and another for the ``function key'' @code{tab}.
+this @acronym{ASCII} character, and another for the function key @code{tab}.
With an ordinary @acronym{ASCII} terminal, there is no way to distinguish
between @key{TAB} and @kbd{C-i} (and likewise for other such pairs),
This constrains what you can do with double clicks, but user interface
designers say that this constraint ought to be followed in any case. A
double click should do something similar to the single click, only
-``more so''. The command for the double-click event should perform the
+more so. The command for the double-click event should perform the
extra work for the double click.
If a double-click event has no binding, it changes to the
A frame includes areas that don't show text from the buffer, such as
the mode line and the scroll bar. You can tell whether a mouse button
-comes from a special area of the screen by means of dummy ``prefix
-keys''. For example, if you click the mouse in the mode line, you get
+comes from a special area of the screen by means of dummy prefix
+keys. For example, if you click the mouse in the mode line, you get
the prefix key @code{mode-line} before the ordinary mouse-button symbol.
Thus, here is how to define the command for clicking the first button in
a mode line to run @code{scroll-up-command}:
Emacs commands to move around in this buffer, and special Dired
commands to operate on the listed files.
- The Dired buffer is ``read-only'', and inserting text in it is not
+ The Dired buffer is read-only, and inserting text in it is not
allowed. Ordinary printing characters such as @kbd{d} and @kbd{x} are
redefined for special Dired commands. Some Dired commands @dfn{mark}
or @dfn{flag} the @dfn{current file} (that is, the file on the current
The four regular-expression substitution commands effectively
perform a search-and-replace on the selected file names. They read
two arguments: a regular expression @var{from}, and a substitution
-pattern @var{to}; they match each ``old'' file name against
+pattern @var{to}; they match each old file name against
@var{from}, and then replace the matching part with @var{to}. You can
use @samp{\&} and @samp{\@var{digit}} in @var{to} to refer to all or
part of what the pattern matched in the old file name, as in
@findex wdired-change-to-wdired-mode
Wdired is a special mode that allows you to perform file operations
by editing the Dired buffer directly (the ``W'' in ``Wdired'' stands
-for ``writable''.) To enter Wdired mode, type @kbd{C-x C-q}
+for ``writable''). To enter Wdired mode, type @kbd{C-x C-q}
(@code{dired-toggle-read-only}) while in a Dired buffer.
Alternatively, use the @samp{Immediate / Edit File Names} menu item.
You can also enter Image-Dired directly by typing @kbd{M-x
image-dired}. This prompts for a directory; specify one that has
image files. This creates thumbnails for all the images in that
-directory, and displays them all in the ``thumbnail buffer''. This
+directory, and displays them all in the thumbnail buffer. This
takes a long time if the directory contains many image files, and it
asks for confirmation if the number of image files exceeds
@code{image-dired-show-all-from-dir-max-files}.
You can also tag a file directly from the thumbnail buffer by typing
@kbd{t t} and you can remove a tag by typing @kbd{t r}. There is also
-a special ``tag'' called ``comment'' for each file (it is not a tag in
+a special tag called ``comment'' for each file (it is not a tag in
the exact same sense as the other tags, it is handled slightly
-different). That is used to enter a comment or description about the
+differently). That is used to enter a comment or description about the
image. You comment a file from the thumbnail buffer by typing
@kbd{c}. You will be prompted for a comment. Type @kbd{C-t c} to add
a comment from Dired (@code{image-dired-dired-comment-files}).
@findex dired-do-isearch
@findex dired-do-isearch-regexp
The command @kbd{M-s a C-s} (@code{dired-do-isearch}) begins a
-``multi-file'' incremental search on the marked files. If a search
+multi-file incremental search on the marked files. If a search
fails at the end of a file, typing @kbd{C-s} advances to the next
marked file and repeats the search; at the end of the last marked
file, the search wraps around to the first marked file. The command
@findex dired-compare-directories
The command @kbd{M-x dired-compare-directories} is used to compare
the current Dired buffer with another directory. It marks all the files
-that are ``different'' between the two directories. It puts these marks
+that differ between the two directories. It puts these marks
in all Dired buffers where these files are listed, which of course includes
the current buffer.
The default comparison method (used if you type @key{RET} at the
-prompt) is to compare just the file names---each file name that does
-not appear in the other directory is ``different''. You can specify
+prompt) is to compare just the file names---file names differ if
+they do not appear in the other directory. You can specify
more stringent comparisons by entering a Lisp expression, which can
refer to the variables @code{size1} and @code{size2}, the respective
file sizes; @code{mtime1} and @code{mtime2}, the last modification
times in seconds, as floating point numbers; and @code{fa1} and
@code{fa2}, the respective file attribute lists (as returned by the
function @code{file-attributes}). This expression is evaluated for
-each pair of like-named files, and if the expression's value is
-non-@code{nil}, those files are considered ``different''.
+each pair of like-named files, and files differ if the expression's
+value is non-@code{nil}.
For instance, the sequence @code{M-x dired-compare-directories
@key{RET} (> mtime1 mtime2) @key{RET}} marks files newer in this
in both directories, as always.
@cindex drag and drop, Dired
- On the X Window System, Emacs supports the ``drag and drop''
+ On the X Window System, Emacs supports the drag and drop
protocol. You can drag a file object from another program, and drop
it onto a Dired buffer; this either moves, copies, or creates a link
to the file in that directory. Precisely which action is taken is
displays only a portion of it. @dfn{Scrolling} commands change which
portion of the buffer is displayed.
- Scrolling ``forward'' or ``up'' advances the portion of the buffer
+ Scrolling forward or up advances the portion of the buffer
displayed in the window; equivalently, it moves the buffer text
-upwards relative to the window. Scrolling ``backward'' or ``down''
+upwards relative to the window. Scrolling backward or down
displays an earlier portion of the buffer, and moves the text
downwards relative to the window.
- In Emacs, scrolling ``up'' or ``down'' refers to the direction that
+ In Emacs, scrolling up or down refers to the direction that
the text moves in the window, @emph{not} the direction that the window
moves relative to the text. This terminology was adopted by Emacs
before the modern meaning of ``scrolling up'' and ``scrolling down''
became widespread. Hence, the strange result that @key{PageDown}
-scrolls ``up'' in the Emacs sense.
+scrolls up in the Emacs sense.
The portion of a buffer displayed in a window always contains point.
If you move point past the bottom or top of the window, scrolling
@cindex synchronizing windows
@dfn{Follow mode} is a minor mode that makes two windows, both
-showing the same buffer, scroll as a single tall ``virtual window''.
+showing the same buffer, scroll as a single tall virtual window.
To use Follow mode, go to a frame with just one window, split it into
two side-by-side windows using @kbd{C-x 3}, and then type @kbd{M-x
follow-mode}. From then on, you can edit the buffer in either of the
This face is used to highlight the current Query Replace match
(@pxref{Replace}).
@item lazy-highlight
-This face is used to highlight ``lazy matches'' for Isearch and Query
+This face is used to highlight lazy matches for Isearch and Query
Replace (matches other than the current one).
@item region
This face is used for displaying an active region (@pxref{Mark}).
The face for displaying control characters and escape sequences
(@pxref{Text Display}).
@item nobreak-space
-The face for displaying ``no-break'' space characters (@pxref{Text
+The face for displaying no-break space characters (@pxref{Text
Display}).
@end table
@cindex faces for mode lines
This face is used for the mode line of the currently selected window,
and for menu bars when toolkit menus are not used. By default, it's
-drawn with shadows for a ``raised'' effect on graphical displays, and
+drawn with shadows for a raised effect on graphical displays, and
drawn as the inverse of the default face on non-windowed terminals.
@item mode-line-inactive
@cindex mode-line-inactive face
The most common use of the fringes is to indicate a continuation
line (@pxref{Continuation Lines}). When one line of text is split
into multiple screen lines, the left fringe shows a curving arrow for
-each screen line except the first, indicating that ``this is not the
-real beginning''. The right fringe shows a curving arrow for each
-screen line except the last, indicating that ``this is not the real
-end''. If the line's direction is right-to-left (@pxref{Bidirectional
+each screen line except the first, indicating that this is not the
+real beginning. The right fringe shows a curving arrow for each
+screen line except the last, indicating that this is not the real
+end. If the line's direction is right-to-left (@pxref{Bidirectional
Editing}), the meanings of the curving arrows in the fringes are
swapped.
The fringes indicate line truncation (@pxref{Line Truncation}) with
-short horizontal arrows meaning ``there's more text on this line which
-is scrolled horizontally out of view''. Clicking the mouse on one of
+short horizontal arrows meaning there's more text on this line which
+is scrolled horizontally out of view. Clicking the mouse on one of
the arrows scrolls the display horizontally in the direction of the
arrow.
@code{trailing-whitespace}.
This feature does not apply when point is at the end of the line
-containing the whitespace. Strictly speaking, that is ``trailing
-whitespace'' nonetheless, but displaying it specially in that case
+containing the whitespace. Strictly speaking, that is trailing
+whitespace nonetheless, but displaying it specially in that case
looks ugly while you are typing in new text. In this special case,
the location of point is enough to show you that the spaces are
present.
@findex whitespace-mode
@vindex whitespace-style
Whitespace mode is a buffer-local minor mode that lets you
-``visualize'' many kinds of whitespace in the buffer, by either
+visualize many kinds of whitespace in the buffer, by either
drawing the whitespace characters with a special face or displaying
them as special glyphs. To toggle this mode, type @kbd{M-x
whitespace-mode}. The kinds of whitespace visualized are determined
specify the mail file to check, or set
@code{display-time-mail-directory} to specify the directory to check
for incoming mail (any nonempty regular file in the directory is
-considered as ``newly arrived mail'').
+considered to be newly arrived mail).
@cindex battery status (on mode line)
@findex display-battery-mode
@vindex visible-cursor
On a text terminal, the cursor's appearance is controlled by the
terminal, largely out of the control of Emacs. Some terminals offer
-two different cursors: a ``visible'' static cursor, and a ``very
-visible'' blinking cursor. By default, Emacs uses the very visible
+two different cursors: a visible static cursor, and a very
+visible blinking cursor. By default, Emacs uses the very visible
cursor, and switches to it when you start or resume Emacs. If the
variable @code{visible-cursor} is @code{nil} when Emacs starts or
resumes, it uses the normal cursor.
@noindent
to your init file. Alternatively, you can change how the cursor
-looks when it ``blinks off'' by customizing the list variable
+looks when it blinks off by customizing the list variable
@code{blink-cursor-alist}. Each element in the list should have the
form @code{(@var{on-type} . @var{off-type})}; this means that if the
cursor is displayed as @var{on-type} when it blinks on (where
@vindex x-stretch-cursor
@cindex wide block cursor
- Some characters, such as tab characters, are ``extra wide''. When
+ Some characters, such as tab characters, are extra wide. When
the cursor is positioned over such a character, it is normally drawn
with the default character width. You can make the cursor stretch to
cover wide characters, by changing the variable
On graphical displays, Emacs displays the mouse pointer as an
hourglass if Emacs is busy. To disable this feature, set the variable
@code{display-hourglass} to @code{nil}. The variable
-@code{hourglass-delay} determines the number of seconds of ``busy
-time'' before the hourglass is shown; the default is 1.
+@code{hourglass-delay} determines the number of seconds of busy
+time before the hourglass is shown; the default is 1.
@vindex make-pointer-invisible
If the mouse pointer lies inside an Emacs frame, Emacs makes it
invisible each time you type a character to insert text, to prevent it
from obscuring the text. (To be precise, the hiding occurs when you
-type a ``self-inserting'' character. @xref{Inserting Text}.) Moving
+type a self-inserting character. @xref{Inserting Text}.) Moving
the mouse pointer makes it visible again. To disable this feature,
set the variable @code{make-pointer-invisible} to @code{nil}.
* Help:: Commands for asking Emacs about its commands.
Important Text-Changing Commands
-* Mark:: The mark: how to delimit a ``region'' of text.
+* Mark:: The mark: how to delimit a region of text.
* Killing:: Killing (cutting) and yanking (copying) text.
* Registers:: Saving a text string or a location in the buffer.
* Display:: Controlling what text is displayed.
* Files:: All about handling files.
* Buffers:: Multiple buffers; editing several files at once.
* Windows:: Viewing multiple pieces of text in one frame.
-* Frames:: Using multiple ``windows'' on your display.
+* Frames:: Using multiple windows on your display.
* International:: Using non-@acronym{ASCII} character sets.
Advanced Features
@end ifnottex
* Editing Binary Files:: Editing binary files with Hexl mode.
* Saving Emacs Sessions:: Saving Emacs state from one session to the next.
-* Recursive Edit:: Performing edits while ``within another command''.
+* Recursive Edit:: Performing edits while within another command.
* Hyperlinking:: Following links in buffers.
* Amusements:: Various games and hacks.
* Packages:: Installing additional features.
* Language Help:: Help relating to international language support.
* Misc Help:: Other help commands.
* Help Files:: Commands to display auxiliary help files.
-* Help Echo:: Help on active text and tooltips (``balloon help'').
+* Help Echo:: Help on active text and tooltips.
The Mark and the Region
* Earlier Kills:: Yanking something killed some time ago.
* Appending Kills:: Several kills in a row all yank together.
-``Cut and Paste'' Operations on Graphical Displays
+Cut and Paste Operations on Graphical Displays
* Clipboard:: How Emacs uses the system clipboard.
* Primary Selection:: The temporarily selected text selection.
* Customize Save:: Customizing the saving of files.
* Interlocking:: How Emacs protects against simultaneous editing
of one file by two users.
-* File Shadowing:: Copying files to ``shadows'' automatically.
+* File Shadowing:: Copying files to shadows automatically.
* Time Stamps:: Emacs can update time stamps on saved files.
Backup Files
* TeX Mode:: Editing TeX and LaTeX files.
* HTML Mode:: Editing HTML and SGML files.
* Nroff Mode:: Editing input to the nroff formatter.
-* Enriched Text:: Editing text ``enriched'' with fonts, colors, etc.
+* Enriched Text:: Editing text enriched with fonts, colors, etc.
* Text Based Tables:: Commands for editing text-based tables.
* Two-Column:: Splitting text columns into separate windows.
* Enriched Indentation:: Changing the left and right margins.
* Enriched Justification:: Centering, setting text flush with the
left or right margin, etc.
-* Enriched Properties:: The ``special'' text properties submenu.
+* Enriched Properties:: The special text properties submenu.
@c The automatic texinfo menu update inserts some duplicate items here
@c (faces, colors, indentation, justification, properties), because
* Basic Picture:: Basic concepts and simple commands of Picture Mode.
* Insert in Picture:: Controlling direction of cursor motion
- after ``self-inserting'' characters.
+ after self-inserting characters.
* Tabs in Picture:: Various features for tab stops and indentation.
* Rectangles in Picture:: Clearing and superimposing rectangles.
@end ifnottex
to decide what to do; by setting variables,
you can control their functioning.
* Key Bindings:: The keymaps say what command each key runs.
- By changing them, you can ``redefine'' keys.
+ By changing them, you can redefine keys.
* Init File:: How to write common customizations in the
initialization file.
If Skip Prefers mode is in effect, the @kbd{n} and @kbd{p} commands
skip over differences in states ``prefer-A'' and ``prefer-B''
(@pxref{State of Difference}). Thus you see only differences for
-which neither version is presumed ``correct''. The mode line
+which neither version is presumed correct. The mode line
indicates Skip Prefers mode with @samp{S}. This mode is only relevant
when there is an ancestor.
The difference is showing the A or the B state by default, because you
haven't made a choice. All differences start in the default-A state
(and thus the merge buffer is a copy of the A buffer), except those for
-which one alternative is ``preferred'' (see below).
+which one alternative is preferred (see below).
When you select a difference, its state changes from default-A or
default-B to plain A or B@. Thus, the selected difference never has
Kill Emacs (@code{save-buffers-kill-terminal}).
@item C-z
On a text terminal, suspend Emacs; on a graphical display,
-``minimize'' the selected frame (@code{suspend-emacs}).
+iconify or minimize the selected frame (@code{suspend-emacs}).
@end table
@kindex C-x C-c
subprocesses (@pxref{Shell}).
@kbd{C-x C-c} behaves specially if you are using Emacs as a server.
-If you type it from a ``client frame'', it closes the client
+If you type it from a client frame, it closes the client
connection. @xref{Emacs Server}.
Emacs can, optionally, record certain session information when you
history commands (@pxref{Minibuffer}). Note that file name completion
ignores file names whose extensions appear in the variable
@code{completion-ignored-extensions} (@pxref{Completion Options}).
-Note also that most commands use ``permissive completion with
-confirmation'' for reading file names: you are allowed to submit a
+Note also that most commands use permissive completion with
+confirmation for reading file names: you are allowed to submit a
nonexistent file name, but if you type @key{RET} immediately after
completing up to a nonexistent file name, Emacs prints
@samp{[Confirm]} and you must type a second @key{RET} to confirm.
@file{/u/rms/gnu/new/foo}.
When typing a file name into the minibuffer, you can make use of a
-couple of shortcuts: a double slash is interpreted as ``ignore
-everything before the second slash in the pair'', and @samp{~/} is
-interpreted as your home directory. @xref{Minibuffer File}.
+couple of shortcuts: a double slash ignores everything before the
+second slash in the pair, and @samp{~/} is your home directory.
+@xref{Minibuffer File}.
@cindex environment variables in file names
@cindex expansion of environment variables
error in typing the name.
@vindex find-file-run-dired
- If you ``visit'' a file that is actually a directory, Emacs invokes
+ If you visit a file that is actually a directory, Emacs invokes
Dired, the Emacs directory browser. @xref{Dired}. You can disable
this behavior by setting the variable @code{find-file-run-dired} to
@code{nil}; in that case, it is an error to try to visit a directory.
On graphical displays, there are two additional methods for visiting
files. Firstly, when Emacs is built with a suitable GUI toolkit,
commands invoked with the mouse (by clicking on the menu bar or tool
-bar) use the toolkit's standard ``File Selection'' dialog instead of
+bar) use the toolkit's standard file selection dialog instead of
prompting for the file name in the minibuffer. On GNU/Linux and Unix
platforms, Emacs does this when built with GTK, LessTif, and Motif
toolkits; on MS-Windows and Mac, the GUI version does that by default.
For information on how to customize this, see @ref{Dialog Boxes}.
- Secondly, Emacs supports ``drag and drop'': dropping a file into an
+ Secondly, Emacs supports drag and drop: dropping a file into an
ordinary Emacs window visits the file using that window. As an
exception, dropping a file into a window displaying a Dired buffer
moves or copies the file into the displayed directory. For details,
On text-mode terminals and on graphical displays when Emacs was
built without a GUI toolkit, you can visit files via the menu-bar
-``File'' menu, which has a ``Visit New File'' item.
+@samp{File} menu, which has a @samp{Visit New File} item.
Each time you visit a file, Emacs automatically scans its contents
to detect what character encoding and end-of-line convention it uses,
* Customize Save:: Customizing the saving of files.
* Interlocking:: How Emacs protects against simultaneous editing
of one file by two users.
-* Shadowing: File Shadowing. Copying files to ``shadows'' automatically.
+* Shadowing: File Shadowing. Copying files to shadows automatically.
* Time Stamps:: Emacs can update time stamps on saved files.
@end menu
changes the buffer name correspondingly. @code{set-visited-file-name}
does not save the buffer in the newly visited file; it just alters the
records inside Emacs in case you do save later. It also marks the
-buffer as ``modified'' so that @kbd{C-x C-s} in that buffer
+buffer as modified so that @kbd{C-x C-s} in that buffer
@emph{will} save.
@kindex C-x C-w
approximately the same part of the text as before. But if you have
made major changes, point may end up in a totally different location.
- Reverting marks the buffer as ``not modified''. It also clears the
+ Reverting marks the buffer as not modified. It also clears the
buffer's undo history (@pxref{Undo}). Thus, the reversion cannot be
undone---if you change your mind yet again, you can't use the undo
commands to bring the reverted changes back.
Auto-Revert mode. These minor modes do not check or revert remote
files, because that is usually too slow.
- One use of Auto-Revert mode is to ``tail'' a file such as a system
+ One use of Auto-Revert mode is to tail a file such as a system
log, so that changes made to that file by other programs are
continuously displayed. To do this, just move the point to the end of
the buffer, and it will stay there as the file contents change.
@cindex directory name abbreviation
@vindex directory-abbrev-alist
Sometimes, a directory is ordinarily accessed through a symbolic
-link, and you may want Emacs to preferentially show its ``linked''
+link, and you may want Emacs to preferentially show its linked
name. To do this, customize @code{directory-abbrev-alist}. Each
element in this list should have the form @code{(@var{from}
. @var{to})}, which means to replace @var{from} with @var{to} whenever
The command @kbd{M-x delete-directory} prompts for a directory name
using the minibuffer, and deletes the directory if it is empty. If
the directory is not empty, you will be asked whether you want to
-delete it recursively. On systems that have a ``Trash'' (or ``Recycle
-Bin'') feature, you can make this command move the specified directory
+delete it recursively. On systems that have a Trash (or Recycle
+Bin) feature, you can make this command move the specified directory
to the Trash instead of deleting it outright, by changing the variable
@code{delete-by-moving-to-trash} to @code{t}. @xref{Misc File Ops},
for more information about using the Trash.
You can use @kbd{M-x smerge-mode} to turn on Smerge mode, a minor
mode for editing output from the @command{diff3} program. This is
typically the result of a failed merge from a version control system
-``update'' outside VC, due to conflicting changes to a file. Smerge
+update outside VC, due to conflicting changes to a file. Smerge
mode provides commands to resolve conflicts by selecting specific
changes.
read-only, you need to make it writable first. @xref{Misc Buffer}.)
Whenever you change a hunk, Diff mode attempts to automatically
correct the line numbers in the hunk headers, to ensure that the patch
-remains ``correct''. To disable automatic line number correction,
+remains correct. To disable automatic line number correction,
change the variable @code{diff-update-on-the-fly} to @code{nil}.
- Diff mode treats each hunk as an ``error message'', similar to
+ Diff mode treats each hunk as an error message, similar to
Compilation mode. Thus, you can use commands such as @kbd{C-x `} to
visit the corresponding source locations. @xref{Compilation Mode}.
@cindex hard links (creation)
@kbd{M-x add-name-to-file} adds an additional name to an existing
file without removing its old name. The new name is created as a
-``hard link'' to the existing file. The new name must belong on the
+hard link to the existing file. The new name must belong on the
same file system that the file is on. On MS-Windows, this command
works only if the file resides in an NTFS file system. On MS-DOS, it
works by copying the file.
@findex insert-file-literally
@kbd{M-x insert-file-literally} is like @kbd{M-x insert-file},
-except the file is inserted ``literally'': it is treated as a sequence
+except the file is inserted literally: it is treated as a sequence
of @acronym{ASCII} characters with no special encoding or conversion,
similar to the @kbd{M-x find-file-literally} command
(@pxref{Visiting}).
@code{imagemagick-types-inhibit} lists the image types which should
never be rendered using ImageMagick, regardless of the value of
@code{imagemagick-enabled-types} (the default list includes types like
-@code{C} and @code{HTML}, which ImageMagick can render as an ``image''
+@code{C} and @code{HTML}, which ImageMagick can render as an image
but Emacs should not). To disable ImageMagick entirely, change
@code{imagemagick-types-inhibit} to @code{t}.
a fileset. These commands are also available from the @samp{Filesets}
menu, where each existing fileset is represented by a submenu.
- @xref{Version Control}, for a different concept of ``filesets'':
+ @xref{Version Control}, for a different concept of filesets:
groups of files bundled together for version control operations.
Filesets of that type are unnamed, and do not persist across Emacs
sessions.
When one of these commands encounters what appears to be an
incorrect word, it asks you what to do. It usually displays a list of
-numbered ``near-misses''---words that are close to the incorrect word.
+numbered @dfn{near-misses}---words that are close to the incorrect word.
Then you must type a single-character response. Here are the valid
responses:
@item l @var{word} @key{RET}
Look in the dictionary for words that match @var{word}. These words
-become the new list of ``near-misses''; you can select one of them as
+become the new list of near-misses; you can select one of them as
the replacement by typing a digit. You can use @samp{*} in @var{word} as a
wildcard.
@cindex Fortran 77 and Fortran 90, 95, 2003, 2008
@findex f90-mode
@findex fortran-mode
- Fortran mode is meant for editing ``fixed form'' (and also ``tab
-format'') source code (normally Fortran 77). For editing more modern
-``free form'' source code (Fortran 90, 95, 2003, 2008), use F90 mode
+ Fortran mode is meant for editing fixed form (and also tab
+format) source code (normally Fortran 77). For editing more modern
+free-form source code (Fortran 90, 95, 2003, 2008), use F90 mode
(@code{f90-mode}). Emacs normally uses Fortran mode for files with
extension @samp{.f}, @samp{.F} or @samp{.for}, and F90 mode for the
extensions @samp{.f90}, @samp{.f95}, @samp{.f03} and @samp{.f08}.
@subsection Motion Commands
In addition to the normal commands for moving by and operating on
-``defuns'' (Fortran subprograms---functions and subroutines, as well
+defuns (Fortran subprograms---functions and subroutines, as well
as modules for F90 mode, using the commands @code{fortran-end-of-subprogram}
and @code{fortran-beginning-of-subprogram}), Fortran mode provides
special commands to move by statements and other program units.
@code{fortran-continuation-string} specifies what character to put in
column 5. A line that starts with a tab character followed by any digit
except @samp{0} is also a continuation line. We call this style of
-continuation @dfn{tab format}. (Fortran 90 introduced ``free form'',
-with another style of continuation lines).
+continuation @dfn{tab format}. (Fortran 90 introduced free-form
+continuation lines.)
@vindex indent-tabs-mode @r{(Fortran mode)}
@vindex fortran-analyze-depth
@table @kbd
@item C-c C-r
-Display a ``column ruler'' momentarily above the current line
+Display a column ruler momentarily above the current line
(@code{fortran-column-ruler}).
@item C-c C-w
Split the current window horizontally temporarily so that it is
@cindex frames
When Emacs is started on a graphical display, e.g., on the X Window
-System, it occupies a graphical system-level ``window''. In this
+System, it occupies a graphical system-level display region. In this
manual, we call this a @dfn{frame}, reserving the word ``window'' for
the part of the frame used for displaying a buffer. A frame initially
contains one window, but it can be subdivided into multiple windows
This chapter describes Emacs features specific to graphical displays
(particularly mouse commands), and features for managing multiple
frames. On text terminals, many of these features are unavailable.
-However, it is still possible to create multiple ``frames'' on text
+However, it is still possible to create multiple frames on text
terminals; such frames are displayed one at a time, filling the entire
terminal screen (@pxref{Non-Window Terminals}). It is also possible
to use the mouse on some text terminals (@pxref{Text-Only Mouse}, for
@cindex mouse, dragging
@findex mouse-set-region
- Holding down @kbd{Mouse-1} and ``dragging'' the mouse over a stretch
+ Holding down @kbd{Mouse-1} and dragging the mouse over a stretch
of text activates the region around that text
(@code{mouse-set-region}), placing the mark where you started holding
down the mouse button, and point where you release it (@pxref{Mark}).
@vindex mouse-wheel-follow-mouse
@vindex mouse-wheel-scroll-amount
@vindex mouse-wheel-progressive-speed
- Some mice have a ``wheel'' which can be used for scrolling. Emacs
+ Some mice have a wheel which can be used for scrolling. Emacs
supports scrolling windows with the mouse wheel, by default, on most
graphical displays. To toggle this feature, use @kbd{M-x
mouse-wheel-mode}. The variables @code{mouse-wheel-follow-mouse} and
@item Double-Mouse-1
Select the text around the word which you click on.
-Double-clicking on a character with ``symbol'' syntax (such as
+Double-clicking on a character with symbol syntax (such as
underscore, in C mode) selects the symbol surrounding that character.
Double-clicking on a character with open- or close-parenthesis syntax
selects the parenthetical grouping which that character starts or
The prefix key @kbd{C-x 5} is analogous to @kbd{C-x 4}. Whereas
each @kbd{C-x 4} command pops up a buffer in a different window in the
selected frame (@pxref{Pop Up Window}), the @kbd{C-x 5} commands use a
-different frame. If an existing visible or iconified (``minimized'')
+different frame. If an existing visible or iconified (minimized)
frame already displays the requested buffer, that frame is raised and
-deiconified (``un-minimized''); otherwise, a new frame is created on
+deiconified (un-minimized); otherwise, a new frame is created on
the current display terminal.
The various @kbd{C-x 5} commands differ in how they find or create the
@item C-z
@kindex C-z @r{(X windows)}
@findex suspend-frame
-Minimize (or ``iconify'') the selected Emacs frame
+Minimize (or iconify) the selected Emacs frame
(@code{suspend-frame}). @xref{Exiting}.
@item C-x 5 o
@kindex <F11>
@findex toggle-frame-fullscreen
Toggle fullscreen mode for the current frame. (The difference
-between ``fullscreen'' and ``maximized'' is normally that the former
+between fullscreen and maximized is normally that the former
hides window manager decorations, giving slightly more screen space to
Emacs itself.)
@end table
@vindex frame-resize-pixelwise
Note that with some window managers you may have to customize the
variable @code{frame-resize-pixelwise} to a non-@code{nil} value in
-order to make a frame truly ``maximized'' or ``fullscreen''. This
+order to make a frame truly maximized or fullscreen. This
variable, when set to a non-@code{nil} value, in general allows
resizing frames at pixel resolution, rather than in integral multiples
of lines and columns.
frame. However, it will refuse to delete the last frame in an Emacs
session, to prevent you from losing the ability to interact with the
Emacs session. Note that when Emacs is run as a daemon (@pxref{Emacs
-Server}), there is always a ``virtual frame'' that remains after all
+Server}), there is always a virtual frame that remains after all
the ordinary, interactive frames are deleted. In this case, @kbd{C-x
5 0} can delete the last interactive frame; you can use
@command{emacsclient} to reconnect to the Emacs session.
names the font that it's rendered in.
@cindex fontconfig
- On X, there are four different ways to express a ``font name''. The
+ On X, there are four different ways to express a font name. The
first is to use a @dfn{Fontconfig pattern}. Fontconfig patterns have
the following form:
@samp{1} for @var{encoding}.
@end table
- The fourth and final method of specifying a font is to use a ``font
-nickname''. Certain fonts have shorter nicknames, which you can use
+ The fourth and final method of specifying a font is to use a font
+nickname. Certain fonts have shorter nicknames, which you can use
instead of a normal font specification. For instance, @samp{6x13} is
equivalent to
@vindex x-gtk-file-dialog-help-text
@cindex hidden files, in GTK+ file chooser
@cindex help text, in GTK+ file chooser
- When Emacs is compiled with GTK+ support, it uses the GTK+ ``file
-chooser'' dialog. Emacs adds an additional toggle button to this
+ When Emacs is compiled with GTK+ support, it uses the GTK+ file
+chooser dialog. Emacs adds an additional toggle button to this
dialog, which you can use to enable or disable the display of hidden
files (files starting with a dot) in that dialog. If you want this
toggle to be activated by default, change the variable
Some human languages, such as English, are written from left to right.
Others, such as Arabic, are written from right to left. Emacs
supports both of these forms, as well as any mixture of them---this
-is ``bidirectional text''. @xref{Bidirectional Editing}.
+is bidirectional text. @xref{Bidirectional Editing}.
@item Bind
To bind a key sequence means to give it a binding (q.v.).
@item Buffer
The buffer is the basic editing unit; one buffer corresponds to one text
being edited. You normally have several buffers, but at any time you are
-editing only one, the ``current buffer'', though several can be visible
+editing only one, the current buffer, though several can be visible
when you are using multiple windows or frames (q.v.). Most buffers
are visiting (q.v.@:) some file. @xref{Buffers}.
screen line when displayed. We say that the text line is continued, and all
screen lines used for it after the first are called continuation
lines. @xref{Continuation Lines}. A related Emacs feature is
-``filling'' (q.v.).
+filling (q.v.).
@item Control Character
A control character is a character that you type by holding down the
GNU General Public License. @xref{Copying}.
@item @key{Ctrl}
-The @key{Ctrl} or ``control'' key is what you hold down
+The @key{Ctrl} or control key is what you hold down
in order to enter a control character (q.v.). @xref{Glossary---C-}.
@item Current Buffer
@anchor{Glossary---Deletion of Files}
@item Deletion of Files
Deleting a file means erasing it from the file system.
-(Note that some systems use the concept of a ``trash can'', or ``recycle
-bin'', to allow you to ``undelete'' files.)
+(Note that some systems use the concept of a trash can, or recycle
+bin, to allow you to undelete files.)
@xref{Misc File Ops,Misc File Ops,Miscellaneous File Operations}.
@item Deletion of Messages
@item Dired
Dired is the Emacs facility that displays the contents of a file
-directory and allows you to ``edit the directory'', performing
+directory and allows you to edit the directory, performing
operations on the files in the directory. @xref{Dired}.
@item Disabled Command
@item Fringe
On a graphical display (q.v.), there's a narrow portion of the frame
(q.v.@:) between the text area and the window's border. These
-``fringes'' are used to display symbols that provide information about
+fringes are used to display symbols that provide information about
the buffer text (@pxref{Fringes}). Emacs displays the fringe using a
special face (q.v.@:) called @code{fringe}. @xref{Faces,fringe}.
Quoting means depriving a character of its usual special significance.
The most common kind of quoting in Emacs is with @kbd{C-q}. What
constitutes special significance depends on the context and on
-convention. For example, an ``ordinary'' character as an Emacs command
+convention. For example, an ordinary character as an Emacs command
inserts itself; so in this context, a special character is any character
that does not normally insert itself (such as @key{DEL}, for example),
and quoting it makes it insert itself as if it were not special. Not
@item Register
Registers are named slots in which text, buffer positions, or
rectangles can be saved for later use. @xref{Registers}. A related
-Emacs feature is ``bookmarks'' (q.v.).
+Emacs feature is bookmarks (q.v.).
@anchor{Glossary---Regular Expression}
@item Regular Expression
* Language Help:: Help relating to international language support.
* Misc Help:: Other help commands.
* Help Files:: Commands to display auxiliary help files.
-* Help Echo:: Help on active text and tooltips (``balloon help'').
+* Help Echo:: Help on active text and tooltips.
@end menu
@iftex
Display information about ordering printed copies of Emacs manuals
(@code{view-order-manuals}).
@item C-h C-n
-Display the ``news'' file, which lists the new features in this
+Display the news, which lists the new features in this
version of Emacs (@code{view-emacs-news}).
@item C-h C-o
Display how to order or download the latest version of
@cindex tooltips
@cindex balloon help
- In Emacs, stretches of ``active text'' (text that does something
+ In Emacs, stretches of active text (text that does something
special in response to mouse clicks or @key{RET}) often have
associated help text. This includes hyperlinks in Emacs buffers, as
well as parts of the mode line. On graphical displays, as well as
combination of space and tab characters to advance point to the next
tab stop (@pxref{Tab Stops}). For this purpose, the position of the
first non-whitespace character on the preceding line is treated as an
-additional tab stop, so you can use @key{TAB} to ``align'' point with
+additional tab stop, so you can use @key{TAB} to align point with
the preceding line. If the region is active (@pxref{Using Region}),
@key{TAB} acts specially: it indents each line in the region so that
its first non-whitespace character is aligned with the preceding line.
@kindex M-^
@findex delete-indentation
Merge the previous and the current line (@code{delete-indentation}).
-This ``joins'' the two lines cleanly, by replacing any indentation at
+This joins the two lines cleanly, by replacing any indentation at
the front of the current line, together with the line boundary, with a
single space.
@findex indent-rigidly
@cindex remove indentation
This command is used to change the indentation of all lines that begin
-in the region, moving the affected lines as a ``rigid'' unit.
+in the region, moving the affected lines as a rigid unit.
If called with no argument, the command activates a transient mode for
adjusting the indentation of the affected lines interactively. While
On graphical displays, @kbd{C-y} first checks if another application
has placed any text in the system clipboard more recently than the
last Emacs kill. If so, it inserts the clipboard's text instead.
-Thus, Emacs effectively treats ``cut'' or ``copy'' clipboard
+Thus, Emacs effectively treats cut or copy clipboard
operations performed in other applications like Emacs kills, except
that they are not recorded in the kill ring. @xref{Cut and Paste},
for details.
with the previous kill. @kbd{M-y} is allowed only after a @kbd{C-y}
or another @kbd{M-y}.
- You can understand @kbd{M-y} in terms of a ``last yank'' pointer which
-points at an entry in the kill ring. Each time you kill, the ``last
-yank'' pointer moves to the newly made entry at the front of the ring.
-@kbd{C-y} yanks the entry which the ``last yank'' pointer points to.
-@kbd{M-y} moves the ``last yank'' pointer to a different entry, and the
+ You can understand @kbd{M-y} in terms of a last-yank pointer which
+points at an entry in the kill ring. Each time you kill, the last-yank
+pointer moves to the newly made entry at the front of the ring.
+@kbd{C-y} yanks the entry which the last-yank pointer points to.
+@kbd{M-y} moves the last-yank pointer to a different entry, and the
text in the buffer changes to match. Enough @kbd{M-y} commands can move
the pointer to any entry in the ring, so you can get any entry into the
buffer. Eventually the pointer reaches the end of the ring; the next
@kbd{M-y} loops back around to the first entry again.
- @kbd{M-y} moves the ``last yank'' pointer around the ring, but it does
+ @kbd{M-y} moves the last-yank pointer around the ring, but it does
not change the order of the entries in the ring, which always runs from
the most recent kill at the front to the oldest one still remembered.
@kbd{M-y} can take a numeric argument, which tells it how many entries
-to advance the ``last yank'' pointer by. A negative argument moves the
+to advance the last-yank pointer by. A negative argument moves the
pointer toward the front of the ring; from the front of the ring, it
-moves ``around'' to the last entry and continues forward from there.
+moves around to the last entry and continues forward from there.
Once the text you are looking for is brought into the buffer, you can
stop doing @kbd{M-y} commands and it will stay there. It's just a copy
of the kill ring entry, so editing it in the buffer does not change
-what's in the ring. As long as no new killing is done, the ``last
-yank'' pointer remains at the same place in the kill ring, so repeating
+what's in the ring. As long as no new killing is done, the last-yank
+pointer remains at the same place in the kill ring, so repeating
@kbd{C-y} will yank another copy of the same previous kill.
When you call @kbd{C-y} with a numeric argument, that also sets the
-``last yank'' pointer to the entry that it yanks.
+last-yank pointer to the entry that it yanks.
@node Appending Kills
@subsection Appending Kills
append to the text that @kbd{M-w} copied into the kill ring.
@node Cut and Paste
-@section ``Cut and Paste'' Operations on Graphical Displays
+@section Cut and Paste Operations on Graphical Displays
@cindex cut
@cindex copy
@cindex paste
@cindex clipboard
The @dfn{clipboard} is the facility that most graphical applications
-use for ``cutting and pasting''. When the clipboard exists, the kill
+use for cutting and pasting. When the clipboard exists, the kill
and yank commands in Emacs make use of it.
When you kill some text with a command such as @kbd{C-w}
if that data turns out to be large.
Yank commands, such as @kbd{C-y} (@code{yank}), also use the
-clipboard. If another application ``owns'' the clipboard---i.e., if
+clipboard. If another application owns the clipboard---i.e., if
you cut or copied text there more recently than your last kill command
in Emacs---then Emacs yanks from the clipboard instead of the kill
ring.
@vindex x-select-enable-clipboard-manager
Many X desktop environments support a feature called the
@dfn{clipboard manager}. If you exit Emacs while it is the current
-``owner'' of the clipboard data, and there is a clipboard manager
+owner of the clipboard data, and there is a clipboard manager
running, Emacs transfers the clipboard data to the clipboard manager
so that it is not lost. In some circumstances, this may cause a delay
when exiting Emacs; if you wish to prevent Emacs from transferring
(usually by dragging the mouse). Typically, this text can be inserted
into other X applications by @kbd{mouse-2} clicks. The primary
selection is separate from the clipboard. Its contents are more
-``fragile''; they are overwritten each time you select text with the
-mouse, whereas the clipboard is only overwritten by explicit ``cut''
-or ``copy'' commands.
+fragile; they are overwritten each time you select text with the
+mouse, whereas the clipboard is only overwritten by explicit cut
+or copy commands.
Under X, whenever the region is active (@pxref{Mark}), the text in
the region is saved in the primary selection. This applies regardless
@table @kbd
@item C-x r k
Kill the text of the region-rectangle, saving its contents as the
-``last killed rectangle'' (@code{kill-rectangle}).
+last killed rectangle (@code{kill-rectangle}).
@item C-x r M-w
-Save the text of the region-rectangle as the ``last killed rectangle''
+Save the text of the region-rectangle as the last killed rectangle
(@code{copy-rectangle-as-kill}).
@item C-x r d
Delete the text of the region-rectangle (@code{delete-rectangle}).
the rectangle; if there is any following text on the line, it moves
backwards to fill the gap.
- ``Killing'' a rectangle is not killing in the usual sense; the
+ Killing a rectangle is not killing in the usual sense; the
rectangle is not stored in the kill ring, but in a special place that
only records the most recent rectangle killed. This is because
yanking a rectangle is so different from yanking linear text that
@kindex C-x r M-w
@findex copy-rectangle-as-kill
@kbd{C-x r M-w} (@code{copy-rectangle-as-kill}) is the equivalent of
-@kbd{M-w} for rectangles: it records the rectangle as the ``last
-killed rectangle'', without deleting the text from the buffer.
+@kbd{M-w} for rectangles: it records the rectangle as the last
+killed rectangle, without deleting the text from the buffer.
@kindex C-x r y
@findex yank-rectangle
@end example
@noindent
-will rotate the keyboard macro ring to the ``second previous'' macro,
+will rotate the keyboard macro ring to the second-previous macro,
execute the resulting head macro three times, rotate back to the
-original head macro, execute that once, rotate to the ``previous''
+original head macro, execute that once, rotate to the previous
macro, execute that, and finally delete it from the macro ring.
@findex kmacro-end-or-call-macro-repeat
desired macro is at the head of the ring. To execute the new macro
ring head immediately, just type @kbd{C-k}.
- Note that Emacs treats the head of the macro ring as the ``last
-defined keyboard macro''. For instance, @key{F4} will execute that
+ Note that Emacs treats the head of the macro ring as the last
+defined keyboard macro. For instance, @key{F4} will execute that
macro, and @kbd{C-x C-k n} will give it a name.
@vindex kmacro-ring-max
On GNUstep, in an X-windows environment you need to use @kbd{Cmd-c}
instead of one of the @kbd{C-w} or @kbd{M-w} commands to transfer text
to the X primary selection; otherwise, Emacs will use the
-``clipboard'' selection. Likewise, @kbd{Cmd-y} (instead of @kbd{C-y})
+clipboard selection. Likewise, @kbd{Cmd-y} (instead of @kbd{C-y})
yanks from the X primary selection instead of the kill-ring or
clipboard.
@section Windowing System Events under Mac OS / GNUstep
Nextstep applications receive a number of special events which have
-no X equivalent. These are sent as specially defined ``keys'', which
+no X equivalent. These are sent as specially defined key events, which
do not correspond to any sequence of keystrokes. Under Emacs, these
-``key'' events can be bound to functions just like ordinary
+key events can be bound to functions just like ordinary
keystrokes. Here is a list of these events.
@table @key
This chapter describes Emacs features for maintaining large
programs. If you are maintaining a large Lisp program, then in
addition to the features described here, you may find
-the @file{ERT} (``Emacs Lisp Regression Testing'') library useful
+the Emacs Lisp Regression Testing (ERT) library useful
(@pxref{Top,,ERT,ert, Emacs Lisp Regression Testing}).
@menu
to the master repository.
On a graphical display, you can move the mouse over this mode line
-indicator to pop up a ``tool-tip'', which displays a more verbose
+indicator to pop up a tool-tip, which displays a more verbose
description of the version control status. Pressing @kbd{Mouse-1}
over the indicator pops up a menu of VC commands, identical to
@samp{Tools / Version Control} on the menu bar.
@findex vc-next-action
@kindex C-x v v
The principal VC command is a multi-purpose command, @kbd{C-x v v}
-(@code{vc-next-action}), which performs the ``most appropriate''
+(@code{vc-next-action}), which performs the most appropriate
action on the current VC fileset: either registering it with a version
control system, or committing it, or unlocking it, or merging changes
into it. The precise actions are described in detail in the following
subsections. You can use @kbd{C-x v v} either in a file-visiting
buffer or in a VC Directory buffer.
- Note that VC filesets are distinct from the ``named filesets'' used
+ Note that VC filesets are distinct from the named filesets used
for viewing and visiting files in functional groups
(@pxref{Filesets}). Unlike named filesets, VC filesets are not named
and don't persist across sessions.
@item
If there is more than one file in the VC fileset and the files have
inconsistent version control statuses, signal an error. (Note,
-however, that a fileset is allowed to include both ``newly-added''
-files and ``modified'' files; @pxref{Registering}.)
+however, that a fileset is allowed to include both newly-added
+files and modified files; @pxref{Registering}.)
@item
If none of the files in the VC fileset are registered with a version
been changed in the repository, offer to update it.
@end itemize
- These rules also apply when you use RCS in its ``non-locking'' mode,
+ These rules also apply when you use RCS in its non-locking mode,
except that changes are not automatically merged from the repository.
Nothing informs you if another user has committed changes in the same
file since you began editing it; when you commit your revision, his
@item
If each file is locked by another user, ask whether you want to
-``steal the lock''. If you say yes, the file becomes locked by you,
+steal the lock. If you say yes, the file becomes locked by you,
and a warning message is sent to the user who had formerly locked the
file.
@end itemize
revision into the working tree. You can also specify a revision on
another branch by giving its revision or branch ID (@pxref{Switching
Branches}). An empty argument (i.e., @kbd{C-u C-x v v @key{RET}})
-checks out the latest (``head'') revision on the current branch.
+checks out the latest (head) revision on the current branch.
This signals an error on a decentralized version control system.
Those systems do not let you specify your own revision IDs, nor do
-they use the concept of ``checking out'' individual files.
+they use the concept of checking out individual files.
@end itemize
@node Log Buffer
@findex log-edit-show-files
@kindex C-c C-d @r{(Log Edit mode)}
@findex log-edit-show-diff
- While in the @file{*vc-log*} buffer, the ``current VC fileset'' is
+ While in the @file{*vc-log*} buffer, the current VC fileset is
considered to be the fileset that will be committed if you type
@w{@kbd{C-c C-c}}. To view a list of the files in the VC fileset,
type @w{@kbd{C-c C-f}} (@code{log-edit-show-files}). To view a diff
registers the file into that repository.
On most version control systems, registering a file with @kbd{C-x v
-i} or @kbd{C-x v v} adds it to the ``working tree'' but not to the
+i} or @kbd{C-x v v} adds it to the working tree but not to the
repository. Such files are labeled as @samp{added} in the VC
Directory buffer, and show a revision ID of @samp{@@@@} in the mode
line. To make the registration take effect in the repository, you
@kindex C-x v g
Many version control systems allow you to view files @dfn{annotated}
with per-line revision information, by typing @kbd{C-x v g}
-(@code{vc-annotate}). This creates a new buffer (the ``annotate
-buffer'') displaying the file's text, with each line colored to show
+(@code{vc-annotate}). This creates a new annotate buffer
+displaying the file's text, with each line colored to show
how old it is. Red text is new, blue is old, and intermediate colors
indicate intermediate ages. By default, the color is scaled over the
full range of ages, such that the oldest changes are blue, and the
On a decentralized version control system, the @kbd{C-x v I}
(@code{vc-log-incoming}) command displays a log buffer showing the
changes that will be applied, the next time you run the version
-control system's ``pull'' command to get new revisions from another
+control system's pull command to get new revisions from another
repository (@pxref{Pulling / Pushing}). This other repository is the default
one from which changes are pulled, as defined by the version control
system; with a prefix argument, @code{vc-log-incoming} prompts for a
specific repository. Similarly, @kbd{C-x v O}
(@code{vc-log-outgoing}) shows the changes that will be sent to
-another repository, the next time you run the ``push'' command; with a
+another repository, the next time you run the push command; with a
prefix argument, it prompts for a specific destination repository.
In the @file{*vc-change-log*} buffer, you can use the following keys
The VC Directory buffer contains a list of version-controlled files
and their version control statuses. It lists files in the current
directory (the one specified when you called @kbd{C-x v d}) and its
-subdirectories, but only those with a ``noteworthy'' status. Files
+subdirectories, but only those with a noteworthy status. Files
that are up-to-date (i.e., the same as in the repository) are
omitted. If all the files in a subdirectory are up-to-date, the
subdirectory is not listed either. As an exception, if a file has
@subsubsection VC Directory Commands
Emacs provides several commands for navigating the VC Directory
-buffer, and for ``marking'' files as belonging to the current VC
+buffer, and for marking files as belonging to the current VC
fileset.
@table @kbd
One use of version control is to support multiple independent lines
of development, which are called @dfn{branches}. Amongst other
-things, branches can be used for maintaining separate ``stable'' and
-``development'' versions of a program, and for developing unrelated
+things, branches can be used for maintaining separate stable and
+development versions of a program, and for developing unrelated
features in isolation from one another.
VC's support for branch operations is currently fairly limited. For
@table @kbd
@item C-x v +
On a decentralized version control system, update the current branch
-by ``pulling in'' changes from another location.
+by pulling in changes from another location.
On a centralized version control system, update the current VC
fileset.
@item C-x v P
-On a decentralized version control system, ``push'' changes from the
+On a decentralized version control system, push changes from the
current branch to another location. This concept does not exist
for centralized version control systems.
@end table
A project may contain one or more @dfn{targets}. A target can be an
object file, executable program, or some other type of file, which is
-``built'' from one or more of the files in the project.
+built from one or more of the files in the project.
To add a new @dfn{target} to a project, type @kbd{C-c . t}
(@code{M-x ede-new-target}). This command also asks if you wish to
-``add'' the current file to that target, which means that the target
+add the current file to that target, which means that the target
is to be built from that file. After you have defined a target, you
can add more files to it by typing @kbd{C-c . a}
(@code{ede-add-file}).
if the variable @code{highlight-nonselected-windows} is
non-@code{nil}, each window highlights its own region.
- There is another kind of region: the ``rectangular region''.
+ There is another kind of region: the rectangular region.
@xref{Rectangles}.
@menu
the above example.
Instead of setting the mark in order to operate on a region, you can
-also use it to ``remember'' a position in the buffer (by typing
+also use it to remember a position in the buffer (by typing
@kbd{C-@key{SPC} C-@key{SPC}}), and later jump back there (by typing
@kbd{C-u C-@key{SPC}}). @xref{Mark Ring}, for details.
behavior. Such commands usually have the word @code{region} in their
names, like @kbd{C-w} (@code{kill-region}) and @code{C-x C-u}
(@code{upcase-region}). If the mark is inactive, they operate on the
-``inactive region''---that is, on the text between point and the
+@dfn{inactive region}---that is, on the text between point and the
position at which the mark was last set (@pxref{Mark Ring}). To
disable this behavior, change the variable
@code{mark-even-if-inactive} to @code{nil}. Then these commands will
@cindex double slash in file name
@cindex slashes repeated in file name
@findex file-name-shadow-mode
-Emacs interprets a double slash as ``ignore everything before the
-second slash in the pair''. In the example above,
+A double slash causes Emacs to ignore everything before the
+second slash in the pair. In the example above,
@file{/u2/emacs/src/} is ignored, so the argument you supplied is
@file{/etc/termcap}. The ignored part of the file name is dimmed if
the terminal allows it. (To disable this dimming, turn off File Name
@cindex completion style
Completion commands work by narrowing a large list of possible
-completion alternatives to a smaller subset that ``matches'' what you
+completion alternatives to a smaller subset that matches what you
have typed in the minibuffer. In @ref{Completion Example}, we gave a
simple example of such matching. The procedure of determining what
-constitutes a ``match'' is quite intricate. Emacs attempts to offer
+constitutes a match is quite intricate. Emacs attempts to offer
plausible completions under most circumstances.
Emacs performs completion using one or more @dfn{completion
@code{".o"}, @code{".elc"}, and @code{"~"}. For example, if a
directory contains @samp{foo.c} and @samp{foo.elc}, @samp{foo}
completes to @samp{foo.c}. However, if @emph{all} possible
-completions end in ``ignored'' strings, they are not ignored: in the
+completions end in otherwise-ignored strings, they are not ignored: in the
previous example, @samp{foo.e} completes to @samp{foo.elc}. Emacs
disregards @code{completion-ignored-extensions} when showing
completion alternatives in the completion list.
@vindex completion-cycle-threshold
If @code{completion-cycle-threshold} is non-@code{nil}, completion
-commands can ``cycle'' through completion alternatives. Normally, if
+commands can cycle through completion alternatives. Normally, if
there is more than one completion alternative for the text in the
minibuffer, a completion command completes up to the longest common
substring. If you change @code{completion-cycle-threshold} to
entries in the minibuffer history (e.g., if you haven't previously
typed @kbd{M-p}), Emacs tries fetching from a list of default
arguments: values that you are likely to enter. You can think of this
-as moving through the ``future history'' list.
+as moving through the future history.
If you edit the text inserted by the @kbd{M-p} or @kbd{M-n}
minibuffer history commands, this does not change its entry in the
@node Yes or No Prompts
@section Yes or No Prompts
- An Emacs command may require you to answer a ``yes or no'' question
+ An Emacs command may require you to answer a yes-or-no question
during the course of its execution. Such queries come in two main
varieties.
@cindex y or n prompt
- For the first type of ``yes or no'' query, the prompt ends with
+ For the first type of yes-or-no query, the prompt ends with
@samp{(y or n)}. Such a query does not actually use the minibuffer;
the prompt appears in the echo area, and you answer by typing either
@samp{y} or @samp{n}, which immediately delivers the response. For
like this:
@smallexample
-File `foo.el' exists; overwrite? (y or n)
+File ‘foo.el’ exists; overwrite? (y or n)
@end smallexample
@noindent
(@pxref{Quitting}).
@cindex yes or no prompt
- The second type of ``yes or no'' query is typically employed if
+ The second type of yes-or-no query is typically employed if
giving the wrong answer would have serious consequences; it uses the
minibuffer, and features a prompt ending with @samp{(yes or no)}. For
example, if you invoke @kbd{C-x k} (@code{kill-buffer}) on a
services, you may want to keep track of these changes.
@item Diffie-Hellman low prime bits
-When doing the public key exchange, the number of ``prime bits''
+When doing the public key exchange, the number of prime bits
should be high to ensure that the channel can't be eavesdropped on by
third parties. If this number is too low, you will be warned.
most common speed is 9600 bits per second. You can change the speed
interactively by clicking on the mode line.
- A serial port can be configured even more by clicking on ``8N1'' in
-the mode line. By default, a serial port is configured as ``8N1'',
+ A serial port can be configured even more by clicking on @samp{8N1} in
+the mode line. By default, a serial port is configured as @samp{8N1},
which means that each byte consists of 8 data bits, No parity check
bit, and 1 stopbit.
process.
You can solve this problem by setting up Emacs as an @dfn{edit
-server}, so that it ``listens'' for external edit requests and acts
+server}, so that it listens for external edit requests and acts
accordingly. There are two ways to start an Emacs server:
@itemize
@vindex server-name
You can run multiple Emacs servers on the same machine by giving
-each one a unique ``server name'', using the variable
+each one a unique @dfn{server name}, using the variable
@code{server-name}. For example, @kbd{M-x set-variable @key{RET}
server-name @key{RET} foo @key{RET}} sets the server name to
@samp{foo}. The @code{emacsclient} program can specify a server by
@kbd{C-x #} (@code{server-edit}) in its buffer. This saves the file
and sends a message back to the @command{emacsclient} program, telling
it to exit. Programs that use @env{EDITOR} usually wait for the
-``editor''---in this case @command{emacsclient}---to exit before doing
+editor---in this case @command{emacsclient}---to exit before doing
something else.
You can also call @command{emacsclient} with multiple file name
@code{nil}, then a different criterion is used: finishing with a
server buffer kills it if the file name matches the regular expression
@code{server-temp-file-regexp}. This is set up to distinguish certain
-``temporary'' files.
+temporary files.
Each @kbd{C-x #} checks for other pending external requests to edit
various files, and selects the next such file. You can switch to a
@cindex @env{EMACS_SERVER_FILE} environment variable
Specify a @dfn{server file} for connecting to an Emacs server via TCP.
-An Emacs server usually uses an operating system feature called a
-``local socket'' to listen for connections. Some operating systems,
+An Emacs server usually uses a
+local socket to listen for connections. Some operating systems,
such as Microsoft Windows, do not support local sockets; in that case,
the server communicates with @command{emacsclient} via TCP.
@findex htmlfontify-buffer
Aside from the commands described in this section, you can also
print hardcopies from Dired (@pxref{Operating on Files}) and the diary
-(@pxref{Displaying the Diary}). You can also ``print'' an Emacs
+(@pxref{Displaying the Diary}). You can also print an Emacs
buffer to HTML with the command @kbd{M-x htmlfontify-buffer}, which
converts the current buffer to a HTML file, replacing Emacs faces with
-CSS-based markup. Furthermore, Org mode allows you to ``print'' Org
+CSS-based markup. Furthermore, Org mode allows you to print Org
files to a variety of formats, such as PDF (@pxref{Org Mode}).
@table @kbd
@vindex ps-landscape-mode
The variable @code{ps-landscape-mode} specifies the orientation of
printing on the page. The default is @code{nil}, which stands for
-``portrait'' mode. Any non-@code{nil} value specifies ``landscape''
+portrait mode. Any non-@code{nil} value specifies landscape
mode.
@vindex ps-number-of-columns
Insert a byte with a code typed in hex.
@item C-x [
-Move to the beginning of a 1k-byte ``page''.
+Move to the beginning of a 1k-byte page.
@item C-x ]
-Move to the end of a 1k-byte ``page''.
+Move to the end of a 1k-byte page.
@item M-g
Move to an address specified in hex.
However, this may be slow if there are a lot of buffers in the
desktop. You can specify the maximum number of buffers to restore
immediately with the variable @code{desktop-restore-eager}; the
-remaining buffers are restored ``lazily'', when Emacs is idle.
+remaining buffers are restored lazily, when Emacs is idle.
@findex desktop-clear
@vindex desktop-globals-to-clear
recursive edit when you no longer need it.
In general, we try to minimize the use of recursive editing levels in
-GNU Emacs. This is because they constrain you to ``go back'' in a
+GNU Emacs. This is because they constrain you to go back in a
particular order---from the innermost level toward the top level. When
possible, we present different activities in separate buffers so that
you can switch between them as you please. Some commands switch to a
@ignore
@c Apart from edt and viper, this is all obsolete.
-@c (Can't believe we were saying ``most other editors'' into 2014!)
+@c (Can't believe we were saying "most other editors" into 2014!)
@c There seems no point having a node just for those, which both have
@c their own manuals.
@node Emulation
@findex vi-mode
@kbd{M-x vi-mode} enters a major mode that replaces the previously
established major mode. All of the vi commands that, in real vi, enter
-``input'' mode are programmed instead to return to the previous major
-mode. Thus, ordinary Emacs serves as vi's ``input'' mode.
+input mode are programmed instead to return to the previous major
+mode. Thus, ordinary Emacs serves as vi's input mode.
Because vi emulation works through major modes, it does not work
to switch buffers during emulation. Return to normal Emacs first.
@item vi (alternate emulator)
@findex vip-mode
@kbd{M-x vip-mode} invokes another vi emulator, said to resemble real vi
-more thoroughly than @kbd{M-x vi-mode}. ``Input'' mode in this emulator
+more thoroughly than @kbd{M-x vi-mode}. Input mode in this emulator
is changed from ordinary Emacs so you can use @key{ESC} to go back to
emulated vi command mode. To get from emulated vi command mode back to
ordinary Emacs, type @kbd{C-z}.
@findex life
@cindex Life
- @kbd{M-x life} runs Conway's ``Life'' cellular automaton.
+ @kbd{M-x life} runs Conway's Game of Life cellular automaton.
@findex landmark
@cindex landmark game
character code, as usual.
@item
-Visual Line mode performs ``word wrapping'', causing long lines to be
+Visual Line mode performs word wrapping, causing long lines to be
wrapped at word boundaries. @xref{Visual Line Mode}.
@end itemize
a new major mode if the new file name implies a mode (@pxref{Saving}).
(@kbd{C-x C-s} does this too, if the buffer wasn't visiting a file.)
However, this does not happen if the buffer contents specify a major
-mode, and certain ``special'' major modes do not allow the mode to
+mode, and certain special major modes do not allow the mode to
change. You can turn off this mode-changing feature by setting
@code{change-major-mode-with-file-name} to @code{nil}.
@cindex MS-DOS peculiarities
This section briefly describes the peculiarities of using Emacs on
-the MS-DOS ``operating system''.
+MS-DOS.
@iftex
Information about Emacs and Microsoft's current operating system
Windows is in the main Emacs manual
one byte, Emacs shows @samp{file ...}.
As a special case, if the character lies in the range 128 (0200
-octal) through 159 (0237 octal), it stands for a ``raw'' byte that
+octal) through 159 (0237 octal), it stands for a raw byte that
does not correspond to any specific displayable character. Such a
-``character'' lies within the @code{eight-bit-control} character set,
+character lies within the @code{eight-bit-control} character set,
and is displayed as an escaped octal character code. In this case,
@kbd{C-x =} shows @samp{part of display ...} instead of @samp{file}.
@end lisp
@noindent
-This automatically activates the input method ``german-prefix'' in
+This automatically activates the input method @code{german-prefix} in
Text mode.
@findex quail-set-keyboard-layout
In addition to converting various representations of non-@acronym{ASCII}
characters, a coding system can perform end-of-line conversion. Emacs
handles three different conventions for how to separate lines in a file:
-newline (``unix''), carriage-return linefeed (``dos''), and just
-carriage-return (``mac'').
+newline (Unix), carriage-return linefeed (DOS), and just
+carriage-return (Mac).
@table @kbd
@item C-h C @var{coding} @key{RET}
@cindex 8-bit display
Normally non-ISO-8859 characters (decimal codes between 128 and 159
inclusive) are displayed as octal escapes. You can change this for
-non-standard ``extended'' versions of ISO-8859 character sets by using the
+non-standard extended versions of ISO-8859 character sets by using the
function @code{standard-display-8bit} in the @code{disp-table} library.
There are two ways to input single-byte non-@acronym{ASCII}
@cindex compose character
@cindex dead character
@item
-You can use the key @kbd{C-x 8} as a ``compose character'' prefix for
+You can use the key @kbd{C-x 8} as a compose-character prefix for
entry of non-@acronym{ASCII} Latin-1 and a few other printing
characters. @kbd{C-x 8} is good for insertion (in the minibuffer as
well as other buffers), for searching, and in any other context where
library is loaded, the @key{Alt} modifier key, if the keyboard has
one, serves the same purpose as @kbd{C-x 8}: use @key{Alt} together
with an accent character to modify the following letter. In addition,
-if the keyboard has keys for the Latin-1 ``dead accent characters'',
+if the keyboard has keys for the Latin-1 dead accent characters,
they too are defined to compose with the following character, once
@code{iso-transl} is loaded.
@code{unicode-bmp}, and @code{eight-bit}). All supported characters
belong to one or more charsets.
- Emacs normally ``does the right thing'' with respect to charsets, so
+ Emacs normally does the right thing with respect to charsets, so
that you don't have to worry about them. However, it is sometimes
helpful to know some of the underlying details about charsets.
One example is font selection (@pxref{Fonts}). Each language
-environment (@pxref{Language Environments}) defines a ``priority
-list'' for the various charsets. When searching for a font, Emacs
+environment (@pxref{Language Environments}) defines a priority
+list for the various charsets. When searching for a font, Emacs
initially attempts to find one that can display the highest-priority
charsets. For instance, in the Japanese language environment, the
charset @code{japanese-jisx0208} has the highest priority, so Emacs
current line by an @kbd{i} or @kbd{d} command.
@item U
-Mark all package with a newer available version for ``upgrading''
+Mark all package with a newer available version for upgrading
(@code{package-menu-mark-upgrades}). This places an installation mark
on the new available versions, and a deletion mark on the old
installed versions.
@var{version} should be a version string (corresponding to a specific
version of the package), or @code{t} (which means to load any
installed version), or @code{nil} (which means no version; this
-``disables'' the package, preventing it from being loaded). A list
+disables the package, preventing it from being loaded). A list
element can also be the symbol @code{all}, which means to load the
latest installed version of any package not named by the other list
elements. The default value is just @code{'(all)}.
@menu
* Basic Picture:: Basic concepts and simple commands of Picture Mode.
* Insert in Picture:: Controlling direction of cursor motion
- after ``self-inserting'' characters.
+ after self-inserting characters.
* Tabs in Picture:: Various features for tab stops and indentation.
* Rectangles in Picture:: Clearing and superimposing rectangles.
@end menu
@kindex C-c ' @r{(Picture mode)}
@kindex C-c / @r{(Picture mode)}
@kindex C-c \ @r{(Picture mode)}
- Since ``self-inserting'' characters in Picture mode overwrite and move
+ Since self-inserting characters in Picture mode overwrite and move
point, there is no essential restriction on how point should be moved.
Normally point moves right, but you can specify any of the eight
-orthogonal or diagonal directions for motion after a ``self-inserting''
+orthogonal or diagonal directions for motion after a self-inserting
character. This is useful for drawing lines in the buffer.
@table @kbd
Move down after insertion (@code{picture-movement-down}).
@item C-c `
@itemx C-c @key{Home}
-Move up and left (``northwest'') after insertion (@code{picture-movement-nw}).
+Move up and left (northwest) after insertion (@code{picture-movement-nw}).
@item C-c '
@itemx C-c @key{prior}
-Move up and right (``northeast'') after insertion
+Move up and right (northeast) after insertion
(@code{picture-movement-ne}).
@item C-c /
@itemx C-c @key{End}
-Move down and left (``southwest'') after insertion
+Move down and left (southwest) after insertion
@*(@code{picture-movement-sw}).
@item C-c \
@itemx C-c @key{next}
-Move down and right (``southeast'') after insertion
+Move down and right (southeast) after insertion
@*(@code{picture-movement-se}).
@end table
@findex picture-motion-reverse
Two motion commands move based on the current Picture insertion
direction. The command @kbd{C-c C-f} (@code{picture-motion}) moves in the
-same direction as motion after ``insertion'' currently does, while @kbd{C-c
+same direction as motion after insertion currently does, while @kbd{C-c
C-b} (@code{picture-motion-reverse}) moves in the opposite direction.
@node Tabs in Picture
Two kinds of tab-like action are provided in Picture mode. Use
@kbd{M-@key{TAB}} (@code{picture-tab-search}) for context-based tabbing.
With no argument, it moves to a point underneath the next
-``interesting'' character that follows whitespace in the previous
+interesting character that follows whitespace in the previous
nonblank line. ``Next'' here means ``appearing at a horizontal position
greater than the one point starts out at''. With an argument, as in
@kbd{C-u M-@key{TAB}}, this command moves to the next such interesting
character in the current line. @kbd{M-@key{TAB}} does not change the
-text; it only moves point. ``Interesting'' characters are defined by
+text; it only moves point. Interesting characters are defined by
the variable @code{picture-tab-chars}, which should define a set of
characters. The syntax for this variable is like the syntax used inside
of @samp{[@dots{}]} in a regular expression---but without the @samp{[}
The following commands move over groupings delimited by parentheses
(or whatever else serves as delimiters in the language you are working
with). They ignore strings and comments, including any parentheses
-within them, and also ignore parentheses that are ``quoted'' with an
+within them, and also ignore parentheses that are quoted with an
escape character. These commands are mainly intended for editing
programs, but can be useful for editing any text containing
-parentheses. They are referred to internally as ``list'' commands
+parentheses. They are referred to internally as ``list commands''
because in Lisp these groupings are lists.
These commands assume that the starting point is not inside a string
@kindex C-M-p
@findex forward-list
@findex backward-list
- The ``list'' commands @kbd{C-M-n} (@code{forward-list}) and
+ The list commands @kbd{C-M-n} (@code{forward-list}) and
@kbd{C-M-p} (@code{backward-list}) move forward or backward over one
(or @var{n}) parenthetical groupings.
When a region is active (@pxref{Mark}), @kbd{M-;} either adds
comment delimiters to the region, or removes them. If every line in
-the region is already a comment, it ``uncomments'' each of those lines
+the region is already a comment, it uncomments each of those lines
by removing their comment delimiters. Otherwise, it adds comment
delimiters to enclose the text in the region.
for a file name.
If you use @kbd{C-h S} in a major mode that does not support it,
-it asks you to specify the ``symbol help mode''. You should enter
+it asks you to specify the symbol help mode. You should enter
a command such as @code{c-mode} that would select a major
mode which @kbd{C-h S} does support.
@section MixedCase Words
@cindex camel case
- Some programming styles make use of mixed-case (or ``CamelCase'')
+ Some programming styles make use of mixed-case (or CamelCase)
symbols like @samp{unReadableSymbol}. (In the GNU project, we recommend
using underscores to separate words within an identifier, rather than
using case distinctions.) Emacs has various features to make it easier
see the Semantic Info manual, which is distributed with Emacs.
@end iftex
- Most of the ``language aware'' features in Emacs, such as Font Lock
-mode (@pxref{Font Lock}), rely on ``rules of thumb''@footnote{Regular
+ Most of the language-aware features in Emacs, such as Font Lock
+mode (@pxref{Font Lock}), rely on rules of thumb@footnote{Regular
expressions and syntax tables.} that usually give good results but are
never completely exact. In contrast, the parsers used by Semantic
have an exact understanding of programming language syntax. This
with the Foldout package (@pxref{Foldout}).
@ifinfo
- The ``automatic typing'' features may be useful for writing programs.
+ The automatic typing features may be useful for writing programs.
@xref{Top,,Autotyping, autotype, Autotyping}.
@end ifinfo
@findex prettify-symbols-mode
Prettify Symbols mode is a buffer-local minor mode that replaces
-certain strings with more ``attractive'' versions for display
+certain strings with more attractive versions for display
purposes. For example, in Emacs Lisp mode, it replaces the string
-``lambda'' with the Greek lambda character. You may wish to use this
+@samp{lambda} with the Greek lambda character @samp{λ}. You may wish
+to use this
in non-programming modes as well. You can customize the mode by
adding more entries to @code{prettify-symbols-alist}. There is also a
global version, @code{global-prettify-symbols-mode}, which enables the
In C mode and related modes, certain printing characters are
@dfn{electric}---in addition to inserting themselves, they also
reindent the current line, and optionally also insert newlines. The
-``electric'' characters are @kbd{@{}, @kbd{@}}, @kbd{:}, @kbd{#},
+electric characters are @kbd{@{}, @kbd{@}}, @kbd{:}, @kbd{#},
@kbd{;}, @kbd{,}, @kbd{<}, @kbd{>}, @kbd{/}, @kbd{*}, @kbd{(}, and
@kbd{)}.
Hide-ifdef minor mode hides selected code within @samp{#if} and
@samp{#ifdef} preprocessor blocks. If you change the variable
@code{hide-ifdef-shadow} to @code{t}, Hide-ifdef minor mode
-``shadows'' preprocessor blocks by displaying them with a less
+shadows preprocessor blocks by displaying them with a less
prominent face, instead of hiding them entirely. See the
documentation string of @code{hide-ifdef-mode} for more information.
@cindex related files
@findex ff-find-related-file
@vindex ff-related-file-alist
-Find a file ``related'' in a special way to the file visited by the
+Find a file related in a special way to the file visited by the
current buffer. Typically this will be the header file corresponding
to a C/C++ source file, or vice versa. The variable
@code{ff-related-file-alist} specifies how to compute related file
@vindex register-preview-delay
@cindex preview of registers
All of the commands that prompt for a register will display a
-``preview'' window that lists the existing registers (if there are
+preview window that lists the existing registers (if there are
any) after a short delay. To change the length of the delay,
customize @code{register-preview-delay}. To prevent this display, set
that option to @code{nil}. You can explicitly request a preview
at the end of this command. @xref{Mark}. @kbd{C-u C-x r s @var{r}},
the same command with a prefix argument, copies the text into register
@var{r} and deletes the text from the buffer as well; you can think of
-this as ``moving'' the region text into the register.
+this as moving the region text into the register.
@findex append-to-register
@findex prepend-to-register
@dfn{Bookmarks} are somewhat like registers in that they record
positions you can jump to. Unlike registers, they have long names, and
they persist automatically from one Emacs session to the next. The
-prototypical use of bookmarks is to record ``where you were reading'' in
+prototypical use of bookmarks is to record where you were reading in
various files.
@table @kbd
You can exit Rmail with @kbd{q} (@code{rmail-quit}); this expunges
and saves the Rmail file, then buries the Rmail buffer as well as its
summary buffer, if present (@pxref{Rmail Summary}). But there is no
-need to ``exit'' formally. If you switch from Rmail to editing in
+need to exit formally. If you switch from Rmail to editing in
other buffers, and never switch back, you have exited. Just make sure
to save the Rmail file eventually (like any other file you have
changed). @kbd{C-x s} is a suitable way to do this (@pxref{Save
@var{subject}]}, where @var{from} and @var{subject} are the sender and
subject of the original message. All you have to do is fill in the
recipients and send. When you forward a message, recipients get a
-message which is ``from'' you, and which has the original message in
+message which is from you, and which has the original message in
its contents.
@vindex rmail-enable-mime-composing
@findex rmail-resend
@dfn{Resending} is an alternative similar to forwarding; the
-difference is that resending sends a message that is ``from'' the
+difference is that resending sends a message that is from the
original sender, just as it reached you---with a few added header fields
(@samp{Resent-From} and @samp{Resent-To}) to indicate that it came via
you. To resend a message in Rmail, use @kbd{C-u f}. (@kbd{f} runs
immediately after its tagline, as part of the Rmail buffer, while
@acronym{MIME} parts of other types are represented only by their
taglines, with their actual contents hidden. In either case, you can
-toggle a @acronym{MIME} part between its ``displayed'' and ``hidden''
+toggle a @acronym{MIME} part between its displayed and hidden
states by typing @key{RET} anywhere in the part---or anywhere in its
tagline (except for buttons for other actions, if there are any). Type
@key{RET} (or click with the mouse) to activate a tagline button, and
@key{TAB} to cycle point between tagline buttons.
The @kbd{v} (@code{rmail-mime}) command toggles between the default
-@acronym{MIME} display described above, and a ``raw'' display showing
+@acronym{MIME} display described above, and a raw display showing
the undecoded @acronym{MIME} data. With a prefix argument, this
command toggles the display of only an entity at point.
your Rmail file (@pxref{Rmail Inbox}). When loaded for the first time,
Rmail attempts to locate the @code{movemail} program and determine its
version. There are two versions of the @code{movemail} program: the
-native one, shipped with GNU Emacs (the ``emacs version'') and the one
-included in GNU mailutils (the ``mailutils version'',
+native one, shipped with GNU Emacs (the Emacs version) and the one
+included in GNU mailutils (the mailutils version,
@pxref{movemail,,,mailutils,GNU mailutils}). They support the same
command line syntax and the same basic subset of options. However, the
Mailutils version offers additional features.
@cindex POP mailboxes
No matter which flavor of @code{movemail} you use, you can specify
a POP inbox by using a POP @dfn{URL} (@pxref{Movemail}). A POP
-@acronym{URL} is a ``file name'' of the form
+@acronym{URL} is of the form
@samp{pop://@var{username}@@@var{hostname}}, where
@var{hostname} is the host name or IP address of the remote mail
server and @var{username} is the user name on that server.
@cindex frame
On a graphical display, such as on GNU/Linux using the X Window
-System, Emacs occupies a ``graphical window''. On a text terminal,
+System, Emacs occupies a graphical window. On a text terminal,
Emacs occupies the entire terminal screen. We will use the term
@dfn{frame} to mean a graphical window or terminal screen occupied by
Emacs. Emacs behaves very similarly on both kinds of frames. It
above the echo area, is called @dfn{the window}. Henceforth in this
manual, we will use the word ``window'' in this sense. Graphical
display systems commonly use the word ``window'' with a different
-meaning; but, as stated above, we refer to those ``graphical windows''
+meaning; but, as stated above, we refer to those graphical windows
as ``frames''.
An Emacs window is where the @dfn{buffer}---the text you are
string is displayed, that indicates a nontrivial end-of-line
convention for encoding a file. Usually, lines of text are separated
by @dfn{newline characters} in a file, but two other conventions are
-sometimes used. The MS-DOS convention uses a ``carriage-return''
-character followed by a ``linefeed'' character; when editing such
+sometimes used. The MS-DOS convention uses a carriage-return
+character followed by a linefeed character; when editing such
files, the colon changes to either a backslash (@samp{\}) or
@samp{(DOS)}, depending on the operating system. Another convention,
-employed by older Macintosh systems, uses a ``carriage-return''
+employed by older Macintosh systems, uses a carriage-return
character instead of a newline; when editing such files, the colon
changes to either a forward slash (@samp{/}) or @samp{(Mac)}. On some
systems, Emacs displays @samp{(Unix)} instead of the colon for files
The next element on the mode line is the string indicated by
@var{ch}. This shows two dashes (@samp{--}) if the buffer displayed
in the window has the same contents as the corresponding file on the
-disk; i.e., if the buffer is ``unmodified''. If the buffer is
+disk; i.e., if the buffer is unmodified. If the buffer is
modified, it shows two stars (@samp{**}). For a read-only buffer, it
shows @samp{%*} if the buffer is modified, and @samp{%%} otherwise.
After exiting a search, you can search for the same string again by
typing just @kbd{C-s C-s}. The first @kbd{C-s} is the key that
-invokes incremental search, and the second @kbd{C-s} means ``search
-again''. Similarly, @kbd{C-r C-r} searches backward for the last
+invokes incremental search, and the second @kbd{C-s} means to search
+again. Similarly, @kbd{C-r C-r} searches backward for the last
search string. In determining the last search string, it doesn't
matter whether the string was searched for with @kbd{C-s} or
@kbd{C-r}.
If an incremental search fails in the minibuffer, it tries searching
the minibuffer history. @xref{Minibuffer History}. You can visualize
-the minibuffer and its history as a series of ``pages'', with the
+the minibuffer and its history as a series of pages, with the
earliest history element on the first page and the current minibuffer
on the last page. A forward search, @kbd{C-s}, searches forward to
later pages; a reverse search, @kbd{C-r}, searches backwards to
parenthetical grouping; it is a separate feature that is assigned as a
second meaning to the same @samp{\( @dots{} \)} construct. In practice
there is usually no conflict between the two meanings; when there is
-a conflict, you can use a ``shy'' group.
+a conflict, you can use a shy group.
@item \(?: @dots{} \)
@cindex shy group, in regexp
-specifies a ``shy'' group that does not record the matched substring;
+specifies a shy group that does not record the matched substring;
you can't refer back to it with @samp{\@var{d}} (see below). This is
useful in mechanically combining regular expressions, so that you can
add groups for syntactic purposes without interfering with the
Use both address and full name, as in:@*
@samp{Elvis Parsley <king@@grassland.com>}.
@item any other value
-Use @code{angles} normally. But if the address must be ``quoted'' to
+Use @code{angles} normally. But if the address must be quoted to
remain syntactically valid under the @code{angles} format but not
under the @code{parens} format, use @code{parens} instead. This is
the default.
@item BCC
Additional mailing address(es) to send the message to, which should
-not appear in the header of the message actually sent. ``BCC'' stands
+not appear in the header of the message actually sent. @samp{BCC} stands
for @dfn{blind carbon copies}.
@item FCC
they are needed. For instance, it inserts the above address as
@samp{"John Q. Smith" <none@@example.com>}.
- Emacs also recognizes ``include'' commands in @file{.mailrc}. They
+ Emacs also recognizes include commands in @file{.mailrc}. They
look like this:
@example
@vindex message-kill-buffer-on-exit
The usual command to send a message is @kbd{C-c C-c}
(@code{mail-send-and-exit}). This sends the message and then
-``buries'' the mail buffer, putting it at the lowest priority for
+buries the mail buffer, putting it at the lowest priority for
reselection. If you want it to kill the mail buffer instead, change
the variable @code{message-kill-buffer-on-exit} to @code{t}.
@findex fortune-to-signature
@cindex fortune cookies
- You can use the @code{fortune} program to put a ``fortune cookie''
+ You can use the @code{fortune} program to put a fortune cookie
message into outgoing mail. To do this, add
@code{fortune-to-signature} to @code{mail-setup-hook}:
@cindex mode, XML
@cindex mode, nXML
@findex nxml-mode
- Emacs has other major modes for text which contains ``embedded''
+ Emacs has other major modes for text which contains embedded
commands, such as @TeX{} and @LaTeX{} (@pxref{TeX Mode}); HTML and
SGML (@pxref{HTML Mode}); XML
@ifinfo
and Groff and Nroff (@pxref{Nroff Mode}).
@cindex ASCII art
- If you need to edit pictures made out of text characters (commonly
-referred to as ``ASCII art''), use Picture mode, a special major mode
-for editing such pictures.
+ If you need to edit ASCII art pictures made out of text characters,
+use Picture mode, a special major mode for editing such pictures.
@iftex
@xref{Picture Mode,,, emacs-xtra, Specialized Emacs Features}.
@end iftex
@cindex templates
@cindex autotyping
@cindex automatic typing
- The ``automatic typing'' features may be useful when writing text.
+ The automatic typing features may be useful when writing text.
@inforef{Top,The Autotype Manual,autotype}.
@end ifinfo
* TeX Mode:: Editing TeX and LaTeX files.
* HTML Mode:: Editing HTML and SGML files.
* Nroff Mode:: Editing input to the nroff formatter.
-* Enriched Text:: Editing text ``enriched'' with fonts, colors, etc.
+* Enriched Text:: Editing text enriched with fonts, colors, etc.
* Text Based Tables:: Commands for editing text-based tables.
* Two-Column:: Splitting text columns into separate windows.
@end menu
prefix for each paragraph automatically. This command divides the
region into paragraphs, treating every change in the amount of
indentation as the start of a new paragraph, and fills each of these
-paragraphs. Thus, all the lines in one ``paragraph'' have the same
+paragraphs. Thus, all the lines in one paragraph have the same
amount of indentation. That indentation serves as the fill prefix for
that paragraph.
commands are not undoable; their effects are simply not recorded by
the undo mechanism, so you can undo right past them (@pxref{Undo}).
- Many of these commands act on the ``current'' heading line. If
+ Many of these commands act on the current heading line. If
point is on a heading line, that is the current heading line; if point
is on a body line, the current heading line is the nearest preceding
header line.
@cindex folding editing
The Foldout package extends Outline mode and Outline minor mode with
-``folding'' commands. The idea of folding is that you zoom in on a
+folding commands. The idea of folding is that you zoom in on a
nested portion of the outline, while hiding its relatives at higher
levels.
While you're zoomed in, you can still use Outline mode's exposure and
hiding functions without disturbing Foldout. Also, since the buffer is
-narrowed, ``global'' editing actions will only affect text under the
+narrowed, global editing actions will only affect text under the
zoomed-in heading. This is useful for restricting changes to a
particular chapter or section of your document.
The major mode for editing XML documents is called nXML mode. This
is a powerful major mode that can recognize many existing XML schema
and use them to provide completion of XML elements via
-@kbd{M-@key{TAB}}, as well as ``on-the-fly'' XML
+@kbd{M-@key{TAB}}, as well as on-the-fly XML
validation with error highlighting. To enable nXML mode in an
existing buffer, type @kbd{M-x nxml-mode}, or, equivalently, @kbd{M-x
xml-mode}. Emacs uses nXML mode for files which have the extension
@cindex text/enriched MIME format
Enriched mode is a minor mode for editing formatted text files in a
-WYSIWYG (``what you see is what you get'') fashion. When Enriched
+WYSIWYG (What You See Is What You Get) fashion. When Enriched
mode is enabled, you can apply various formatting properties to the
text in the buffer, such as fonts and colors; upon saving the buffer,
those properties are saved together with the text, using the MIME
* Enriched Indentation:: Changing the left and right margins.
* Enriched Justification:: Centering, setting text flush with the
left or right margin, etc.
-* Enriched Properties:: The ``special'' text properties submenu.
+* Enriched Properties:: The special text properties submenu.
@end menu
@node Enriched Mode
deletes the separator. Lines that don't have the column separator at
the proper place remain unsplit; they stay in the left-hand buffer, and
the right-hand buffer gets an empty line to correspond. (This is the
-way to write a line that ``spans both columns while in two-column
-mode'': write it in the left-hand buffer, and put an empty line in the
+way to write a line that spans both columns while in two-column
+mode: write it in the left-hand buffer, and put an empty line in the
right-hand buffer.)
@kindex F2 RET
input. In that case, the command it runs is @code{keyboard-quit}.
On a text terminal, if you quit with @kbd{C-g} a second time before
-the first @kbd{C-g} is recognized, you activate the ``emergency
-escape'' feature and return to the shell. @xref{Emergency Escape}.
+the first @kbd{C-g} is recognized, you activate the emergency-escape
+feature and return to the shell. @xref{Emergency Escape}.
@cindex NFS and quitting
There are some situations where you cannot quit. When Emacs is
it is ready for the next command.
@findex top-level
- The command @kbd{M-x top-level} is equivalent to ``enough''
+ The command @kbd{M-x top-level} is equivalent to enough
@kbd{C-]} commands to get you out of all the levels of recursive edits
that you are in; it also exits the minibuffer if it is active.
@kbd{C-]} gets you out one level at a time, but @kbd{M-x top-level}
The @samp{bug-gnu-emacs} mailing list (also available as the newsgroup
@samp{gnu.emacs.bug}). You can read the list archives at
@url{http://lists.gnu.org/mailman/listinfo/bug-gnu-emacs}. This list
-works as a ``mirror'' of the Emacs bug reports and follow-up messages
+works as a mirror of the Emacs bug reports and follow-up messages
which are sent to the bug tracker. It also contains old bug reports
from before the bug tracker was introduced (in early 2008).
@cindex bug criteria
@cindex what constitutes an Emacs bug
- If Emacs accesses an invalid memory location (``segmentation
-fault''), or exits with an operating system error message that
-indicates a problem in the program (as opposed to something like
-``disk full''), then it is certainly a bug.
+ If Emacs accesses an invalid memory location or exits with an
+operating system error message that indicates a problem in the program
+(as opposed to something like ``disk full''), then it is certainly a
+bug.
If the Emacs display does not correspond properly to the contents of
the buffer, then it is a bug. But you should check that features like
what we mean by ``guessing explanations''. The problem might be due
to the fact that there is a @samp{z} in the file name. If this is so,
then when we got your report, we would try out the problem with some
-``large file'', probably with no @samp{z} in its name, and not see any
+large file, probably with no @samp{z} in its name, and not see any
problem. There is no way we could guess that we should try visiting a
file with a @samp{z} in its name.
are available in the file @file{etc/DEBUG} in the Emacs distribution.
That file also includes instructions for investigating problems
whereby Emacs stops responding (many people assume that Emacs is
-``hung'', whereas in fact it might be in an infinite loop).
+hung, whereas in fact it might be in an infinite loop).
To find the file @file{etc/DEBUG} in your Emacs installation, use the
directory name stored in the variable @code{data-directory}.
@item
@ifset WWW_GNU_ORG
@ifhtml
-the ``Tips'' Appendix in the Emacs Lisp Reference
+the ``Tips and Conventions'' Appendix in the Emacs Lisp Reference
@url{http://www.gnu.org/software/emacs/manual/html_node/elisp/Tips.html}.
@end ifhtml
@ifnothtml
-@xref{Tips, ``Tips'' Appendix in the Emacs Lisp Reference, Tips
+@xref{Tips, ``Tips and Conventions'' Appendix in the Emacs Lisp Reference, Tips
Appendix, elisp, Emacs Lisp Reference}.
@end ifnothtml
@end ifset
@ifclear WWW_GNU_ORG
-@xref{Tips, ``Tips'' Appendix in the Emacs Lisp Reference, Tips
+@xref{Tips, ``Tips and Conventions'' Appendix in the Emacs Lisp Reference, Tips
Appendix, elisp, Emacs Lisp Reference}.
@end ifclear
@end ifnottex
except for the additional dot (@samp{.}) after the version. The
relevant VC commands can use both kinds of version backups. The main
-difference is that the ``manual'' version backups made by @kbd{C-x v
+difference is that the manual version backups made by @kbd{C-x v
~} are not deleted automatically when you commit.
@cindex locking (CVS)
@node Displaying Buffers
@section Displaying a Buffer in a Window
- It is a common Emacs operation to display or ``pop up'' some buffer
+ It is a common Emacs operation to display or pop up some buffer
in response to a user command. There are several different ways in
which commands do this.
Many commands, like @kbd{C-x C-f} (@code{find-file}), display the
-buffer by ``taking over'' the selected window, expecting that the
+buffer by taking over the selected window, expecting that the
user's attention will be diverted to that buffer. These commands
usually work by calling @code{switch-to-buffer} internally
(@pxref{Select Buffer}).
@findex display-buffer
- Some commands try to display ``intelligently'', trying not to take
+ Some commands try to display intelligently, trying not to take
over the selected window, e.g., by splitting off a new window and
displaying the desired buffer there. Such commands, which include the
various help commands (@pxref{Help}), work by calling
@item
Otherwise, if the buffer is already displayed in an existing window,
-``reuse'' that window. Normally, only windows on the selected frame
+reuse that window. Normally, only windows on the selected frame
are considered, but windows on other frames are also reusable if you
change @code{pop-up-frames} (see below) to @code{t}.
@cindex window configuration changes, undoing
Winner mode is a global minor mode that records the changes in the
window configuration (i.e., how the frames are partitioned into
-windows), so that you can ``undo'' them. You can toggle Winner mode
+windows), so that you can undo them. You can toggle Winner mode
with @kbd{M-x winner-mode}, or by customizing the variable
@code{winner-mode}. When the mode is enabled, @kbd{C-c left}
(@code{winner-undo}) undoes the last window configuration change. If
The Windmove package defines commands for moving directionally
between neighboring windows in a frame. @kbd{M-x windmove-right}
selects the window immediately to the right of the currently selected
-one, and similarly for the ``left'', ``up'', and ``down''
+one, and similarly for the left, up, and down
counterparts. @kbd{M-x windmove-default-keybindings} binds these
commands to @kbd{S-right} etc.; doing so disables shift selection for
those keys (@pxref{Shift Selection}).
graphical widgets, such as the menu-bar, scroll-bar, and dialog boxes,
is determined by
@ifnottex
-``GTK resources'', which we will also describe.
+GTK resources, which we will also describe.
@end ifnottex
@iftex
-``GTK resources''.
+GTK resources.
@end iftex
When Emacs is built without GTK+ support, the appearance of these
widgets is determined by additional X resources.
@ifnottex
@item @code{privateColormap} (class @code{PrivateColormap})
-If @samp{on}, use a private color map, in the case where the ``default
-visual'' of class PseudoColor and Emacs is using it.
+If @samp{on}, use a private color map, in the case where the default
+visual of class PseudoColor and Emacs is using it.
@item @code{reverseVideo} (class @code{ReverseVideo})
Switch foreground and background default colors if @samp{on}, use colors as
@code{emacs-filedialog}, of class @code{GtkFileSelection}.
Because the widgets for pop-up menus and dialogs are free-standing
-windows and not ``contained'' in the @code{Emacs} widget, their GTK+
+windows and not contained in the @code{Emacs} widget, their GTK+
absolute names do not start with @samp{Emacs}. To customize these
widgets, use wildcards like this:
@item ACTIVE
This is the state for a widget that is ready to do something. It is
also for the trough of a scroll bar, i.e., @code{bg[ACTIVE] = "red"}
-sets the scroll bar trough to red. Buttons that have been pressed but
-not released yet (``armed'') are in this state.
+sets the scroll bar trough to red. Buttons that have been armed
+(pressed but not released yet) are in this state.
@item PRELIGHT
This is the state for a widget that can be manipulated, when the mouse
pointer is over it---for example when the mouse is over the thumb in
Although these are examples, the programs are real. I use them.
Other people use them. You may use them. Beyond the fragments of
programs used for illustrations, there is very little in here that is
-``just for teaching purposes''; what you see is used. This is a great
+just for teaching purposes; what you see is used. This is a great
advantage of Emacs Lisp: it is easy to learn to use it for work.
@end ignore
information is formally introduced.)
When you read this text, you are not expected to learn everything the
-first time. Frequently, you need only make, as it were, a ``nodding
-acquaintance'' with some of the items mentioned. My hope is that I have
+first time. Frequently, you need make only a nodding
+acquaintance with some of the items mentioned. My hope is that I have
structured the text and given you enough hints that you will be alert to
what is important, and concentrate on it.
-You will need to ``dive into'' some paragraphs; there is no other way
+You will need to dive into some paragraphs; there is no other way
to read them. But I have tried to keep down the number of such
paragraphs. This book is intended as an approachable hill, rather than
as a daunting mountain.
press the @key{\} key.
In addition to typing a lone keychord, you can prefix what you type
-with @kbd{C-u}, which is called the ``universal argument''. The
+with @kbd{C-u}, which is called the @dfn{universal argument}. The
@kbd{C-u} keychord passes an argument to the subsequent command.
Thus, to indent a region of plain text by 6 spaces, mark the region,
and then type @w{@kbd{C-u 6 M-C-\}}. (If you do not specify a number,
@c use code for the number four, not samp.
@noindent
-You will see the number @code{4} appear in the echo area. (In the
-jargon, what you have just done is ``evaluate the list.'' The echo area
-is the line at the bottom of the screen that displays or ``echoes''
+You will see the number @code{4} appear in the echo area. (What
+you have just done is evaluate the list. The echo area
+is the line at the bottom of the screen that displays or echoes
text.) Now try the same thing with a quoted list: place the cursor
right after the following list and type @kbd{C-x C-e}:
inside of GNU Emacs called the @dfn{Lisp interpreter}---giving the
interpreter a command to evaluate the expression. The name of the Lisp
interpreter comes from the word for the task done by a human who comes
-up with the meaning of an expression---who ``interprets'' it.
+up with the meaning of an expression---who interprets it.
You can also evaluate an atom that is not part of a list---one that is
not surrounded by parentheses; again, the Lisp interpreter translates
hard, but once understood, they can point the way.
The error message is generated by a built-in GNU Emacs debugger. We
-will ``enter the debugger''. You get out of the debugger by typing @code{q}.
+will enter the debugger. You get out of the debugger by typing @code{q}.
What we will do is evaluate a list that is not quoted and does not
have a meaningful command as its first element. Here is a list almost
The slightly odd word, @samp{void-function}, is designed to cover the
way Emacs Lisp is implemented, which is that when a symbol does not
have a function definition attached to it, the place that should
-contain the instructions is ``void''.
+contain the instructions is void.
On the other hand, since we were able to add 2 plus 2 successfully, by
evaluating @code{(+ 2 2)}, we can infer that the symbol @code{+} must
give up on that function and produce an error message. (The interpreter
may also find itself tossed, so to speak, to a different function or it
may attempt to repeat continually what it is doing for ever and ever in
-what is called an ``infinite loop''. These actions are less common; and
+an infinite loop. These actions are less common; and
we can ignore them.) Most frequently, the interpreter returns a value.
@cindex @samp{side effect} defined
At the same time the interpreter returns a value, it may do something
else as well, such as move a cursor or copy a file; this other kind of
action is called a @dfn{side effect}. Actions that we humans think are
-important, such as printing results, are often ``side effects'' to the
-Lisp interpreter. The jargon can sound peculiar, but it turns out that
-it is fairly easy to learn to use side effects.
+important, such as printing results, are often side effects to the
+Lisp interpreter. It is fairly easy to learn to use side effects.
In summary, evaluating a symbolic expression most commonly causes the
Lisp interpreter to return a value and perhaps carry out a side effect;
Now it is easy to understand the name of the command invoked by the
keystrokes @kbd{C-x C-e}: the name is @code{eval-last-sexp}. The
letters @code{sexp} are an abbreviation for ``symbolic expression'', and
-@code{eval} is an abbreviation for ``evaluate''. The command means
-``evaluate last symbolic expression''.
+@code{eval} is an abbreviation for ``evaluate''. The command
+evaluates the last symbolic expression.
As an experiment, you can try evaluating the expression by putting the
cursor at the beginning of the next line immediately following the
@noindent
The value produced by evaluating this expression is @code{"abcdef"}.
+@cindex substring
A function such as @code{substring} uses both a string and numbers as
-arguments. The function returns a part of the string, a substring of
+arguments. The function returns a part of the string, a @dfn{substring} of
the first argument. This function takes three arguments. Its first
argument is the string of characters, the second and third arguments
are numbers that indicate the beginning (inclusive) and end
though it is made up of several words separated by spaces. Lisp counts
everything between the two quotation marks as part of the string,
including the spaces. You can think of the @code{substring} function as
-a kind of ``atom smasher'' since it takes an otherwise indivisible atom
+a kind of atom smasher since it takes an otherwise indivisible atom
and extracts a part. However, @code{substring} is only able to extract
a substring from an argument that is a string, not from another type of
atom such as a number or symbol.
chapters we shall come upon at least one symbol that has ``pointer'' as
part of its name. The name is chosen because the symbol has a value,
specifically a list, attached to it; or, expressed another way,
-the symbol is set to ``point'' to the list.
+the symbol is set to point to the list.
@node Counting
@subsection Counting
@item
A function always returns a value when it is evaluated (unless it gets
-an error); in addition, it may also carry out some action called a
-``side effect''. In many cases, a function's primary purpose is to
+an error); in addition, it may also carry out some action that is a
+side effect. In many cases, a function's primary purpose is to
create a side effect.
@end itemize
Also, we have just introduced another jargon term, the word @dfn{call}.
When you evaluate a list in which the first symbol is a function, you
are calling that function. The use of the term comes from the notion of
-the function as an entity that can do something for you if you ``call''
+the function as an entity that can do something for you if you call
it---just as a plumber is an entity who can fix a leak if you call him
or her.
@noindent
The symbol @code{number}, specified in the function definition in the
-next section, is given or ``bound to'' the value 3 in the actual use of
+next section, is bound to the value 3 in the actual use of
the function. Note that although @code{number} was inside parentheses
in the function definition, the argument passed to the
@code{multiply-by-seven} function is not in parentheses. The
If you evaluate this example, you are likely to get an error message.
(Go ahead, try it!) This is because we have written the function
definition, but not yet told the computer about the definition---we have
-not yet installed (or ``loaded'') the function definition in Emacs.
+not yet loaded the function definition in Emacs.
Installing a function is the process that tells the Lisp interpreter the
definition of the function. Installation is described in the next
section.
by seven. It produces the same answer, but by a different path. At
the same time, we will add a comment to the code; a comment is text
that the Lisp interpreter ignores, but that a human reader may find
-useful or enlightening. The comment is that this is the ``second
-version''.
+useful or enlightening. The comment is that this is the second
+version.
@smallexample
@group
(@xref{Keybindings, , Some Keybindings}, to learn how to bind a command
to a key.)
-A prefix argument is passed to an interactive function by typing the
+A @dfn{prefix argument} is passed to an interactive function by typing the
@key{META} key followed by a number, for example, @kbd{M-3 M-e}, or by
typing @kbd{C-u} and then a number, for example, @kbd{C-u 3 M-e} (if you
type @kbd{C-u} without a number, it defaults to 4).
The first part of the argument to @code{interactive} is @samp{p}, with
which you are already familiar. This argument tells Emacs to
-interpret a ``prefix'', as a number to be passed to the function. You
+interpret a prefix, as a number to be passed to the function. You
can specify a prefix either by typing @kbd{C-u} followed by a number
or by typing @key{META} followed by a number. The prefix is the
number of specified characters. Thus, if your prefix is three and the
that is temporary and local. The values set by @code{let} are
automatically undone when the @code{let} is finished. The setting
only affects expressions that are inside the bounds of the @code{let}
-expression. In computer science jargon, we would say ``the binding of
+expression. In computer science jargon, we would say the binding of
a symbol is visible only in functions called in the @code{let} form;
-in Emacs Lisp, scoping is dynamic, not lexical.''
+in Emacs Lisp, scoping is dynamic, not lexical.
@code{let} can create more than one variable at once. Also,
@code{let} gives each variable it creates an initial value, either a
-value specified by you, or @code{nil}. (In the jargon, this is called
-``binding the variable to the value''.) After @code{let} has created
+value specified by you, or @code{nil}. (In the jargon, this is
+binding the variable to the value.) After @code{let} has created
and bound the variables, it executes the code in the body of the
@code{let}, and returns the value of the last expression in the body,
as the value of the whole @code{let} expression. (``Execute'' is a jargon
included here. It is used, for example, in the code for the
function @code{beginning-of-buffer}.
-The basic idea behind an @code{if}, is that ``@emph{if} a test is true,
-@emph{then} an expression is evaluated.'' If the test is not true, the
+The basic idea behind an @code{if}, is that @emph{if} a test is true,
+@emph{then} an expression is evaluated. If the test is not true, the
expression is not evaluated. For example, you might make a decision
such as, ``if it is warm and sunny, then go to the beach!''
Also, when an @code{if} expression is written, the true-or-false-test
is usually written on the same line as the symbol @code{if}, but the
-action to carry out if the test is true, the ``then-part'', is written
+action to carry out if the test is true, the then-part, is written
on the second and subsequent lines. This makes the @code{if}
expression easier to read.
Lisp, and C, and it works with non-programming text as well. For
example, @code{find-tag} will jump to the various nodes in the
Texinfo source file of this document.
-The @code{find-tag} function depends on ``tags tables'' that record
+The @code{find-tag} function depends on @dfn{tags tables} that record
the locations of the functions, variables, and other items to which
@code{find-tag} jumps.
@cindex TAGS table, specifying
@findex find-tag
Depending on how the initial default values of your copy of Emacs are
-set, you may also need to specify the location of your ``tags table'',
+set, you may also need to specify the location of your tags table,
which is a file called @file{TAGS}. For example, if you are
interested in Emacs sources, the tags table you will most likely want,
if it has already been created for you, will be in a subdirectory of
The @code{append-to-buffer} command uses the
@code{insert-buffer-substring} function to copy the region.
@code{insert-buffer-substring} is described by its name: it takes a
-string of characters from part of a buffer, a ``substring'', and
-inserts them into another buffer.
+substring from a buffer, and inserts it into another buffer.
Most of @code{append-to-buffer} is
concerned with setting up the conditions for
You can imagine yourself at a conference where an usher is wandering
around holding a list with your name on it and looking for you: the
-usher is ``bound'' to your name, not to you; but when the usher finds
-you and takes your arm, the usher becomes ``bound'' to you.
+usher is bound to your name, not to you; but when the usher finds
+you and takes your arm, the usher becomes bound to you.
@need 800
In Lisp, you might describe this situation like this:
@noindent
@code{not} is a function that returns true if its argument is false
and false if its argument is true. So if @code{(bufferp buffer)}
-returns true, the @code{not} expression returns false and vice versa:
-what is ``not true'' is false and what is ``not false'' is true.
+returns true, the @code{not} expression returns false and vice versa.
Using this test, the @code{if} expression works as follows: when the
value of the variable @code{buffer} is actually a buffer rather than
buffer, not the accessible part. The computation makes much more
sense when it handles just the accessible part. (@xref{Narrowing &
Widening, , Narrowing and Widening}, for more information on focusing
-attention to an ``accessible'' part.)
+attention to an accessible part.)
@need 800
The line looks like this:
The first argument is @code{(prefix-numeric-value arg)}. When
@code{"P"} is used as the argument for @code{interactive}, the value
-passed to the function as its argument is passed a ``raw prefix
-argument'', and not a number. (It is a number in a list.) To perform
+passed to the function as its argument is passed a @dfn{raw prefix
+argument}, and not a number. (It is a number in a list.) To perform
the arithmetic, a conversion is necessary, and
@code{prefix-numeric-value} does the job.
perhaps, not necessary, but which, if it did not occur, would be sure
to draw complaints. (The @code{(not (consp arg))} portion is so that
if you specify the command with a @kbd{C-u}, but without a number,
-that is to say, if the ``raw prefix argument'' is simply a cons cell,
+that is to say, if the raw prefix argument is simply a cons cell,
the command does not put you at the beginning of the second line.)
@node Second Buffer Related Review
argument, if desired.
@item prefix-numeric-value
-Convert the ``raw prefix argument'' produced by @code{(interactive
+Convert the raw prefix argument produced by @code{(interactive
"P")} to a numeric value.
@item forward-line
they are applied. This is very important for how they are used.
Also, in the first chapter, in the discussion about atoms, I said that
-in Lisp, ``certain kinds of atom, such as an array, can be separated
+in Lisp, certain kinds of atom, such as an array, can be separated
into parts; but the mechanism for doing this is different from the
mechanism for splitting a list. As far as Lisp is concerned, the
-atoms of a list are unsplittable.'' (@xref{Lisp Atoms}.) The
+atoms of a list are unsplittable. (@xref{Lisp Atoms}.) The
@code{car} and @code{cdr} functions are used for splitting lists and
are considered fundamental to Lisp. Since they cannot split or gain
access to the parts of an array, an array is considered an atom.
list in which the element is followed by the elements of the original
list.
-We often say that ``@code{cons} puts a new element at the beginning of
-a list; it attaches or pushes elements onto the list'', but this
+We often say that @code{cons} puts a new element at the beginning of
+a list, or that it attaches or pushes elements onto the list, but this
phrasing can be misleading, since @code{cons} does not change an
existing list, but creates a new one.
Note that the elements are numbered from zero, not one. That is to
say, the first element of a list, its @sc{car} is the zeroth element.
-This is called ``zero-based'' counting and often bothers people who
+This zero-based counting often bothers people who
are accustomed to the first element in a list being number one, which
-is ``one-based''.
+is one-based.
@need 1250
For example:
@noindent
If you evaluate this expression, the list @code{(cat dog)} will appear
in the echo area. This is the value returned by the function. The
-result we are interested in is the ``side effect'', which we can see by
+result we are interested in is the side effect, which we can see by
evaluating the variable @code{domesticated-animals}:
@smallexample
@cindex Erasing text
@cindex Deleting text
-Whenever you cut or clip text out of a buffer with a ``kill'' command in
+Whenever you cut or clip text out of a buffer with a @dfn{kill} command in
GNU Emacs, it is stored in a list and you can bring it back with a
-``yank'' command.
+@dfn{yank} command.
(The use of the word ``kill'' in Emacs for processes which specifically
@emph{do not} destroy the values of the entities is an unfortunate
The list that holds the pieces of text is called the @dfn{kill ring}.
This chapter leads up to a description of the kill ring and how it is
used by first tracing how the @code{zap-to-char} function works. This
-function uses (or ``calls'') a function that invokes a function that
+function calls a function that invokes a function that
manipulates the kill ring. Thus, before reaching the mountains, we
climb the foothills.
two different things. First, and most simply, is the @samp{p}.
This part is separated from the next part by a newline, @samp{\n}.
The @samp{p} means that the first argument to the function will be
-passed the value of a ``processed prefix''. The prefix argument is
+passed the value of a @dfn{processed prefix}. The prefix argument is
passed by typing @kbd{C-u} and a number, or @kbd{M-} and a number. If
the function is called interactively without a prefix, 1 is passed to
this argument.
character as a string.) If the search is backwards,
@code{search-forward} leaves point just before the first character in
the target. Also, @code{search-forward} returns @code{t} for true.
-(Moving point is therefore a ``side effect''.)
+(Moving point is therefore a side effect.)
@need 1250
In @code{zap-to-char}, the @code{search-forward} function looks like this:
enables you to define new control constructs and other language
features. It tells the interpreter how to compute another Lisp
expression which will in turn compute the value. In this case, the
-``other expression'' is an @code{if} expression.
+other expression is an @code{if} expression.
The @code{kill-region} function definition also has an @code{unless}
macro; it is the converse of @code{when}. The @code{unless} macro is
@code{yank-handler} is an optional argument to @code{kill-region} that
tells the @code{kill-append} and @code{kill-new} functions how deal
-with properties added to the text, such as ``bold'' or ``italics''.
+with properties added to the text, such as bold or italics.
@code{last-command} is a variable that comes with Emacs that we have
not seen before. Normally, whenever a function is executed, Emacs
almost becoming routine.
The documentation is somewhat confusing unless you remember that the
-word ``kill'' has a meaning different from usual. The ``Transient Mark''
+word ``kill'' has a meaning different from usual. The Transient Mark
and @code{interprogram-cut-function} comments explain certain
side-effects.
(Also, the function provides an optional argument called
@code{yank-handler}; when invoked, this argument tells the function
-how to deal with properties added to the text, such as ``bold'' or
-``italics''.)
+how to deal with properties added to the text, such as bold or
+italics.)
@c !!! bug in GNU Emacs 22 version of kill-append ?
It has a @code{let*} function to set the value of the first element of
The function definition has an optional @code{yank-handler} argument,
which when invoked tells the function how to deal with properties
-added to the text, such as ``bold'' or ``italics''. We will skip that.
+added to the text, such as bold or italics. We will skip that.
@need 1200
The first line of the documentation makes sense:
In this case, the expression tests first to see whether
@code{menu-bar-update-yank-menu} exists as a function, and if so,
calls it. The @code{fboundp} function returns true if the symbol it
-is testing has a function definition that ``is not void''. If the
+is testing has a function definition that is not void. If the
symbol's function definition were void, we would receive an error
message, as we did when we created errors intentionally (@pxref{Making
Errors, , Generate an Error Message}).
previously clipped text. For a detailed discussion, see
@ref{kill-append function, , The @code{kill-append} function}.)
-If you then yank back the text, i.e., ``paste'' it, you get both
+If you then yank back the text, i.e., paste it, you get both
pieces of text at once. That way, if you delete two words in a row,
and then yank them back, you get both words, in their proper order,
with one yank. (The @w{@code{(< end beg))}} expression makes sure the
@code{interactive} declaration in a function written in Lisp: a letter
followed, perhaps, by a prompt. The only difference from the Lisp is
when the macro is called with no arguments. Then you write a @code{0}
-(which is a ``null string''), as in this macro.
+(which is a null string), as in this macro.
If you were to specify arguments, you would place them between
quotation marks. The C macro for @code{goto-char} includes
The seventh part is a documentation string, just like the one for a
function written in Emacs Lisp. This is written as a C comment. (When
you build Emacs, the program @command{lib-src/make-docfile} extracts
-these comments and uses them to make the ``real'' documentation.)
+these comments and uses them to make the documentation.)
@end itemize
@need 1200
In a C macro, the formal parameters come next, with a statement of
-what kind of object they are, followed by what might be called the ``body''
-of the macro. For @code{delete-and-extract-region} the ``body''
+what kind of object they are, followed by the body
+of the macro. For @code{delete-and-extract-region} the body
consists of the following four lines:
@smallexample
In early versions of Emacs, these two numbers were thirty-two bits
long, but the code is slowly being generalized to handle other
lengths. Three of the available bits are used to specify the type of
-information; the remaining bits are used as ``content''.
+information; the remaining bits are used as content.
@samp{XINT} is a C macro that extracts the relevant number from the
longer collection of bits; the three other bits are discarded.
where the buried treasure lies.
(In addition to its name, symbol definition, and variable value, a
-symbol has a ``drawer'' for a @dfn{property list} which can be used to
+symbol has a drawer for a @dfn{property list} which can be used to
record other information. Property lists are not discussed here; see
@ref{Property Lists, , Property Lists, elisp, The GNU Emacs Lisp
Reference Manual}.)
@cindex Retrieving text
@cindex Pasting text
-Whenever you cut text out of a buffer with a ``kill'' command in GNU Emacs,
-you can bring it back with a ``yank'' command. The text that is cut out of
+Whenever you cut text out of a buffer with a kill command in GNU Emacs,
+you can bring it back with a yank command. The text that is cut out of
the buffer is put in the kill ring and the yank commands insert the
appropriate contents of the kill ring back into a buffer (not necessarily
the original buffer).
make sense on reflection. The kill ring is generally thought of as the
complete structure of data that holds the information of what has recently
been cut out of the Emacs buffers. The @code{kill-ring-yank-pointer}
-on the other hand, serves to indicate---that is, to ``point to''---that part
+on the other hand, serves to indicate---that is, to point to---that part
of the kill ring of which the first element (the @sc{car}) will be
inserted.
way to think about and then to solve problems@footnote{You can write
recursive functions to be frugal or wasteful of mental or computer
resources; as it happens, methods that people find easy---that are
-frugal of ``mental resources''---sometimes use considerable computer
+frugal of mental resources---sometimes use considerable computer
resources. Emacs was designed to run on machines that we now consider
limited and its default settings are conservative. You may want to
increase the values of @code{max-specpdl-size} and
repeats the same thing again and again, like an airplane doing a loop.
When the result of evaluating the true-or-false-test is false, the
Lisp interpreter does not evaluate the rest of the @code{while}
-expression and ``exits the loop''.
+expression and exits the loop.
Clearly, if the value returned by evaluating the first argument to
@code{while} is always true, the body following will be evaluated
to be printed in the @file{*scratch*} buffer instead of being printed
in the echo area. (Otherwise you will see something like this in your
echo area: @code{^Jgazelle^J^Jgiraffe^J^Jlion^J^Jtiger^Jnil}, in which
-each @samp{^J} stands for a ``newline''.)
+each @samp{^J} stands for a newline.)
@need 1500
In a recent instance of GNU Emacs, you can evaluate these expressions
equivalent @code{while} loop. Both are Lisp macros. (@xref{Macros, ,
Macros, elisp, The GNU Emacs Lisp Reference Manual}. )
-@code{dolist} works like a @code{while} loop that ``@sc{cdr}s down a
-list'': @code{dolist} automatically shortens the list each time it
+@code{dolist} works like a @code{while} loop that @sc{cdr}s down a
+list: @code{dolist} automatically shortens the list each time it
loops---takes the @sc{cdr} of the list---and binds the @sc{car} of
each shorter version of the list to the first of its arguments.
Like a @code{while} loop, a @code{dolist} loops. What is different is
that it automatically shortens the list each time it loops---it
-``@sc{cdr}s down the list'' on its own---and it automatically binds
+@sc{cdr}s down the list on its own---and it automatically binds
the @sc{car} of each shorter version of the list to the first of its
arguments.
is not the same entity. It is different. In the jargon, it is a
different ``instance''.
-Eventually, if the program is written correctly, the ``slightly
-different arguments'' will become sufficiently different from the first
+Eventually, if the program is written correctly, the slightly
+different arguments will become sufficiently different from the first
arguments that the final instance will stop.
@menu
@code{defun} macro, you install the necessary equipment to build
robots. It is as if you were in a factory, setting up an assembly
line. Robots with the same name are built according to the same
-blueprints. So they have, as it were, the same ``model number'', but a
-different ``serial number''.
+blueprints. So they have the same model number, but a
+different serial number.
We often say that a recursive function ``calls itself''. What we mean
is that the instructions in a recursive function cause the Lisp
The @code{print-elements-recursively} function first tests whether
there is any content in the list; if there is, the function prints the
first element of the list, the @sc{car} of the list. Then the
-function ``invokes itself'', but gives itself as its argument, not the
+function invokes itself, but gives itself as its argument, not the
whole list, but the second and subsequent elements of the list, the
@sc{cdr} of the list.
When the second evaluation occurs, the @code{when} expression is
evaluated and if true, prints the first element of the list it
receives as its argument (which is the second element of the original
-list). Then the function ``calls itself'' with the @sc{cdr} of the list
+list). Then the function calls itself with the @sc{cdr} of the list
it is invoked with, which (the second time around) is the @sc{cdr} of
the @sc{cdr} of the original list.
instance of the program. The new instance is a clone of the first,
but is a separate individual.
-Each time the function ``invokes itself'', it invokes itself on a
+Each time the function invokes itself, it does so on a
shorter version of the original list. It creates a new instance that
works on a shorter list.
every element of a list and the result of that action is accumulated
with the results of performing the action on the other elements.
-This is very like the ``every'' pattern using @code{cons}, except that
+This is very like the @code{every} pattern using @code{cons}, except that
@code{cons} is not used, but some other combiner.
@need 1500
the element is acted on and the results are kept only if the element
meets a criterion.
-Again, this is very like the ``every'' pattern, except the element is
+Again, this is very like the @code{every} pattern, except the element is
skipped unless it meets a criterion.
@need 1500
The solution to the problem of deferred operations is to write in a
manner that does not defer operations@footnote{The phrase @dfn{tail
recursive} is used to describe such a process, one that uses
-``constant space''.}. This requires
+constant space.}. This requires
writing to a different pattern, often one that involves writing two
-function definitions, an ``initialization'' function and a ``helper''
+function definitions, an initialization function and a helper
function.
-The ``initialization'' function sets up the job; the ``helper'' function
+The initialization function sets up the job; the helper function
does the work.
@need 1200
@group
(defun triangle-initialization (number)
"Return the sum of the numbers 1 through NUMBER inclusive.
-This is the `initialization' component of a two function
+This is the initialization component of a two function
duo that uses recursion."
(triangle-recursive-helper 0 0 number))
@end group
@group
(defun triangle-recursive-helper (sum counter number)
"Return SUM, using COUNTER, through NUMBER inclusive.
-This is the “helper” component of a two function duo
+This is the helper component of a two function duo
that uses recursion."
(if (> counter number)
sum
@end group
@end smallexample
-The ``initialization'' function calls the first instance of the ``helper''
+The initialization function calls the first instance of the helper
function with three arguments: zero, zero, and a number which is the
number of rows in the triangle.
-The first two arguments passed to the ``helper'' function are
+The first two arguments passed to the helper function are
initialization values. These values are changed when
@code{triangle-recursive-helper} invokes new instances.@footnote{The
jargon is mildly confusing: @code{triangle-recursive-helper} uses a
process that is iterative in a procedure that is recursive. The
process is called iterative because the computer need only record the
three values, @code{sum}, @code{counter}, and @code{number}; the
-procedure is recursive because the function ``calls itself''. On the
+procedure is recursive because the function calls itself. On the
other hand, both the process and the procedure used by
@code{triangle-recursively} are called recursive. The word
``recursive'' has different meanings in the two contexts.}
character in the target. If the search is backwards, it leaves point
just before the first character in the target. You may tell
@code{re-search-forward} to return @code{t} for true. (Moving point
-is therefore a ``side effect''.)
+is therefore a side effect.)
Like @code{search-forward}, the @code{re-search-forward} function takes
four arguments:
evaluates the else-part. The true-or-false-test of the @code{if}
expression is the regular expression search.
-It may seem odd to have what looks like the ``real work'' of
+It may seem odd to have what looks like the real work of
the @code{forward-sentence} function buried here, but this is a common
way this kind of operation is carried out in Lisp.
Lisp files in that directory.
@need 1250
-The @code{etags} program takes all the usual shell ``wildcards''. For
+The @code{etags} program takes all the usual shell wildcards. For
example, if you have two directories for which you want a single
@file{TAGS} file, type @w{@code{etags *.el ../elisp/*.el}}, where
@file{../elisp/} is the second directory:
Type @w{@kbd{M-x locate @key{RET} TAGS @key{RET}}} and Emacs will list
for you the full path names of all your @file{TAGS} files. On my
system, this command lists 34 @file{TAGS} files. On the other hand, a
-``plain vanilla'' system I recently installed did not contain any
+plain vanilla system I recently installed did not contain any
@file{TAGS} files.
If the tags table you want has been created, you can use the @code{M-x
It indicates that the following character is interpreted differently
than usual. For example, the two characters, @samp{\n}, stand for
@samp{newline}, rather than for a backslash followed by @samp{n}. Two
-backslashes in a row stand for an ordinary, ``unspecial'' backslash, so
+backslashes in a row stand for an ordinary, unspecial backslash, so
Emacs Lisp interpreter ends of seeing a single backslash followed by a
letter. So it discovers the letter is special.)
user.
Often, one thinks of the binding within a @code{let} expression as
-somehow secondary to the ``primary'' work of a function. But in this
-case, what you might consider the ``primary'' job of the function,
+somehow secondary to the primary work of a function. But in this
+case, what you might consider the primary job of the function,
counting words, is done within the @code{let} expression.
@need 1250
Next, we need to write the recursive counting function.
-A recursive function has at least three parts: the ``do-again-test'', the
-``next-step-expression'', and the recursive call.
+A recursive function has at least three parts: the do-again-test, the
+next-step-expression, and the recursive call.
The do-again-test determines whether the function will or will not be
called again. Since we are counting words in a region and can use a
The third part of a recursive function is the recursive call.
-Somewhere, also, we also need a part that does the ``work'' of the
+Somewhere, also, we also need a part that does the work of the
function, a part that does the counting. A vital part!
@need 1250
function definition, the first question is (or ought to be) what are
we going to count? When we speak of ``words'' with respect to a Lisp
function definition, we are actually speaking, in large part, of
-``symbols''. For example, the following @code{multiply-by-seven}
+symbols. For example, the following @code{multiply-by-seven}
function contains the five symbols @code{defun},
@code{multiply-by-seven}, @code{number}, @code{*}, and @code{7}. In
addition, in the documentation string, it contains the four words
Tables, elisp, The GNU Emacs Lisp Reference Manual}.)
Syntax tables specify which characters belong to which categories.
-Usually, a hyphen is not specified as a ``word constituent character''.
-Instead, it is specified as being in the ``class of characters that are
-part of symbol names but not words.'' This means that the
+Usually, a hyphen is not specified as a word constituent character.
+Instead, it is specified as being in the class of characters that are
+part of symbol names but not words. This means that the
@code{@value{COUNT-WORDS}} function treats it in the same way it treats
an interword white space, which is why @code{@value{COUNT-WORDS}}
counts @samp{multiply-by-seven} as three words.
procedure has the merit of clarity, but the task is a little tricky.
@need 1200
-The first part is simple enough: the pattern must match ``at least one
-character that is a word or symbol constituent''. Thus:
+The first part is simple enough: the pattern must match at least one
+character that is a word or symbol constituent. Thus:
@smallexample
"\\(\\w\\|\\s_\\)+"
characters must be matched at least once.
However, the second part of the regexp is more difficult to design.
-What we want is to follow the first part with ``optionally one or more
-characters that are not constituents of a word or symbol''. At first,
+What we want is to follow the first part with optionally one or more
+characters that are not constituents of a word or symbol. At first,
I thought I could define this with the following:
@smallexample
@section @code{lengths-list-file} in Detail
The core of the @code{lengths-list-file} function is a @code{while}
-loop containing a function to move point forward ``defun by defun'' and
+loop containing a function to move point forwar,d defun by defun, and
a function to count the number of words and symbols in each defun.
This core must be surrounded by functions that do various other tasks,
including finding the file, and ensuring that point starts out at the
function is usually not needed---Emacs creates a fresh buffer if none
already exists; but if a buffer visiting the file already exists Emacs
returns that one. In this case, the buffer may be narrowed and must
-be widened. If we wanted to be fully ``user-friendly'', we would
+be widened. If we wanted to be fully user-friendly, we would
arrange to save the restriction and the location of point, but we
won't.
The @code{(goto-char (point-min))} expression moves point to the
beginning of the buffer.
-Then comes a @code{while} loop in which the ``work'' of the function is
+Then comes a @code{while} loop in which the work of the function is
carried out. In the loop, Emacs determines the length of each
definition and constructs a lengths' list containing the information.
with recursion. A recursive version of @code{lengths-list-many-files}
is short and simple.
-The recursive function has the usual parts: the ``do-again-test'', the
-``next-step-expression'', and the recursive call. The ``do-again-test''
+The recursive function has the usual parts: the do-again-test, the
+next-step-expression, and the recursive call. The do-again-test
determines whether the function should call itself again, which it
will do if the @code{list-of-files} contains any remaining elements;
-the ``next-step-expression'' resets the @code{list-of-files} to the
+the next-step-expression resets the @code{list-of-files} to the
@sc{cdr} of itself, so eventually the list will be empty; and the
recursive call calls itself on the shorter list. The complete
function is shorter than this description!
@end ifnottex
Based on what we have done before, we can readily foresee that it
-should not be too hard to write a function that ``@sc{cdr}s'' down the
+should not be too hard to write a function that @sc{cdr}s down the
lengths' list, looks at each element, determines which length range it
is in, and increments a counter for that range.
Emacs contains a function to sort lists, called (as you might guess)
@code{sort}. The @code{sort} function takes two arguments, the list
to be sorted, and a predicate that determines whether the first of
-two list elements is ``less'' than the second.
+two list elements is less than the second.
As we saw earlier (@pxref{Wrong Type of Argument, , Using the Wrong
Type Object as an Argument}), a predicate is a function that
The @code{directory-files-and-attributes} function returns a list of
lists. Each of the lists within the main list consists of 13
elements. The first element is a string that contains the name of the
-file---which, in GNU/Linux, may be a ``directory file'', that is to
+file---which, in GNU/Linux, may be a @dfn{directory file}, that is to
say, a file with the special attributes of a directory. The second
element of the list is @code{t} for a directory, a string
for symbolic link (the string is the name linked to), or @code{nil}.
sub-directory and repeat its actions.
However, we should note that every directory contains a name that
-refers to itself, called @file{.}, (``dot'') and a name that refers to
-its parent directory, called @file{..} (``double dot''). (In
+refers to itself, called @file{.} (``dot''), and a name that refers to
+its parent directory, called @file{..} (``dot dot''). (In
@file{/}, the root directory, @file{..} refers to itself, since
@file{/} has no parent.) Clearly, we do not want our
@code{files-in-below-directory} function to enter those directories,
@code{while} loop to move from one filename to another within a
directory, checking what needs to be done; and we will use a recursive
call to repeat the actions on each sub-directory. The recursive
-pattern is ``accumulate''
+pattern is Accumulate
(@pxref{Accumulate}),
using @code{append} as the combiner.
(4 3 2 1)
@end smallexample
-Note that the @code{nreverse} function is ``destructive''---that is,
+Note that the @code{nreverse} function is destructive---that is,
it changes the list to which it is applied; this contrasts with the
@code{car} and @code{cdr} functions, which are non-destructive. In
this case, we do not want the original @code{defuns-per-range-list},
Since Emacs is designed to be flexible and work with all kinds of
terminals, including character-only terminals, the graph will need to
-be made from one of the ``typewriter'' symbols. An asterisk will do; as
+be made from one of the typewriter symbols. An asterisk will do; as
we enhance the graph-printing function, we can make the choice of
symbol a user option.
@findex apply
We need a function that passes a list of arguments to a function.
-This function is @code{apply}. This function ``applies'' its first
+This function is @code{apply}. This function applies its first
argument (a function) to its remaining arguments, the last of which
may be a list.
without a book such as this. It is possible to discover other
functions, like @code{search-forward} or @code{insert-rectangle}, by
guessing at a part of their names and then using @code{apropos}. Even
-though its base in metaphor is clear---``apply'' its first argument to
+though its base in metaphor is clear---apply its first argument to
the rest---I doubt a novice would come up with that particular word
when using @code{apropos} or other aid. Of course, I could be wrong;
after all, the function was first named by someone who had to invent
As written, @code{column-of-graph} contains a major flaw: the symbols
used for the blank and for the marked entries in the column are
-``hard-coded'' as a space and asterisk. This is fine for a prototype,
+hard-coded as a space and asterisk. This is fine for a prototype,
but you, or another user, may wish to use other symbols. For example,
in testing the graph function, you many want to use a period in place
of the space, to make sure the point is being repositioned properly
below the top is blank. To construct a column for a line graph, the
function first constructs a list of blanks that is one shorter than
the value, then it uses @code{cons} to attach a graph symbol to the
-list; then it uses @code{cons} again to attach the ``top blanks'' to
+list; then it uses @code{cons} again to attach the top blanks to
the list.
It is easy to see how to write such a function, but since we don't
@w{@code{(sit-for 0)}} expression in the @code{while} loop. This
expression makes the graph printing operation more interesting to
watch than it would be otherwise. The expression causes Emacs to
-``sit'' or do nothing for a zero length of time and then redraw the
+@dfn{sit} or do nothing for a zero length of time and then redraw the
screen. Placed here, it causes Emacs to redraw the screen column by
column. Without it, Emacs would not redraw the screen until the
function exits.
@findex recursive-graph-body-print
The @code{graph-body-print} function may also be written recursively.
-The recursive solution is divided into two parts: an outside ``wrapper''
+The recursive solution is divided into two parts: an outside wrapper
that uses a @code{let} expression to determine the values of several
variables that need only be found once, such as the maximum height of
the graph, and an inside function that is called recursively to print
the graph.
@need 1250
-The ``wrapper'' is uncomplicated:
+The wrapper is uncomplicated:
@smallexample
@group
@end smallexample
The recursive function is a little more difficult. It has four parts:
-the ``do-again-test'', the printing code, the recursive call, and the
-``next-step-expression''. The ``do-again-test'' is a @code{when}
+the do-again-test, the printing code, the recursive call, and the
+next-step-expression. The do-again-test is a @code{when}
expression that determines whether the @code{numbers-list} contains
any remaining elements; if it does, the function prints one column of
the graph using the printing code and calls itself again. The
function calls itself again according to the value produced by the
-``next-step-expression'' which causes the call to act on a shorter
+next-step-expression which causes the call to act on a shorter
version of the @code{numbers-list}.
@smallexample
@cindex Initialization file
``You don't have to like Emacs to like it''---this seemingly
-paradoxical statement is the secret of GNU Emacs. The plain, ``out of
-the box'' Emacs is a generic tool. Most people who use it, customize
+paradoxical statement is the secret of GNU Emacs. The plain, out-of-the-box
+Emacs is a generic tool. Most people who use it, customize
it to suit themselves.
GNU Emacs is mostly written in Emacs Lisp; this means that by writing
right default for such a file, just as C mode is the right default for
editing C code. (Enough programming languages have syntaxes
that enable them to share or nearly share features, so C mode is
-now provided by CC mode, the ``C Collection''.)
+now provided by CC mode, the C Collection.)
But when you do know who is going to use Emacs---you,
yourself---then it makes sense to customize Emacs.
everyone.
Two site-wide initialization files, @file{site-load.el} and
-@file{site-init.el}, are loaded into Emacs and then ``dumped'' if a
-``dumped'' version of Emacs is created, as is most common. (Dumped
+@file{site-init.el}, are loaded into Emacs and then dumped if a
+dumped version of Emacs is created, as is most common. (Dumped
copies of Emacs load more quickly. However, once a file is loaded and
dumped, a change to it does not lead to a change in Emacs unless you
load it yourself or re-dump Emacs. @xref{Building Emacs, , Building
@node Text and Auto-fill
@section Text and Auto Fill Mode
-Now we come to the part that ``turns on'' Text mode and
+Now we come to the part that turns on Text mode and
Auto Fill mode.
@smallexample
the line says @w{@samp{-*- C -*-}}, Emacs turns on C mode. Emacs
possesses a list of extensions and specifications that it uses
automatically. In addition, Emacs looks near the last page for a
-per-buffer, ``local variables list'', if any.
+per-buffer, local variables list, if any.
@ifinfo
@xref{Choosing Modes, , How Major Modes are Chosen, emacs, The GNU
@code{turn-on-auto-fill} is the name of a program, that, you guessed
it!, turns on Auto Fill mode.
-Every time Emacs turns on Text mode, Emacs runs the commands ``hooked''
+Every time Emacs turns on Text mode, Emacs runs the commands hooked
onto Text mode. So every time Emacs turns on Text mode, Emacs also
turns on Auto Fill mode.
@node Mail Aliases
@section Mail Aliases
-Here is a @code{setq} that ``turns on'' mail aliases, along with more
+Here is a @code{setq} that turns on mail aliases, along with more
reminders.
@smallexample
says, in effect, ``Yes, use mail aliases.''
Mail aliases are convenient short names for long email addresses or
-for lists of email addresses. The file where you keep your ``aliases''
+for lists of email addresses. The file where you keep your aliases
is @file{~/.mailrc}. You write an alias like this:
@smallexample
@findex global-set-key
The command is @code{global-set-key}. It is followed by the
keybinding. In a @file{.emacs} file, the keybinding is written as
-shown: @code{\C-c} stands for ``control-c'', which means ``press the
-control key and the @key{c} key at the same time''. The @code{w} means
-``press the @key{w} key''. The keybinding is surrounded by double
+shown: @code{\C-c} stands for Control-C, which means to press the
+control key and the @key{c} key at the same time. The @code{w} means
+to press the @key{w} key. The keybinding is surrounded by double
quotation marks. In documentation, you would write this as
@w{@kbd{C-c w}}. (If you were binding a @key{META} key, such as
@kbd{M-c}, rather than a @key{CTRL} key, you would write
As for the keybinding itself: @kbd{C-c w}. This combines the prefix
key, @kbd{C-c}, with a single character, in this case, @kbd{w}. This
set of keys, @kbd{C-c} followed by a single character, is strictly
-reserved for individuals' own use. (I call these ``own'' keys, since
+reserved for individuals' own use. (I call these @dfn{own} keys, since
these are for my own use.) You should always be able to create such a
keybinding for your own use without stomping on someone else's
keybinding. If you ever write an extension to Emacs, please avoid
taking any of these keys for public use. Create a key like @kbd{C-c
-C-w} instead. Otherwise, we will run out of ``own'' keys.
+C-w} instead. Otherwise, we will run out of own keys.
@need 1250
Here is another keybinding, with a comment:
Rarely used functions are frequently autoloaded. The
@file{loaddefs.el} library contains thousands of autoloaded functions,
from @code{5x5} to @code{zone}. Of course, you may
-come to use a ``rare'' function frequently. When you do, you should
+come to use a rare function frequently. When you do, you should
load that function's file with a @code{load} expression in your
@file{.emacs} file.
In my @file{.emacs} file, I load 14 libraries that contain functions
that would otherwise be autoloaded. (Actually, it would have been
-better to include these files in my ``dumped'' Emacs, but I forgot.
+better to include these files in my dumped Emacs, but I forgot.
@xref{Building Emacs, , Building Emacs, elisp, The GNU Emacs Lisp
Reference Manual}, and the @file{INSTALL} file for more about
dumping.)
@end group
@end smallexample
-If you want to write with Chinese ``GB'' characters, set this instead:
+If you want to write with Chinese GB characters, set this instead:
@smallexample
@group
@code{:eval} says to evaluate the following form and use the result as
a string to display. In this case, the expression displays the first
component of the full system name. The end of the first component is
-a @samp{.} (``period''), so I use the @code{string-match} function to
+a @samp{.} (period), so I use the @code{string-match} function to
tell me the length of the first component. The substring from the
zeroth character to that length is the name of the machine.
@emph{top} of the window.) @samp{%-} inserts enough dashes to fill
out the line.
-Remember, ``You don't have to like Emacs to like it''---your own
+Remember, you don't have to like Emacs to like it---your own
Emacs can have different colors, different commands, and different
keys than a default Emacs.
-On the other hand, if you want to bring up a plain ``out of the box''
+On the other hand, if you want to bring up a plain out-of-the-box
Emacs, with no customization, type:
@smallexample
long lines. As usual, you can quit the debugger by typing @kbd{q} in
the @file{*Backtrace*} buffer.)
-In practice, for a bug as simple as this, the ``Lisp error'' line will
+In practice, for a bug as simple as this, the Lisp error line will
tell you what you need to know to correct the definition. The
-function @code{1=} is ``void''.
+function @code{1=} is void.
@ignore
@need 800
an arrowhead at the left hand side of that line. The arrowhead marks
the line where the function is executing. (In the following examples,
we show the arrowhead with @samp{=>}; in a windowing system, you may
-see the arrowhead as a solid triangle in the window ``fringe''.)
+see the arrowhead as a solid triangle in the window fringe.)
@smallexample
=>@point{}(if (= number 1)
@noindent
This means the value of @code{number} is 3, which is octal three,
-hexadecimal three, and @sc{ascii} ``control-c'' (the third letter of the
+hexadecimal three, and @sc{ascii} Control-C (the third letter of the
alphabet, in case you need to know this information).
You can continue moving through the code until you reach the line with
Install the @code{@value{COUNT-WORDS}} function and then cause it to
enter the built-in debugger when you call it. Run the command on a
region containing two words. You will need to press @kbd{d} a
-remarkable number of times. On your system, is a ``hook'' called after
+remarkable number of times. On your system, is a hook called after
the command finishes? (For information on hooks, see @ref{Command
Overview, , Command Loop Overview, elisp, The GNU Emacs Lisp Reference
Manual}.)
character codes; and it shows how to create a temporary buffer.
(The @code{indent-to} function is written in C rather than Emacs Lisp;
-it is a ``built-in'' function. @code{help-follow} takes you to its
+it is a built-in function. @code{help-follow} takes you to its
source as does @code{find-tag}, when properly set up.)
You can look at a function's source using @code{find-tag}, which is
@code{interprogram-paste} and one if not.
@need 2000
-Let us consider the ``if not'' or else-part of the @code{current-kill}
+Let us consider the else-part of the @code{current-kill}
function. (The then-part uses the @code{kill-new} function, which
we have already described. @xref{kill-new function, , The
@code{kill-new} function}.)
even in the bowels of a computer. As it is, the code in Emacs implies
that a human who is acting virtuously, by exploring his or her
environment, is making an error. This is bad. Even though the computer
-takes the same steps as it does when there is an ``error'', a term such as
+takes the same steps as it does when there is an error, a term such as
``cancel'' would have a clearer connotation.
@ifnottex
(* (1+ (/ 12 5)) 5)
@end smallexample
-All through this discussion, we have been using ``five'' as the value
+All through this discussion, we have been using 5 as the value
for spacing labels on the Y axis; but we may want to use some other
-value. For generality, we should replace ``five'' with a variable to
+value. For generality, we should replace 5 with a variable to
which we can assign a value. The best name I can think of for this
variable is @code{Y-axis-label-spacing}.
@end smallexample
Next, we create the function to print the numbered line, starting with
-the number ``1'' under the first column:
+the number 1 under the first column:
@findex print-X-axis-numbered-line
@smallexample
@end smallexample
@noindent
-is a function definition that says ``return the value resulting from
-dividing whatever is passed to me as @code{arg} by 50''.
+is a function that returns the value resulting from
+dividing whatever is passed to it as @code{arg} by 50.
@need 1200
Earlier, for example, we had a function @code{multiply-by-seven}; it
When a major mode defines a system abbrev, it should call
@code{define-abbrev} and specify @code{t} for the @code{:system}
-property. Be aware that any saved non-``system'' abbrevs are restored
+property. Be aware that any saved non-system abbrevs are restored
at startup, i.e., before some major modes are loaded. Therefore, major
modes should not assume that their abbrev tables are empty when they
are first loaded.
with properties @var{props} (@pxref{Abbrev Properties}). The return
value is @var{name}. The @code{:system} property in @var{props} is
treated specially here: if it has the value @code{force}, then it will
-overwrite an existing definition even for a non-``system'' abbrev of
+overwrite an existing definition even for a non-system abbrev of
the same name.
@var{name} should be a string. The argument @var{expansion} is
normally the desired expansion (a string), or @code{nil} to undefine
the abbrev. If it is anything but a string or @code{nil}, then the
-abbreviation ``expands'' solely by running @var{hook}.
+abbreviation expands solely by running @var{hook}.
The argument @var{hook} is a function or @code{nil}. If @var{hook} is
non-@code{nil}, then it is called with no arguments after the abbrev is
and window-local buffer lists have all been removed. Functions for
resizing windows can delete windows if they become too small.
-The ``action function'' feature for controlling buffer display has
+The action-function feature for controlling buffer display has
been removed, including @code{display-buffer-overriding-action} and
related variables, as well as the @var{action} argument to
@code{display-buffer} and other functions. The way to
The standard completion interface has been simplified, eliminating the
@code{completion-extra-properties} variable, the @code{metadata}
action flag for completion functions, and the concept of
-``completion categories''. Lisp programmers may now find the choice
+completion categories. Lisp programmers may now find the choice
of methods for tuning completion less bewildering, but if a package
finds the streamlined interface insufficient for its needs, it must
implement its own specialized completion feature.
Most of the GNU Emacs text editor is written in the programming
language called Emacs Lisp. You can write new code in Emacs Lisp and
install it as an extension to the editor. However, Emacs Lisp is more
-than a mere ``extension language''; it is a full computer programming
+than a mere extension language; it is a full computer programming
language in its own right. You can use it as you would any other
programming language.
@xref{Numbered Backups}.
In this example, the value says that @file{~rms/foo.~5~} is the name
-to use for the new backup file, and @file{~rms/foo.~3~} is an ``excess''
+to use for the new backup file, and @file{~rms/foo.~3~} is an excess
version that the caller should consider deleting now.
@smallexample
* Buffer File Name:: The buffer file name indicates which file is visited.
* Buffer Modification:: A buffer is @dfn{modified} if it needs to be saved.
* Modification Time:: Determining whether the visited file was changed
- ``behind Emacs's back''.
+ behind Emacs's back.
* Read Only Buffers:: Modifying text is not allowed in a read-only buffer.
* Buffer List:: How to look at all the existing buffers.
* Creating Buffers:: Functions that create buffers.
is dedicated (@pxref{Dedicated Windows}) and there are other windows on
its frame, the window is deleted. If it is the only window on its frame
and that frame is not the only frame on its terminal, the frame is
-``dismissed'' by calling the function specified by
+dismissed by calling the function specified by
@code{frame-auto-hide-function} (@pxref{Quitting Windows}). Otherwise,
it calls @code{switch-to-prev-buffer} (@pxref{Window History}) to show
another buffer in that window. If @var{buffer-or-name} is displayed in
buffer.
Any processes that have this buffer as the @code{process-buffer} are
-sent the @code{SIGHUP} (``hangup'') signal, which normally causes them
+sent the @code{SIGHUP} (hangup) signal, which normally causes them
to terminate. @xref{Signals to Processes}.
If the buffer is visiting a file and contains unsaved changes,
@var{name} is the name of an existing buffer, an error is signaled.
If @var{clone} is non-@code{nil}, then the indirect buffer originally
-shares the ``state'' of @var{base-buffer} such as major mode, minor
+shares the state of @var{base-buffer} such as major mode, minor
modes, buffer local variables and so on. If @var{clone} is omitted
or @code{nil} the indirect buffer's state is set to the default state
for new buffers.
of @code{describe-function} will include similar information.
The value of the property can be: a string, which the byte-compiler
will use directly in its warning (it should end with a period, and not
-start with a capital, e.g., ``use @dots{} instead.''); @code{t}; any
+start with a capital, e.g., @code{"use (system-name) instead."}); @code{t}; any
other symbol, which should be an alternative function to use in Lisp
code.
single-click command has already run. It must produce the desired
results of a double click, starting from the results of a single click.
-This is convenient, if the meaning of a double click somehow ``builds
-on'' the meaning of a single click---which is recommended user interface
+This is convenient, if the meaning of a double click somehow builds
+on the meaning of a single click---which is recommended user interface
design practice for double clicks.
If you click a button, then press it down again and start moving the
button and modifier keys. The information about the window part is kept
elsewhere in the event---in the coordinates. But
@code{read-key-sequence} translates this information into imaginary
-``prefix keys'', all of which are symbols: @code{header-line},
+prefix keys, all of which are symbols: @code{header-line},
@code{horizontal-scroll-bar}, @code{menu-bar}, @code{mode-line},
@code{vertical-line}, and @code{vertical-scroll-bar}. You can define
meanings for mouse clicks in special window parts by defining key
account, use the function @code{read-key}:
@defun read-key &optional prompt
-This function reads a single key. It is ``intermediate'' between
+This function reads a single key. It is intermediate between
@code{read-key-sequence} and @code{read-event}. Unlike the former, it
reads a single key, not a key sequence. Unlike the latter, it does
not return a raw event, but decodes and translates the user input
from @code{read-event}.
@defvar extra-keyboard-modifiers
-This variable lets Lisp programs ``press'' the modifier keys on the
+This variable lets Lisp programs press the modifier keys on the
keyboard. The value is a character. Only the modifiers of the
character matter. Each time the user types a keyboard key, it is
altered as if those modifier keys were held down. For instance, if
Thus, setting @code{extra-keyboard-modifiers} to zero cancels any
modification.
-When using a window system, the program can ``press'' any of the
+When using a window system, the program can press any of the
modifier keys in this way. Otherwise, only the @key{CTL} and @key{META}
keys can be virtually pressed.
@node Event Input Misc
@subsection Miscellaneous Event Input Features
-This section describes how to ``peek ahead'' at events without using
+This section describes how to peek ahead at events without using
them up, how to check for pending input, and how to discard pending
input. See also the function @code{read-passwd} (@pxref{Reading a
Password}).
binding is unwound at the end of a @code{let} form. At that time, if
@code{quit-flag} is still non-@code{nil}, the requested quit happens
immediately. This behavior is ideal when you wish to make sure that
-quitting does not happen within a ``critical section'' of the program.
+quitting does not happen within a critical section of the program.
@cindex @code{read-quoted-char} quitting
In some functions (such as @code{read-quoted-char}), @kbd{C-g} is
change the major mode of the current buffer temporarily to a special
major mode, which should have a command to go back to the previous mode.
(The @kbd{e} command in Rmail uses this technique.) Or, if you wish to
-give the user different text to edit ``recursively'', create and select
+give the user different text to edit recursively, create and select
a new buffer in a special mode. In this mode, define a command to
complete the processing and go back to the previous buffer. (The
@kbd{m} command in Rmail does this.)
If @var{symbol}'s definition is a byte-code function object,
@code{byte-compile} does nothing and returns @code{nil}. It does not
-``compile the symbol's definition again'', since the original
+compile the symbol's definition again, since the original
(non-compiled) code has already been replaced in the symbol's function
cell by the byte-compiled code.
When Emacs loads functions and variables from a byte-compiled file,
it normally does not load their documentation strings into memory.
-Each documentation string is ``dynamically'' loaded from the
+Each documentation string is dynamically loaded from the
byte-compiled file only when needed. This saves memory, and speeds up
loading by skipping the processing of the documentation strings.
accomplished by writing compiled files with a special Lisp reader
construct, @samp{#@@@var{count}}. This construct skips the next
@var{count} characters. It also uses the @samp{#$} construct, which
-stands for ``the name of this file, as a string''. Do not use these
+stands for the name of this file, as a string. Do not use these
constructs in Lisp source files; they are not designed to be clear to
humans reading the file.
two or more forms in succession and use the value of the last of them.
But programmers found they often needed to use a @code{progn} in the
body of a function, where (at that time) only one form was allowed. So
-the body of a function was made into an ``implicit @code{progn}'':
+the body of a function was made into an implicit @code{progn}:
several forms are allowed just as in the body of an actual @code{progn}.
Many other control structures likewise contain an implicit @code{progn}.
As a result, @code{progn} is not used as much as it was many years ago.
@code{cond} tries the clauses in textual order, by evaluating the
@var{condition} of each clause. If the value of @var{condition} is
-non-@code{nil}, the clause ``succeeds''; then @code{cond} evaluates its
+non-@code{nil}, the clause succeeds; then @code{cond} evaluates its
@var{body-forms}, and returns the value of the last of @var{body-forms}.
Any remaining clauses are ignored.
-If the value of @var{condition} is @code{nil}, the clause ``fails'', so
+If the value of @var{condition} is @code{nil}, the clause fails, so
the @code{cond} moves on to the following clause, trying its @var{condition}.
A clause may also look like this:
@end group
@end example
-To write a ``repeat...until'' loop, which will execute something on each
+To write a repeat-until loop, which will execute something on each
iteration and then do the end-test, put the body followed by the
end-test in a @code{progn} as the first argument of @code{while}, as
shown here:
It's important to note that generator function bodies only execute
inside calls to @code{iter-next}. A call to a function defined with
-@code{iter-defun} produces an iterator; you must ``drive'' this
+@code{iter-defun} produces an iterator; you must drive this
iterator with @code{iter-next} for anything interesting to happen.
Each call to a generator function produces a @emph{different}
iterator, each with its own state.
@subsection Examples of @code{catch} and @code{throw}
One way to use @code{catch} and @code{throw} is to exit from a doubly
-nested loop. (In most languages, this would be done with a ``goto''.)
+nested loop. (In most languages, this would be done with a @code{goto}.)
Here we compute @code{(foo @var{i} @var{j})} for @var{i} and @var{j}
varying from 0 to 9:
(@pxref{Processing of Errors}). Here we describe how to signal an
error.
- Most errors are signaled ``automatically'' within Lisp primitives
+ Most errors are signaled automatically within Lisp primitives
which you call for other purposes, such as if you try to take the
@sc{car} of an integer or move forward a character at the end of the
buffer. You can also signal errors explicitly with the functions
Specify @var{getfunction} as the way to extract the value of this
option. The function @var{getfunction} should take one argument, a
symbol, and should return whatever customize should use as the
-``current value'' for that symbol (which need not be the symbol's Lisp
+current value for that symbol (which need not be the symbol's Lisp
value). The default is @code{default-value}.
You have to really understand the workings of Custom to use
@end table
It is useful to specify the @code{:require} keyword for an option
-that ``turns on'' a certain feature. This causes Emacs to load the
+that turns on a certain feature. This causes Emacs to load the
feature, if it is not already loaded, whenever the option is set.
@xref{Common Keywords}. Here is an example, from the library
@file{saveplace.el}:
@end example
@noindent
-specifies that there are three ``known'' keys, namely @code{"foo"},
+specifies that there are three known keys, namely @code{"foo"},
@code{"bar"} and @code{"baz"}, which will always be shown first.
You may want to restrict the value type for specific keys, for
@item (radio @var{element-types}@dots{})
This is similar to @code{choice}, except that the choices are displayed
-using ``radio buttons'' rather than a menu. This has the advantage of
+using radio buttons rather than a menu. This has the advantage of
displaying documentation for the choices when applicable and so is often
a good choice for a choice between constant functions
(@code{function-item} customization types).
Themes*} buffer.
Two special theme names are disallowed (using them causes an error):
-@code{user} is a ``dummy'' theme that stores the user's direct
-customization settings, and @code{changed} is a ``dummy'' theme that
+@code{user} is a dummy theme that stores the user's direct
+customization settings, and @code{changed} is a dummy theme that
stores changes made outside of the Customize system.
@end defmac
@end defun
In theory, a theme file can also contain other Lisp forms, which
-would be evaluated when loading the theme, but that is ``bad form''.
+would be evaluated when loading the theme, but that is bad form.
To protect against loading themes containing malicious code, Emacs
displays the source file and asks for confirmation from the user
before loading any non-built-in theme for the first time.
@defvar custom-known-themes
The value of this variable is a list of themes loaded into Emacs.
Each theme is represented by a Lisp symbol (the theme name). The
-default value of this variable is a list containing two ``dummy''
+default value of this variable is a list containing two dummy
themes: @code{(user changed)}. The @code{changed} theme stores
settings made before any Custom themes are applied (e.g., variables
set outside of Customize). The @code{user} theme stores settings the
@cindex debugging invalid Lisp syntax
The Lisp reader reports invalid syntax, but cannot say where the real
-problem is. For example, the error ``End of file during parsing'' in
+problem is. For example, the error @samp{End of file during parsing} in
evaluating an expression indicates an excess of open parentheses (or
square brackets). The reader detects this imbalance at the end of the
file, but it cannot figure out where the close parenthesis should have
-been. Likewise, ``Invalid read syntax: ")"'' indicates an excess close
+been. Likewise, @samp{Invalid read syntax: ")"} indicates an excess close
parenthesis or missing open parenthesis, but does not say where the
missing parenthesis belongs. How, then, to find what to change?
@cindex @samp{\} in display
When a line of text extends beyond the right edge of a window, Emacs
-can @dfn{continue} the line (make it ``wrap'' to the next screen
+can @dfn{continue} the line (make it wrap to the next screen
line), or @dfn{truncate} the line (limit it to one screen line). The
additional screen lines used to display a long text line are called
@dfn{continuation} lines. Continuation is not the same as filling;
indicate truncated and continued lines (@pxref{Fringes}). On a text
terminal, a @samp{$} in the rightmost column of the window indicates
truncation; a @samp{\} on the rightmost column indicates a line that
-``wraps''. (The display table can specify alternate characters to use
+wraps. (The display table can specify alternate characters to use
for this; @pxref{Display Tables}).
@defopt truncate-lines
The arguments @var{min-value} and @var{max-value} should be numbers
standing for the starting and final states of the operation. For
-instance, an operation that ``scans'' a buffer should set these to the
+instance, an operation that scans a buffer should set these to the
results of @code{point-min} and @code{point-max} correspondingly.
@var{max-value} should be greater than @var{min-value}.
Alternatively, you can set @var{min-value} and @var{max-value} to
@code{nil}. In that case, the progress reporter does not report
-process percentages; it instead displays a ``spinner'' that rotates a
+process percentages; it instead displays a spinner that rotates a
notch each time you update the progress reporter.
If @var{min-value} and @var{max-value} are numbers, you can give the
@defun progress-reporter-done reporter
This function should be called when the operation is finished. It
-prints the message of @var{reporter} followed by word ``done'' in the
+prints the message of @var{reporter} followed by word @samp{done} in the
echo area.
You should always call this function and not hope for
-@code{progress-reporter-update} to print ``100%''. Firstly, it may
+@code{progress-reporter-update} to print @samp{100%}. Firstly, it may
never print it, there are many good reasons for this not to happen.
-Secondly, ``done'' is more explicit.
+Secondly, @samp{done} is more explicit.
@end defun
@defmac dotimes-with-progress-reporter (var count [result]) message body@dots{}
successive related messages for the sake of two cases: question
followed by answer, and a series of progress messages.
- A ``question followed by an answer'' means two messages like the
+ A question followed by an answer has two messages like the
ones produced by @code{y-or-n-p}: the first is @samp{@var{question}},
and the second is @samp{@var{question}...@var{answer}}. The first
message conveys no additional information beyond what's in the second,
so logging the second message discards the first from the log.
- A ``series of progress messages'' means successive messages like
+ A series of progress messages has successive messages like
those produced by @code{make-progress-reporter}. They have the form
@samp{@var{base}...@var{how-far}}, where @var{base} is the same each
time, while @var{how-far} varies. Logging each message in the series
This is the only valid way to change the endpoints of an overlay. Do
not try modifying the markers in the overlay by hand, as that fails to
update other vital data structures and can cause some overlays to be
-``lost''.
+lost.
@end defun
@defun remove-overlays &optional start end name value
@end example
Emacs stores the overlays of each buffer in two lists, divided
-around an arbitrary ``center position''. One list extends backwards
+around an arbitrary center position. One list extends backwards
through the buffer from that center position, and the other extends
forwards from that center position. The center position can be anywhere
in the buffer.
@defun overlays-in beg end
This function returns a list of the overlays that overlap the region
-@var{beg} through @var{end}. ``Overlap'' means that at least one
-character is contained within the overlay and also contained within the
-specified region; however, empty overlays (@pxref{Managing Overlays,
-empty overlay}) are included in the result if they are located at
+@var{beg} through @var{end}. An overlay overlaps with a region if it
+contains one or more characters in the region; empty overlays
+(@pxref{Managing Overlays, empty overlay}) overlap if they are at
@var{beg}, strictly between @var{beg} and @var{end}, or at @var{end}
when @var{end} denotes the position at the end of the buffer.
@end defun
@item
If the text lies within an overlay with a non-@code{nil} @code{face}
property, Emacs applies the face(s) specified by that property. If
-the overlay has a @code{mouse-face} property and the mouse is ``near
-enough'' to the overlay, Emacs applies the face or face attributes
+the overlay has a @code{mouse-face} property and the mouse is near
+enough to the overlay, Emacs applies the face or face attributes
specified by the @code{mouse-face} property instead. @xref{Overlay
Properties}.
arguments, @var{specs}, should form either a list of face names, or a
property list of attribute/value pairs.
-The return value is a Lisp object that serves as a ``cookie''; you can
+The return value is a Lisp object that serves as a cookie; you can
pass this object as an argument to @code{face-remap-remove-relative}
if you need to remove the remapping later.
often a good idea to use certain existing faces or inherit from them,
rather than defining entirely new faces. This way, if other users
have customized the basic faces to give Emacs a certain look, your
-program will ``fit in'' without additional customization.
+program will fit in without additional customization.
Some of the basic faces defined in Emacs are listed below. In
addition to these, you might want to make use of the Font Lock faces
unspecified (and so given by @code{default}).
@item shadow
-For ``dimmed out'' text. For example, it is used for the ignored
+For dimmed-out text. For example, it is used for the ignored
part of a filename in the minibuffer (@pxref{Minibuffer File,,
Minibuffers for File Names, emacs, The GNU Emacs Manual}).
@item link
@itemx link-visited
For clickable text buttons that send the user to a different
-buffer or ``location''.
+buffer or location.
@item highlight
For stretches of text that should temporarily stand out. For example,
character codes. An individual font cannot display the whole range of
characters that Emacs supports, but a fontset can. Fontsets have names,
just as fonts do, and you can use a fontset name in place of a font name
-when you specify the ``font'' for a frame or a face. Here is
+when you specify the font for a frame or a face. Here is
information about defining a fontset under Lisp program control.
@defun create-fontset-from-fontset-spec fontset-spec &optional style-variant-p noerror
maximum length of the returned list. The optional argument
@var{prefer}, if non-@code{nil}, should be another font spec, which is
used to control the order of the returned list; the returned font
-entities are sorted in order of decreasing ``closeness'' to that font
+entities are sorted in order of decreasing closeness to that font
spec.
@end defun
If you call @code{set-face-attribute} and pass a font spec, font
entity, or font name string as the value of the @code{:font}
-attribute, Emacs opens the best ``matching'' font that is available
+attribute, Emacs opens the best matching font that is available
for display. It then stores the corresponding font object as the
actual value of the @code{:font} attribute for that face.
@cindex right dividers
@cindex bottom dividers
-Window dividers are bars drawn between a frame's windows. A ``right''
+Window dividers are bars drawn between a frame's windows. A right
divider is drawn between a window and any adjacent windows on the right.
Its width (thickness) is specified by the frame parameter
-@code{right-divider-width}. A ``bottom'' divider is drawn between a
+@code{right-divider-width}. A bottom divider is drawn between a
window and adjacent windows on the bottom or the echo area. Its width
is specified by the frame parameter @code{bottom-divider-width}. In
either case, specifying a width of zero means to not draw such dividers.
@xref{Layout Parameters}.
- Technically, a right divider ``belongs'' to the window on its left,
+ Technically, a right divider belongs to the window on its left,
which means that its width contributes to the total width of that
-window. A bottom divider ``belongs'' to the window above it, which
+window. A bottom divider belongs to the window above it, which
means that its width contributes to the total height of that window.
@xref{Window Sizes}. When a window has both, a right and a bottom
-divider, the bottom divider ``prevails''. This means that a bottom
+divider, the bottom divider prevails. This means that a bottom
divider is drawn over the full total width of its window while the right
divider ends above the bottom divider.
display specifications make most other display specifications
irrelevant, since those don't apply to the replacement.
- For replacing display specifications, ``the text that has the
-property'' means all the consecutive characters that have the same
+ For replacing display specifications, @dfn{the text that has the
+property} means all the consecutive characters that have the same
Lisp object as their @code{display} property; these characters are
replaced as a single unit. If two characters have different Lisp
objects as their @code{display} properties (i.e., objects which are
@table @asis
@item @code{(+ @var{n})}
@c FIXME: Add an index for "step"? --xfq
-This means to use a font that is @var{n} steps larger. A ``step'' is
+This means to use a font that is @var{n} steps larger. A @dfn{step} is
defined by the set of available fonts---specifically, those that match
what was otherwise specified for this text, in all attributes except
height. Each size for which a suitable font is available counts as
@defvar left-margin-width
This variable specifies the width of the left margin, in character
-cell (a.k.a.@: ``column'') units. It is buffer-local in all buffers.
+cell (a.k.a.@: column) units. It is buffer-local in all buffers.
A value of @code{nil} means no left marginal area.
@end defvar
Specifies the Laplace edge detection algorithm, which blurs out small
differences in color while highlighting larger differences. People
sometimes consider this useful for displaying the image for a
-``disabled'' button.
+disabled button.
@item (edge-detection :matrix @var{matrix} :color-adjust @var{adjust})
@cindex edge detection, images
@end ifnottex
@item disabled
-Specifies transforming the image so that it looks ``disabled''.
+Specifies transforming the image so that it looks disabled.
@end table
@item :mask @var{mask}
@code{insert-image}, but splits the image into @var{rows}x@var{cols}
equally sized slices.
-If an image is inserted ``sliced'', Emacs displays each slice as a
-separate image, and allow more intuitive scrolling up/down, instead of
+Emacs displays each slice as a
+separate image, and allows more intuitive scrolling up/down, instead of
jumping up/down the entire image when paging through a buffer that
displays (large) images.
@end defun
multiple frames for GIF, TIFF, and certain ImageMagick formats such as
DJVM@.
-The frames can be used either to represent multiple ``pages'' (this is
+The frames can be used either to represent multiple pages (this is
usually the case with multi-frame TIFF files, for example), or to
create animation (usually the case with multi-frame GIF files).
specific tasks.
@defun define-button-type name &rest properties
-Define a ``button type'' called @var{name} (a symbol).
+Define a button type called @var{name} (a symbol).
The remaining arguments
form a sequence of @var{property value} pairs, specifying default
property values for buttons with this type (a button's type may be set
These are commands and functions for locating and operating on
buttons in an Emacs buffer.
-@code{push-button} is the command that a user uses to actually ``push''
+@code{push-button} is the command that a user uses to actually push
a button, and is bound by default in the button itself to @key{RET}
and to @key{mouse-2} using a local keymap in the button's overlay or
text properties. Commands that are useful outside the buttons itself,
The Ewoc package constructs buffer text that represents a structure
of Lisp objects, and updates the text to follow changes in that
-structure. This is like the ``view'' component in the
-``model/view/controller'' design paradigm. Ewoc means ``Emacs's
+structure. This is like the view component in the
+model--view--controller design paradigm. Ewoc means ``Emacs's
Widget for Object Collections''.
An @dfn{ewoc} is a structure that organizes information required to
@noindent
You can also use, as the data element value, a Lisp object (list or
-vector) that is a container for the ``real'' value, or an index into
+vector) that is a container for the real value, or an index into
some other structure. The example (@pxref{Abstract Display Example})
uses the latter approach.
the footer and every node's textual description. If @var{nosep}
is non-@code{nil}, no newline is inserted. This may be useful for
displaying an entire ewoc on a single line, for example, or for
-making nodes ``invisible'' by arranging for @var{pretty-printer}
+making nodes invisible by arranging for @var{pretty-printer}
to do nothing for those nodes.
An ewoc maintains its text in the buffer that is current when
@subsection Abstract Display Example
Here is a simple example using functions of the ewoc package to
-implement a ``color components display'', an area in a buffer that
+implement a @dfn{color components} display, an area in a buffer that
represents a vector of three integers (itself representing a 24-bit RGB
value) in various ways.
@end example
@cindex controller part, model/view/controller
- This example can be extended to be a ``color selection widget'' (in
-other words, the controller part of the ``model/view/controller''
+ This example can be extended to be a color selection widget (in
+other words, the controller part of the model--view--controller
design paradigm) by defining commands to modify @code{colorcomp-data}
-and to ``finish'' the selection process, and a keymap to tie it all
+and to finish the selection process, and a keymap to tie it all
together conveniently.
@smallexample
@strong{Warning:} if you use the display table to change the display
of newline characters, the whole buffer will be displayed as one long
-``line''.
+line.
- The display table also has six ``extra slots'' which serve special
+ The display table also has six @dfn{extra slots} which serve special
purposes. Here is a table of their meanings; @code{nil} in any slot
means to use the default for that slot, as stated below.
@samp{\230}).
@item format-control
-Characters of Unicode General Category ``Cf'', such as @samp{U+200E}
+Characters of Unicode General Category [Cf], such as @samp{U+200E}
(Left-to-Right Mark), but excluding characters that have graphic
images, such as @samp{U+00AD} (Soft Hyphen).
@end defopt
@defvar ring-bell-function
-If this is non-@code{nil}, it specifies how Emacs should ``ring the
-bell''. Its value should be a function of no arguments. If this is
+If this is non-@code{nil}, it specifies how Emacs should ring the
+bell. Its value should be a function of no arguments. If this is
non-@code{nil}, it takes precedence over the @code{visible-bell}
variable.
@end defvar
position. In performing this @dfn{bidirectional reordering}, Emacs
follows the Unicode Bidirectional Algorithm (a.k.a.@: @acronym{UBA}),
which is described in Annex #9 of the Unicode standard
-(@url{http://www.unicode.org/reports/tr9/}). Emacs provides a ``Full
-Bidirectionality'' class implementation of the @acronym{UBA},
+(@url{http://www.unicode.org/reports/tr9/}). Emacs provides a Full
+Bidirectionality class implementation of the @acronym{UBA},
consistent with the requirements of the Unicode Standard v7.0.
@defvar bidi-display-reordering
when two strings with bidirectional content are juxtaposed in a
buffer, or otherwise programmatically concatenated into a string of
text. A typical problematic case is when a buffer consists of
-sequences of text ``fields'' separated by whitespace or punctuation
+sequences of text fields separated by whitespace or punctuation
characters, like Buffer Menu mode or Rmail Summary Mode. Because the
punctuation characters used as separators have @dfn{weak
directionality}, they take on the directionality of surrounding text.
expression @emph{from the current stop point}, first type @kbd{w}
(@code{edebug-where}) to move point there, and then type @kbd{f}.
-The @kbd{o} command continues ``out of'' an expression. It places a
+The @kbd{o} command continues out of an expression. It places a
temporary breakpoint at the end of the sexp containing point. If the
containing sexp is a function definition itself, @kbd{o} continues until
just before the last sexp in the definition. If that is where you are
frequency.
Coverage testing works by comparing the result of each expression with
-the previous result; each form in the program is considered ``covered''
+the previous result; each form in the program is considered covered
if it has returned two different values since you began testing coverage
in the current Emacs session. Thus, to do coverage testing on your
program, execute it under various conditions and note whether it behaves
The character @samp{=} following the count for an expression says that
the expression has returned the same value each time it was evaluated.
-In other words, it is not yet ``covered'' for coverage testing purposes.
+In other words, it is not yet covered for coverage testing purposes.
To clear the frequency count and coverage data for a definition,
simply reinstrument it with @code{eval-defun}.
@c This paragraph is not filled, because LaLiberte's conversion script
@c needs an xref to be on just one line.
When Edebug needs to display something (e.g., in trace mode), it saves
-the current window configuration from ``outside'' Edebug
+the current window configuration from outside Edebug
(@pxref{Window Configurations}). When you exit Edebug, it restores
the previous window configuration.
Emacs redisplays only when it pauses. Usually, when you continue
execution, the program re-enters Edebug at a breakpoint or after
stepping, without pausing or reading input in between. In such cases,
-Emacs never gets a chance to redisplay the ``outside'' configuration.
+Emacs never gets a chance to redisplay the outside configuration.
Consequently, what you see is the same window configuration as the last
time Edebug was active, with no interruption.
If you instrument the @code{test} macro and step through it, then by
default the result of the @code{symbol-function} call has numerous
@code{edebug-after} and @code{edebug-before} forms, which can make it
-difficult to see the ``actual'' result. If
+difficult to see the actual result. If
@code{edebug-unwrap-results} is non-@code{nil}, Edebug tries to remove
these forms from the result.
@end defopt
we find the real function via the symbol.
* Function Forms:: Forms that call functions.
* Macro Forms:: Forms that call macros.
-* Special Forms:: ``Special forms'' are idiosyncratic primitives,
+* Special Forms:: Special forms are idiosyncratic primitives,
most of them extremely important.
* Autoloading:: Functions set up to load files
containing their real definitions.
Variables
* Global Variables:: Variable values that exist permanently, everywhere.
-* Constant Variables:: Certain ``variables'' have values that never change.
+* Constant Variables:: Variables that never change.
* Local Variables:: Variable values that exist only temporarily.
* Void Variables:: Symbols that lack values.
* Defining Variables:: A definition says a symbol is used as a variable.
* Repeated Loading:: Precautions about loading a file twice.
* Named Features:: Loading a library if it isn't already loaded.
* Where Defined:: Finding which file defined a certain symbol.
-* Unloading:: How to ``unload'' a library that was loaded.
+* Unloading:: How to unload a library that was loaded.
* Hooks for Loading:: Providing code to be run when
particular libraries are loaded.
is visited.
* Buffer Modification:: A buffer is @dfn{modified} if it needs to be saved.
* Modification Time:: Determining whether the visited file was changed
- ``behind Emacs's back''.
+ behind Emacs's back.
* Read Only Buffers:: Modifying text is not allowed in a
read-only buffer.
* Buffer List:: How to look at all the existing buffers.
* Marker Insertion Types:: Two ways a marker can relocate when you
insert where it points.
* Moving Markers:: Moving the marker to a new buffer or position.
-* The Mark:: How ``the mark'' is implemented with a marker.
-* The Region:: How to access ``the region''.
+* The Mark:: How the mark is implemented with a marker.
+* The Region:: How to access the region.
Text
* Base 64:: Conversion to or from base 64 encoding.
* Checksum/Hash:: Computing cryptographic hashes.
* Parsing HTML/XML:: Parsing HTML and XML.
-* Atomic Changes:: Installing several buffer changes ``atomically''.
+* Atomic Changes:: Installing several buffer changes atomically.
* Change Hooks:: Supplying functions to be run when text is changed.
The Kill Ring
A Lisp object that is intended to be evaluated is called a
@dfn{form} (or an @dfn{expression}). How Emacs evaluates a form
depends on its data type. Emacs has three different kinds of form
-that are evaluated differently: symbols, lists, and ``all other
-types''. This section describes all three kinds, one by one, starting
-with the ``all other types'' which are self-evaluating forms.
+that are evaluated differently: symbols, lists, and all other
+types. This section describes all three kinds, one by one, starting
+with the other types, which are self-evaluating forms.
@menu
* Self-Evaluating Forms:: Forms that evaluate to themselves.
we find the real function via the symbol.
* Function Forms:: Forms that call functions.
* Macro Forms:: Forms that call macros.
-* Special Forms:: ``Special forms'' are idiosyncratic primitives,
+* Special Forms:: Special forms are idiosyncratic primitives,
most of them extremely important.
* Autoloading:: Functions set up to load files
containing their real definitions.
@result{} 123
@end group
@group
-(eval '123) ; @r{Evaluated ``by hand''---result is the same.}
+(eval '123) ; @r{Evaluated by hand---result is the same.}
@result{} 123
@end group
@group
Visiting a file means reading a file into a buffer. Once this is
done, we say that the buffer is @dfn{visiting} that file, and call the
-file ``the visited file'' of the buffer.
+file @dfn{the visited file} of the buffer.
A file and a buffer are two different things. A file is information
recorded permanently in the computer (unless you delete it). A
systems that do not support symbolic links, a regular file is used.)
When you access files using NFS, there may be a small probability that
-you and another user will both lock the same file ``simultaneously''.
+you and another user will both lock the same file simultaneously.
If this happens, it is possible for the two users to make changes
simultaneously, but Emacs will still warn the user who saves second.
Also, the detection of modification of a buffer visiting a file changed
@cindex MS-DOS and file modes
@cindex file modes and MS-DOS
@strong{MS-DOS note:} On MS-DOS, there is no such thing as an
-``executable'' file mode bit. So @code{file-modes} considers a file
+executable file mode bit. So @code{file-modes} considers a file
executable if its name ends in one of the standard executable
extensions, such as @file{.com}, @file{.bat}, @file{.exe}, and some
others. Files that begin with the Unix-standard @samp{#!} signature,
appearing as a name component, call @code{file-truename} without prior
direct or indirect calls to @code{expand-file-name}. Otherwise, the
file name component immediately preceding @samp{..} will be
-``simplified away'' before @code{file-truename} is called. To
+simplified away before @code{file-truename} is called. To
eliminate the need for a call to @code{expand-file-name},
@code{file-truename} handles @samp{~} in the same way that
@code{expand-file-name} does. @xref{File Name Expansion,, Functions
and setting two specific sets of extended file attributes: Access
Control Lists (ACLs) and SELinux contexts. These extended file
attributes are used, on some systems, to impose more sophisticated
-file access controls than the basic ``Unix-style'' permissions
+file access controls than the basic Unix-style permissions
discussed in the previous sections.
@cindex access control list
@cindex file with multiple names
@cindex file hard link
This function gives the file named @var{oldname} the additional name
-@var{newname}. This means that @var{newname} becomes a new ``hard
-link'' to @var{oldname}.
+@var{newname}. This means that @var{newname} becomes a new hard
+link to @var{oldname}.
In the first part of the following example, we list two files,
@file{foo} and @file{foo3}.
the correct permissions to do so.
If the optional argument @var{preserve-permissions} is non-@code{nil},
-this function copies the file modes (or ``permissions'') of
+this function copies the file modes (or permissions) of
@var{oldname} to @var{newname}, as well as the Access Control List and
SELinux context (if any). @xref{Information about Files}.
has these permissions, or a subset of them (@code{write-region} will
not grant execute permissions even if the default file permissions
allow execution). On Unix and GNU/Linux, the default permissions are
-given by the bitwise complement of the ``umask'' value.
+given by the bitwise complement of the @samp{umask} value.
The argument @var{mode} should be an integer which specifies the
permissions, similar to @code{set-file-modes} above. Only the lowest
@end defun
@defun file-name-extension filename &optional period
-This function returns @var{filename}'s final ``extension'', if any,
+This function returns @var{filename}'s final extension, if any,
after applying @code{file-name-sans-versions} to remove any
version/backup part. The extension, in a file name, is the part that
follows the last @samp{.} in the last name component (minus any
@file{foo}. It returns @code{""} for null extensions, as in
@file{foo.}. If the last component of a file name begins with a
@samp{.}, that @samp{.} doesn't count as the beginning of an
-extension. Thus, @file{.emacs}'s ``extension'' is @code{nil}, not
+extension. Thus, @file{.emacs}'s extension is @code{nil}, not
@samp{.emacs}.
If @var{period} is non-@code{nil}, then the returned value includes
@noindent
This is for the sake of filesystems that have the concept of a
-``superroot'' above the root directory @file{/}. On other filesystems,
+superroot above the root directory @file{/}. On other filesystems,
@file{/../} is interpreted exactly the same as @file{/}.
Note that @code{expand-file-name} does @emph{not} expand environment
@var{filename} with the environment variable values. Following
standard Unix shell syntax, @samp{$} is the prefix to substitute an
environment variable value. If the input contains @samp{$$}, that is
-converted to @samp{$}; this gives the user a way to ``quote'' a
+converted to @samp{$}; this gives the user a way to quote a
@samp{$}.
The environment variable name is the series of alphanumeric characters
@defun directory-files-recursively directory match &optional include-directories
Return all files under @var{directory} whose file names match
-@var{match} recursively. The file names are returned ``depth first'',
+@var{match} recursively. The file names are returned depth first,
meaning that contents of sub-directories are returned before contents
of the directories. If @var{include-directories} is non-@code{nil},
also return directory names that have matching names.
@end deffn
@node Magic File Names
-@section Making Certain File Names ``Magic''
+@section Making Certain File Names Magic
@cindex magic file names
You can implement special handling for certain file names. This is
possibly others to be added in the future. It need not implement all
these operations itself---when it has nothing special to do for a
certain operation, it can reinvoke the primitive, to handle the
-operation ``in the usual way''. It should always reinvoke the primitive
+operation in the usual way. It should always reinvoke the primitive
for an operation it does not recognize. Here's one way to do this:
@smallexample
Handlers that don't really do anything special for actual access to the
file---such as the ones that implement completion of host names for
remote file names---should have a non-@code{nil} @code{safe-magic}
-property. For instance, Emacs normally ``protects'' directory names
+property. For instance, Emacs normally protects directory names
it finds in @code{PATH} from becoming magic, if they look like magic
file names, by prefixing them with @samp{/:}. But if the handler that
would be used for them has a non-@code{nil} @code{safe-magic}
emacs, The GNU Emacs Manual}). Emacs can connect to other X displays
via the command @code{make-frame-on-display}. Each X display has its
own selected frame and its own minibuffer windows; however, only one
-of those frames is ``@emph{the} selected frame'' at any given moment
+of those frames is @emph{the} selected frame at any given moment
(@pxref{Input Focus}). Emacs can even connect to other text
terminals, by interacting with the @command{emacsclient} program.
@xref{Emacs Server,,, emacs, The GNU Emacs Manual}.
the other frame parameters from the alist @var{parameters}.
@var{display} should be the name of an X display (a string).
-Before creating the frame, this function ensures that Emacs is ``set
-up'' to display graphics. For instance, if Emacs has not processed X
+Before creating the frame, this function ensures that Emacs is set
+up to display graphics. For instance, if Emacs has not processed X
resources (e.g., if it was started on a text terminal), it does so at
this time. In all other respects, this function behaves like
@code{make-frame} (@pxref{Creating Frames}).
@end defun
@cindex multi-monitor
- On some ``multi-monitor'' setups, a single X display outputs to more
+ On some multi-monitor setups, a single X display outputs to more
than one physical monitor. You can use the functions
@code{display-monitor-attributes-list} and @code{frame-monitor-attributes}
to obtain information about such setups.
coordinates might be negative.
@item workarea
-Position of the top-left corner and size of the work area (``usable''
+Position of the top-left corner and size of the work area (usable
space) in pixels as @samp{(@var{x} @var{y} @var{width} @var{height})}.
This may be different from @samp{geometry} in that space occupied by
various window manager features (docks, taskbars, etc.)@: may be
specify the size of that rectangle.
@cindex outer position
-The upper left corner of the outer frame (indicated by ``(0)'' in the
+The upper left corner of the outer frame (indicated by @samp{(0)} in the
drawing above) is the @dfn{outer position} or the frame. It is
specified by and settable via the @code{left} and @code{top} frame
parameters (@pxref{Position Parameters}) as well as the functions
@cindex external border
The @dfn{external border} is part of the decorations supplied by the
window manager. It's typically used for resizing the frame with the
-mouse. The external border is normally not shown on ``fullboth'' and
+mouse. The external border is normally not shown on fullboth and
maximized frames (@pxref{Size Parameters}) and doesn't exist for text
terminal frames.
The @dfn{title bar} is also part of the window manager's decorations and
typically displays the title of the frame (@pxref{Frame Titles}) as well
as buttons for minimizing, maximizing and deleting the frame. The title
-bar is usually not displayed on ``fullboth'' (@pxref{Size Parameters})
+bar is usually not displayed on fullboth (@pxref{Size Parameters})
or tooltip frames. Title bars don't exist for text terminal frames.
@item Menu Bar
@var{frame}, @code{native-edges} (or @code{nil}) means to return its
native edges and @code{inner-edges} means to return its inner edges.
-Notice that the ``pixels at the positions'' @var{bottom} and @var{right}
+Notice that the pixels at the positions @var{bottom} and @var{right}
lie immediately outside the corresponding frame. This means that if you
have, for example, two side-by-side frames positioned such that the
right outer edge of the frame on the left equals the left outer edge of
-the frame on the right, the pixels ``representing'' that edge are part
+the frame on the right, the pixels representing that edge are part
of the frame on the right.
@end defun
@cindex default height of character
Each frame has a @dfn{default font} which specifies the default
character size for that frame. This size is meant when retrieving or
-changing the size of a frame in terms of ``columns'' or ``lines''
+changing the size of a frame in terms of columns or lines
(@pxref{Size Parameters}). It is also used when resizing (@pxref{Window
Sizes}) or splitting (@pxref{Splitting Windows}) windows.
(GTK+), or be accepted (Lucid, Motif, MS-Windows).
With some window managers you may have to set this to non-@code{nil} in
-order to make a frame appear truly ``maximized'' or ``fullscreen''.
+order to make a frame appear truly maximized or fullscreen.
@end defopt
@defun set-frame-size frame width height pixelwise
Using a smaller height than the terminal actually implements may be
useful to reproduce behavior observed on a smaller screen, or if the
terminal malfunctions when using its whole screen. Setting the frame
-height ``for real'' does not always work, because knowing the correct
+height directly does not always work, because knowing the correct
actual size may be necessary for correct cursor positioning on
text terminals.
The difference between @code{maximized} and @code{fullboth} is that a
maximized frame usually keeps its title bar and the buttons for resizing
and closing the frame. Also, maximized frames typically avoid hiding
-any task bar or panels displayed on the desktop. ``Fullboth'' frames,
-on the other hand, usually omit the title bar and occupy the entire
+any task bar or panels displayed on the desktop. A fullboth frame,
+on the other hand, usually omits the title bar and occupies the entire
available screen space.
-``Fullheight'' and ``fullwidth'' frames are more similar to maximized
+Fullheight and fullwidth frames are more similar to maximized
frames in this regard. However, these typically display an external
border which might be absent with maximized frames. Hence the heights
of maximized and fullheight frames and the widths of maximized and
With some window managers you may have to customize the variable
@code{frame-resize-pixelwise} (@pxref{Size and Position}) in order to
-make a frame truly appear ``maximized'' or ``fullscreen''. Moreover,
+make a frame truly appear maximized or fullscreen. Moreover,
some window managers might not support smooth transition between the
various fullscreen or maximization states. Customizing the variable
@code{x-frame-normalize-before-maximize} can help to overcome that.
@vindex fullscreen-restore, a frame parameter
@item fullscreen-restore
-This parameter specifies the desired ``fullscreen'' state of the frame
+This parameter specifies the desired fullscreen state of the frame
after invoking the @code{toggle-frame-fullscreen} command (@pxref{Frame
-Commands,,, emacs, The GNU Emacs Manual}) in the ``fullboth'' state.
+Commands,,, emacs, The GNU Emacs Manual}) in the fullboth state.
Normally this parameter is installed automatically by that command when
toggling the state to fullboth. If, however, you start Emacs in the
fullboth state, you have to specify the desired behavior in your initial
form @code{(@var{on-state} . @var{off-state})}. Whenever the cursor
type equals @var{on-state} (comparing using @code{equal}), the
corresponding @var{off-state} specifies what the cursor looks like
-when it blinks ``off''. Both @var{on-state} and @var{off-state}
+when it blinks off. Both @var{on-state} and @var{off-state}
should be suitable values for the @code{cursor-type} frame parameter.
There are various defaults for how to blink each type of cursor, if
@vindex screen-gamma, a frame parameter
@item screen-gamma
@cindex gamma correction
-If this is a number, Emacs performs ``gamma correction'' which adjusts
+If this is a number, Emacs performs gamma correction which adjusts
the brightness of all colors. The value should be the screen gamma of
your display.
@defun visible-frame-list
This function returns a list of just the currently visible frames.
@xref{Visibility of Frames}. Frames on text terminals always count as
-``visible'', even though only the selected one is actually displayed.
+visible, even though only the selected one is actually displayed.
@end defun
@defun next-frame &optional frame minibuf
This function lets you cycle conveniently through all the frames on
the current display from an arbitrary starting point. It returns the
-``next'' frame after @var{frame} in the cycle. If @var{frame} is
+next frame after @var{frame} in the cycle. If @var{frame} is
omitted or @code{nil}, it defaults to the selected frame (@pxref{Input
Focus}).
When Emacs displays its frames on several terminals (@pxref{Multiple
Terminals}), each terminal has its own selected frame. But only one
-of these is ``@emph{the} selected frame'': it's the frame that belongs
+of these is @emph{the} selected frame: it's the frame that belongs
to the terminal from which the most recent input came. That is, when
Emacs runs a command that came from a certain terminal, the selected
frame is the one of that terminal. Since Emacs runs only a single
explicitly switch to a different frame from a Lisp function, call
@code{select-frame-set-input-focus}.
-Lisp programs can also switch frames ``temporarily'' by calling the
+Lisp programs can also switch frames temporarily by calling the
function @code{select-frame}. This does not alter the window system's
concept of focus; rather, it escapes from the window manager's control
until that control is somehow reasserted.
value is @code{t} if @var{frame} is visible, @code{nil} if it is
invisible, and @code{icon} if it is iconified.
-On a text terminal, all frames are considered ``visible'' for the
+On a text terminal, all frames are considered visible for the
purposes of this function, even though only one frame is displayed.
@xref{Raising and Lowering}.
@end defun
@defvar x-resource-class
This variable specifies the application name that @code{x-get-resource}
should look up. The default value is @code{"Emacs"}. You can examine X
-resources for application names other than ``Emacs'' by binding this
+resources for other application names by binding this
variable to some other string, around a call to @code{x-get-resource}.
@end defvar
different in appearance than the default face, and
@item
-``close in spirit'' to what the attributes specify, if not exact.
+close in spirit to what the attributes specify, if not exact.
@end enumerate
Point (2) implies that a @code{:weight black} attribute will be
satisfied by any display that can display bold, as will
@code{:foreground "yellow"} as long as some yellowish color can be
displayed, but @code{:slant italic} will @emph{not} be satisfied by
-the tty display code's automatic substitution of a ``dim'' face for
+the tty display code's automatic substitution of a dim face for
italic.
@end defun
This function returns the height of the screen in pixels.
On a character terminal, it gives the height in characters.
-For graphical terminals, note that on ``multi-monitor'' setups this
+For graphical terminals, note that on multi-monitor setups this
refers to the pixel height for all physical monitors associated with
@var{display}. @xref{Multiple Terminals}.
@end defun
This function returns the width of the screen in pixels.
On a character terminal, it gives the width in characters.
-For graphical terminals, note that on ``multi-monitor'' setups this
+For graphical terminals, note that on multi-monitor setups this
refers to the pixel width for all physical monitors associated with
@var{display}. @xref{Multiple Terminals}.
@end defun
This function returns the height of the screen in millimeters,
or @code{nil} if Emacs cannot get that information.
-For graphical terminals, note that on ``multi-monitor'' setups this
+For graphical terminals, note that on multi-monitor setups this
refers to the height for all physical monitors associated with
@var{display}. @xref{Multiple Terminals}.
@end defun
This function returns the width of the screen in millimeters,
or @code{nil} if Emacs cannot get that information.
-For graphical terminals, note that on ``multi-monitor'' setups this
+For graphical terminals, note that on multi-monitor setups this
refers to the width for all physical monitors associated with
@var{display}. @xref{Multiple Terminals}.
@end defun
@end defun
@defun x-server-vendor &optional display
-This function returns the ``vendor'' that provided the window system
+This function returns the vendor that provided the window system
software (as a string). On GNU and Unix systems this really means
whoever distributes the X server. On MS-Windows this is the vendor ID
string of the Windows OS (Microsoft).
@item closure
A function object that is much like a lambda expression, except that
-it also encloses an ``environment'' of lexical variable bindings.
+it also encloses an environment of lexical variable bindings.
@xref{Closures}.
@item byte-code function
@quotation
@b{Common Lisp note:} Common Lisp allows the function to specify what
default value to use when an optional argument is omitted; Emacs Lisp
-always uses @code{nil}. Emacs Lisp does not support ``supplied-p''
+always uses @code{nil}. Emacs Lisp does not support @code{supplied-p}
variables that tell you whether an argument was explicitly passed.
@end quotation
The argument @var{function} must be either a Lisp function or a
primitive function. Special forms and macros are not allowed, because
-they make sense only when given the ``unevaluated'' argument
+they make sense only when given the unevaluated argument
expressions. @code{funcall} cannot provide these because, as we saw
above, it never knows them in the first place.
@var{args}, documentation string @var{doc} (if any), interactive spec
@var{interactive} (if any), and body forms given by @var{body}.
-In effect, this macro makes @code{lambda} forms ``self-quoting'':
+In effect, this macro makes @code{lambda} forms self-quoting:
evaluating a form whose @sc{car} is @code{lambda} yields the form
itself:
@noindent
However, the fact that the internal structure of a closure is
-``exposed'' to the rest of the Lisp world is considered an internal
+exposed to the rest of the Lisp world is considered an internal
implementation detail. For this reason, we recommend against directly
examining or altering the structure of closure objects.
@section The @code{declare} Form
@findex declare
- @code{declare} is a special macro which can be used to add ``meta''
+ @code{declare} is a special macro which can be used to add meta
properties to a function or macro: for example, marking it as
obsolete, or giving its forms a special @key{TAB} indentation
convention in Emacs Lisp mode.
@example
In end of data:
-fortran.el:2152:1:Warning: the function `gud-find-c-expr' is not
+fortran.el:2152:1:Warning: the function ‘gud-find-c-expr’ is not
known to be defined.
@end example
Being quick and simple, @code{unsafep} does a very light analysis and
rejects many Lisp expressions that are actually safe. There are no
known cases where @code{unsafep} returns @code{nil} for an unsafe
-expression. However, a ``safe'' Lisp expression can return a string
+expression. However, a safe Lisp expression can return a string
with a @code{display} property, containing an associated Lisp
expression to be executed after the string is inserted into a buffer.
This associated expression can be a virus. In order to be safe, you
with a series of functions for operating on them. Hash tables have a
special printed representation, which consists of @samp{#s} followed
by a list specifying the hash table properties and contents.
-@xref{Creating Hash}. (Note that the term ``hash notation'', which
-refers to the initial @samp{#} character used in the printed
+@xref{Creating Hash}.
+(Hash notation, the initial @samp{#} character used in the printed
representations of objects with no read representation, has nothing to
-do with the term ``hash table''. @xref{Printed Representation}.)
+do with hash tables. @xref{Printed Representation}.)
Obarrays are also a kind of hash table, but they are a different type
of object and are used only for recording interned symbols
@table @code
@item eql
-Keys which are numbers are ``the same'' if they are @code{equal}, that
+Keys which are numbers are the same if they are @code{equal}, that
is, if they are equal in value and either both are integers or both
are floating point; otherwise, two distinct objects are never
-``the same''.
+the same.
@item eq
-Any two distinct Lisp objects are ``different'' as keys.
+Any two distinct Lisp objects are different as keys.
@item equal
-Two Lisp objects are ``the same'', as keys, if they are equal
+Two Lisp objects are the same, as keys, if they are equal
according to @code{equal}.
@end table
The default size is 65.
@item :rehash-size @var{rehash-size}
-When you add an association to a hash table and the table is ``full'',
+When you add an association to a hash table and the table is full,
it grows automatically. This value specifies how to make the hash table
larger, at that time.
The default value is 1.5.
@item :rehash-threshold @var{threshold}
-This specifies the criterion for when the hash table is ``full'' (so
+This specifies the criterion for when the hash table is full (so
it should be made larger). The value, @var{threshold}, should be a
positive floating-point number, no greater than 1. The hash table is
-``full'' whenever the actual number of entries exceeds this fraction
+full whenever the actual number of entries exceeds this fraction
of the nominal size. The default for @var{threshold} is 0.8.
@end table
@end defun
After defining @var{name} in this way, you can use it as the @var{test}
argument in @code{make-hash-table}. When you do that, the hash table
will use @var{test-fn} to compare key values, and @var{hash-fn} to compute
-a ``hash code'' from a key value.
+a hash code from a key value.
The function @var{test-fn} should accept two arguments, two keys, and
-return non-@code{nil} if they are considered ``the same''.
+return non-@code{nil} if they are considered the same.
The function @var{hash-fn} should accept one argument, a key, and return
-an integer that is the ``hash code'' of that key. For good results, the
+an integer that is the hash code of that key. For good results, the
function should use the whole range of integers for hash codes,
including negative integers.
@c Do not blithely break or fill these lines.
@c That makes them incorrect.
+@group
+minibuffer-temporary-goal-position Variable
+not documented
+@end group
+
@group
set-goal-column Keys: C-x C-n
Set the current horizontal position as a goal for C-n and C-p.
@group
Those commands will move to this position in the line moved to
rather than trying to keep the same horizontal position.
-With a non-nil argument, clears out the goal column
+With a non-nil argument ARG, clears out the goal column
so that C-n and C-p resume vertical motion.
-The goal column is stored in the variable `goal-column'.
+The goal column is stored in the variable ‘goal-column’.
+
+(fn ARG)
@end group
@group
temporary-goal-column Variable
Current goal column for vertical motion.
-It is the column where point was
-at the start of current run of vertical motion commands.
-When the `track-eol' feature is doing its job, the value is 9999.
+It is the column where point was at the start of the current run
+of vertical motion commands.
+
+When moving by visual lines via the function ‘line-move-visual’, it is a cons
+cell (COL . HSCROLL), where COL is the x-position, in pixels,
+divided by the default column width, and HSCROLL is the number of
+columns by which window is scrolled from left margin.
+
+When the ‘track-eol’ feature is doing its job, the value is
+‘most-positive-fixnum’.
---------- Buffer: *Help* ----------
@end group
@end smallexample
we describe some program-level interfaces to the same information.
@deffn Command apropos pattern &optional do-all
-This function finds all ``meaningful'' symbols whose names contain a
+This function finds all meaningful symbols whose names contain a
match for the apropos pattern @var{pattern}. An apropos pattern is
either a word to match, a space-separated list of words of which at
least two must match, or a regular expression (if any special regular
-expression characters occur). A symbol is ``meaningful'' if it has a
+expression characters occur). A symbol is meaningful if it has a
definition as a function, variable, or face, or has properties.
The function returns a list of elements that look like this:
@defopt help-event-list
The value of this variable is a list of event types that serve as
-alternative ``help characters''. These events are handled just like the
+alternative help characters. These events are handled just like the
event specified by @code{help-char}.
@end defopt
@end deffn
The following two functions are meant for modes that want to provide
-help without relinquishing control, such as the ``electric'' modes.
+help without relinquishing control, such as the electric modes.
Their names begin with @samp{Helper} to distinguish them from the
ordinary help functions.
@item buffer-quit-function
@vindex buffer-quit-function
-Function to call to ``quit'' the current buffer.
+Function to call to quit the current buffer.
@item change-major-mode-hook
@xref{Creating Buffer-Local}.
matter what the Lisp program or the user does, it is impossible to refer
to them, since there is no longer a way to reach them. Their space
might as well be reused, since no one will miss them. The second
-(``sweep'') phase of the garbage collector arranges to reuse them.
+(sweep) phase of the garbage collector arranges to reuse them.
@c ??? Maybe add something describing weak hash tables here?
in this window.
@item last_had_star
-A non-@code{nil} value means the window's buffer was ``modified'' when the
+A non-@code{nil} value means the window's buffer was modified when the
window was last updated.
@item vertical_scroll_bar
Do not assume that signed integer arithmetic wraps around on overflow.
This is no longer true of Emacs porting targets: signed integer
overflow has undefined behavior in practice, and can dump core or
-even cause earlier or later code to behave ``illogically''. Unsigned
+even cause earlier or later code to behave illogically. Unsigned
overflow does wrap around reliably, modulo a power of two.
@item
Most of the GNU Emacs text editor is written in the programming
language called Emacs Lisp. You can write new code in Emacs Lisp and
install it as an extension to the editor. However, Emacs Lisp is more
-than a mere ``extension language''; it is a full computer programming
+than a mere extension language; it is a full computer programming
language in its own right. You can use it as you would any other
programming language.
printer'' refer to those routines in Lisp that convert textual
representations of Lisp objects into actual Lisp objects, and vice
versa. @xref{Printed Representation}, for more details. You, the
-person reading this manual, are thought of as ``the programmer'' and are
-addressed as ``you''. ``The user'' is the person who uses Lisp
+person reading this manual, are thought of as the programmer and are
+addressed as ``you''. The user is the person who uses Lisp
programs, including those you write.
@cindex typographic conventions
@cindex buffer text notation
Some examples describe modifications to the contents of a buffer, by
-showing the ``before'' and ``after'' versions of the text. These
+showing the before and after versions of the text. These
examples show the contents of the buffer in question between two lines
of dashes containing the buffer name. In addition, @samp{@point{}}
indicates the location of point. (The symbol for point, of course, is
order. Emacs searches for each input key sequence in all these
keymaps.
- Of these ``usual'' keymaps, the highest-precedence one is specified
+ Of these usual keymaps, the highest-precedence one is specified
by the @code{keymap} text or overlay property at point, if any. (For
a mouse input event, Emacs uses the event position instead of point;
@iftex
defined regardless of the current buffer, such as @kbd{C-f}. It is
always active, and is bound to the variable @code{global-map}.
- Apart from the above ``usual'' keymaps, Emacs provides special ways
+ Apart from the above usual keymaps, Emacs provides special ways
for programs to make other keymaps active. Firstly, the variable
@code{overriding-local-map} specifies a keymap that replaces the usual
active keymaps, except for the global keymap. Secondly, the
menu bar display. So if a menu bar key sequence comes in, you should
clear the variables before looking up and executing that key sequence.
Modes that use the variables would typically do this anyway; normally
-they respond to events that they do not handle by ``unreading'' them and
+they respond to events that they do not handle by unreading them and
exiting.
@end defvar
modes. It is intended for modes or packages using multiple minor-mode
keymaps. Each element is a keymap alist which has the same format and
meaning as @code{minor-mode-map-alist}, or a symbol with a variable
-binding which is such an alist. The ``active'' keymaps in each alist
+binding which is such an alist. The active keymaps in each alist
are used before @code{minor-mode-map-alist} and
@code{minor-mode-overriding-map-alist}.
@end defvar
the rest of the event is ignored. In fact, a key sequence used for key
lookup may designate a mouse event with just its types (a symbol)
instead of the entire event (a list). @xref{Input Events}. Such
-a ``key sequence'' is insufficient for @code{command-execute} to run,
+a key sequence is insufficient for @code{command-execute} to run,
but it is sufficient for looking up or rebinding a key.
When the key sequence consists of multiple events, key lookup
@cindex preventing prefix key
@code{undefined} is used in local keymaps to override a global key
-binding and make the key ``undefined'' locally. A local binding of
+binding and make the key undefined locally. A local binding of
@code{nil} would fail to do this because it would not override the
global binding.
@end example
If the string or vector @var{key} is not a valid key sequence according
-to the prefix keys specified in @var{keymap}, it must be ``too long''
+to the prefix keys specified in @var{keymap}, it must be too long
and have extra events at the end that do not fit into a single key
sequence. Then the value is a number, the number of events at the front
of @var{key} that compose a complete key.
are used differently: they specify translations to make while reading
key sequences, rather than bindings for complete key sequences. As
each key sequence is read, it is checked against each translation
-keymap. If one of the translation keymaps ``binds'' @var{k} to a
+keymap. If one of the translation keymaps binds @var{k} to a
vector @var{v}, then whenever @var{k} appears as a sub-sequence
@emph{anywhere} in a key sequence, that sub-sequence is replaced with
the events in @var{v}.
For example, VT100 terminals send @kbd{@key{ESC} O P} when the
keypad key @key{PF1} is pressed. On such terminals, Emacs must
translate that sequence of events into a single event @code{pf1}.
-This is done by ``binding'' @kbd{@key{ESC} O P} to @code{[pf1]} in
+This is done by binding @kbd{@key{ESC} O P} to @code{[pf1]} in
@code{input-decode-map}. Thus, when you type @kbd{C-c @key{PF1}} on
the terminal, the terminal emits the character sequence @kbd{C-c
@key{ESC} O P}, and @code{read-key-sequence} translates this back into
@cindex key translation function
You can use @code{input-decode-map}, @code{local-function-key-map},
and @code{key-translation-map} for more than simple aliases, by using
-a function, instead of a key sequence, as the ``translation'' of a
+a function, instead of a key sequence, as the translation of a
key. Then this function is called to compute the translation of that
key.
@end example
@noindent
-@var{help} specifies a ``help-echo'' string to display while the mouse
+@var{help} specifies a help-echo string to display while the mouse
is on that item in the same way as @code{help-echo} text properties
(@pxref{Help display}).
controls whether the menu item is enabled. Every time the keymap is
used to display a menu, Emacs evaluates the expression, and it enables
the menu item only if the expression's value is non-@code{nil}. When a
-menu item is disabled, it is displayed in a ``fuzzy'' fashion, and
+menu item is disabled, it is displayed in a fuzzy fashion, and
cannot be selected.
The menu bar does not recalculate which items are enabled every time you
not defined at all.
@item :help @var{help}
-The value of this property, @var{help}, specifies a ``help-echo'' string
+The value of this property, @var{help}, specifies a help-echo string
to display while the mouse is on that item. This is displayed in the
same way as @code{help-echo} text properties (@pxref{Help display}).
Note that this must be a constant string, unlike the @code{help-echo}
@code{:radio}. The @sc{cdr}, @var{selected}, should be a form; the
result of evaluating it says whether this button is currently selected.
-A @dfn{toggle} is a menu item which is labeled as either ``on'' or ``off''
+A @dfn{toggle} is a menu item which is labeled as either on or off
according to the value of @var{selected}. The command itself should
toggle @var{selected}, setting it to @code{t} if it is @code{nil},
and to @code{nil} if it is @code{t}. Here is how the menu item
which toggles the variable @code{debug-on-error}.
@dfn{Radio buttons} are a group of menu items, in which at any time one
-and only one is ``selected''. There should be a variable whose value
+and only one is selected. There should be a variable whose value
says which one is selected at any time. The @var{selected} form for
each radio button in the group should check whether the variable has the
right value for selecting that button. Clicking on the button should
@node Alias Menu Items
@subsubsection Alias Menu Items
- Sometimes it is useful to make menu items that use the ``same''
+ Sometimes it is useful to make menu items that use the same
command but with different enable conditions. The best way to do this
in Emacs now is with extended menu items; before that feature existed,
it could be done by defining alias commands and using them in menu
@end example
When using aliases in menus, often it is useful to display the
-equivalent key bindings for the ``real'' command name, not the aliases
+equivalent key bindings for the real command name, not the aliases
(which typically don't have any key bindings except for the menu
itself). To request this, give the alias symbol a non-@code{nil}
@code{menu-alias} property. Thus,
@end smallexample
@noindent
-Note the symbols which the bindings are ``made for''; these appear
+Note the symbols which the bindings are made for; these appear
inside square brackets, in the key sequence being defined. In some
cases, this symbol is the same as the command name; sometimes it is
-different. These symbols are treated as ``function keys'', but they are
+different. These symbols are treated as function keys, but they are
not real function keys on the keyboard. They do not affect the
-functioning of the menu itself, but they are ``echoed'' in the echo area
+functioning of the menu itself, but they are echoed in the echo area
when the user selects from the menu, and they appear in the output of
@code{where-is} and @code{apropos}.
The menu in this example is intended for use with the mouse. If a
menu is intended for use with the keyboard, that is, if it is bound to
a key sequence ending with a keyboard event, then the menu items
-should be bound to characters or ``real'' function keys, that can be
+should be bound to characters or real function keys, that can be
typed with the keyboard.
The binding whose definition is @code{("--")} is a separator line.
Emacs usually shows a @dfn{menu bar} at the top of each frame.
@xref{Menu Bars,,,emacs, The GNU Emacs Manual}. Menu bar items are
-subcommands of the fake ``function key'' @code{menu-bar}, as defined
+subcommands of the fake function key @code{menu-bar}, as defined
in the active keymaps.
- To add an item to the menu bar, invent a fake ``function key'' of your
+ To add an item to the menu bar, invent a fake function key of your
own (let's call it @var{key}), and make a binding for the key sequence
@code{[menu-bar @var{key}]}. Most often, the binding is a menu keymap,
so that pressing a button on the menu bar item leads to another menu.
- When more than one active keymap defines the same ``function key''
+ When more than one active keymap defines the same function key
for the menu bar, the item appears just once. If the user clicks on
that menu bar item, it brings up a single, combined menu containing
all the subcommands of that item---the global subcommands, the local
but does not contract automatically.
The tool bar contents are controlled by a menu keymap attached to a
-fake ``function key'' called @code{tool-bar} (much like the way the menu
+fake function key called @code{tool-bar} (much like the way the menu
bar is controlled). So you define a tool bar item using
@code{define-key}, like this:
@end example
@noindent
-where @var{key} is a fake ``function key'' to distinguish this item from
+where @var{key} is a fake function key to distinguish this item from
other items, and @var{item} is a menu item key binding (@pxref{Extended
Menu Items}), which says how to display this item and how it behaves.
in the item must be a command, not a keymap; in other words, it does not
work to define a tool bar icon as a prefix key.
- The @code{:help} property specifies a ``help-echo'' string to display
+ The @code{:help} property specifies a help-echo string to display
while the mouse is on that item. This is displayed in the same way as
@code{help-echo} text properties (@pxref{Help display}).
We have bound this manual using a new @dfn{lay-flat} binding
technology. This type of binding allows you to open a soft cover book
-so that it ``lays flat'' on a table without creasing the binding.
+so that it lays flat on a table without creasing the binding.
-In order to make the book lay flat properly, you need to ``crack'' the
+In order to make the book lay flat properly, you need to crack the
binding. To do this, divide the book into two sections and bend it so
that the front and back covers meet. Do not worry; the pages are
sewn and glued to the binding, and will not fall out easily.
We say that ``the @sc{car} of this cons cell is'' whatever object
its @sc{car} slot currently holds, and likewise for the @sc{cdr}.
- A list is a series of cons cells ``chained together'', so that each
+ A list is a series of cons cells chained together, so that each
cell refers to the next one. There is one cons cell for each element
of the list. By convention, the @sc{car}s of the cons cells hold the
elements of the list, and the @sc{cdr}s are used to chain the list
@cindex destructive list operations
You can modify the @sc{car} and @sc{cdr} contents of a cons cell with the
-primitives @code{setcar} and @code{setcdr}. We call these ``destructive''
+primitives @code{setcar} and @code{setcdr}. These are destructive
operations because they change existing list structure.
@cindex CL note---@code{rplaca} vs @code{setcar}
@cindex reordering, of elements in lists
@cindex modification of lists
- Here are some functions that rearrange lists ``destructively'' by
-modifying the @sc{cdr}s of their component cons cells. We call these
-functions ``destructive'' because they chew up the original lists passed
+ Here are some functions that rearrange lists destructively by
+modifying the @sc{cdr}s of their component cons cells. These functions
+are destructive because they chew up the original lists passed
to them as arguments, relinking their cons cells to form a new list that
is the returned value.
@code{rassoc} is like @code{assoc} except that it compares the @sc{cdr} of
each @var{alist} association instead of the @sc{car}. You can think of
-this as ``reverse @code{assoc}'', finding the key for a given value.
+this as reverse @code{assoc}, finding the key for a given value.
@end defun
@defun assq key alist
@code{rassq} is like @code{assq} except that it compares the @sc{cdr} of
each @var{alist} association instead of the @sc{car}. You can think of
-this as ``reverse @code{assq}'', finding the key for a given value.
+this as reverse @code{assq}, finding the key for a given value.
For example:
* Repeated Loading:: Precautions about loading a file twice.
* Named Features:: Loading a library if it isn't already loaded.
* Where Defined:: Finding which file defined a certain symbol.
-* Unloading:: How to ``unload'' a library that was loaded.
+* Unloading:: How to unload a library that was loaded.
* Hooks for Loading:: Providing code to be run when
particular libraries are loaded.
@end menu
the function or macro (@pxref{Documentation Basics}).
There are two ways to set up an autoloaded function: by calling
-@code{autoload}, and by writing a special ``magic'' comment in the
+@code{autoload}, and by writing a magic comment in the
source before the real definition. @code{autoload} is the low-level
primitive for autoloading; any Lisp program can call @code{autoload} at
any time. Magic comments are the most convenient way to make a function
@defvar generated-autoload-file
The value of this variable names an Emacs Lisp file where the autoload
calls should go. The default value is @file{loaddefs.el}, but you can
-override that, e.g., in the ``Local Variables'' section of a
+override that, e.g., in the local variables section of a
@file{.el} file (@pxref{File Local Variables}). The autoload file is
assumed to contain a trailer starting with a formfeed character.
@end defvar
When defining a macro you must pay attention to the number of times
the arguments will be evaluated when the expansion is executed. The
following macro (used to facilitate iteration) illustrates the
-problem. This macro allows us to write a ``for'' loop construct.
+problem. This macro allows us to write a for-loop construct.
@findex for
@example
@noindent
The arguments @code{from}, @code{to}, and @code{do} in this macro are
-``syntactic sugar''; they are entirely ignored. The idea is that you
+syntactic sugar; they are entirely ignored. The idea is that you
will write noise words (such as @code{from}, @code{to}, and @code{do})
in those positions in the macro call.
constructed each time @code{initialize} is called. Thus, no side effect
survives between calls. If @code{initialize} is compiled, then the
macro @code{empty-object} is expanded during compilation, producing a
-single ``constant'' @code{(nil)} that is reused and altered each time
+single constant @code{(nil)} that is reused and altered each time
@code{initialize} is called.
One way to avoid pathological cases like this is to think of
* Marker Insertion Types:: Two ways a marker can relocate when you
insert where it points.
* Moving Markers:: Moving the marker to a new buffer or position.
-* The Mark:: How ``the mark'' is implemented with a marker.
-* The Region:: How to access ``the region''.
+* The Mark:: How the mark is implemented with a marker.
+* The Region:: How to access the region.
@end menu
@node Overview of Markers
Each buffer has a special marker, which is designated @dfn{the
mark}. When a buffer is newly created, this marker exists but does
-not point anywhere; this means that the mark ``doesn't exist'' in that
+not point anywhere; this means that the mark doesn't exist in that
buffer yet. Subsequent commands can set the mark.
The mark specifies a position to bound a range of text for many
because this enables the user to move back there conveniently after
the replace is finished.
- Once the mark ``exists'' in a buffer, it normally never ceases to
+ Once the mark exists in a buffer, it normally never ceases to
exist. However, it may become @dfn{inactive}, if Transient Mark mode
is enabled. The buffer-local variable @code{mark-active}, if
non-@code{nil}, means that the mark is active. A command can call the
@end defvar
@defun handle-shift-selection
-This function implements the ``shift-selection'' behavior of
+This function implements the shift-selection behavior of
point-motion commands. @xref{Shift Selection,,, emacs, The GNU Emacs
Manual}. It is called automatically by the Emacs command loop
whenever a command with a @samp{^} character in its @code{interactive}
@node The Region
@section The Region
-@c The index entry must be just ``region'' to make it the first hit
-@c when the user types ``i region RET'', because otherwise the Info
+@c The index entry must be just "region" to make it the first hit
+@c when the user types "i region RET", because otherwise the Info
@c reader will present substring matches in alphabetical order,
@c putting this one near the end, with something utterly unrelated as
@c the first hit.
incrementing the number at the end of the name. (The names begin with
a space so that they won't show up in normal buffer lists.) Of
several recursive minibuffers, the innermost (or most recently
-entered) is the active minibuffer. We usually call this ``the''
+entered) is the active minibuffer. We usually call this @emph{the}
minibuffer. You can permit or forbid recursive minibuffers by setting
the variable @code{enable-recursive-minibuffers}, or by putting
properties of that name on command symbols (@xref{Recursive Mini}.)
The argument @var{default} specifies default values to make available
through the history commands. It should be a string, a list of
strings, or @code{nil}. The string or strings become the minibuffer's
-``future history'', available to the user with @kbd{M-n}.
+future history, available to the user with @kbd{M-n}.
If @var{read} is non-@code{nil}, then @var{default} is also used
as the input to @code{read}, if the user enters empty input.
strings, or @code{nil}, which is equivalent to an empty string. When
@var{default} is a string, that string is the default value. When it
is a list of strings, the first string is the default value. (All
-these strings are available to the user in the ``future minibuffer
-history''.)
+these strings are available to the user in the future minibuffer
+history.)
This function works by calling the
@code{read-from-minibuffer} function:
The function now has a list of regular expressions that it passes to
@code{read-from-minibuffer} to obtain the user's input. The first
element of the list is the default result in case of empty input. All
-elements of the list are available to the user as the ``future
-minibuffer history list'' (@pxref{Minibuffer History, future list,,
+elements of the list are available to the user as the future
+minibuffer history list (@pxref{Minibuffer History, future list,,
emacs, The GNU Emacs Manual}).
The optional argument @var{history}, if non-@code{nil}, is a symbol
@end defun
If you store a completion alist in a variable, you should mark the
-variable as ``risky'' by giving it a non-@code{nil}
+variable as risky by giving it a non-@code{nil}
@code{risky-local-variable} property. @xref{File Local Variables}.
@defvar completion-ignore-case
This function asks the user a question, expecting input in the echo
area. It returns @code{t} if the user types @kbd{y}, @code{nil} if the
user types @kbd{n}. This function also accepts @key{SPC} to mean yes
-and @key{DEL} to mean no. It accepts @kbd{C-]} to mean ``quit'', like
+and @key{DEL} to mean no. It accepts @kbd{C-]} to quit, like
@kbd{C-g}, because the question might look like a minibuffer and for
that reason the user might try to use @kbd{C-]} to get out. The answer
is a single character, with no @key{RET} needed to terminate it. Upper
@cindex multiple yes-or-no questions
When you have a series of similar questions to ask, such as ``Do you
-want to save this buffer'' for each buffer in turn, you should use
+want to save this buffer?'' for each buffer in turn, you should use
@code{map-y-or-n-p} to ask the collection of questions, rather than
asking each question individually. This gives the user certain
convenient facilities such as the ability to answer the whole series at
When the user responds with @var{char}, @code{map-y-or-n-p} calls
@var{function}. If it returns non-@code{nil}, the object is considered
-``acted upon'', and @code{map-y-or-n-p} advances to the next object in
+acted upon, and @code{map-y-or-n-p} advances to the next object in
@var{list}. If it returns @code{nil}, the prompt is repeated for the
same object.
@defun run-hook-with-args-until-failure hook &rest args
This function runs an abnormal hook by calling each hook function in
-turn, stopping if one of them ``fails'' by returning @code{nil}. Each
+turn, stopping if one of them fails by returning @code{nil}. Each
hook function is passed the arguments @var{args}. If this function
stops because one of the hook functions fails, it returns @code{nil};
otherwise it returns a non-@code{nil} value.
@defun run-hook-with-args-until-success hook &rest args
This function runs an abnormal hook by calling each hook function,
-stopping if one of them ``succeeds'' by returning a non-@code{nil}
+stopping if one of them succeeds by returning a non-@code{nil}
value. Each hook function is passed the arguments @var{args}. If this
function stops because one of the hook functions returns a
non-@code{nil} value, it returns that value; otherwise it returns
@item
The major mode command should set the variable @code{mode-name} to the
-``pretty'' name of the mode, usually a string (but see @ref{Mode Line
+pretty name of the mode, usually a string (but see @ref{Mode Line
Data}, for other possible forms). The name of the mode appears
in the mode line.
A major mode can also rebind the keys @kbd{M-n}, @kbd{M-p} and
@kbd{M-s}. The bindings for @kbd{M-n} and @kbd{M-p} should normally
-be some kind of ``moving forward and backward'', but this does not
+be some kind of moving forward and backward, but this does not
necessarily mean cursor motion.
It is legitimate for a major mode to rebind a standard key sequence if
-it provides a command that does ``the same job'' in a way better
+it provides a command that does the same job in a way better
suited to the text this mode is used for. For example, a major mode
for editing a programming language might redefine @kbd{C-M-a} to
-``move to the beginning of a function'' in a way that works better for
+move to the beginning of a function in a way that works better for
that language.
It is also legitimate for a major mode to rebind a standard key
When you defined a major mode using @code{define-derived-mode}, it
automatically makes sure these conventions are followed. If you
-define a major mode ``by hand'', not using @code{define-derived-mode},
+define a major mode by hand, not using @code{define-derived-mode},
use the following functions to handle these conventions automatically.
@defun run-mode-hooks &rest hookvars
@itemize
@item
@var{id} is either @code{nil}, or a Lisp object that identifies the
-entry. If the latter, the cursor stays on the ``same'' entry when
+entry. If the latter, the cursor stays on the same entry when
re-sorting entries. Comparison is done with @code{equal}.
@item
The argument @var{comment-list} is a list in which each element is
either a character, a string of one or two characters, or a cons cell.
A character or a string is set up in the mode's syntax table as a
-``comment starter''. If the entry is a cons cell, the @sc{car} is set
-up as a ``comment starter'' and the @sc{cdr} as a ``comment ender''.
+comment starter. If the entry is a cons cell, the @sc{car} is set
+up as a comment starter and the @sc{cdr} as a comment ender.
(Use @code{nil} for the latter if you want comments to end at the end
of the line.) Note that the syntax table mechanism has limitations
about what comment starters and enders are actually possible.
There is one exception: if the value of @var{symbol} is a string, it is
displayed verbatim: the @code{%}-constructs are not recognized.
-Unless @var{symbol} is marked as ``risky'' (i.e., it has a
+Unless @var{symbol} is marked as risky (i.e., it has a
non-@code{nil} @code{risky-local-variable} property), all text
properties specified in @var{symbol}'s value are ignored. This includes
the text properties of strings in @var{symbol}'s value, as well as all
The following three variables are used in @code{mode-line-modes}:
@defvar mode-name
-This buffer-local variable holds the ``pretty'' name of the current
+This buffer-local variable holds the pretty name of the current
buffer's major mode. Each major mode should set this variable so that
the mode name will appear in the mode line. The value does not have
to be a string, but can use any of the data types valid in a mode-line
@defvar imenu-prev-index-position-function
If this variable is non-@code{nil}, its value should be a function that
-finds the next ``definition'' to put in the buffer index, scanning
+finds the next definition to put in the buffer index, scanning
backward in the buffer from point. It should return @code{nil} if it
-doesn't find another ``definition'' before point. Otherwise it should
-leave point at the place it finds a ``definition'' and return any
+doesn't find another definition before point. Otherwise it should
+leave point at the place it finds a definition and return any
non-@code{nil} value.
Setting this variable makes it buffer-local in the current buffer.
@code{font-lock-comment-face} is @code{font-lock-comment-face}.
The faces are listed with descriptions of their typical usage, and in
-order of greater to lesser ``prominence''. If a mode's syntactic
+order of greater to lesser prominence. If a mode's syntactic
categories do not fit well with the usage descriptions, the faces can be
assigned using the ordering as a guide.
@defvar font-lock-beginning-of-syntax-function
If this variable is non-@code{nil}, it should be a function to move
-point back to a position that is syntactically at ``top level'' and
+point back to a position that is syntactically at top level and
outside of strings or comments. The value is normally set through an
@var{other-vars} element in @code{font-lock-defaults}. If it is
@code{nil}, Font Lock uses @code{syntax-begin-function} to move back
incorrect code.
Good maintainable indentation functions usually fall into two categories:
-either parsing forward from some ``safe'' starting point until the
+either parsing forward from some safe starting point until the
position of interest, or parsing backward from the position of interest.
Neither of the two is a clearly better choice than the other: parsing
backward is often more difficult than parsing forward because
programming languages are designed to be parsed forward, but for the
purpose of indentation it has the advantage of not needing to
-guess a ``safe'' starting point, and it generally enjoys the property
+guess a safe starting point, and it generally enjoys the property
that only a minimum of text will be analyzed to decide the indentation
of a line, so indentation will tend to be less affected by syntax errors in
some earlier unrelated piece of code. Parsing forward on the other hand
@cindex SMIE
SMIE is a package that provides a generic navigation and indentation
-engine. Based on a very simple parser using an ``operator precedence
-grammar'', it lets major modes extend the sexp-based navigation of Lisp
+engine. Based on a very simple parser using an operator precedence
+grammar, it lets major modes extend the sexp-based navigation of Lisp
to non-Lisp languages as well as provide a simple to use but reliable
auto-indentation.
characters whose @code{Numeric_Type} is @samp{Decimal}. The value is
an integer, or @code{nil} if the character has no decimal digit value.
For unassigned codepoints, the value is @code{nil}, which means
-@acronym{NaN}, or ``not-a-number''.
+@acronym{NaN}, or not a number.
@item digit-value
Corresponds to the Unicode @code{Numeric_Value} property for
@section Locales
@cindex locale
- POSIX defines a concept of ``locales'' which control which language
+ In POSIX, locales control which language
to use in language-related features. These Emacs variables control
how Emacs interacts with these features.
@cindex NaN
The @acronym{IEEE} floating-point standard supports positive
infinity and negative infinity as floating-point values. It also
-provides for a class of values called NaN or ``not-a-number'';
+provides for a class of values called NaN or not a number;
numerical functions return such values in cases where there is no
correct answer. For example, @code{(/ 0.0 0.0)} returns a NaN@.
Although NaN values carry a sign, for practical purposes there is no other
sequence of @dfn{bits} (digits which are either zero or one). A bitwise
operation acts on the individual bits of such a sequence. For example,
@dfn{shifting} moves the whole sequence left or right one or more places,
-reproducing the same pattern ``moved over''.
+reproducing the same pattern moved over.
The bitwise operations in Emacs Lisp apply only to integers.
@end defun
@defun logand &rest ints-or-markers
-This function returns the ``logical and'' of the arguments: the
-@var{n}th bit is set in the result if, and only if, the @var{n}th bit is
-set in all the arguments. (``Set'' means that the value of the bit is 1
-rather than 0.)
+This function returns the bitwise AND of the arguments: the @var{n}th
+bit is 1 in the result if, and only if, the @var{n}th bit is 1 in all
+the arguments.
-For example, using 4-bit binary numbers, the ``logical and'' of 13 and
+For example, using 4-bit binary numbers, the bitwise AND of 13 and
12 is 12: 1101 combined with 1100 produces 1100.
-In both the binary numbers, the leftmost two bits are set (i.e., they
-are 1's), so the leftmost two bits of the returned value are set.
-However, for the rightmost two bits, each is zero in at least one of
-the arguments, so the rightmost two bits of the returned value are 0's.
+In both the binary numbers, the leftmost two bits are both 1
+so the leftmost two bits of the returned value are both 1.
+However, for the rightmost two bits, each is 0 in at least one of
+the arguments, so the rightmost two bits of the returned value are both 0.
@noindent
Therefore,
@end defun
@defun logior &rest ints-or-markers
-This function returns the ``inclusive or'' of its arguments: the @var{n}th bit
-is set in the result if, and only if, the @var{n}th bit is set in at least
-one of the arguments. If there are no arguments, the result is zero,
+This function returns the bitwise inclusive OR of its arguments: the @var{n}th
+bit is 1 in the result if, and only if, the @var{n}th bit is 1 in at
+least one of the arguments. If there are no arguments, the result is 0,
which is an identity element for this operation. If @code{logior} is
passed just one argument, it returns that argument.
@end defun
@defun logxor &rest ints-or-markers
-This function returns the ``exclusive or'' of its arguments: the
-@var{n}th bit is set in the result if, and only if, the @var{n}th bit is
-set in an odd number of the arguments. If there are no arguments, the
+This function returns the bitwise exclusive OR of its arguments: the
+@var{n}th bit is 1 in the result if, and only if, the @var{n}th bit is
+1 in an odd number of the arguments. If there are no arguments, the
result is 0, which is an identity element for this operation. If
@code{logxor} is passed just one argument, it returns that argument.
@end defun
@defun lognot integer
-This function returns the logical complement of its argument: the @var{n}th
+This function returns the bitwise complement of its argument: the @var{n}th
bit is one in the result if, and only if, the @var{n}th bit is zero in
@var{integer}, and vice-versa.
properties that mimic a random series. For example, all possible
values occur equally often in a pseudo-random series.
- Pseudo-random numbers are generated from a ``seed''. Starting from
+ Pseudo-random numbers are generated from a seed. Starting from
any given seed, the @code{random} function always generates the same
sequence of numbers. By default, Emacs initializes the random seed at
startup, in such a way that the sequence of values of @code{random}
have similar structures and may usually be used in the same contexts.
Types can overlap, and objects can belong to two or more types.
Consequently, we can ask whether an object belongs to a particular type,
-but not for ``the'' type of an object.
+but not for @emph{the} type of an object.
@cindex primitive type
A few fundamental object types are built into Emacs. These, from
@samp{?\b}, @samp{?\t}, @samp{?\n}, @samp{?\v}, @samp{?\f},
@samp{?\s}, @samp{?\r}, @samp{?\d}, and @samp{?\e}, respectively.
(@samp{?\s} followed by a dash has a different meaning---it applies
-the ``super'' modifier to the following character.) Thus,
+the super modifier to the following character.) Thus,
@example
?\a @result{} 7 ; @r{control-g, @kbd{C-g}}
@cindex escape sequence
These sequences which start with backslash are also known as
@dfn{escape sequences}, because backslash plays the role of an
-``escape character''; this terminology has nothing to do with the
+escape character; this has nothing to do with the
character @key{ESC}. @samp{\s} is meant for use in character
constants; in string constants, just write the space.
@cindex CL note---case of letters
@quotation
@b{Common Lisp note:} In Common Lisp, lower case letters are always
-``folded'' to upper case, unless they are explicitly escaped. In Emacs
+folded to upper case, unless they are explicitly escaped. In Emacs
Lisp, upper case and lower case letters are distinct.
@end quotation
A @dfn{cons cell} is an object that consists of two slots, called
the @sc{car} slot and the @sc{cdr} slot. Each slot can @dfn{hold} any
-Lisp object. We also say that ``the @sc{car} of this cons cell is''
+Lisp object. We also say that the @sc{car} of this cons cell is
whatever object its @sc{car} slot currently holds, and likewise for
the @sc{cdr}.
@quotation
A note to C programmers: a Lisp list thus works as a @dfn{linked list}
built up of cons cells. Because pointers in Lisp are implicit, we do
-not distinguish between a cons cell slot ``holding'' a value versus
-``pointing to'' the value.
+not distinguish between a cons cell slot holding a value versus
+pointing to the value.
@end quotation
@cindex atoms
Because cons cells are so central to Lisp, we also have a word for
-``an object which is not a cons cell''. These objects are called
+an object which is not a cons cell. These objects are called
@dfn{atoms}.
@cindex parenthesis
The names @sc{car} and @sc{cdr} derive from the history of Lisp. The
original Lisp implementation ran on an @w{IBM 704} computer which
-divided words into two parts, called the ``address'' part and the
-``decrement''; @sc{car} was an instruction to extract the contents of
+divided words into two parts, the address and the
+decrement; @sc{car} was an instruction to extract the contents of
the address part of a register, and @sc{cdr} an instruction to extract
-the contents of the decrement. By contrast, ``cons cells'' are named
+the contents of the decrement. By contrast, cons cells are named
for the function @code{cons} that creates them, which in turn was named
for its purpose, the construction of cells.
cell.
In this example, the first box, which holds the @sc{car} of the first
-cons cell, refers to or ``holds'' @code{rose} (a symbol). The second
+cons cell, refers to or holds @code{rose} (a symbol). The second
box, holding the @sc{cdr} of the first cons cell, refers to the next
pair of boxes, the second cons cell. The @sc{car} of the second cons
cell is @code{violet}, and its @sc{cdr} is the third cons cell. The
@cindex @samp{#^} read syntax
The printed representation of a char-table is like a vector
except that there is an extra @samp{#^} at the beginning.@footnote{You
-may also encounter @samp{#^^}, used for ``sub-char-tables''.}
+may also encounter @samp{#^^}, used for sub-char-tables.}
@xref{Char-Tables}, for special functions to operate on char-tables.
Uses of char-tables include:
The printed representation of a bool-vector is like a string, except
that it begins with @samp{#&} followed by the length. The string
constant that follows actually specifies the contents of the bool-vector
-as a bitmap---each ``character'' in the string contains 8 bits, which
+as a bitmap---each character in the string contains 8 bits, which
specify the next 8 elements of the bool-vector (1 stands for @code{t},
and 0 for @code{nil}). The least significant bits of the character
correspond to the lowest indices in the bool-vector.
The contents of a buffer are much like a string, but buffers are not
used like strings in Emacs Lisp, and the available operations are
different. For example, you can insert text efficiently into an
-existing buffer, altering the buffer's contents, whereas ``inserting''
+existing buffer, altering the buffer's contents, whereas inserting
text into a string requires concatenating substrings, and the result
is an entirely new string object.
@end example
You can also use the same syntax to make a circular structure, which
-appears as an ``element'' within itself. Here is an example:
+appears as an element within itself. Here is an example:
@example
#1=(a #1#)
@c have SIGTSTP?
@cindex SIGTSTP
Some operating systems (those without @code{SIGTSTP}, or MS-DOS) do
-not support suspension of jobs; on these systems, ``suspension''
+not support suspension of jobs; on these systems, suspension
actually creates a new shell temporarily as a subprocess of Emacs.
Then you would exit the shell to return to Emacs.
@end group
@end smallexample
-If @code{process-environment} contains ``duplicate'' elements that
+If @code{process-environment} contains multiple elements that
specify the same environment variable, the first of these elements
-specifies the variable, and the other ``duplicates'' are ignored.
+specifies the variable, and the others are ignored.
@end defvar
@defvar initial-environment
The symbols @code{user-login-name}, @code{user-real-login-name} and
@code{user-full-name} are variables as well as functions. The functions
return the same values that the variables hold. These variables allow
-you to ``fake out'' Emacs by telling the functions what to return. The
+you to fake out Emacs by telling the functions what to return. The
variables are also useful for constructing frame titles (@pxref{Frame
Titles}).
The characters @samp{E} and @samp{O} act as modifiers when used between
@samp{%} and one of the letters in the table above. @samp{E} specifies
-using the current locale's ``alternative'' version of the date and time.
+using the current locale's alternative version of the date and time.
In a Japanese locale, for example, @code{%Ex} might yield a date format
based on the Japanese Emperors' reigns. @samp{E} is allowed in
@samp{%Ec}, @samp{%EC}, @samp{%Ex}, @samp{%EX}, @samp{%Ey}, and
@samp{%EY}.
-@samp{O} means to use the current locale's ``alternative''
+@samp{O} means to use the current locale's alternative
representation of numbers, instead of the ordinary decimal digits. This
is allowed with most letters, all the ones that output numbers.
@end defun
The main use of @code{current-idle-time} is when an idle timer
-function wants to ``take a break'' for a while. It can set up another
+function wants to take a break for a while. It can set up another
idle timer to call the same function again, after a few seconds more
idleness. Here's an example:
This variable's value should be an alist with one element for each
system-specific keysym. Each element has the form @code{(@var{code}
. @var{symbol})}, where @var{code} is the numeric keysym code (not
-including the ``vendor specific'' bit,
+including the vendor-specific bit,
@ifnottex
@minus{}2**28),
@end ifnottex
Otherwise, the base location should be a directory name. In this
case, Emacs retrieves packages from this archive via ordinary file
-access. Such ``local'' archives are mainly useful for testing.
+access. Such local archives are mainly useful for testing.
@end defopt
A package archive is simply a directory in which the package files,
normally ignore which buffer the marker points into; they convert the
marker to an integer, and use that integer, exactly as if you had
passed the integer as the argument, even if the marker points to the
-``wrong'' buffer. A marker that points nowhere cannot convert to an
+wrong buffer. A marker that points nowhere cannot convert to an
integer; using it instead of an integer causes an error.
@xref{Markers}.
- See also the ``field'' feature (@pxref{Fields}), which provides
+ See also the field feature (@pxref{Fields}), which provides
functions that are used by many cursor-motion commands.
@menu
@c Emacs 19 feature
This variable affects the behavior of @code{forward-word} and everything
that uses it. If it is non-@code{nil}, then characters in the
-``escape'' and ``character quote'' syntax classes count as part of
+escape and character-quote syntax classes count as part of
words. Otherwise, they do not.
@end defopt
@deffn Command previous-line count
@cindex goal column
This function moves point up @var{count} lines (down if @var{count}
-is negative). In moving, it attempts to keep point in the ``goal column''
+is negative). In moving, it attempts to keep point in the goal column
(normally the same column that it was at the beginning of the move).
If there is no character in the target line exactly under the current
@deffn Command next-line count
This function moves point down @var{count} lines (up if @var{count}
-is negative). In moving, it attempts to keep point in the ``goal column''
+is negative). In moving, it attempts to keep point in the goal column
(normally the same column that it was at the beginning of the move).
If there is no character in the target line exactly under the current
@section Excursions
@cindex excursion
- It is often useful to move point ``temporarily'' within a localized
+ It is often useful to move point temporarily within a localized
portion of the program. This is called an @dfn{excursion}, and it is
done with the @code{save-excursion} special form. This construct
remembers the initial identity of the current buffer, and its value
during an excursion:
@example
-Warning: Use `with-current-buffer' rather than
+Warning: Use ‘with-current-buffer’ rather than
save-excursion+set-buffer
@end example
@item :stop @var{stopped}
If @var{stopped} is non-@code{nil}, start the process in the
-``stopped'' state.
+stopped state.
@item :filter @var{filter}
Initialize the process filter to @var{filter}.
@item :stop @var{stopped}
If @var{stopped} is non-@code{nil}, start the process in the
-``stopped'' state.
+stopped state.
@item :filter @var{filter}
Initialize the process filter to @var{filter}.
Asynchronous subprocesses receive input when it is sent to them by
Emacs, which is done with the functions in this section. You must
specify the process to send input to, and the input data to send. The
-data appears on the ``standard input'' of the subprocess.
+data appears on the standard input of the subprocess.
@c FIXME which?
Some operating systems have limited space for buffered input in a
@defun interrupt-process &optional process current-group
This function interrupts the process @var{process} by sending the
-signal @code{SIGINT}. Outside of Emacs, typing the ``interrupt
-character'' (normally @kbd{C-c} on some systems, and @key{DEL} on
+signal @code{SIGINT}. Outside of Emacs, typing the interrupt
+character (normally @kbd{C-c} on some systems, and @key{DEL} on
others) sends this signal. When the argument @var{current-group} is
-non-@code{nil}, you can think of this function as ``typing @kbd{C-c}''
+non-@code{nil}, you can think of this function as typing @kbd{C-c}
on the terminal by which Emacs talks to the subprocess.
@end defun
@defun quit-process &optional process current-group
This function sends the signal @code{SIGQUIT} to the process
-@var{process}. This signal is the one sent by the ``quit
-@c FIXME? Never heard of C-b being used for this. In readline, e.g.,
-@c bash, that is backward-word.
-character'' (usually @kbd{C-b} or @kbd{C-\}) when you are not inside
+@var{process}. This signal is the one sent by the quit
+character (usually @kbd{C-\}) when you are not inside
Emacs.
@end defun
signal @code{SIGTSTP}. Use @code{continue-process} to resume its
execution.
-Outside of Emacs, on systems with job control, the ``stop character''
+Outside of Emacs, on systems with job control, the stop character
(usually @kbd{C-z}) normally sends this signal. When
@var{current-group} is non-@code{nil}, you can think of this function as
-``typing @kbd{C-z}'' on the terminal Emacs uses to communicate with the
+typing @kbd{C-z} on the terminal Emacs uses to communicate with the
subprocess.
@end defun
@item "T"
stopped, e.g., by a job control signal
@item "Z"
-``zombie'': a process that terminated, but was not reaped by its parent
+zombie: a process that terminated, but was not reaped by its parent
@end table
@noindent
@cindex @acronym{STARTTLS} network connections
Emacs can create encrypted network connections, using either built-in
or external support. The built-in support uses the GnuTLS
-(``Transport Layer Security'') library; see
+Transport Layer Security Library; see
@uref{http://www.gnu.org/software/gnutls/, the GnuTLS project page}.
If your Emacs was compiled with GnuTLS support, the function
@code{gnutls-available-p} is defined and returns non-@code{nil}. For
An ordinary, unencrypted connection.
@item tls
@itemx ssl
-A @acronym{TLS} (``Transport Layer Security'') connection.
+A @acronym{TLS} (Transport Layer Security) connection.
@item nil
@itemx network
Start with a plain connection, and if parameters @samp{:success}
@item :type @var{type}
Specify the communication type. A value of @code{nil} specifies a
stream connection (the default); @code{datagram} specifies a datagram
-connection; @code{seqpacket} specifies a ``sequenced packet stream''
+connection; @code{seqpacket} specifies a sequenced packet stream
connection. Both connections and servers can be of these types.
@item :server @var{server-flag}
in the local address space.
@item
-An ``unsupported family'' address is represented by a cons
+An unsupported-family address is represented by a cons
@code{(@var{f} . @var{av})}, where @var{f} is the family number and
@var{av} is a vector specifying the socket address using one element
per address data byte. Do not rely on this format in portable code,
@item :stop @var{stopped}
If @var{stopped} is non-@code{nil}, start the network connection or
-server in the ``stopped'' state.
+server in the stopped state.
@item :buffer @var{buffer}
Use @var{buffer} as the process buffer.
@item (:type datagram)
Non-@code{nil} if datagrams are supported.
@item (:family local)
-Non-@code{nil} if local (a.k.a.@: ``UNIX domain'') sockets are supported.
+Non-@code{nil} if local (a.k.a.@: UNIX domain) sockets are supported.
@item (:family ipv6)
Non-@code{nil} if IPv6 is supported.
@item (:service t)
Before Exit}. The flags defaults to @code{nil} if unspecified.
@item :stop @var{bool}
-Start process in the ``stopped'' state if @var{bool} is
+Start process in the stopped state if @var{bool} is
non-@code{nil}. In the stopped state, a serial process does not
accept incoming data, but you can send outgoing data. The stopped
state is cleared by @code{continue-process} and set by
@dfn{fields}. This specification controls the length of each field to be
processed, and how to pack or unpack it. We normally keep bindat specs
in variables whose names end in @samp{-bindat-spec}; that kind of name
-is automatically recognized as ``risky''.
+is automatically recognized as risky.
@cindex endianness
@cindex big endian
A field's @dfn{type} describes the size (in bytes) of the object
that the field represents and, in the case of multibyte fields, how
the bytes are ordered within the field. The two possible orderings
-are ``big endian'' (also known as ``network byte ordering'') and
-``little endian''. For instance, the number @code{#x23cd} (decimal
+are big endian (also known as network byte ordering) and
+little endian. For instance, the number @code{#x23cd} (decimal
9165) in big endian would be the two bytes @code{#x23} @code{#xcd};
and in little endian, @code{#xcd} @code{#x23}. Here are the possible
type values:
@end deffn
@deffn Command word-search-forward string &optional limit noerror repeat
-This function searches forward from point for a ``word'' match for
+This function searches forward from point for a word match for
@var{string}. If it finds a match, it sets point to the end of the
match found, and returns the new value of point.
@item @samp{*?}, @samp{+?}, @samp{??}
@cindex non-greedy repetition characters in regexp
-These are ``non-greedy'' variants of the operators @samp{*}, @samp{+}
+These are non-greedy variants of the operators @samp{*}, @samp{+}
and @samp{?}. Where those operators match the largest possible
substring (consistent with matching the entire containing expression),
the non-greedy variants match the smallest possible substring
@defun looking-at regexp
This function determines whether the text in the current buffer directly
following point matches the regular expression @var{regexp}. ``Directly
-following'' means precisely that: the search is ``anchored'' and it can
+following'' means precisely that: the search is anchored and it can
succeed only starting with the first character following point. The
result is @code{t} if so, @code{nil} otherwise.
@itemize @bullet
@item
-The ``key bindings'' are not commands, just symbols that are meaningful
+The key bindings are not commands, just symbols that are meaningful
to the functions that use this map.
@item
Prefix keys are not supported; each key binding must be for a
single-event key sequence. This is because the functions don't use
@code{read-key-sequence} to get the input; instead, they read a single
-event and look it up ``by hand''.
+event and look it up by hand.
@end itemize
@end defvar
-Here are the meaningful ``bindings'' for @code{query-replace-map}.
+Here are the meaningful bindings for @code{query-replace-map}.
Several of them are meaningful only for @code{query-replace} and
friends.
@defvar multi-query-replace-map
This variable holds a keymap that extends @code{query-replace-map} by
providing additional keybindings that are useful in multi-buffer
-replacements. The additional ``bindings'' are:
+replacements. The additional bindings are:
@table @code
@item automatic-all
The argument @var{predicate} must be a function that accepts two
arguments. It is called with two elements of @var{sequence}. To get an
increasing order sort, the @var{predicate} should return non-@code{nil} if the
-first element is ``less than'' the second, or @code{nil} if not.
+first element is less than the second, or @code{nil} if not.
The comparison function @var{predicate} must give reliable results for
any given pair of arguments, at least within a single call to
efficient ring data structure is implemented by the @code{ring}
package. It provides the functions listed in this section.
- Note that several ``rings'' in Emacs, like the kill ring and the
+ Note that several rings in Emacs, like the kill ring and the
mark ring, are actually implemented as simple lists, @emph{not} using
the @code{ring} package; thus the following functions won't work on
them.
When it is called with one argument (always a character), @var{function}
should save the argument and arrange to return it on the next call.
This is called @dfn{unreading} the character; it happens when the Lisp
-reader reads one character too many and wants to ``put it back where it
-came from''. In this case, it makes no difference what value
+reader reads one character too many and wants to put it back where it
+came from. In this case, it makes no difference what value
@var{function} returns.
@end itemize
@defun pp object &optional stream
This function outputs @var{object} to @var{stream}, just like
-@code{prin1}, but does it in a more ``pretty'' way. That is, it'll
+@code{prin1}, but does it in a prettier way. That is, it'll
indent and fill the object to make it more readable for humans.
@end defun
@end example
Somewhat odd, but predictable, behavior can occur for certain
-``non-greedy'' values of @var{separators} that can prefer empty
+non-greedy values of @var{separators} that can prefer empty
matches over non-empty matches. Again, such values rarely occur in
practice:
@var{start2} up to index @var{end2}.
The strings are compared by the numeric values of their characters.
-For instance, @var{str1} is considered ``smaller than'' @var{str2} if
+For instance, @var{str1} is considered less than @var{str2} if
its first differing character has a smaller numeric value. If
@var{ignore-case} is non-@code{nil}, characters are converted to
lower-case before comparing them. Unibyte strings are converted to
strings and integers. @code{format} (@pxref{Formatting Strings}) and
@code{prin1-to-string} (@pxref{Output Functions}) can also convert
Lisp objects into strings. @code{read-from-string} (@pxref{Input
-Functions}) can ``convert'' a string representation of a Lisp object
+Functions}) can convert a string representation of a Lisp object
into an object. The functions @code{string-to-multibyte} and
@code{string-to-unibyte} convert the text representation of a string
(@pxref{Converting Representations}).
ignored except for @samp{%d}, @samp{%e}, @samp{%f}, @samp{%g}, and if
both flags are used, @samp{+} takes precedence.
- The flag @samp{#} specifies an ``alternate form'' which depends on
+ The flag @samp{#} specifies an alternate form which depends on
the format in use. For @samp{%o}, it ensures that the result begins
with a @samp{0}. For @samp{%x} and @samp{%X}, it prefixes the result
with @samp{0x} or @samp{0X}. For @samp{%e}, @samp{%f}, and @samp{%g},
Some language environments modify the case conversions of
@acronym{ASCII} characters; for example, in the Turkish language
-environment, the @acronym{ASCII} character @samp{I} is downcased into
-a Turkish ``dotless i''. This can interfere with code that requires
+environment, the @acronym{ASCII} capital I is downcased into
+a Turkish dotless i (@samp{ı}). This can interfere with code that requires
ordinary @acronym{ASCII} case conversion, such as implementations of
@acronym{ASCII}-based network protocols. In that case, use the
@code{with-case-table} macro with the variable @var{ascii-case-table},
@section Symbol Components
@cindex symbol components
- Each symbol has four components (or ``cells''), each of which
+ Each symbol has four components (or cells), each of which
references another object:
@table @asis
@cindex obarray
@cindex bucket (in obarray)
When the Lisp reader encounters a symbol, it reads all the characters
-of the name. Then it ``hashes'' those characters to find an index in a
+of the name. Then it hashes those characters to find an index in a
table called an @dfn{obarray}. Hashing is an efficient method of
looking something up. For example, instead of searching a telephone
book cover to cover when looking up Jan Jones, you start with the J's
should be enabled in menus. @xref{Simple Menu Items}.
@item mode-class
-If the value is @code{special}, the named major mode is ``special''.
+If the value is @code{special}, the named major mode is special.
@xref{Major Mode Conventions}.
@item permanent-local
Usually, this designator character is one that is often assigned that
class; however, its meaning as a designator is unvarying and
independent of what syntax that character currently has. Thus,
-@samp{\} as a designator character always means ``escape character''
+@samp{\} as a designator character always stands for escape character
syntax, regardless of whether the @samp{\} character actually has that
syntax in the current syntax table.
@ifnottex
@end table
@item
-@samp{p} identifies an additional ``prefix character'' for Lisp syntax.
+@samp{p} identifies an additional prefix character for Lisp syntax.
These characters are treated as whitespace when they appear between
expressions. When they appear within an expression, they are handled
according to their usual syntax classes.
expressions. We will refer to such expressions as @dfn{sexps},
following the terminology of Lisp, even though these functions can act
on languages other than Lisp. Basically, a sexp is either a balanced
-parenthetical grouping, a string, or a ``symbol'' (i.e., a sequence
+parenthetical grouping, a string, or a symbol (i.e., a sequence
of characters whose syntax is either word constituent or symbol
constituent). However, characters in the expression prefix syntax
class (@pxref{Syntax Class Table}) are treated as part of the sexp if
A character's syntax controls how it changes the state of the
parser, rather than describing the state itself. For example, a
string delimiter character toggles the parser state between
-``in-string'' and ``in-code'', but the syntax of characters does not
+in-string and in-code, but the syntax of characters does not
directly say whether they are inside a string. For example (note that
15 is the syntax code for generic string delimiters),
expected, with nothing except whitespace between them, it returns
@code{t}; otherwise it returns @code{nil}.
-This function cannot tell whether the ``comments'' it traverses are
+This function cannot tell whether the comments it traverses are
embedded within a string. If they look like comments, it treats them
as comments.
* Base 64:: Conversion to or from base 64 encoding.
* Checksum/Hash:: Computing cryptographic hashes.
* Parsing HTML/XML:: Parsing HTML and XML.
-* Atomic Changes:: Installing several buffer changes ``atomically''.
+* Atomic Changes:: Installing several buffer changes atomically.
* Change Hooks:: Supplying functions to be run when text is changed.
@end menu
asking for any confirmation. It returns @code{nil}.
Normally, deleting a large amount of text from a buffer inhibits further
-auto-saving of that buffer ``because it has shrunk''. However,
+auto-saving of that buffer because it has shrunk. However,
@code{erase-buffer} does not do this, the idea being that the future
text is not really related to the former text, and its size should not
be compared with that of the former text.
it so that the user can reinsert it by @dfn{yanking}. Most of these
functions have @samp{kill-} in their name. By contrast, the functions
whose names start with @samp{delete-} normally do not save text for
-yanking (though they can still be undone); these are ``deletion''
+yanking (though they can still be undone); these are deletion
functions.
Most of the kill commands are primarily for interactive use, and are
Some people think this use of the word ``kill'' is unfortunate, since
it refers to operations that specifically @emph{do not} destroy the
-entities ``killed''. This is in sharp contrast to ordinary life, in
-which death is permanent and ``killed'' entities do not come back to
+entities killed. This is in sharp contrast to ordinary life, in
+which death is permanent and killed entities do not come back to
life. Therefore, other metaphors have been proposed. For example, the
term ``cut ring'' makes sense to people who, in pre-computer days, used
scissors and paste to cut up and rearrange manuscripts. However, it
unit; the second and subsequent consecutive kill commands add text to
the entry made by the first one.
- For yanking, one entry in the kill ring is designated the ``front'' of
-the ring. Some yank commands ``rotate'' the ring by designating a
-different element as the ``front''. But this virtual rotation doesn't
+ For yanking, one entry in the kill ring is designated the front of
+the ring. Some yank commands rotate the ring by designating a
+different element as the front. But this virtual rotation doesn't
change the list itself---the most recent entry always comes first in the
list.
@subsection Functions for Killing
@code{kill-region} is the usual subroutine for killing text. Any
-command that calls this function is a ``kill command'' (and should
+command that calls this function is a kill command (and should
probably have @samp{kill} in its name). @code{kill-region} puts the
newly killed text in a new element at the beginning of the kill ring or
adds it to the most recent element. It determines automatically (using
@defun current-kill n &optional do-not-move
The function @code{current-kill} rotates the yanking pointer, which
-designates the ``front'' of the kill ring, by @var{n} places (from newer
+designates the front of the kill ring, by @var{n} places (from newer
kills to older ones), and returns the text at that place in the ring.
If the optional second argument @var{do-not-move} is non-@code{nil},
@code{nil} or a function of no arguments.
If the value is a function, @code{current-kill} calls it to get the
-``most recent kill''. If the function returns a non-@code{nil} value,
-then that value is used as the ``most recent kill''. If it returns
+most recent kill. If the function returns a non-@code{nil} value,
+then that value is used as the most recent kill. If it returns
@code{nil}, then the front of the kill ring is used.
To facilitate support for window systems that support multiple
selections, this function may also return a list of strings. In that
-case, the first string is used as the ``most recent kill'', and all
+case, the first string is used as the most recent kill, and all
the other strings are pushed onto the kill ring, for easy access by
@code{yank-pop}.
The @code{kill-ring-yank-pointer} variable points to a link in the
kill ring list, whose @sc{car} is the text to yank next. We say it
-identifies the ``front'' of the ring. Moving
+identifies the front of the ring. Moving
@code{kill-ring-yank-pointer} to a different link is called
@dfn{rotating the kill ring}. We call the kill ring a ``ring'' because
the functions that move the yank pointer wrap around from the end of the
@defvar kill-ring-yank-pointer
This variable's value indicates which element of the kill ring is at the
-``front'' of the ring for yanking. More precisely, the value is a tail
+front of the ring for yanking. More precisely, the value is a tail
of the value of @code{kill-ring}, and its @sc{car} is the kill string
that @kbd{C-y} should yank.
@end defvar
As editing continues, undo lists get longer and longer. To prevent
them from using up all available memory space, garbage collection trims
-them back to size limits you can set. (For this purpose, the ``size''
+them back to size limits you can set. (For this purpose, the size
of an undo list measures the cons cells that make up the list, plus the
strings of deleted text.) Three variables control the range of acceptable
sizes: @code{undo-limit}, @code{undo-strong-limit} and
@defvar use-hard-newlines
If this variable is non-@code{nil}, the filling functions do not delete
-newlines that have the @code{hard} text property. These ``hard
-newlines'' act as paragraph separators. @xref{Hard and Soft
+newlines that have the @code{hard} text property. These hard
+newlines act as paragraph separators. @xref{Hard and Soft
Newlines,, Hard and Soft Newlines, emacs, The GNU Emacs Manual}.
@end defvar
additional check of the validity of the one available candidate fill
prefix: the candidate must match this regular expression, or match
@code{comment-start-skip}. If it doesn't, @code{fill-context-prefix}
-replaces the candidate with a string of spaces ``of the same width''
+replaces the candidate with a string of spaces of the same width
as it.
The default value of this variable is @w{@code{"\\`[ \t]*\\'"}}, which
You can specify more complex ways of choosing a fill prefix
automatically by setting this variable to a function. The function is
called with point after the left margin (if any) of a line, and it
-must preserve point. It should return either ``that line's'' fill
+must preserve point. It should return either that line's fill
prefix or @code{nil}, meaning it has failed to determine a prefix.
@end defopt
@deffn Command indent-rigidly start end count
This function indents all lines starting between @var{start}
(inclusive) and @var{end} (exclusive) sideways by @var{count} columns.
-This ``preserves the shape'' of the affected region, moving it as a
+This preserves the shape of the affected region, moving it as a
rigid unit.
This is useful not only for indenting regions of unindented text, but
@end deffn
@node Indent Tabs
-@subsection Adjustable ``Tab Stops''
+@subsection Adjustable Tab Stops
@cindex tabs stops for indentation
- This section explains the mechanism for user-specified ``tab stops''
+ This section explains the mechanism for user-specified tab stops
and the mechanisms that use and set them. The name ``tab stops'' is
used because the feature is similar to that of the tab stops on a
typewriter. The feature works by inserting an appropriate number of
@code{nil}, Emacs's redisplay routine calls the functions in
@code{fontification-functions} (@pxref{Auto Faces}) to prepare this
part of the buffer before it is displayed. It is used internally by
-the ``just in time'' font locking code.
+the just-in-time font locking code.
@item display
This property activates various features that change the
@table @code
@item hard
-If a newline character has this property, it is a ``hard'' newline.
+If a newline character has this property, it is a hard newline.
The fill commands do not alter hard newlines and do not move words
across them. However, this property takes effect only if the
@code{use-hard-newlines} minor mode is enabled. @xref{Hard and Soft
@defvar buffer-access-fontified-property
If this variable's value is non-@code{nil}, it is a symbol which is used
as a text property name. A non-@code{nil} value for that text property
-means, ``the other text properties for this character have already been
-computed''.
+means the other text properties for this character have already been
+computed.
If all the characters in the range specified for @code{buffer-substring}
have a non-@code{nil} value for this property, @code{buffer-substring}
bind the @code{follow-link} event to a keymap (which can be a major
mode keymap or a local keymap specified via the @code{keymap} text
property). The value of the @code{follow-link} property, or the
-binding for the @code{follow-link} event, acts as a ``condition'' for
+binding for the @code{follow-link} event, acts as a condition for
the link action. This condition tells Emacs two things: the
circumstances under which a @kbd{Mouse-1} click should be regarded as
-occurring ``inside'' the link, and how to compute an ``action code''
+occurring inside the link, and how to compute an action code
that says what to translate the @kbd{Mouse-1} click into. The link
action condition can be one of the following:
@end defun
@defun constrain-to-field new-pos old-pos &optional escape-from-edge only-in-line inhibit-capture-property
-This function ``constrains'' @var{new-pos} to the field that
+This function constrains @var{new-pos} to the field that
@var{old-pos} belongs to---in other words, it returns the position
closest to @var{new-pos} that is in the same field as @var{old-pos}.
@var{new-pos} can be anywhere in the two adjacent fields.
Additionally, if two fields are separated by another field with the
special value @code{boundary}, then any point within this special
-field is also considered to be ``on the boundary''.
+field is also considered to be on the boundary.
Commands like @kbd{C-a} with no argument, that normally move backward
to a specific kind of location and stay there once there, probably
@cindex intervals
Some editors that support adding attributes to text in the buffer do
-so by letting the user specify ``intervals'' within the text, and adding
+so by letting the user specify intervals within the text, and adding
the properties to the intervals. Those editors permit the user or the
programmer to determine where individual intervals start and end. We
deliberately provided a different sort of interface in Emacs Lisp to
same properties. Thus, editing does not preserve the distinction
between one interval and two.
- Suppose we ``fix'' this problem by coalescing the two intervals when
+ Suppose we attempt to fix this problem by coalescing the two intervals when
the text is inserted. That works fine if the buffer originally was a
single interval. But suppose instead that we have two adjacent
intervals with the same properties, and we kill the text of one interval
@cindex cryptographic hash
Emacs has built-in support for computing @dfn{cryptographic hashes}.
-A cryptographic hash, or @dfn{checksum}, is a digital ``fingerprint''
+A cryptographic hash, or @dfn{checksum}, is a digital fingerprint
of a piece of data (e.g., a block of text) which can be used to check
that you have an unaltered copy of that data.
SHA-1, SHA-2, SHA-224, SHA-256, SHA-384 and SHA-512. MD5 is the
oldest of these algorithms, and is commonly used in @dfn{message
digests} to check the integrity of messages transmitted over a
-network. MD5 is not ``collision resistant'' (i.e., it is possible to
+network. MD5 is not collision resistant (i.e., it is possible to
deliberately design different pieces of data which have the same MD5
hash), so you should not used it for anything security-related. A
similar theoretical weakness also exists in SHA-1. Therefore, for
@defun libxml-parse-html-region start end &optional base-url discard-comments
This function parses the text between @var{start} and @var{end} as
HTML, and returns a list representing the HTML @dfn{parse tree}. It
-attempts to handle ``real world'' HTML by robustly coping with syntax
+attempts to handle real-world HTML by robustly coping with syntax
mistakes.
The optional argument @var{base-url}, if non-@code{nil}, should be a
@defun prepare-change-group &optional buffer
This function sets up a change group for buffer @var{buffer}, which
-defaults to the current buffer. It returns a ``handle'' that
+defaults to the current buffer. It returns a handle that
represents the change group. You must use this handle to activate the
change group and subsequently to finish it.
@end defun
@item
In @code{interactive}, if you use a Lisp expression to produce a list
-of arguments, don't try to provide the ``correct'' default values for
+of arguments, don't try to provide the correct default values for
region or position arguments. Instead, provide @code{nil} for those
arguments if they were not specified, and have the function body
compute the default value when the argument is @code{nil}. For
@item
The documentation string for a function that is a yes-or-no predicate
should start with words such as ``Return t if'', to indicate
-explicitly what constitutes ``truth''. The word ``return'' avoids
+explicitly what constitutes truth. The word ``return'' avoids
starting the sentence with lower-case ``t'', which could be somewhat
distracting.
Comments that start with three semicolons, @samp{;;;}, should start at
the left margin. We use them
for comments which should be considered a
-``heading'' by Outline minor mode. By default, comments starting with
+heading by Outline minor mode. By default, comments starting with
at least three semicolons (followed by a single space and a
non-whitespace character) are considered headings, comments starting
with two or fewer are not. Historically, triple-semicolon comments have
@menu
* Global Variables:: Variable values that exist permanently, everywhere.
-* Constant Variables:: Certain ``variables'' have values that never change.
+* Constant Variables:: Variables that never change.
* Local Variables:: Variable values that exist only temporarily.
* Void Variables:: Symbols that lack values.
* Defining Variables:: A definition says a symbol is used as a variable.
@code{nil} otherwise.
@end defun
-These constants are fundamentally different from the ``constants''
+These constants are fundamentally different from the constants
defined using the @code{defconst} special form (@pxref{Defining
Variables}). A @code{defconst} form serves to inform human readers
that you do not intend to change the value of a variable, but Emacs
and it is the binding acted on by @code{setq}.
For most purposes, you can think of the current binding as the
-``innermost'' local binding, or the global binding if there is no
+innermost local binding, or the global binding if there is no
local binding. To be more precise, a rule called the @dfn{scoping
rule} determines where in a program a local binding takes effect. The
default scoping rule in Emacs Lisp is called @dfn{dynamic scoping},
Variables}); a few variables have terminal-local bindings
(@pxref{Multiple Terminals}). These kinds of bindings work somewhat
like ordinary local bindings, but they are localized depending on
-``where'' you are in Emacs.
+where you are in Emacs.
@defopt max-specpdl-size
@anchor{Definition of max-specpdl-size}
@end defopt
@node Void Variables
-@section When a Variable is ``Void''
+@section When a Variable is Void
@cindex @code{void-variable} error
@cindex void variable
@item @dots{}-predicate
The value is a predicate---a function of one argument that returns
-non-@code{nil} for ``good'' arguments and @code{nil} for ``bad''
-arguments.
+non-@code{nil} for success and @code{nil} for failure.
@item @dots{}-flag
The value is significant only as to whether it is @code{nil} or not.
@end table
When you define a variable, always consider whether you should mark
-it as ``safe'' or ``risky''; see @ref{File Local Variables}.
+it as safe or risky; see @ref{File Local Variables}.
When defining and initializing a variable that holds a complicated
value (such as a keymap with bindings in it), it's best to put the
(defvar x -99) ; @r{@code{x} receives an initial value of @minus{}99.}
(defun getx ()
- x) ; @r{@code{x} is used ``free'' in this function.}
+ x) ; @r{@code{x} is used free in this function.}
(let ((x 1)) ; @r{@code{x} is dynamically bound.}
(getx))
@end example
@noindent
-The function @code{getx} refers to @code{x}. This is a ``free''
+The function @code{getx} refers to @code{x}. This is a @dfn{free}
reference, in the sense that there is no binding for @code{x} within
that @code{defun} construct itself. When we call @code{getx} from
within a @code{let} form in which @code{x} is (dynamically) bound, it
@result{} 4
(defun getx ()
- x) ; @r{@code{x} is used ``free'' in this function.}
+ x) ; @r{@code{x} is used free in this function.}
(let ((x 1)) ; @r{@code{x} is lexically bound.}
(getx))
@cindex closures, example of using
Lexical bindings have indefinite extent. Even after a binding
construct has finished executing, its lexical environment can be
-``kept around'' in Lisp objects called @dfn{closures}. A closure is
+kept around in Lisp objects called @dfn{closures}. A closure is
created when you define a named or anonymous function with lexical
binding enabled. @xref{Closures}, for details.
A simple way to find out which variables need a variable definition
is to byte-compile the source file. @xref{Byte Compilation}. If a
non-special variable is used outside of a @code{let} form, the
-byte-compiler will warn about reference or assignment to a ``free
-variable''. If a non-special variable is bound but not used within a
-@code{let} form, the byte-compiler will warn about an ``unused lexical
-variable''. The byte-compiler will also issue a warning if you use a
+byte-compiler will warn about reference or assignment to a free
+variable. If a non-special variable is bound but not used within a
+@code{let} form, the byte-compiler will warn about an unused lexical
+variable. The byte-compiler will also issue a warning if you use a
special variable as a function argument.
(To silence byte-compiler warnings about unused variables, just use
@cindex local variables, killed by major mode
@defun kill-all-local-variables
This function eliminates all the buffer-local variable bindings of the
-current buffer except for variables marked as ``permanent'' and local
+current buffer except for variables marked as permanent and local
hook functions that have a non-@code{nil} @code{permanent-local-hook}
property (@pxref{Setting Hooks}). As a result, the buffer will see
the default values of most variables.
completely ignored.
@end defvar
- The @samp{Eval:} ``variable'' is also a potential loophole, so Emacs
+ The @samp{Eval:} variable is also a potential loophole, so Emacs
normally asks for confirmation before handling it.
@defopt enable-local-eval
@defopt safe-local-eval-forms
This variable holds a list of expressions that are safe to
-evaluate when found in the @samp{Eval:} ``variable'' in a file
+evaluate when found in the @samp{Eval:} variable in a file
local variables list.
@end defopt
of arrays, properties of symbols, and many other locations are also
places where Lisp values are stored.
-Generalized variables are analogous to ``lvalues'' in the C
+Generalized variables are analogous to lvalues in the C
language, where @samp{x = a[i]} gets an element from an array
and @samp{a[i] = x} stores an element using the same notation.
Just as certain forms like @code{a[i]} can be lvalues in C, there
@cindex CL note---no @code{setf} functions
@quotation
@b{Common Lisp note:} Common Lisp defines another way to specify the
-@code{setf} behavior of a function, namely ``@code{setf} functions'',
+@code{setf} behavior of a function, namely @code{setf} functions,
whose names are lists @code{(setf @var{name})} rather than symbols.
For example, @code{(defun (setf foo) @dots{})} defines the function
that is used when @code{setf} is applied to @code{foo}. Emacs does
width of a window. The return value of many of these functions can be
specified either in units of pixels or in units of lines and columns.
On a graphical display, the latter actually correspond to the height and
-width of a ``default'' character specified by the frame's default font
+width of a default character specified by the frame's default font
as returned by @code{frame-char-height} and @code{frame-char-width}
(@pxref{Frame Font}). Thus, if a window is displaying text with a
different font or size, the reported line height and column width for
@defun split-window &optional window size side pixelwise
This function creates a new live window next to the window
@var{window}. If @var{window} is omitted or @code{nil}, it defaults
-to the selected window. That window is ``split'', and reduced in
+to the selected window. That window is split, and reduced in
size. The space is taken up by the new window, which is returned.
The optional second argument @var{size} determines the sizes of
areas like a mode line or a scroll bar. The function
@code{window-min-size} (@pxref{Window Sizes}) can be used to determine
the minimum requirements of @var{window} in this regard. Since the new
-window usually ``inherits'' areas like the mode line or the scroll bar
+window usually inherits areas like the mode line or the scroll bar
from @var{window}, that function is also a good guess for the minimum
size of the new window. The caller should specify a smaller size only
if it correspondingly removes an inherited area before the next
coding. As a rule, such selections (including those made by the macros
@code{save-selected-window} and @code{with-selected-window} below) are
not recorded thus avoiding to pollute @code{buffer-list-update-hook}.
-Selections that ``really count'' are those causing a visible change in
+Selections that really count are those causing a visible change in
the next redisplay of @var{window}'s frame and should be always
recorded. This also means that to run a function each time a window
gets selected, putting it on @code{buffer-list-update-hook} should be
@cindex use time of window
@cindex window order by time of last use
@defun window-use-time &optional window
-This functions returns the ``use time'' of window @var{window}.
+This functions returns the use time of window @var{window}.
@var{window} must be a live window and defaults to the selected one.
The @dfn{use time} of a window is not really a time value, but it does
increase monotonically with each window selection, so the window with
-the lowest ``use time'' is the least recently selected one, and the
-window with the highest ``use time'' is the most recently selected
+the lowest use time is the least recently selected one, and the
+window with the highest use time is the most recently selected
one.
@end defun
The optional argument @var{minibuf} specifies whether minibuffer windows
should be included in the cyclic ordering. Normally, when @var{minibuf}
is @code{nil}, a minibuffer window is included only if it is currently
-``active''; this matches the behavior of @kbd{C-x o}. (Note that a
+active; this matches the behavior of @kbd{C-x o}. (Note that a
minibuffer window is active as long as its minibuffer is in use; see
@ref{Minibuffers}).
@cindex least recently used window
@defun get-lru-window &optional all-frames dedicated not-selected
-This function returns a live window which is heuristically the ``least
-recently used'' window. The optional argument @var{all-frames} has
+This function returns a live window which is heuristically the least
+recently used. The optional argument @var{all-frames} has
the same meaning as in @code{next-window}.
If any full-width windows are present, only those windows are
@cindex most recently used window
@defun get-mru-window &optional all-frames dedicated not-selected
-This function is like @code{get-lru-window}, but it returns the ``most
-recently used'' window instead. The meaning of the arguments is the
+This function is like @code{get-lru-window}, but it returns the most
+recently used window instead. The meaning of the arguments is the
same as described for @code{get-lru-window}.
@end defun
@defopt display-buffer-base-action
The value of this option should be a display action. This option can
-be used to define a ``standard'' display action for calls to
+be used to define a standard display action for calls to
@code{display-buffer}.
@end defopt
@end defun
@defun display-buffer-reuse-window buffer alist
-This function tries to ``display'' @var{buffer} by finding a window
+This function tries to display @var{buffer} by finding a window
that is already displaying it.
If @var{alist} has a non-@code{nil} @code{inhibit-same-window} entry,
@end defun
@defun display-buffer-use-some-frame buffer alist
-This function tries to ``display'' @var{buffer} by trying to find a
+This function tries to display @var{buffer} by trying to find a
frame that meets a predicate (by default any frame other than the
current frame).
(provided *foo* was put by @code{display-buffer} there before) or a
popped-up window as follows: If the window is part of a vertical
combination, it will set its height to ten lines. Note that if, instead
-of the number ``10'', we specified the function
+of the number 10, we specified the function
@code{fit-window-to-buffer}, @code{display-buffer} would come up with a
one-line window to fit the empty buffer. If the window is part of a
horizontal combination, it sets its width to 40 columns. Whether a new
selected one is dedicated to its buffer, @code{display-buffer} will
proceed as described in the previous example. Note, however, that when
it tries to adjust the height of any reused or popped-up window, it will
-in any case try to set its number of lines to ``5'' since that value
+in any case try to set its number of lines to 5 since that value
overrides the corresponding specification in the @var{action} argument
of @code{display-buffer}.
When @var{window} is the selected window, the value returned is the
value of point in that window's buffer. Strictly speaking, it would be
-more correct to return the ``top-level'' value of point, outside of any
+more correct to return the top-level value of point, outside of any
@code{save-excursion} forms. But that value is hard to find.
@end defun
point to the left margin on the middle line in the window.
For example, if point @w{is 1} and you set the start of the window
-@w{to 37}, the start of the next line, point will be ``above'' the top
+@w{to 37}, the start of the next line, point will be above the top
of the window. The display routines will automatically move point if
it is still 1 when redisplay occurs. Here is an example:
@cindex centering point
This function scrolls the text in the selected window so that point is
displayed at a specified vertical position within the window. It does
-not ``move point'' with respect to the text.
+not move point with respect to the text.
If @var{count} is a non-negative number, that puts the line containing
point @var{count} lines down from the top of the window. If
disappear off to the left depends on their width, and could vary from
line to line.
- Because we read from side to side in the ``inner loop'', and from top
-to bottom in the ``outer loop'', the effect of horizontal scrolling is
+ Because we read from side to side in the inner loop, and from top
+to bottom in the outer loop, the effect of horizontal scrolling is
not like that of textual or vertical scrolling. Textual scrolling
involves selection of a portion of text to display, and vertical
scrolling moves the window contents contiguously; but horizontal
native position of the window's frame (@pxref{Frame Geometry}). Some
functions report positions relative to the origin of the display of the
window's frame. In any case, the origin has the coordinates (0, 0) and
-X and Y coordinates increase ``rightward'' and ``downward''
+X and Y coordinates increase rightward and downward
respectively.
For the following functions, X and Y coordinates are reported in
integer character units, i.e., numbers of lines and columns
-respectively. On a graphical display, each ``line'' and ``column''
+respectively. On a graphical display, each line and column
corresponds to the height and width of a default character specified by
the frame's default font (@pxref{Frame Font}).
The following functions return window positions in pixels, rather
than character units. Though mostly useful on graphical displays,
they can also be called on text terminals, where the screen area of
-each text character is taken to be ``one pixel''.
+each text character is taken to be one pixel.
@defun window-pixel-edges &optional window
This function returns a list of pixel coordinates for the edges of
@end group
@end example
-On a graphical terminal this form ``warps'' the mouse cursor to the
+On a graphical terminal this form warps the mouse cursor to the
upper left corner of the glyph at the selected window's point. A
position calculated this way can be also used to show a tooltip window
there.