@smallexample
@group
-(let ((zebra 'stripes)
- (tiger 'fierce))
+(let ((zebra "stripes")
+ (tiger "fierce"))
(message "One kind of animal has %s and another is %s."
zebra tiger))
@end group
@end smallexample
-Here, the varlist is @code{((zebra 'stripes) (tiger 'fierce))}.
+Here, the varlist is @code{((zebra "stripes") (tiger "fierce"))}.
The two variables are @code{zebra} and @code{tiger}. Each variable is
the first element of a two-element list and each value is the second
element of its two-element list. In the varlist, Emacs binds the
-variable @code{zebra} to the value @code{stripes}@footnote{According
+variable @code{zebra} to the value @code{"stripes"}@footnote{According
to Jared Diamond in @cite{Guns, Germs, and Steel}, ``@dots{} zebras
become impossibly dangerous as they grow older'' but the claim here is
that they do not become fierce like a tiger. (1997, W. W. Norton and
Co., ISBN 0-393-03894-2, page 171)}, and binds the
-variable @code{tiger} to the value @code{fierce}. In this example,
-both values are symbols preceded by a quote. The values could just as
-well have been another list or a string. The body of the @code{let}
+variable @code{tiger} to the value @code{"fierce"}. In this example,
+both values are strings. The values could just as well have been
+another list or a symbol. The body of the @code{let}
follows after the list holding the variables. In this example, the
body is a list that uses the @code{message} function to print a string
in the echo area.
For example, the value may be bound to an argument of a function
definition. In the following function definition, the character of the
animal is a value that is passed to the function. If the value bound to
-@code{characteristic} is @code{fierce}, then the message, @samp{It's a
+@code{characteristic} is @code{"fierce"}, then the message, @samp{It is a
tiger!} will be printed; otherwise, @code{nil} will be returned.
@smallexample
@group
(defun type-of-animal (characteristic)
"Print message in echo area depending on CHARACTERISTIC.
-If the CHARACTERISTIC is the symbol ‘fierce’,
+If the CHARACTERISTIC is the string \"fierce\",
then warn of a tiger."
- (if (equal characteristic 'fierce)
- (message "It’s a tiger!")))
+ (if (equal characteristic "fierce")
+ (message "It is a tiger!")))
@end group
@end smallexample
@smallexample
@group
-(type-of-animal 'fierce)
+(type-of-animal "fierce")
-(type-of-animal 'zebra)
+(type-of-animal "striped")
@end group
@end smallexample
@c Following sentences rewritten to prevent overfull hbox.
@noindent
-When you evaluate @code{(type-of-animal 'fierce)}, you will see the
-following message printed in the echo area: @code{"It’s a tiger!"}; and
-when you evaluate @code{(type-of-animal 'zebra)} you will see @code{nil}
+When you evaluate @code{(type-of-animal "fierce")}, you will see the
+following message printed in the echo area: @code{"It is a tiger!"}; and
+when you evaluate @code{(type-of-animal "striped")} you will see @code{nil}
printed in the echo area.
@node type-of-animal in detail
@group
(defun type-of-animal (characteristic)
"Print message in echo area depending on CHARACTERISTIC.
-If the CHARACTERISTIC is the symbol ‘fierce’,
+If the CHARACTERISTIC is the string \"fierce\",
then warn of a tiger."
@var{body: the} @code{if} @var{expression})
@end group
@smallexample
@group
-(if (equal characteristic 'fierce)
- (message "It’s a tiger!")))
+(if (equal characteristic "fierce")
+ (message "It is a tiger!")))
@end group
@end smallexample
Here, the true-or-false-test is the expression:
@smallexample
-(equal characteristic 'fierce)
+(equal characteristic "fierce")
@end smallexample
@noindent
In Lisp, @code{equal} is a function that determines whether its first
argument is equal to its second argument. The second argument is the
-quoted symbol @code{'fierce} and the first argument is the value of the
+string @code{"fierce"} and the first argument is the value of the
symbol @code{characteristic}---in other words, the argument passed to
this function.
In the first exercise of @code{type-of-animal}, the argument
-@code{fierce} is passed to @code{type-of-animal}. Since @code{fierce}
-is equal to @code{fierce}, the expression, @code{(equal characteristic
-'fierce)}, returns a value of true. When this happens, the @code{if}
+@code{"fierce"} is passed to @code{type-of-animal}. Since @code{"fierce"}
+is equal to @code{"fierce"}, the expression, @code{(equal characteristic
+"fierce")}, returns a value of true. When this happens, the @code{if}
evaluates the second argument or then-part of the @code{if}:
-@code{(message "It’s a tiger!")}.
+@code{(message "It is a tiger!")}.
On the other hand, in the second exercise of @code{type-of-animal}, the
-argument @code{zebra} is passed to @code{type-of-animal}. @code{zebra}
-is not equal to @code{fierce}, so the then-part is not evaluated and
+argument @code{"striped"} is passed to @code{type-of-animal}. @code{"striped"}
+is not equal to @code{"fierce"}, so the then-part is not evaluated and
@code{nil} is returned by the @code{if} expression.
@node else
@group
(defun type-of-animal (characteristic) ; @r{Second version.}
"Print message in echo area depending on CHARACTERISTIC.
-If the CHARACTERISTIC is the symbol ‘fierce’,
-then warn of a tiger; else say it’s not fierce."
- (if (equal characteristic 'fierce)
- (message "It’s a tiger!")
- (message "It’s not fierce!")))
+If the CHARACTERISTIC is the string \"fierce\",
+then warn of a tiger; else say it is not fierce."
+ (if (equal characteristic "fierce")
+ (message "It is a tiger!")
+ (message "It is not fierce!")))
@end group
@end smallexample
@sp 1
@smallexample
@group
-(type-of-animal 'fierce)
+(type-of-animal "fierce")
-(type-of-animal 'zebra)
+(type-of-animal "striped")
@end group
@end smallexample
@c Following sentence rewritten to prevent overfull hbox.
@noindent
-When you evaluate @code{(type-of-animal 'fierce)}, you will see the
-following message printed in the echo area: @code{"It’s a tiger!"}; but
-when you evaluate @code{(type-of-animal 'zebra)}, you will see
-@code{"It’s not fierce!"}.
+When you evaluate @code{(type-of-animal "fierce")}, you will see the
+following message printed in the echo area: @code{"It is a tiger!"}; but
+when you evaluate @code{(type-of-animal "striped")}, you will see
+@code{"It is not fierce!"}.
-(Of course, if the @var{characteristic} were @code{ferocious}, the
-message @code{"It’s not fierce!"} would be printed; and it would be
+(Of course, if the @var{characteristic} were @code{"ferocious"}, the
+message @code{"It is not fierce!"} would be printed; and it would be
misleading! When you write code, you need to take into account the
possibility that some such argument will be tested by the @code{if}
and write your program accordingly.)
from the true beginning.
@end group
@group
-Don’t use this in Lisp programs!
+Don't use this in Lisp programs!
\(goto-char (point-min)) is faster
and does not set the mark."
(interactive "P")
@smallexample
@group
(defun zap-to-char (arg char)
- "Kill up to and including ARG’th occurrence of CHAR.
-Case is ignored if ‘case-fold-search’ is non-nil in the current buffer.
+ "Kill up to and including ARG'th occurrence of CHAR.
+Case is ignored if `case-fold-search' is non-nil in the current buffer.
Goes backward if ARG is negative; error if CHAR not found."
(interactive "p\ncZap to char: ")
(if (char-table-p translation-table-for-input)
The documentation is thorough. You do need to know the jargon meaning
of the word ``kill''.
+@cindex curved quotes
+@cindex curly quotes
+The version 22 documentation string for @code{zap-to-char} uses ASCII
+grave accent and apostrophe to quote a symbol, so it appears as
+@t{`case-fold-search'}. This quoting style was inspired by 1970s-era
+displays in which grave accent and apostrophe were often mirror images
+suitable for use as quotes. On most modern displays this is no longer
+true, and when these two ASCII characters appear in documentation
+strings or diagnostic message formats, Emacs typically transliterates
+them to curved single quotes, so that the abovequoted symbol appears
+as @t{‘case-fold-search’}. Source-code strings can also simply use
+curved quotes directly.
+
@node zap-to-char interactive
@subsection The @code{interactive} Expression
In Lisp code, optional third arg YANK-HANDLER, if non-nil,
specifies the yank-handler text property to be set on the killed
-text. See ‘insert-for-yank’."
+text. See `insert-for-yank'."
;; Pass point first, then mark, because the order matters
;; when calling kill-append.
(interactive (list (point) (mark)))
@smallexample
@group
(defun copy-region-as-kill (beg end)
- "Save the region as if killed, but don’t kill it.
+ "Save the region as if killed, but don't kill it.
In Transient Mark mode, deactivate the mark.
-If ‘interprogram-cut-function’ is non-nil, also save the text for a window
+If `interprogram-cut-function' is non-nil, also save the text for a window
system cut and paste."
(interactive "r")
@end group
@unnumberedsubsubsec The @code{kill-new} function
@findex kill-new
-@c in GNU Emacs 22, additional documentation to kill-new:
-@ignore
-Optional third arguments YANK-HANDLER controls how the STRING is later
-inserted into a buffer; see `insert-for-yank' for details.
-When a yank handler is specified, STRING must be non-empty (the yank
-handler, if non-nil, is stored as a `yank-handler' text property on STRING).
-
-When the yank handler has a non-nil PARAM element, the original STRING
-argument is not used by `insert-for-yank'. However, since Lisp code
-may access and use elements from the kill ring directly, the STRING
-argument should still be a \"useful\" string for such uses."
-@end ignore
@need 1200
-The @code{kill-new} function looks like this:
+In version 22 the @code{kill-new} function looks like this:
@smallexample
@group
(defun kill-new (string &optional replace yank-handler)
"Make STRING the latest kill in the kill ring.
-Set ‘kill-ring-yank-pointer’ to point to it.
+Set `kill-ring-yank-pointer' to point to it.
-If `interprogram-cut-function’ is non-nil, apply it to STRING.
+If `interprogram-cut-function' is non-nil, apply it to STRING.
Optional second argument REPLACE non-nil means that STRING will replace
the front of the kill ring, rather than being added to the list.
@dots{}"
(defun current-kill (n &optional do-not-move)
"Rotate the yanking point by N places, and then return that kill.
-If N is zero, ‘interprogram-paste-function’ is set, and calling it
+If N is zero, `interprogram-paste-function' is set, and calling it
returns a string, then that string is added to the front of the
kill ring and returned as the latest kill.
-If optional arg DO-NOT-MOVE is non-nil, then don’t actually move the
+If optional arg DO-NOT-MOVE is non-nil, then don't actually move the
yanking point; just return the Nth kill forward."
(let ((interprogram-paste (and (= n 0)
interprogram-paste-function
@smallexample
@group
(defun forward-sentence (&optional arg)
- "Move forward to next ‘sentence-end’. With argument, repeat.
-With negative argument, move backward repeatedly to ‘sentence-beginning’.
+ "Move forward to next end of sentence. With argument, repeat.
+With negative argument, move backward repeatedly to start of sentence.
-The variable ‘sentence-end’ is a regular expression that matches ends of
+The variable `sentence-end' is a regular expression that matches ends of
sentences. Also, every paragraph boundary terminates sentences as well."
@end group
@group
@smallexample
@group
(defun load-library (library)
- "Load the library named LIBRARY.
-This is an interface to the function ‘load’."
+ "Load the Emacs Lisp library named LIBRARY.
+This is an interface to the function `load'. LIBRARY is searched
+for in `load-path', both with and without `load-suffixes' (as
+well as `load-file-rep-suffixes').
+
+See Info node `(emacs)Lisp Libraries' for more details.
+See `load-file' for a different interface to `load'."
(interactive
(list (completing-read "Load library: "
(apply-partially 'locate-file-completion-table
@group
(defun current-kill (n &optional do-not-move)
"Rotate the yanking point by N places, and then return that kill.
-If N is zero, ‘interprogram-paste-function’ is set, and calling it
-returns a string, then that string is added to the front of the
-kill ring and returned as the latest kill.
+If N is zero and `interprogram-paste-function' is set to a
+function that returns a string or a list of strings, and if that
+function doesn't return nil, then that string (or list) is added
+to the front of the kill ring and the string (or first string in
+the list) is returned as the latest kill.
@end group
@group
-If optional arg DO-NOT-MOVE is non-nil, then don’t actually move the
-yanking point; just return the Nth kill forward."
+If N is not zero, and if `yank-pop-change-selection' is
+non-nil, use `interprogram-cut-function' to transfer the
+kill at the new yank point into the window system selection.
+@end group
+@group
+If optional arg DO-NOT-MOVE is non-nil, then don't actually
+move the yanking point; just return the Nth kill forward."
+
(let ((interprogram-paste (and (= n 0)
interprogram-paste-function
(funcall interprogram-paste-function))))
;; text to the kill ring, so Emacs doesn't try to own the
;; selection, with identical text.
(let ((interprogram-cut-function nil))
- (kill-new interprogram-paste))
- interprogram-paste)
+ (if (listp interprogram-paste)
+ (mapc 'kill-new (nreverse interprogram-paste))
+ (kill-new interprogram-paste)))
+ (car kill-ring))
@end group
@group
(or kill-ring (error "Kill ring is empty"))
(nthcdr (mod (- n (length kill-ring-yank-pointer))
(length kill-ring))
kill-ring)))
- (or do-not-move
- (setq kill-ring-yank-pointer ARGth-kill-element))
+ (unless do-not-move
+ (setq kill-ring-yank-pointer ARGth-kill-element)
+ (when (and yank-pop-change-selection
+ (> n 0)
+ interprogram-cut-function)
+ (funcall interprogram-cut-function (car ARGth-kill-element))))
(car ARGth-kill-element)))))
@end group
@end smallexample
"Reinsert (\"paste\") the last stretch of killed text.
More precisely, reinsert the stretch of killed text most recently
killed OR yanked. Put point at end, and set mark at beginning.
-With just \\[universal-argument] as argument, same but put point at
-beginning (and mark at end). With argument N, reinsert the Nth most
-recently killed stretch of killed text.
+With just \\[universal-argument] as argument, same but put point at beginning (and mark at end).
+With argument N, reinsert the Nth most recently killed stretch of killed
+text.
When this command inserts killed text into the buffer, it honors
-‘yank-excluded-properties’ and ‘yank-handler’ as described in the
-doc string for ‘insert-for-yank-1’, which see.
+`yank-excluded-properties' and `yank-handler' as described in the
+doc string for `insert-for-yank-1', which see.
-See also the command \\[yank-pop]."
+See also the command `yank-pop' (\\[yank-pop])."
@end group
@group
(interactive "*P")
((eq arg '-) -2)
(t (1- arg)))))
(if (consp arg)
- ;; This is like exchange-point-and-mark,
- ;; but doesn't activate the mark.
+ ;; This is like exchange-point-and-mark, but doesn't activate the mark.
;; It is cleaner to avoid activation, even though the command
;; loop would deactivate the mark because we inserted text.
(goto-char (prog1 (mark t)
\f
* Changes in Specialized Modes and Packages in Emacs 25.1
+** You can recompute the VC state of a file buffer with `M-x vc-refresh-state'
** Prog mode has some support for multi-mode indentation.
See `prog-indentation-context' and `prog-widen'.
\f
* Lisp Changes in Emacs 25.1
+** New hooks prefix-command-echo-keystrokes-functions and
+prefix-command-preserve-state-hook, to allow the definition of prefix
+commands other than the predefined C-u.
+
** New functions `filepos-to-bufferpos' and `bufferpos-to-filepos'.
** The default value of `load-read-function' is now `read'.
will be stored in that character's register.
For example, use this to define the golden ratio number:
- (setq calculator-user-registers '((?g . 1.61803398875)))
+ (setq calculator-user-registers \\='((?g . 1.61803398875)))
before you load calculator."
:type '(repeat (cons character number))
:set (lambda (_ val)
t as a prefix key:
(setq calculator-user-operators
- '((\"tf\" cl-to-fr (+ 32 (/ (* X 9) 5)) 1)
+ \\='((\"tf\" cl-to-fr (+ 32 (/ (* X 9) 5)) 1)
(\"tc\" fr-to-cl (/ (* (- X 32) 5) 9) 1)
(\"tp\" kg-to-lb (/ X 0.453592) 1)
(\"tk\" lb-to-kg (* X 0.453592) 1)
version of `X' and `F' for a recursive call. Here is a [very
inefficient] Fibonacci number calculation:
- (add-to-list 'calculator-user-operators
- '(\"F\" fib
+ (add-to-list \\='calculator-user-operators
+ \\='(\"F\" fib
(if (<= TX 1) 1 (+ (F (- TX 1)) (F (- TX 2))))))
Note that this will be either postfix or prefix, according to
For example, if daylight saving time ends on the last Sunday in October:
- '(calendar-nth-named-day -1 0 10 year)
+ (calendar-nth-named-day -1 0 10 year)
If the locale never uses daylight saving time, set this to nil."
:type 'sexp
(setq calendar-week-start-day 1
calendar-intermonth-text
- '(propertize
+ \\='(propertize
(format \"%2d\"
(car
(calendar-iso-from-absolute
(calendar-absolute-from-gregorian (list month day year)))))
- 'font-lock-face 'font-lock-function-name-face))
+ \\='font-lock-face \\='font-lock-function-name-face))
See also `calendar-intermonth-header'."
:group 'calendar
specific to a major mode. For example, in jde mode:
\(defvar-mode-local jde-mode semantic-idle-summary-out-of-context-faces
- (append (default-value 'semantic-idle-summary-out-of-context-faces)
- '(jde-java-font-lock-doc-tag-face
+ (append (default-value \\='semantic-idle-summary-out-of-context-faces)
+ \\='(jde-java-font-lock-doc-tag-face
jde-java-font-lock-link-face
jde-java-font-lock-bold-face
jde-java-font-lock-underline-face
For example, the MH-E package updates this alist as follows:
- (add-to-list 'customize-package-emacs-version-alist
- '(MH-E (\"6.0\" . \"22.1\") (\"6.1\" . \"22.1\")
+ (add-to-list \\='customize-package-emacs-version-alist
+ \\='(MH-E (\"6.0\" . \"22.1\") (\"6.1\" . \"22.1\")
(\"7.0\" . \"22.1\") (\"7.1\" . \"22.1\")
(\"7.2\" . \"22.1\") (\"7.3\" . \"22.1\")
(\"7.4\" . \"22.1\") (\"8.0\" . \"22.1\")))
automatically to preserve proper execution order of the arguments.
For example:
- (defsetf nth (n x) (v) `(setcar (nthcdr ,n ,x) ,v))
+ (defsetf nth (n x) (v) \\=`(setcar (nthcdr ,n ,x) ,v))
You can replace this form with `gv-define-setter'.
"Make a new instance of CLASS based on INITARGS.
For example:
- (make-instance 'foo)
+ (make-instance \\='foo)
INITARGS is a property list with keywords based on the `:initarg'
for each slot. For example:
- (make-instance 'foo :slot1 value1 :slotN valueN)")
+ (make-instance \\='foo :slot1 value1 :slotN valueN)")
(define-obsolete-function-alias 'constructor #'make-instance "25.1")
effect.
Major modes should modify this variable using `add-function', for example:
- (add-function :before-until (local 'eldoc-documentation-function)
- #'foo-mode-eldoc-function)
+ (add-function :before-until (local \\='eldoc-documentation-function)
+ #\\='foo-mode-eldoc-function)
so that the global documentation function (i.e. the default value of the
variable) is taken into account if the major mode specific function does not
return any documentation.")
The first arg in ARGLIST (the one that receives VAL) receives an expression
which can do arbitrary things, whereas the other arguments are all guaranteed
to be pure and copyable. Example use:
- (gv-define-setter aref (v a i) `(aset ,a ,i ,v))"
+ (gv-define-setter aref (v a i) \\=`(aset ,a ,i ,v))"
(declare (indent 2) (debug (&define name sexp body)))
`(gv-define-expander ,name
(lambda (do &rest args)
(defvar cua--prefix-override-timer nil)
(defvar cua--prefix-override-length nil)
-(defun cua--prefix-override-replay (arg repeat)
+(defun cua--prefix-override-replay (repeat)
(let* ((keys (this-command-keys))
(i (length keys))
(key (aref keys (1- i))))
;; Don't record this command
(setq this-command last-command)
;; Restore the prefix arg
- (setq prefix-arg arg)
- (reset-this-command-lengths)
+ ;; This should make it so that exchange-point-and-mark gets the prefix when
+ ;; you do C-u C-x C-x C-x work (where the C-u is properly passed to the C-x
+ ;; C-x binding after the first C-x C-x was rewritten to just C-x).
+ (prefix-command-preserve-state)
;; Push the key back on the event queue
(setq unread-command-events (cons key unread-command-events))))
-(defun cua--prefix-override-handler (arg)
+(defun cua--prefix-override-handler ()
"Start timer waiting for prefix key to be followed by another key.
Repeating prefix key when region is active works as a single prefix key."
- (interactive "P")
- (cua--prefix-override-replay arg 0))
+ (interactive)
+ (cua--prefix-override-replay 0))
-(defun cua--prefix-repeat-handler (arg)
+(defun cua--prefix-repeat-handler ()
"Repeating prefix key when region is active works as a single prefix key."
- (interactive "P")
- (cua--prefix-override-replay arg 1))
+ (interactive)
+ (cua--prefix-override-replay 1))
(defun cua--prefix-copy-handler (arg)
"Copy region/rectangle, then replay last key."
(when (= (length (this-command-keys)) cua--prefix-override-length)
(setq unread-command-events (cons 'timeout unread-command-events))
(if prefix-arg
- (reset-this-command-lengths)
+ nil
+ ;; FIXME: Why?
(setq overriding-terminal-local-map nil))
(cua--select-keymaps)))
(call-interactively this-command))
(defun cua--keep-active ()
- (setq mark-active t
- deactivate-mark nil))
+ (when (mark t)
+ (setq mark-active t
+ deactivate-mark nil)))
(defun cua--deactivate (&optional now)
(if (not now)
(cond ((null cua-enable-cua-keys)
(exchange-point-and-mark arg))
(arg
- (setq mark-active t))
+ (when (mark t) (setq mark-active t)))
(t
(let (mark-active)
(exchange-point-and-mark)
(defvar cua--keymaps-initialized nil)
-(defun cua--shift-control-prefix (prefix arg)
+(defun cua--shift-control-prefix (prefix)
;; handle S-C-x and S-C-c by emulating the fast double prefix function.
;; Don't record this command
(setq this-command last-command)
;; Restore the prefix arg
- (setq prefix-arg arg)
- (reset-this-command-lengths)
+ ;; This should make it so that exchange-point-and-mark gets the prefix when
+ ;; you do C-u S-C-x C-x work (where the C-u is properly passed to the C-x
+ ;; C-x binding after the first S-C-x was rewritten to just C-x).
+ (prefix-command-preserve-state)
;; Activate the cua--prefix-repeat-keymap
(setq cua--prefix-override-timer 'shift)
;; Push duplicate keys back on the event queue
- (setq unread-command-events (cons prefix (cons prefix unread-command-events))))
+ (setq unread-command-events
+ (cons prefix (cons prefix unread-command-events))))
-(defun cua--shift-control-c-prefix (arg)
- (interactive "P")
- (cua--shift-control-prefix ?\C-c arg))
+(defun cua--shift-control-c-prefix ()
+ (interactive)
+ (cua--shift-control-prefix ?\C-c))
-(defun cua--shift-control-x-prefix (arg)
- (interactive "P")
- (cua--shift-control-prefix ?\C-x arg))
+(defun cua--shift-control-x-prefix ()
+ (interactive)
+ (cua--shift-control-prefix ?\C-x))
(defun cua--init-keymaps ()
;; Cache actual rectangle modifier key.
Would expand to:
(prog2
- (defvar erc-server-311-functions 'erc-server-311
+ (defvar erc-server-311-functions \\='erc-server-311
\"Some non-generic variable documentation.
Hook called upon receiving a 311 server response.
numbers between LOW and HIGH (inclusive) is returned.
As an example:
- (erc-ports-list '(1)) => (1)
- (erc-ports-list '((1 5))) => (1 2 3 4 5)
- (erc-ports-list '(1 (3 5))) => (1 3 4 5)"
+ (erc-ports-list \\='(1)) => (1)
+ (erc-ports-list \\='((1 5))) => (1 2 3 4 5)
+ (erc-ports-list \\='(1 (3 5))) => (1 3 4 5)"
(let (result)
(dolist (p ports)
(cond ((numberp p)
;; indent-tabs-mode: t
;; tab-width: 8
;; End:
-
Example of use:
(setq erc-nickserv-passwords
- '((freenode ((\"nick-one\" . \"password\")
+ \\='((freenode ((\"nick-one\" . \"password\")
(\"nick-two\" . \"password\")))
(DALnet ((\"nick\" . \"password\")))))"
:group 'erc-services
As an example:
(setq erc-quit-reason-various-alist
- '((\"xmms\" dme:now-playing)
+ \\='((\"xmms\" dme:now-playing)
(\"version\" erc-quit-reason-normal)
(\"home\" \"Gone home !\")
(\"^$\" \"Default Reason\")))
As an example:
(setq erc-part-reason-various-alist
- '((\"xmms\" dme:now-playing)
+ \\='((\"xmms\" dme:now-playing)
(\"version\" erc-part-reason-normal)
(\"home\" \"Gone home !\")
(\"^$\" \"Default Reason\")))
For example, OPTIONS might look like:
- '((?C nil nil multi-column \"multi-column display\")
+ ((?C nil nil multi-column \"multi-column display\")
(nil \"help\" nil nil \"show this usage display\")
(?r \"reverse\" nil reverse-list \"reverse order while sorting\")
:external \"ls\"
Caveat: Fileset names have to be unique.
Example definition:
- '\(\(\"My Wiki\"
+ \\='\(\(\"My Wiki\"
\(:ingroup \"~/Etc/My-Wiki/WikiContents\"))
\(\"My Homepage\"
\(:pattern \"~/public_html/\" \"^.+\\\\.html$\")
For example:
- (font-lock-add-keywords 'c-mode
- '((\"\\\\\\=<\\\\(FIXME\\\\):\" 1 'font-lock-warning-face prepend)
- (\"\\\\\\=<\\\\(and\\\\|or\\\\|not\\\\)\\\\\\=>\" . 'font-lock-keyword-face)))
+ (font-lock-add-keywords \\='c-mode
+ \\='((\"\\\\\\=<\\\\(FIXME\\\\):\" 1 \\='font-lock-warning-face prepend)
+ (\"\\\\\\=<\\\\(and\\\\|or\\\\|not\\\\)\\\\\\=>\" . \\='font-lock-keyword-face)))
adds two fontification patterns for C mode, to fontify `FIXME:' words, even in
comments, and to fontify `and', `or' and `not' words as keywords.
If ADDRESS matches author's mail address, it will remove things like
advertisements. For example:
-\((\"@yoo-hoo\\\\.co\\\\.jp\\\\'\" . \"\\n_+\\nDo You Yoo-hoo!\\\\?\\n.*\\n.*\\n\"))
+\((\"@yoo-hoo\\\\.co\\\\.jp\\\\\\='\" . \"\\n_+\\nDo You Yoo-hoo!\\\\?\\n.*\\n.*\\n\"))
"
:type '(repeat
(cons
;; Specify the altitude of Face images in the From header.
\(setq gnus-face-properties-alist
- '((pbm . (:face gnus-x-face :ascent 80))
+ \\='((pbm . (:face gnus-x-face :ascent 80))
(png . (:ascent 80))))
;; Show Face images as pressed buttons.
\(setq gnus-face-properties-alist
- '((pbm . (:face gnus-x-face :relief -2))
+ \\='((pbm . (:face gnus-x-face :relief -2))
(png . (:relief -2))))
See the manual for the valid properties for various image types.
For example:
\(setq gnus-newsgroup-variables
- '(message-use-followup-to
+ \\='(message-use-followup-to
(gnus-visible-headers .
\"^From:\\\\|^Newsgroups:\\\\|^Subject:\\\\|^Date:\\\\|^To:\")))
")
(string-equal (downcase str1) (downcase prefix))
(string-equal str1 prefix))))))
-(if (fboundp 'format-message)
- (defalias 'gnus-format-message 'format-message)
- ;; for Emacs < 25, and XEmacs, don't worry about quote translation.
- (defalias 'gnus-format-message 'format))
+(defalias 'gnus-format-message
+ (if (fboundp 'format-message) 'format-message
+ ;; for Emacs < 25, and XEmacs, don't worry about quote translation.
+ 'format))
;; Simple check: can be a macro but this way, although slow, it's really clear.
;; We don't use `bound-and-true-p' because it's not in XEmacs.
scheme might appear somewhat weird at a first glance, it is very powerful.
In order to make this clear, here are some examples:
-- '(0 . day): this is the default value of `nndiary-reminders'. It means
+- (0 . day): this is the default value of `nndiary-reminders'. It means
pop up the appointments of the day each morning at 00:00.
-- '(1 . day): this means pop up the appointments the day before, at 00:00.
+- (1 . day): this means pop up the appointments the day before, at 00:00.
-- '(6 . hour): for an appointment at 18:30, this would pop up the
+- (6 . hour): for an appointment at 18:30, this would pop up the
appointment message at 12:00.
-- '(360 . minute): for an appointment at 18:30 and 15 seconds, this would
+- (360 . minute): for an appointment at 18:30 and 15 seconds, this would
pop up the appointment message at 12:30."
:group 'nndiary
:type '(repeat (cons :format "%v\n"
Example:
\(setq nnmail-fancy-expiry-targets
- '((to-from \"boss\" \"nnfolder:Work\")
+ \\='((to-from \"boss\" \"nnfolder:Work\")
(\"Subject\" \"IMPORTANT\" \"nnfolder:IMPORTANT.%Y.%b\")
(\"from\" \".*\" \"nnfolder:Archive-%Y\")))
junk: Mail will be deleted. Use with care! Do not submerge in water!
Example:
(setq nnmail-split-fancy
- '(| (\"Subject\" \"MAKE MONEY FAST\" junk)
+ \\='(| (\"Subject\" \"MAKE MONEY FAST\" junk)
...other.rules.omitted...))
FIELD must match a complete field name. VALUE must match a complete
Examples of image filename patterns to match:
file://foo.png
- `file://foo.png'
+ \\=`file://foo.png\\='
\\[\\[foo.gif]]
<foo.png>
foo.JPG
(defun deprefixify-iso8859-2-region (start end)
(interactive \"*r\")
(ogonek-deprefixify-region start end ?/ \"iso8859-2\"))
- (global-set-key \"\\C-cd\" 'deprefixify-iso8859-2-region) ; ctrl-c d
+ (global-set-key \"\\C-cd\" \\='deprefixify-iso8859-2-region) ; ctrl-c d
(defun mazovia-to-iso8859-2 (start end)
(interactive \"*r\")
(ogonek-recode-region start end \"mazovia\" \"iso8859-2\"))
- (global-set-key \"\\C-cr\" 'mazovia-to-iso8859-2) ; ctrl-c r
+ (global-set-key \"\\C-cr\" \\='mazovia-to-iso8859-2) ; ctrl-c r
(defun prefixify-iso8859-2-region (start end)
(interactive \"*r\")
(ogonek-prefixify-region start end \"iso8859-2\" ?/))
- (global-set-key \"\\C-cp\" 'prefixify-iso8859-2-region) ; ctrl-c p
+ (global-set-key \"\\C-cp\" \\='prefixify-iso8859-2-region) ; ctrl-c p
Each recoding operation can be called off using the `undo' command.")
(defvar kmacro-step-edit-inserting) ;; inserting into macro
(defvar kmacro-step-edit-appending) ;; append to end of macro
(defvar kmacro-step-edit-replace) ;; replace orig macro when done
-(defvar kmacro-step-edit-prefix-index) ;; index of first prefix arg key
(defvar kmacro-step-edit-key-index) ;; index of current key
(defvar kmacro-step-edit-action) ;; automatic action on next pre-command hook
(defvar kmacro-step-edit-help) ;; kmacro step edit help enabled
following additional answers: `insert', `insert-1', `replace', `replace-1',
`append', `append-end', `act-repeat', `skip-end', `skip-keep'.")
-(defvar kmacro-step-edit-prefix-commands
- '(universal-argument universal-argument-more universal-argument-minus
- digit-argument negative-argument)
- "Commands which build up a prefix arg for the current command.")
-
(defun kmacro-step-edit-prompt (macro index)
;; Show step-edit prompt
(let ((keys (and (not kmacro-step-edit-appending)
;; Handle prefix arg, or query user
(cond
(act act) ;; set above
- ((memq this-command kmacro-step-edit-prefix-commands)
- (unless kmacro-step-edit-prefix-index
- (setq kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
- (setq act 'universal-argument))
- ((eq this-command 'universal-argument-other-key)
- (setq act 'universal-argument))
(t
- (kmacro-step-edit-prompt macro (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
+ (kmacro-step-edit-prompt macro kmacro-step-edit-key-index)
(setq act (lookup-key kmacro-step-edit-map
(vector (with-current-buffer (current-buffer) (read-event))))))))
;; Resume macro execution and perform the action
(cond
- ((eq act 'universal-argument)
- nil)
((cond
((eq act 'act)
t)
(setq kmacro-step-edit-active 'ignore)
nil)
((eq act 'skip)
- (setq kmacro-step-edit-prefix-index nil)
nil)
((eq act 'skip-keep)
(setq this-command 'ignore)
(setq act t)
t)
((member act '(insert-1 insert))
- (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
+ (setq executing-kbd-macro-index kmacro-step-edit-key-index)
(setq kmacro-step-edit-inserting (if (eq act 'insert-1) 1 t))
nil)
((member act '(replace-1 replace))
(setq kmacro-step-edit-inserting (if (eq act 'replace-1) 1 t))
- (setq kmacro-step-edit-prefix-index nil)
(if (= executing-kbd-macro-index (length executing-kbd-macro))
(setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
kmacro-step-edit-appending t))
(setq act t)
t)
((eq act 'help)
- (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
+ (setq executing-kbd-macro-index kmacro-step-edit-key-index)
(setq kmacro-step-edit-help (not kmacro-step-edit-help))
nil)
(t ;; Ignore unknown responses
- (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
+ (setq executing-kbd-macro-index kmacro-step-edit-key-index)
nil))
- (if (> executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
+ (if (> executing-kbd-macro-index kmacro-step-edit-key-index)
(setq kmacro-step-edit-new-macro
(vconcat kmacro-step-edit-new-macro
(substring executing-kbd-macro
- (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
- (if (eq act t) nil executing-kbd-macro-index)))
- kmacro-step-edit-prefix-index nil))
+ kmacro-step-edit-key-index
+ (if (eq act t) nil
+ executing-kbd-macro-index)))))
(if restore-index
(setq executing-kbd-macro-index restore-index)))
(t
(executing-kbd-macro nil)
(defining-kbd-macro nil)
cmd keys next-index)
- (setq executing-kbd-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
- kmacro-step-edit-prefix-index nil)
+ (setq executing-kbd-macro-index kmacro-step-edit-key-index)
(kmacro-step-edit-prompt macro nil)
;; Now, we have read a key sequence from the macro, but we don't want
;; to execute it yet. So push it back and read another sequence.
- (reset-this-command-lengths)
(setq keys (read-key-sequence nil nil nil nil t))
(setq cmd (key-binding keys t nil))
(if (cond
unread-command-events nil)))
(setq cmd 'ignore)
nil)
- ((memq cmd kmacro-step-edit-prefix-commands)
- (reset-this-command-lengths)
- nil)
- ((eq cmd 'universal-argument-other-key)
- (setq kmacro-step-edit-action t)
- (reset-this-command-lengths)
- (if (numberp kmacro-step-edit-inserting)
- (setq kmacro-step-edit-inserting nil))
- nil)
((numberp kmacro-step-edit-inserting)
(setq kmacro-step-edit-inserting nil)
nil)
((equal keys "\C-j")
(setq kmacro-step-edit-inserting nil)
(setq kmacro-step-edit-action nil)
- ;; Forget any (partial) prefix arg from next command
- (setq kmacro-step-edit-prefix-index nil)
- (reset-this-command-lengths)
- (setq overriding-terminal-local-map nil)
(setq next-index kmacro-step-edit-key-index)
t)
(t nil))
(kmacro-step-edit-inserting nil)
(kmacro-step-edit-appending nil)
(kmacro-step-edit-replace t)
- (kmacro-step-edit-prefix-index nil)
(kmacro-step-edit-key-index 0)
(kmacro-step-edit-action nil)
(kmacro-step-edit-help nil)
Example:
\(msb--aggregate-alist
- '((a . a1) (a . a2) (b . b1) (c . c3) (a . a4) (a . a3) (b . b3) (b . b2))
+ \\='((a . a1) (a . a2) (b . b1) (c . c3) (a . a4) (a . a3) (b . b3) (b . b2))
(function string=)
(lambda (item1 item2)
(string< (symbol-name item1) (symbol-name item2))))
\(dbus-call-method-asynchronously
:system \"org.freedesktop.Hal\" \"/org/freedesktop/Hal/devices/computer\"
- \"org.freedesktop.Hal.Device\" \"GetPropertyString\" 'message
+ \"org.freedesktop.Hal.Device\" \"GetPropertyString\" \\='message
\"system.kernel.machine\")
=> \(:serial :system 2)
\(dbus-register-signal
:system \"org.freedesktop.Hal\" \"/org/freedesktop/Hal/Manager\"
- \"org.freedesktop.Hal.Manager\" \"DeviceAdded\" 'my-signal-handler)
+ \"org.freedesktop.Hal.Manager\" \"DeviceAdded\" \\='my-signal-handler)
=> \(\(:signal :system \"org.freedesktop.Hal.Manager\" \"DeviceAdded\")
\(\"org.freedesktop.Hal\" \"/org/freedesktop/Hal/Manager\" my-signal-handler))
:type 'string
:group 'tls)
-(eval-and-compile
- (if (fboundp 'format-message)
- (defalias 'tls-format-message 'format-message)
+(defalias 'tls-format-message
+ (if (fboundp 'format-message) 'format-message
;; for Emacs < 25, and XEmacs, don't worry about quote translation.
- (defalias 'tls-format-message 'format)))
+ 'format))
(defun tls-certificate-information (der)
"Parse X.509 certificate in DER format into an assoc list."
(add-to-list 'tramp-methods
'("sudo"
(tramp-login-program "sudo")
- (tramp-login-args (("-u" "%u") ("-s") ("-H") ("-p" "Password:")))
+ ;; The password template must be masked. Otherwise, it could be
+ ;; interpreted as password prompt if the remote host echoes the command.
+ (tramp-login-args (("-u" "%u") ("-s") ("-H")
+ ("-p" "P\"\"a\"\"s\"\"s\"\"w\"\"o\"\"r\"\"d\"\":")))
;; Local $SHELL could be a nasty one, like zsh or fish. Let's override it.
(tramp-login-env (("SHELL") ("/bin/sh")))
(tramp-remote-shell "/bin/sh")
;; However, I don't know whether all base64 versions do supports
;; this option.
(b64 "base64" "base64 -d")
+ (b64 "openssl enc -base64" "openssl enc -d -base64")
(b64 "mimencode -b" "mimencode -u -b")
(b64 "mmencode -b" "mmencode -u -b")
(b64 "recode data..base64" "recode base64..data")
(tramp-set-completion-function
\"ssh\"
- '((tramp-parse-sconfig \"/etc/ssh_config\")
+ \\='((tramp-parse-sconfig \"/etc/ssh_config\")
(tramp-parse-sconfig \"~/.ssh/config\")))"
(let ((r function-list)
;;;###tramp-autoload
(defun tramp-clear-passwd (vec)
"Clear password cache for connection related to VEC."
+ (let ((hop (tramp-file-name-hop vec)))
+ (when hop
+ ;; Clear also the passwords of the hops.
+ (tramp-clear-passwd
+ (tramp-dissect-file-name
+ (concat
+ tramp-prefix-format
+ (tramp-compat-replace-regexp-in-string
+ (concat tramp-postfix-hop-regexp "$")
+ tramp-postfix-host-format hop))))))
(tramp-compat-funcall
'password-cache-remove
(tramp-make-tramp-file-name
This is exactly like `sregexq' (q.v.) except that it evaluates all its
arguments, so literal sregex clauses must be quoted. For example:
- (sregex '(or \"Bob\" \"Robert\")) => \"Bob\\\\|Robert\"
+ (sregex \\='(or \"Bob\" \"Robert\")) => \"Bob\\\\|Robert\"
An argument-evaluating sregex interpreter lets you reuse sregex
subexpressions:
- (let ((dotstar '(0+ any))
- (whitespace '(1+ (syntax ?-)))
- (digits '(1+ (char (?0 . ?9)))))
- (sregex 'bol dotstar \":\" whitespace digits)) => \"^.*:\\\\s-+[0-9]+\""
+ (let ((dotstar \\='(0+ any))
+ (whitespace \\='(1+ (syntax ?-)))
+ (digits \\='(1+ (char (?0 . ?9)))))
+ (sregex \\='bol dotstar \":\" whitespace digits)) => \"^.*:\\\\s-+[0-9]+\""
(sregex--sequence exps nil))
(defmacro sregexq (&rest exps)
"Alist of characters and custom functions for bulk actions.
For example, this value makes those two functions available:
- '((?R set-category)
- (?C bulk-cut))
+ ((?R set-category)
+ (?C bulk-cut))
With selected entries in an agenda buffer, `B R' will call
the custom function `set-category' on the selected entries.
`todo' and `nottodo' accept as an argument a list of todo
keywords, which may include \"*\" to match any todo keyword.
- (org-agenda-skip-entry-if 'todo '(\"TODO\" \"WAITING\"))
+ (org-agenda-skip-entry-if \\='todo \\='(\"TODO\" \"WAITING\"))
would skip all entries with \"TODO\" or \"WAITING\" keywords.
Instead of a list, a keyword class may be given. For example:
- (org-agenda-skip-entry-if 'nottodo 'done)
+ (org-agenda-skip-entry-if \\='nottodo \\='done)
would skip entries that haven't been marked with any of \"DONE\"
keywords. Possible classes are: `todo', `done', `any'.
argument: an entry from `org-agenda-get-day-entries'.
FILTER can also be an alist with the car of each cell being
-either 'headline or 'category. For example:
+either `headline' or `category'. For example:
- '((headline \"IMPORTANT\")
- (category \"Work\"))
+ ((headline \"IMPORTANT\")
+ (category \"Work\"))
will only add headlines containing IMPORTANT or headlines
belonging to the \"Work\" category.
Example:
(setq org-protocol-project-alist
- '((\"http://orgmode.org/worg/\"
+ \\='((\"http://orgmode.org/worg/\"
:online-suffix \".php\"
:working-suffix \".org\"
:base-url \"http://orgmode.org/worg/\"
Here is an example:
(setq org-protocol-protocol-alist
- '((\"my-protocol\"
+ \\='((\"my-protocol\"
:protocol \"my-protocol\"
:function my-protocol-handler-function)
(\"your-protocol\"
For example:
\(setq org-html-table-row-tags
- (cons '(cond (top-row-p \"<tr class=\\\"tr-top\\\">\")
+ (cons \\='(cond (top-row-p \"<tr class=\\\"tr-top\\\">\")
(bottom-row-p \"<tr class=\\\"tr-bottom\\\">\")
(t (if (= (mod row-number 2) 1)
\"<tr class=\\\"tr-odd\\\">\"
within each set. For example in texinfo mode:
(setq outline-heading-alist
- '((\"@chapter\" . 2) (\"@section\" . 3) (\"@subsection\" . 4)
+ \\='((\"@chapter\" . 2) (\"@section\" . 3) (\"@subsection\" . 4)
(\"@subsubsection\" . 5)
(\"@unnumbered\" . 2) (\"@unnumberedsec\" . 3)
(\"@unnumberedsubsec\" . 4) (\"@unnumberedsubsubsec\" . 5)
* On GNU or Unix system:
- '((unix \".\" \"~/bin\" ghostview mpage PATH)
+ ((unix \".\" \"~/bin\" ghostview mpage PATH)
(ghostview \"$HOME/bin/gsview-dir\")
(mpage \"$HOME/bin/mpage-dir\")
)
* On Windows system:
- '((windows \"c:/applications/executables\" PATH ghostview mpage)
+ ((windows \"c:/applications/executables\" PATH ghostview mpage)
(ghostview \"c:/gs/gsview-dir\")
(mpage \"c:/mpage-dir\")
)"
SYMBOL It's a symbol to identify a text printer. It's for
setting option `pr-txt-name' and for menu selection.
Examples:
- 'prt_06a
- 'my_printer
+ prt_06a
+ my_printer
COMMAND Name of the program for printing a text file. On MS-DOS and
MS-Windows systems, if the value is an empty string, then Emacs
instead of including an explicit switch on this list.
Example:
. for lpr
- '(\"-#3\" \"-l\")
+ (\"-#3\" \"-l\")
nil
NAME A string that specifies a text printer name.
* On GNU or Unix system:
- '((prt_06a \"lpr\" nil \"prt_06a\")
+ ((prt_06a \"lpr\" nil \"prt_06a\")
(prt_07c nil nil \"prt_07c\")
)
* On Windows system:
- '((prt_06a \"print\" nil \"/D:\\\\\\\\printers\\\\prt_06a\")
+ ((prt_06a \"print\" nil \"/D:\\\\\\\\printers\\\\prt_06a\")
(prt_07c nil nil \"/D:\\\\\\\\printers\\\\prt_07c\")
(PRN \"\" nil \"PRN\")
(standard \"redpr.exe\" nil \"\")
SYMBOL It's a symbol to identify a PostScript printer. It's for
setting option `pr-ps-name' and for menu selection.
Examples:
- 'prt_06a
- 'my_printer
+ prt_06a
+ my_printer
COMMAND Name of the program for printing a PostScript file. On MS-DOS
and MS-Windows systems, if the value is an empty string then
instead of including an explicit switch on this list.
Example:
. for lpr
- '(\"-#3\" \"-l\")
+ (\"-#3\" \"-l\")
nil
. for gsprint.exe
- '(\"-all\" \"-twoup\")
+ (\"-all\" \"-twoup\")
PRINTER-SWITCH A string that specifies PostScript printer name switch. If
it's necessary to have a space between PRINTER-SWITCH and NAME,
which the current setting inherits the context. Take care with
circular inheritance.
Examples:
- '(ps-landscape-mode . nil)
- '(ps-spool-duplex . t)
- '(pr-gs-device . (my-gs-device t))
+ (ps-landscape-mode . nil)
+ (ps-spool-duplex . t)
+ (pr-gs-device . (my-gs-device t))
This variable should be modified by customization engine. If this variable is
modified by other means (for example, a lisp function), use `pr-update-menus'
* On GNU or Unix system:
- '((lps_06b \"lpr\" nil \"-P\" \"lps_06b\")
+ ((lps_06b \"lpr\" nil \"-P\" \"lps_06b\")
(lps_07c \"lpr\" nil nil \"lps_07c\")
(lps_08c nil nil nil \"lps_08c\")
)
* On Windows system:
- '((lps_06a \"print\" nil \"/D:\" \"\\\\\\\\printers\\\\lps_06a\")
+ ((lps_06a \"print\" nil \"/D:\" \"\\\\\\\\printers\\\\lps_06a\")
(lps_06b \"print\" nil nil \"\\\\\\\\printers\\\\lps_06b\")
(lps_07c \"print\" nil \"\" \"/D:\\\\\\\\printers\\\\lps_07c\")
(lps_08c nil nil nil \"\\\\\\\\printers\\\\lps_08c\")
As an example of gsprint declaration:
(setq pr-ps-printer-alist
- '((A \"gsprint\" (\"-all\" \"-twoup\") \"-printer \" \"lps_015\")
+ \\='((A \"gsprint\" (\"-all\" \"-twoup\") \"-printer \" \"lps_015\")
(B \"gsprint\" (\"-all\" \"-twoup\") nil \"-printer lps_015\")
;; some other printer declaration
))
which the current setting inherits the context. Take care with
circular inheritance.
Examples:
- '(ps-landscape-mode . nil)
- '(ps-spool-duplex . t)
- '(pr-gs-device . (my-gs-device t))"
+ (ps-landscape-mode . nil)
+ (ps-spool-duplex . t)
+ (pr-gs-device . (my-gs-device t))"
:type '(repeat
(list
:tag ""
SYMBOL It's a symbol to identify a PostScript utility. It's for
`pr-ps-utility' variable setting and for menu selection.
Examples:
- 'mpage
- 'psnup
+ mpage
+ psnup
UTILITY Name of utility for processing a PostScript file.
See also `pr-path-alist'.
program and must be placed before any other switches.
Example:
. for psnup:
- '(\"-q\")
+ (\"-q\")
PAPERSIZE It's a format string to specify paper size switch.
Example:
program.
Example:
. for psnup
- '(\"-q\")
+ (\"-q\")
nil
DEFAULT It's a way to set default values when this entry is selected.
which the current setting inherits the context. Take care with
circular inheritance.
Examples:
- '(pr-file-landscape . nil)
- '(pr-file-duplex . t)
- '(pr-gs-device . (my-gs-device t))
+ (pr-file-landscape . nil)
+ (pr-file-duplex . t)
+ (pr-gs-device . (my-gs-device t))
This variable should be modified by customization engine. If this variable is
modified by other means (for example, a lisp function), use `pr-update-menus'
* On GNU or Unix system:
- '((mpage \"mpage\" nil \"-b%s\" \"-%d\" \"-l\" \"-t\" \"-T\" \">\" nil)
+ ((mpage \"mpage\" nil \"-b%s\" \"-%d\" \"-l\" \"-t\" \"-T\" \">\" nil)
(psnup \"psnup\" (\"-q\") \"-P%s\" \"-%d\" \"-l\" nil nil \" \" nil
(pr-file-duplex . nil) (pr-file-tumble . nil))
)
* On Windows system:
- '((psnup \"c:/psutils/psnup\" (\"-q\") \"-P%s\" \"-%d\" \"-l\" nil nil \" \"
+ ((psnup \"c:/psutils/psnup\" (\"-q\") \"-P%s\" \"-%d\" \"-l\" nil nil \" \"
nil (pr-file-duplex . nil) (pr-file-tumble . nil))
)
Example value:
- '((\"Emacs Lisp\" Info-goto-emacs-command-node obarray)
+ ((\"Emacs Lisp\" Info-goto-emacs-command-node obarray)
(\"Common Lisp\" common-lisp-hyperspec common-lisp-hyperspec-obarray)
(\"SCWM\" scwm-documentation scwm-obarray))"
:group 'etags
in the buffer. Here is a simple example of how to use this variable:
(defun display-code-line-counts (ov)
- (when (eq 'code (overlay-get ov 'hs))
- (overlay-put ov 'display
+ (when (eq \\='code (overlay-get ov \\='hs))
+ (overlay-put ov \\='display
(format \"... / %d\"
(count-lines (overlay-start ov)
(overlay-end ov))))))
- (setq hs-set-up-overlay 'display-code-line-counts)
+ (setq hs-set-up-overlay \\='display-code-line-counts)
This example shows how to get information from the overlay as well
as how to set its `display' property. See `hs-make-overlay' and
Some examples:
No spaces before and 1 after a comma
- (idlwave-action-and-binding \",\" '(idlwave-surround 0 1))
+ (idlwave-action-and-binding \",\" \\='(idlwave-surround 0 1))
A minimum of 1 space before and after `=' (see `idlwave-expand-equal').
- (idlwave-action-and-binding \"=\" '(idlwave-expand-equal -1 -1))
+ (idlwave-action-and-binding \"=\" \\='(idlwave-expand-equal -1 -1))
Capitalize system variables - action only
- (idlwave-action-and-binding idlwave-sysvar '(capitalize-word 1) t)"
+ (idlwave-action-and-binding idlwave-sysvar \\='(capitalize-word 1) t)"
(if (not (equal select 'noaction))
;; Add action
(let* ((table (if select 'idlwave-indent-action-table
For example:
- (sql-add-product-keywords 'ms
- '((\"\\\\b\\\\w+_t\\\\b\" . font-lock-type-face)))
+ (sql-add-product-keywords \\='ms
+ \\='((\"\\\\b\\\\w+_t\\\\b\" . font-lock-type-face)))
adds a fontification pattern to fontify identifiers ending in
`_t' as data types."
is put into the AUTOSENSE list and is not desired, use the AUTO_CONSTANT
declaration anywhere in the module (parenthesis are required):
- /* AUTO_CONSTANT ( `this_is_really_constant_dont_autosense_it ) */
+ /* AUTO_CONSTANT ( \\=`this_is_really_constant_dont_autosense_it ) */
Better yet, use a parameter, which will be understood to be constant
automatically.
An example:
always @ (/*AS*/) begin
- /* AUTO_CONSTANT (`constant) */
- outin = ina | inb | `constant;
+ /* AUTO_CONSTANT (\\=`constant) */
+ outin = ina | inb | \\=`constant;
out = outin;
end
Typing \\[verilog-auto] will make this into:
always @ (/*AS*/ina or inb) begin
- /* AUTO_CONSTANT (`constant) */
- outin = ina | inb | `constant;
+ /* AUTO_CONSTANT (\\=`constant) */
+ outin = ina | inb | \\=`constant;
out = outin;
end
operator. (This was added to the language in part due to AUTOSENSE!)
always @* begin
- outin = ina | inb | `constant;
+ outin = ina | inb | \\=`constant;
out = outin;
end"
(save-excursion
filtered by option `ps-selected-pages' and then by `ps-even-or-odd-pages'.
For example, if we have:
- (setq ps-selected-pages '(1 4 (6 . 10) (12 . 16) 20))
+ (setq ps-selected-pages \\='(1 4 (6 . 10) (12 . 16) 20))
Combining with `ps-even-or-odd-pages' and option `ps-n-up-printing', we have:
number or a string. If it is a string, the string should contain PostScript
programming that returns a float or integer value.
-For example, if you wish to print an EPS image on all pages do:
+For example, if you wish to print an EPS image on all pages use:
- '((\"~/images/EPS-image.ps\"))"
+ ((\"~/images/EPS-image.ps\"))"
:type '(repeat
(list
(file :tag "EPS File")
number or a string. If it is a string, the string should contain PostScript
programming that returns a float or integer value.
-For example, if you wish to print text \"Preliminary\" on all pages do:
+For example, if you wish to print text \"Preliminary\" on all pages use:
- '((\"Preliminary\"))"
+ ((\"Preliminary\"))"
:type '(repeat
(list
(string :tag "Text")
"Contact the Emacs server named SERVER and evaluate FORM there.
Returns the result of the evaluation, or signals an error if it
cannot contact the specified server. For example:
- (server-eval-at \"server\" '(emacs-pid))
+ (server-eval-at \"server\" \\='(emacs-pid))
returns the process ID of the Emacs instance running \"server\"."
(let* ((server-dir (if server-use-tcp server-auth-dir server-socket-dir))
(server-file (expand-file-name server server-dir))
"Produce a copy of FORMULA where all symbols that refer to cells in row
STARTROW or above, and col STARTCOL or above, are altered by adding ROWINCR
and COLINCR. STARTROW and STARTCOL are 0-based. Example:
- (ses-relocate-formula '(+ A1 B2 D3) 1 2 1 -1)
+ (ses-relocate-formula \\='(+ A1 B2 D3) 1 2 1 -1)
=> (+ A1 B2 C4)
If ROWINCR or COLINCR is negative, references to cells being deleted are
removed. Example:
- (ses-relocate-formula '(+ A1 B2 D3) 0 1 0 -1)
+ (ses-relocate-formula \\='(+ A1 B2 D3) 0 1 0 -1)
=> (+ A1 C3)
Sets `ses-relocate-return' to 'delete if cell-references were removed."
(let (rowcol result)
a special event, so ignore the prefix argument and don't clear it."
(setq debug-on-next-call nil)
(let ((prefixarg (unless special
+ ;; FIXME: This should probably be done around
+ ;; pre-command-hook rather than here!
(prog1 prefix-arg
(setq current-prefix-arg prefix-arg)
- (setq prefix-arg nil)))))
+ (setq prefix-arg nil)
+ (when current-prefix-arg
+ (prefix-command-update))))))
(if (and (symbolp cmd)
(get cmd 'disabled)
disabled-command-function)
(display-buffer buffer)
nil)
\f
+;;;; Prefix commands
+
+(setq prefix-command--needs-update nil)
+(setq prefix-command--last-echo nil)
+
+(defun internal-echo-keystrokes-prefix ()
+ ;; BEWARE: Called directly from the C code.
+ (if (not prefix-command--needs-update)
+ prefix-command--last-echo
+ (setq prefix-command--last-echo
+ (let ((strs nil))
+ (run-hook-wrapped 'prefix-command-echo-keystrokes-functions
+ (lambda (fun) (push (funcall fun) strs)))
+ (setq strs (delq nil strs))
+ (when strs (mapconcat #'identity strs " "))))))
+
+(defvar prefix-command-echo-keystrokes-functions nil
+ "Abnormal hook which constructs the description of the current prefix state.
+Each function is called with no argument, should return a string or nil.")
+
+(defun prefix-command-update ()
+ "Update state of prefix commands.
+Call it whenever you change the \"prefix command state\"."
+ (setq prefix-command--needs-update t))
+
+(defvar prefix-command-preserve-state-hook nil
+ "Normal hook run when a command needs to preserve the prefix.")
+
+(defun prefix-command-preserve-state ()
+ "Pass the current prefix command state to the next command.
+Should be called by all prefix commands.
+Runs `prefix-command-preserve-state-hook'."
+ (run-hooks 'prefix-command-preserve-state-hook)
+ ;; If the current command is a prefix command, we don't want the next (real)
+ ;; command to have `last-command' set to, say, `universal-argument'.
+ (setq this-command last-command)
+ (setq real-this-command real-last-command)
+ (prefix-command-update))
+
+(defun reset-this-command-lengths ()
+ (declare (obsolete prefix-command-preserve-state "25.1"))
+ nil)
+
+;;;;; The main prefix command.
+
+;; FIXME: Declaration of `prefix-arg' should be moved here!?
+
+(add-hook 'prefix-command-echo-keystrokes-functions
+ #'universal-argument--description)
+(defun universal-argument--description ()
+ (when prefix-arg
+ (concat "C-u"
+ (pcase prefix-arg
+ (`(-) " -")
+ (`(,(and (pred integerp) n))
+ (let ((str ""))
+ (while (and (> n 4) (= (mod n 4) 0))
+ (setq str (concat str " C-u"))
+ (setq n (/ n 4)))
+ (if (= n 4) str (format " %s" prefix-arg))))
+ (_ (format " %s" prefix-arg))))))
+
+(add-hook 'prefix-command-preserve-state-hook
+ #'universal-argument--preserve)
+(defun universal-argument--preserve ()
+ (setq prefix-arg current-prefix-arg))
+
(defvar universal-argument-map
(let ((map (make-sparse-keymap))
(universal-argument-minus
"Keymap used while processing \\[universal-argument].")
(defun universal-argument--mode ()
- (set-transient-map universal-argument-map))
+ (prefix-command-update)
+ (set-transient-map universal-argument-map nil))
(defun universal-argument ()
"Begin a numeric argument for the following command.
which is different in effect from any particular numeric argument.
These commands include \\[set-mark-command] and \\[start-kbd-macro]."
(interactive)
+ (prefix-command-preserve-state)
(setq prefix-arg (list 4))
(universal-argument--mode))
;; A subsequent C-u means to multiply the factor by 4 if we've typed
;; nothing but C-u's; otherwise it means to terminate the prefix arg.
(interactive "P")
+ (prefix-command-preserve-state)
(setq prefix-arg (if (consp arg)
(list (* 4 (car arg)))
(if (eq arg '-)
"Begin a negative numeric argument for the next command.
\\[universal-argument] following digits or minus sign ends the argument."
(interactive "P")
+ (prefix-command-preserve-state)
(setq prefix-arg (cond ((integerp arg) (- arg))
((eq arg '-) nil)
(t '-)))
"Part of the numeric argument for the next command.
\\[universal-argument] following digits or minus sign ends the argument."
(interactive "P")
+ (prefix-command-preserve-state)
(let* ((char (if (integerp last-command-event)
last-command-event
(get last-command-event 'ascii-character)))
(defvar server-name)
(defvar server-process)
+(defun startup--setup-quote-display ()
+ "If curved quotes don't work, display ASCII approximations."
+ (dolist (char-repl '((?‘ . ?\`) (?’ . ?\') (?“ . ?\") (?” . ?\")))
+ (when (not (char-displayable-p (car char-repl)))
+ (unless standard-display-table
+ (setq standard-display-table (make-display-table)))
+ (aset standard-display-table (car char-repl)
+ (vector (make-glyph-code (cdr char-repl) 'shadow))))))
+
(defun command-line ()
"A subroutine of `normal-top-level'.
Amongst another things, it parses the command-line arguments."
'("no" "off" "false" "0")))))
(setq no-blinking-cursor t))
- ;; If curved quotes don't work, display ASCII approximations.
- (dolist (char-repl '((?‘ . [?\`]) (?’ . [?\']) (?“ . [?\"]) (?” . [?\"])))
- (when (not (char-displayable-p (car char-repl)))
- (or standard-display-table
- (setq standard-display-table (make-display-table)))
- (aset standard-display-table (car char-repl) (cdr char-repl))))
- (setq internal--text-quoting-flag t)
+ (unless noninteractive
+ (startup--setup-quote-display)
+ (setq internal--text-quoting-flag t))
;; Re-evaluate predefined variables whose initial value depends on
;; the runtime context.
(if oem-o-cs-p oem-code-page-output-coding oem-code-page-coding))
;; Since we changed the terminal encoding, we need to repeat
;; the test for Unicode quotes being displayable.
- (dolist (char-repl
- '((?‘ . [?\`]) (?’ . [?\']) (?“ . [?\"]) (?” . [?\"])))
- (when (not (char-displayable-p (car char-repl)))
- (or standard-display-table
- (setq standard-display-table (make-display-table)))
- (aset standard-display-table (car char-repl) (cdr char-repl))))))
+ (startup--setup-quote-display)))
(let* ((colors w32-tty-standard-colors)
(color (car colors)))
(tty-color-clear)
(progn
(table-insert 16 3 5 1)
(table-forward-cell 15)
- (table-insert-sequence \"D0\" -16 1 1 'center)
+ (table-insert-sequence \"D0\" -16 1 1 \\='center)
(table-forward-cell 16)
- (table-insert-sequence \"A[0]\" -16 1 1 'center)
+ (table-insert-sequence \"A[0]\" -16 1 1 \\='center)
(table-forward-cell 1)
- (table-insert-sequence \"-\" 16 0 1 'center))
+ (table-insert-sequence \"-\" 16 0 1 \\='center))
(progn
(table-insert 16 8 5 1)
- (table-insert-sequence \"@\" 0 1 2 'right)
+ (table-insert-sequence \"@\" 0 1 2 \\='right)
(table-forward-cell 1)
- (table-insert-sequence \"64\" 0 1 2 'left))"
+ (table-insert-sequence \"64\" 0 1 2 \\='left))"
(interactive
(progn
(barf-if-buffer-read-only)
This function is meant to be used to set `tildify-foreach-region-function'
variable. For example, for an XML file one might use:
(setq-local tildify-foreach-region-function
- (apply-partially 'tildify-foreach-ignore-environments
- '((\"<! *--\" . \"-- *>\") (\"<\" . \">\"))))"
+ (apply-partially \\='tildify-foreach-ignore-environments
+ \\='((\"<! *--\" . \"-- *>\") (\"<\" . \">\"))))"
(let ((beg-re (concat "\\(?:" (mapconcat 'car pairs "\\)\\|\\(?:") "\\)"))
p end-re)
(save-excursion
(vc-git--state-code diff-letter)))
(if (vc-git--empty-db-p) 'added 'up-to-date))))
-(defun vc-git-working-revision (file)
+(defun vc-git-working-revision (_file)
"Git-specific version of `vc-working-revision'."
- (let* (process-file-side-effects
- (str (vc-git--run-command-string nil "symbolic-ref" "HEAD")))
- (vc-file-setprop file 'vc-git-detached (null str))
- (if str
- (if (string-match "^\\(refs/heads/\\)?\\(.+\\)$" str)
- (match-string 2 str)
- str)
- (vc-git--rev-parse "HEAD"))))
+ (let (process-file-side-effects)
+ (vc-git--rev-parse "HEAD")))
+
+(defun vc-git--symbolic-ref (file)
+ (or
+ (vc-file-getprop file 'vc-git-symbolic-ref)
+ (let* (process-file-side-effects
+ (str (vc-git--run-command-string nil "symbolic-ref" "HEAD")))
+ (vc-file-setprop file 'vc-git-symbolic-ref
+ (if str
+ (if (string-match "^\\(refs/heads/\\)?\\(.+\\)$" str)
+ (match-string 2 str)
+ str))))))
(defun vc-git-mode-line-string (file)
"Return a string for `vc-mode-line' to put in the mode line for FILE."
(let* ((rev (vc-working-revision file))
- (detached (vc-file-getprop file 'vc-git-detached))
+ (disp-rev (or (vc-git--symbolic-ref file)
+ (substring rev 0 7)))
(def-ml (vc-default-mode-line-string 'Git file))
(help-echo (get-text-property 0 'help-echo def-ml)))
- (propertize (if detached
- (substring def-ml 0 (- 7 (length rev)))
- def-ml)
+ (propertize (replace-regexp-in-string (concat rev "\\'") disp-rev def-ml t t)
'help-echo (concat help-echo "\nCurrent revision: " rev))))
(cl-defstruct (vc-git-extra-fileinfo
(defun vc-default-find-file-hook (_backend)
nil)
-(defun vc-find-file-hook ()
- "Function for `find-file-hook' activating VC mode if appropriate."
+(defun vc-refresh-state ()
+ "Activate or deactivate VC mode as appropriate."
+ (interactive)
;; Recompute whether file is version controlled,
;; if user has killed the buffer and revisited.
(when vc-mode
(vc-follow-link)
(message "Followed link to %s" buffer-file-name)
- (vc-find-file-hook))
+ (vc-refresh-state))
(t
(if (yes-or-no-p (format
"Symbolic link to %s-controlled source file; follow link? " link-type))
(progn (vc-follow-link)
(message "Followed link to %s" buffer-file-name)
- (vc-find-file-hook))
+ (vc-refresh-state))
(message
"Warning: editing through the link bypasses version control")
)))))))))
-(add-hook 'find-file-hook 'vc-find-file-hook)
+(add-hook 'find-file-hook #'vc-refresh-state)
+(define-obsolete-function-alias 'vc-find-file-hook 'vc-refresh-state "25.1")
(defun vc-kill-buffer-hook ()
"Discard VC info about a file when we kill its buffer."
cell whose cdr itself is a list. The obvious way to translate this
into a widget type would be
- (define-widget 'my-list 'choice
+ (define-widget \\='my-list \\='choice
\"A list of sexps.\"
:tag \"Sexp list\"
- :args '((const nil) (cons :value (nil) sexp my-list)))
+ :args \\='((const nil) (cons :value (nil) sexp my-list)))
Here we attempt to define my-list as a choice of either the constant
nil, or a cons-cell containing a sexp and my-lisp. This will not work
Using the `lazy' widget you can overcome this problem, as in this
example:
- (define-widget 'sexp-list 'lazy
+ (define-widget \\='sexp-list \\='lazy
\"A list of sexps.\"
:tag \"Sexp list\"
- :type '(choice (const nil) (cons :value (nil) sexp sexp-list)))"
+ :type \\='(choice (const nil) (cons :value (nil) sexp sexp-list)))"
:format "%{%t%}: %v"
;; We don't convert :type because we want to allow recursive
;; data structures. This is slow, so we should not create speed
DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
mode_line_format,
doc: /* Default value of `mode-line-format' for buffers that don't override it.
-This is the same as (default-value 'mode-line-format). */);
+This is the same as (default-value \\='mode-line-format). */);
DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
header_line_format,
doc: /* Default value of `header-line-format' for buffers that don't override it.
-This is the same as (default-value 'header-line-format). */);
+This is the same as (default-value \\='header-line-format). */);
DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type,
doc: /* Default value of `cursor-type' for buffers that don't override it.
-This is the same as (default-value 'cursor-type). */);
+This is the same as (default-value \\='cursor-type). */);
DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
extra_line_spacing,
doc: /* Default value of `line-spacing' for buffers that don't override it.
-This is the same as (default-value 'line-spacing). */);
+This is the same as (default-value \\='line-spacing). */);
DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
cursor_in_non_selected_windows,
doc: /* Default value of `cursor-in-non-selected-windows'.
-This is the same as (default-value 'cursor-in-non-selected-windows). */);
+This is the same as (default-value \\='cursor-in-non-selected-windows). */);
DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
abbrev_mode,
doc: /* Default value of `abbrev-mode' for buffers that do not override it.
-This is the same as (default-value 'abbrev-mode). */);
+This is the same as (default-value \\='abbrev-mode). */);
DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
ctl_arrow,
doc: /* Default value of `ctl-arrow' for buffers that do not override it.
-This is the same as (default-value 'ctl-arrow). */);
+This is the same as (default-value \\='ctl-arrow). */);
DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
enable_multibyte_characters,
doc: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
-This is the same as (default-value 'enable-multibyte-characters). */);
+This is the same as (default-value \\='enable-multibyte-characters). */);
DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
buffer_file_coding_system,
doc: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
-This is the same as (default-value 'buffer-file-coding-system). */);
+This is the same as (default-value \\='buffer-file-coding-system). */);
DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
truncate_lines,
doc: /* Default value of `truncate-lines' for buffers that do not override it.
-This is the same as (default-value 'truncate-lines). */);
+This is the same as (default-value \\='truncate-lines). */);
DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
fill_column,
doc: /* Default value of `fill-column' for buffers that do not override it.
-This is the same as (default-value 'fill-column). */);
+This is the same as (default-value \\='fill-column). */);
DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
left_margin,
doc: /* Default value of `left-margin' for buffers that do not override it.
-This is the same as (default-value 'left-margin). */);
+This is the same as (default-value \\='left-margin). */);
DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
tab_width,
doc: /* Default value of `tab-width' for buffers that do not override it.
NOTE: This controls the display width of a TAB character, and not
the size of an indentation step.
-This is the same as (default-value 'tab-width). */);
+This is the same as (default-value \\='tab-width). */);
DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
case_fold_search,
doc: /* Default value of `case-fold-search' for buffers that don't override it.
-This is the same as (default-value 'case-fold-search). */);
+This is the same as (default-value \\='case-fold-search). */);
DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
left_margin_cols,
doc: /* Default value of `left-margin-width' for buffers that don't override it.
-This is the same as (default-value 'left-margin-width). */);
+This is the same as (default-value \\='left-margin-width). */);
DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
right_margin_cols,
doc: /* Default value of `right-margin-width' for buffers that don't override it.
-This is the same as (default-value 'right-margin-width). */);
+This is the same as (default-value \\='right-margin-width). */);
DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
left_fringe_width,
doc: /* Default value of `left-fringe-width' for buffers that don't override it.
-This is the same as (default-value 'left-fringe-width). */);
+This is the same as (default-value \\='left-fringe-width). */);
DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
right_fringe_width,
doc: /* Default value of `right-fringe-width' for buffers that don't override it.
-This is the same as (default-value 'right-fringe-width). */);
+This is the same as (default-value \\='right-fringe-width). */);
DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
fringes_outside_margins,
doc: /* Default value of `fringes-outside-margins' for buffers that don't override it.
-This is the same as (default-value 'fringes-outside-margins). */);
+This is the same as (default-value \\='fringes-outside-margins). */);
DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
scroll_bar_width,
doc: /* Default value of `scroll-bar-width' for buffers that don't override it.
-This is the same as (default-value 'scroll-bar-width). */);
+This is the same as (default-value \\='scroll-bar-width). */);
DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
vertical_scroll_bar_type,
doc: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
-This is the same as (default-value 'vertical-scroll-bar). */);
+This is the same as (default-value \\='vertical-scroll-bar). */);
DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
indicate_empty_lines,
doc: /* Default value of `indicate-empty-lines' for buffers that don't override it.
-This is the same as (default-value 'indicate-empty-lines). */);
+This is the same as (default-value \\='indicate-empty-lines). */);
DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
indicate_buffer_boundaries,
doc: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
-This is the same as (default-value 'indicate-buffer-boundaries). */);
+This is the same as (default-value \\='indicate-buffer-boundaries). */);
DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
fringe_indicator_alist,
doc: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
-This is the same as (default-value 'fringe-indicator-alist). */);
+This is the same as (default-value \\='fringe-indicator-alist). */);
DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
fringe_cursor_alist,
doc: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
-This is the same as (default-value 'fringe-cursor-alist). */);
+This is the same as (default-value \\='fringe-cursor-alist). */);
DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
scroll_up_aggressively,
doc: /* Default value of `scroll-up-aggressively'.
This value applies in buffers that don't have their own local values.
-This is the same as (default-value 'scroll-up-aggressively). */);
+This is the same as (default-value \\='scroll-up-aggressively). */);
DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
scroll_down_aggressively,
doc: /* Default value of `scroll-down-aggressively'.
This value applies in buffers that don't have their own local values.
-This is the same as (default-value 'scroll-down-aggressively). */);
+This is the same as (default-value \\='scroll-down-aggressively). */);
DEFVAR_PER_BUFFER ("header-line-format",
&BVAR (current_buffer, header_line_format),
For instance, to tell that there's a word boundary between Hiragana
and Katakana (both are in the same script `kana'),
-the element `(?H . ?K) should be in this list. */);
+the element `(?H . ?K)' should be in this list. */);
Vword_combining_categories = Qnil;
just as setting the variable would do.
This function returns VARIABLE, and therefore
- (set (make-local-variable 'VARIABLE) VALUE-EXP)
+ (set (make-local-variable \\='VARIABLE) VALUE-EXP)
works.
See also `make-variable-buffer-local'.
Value is nil if specified file cannot be opened.
ID-FORMAT specifies the preferred format of attributes uid and gid (see
-below) - valid values are 'string and 'integer. The latter is the
+below) - valid values are `string' and `integer'. The latter is the
default, but we plan to change that, so you should specify a non-nil value
for ID-FORMAT if you use the returned uid or gid.
You can pass more than 7 arguments; then the first six arguments
are used as SECOND through YEAR, and the *last* argument is used as ZONE.
The intervening arguments are ignored.
-This feature lets (apply 'encode-time (decode-time ...)) work.
+This feature lets (apply \\='encode-time (decode-time ...)) work.
Out-of-range values for SECOND, MINUTE, HOUR, DAY, or MONTH are allowed;
for example, a DAY of 0 means the day preceding the given month.
Warning: `quote' does not construct its return value, but just returns
the value that was pre-constructed by the Lisp reader (see info node
`(elisp)Printed Representation').
-This means that '(a . b) is not identical to (cons 'a 'b): the former
+This means that \\='(a . b) is not identical to (cons \\='a \\='b): the former
does not cons. Quoting should be reserved for constants that will
never be modified by side-effects, unless you like self-modifying code.
See the common pitfall in info node `(elisp)Rearrangement' for an example
DEFUN ("apply", Fapply, Sapply, 1, MANY, 0,
doc: /* Call FUNCTION with our remaining args, using our last arg as list of args.
Then return the value FUNCTION returns.
-Thus, (apply '+ 1 2 '(3 4)) returns 10.
+Thus, (apply \\='+ 1 2 \\='(3 4)) returns 10.
usage: (apply FUNCTION &rest ARGUMENTS) */)
(ptrdiff_t nargs, Lisp_Object *args)
{
DEFUN ("funcall", Ffuncall, Sfuncall, 1, MANY, 0,
doc: /* Call first argument as a function, passing remaining arguments to it.
Return the value that function returns.
-Thus, (funcall 'cons 'x 'y) returns (x . y).
+Thus, (funcall \\='cons \\='x \\='y) returns (x . y).
usage: (funcall FUNCTION &rest ARGUMENTS) */)
(ptrdiff_t nargs, Lisp_Object *args)
{
do (file-exists-p FILENAME) and FILENAME is handled by HANDLER, then
HANDLER is called like this:
- (funcall HANDLER 'file-exists-p FILENAME)
+ (funcall HANDLER \\='file-exists-p FILENAME)
Note that HANDLER must be able to handle all I/O primitives; if it has
nothing special to do for a primitive, it should reinvoke the
locale settings. For example, punctuation and whitespace characters
might be considered less significant for sorting:
-\(sort '\("11" "12" "1 1" "1 2" "1.1" "1.2") 'string-collate-lessp)
+\(sort '\("11" "12" "1 1" "1 2" "1.1" "1.2") \\='string-collate-lessp)
=> \("11" "1 1" "1.1" "12" "1 2" "1.2")
The optional argument LOCALE, a string, overrides the setting of your
See also `string-to-multibyte'.
Beware, this often doesn't really do what you think it does.
-It is similar to (decode-coding-string STRING 'utf-8-emacs).
+It is similar to (decode-coding-string STRING \\='utf-8-emacs).
If you're not sure, whether to use `string-as-multibyte' or
`string-to-multibyte', use `string-to-multibyte'. */)
(Lisp_Object string)
In that case, the `tty' parameter specifies the device file to open,
and the `tty-type' parameter specifies the terminal type. Example:
- (make-terminal-frame '((tty . "/dev/pts/5") (tty-type . "xterm")))
+ (make-terminal-frame \\='((tty . "/dev/pts/5") (tty-type . "xterm")))
Note that changing the size of one terminal frame automatically
affects all frames on the same terminal device. */)
DEFVAR_LISP ("default-frame-alist", Vdefault_frame_alist,
doc: /* Alist of default values for frame creation.
These may be set in your init file, like this:
- (setq default-frame-alist '((width . 80) (height . 55) (menu-bar-lines . 1)))
+ (setq default-frame-alist \\='((width . 80) (height . 55) (menu-bar-lines . 1)))
These override values given in window system configuration data,
including X Windows' defaults database.
For values specific to the first Emacs frame, see `initial-frame-alist'.
keep it unchanged if this option is either t or a list containing
`vertical-scroll-bars'.
-The default value is '(tool-bar-lines) on Lucid, Motif and Windows
+The default value is \\='(tool-bar-lines) on Lucid, Motif and Windows
\(which means that adding/removing a tool bar does not change the frame
height), nil on all other window systems including GTK+ (which means
that changing any of the parameters listed above may change the size of
defining the supported image types. */
DEFVAR_LISP ("image-types", Vimage_types,
doc: /* List of potentially supported image types.
-Each element of the list is a symbol for an image type, like 'jpeg or 'png.
+Each element of the list is a symbol for an image type, like `jpeg' or `png'.
To check whether it is really supported, use `image-type-available-p'. */);
Vimage_types = Qnil;
Lisp_Object this_command_keys;
ptrdiff_t this_command_key_count;
-/* True after calling Freset_this_command_lengths.
- Usually it is false. */
-static bool this_command_key_count_reset;
-
/* This vector is used as a buffer to record the events that were actually read
by read_key_sequence. */
static Lisp_Object raw_keybuf;
that precede this key sequence. */
static ptrdiff_t this_single_command_key_start;
-/* Record values of this_command_key_count and echo_length ()
- before this command was read. */
-static ptrdiff_t before_command_key_count;
-static ptrdiff_t before_command_echo_length;
-
#ifdef HAVE_STACK_OVERFLOW_HANDLING
/* For longjmp to recover from C stack overflow. */
ptrdiff_t size = sizeof initbuf;
char *buffer = initbuf;
char *ptr = buffer;
- Lisp_Object echo_string;
+ Lisp_Object echo_string = KVAR (current_kboard, echo_string);
USE_SAFE_ALLOCA;
- echo_string = KVAR (current_kboard, echo_string);
+ if (STRINGP (echo_string) && SCHARS (echo_string) > 0)
+ /* Add a space at the end as a separator between keys. */
+ ptr++[0] = ' ';
/* If someone has passed us a composite event, use its head symbol. */
c = EVENT_HEAD (c);
ptr += len;
}
- /* Replace a dash from echo_dash with a space, otherwise add a space
- at the end as a separator between keys. */
- AUTO_STRING (space, " ");
- if (STRINGP (echo_string) && SCHARS (echo_string) > 1)
- {
- Lisp_Object last_char, prev_char, idx;
-
- idx = make_number (SCHARS (echo_string) - 2);
- prev_char = Faref (echo_string, idx);
-
- idx = make_number (SCHARS (echo_string) - 1);
- last_char = Faref (echo_string, idx);
-
- /* We test PREV_CHAR to make sure this isn't the echoing of a
- minus-sign. */
- if (XINT (last_char) == '-' && XINT (prev_char) != ' ')
- Faset (echo_string, idx, make_number (' '));
- else
- echo_string = concat2 (echo_string, space);
- }
- else if (STRINGP (echo_string) && SCHARS (echo_string) > 0)
- echo_string = concat2 (echo_string, space);
-
kset_echo_string
(current_kboard,
concat2 (echo_string, make_string (buffer, ptr - buffer)));
SAFE_FREE ();
}
-/* Add C to the echo string, if echoing is going on. C can be a
- character or a symbol. */
-
-static void
-echo_char (Lisp_Object c)
-{
- if (current_kboard->immediate_echo)
- {
- echo_add_key (c);
- echo_now ();
- }
-}
-
/* Temporarily add a dash to the end of the echo string if it's not
empty, so that it serves as a mini-prompt for the very next
character. */
if (NILP (KVAR (current_kboard, echo_string)))
return;
- if (this_command_key_count == 0)
- return;
-
if (!current_kboard->immediate_echo
&& SCHARS (KVAR (current_kboard, echo_string)) == 0)
return;
echo_now ();
}
-/* Display the current echo string, and begin echoing if not already
- doing so. */
-
static void
-echo_now (void)
+echo_update (void)
{
- if (!current_kboard->immediate_echo)
+ if (current_kboard->immediate_echo)
{
ptrdiff_t i;
- current_kboard->immediate_echo = true;
+ kset_echo_string (current_kboard,
+ call0 (Qinternal_echo_keystrokes_prefix));
for (i = 0; i < this_command_key_count; i++)
{
Lisp_Object c;
- /* Set before_command_echo_length to the value that would
- have been saved before the start of this subcommand in
- command_loop_1, if we had already been echoing then. */
- if (i == this_single_command_key_start)
- before_command_echo_length = echo_length ();
-
c = AREF (this_command_keys, i);
if (! (EVENT_HAS_PARAMETERS (c)
&& EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
- echo_char (c);
+ echo_add_key (c);
}
- /* Set before_command_echo_length to the value that would
- have been saved before the start of this subcommand in
- command_loop_1, if we had already been echoing then. */
- if (this_command_key_count == this_single_command_key_start)
- before_command_echo_length = echo_length ();
+ echo_now ();
+ }
+}
+
+/* Display the current echo string, and begin echoing if not already
+ doing so. */
+static void
+echo_now (void)
+{
+ if (!current_kboard->immediate_echo)
+ {
+ current_kboard->immediate_echo = true;
+ echo_update ();
/* Put a dash at the end to invite the user to type more. */
echo_dash ();
}
static void
add_command_key (Lisp_Object key)
{
-#if 0 /* Not needed after we made Freset_this_command_lengths
- do the job immediately. */
- /* If reset-this-command-length was called recently, obey it now.
- See the doc string of that function for an explanation of why. */
- if (before_command_restore_flag)
- {
- this_command_key_count = before_command_key_count_1;
- if (this_command_key_count < this_single_command_key_start)
- this_single_command_key_start = this_command_key_count;
- echo_truncate (before_command_echo_length_1);
- before_command_restore_flag = 0;
- }
-#endif
-
if (this_command_key_count >= ASIZE (this_command_keys))
this_command_keys = larger_vector (this_command_keys, 1, -1);
DEFUN ("recursive-edit", Frecursive_edit, Srecursive_edit, 0, 0, "",
doc: /* Invoke the editor command loop recursively.
To get out of the recursive edit, a command can throw to ‘exit’ -- for
-instance ‘(throw 'exit nil)’.
+instance ‘(throw \\='exit nil)’.
If you throw a value other than t, ‘recursive-edit’ returns normally
to the function that called it. Throwing a t value causes
‘recursive-edit’ to quit, so that control returns to the command loop
/* The last boundary auto-added to buffer-undo-list. */
Lisp_Object last_undo_boundary;
-/* FIXME: This is wrong rather than test window-system, we should call
- a new set-selection, which will then dispatch to x-set-selection, or
- tty-set-selection, or w32-set-selection, ... */
-
Lisp_Object
command_loop_1 (void)
{
cancel_echoing ();
this_command_key_count = 0;
- this_command_key_count_reset = false;
this_single_command_key_start = 0;
if (NILP (Vmemory_full))
&& !NILP (Ffboundp (Qrecompute_lucid_menubar)))
call0 (Qrecompute_lucid_menubar);
- before_command_key_count = this_command_key_count;
- before_command_echo_length = echo_length ();
-
Vthis_command = Qnil;
Vreal_this_command = Qnil;
Vthis_original_command = Qnil;
{
cancel_echoing ();
this_command_key_count = 0;
- this_command_key_count_reset = false;
this_single_command_key_start = 0;
goto finalize;
}
}
#endif
- if (NILP (KVAR (current_kboard, Vprefix_arg))) /* FIXME: Why? --Stef */
- {
- Lisp_Object undo = BVAR (current_buffer, undo_list);
- Fundo_boundary ();
- last_undo_boundary
- = (EQ (undo, BVAR (current_buffer, undo_list))
- ? Qnil : BVAR (current_buffer, undo_list));
- }
+ {
+ Lisp_Object undo = BVAR (current_buffer, undo_list);
+ Fundo_boundary ();
+ last_undo_boundary
+ = (EQ (undo, BVAR (current_buffer, undo_list))
+ ? Qnil : BVAR (current_buffer, undo_list));
+ }
call1 (Qcommand_execute, Vthis_command);
#ifdef HAVE_WINDOW_SYSTEM
safe_run_hooks (Qdeferred_action_function);
- /* If there is a prefix argument,
- 1) We don't want Vlast_command to be ``universal-argument''
- (that would be dumb), so don't set Vlast_command,
- 2) we want to leave echoing on so that the prefix will be
- echoed as part of this key sequence, so don't call
- cancel_echoing, and
- 3) we want to leave this_command_key_count non-zero, so that
- read_char will realize that it is re-reading a character, and
- not echo it a second time.
-
- If the command didn't actually create a prefix arg,
- but is merely a frame event that is transparent to prefix args,
- then the above doesn't apply. */
- if (NILP (KVAR (current_kboard, Vprefix_arg))
- || CONSP (last_command_event))
+ kset_last_command (current_kboard, Vthis_command);
+ kset_real_last_command (current_kboard, Vreal_this_command);
+ if (!CONSP (last_command_event))
+ kset_last_repeatable_command (current_kboard, Vreal_this_command);
+
+ this_command_key_count = 0;
+ this_single_command_key_start = 0;
+
+ if (current_kboard->immediate_echo
+ && !NILP (call0 (Qinternal_echo_keystrokes_prefix)))
{
- kset_last_command (current_kboard, Vthis_command);
- kset_real_last_command (current_kboard, Vreal_this_command);
- if (!CONSP (last_command_event))
- kset_last_repeatable_command (current_kboard, Vreal_this_command);
- cancel_echoing ();
- this_command_key_count = 0;
- this_command_key_count_reset = false;
- this_single_command_key_start = 0;
+ current_kboard->immediate_echo = false;
+ /* Refresh the echo message. */
+ echo_now ();
}
+ else
+ cancel_echoing ();
if (!NILP (BVAR (current_buffer, mark_active))
&& !NILP (Vrun_hooks))
also_record = Qnil;
-#if 0 /* This was commented out as part of fixing echo for C-u left. */
- before_command_key_count = this_command_key_count;
- before_command_echo_length = echo_length ();
-#endif
c = Qnil;
previous_echo_area_message = Qnil;
goto reread_for_input_method;
}
- this_command_key_count_reset = false;
-
if (!NILP (Vexecuting_kbd_macro))
{
/* We set this to Qmacro; since that's not a frame, nobody will
(3) There's only one place in 20.x where ok_to_echo_at_next_pause
is set to a non-null value. This is done in read_char and it is
- set to echo_area_glyphs after a call to echo_char. That means
+ set to echo_area_glyphs. That means
ok_to_echo_at_next_pause is either null or
current_kboard->echobuf with the appropriate current_kboard at
that time.
if (minibuf_level == 0
&& !end_time
&& !current_kboard->immediate_echo
- && this_command_key_count > 0
+ && (this_command_key_count > 0
+ || !NILP (call0 (Qinternal_echo_keystrokes_prefix)))
&& ! noninteractive
&& echo_keystrokes_p ()
&& (/* No message. */
{
Lisp_Object keys;
ptrdiff_t key_count;
- bool key_count_reset;
ptrdiff_t command_key_start;
ptrdiff_t count = SPECPDL_INDEX ();
Lisp_Object saved_echo_string = KVAR (current_kboard, echo_string);
ptrdiff_t saved_echo_after_prompt = current_kboard->echo_after_prompt;
-#if 0
- if (before_command_restore_flag)
- {
- this_command_key_count = before_command_key_count_1;
- if (this_command_key_count < this_single_command_key_start)
- this_single_command_key_start = this_command_key_count;
- echo_truncate (before_command_echo_length_1);
- before_command_restore_flag = 0;
- }
-#endif
-
/* Save the this_command_keys status. */
key_count = this_command_key_count;
- key_count_reset = this_command_key_count_reset;
command_key_start = this_single_command_key_start;
if (key_count > 0)
/* Clear out this_command_keys. */
this_command_key_count = 0;
- this_command_key_count_reset = false;
this_single_command_key_start = 0;
/* Now wipe the echo area. */
/* Restore the saved echoing state
and this_command_keys state. */
this_command_key_count = key_count;
- this_command_key_count_reset = key_count_reset;
this_single_command_key_start = command_key_start;
if (key_count > 0)
this_command_keys = keys;
goto retry;
}
- if ((! reread || this_command_key_count == 0
- || this_command_key_count_reset)
+ if ((! reread || this_command_key_count == 0)
&& !end_time)
{
/* Don't echo mouse motion events. */
- if (echo_keystrokes_p ()
- && ! (EVENT_HAS_PARAMETERS (c)
- && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
- {
- echo_char (c);
- if (! NILP (also_record))
- echo_char (also_record);
- /* Once we reread a character, echoing can happen
- the next time we pause to read a new one. */
- ok_to_echo_at_next_pause = current_kboard;
- }
+ if (! (EVENT_HAS_PARAMETERS (c)
+ && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
+ /* Once we reread a character, echoing can happen
+ the next time we pause to read a new one. */
+ ok_to_echo_at_next_pause = current_kboard;
/* Record this character as part of the current key. */
add_command_key (c);
if (! NILP (also_record))
add_command_key (also_record);
+
+ echo_update ();
}
last_input_event = c;
record_char (c);
-#if 0
- before_command_key_count = this_command_key_count;
- before_command_echo_length = echo_length ();
-#endif
-
- /* Don't echo mouse motion events. */
- if (echo_keystrokes_p ())
- {
- echo_char (c);
-
- /* Once we reread a character, echoing can happen
- the next time we pause to read a new one. */
- ok_to_echo_at_next_pause = 0;
- }
+ /* Once we reread a character, echoing can happen
+ the next time we pause to read a new one. */
+ ok_to_echo_at_next_pause = NULL;
/* Record this character as part of the current key. */
add_command_key (c);
+ echo_update ();
/* Re-reading in the middle of a command. */
last_input_event = c;
{
key = keybuf[t];
add_command_key (key);
- if (echo_keystrokes_p ()
- && current_kboard->immediate_echo)
+ if (current_kboard->immediate_echo)
{
- echo_add_key (key);
- echo_dash ();
+ /* Set immediate_echo to false so as to force echo_now to
+ redisplay (it will set immediate_echo right back to true). */
+ current_kboard->immediate_echo = false;
+ echo_now ();
}
}
Better ideas? */
for (; t < mock_input; t++)
- {
- if (echo_keystrokes_p ())
- echo_char (keybuf[t]);
- add_command_key (keybuf[t]);
- }
+ add_command_key (keybuf[t]);
+ echo_update ();
return t;
}
if (NILP (continue_echo))
{
this_command_key_count = 0;
- this_command_key_count_reset = false;
this_single_command_key_start = 0;
}
return Fvector (raw_keybuf_count, XVECTOR (raw_keybuf)->contents);
}
-DEFUN ("reset-this-command-lengths", Freset_this_command_lengths,
- Sreset_this_command_lengths, 0, 0, 0,
- doc: /* Make the unread events replace the last command and echo.
-Used in `universal-argument-other-key'.
-
-`universal-argument-other-key' rereads the event just typed.
-It then gets translated through `function-key-map'.
-The translated event has to replace the real events,
-both in the value of (this-command-keys) and in echoing.
-To achieve this, `universal-argument-other-key' calls
-`reset-this-command-lengths', which discards the record of reading
-these events the first time. */)
- (void)
-{
- this_command_key_count = before_command_key_count;
- if (this_command_key_count < this_single_command_key_start)
- this_single_command_key_start = this_command_key_count;
-
- echo_truncate (before_command_echo_length);
-
- /* Cause whatever we put into unread-command-events
- to echo as if it were being freshly read from the keyboard. */
- this_command_key_count_reset = true;
-
- return Qnil;
-}
-
DEFUN ("clear-this-command-keys", Fclear_this_command_keys,
Sclear_this_command_keys, 0, 1, 0,
doc: /* Clear out the vector that `this-command-keys' returns.
int i;
this_command_key_count = 0;
- this_command_key_count_reset = false;
if (NILP (keep_record))
{
staticpro (&raw_keybuf);
DEFSYM (Qcommand_execute, "command-execute");
+ DEFSYM (Qinternal_echo_keystrokes_prefix, "internal-echo-keystrokes-prefix");
accent_key_syms = Qnil;
staticpro (&accent_key_syms);
defsubr (&Sthis_command_keys_vector);
defsubr (&Sthis_single_command_keys);
defsubr (&Sthis_single_command_raw_keys);
- defsubr (&Sreset_this_command_lengths);
defsubr (&Sclear_this_command_keys);
defsubr (&Ssuspend_emacs);
defsubr (&Sabort_recursive_edit);
DEFVAR_BOOL ("print-quoted", print_quoted,
doc: /* Non-nil means print quoted forms with reader syntax.
-I.e., (quote foo) prints as 'foo, (function foo) as #'foo. */);
+I.e., (quote foo) prints as \\='foo, (function foo) as #\\='foo. */);
print_quoted = 0;
DEFVAR_LISP ("print-gensym", Vprint_gensym,
\(serial-process-configure :process "/dev/ttyS0" :speed 1200)
\(serial-process-configure
- :buffer "COM1" :stopbits 1 :parity 'odd :flowcontrol 'hw)
+ :buffer "COM1" :stopbits 1 :parity \\='odd :flowcontrol \\='hw)
\(serial-process-configure :port "\\\\.\\COM13" :bytesize 7)
\(make-serial-process :port "COM1" :speed 115200 :stopbits 2)
-\(make-serial-process :port "\\\\.\\COM13" :speed 1200 :bytesize 7 :parity 'odd)
+\(make-serial-process :port "\\\\.\\COM13" :speed 1200 :bytesize 7 :parity \\='odd)
\(make-serial-process :port "/dev/tty.BlueConsole-SPP-1" :speed nil)
DEFUN ("set-message-beep", Fset_message_beep, Sset_message_beep, 1, 1, 0,
doc: /* Set the sound generated when the bell is rung.
-SOUND is 'asterisk, 'exclamation, 'hand, 'question, 'ok, or 'silent
-to use the corresponding system sound for the bell. The 'silent sound
+SOUND is `asterisk', `exclamation', `hand', `question', `ok', or `silent'
+to use the corresponding system sound for the bell. The `silent' sound
prevents Emacs from making any sound at all.
SOUND is nil to use the normal beep. */)
(Lisp_Object sound)
only in that buffer. For instance, the mode my-mode could define a
face `my-mode-default', and then in the mode setup function, do:
- (set (make-local-variable 'face-remapping-alist)
- '((default my-mode-default)))).
+ (set (make-local-variable \\='face-remapping-alist)
+ \\='((default my-mode-default)))).
Because Emacs normally only redraws screen areas when the underlying
buffer contents change, you may need to call `redraw-display' after