@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.