"Create the allout keymap according to the keybinding specs, and set it.
Useful standalone or to effect customizations of the
-respective allout-mode keybinding variables, `allout-command-prefix',
+respective `allout-mode' keybinding variables, `allout-command-prefix',
`allout-prefixed-keybindings', and `allout-unprefixed-keybindings'"
;; Set the customization variable, if any:
(when varname
(allout-institute-keymap map)))
;;;_ > allout-institute-keymap (map)
(defun allout-institute-keymap (map)
- "Associate allout-mode bindings with allout as a minor mode."
+ "Associate `allout-mode' bindings with allout as a minor mode."
;; Architecture:
;; allout-mode-map var is a keymap by virtue of being a defalias for
;; allout-mode-map-value, which has the actual keymap value.
See `allout-expose-topic' for more about the exposure process.
Also, allout's mode-specific provisions will make topic prefixes default
-to the comment-start string, if any, of the language of the file. This
+to the `comment-start' string, if any, of the language of the file. This
is modulo the setting of `allout-use-mode-specific-leader', which see."
:type 'allout-layout-type
:group 'allout)
;;;_ = allout-show-bodies
(defcustom allout-show-bodies nil
- "If non-nil, show entire body when exposing a topic, rather than
-just the header."
+ "If non-nil, show entire body when exposing a topic, rather than just the header."
:type 'boolean
:group 'allout)
(make-variable-buffer-local 'allout-show-bodies)
"When non-nil, use mode-specific topic-header prefixes.
Allout outline mode will use the mode-specific `allout-mode-leaders' or
-comment-start string, if any, to lead the topic prefix string, so topic
+`comment-start' string, if any, to lead the topic prefix string, so topic
headers look like comments in the programming language. It will also use
-the comment-start string, with an `_' appended, for `allout-primary-bullet'.
+the `comment-start' string, with an `_' appended, for `allout-primary-bullet'.
String values are used as literals, not regular expressions, so
do not escape any regular-expression characters.
Value t means to first check for assoc value in `allout-mode-leaders'
-alist, then use comment-start string, if any, then use default (`.').
-\(See note about use of comment-start strings, below.)
+alist, then use `comment-start' string, if any, then use default (`.').
+\(See note about use of `comment-start' strings, below.)
Set to the symbol for either of `allout-mode-leaders' or
`comment-start' to use only one of them, respectively.
Value nil means to always use the default (`.') and leave
`allout-primary-bullet' unaltered.
-comment-start strings that do not end in spaces are tripled in
+`comment-start' strings that do not end in spaces are tripled in
the header-prefix, and an `_' underscore is tacked on the end, to
-distinguish them from regular comment strings. comment-start
+distinguish them from regular comment strings. `comment-start'
strings that do end in spaces are not tripled, but an underscore
is substituted for the space. [This presumes that the space is
for appearance, not comment syntax. You can use
(defvar allout-mode-leaders '()
"Specific allout-prefix leading strings per major modes.
-Use this if the mode's comment-start string isn't what you
-prefer, or if the mode lacks a comment-start string. See
+Use this if the mode's `comment-start' string isn't what you
+prefer, or if the mode lacks a `comment-start' string. See
`allout-use-mode-specific-leader' for more details.
If you're constructing a string that will comment-out outline
;;;_ : Version
;;;_ = allout-version
(defvar allout-version "2.3"
- "Version of currently loaded outline package. (allout.el)")
+ "Version of currently loaded allout.el package.")
;;;_ > allout-version
(defun allout-version (&optional here)
"Return string describing the loaded outline version."
'allout-mode)
;;;_ > allout-write-contents-hook-handler ()
(defun allout-write-contents-hook-handler ()
- "Implement `allout-encrypt-unencrypted-on-saves' for file writes
+ "Implement `allout-encrypt-unencrypted-on-saves' for file writes.
Return nil if all goes smoothly, or else return an informative
message if an error is encountered. The message will serve as a
index
do-successors
sans-offspring)
- "Like `allout-rebullet-topic', but on nearest containing topic
-\(visible or not).
+ "Like `allout-rebullet-topic', but on nearest containing topic (visible or not).
See `allout-rebullet-heading' for rebulleting behavior.
max-pos)))
;;;_ > allout-old-expose-topic (spec &rest followers)
(defun allout-old-expose-topic (spec &rest followers)
- "Deprecated. Use `allout-expose-topic' (with different schema
-format) instead.
+ "Deprecated. Use `allout-expose-topic' (with different schema format) instead.
Dictate wholesale exposure scheme for current topic, according to SPEC.
codes))
(defun ansi-color-make-color-map ()
- "Creates a vector of face definitions and returns it.
+ "Create a vector of face definitions and return it.
The index into the vector is an ANSI code. See the documentation of
`ansi-color-map' for an example.
(error "There is nothing to follow here"))))
(defun apropos-next-symbol ()
- "Move cursor down to the next symbol in an apropos-mode buffer."
+ "Move cursor down to the next symbol in an `apropos-mode' buffer."
(interactive)
(forward-line)
(while (and (not (eq (face-at-point) 'apropos-symbol))
(forward-line)))
(defun apropos-previous-symbol ()
- "Move cursor back to the last symbol in an apropos-mode buffer."
+ "Move cursor back to the last symbol in an `apropos-mode' buffer."
(interactive)
(forward-line -1)
(while (and (not (eq (face-at-point) 'apropos-symbol))
;; TODO: or maybe leave as (setq auth-source-netrc-use-gpg-tokens 'never)
(defcustom auth-source-netrc-use-gpg-tokens 'never
- "Set this to tell auth-source when to create GPG password
+ "Set this to tell `auth-source' when to create GPG password
tokens in netrc files. It's either an alist or `never'.
Note that if EPA/EPG is not available, this should NOT be used."
:version "23.2" ;; No Gnus
(add-hook 'auth-source-backend-parser-functions #'auth-source-backends-parser-secrets)
(defun auth-source-backend-parse-parameters (entry backend)
- "Fill in the extra auth-source-backend parameters of ENTRY.
+ "Fill in the extra `auth-source-backend' parameters of ENTRY.
Using the plist ENTRY, get the :host, :port, and :user search
parameters."
(let ((entry (if (stringp entry)
&key backend require create
type max host user port
&allow-other-keys)
- "Given a property list SPEC, return search matches from the :backend.
+ "Given a property list SPEC, return search matches from the `:backend'.
See `auth-source-search' for details on SPEC."
;; just in case, check that the type is correct (null or same as the backend)
(cl-assert (or (null type) (eq type (oref backend type)))
&key backend require
type max host user port
&allow-other-keys)
- "Given a property list SPEC, return search matches from the :backend.
+ "Given a property list SPEC, return search matches from the `:backend'.
See `auth-source-search' for details on SPEC."
;; just in case, check that the type is correct (null or same as the backend)
(cl-assert (or (null type) (eq type (oref backend type)))
(const :tag "Ask if called non-interactively" function)
(other :tag "Ask" t)))
-(defcustom auto-insert-prompt "Perform %s auto-insertion? "
- "Prompt to use when querying whether to auto-insert.
+(defcustom auto-insert-prompt "Perform %s auto-insertion?"
+ "Prompt to use when querying whether to `auto-insert'.
If this contains a %s, that will be replaced by the matching rule."
- :type 'string)
+ :type 'string
+ :version "28.1")
(defcustom auto-insert-alist
(defvar mode-line-front-space '(:eval (if (display-graphic-p) " " "-"))
"Mode line construct to put at the front of the mode line.
By default, this construct is displayed right at the beginning of
-the mode line, except that if there is a memory-full message, it
-is displayed first.")
+the mode line, except that if there is a \"memory full\" message,
+it is displayed first.")
(put 'mode-line-front-space 'risky-local-variable t)
(defun mode-line-mule-info-help-echo (window _object _point)
(define-key map "p" 'previous-error)
(define-key map "\M-p" 'previous-error)
map)
- "Keymap to repeat next-error key sequences. Used in `repeat-mode'.")
+ "Keymap to repeat `next-error' key sequences. Used in `repeat-mode'.")
(put 'next-error 'repeat-map 'next-error-repeat-map)
(put 'previous-error 'repeat-map 'next-error-repeat-map)
recent one.
To yank words from the text of the buffer and use them as part of the
-bookmark name, type C-w while setting a bookmark. Successive C-w's
+bookmark name, type \\<bookmark-minibuffer-read-name-map>\
+\\[bookmark-yank-word] while setting a bookmark. Successive \
+\\[bookmark-yank-word]'s
yank successive words.
Typing \\[universal-argument] inserts (at the bookmark name prompt) the name of the last
is nil, raise an error.
To yank words from the text of the buffer and use them as part of the
-bookmark name, type C-w while setting a bookmark. Successive C-w's
+bookmark name, type \\<bookmark-minibuffer-read-name-map>\
+\\[bookmark-yank-word] while setting a bookmark. Successive \
+\\[bookmark-yank-word]'s
yank successive words.
Typing \\[universal-argument] inserts (at the bookmark name prompt) the name of the last
as an argument. If called with two strings, then no prompting is done.
You must pass at least OLD-NAME when calling from Lisp.
-While you are entering the new name, consecutive C-w's insert
+While you are entering the new name, consecutive \
+\\<bookmark-minibuffer-read-name-map>\\[bookmark-yank-word]'s insert
consecutive words from the text of the buffer into the new bookmark
name."
(interactive (list (bookmark-completing-read "Old bookmark name")))
(define-key map [mouse-2] 'bookmark-bmenu-other-window-with-mouse)
map))
-(easy-menu-define
- bookmark-menu bookmark-bmenu-mode-map "Bookmark Menu"
+(easy-menu-define bookmark-menu bookmark-bmenu-mode-map
+ "Menu for `bookmark-bmenu'."
'("Bookmark"
["Select Bookmark in This Window" bookmark-bmenu-this-window t]
["Select Bookmark in Full-Frame Window" bookmark-bmenu-1-window t]
(defun bookmark-bmenu-save ()
"Save the current list into a bookmark file.
-With a prefix arg, prompts for a file to save them in.
+With a prefix arg, prompt for a file to save them in.
See also the related behaviors of `bookmark-load' and
`bookmark-bmenu-load'."
so the Buffer Menu remains visible in its window.
\\[Buffer-menu-view] Select current line's buffer, in View mode.
\\[Buffer-menu-view-other-window] Select that buffer in
- another window, in view-mode.
+ another window, in `view-mode'.
\\[Buffer-menu-switch-other-window] Make another window display that buffer.
\\[Buffer-menu-mark] Mark current line's buffer to be displayed.
\\[Buffer-menu-select] Select current line's buffer.
\\[Buffer-menu-isearch-buffers] Incremental search in the marked buffers.
\\[Buffer-menu-isearch-buffers-regexp] Isearch for regexp in the marked buffers.
\\[Buffer-menu-multi-occur] Show lines matching regexp in the marked buffers.
-\\[Buffer-menu-visit-tags-table] visit-tags-table this buffer.
+\\[Buffer-menu-visit-tags-table] `visit-tags-table' this buffer.
\\[Buffer-menu-not-modified] Clear modified-flag on that buffer.
\\[Buffer-menu-save] Mark that buffer to be saved, and move down.
\\[Buffer-menu-delete] Mark that buffer to be deleted, and move down.
(display-buffer (list-buffers-noselect arg)))
(defun Buffer-menu-toggle-files-only (arg)
- "Toggle whether the current buffer-menu displays only file buffers.
+ "Toggle whether the current `buffer-menu' displays only file buffers.
With a positive ARG, display only file buffers. With zero or
negative ARG, display other buffers as well."
(interactive "P" Buffer-menu-mode)
;; [this is an internal function]
(defsubst button-category-symbol (type)
- "Return the symbol used by button-type TYPE to store properties.
+ "Return the symbol used by `button-type' TYPE to store properties.
Buttons inherit them by setting their `category' property to that symbol."
(or (get type 'button-category-symbol)
(error "Unknown button type `%s'" type)))
(defun define-button-type (name &rest properties)
"Define a `button type' called NAME (a symbol).
-The remaining arguments form a plist of PROPERTY VALUE pairs,
-specifying properties to use as defaults for buttons with this type
-\(a button's type may be set by giving it a `type' property when
-creating the button, using the :type keyword argument).
+The remaining PROPERTIES arguments form a plist of PROPERTY VALUE
+pairs, specifying properties to use as defaults for buttons with
+this type (a button's type may be set by giving it a `type'
+property when creating the button, using the :type keyword
+argument).
In addition, the keyword argument :supertype may be used to specify a
-button-type from which NAME inherits its default property values
-\(however, the inheritance happens only when NAME is defined; subsequent
+`button-type' from which NAME inherits its default property values
+(however, the inheritance happens only when NAME is defined; subsequent
changes to a supertype are not reflected in its subtypes)."
(let ((catsym (make-symbol (concat (symbol-name name) "-button")))
(super-catsym
name))
(defun button-type-put (type prop val)
- "Set the button-type TYPE's PROP property to VAL."
+ "Set the `button-type' TYPE's PROP property to VAL."
(put (button-category-symbol type) prop val))
(defun button-type-get (type prop)
- "Get the property of button-type TYPE named PROP."
+ "Get the property of `button-type' TYPE named PROP."
(get (button-category-symbol type) prop))
(defun button-type-subtype-p (type supertype)
- "Return non-nil if button-type TYPE is a subtype of SUPERTYPE."
+ "Return non-nil if `button-type' TYPE is a subtype of SUPERTYPE."
(or (eq type supertype)
(and type
(button-type-subtype-p (button-type-get type 'supertype)
(button-end button))))
(defsubst button-type (button)
- "Return BUTTON's button-type."
+ "Return BUTTON's `button-type'."
(button-get button 'type))
(defun button-has-type-p (button type)
- "Return non-nil if BUTTON has button-type TYPE, or one of its subtypes."
+ "Return non-nil if BUTTON has `button-type' TYPE, or one of its subtypes."
(button-type-subtype-p (button-get button 'type) type))
(defun button--area-button-p (b)
(defun make-button (beg end &rest properties)
"Make a button from BEG to END in the current buffer.
-The remaining arguments form a plist of PROPERTY VALUE pairs,
-specifying properties to add to the button.
+The remaining PROPERTIES arguments form a plist of PROPERTY VALUE
+pairs, specifying properties to add to the button.
In addition, the keyword argument :type may be used to specify a
-button-type from which to inherit other properties; see
+`button-type' from which to inherit other properties; see
`define-button-type'.
Also see `make-text-button', `insert-button'."
The remaining arguments form a plist of PROPERTY VALUE pairs,
specifying properties to add to the button.
In addition, the keyword argument :type may be used to specify a
-button-type from which to inherit other properties; see
+`button-type' from which to inherit other properties; see
`define-button-type'.
Also see `insert-text-button', `make-button'."
(defun make-text-button (beg end &rest properties)
"Make a button from BEG to END in the current buffer.
-The remaining arguments form a plist of PROPERTY VALUE pairs,
-specifying properties to add to the button.
+The remaining PROPERTIES arguments form a plist of PROPERTY VALUE
+pairs, specifying properties to add to the button.
In addition, the keyword argument :type may be used to specify a
-button-type from which to inherit other properties; see
+`button-type' from which to inherit other properties; see
`define-button-type'.
This function is like `make-button', except that the button is actually
(defun insert-text-button (label &rest properties)
"Insert a button with the label LABEL.
-The remaining arguments form a plist of PROPERTY VALUE pairs,
-specifying properties to add to the button.
+The remaining PROPERTIES arguments form a plist of PROPERTY VALUE
+pairs, specifying properties to add to the button.
In addition, the keyword argument :type may be used to specify a
-button-type from which to inherit other properties; see
+`button-type' from which to inherit other properties; see
`define-button-type'.
This function is like `insert-button', except that the button is
("₋" "-") ; -
("₍" "(") ; (
("₎" ")")) ; )
- "A list whose elements (old new) indicate replacements to make
-in Calc algebraic input.")
+ "A list indicating replacements to make in Calc algebraic input.")
(defvar math-read-superscripts
"⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁽⁾ⁿⁱ" ; 0123456789+-()ni
fmt))))
(defconst math-julian-date-beginning '(float 17214245 -1)
- "The beginning of the Julian date calendar,
-as measured in the number of days before December 31, 1 BC (Gregorian).")
+ "The beginning of the Julian date calendar.
+This is measured in the number of days before December 31, 1
+BC (Gregorian).")
(defconst math-julian-date-beginning-int 1721425
- "The beginning of the Julian date calendar,
-as measured in the integer number of days before December 31, 1 BC (Gregorian).")
+ "The beginning of the Julian date calendar.
+This is measured in the integer number of days before December
+31, 1 BC (Gregorian).")
(defconst math-unix-epoch 719163
- "The beginning of Unix time: days from December 31, 1 BC (Gregorian)
-to Jan 1, 1970 AD.")
+ "The beginning of Unix time.
+This is measured in the integer number of days from December 31,
+1 BC (Gregorian) to Jan 1, 1970 AD.")
(defun math-format-date-part (x)
(cond ((stringp x)
(defun math-atomic-factorp (expr)
- "Return true if is a factor containing no sums or quotients."
+ "Return non-nil if is a factor containing no sums or quotients."
(cond ((eq (car-safe expr) '*)
(and (math-atomic-factorp (nth 1 expr))
(math-atomic-factorp (nth 2 expr))))
:type 'boolean)
(defcustom calc-ensure-consistent-units nil
- "If non-nil, make sure new units are consistent with current units
-when converting units."
+ "If non-nil, ensure new units are consistent with current units when converting."
:version "24.3"
:type 'boolean)
(defvar calc-display-sci-high 0
"Floating-point numbers with this positive exponent or higher above the
-current precision are displayed in scientific notation in calc-mode.")
+current precision are displayed in scientific notation in `calc-mode'.")
(defvar calc-display-sci-low -3
"Floating-point numbers with this negative exponent or lower are displayed
-scientific notation in calc-mode.")
+scientific notation in `calc-mode'.")
(defvar calc-digit-after-point nil
"If t, display at least one digit after the decimal point, as in `12.0'.
"List of variables used in customizing GNU Calc.")
(defmacro defcalcmodevar (var defval &optional doc)
- "Declare VAR as a Calc variable, with default value DEFVAL
-and doc-string DOC.
+ "Declare VAR as a Calc variable, with default value DEFVAL and doc-string DOC.
The variable VAR will be added to `calc-mode-var-list'."
`(progn
(defvar ,var ,defval ,doc)
(defvar calc-trail-pointer nil
"The \"current\" entry in trail buffer.")
(defvar calc-trail-overlay nil
- "The value of overlay-arrow-string.")
+ "The value of `overlay-arrow-string'.")
(defvar calc-undo-list nil
"The list of previous operations for undo.")
(defvar calc-redo-list nil
(concat prompt (if (<= trim 0) expr (substring expr trim)))))
(defun calculator-string-to-number (str)
- "Convert the given STR to a number, according to the value of
-`calculator-input-radix'."
+ "Convert STR to number according to `calculator-input-radix'."
(if calculator-input-radix
(string-to-number str (cadr (assq calculator-input-radix
'((bin 2) (oct 8) (hex 16)))))
;;; Input interaction
(defun calculator-last-input (&optional keys)
- "Return the last key sequence that was used to invoke this command, or
-the input KEYS. Uses the `function-key-map' translate keypad numbers to
-plain ones."
+ "Return the last key sequence used to invoke this command, or the input KEYS.
+Uses the `function-key-map' translate keypad numbers to plain
+ones."
(let* ((inp (or keys (this-command-keys)))
(inp (or (and (arrayp inp) (not (stringp inp))
(lookup-key function-key-map inp))
\(diary-mail-entries)
-# diary-rem.el ends here
-"
+# diary-rem.el ends here"
(interactive "P")
(if (string-equal diary-mail-addr "")
(user-error "You must set `diary-mail-addr' to use this command")
paren))
(defvar diary-marking-entries-flag nil
- "True during the marking of diary entries, nil otherwise.")
+ "Non-nil during the marking of diary entries, nil otherwise.")
(defvar diary-marking-entry-flag nil
- "True during the marking of diary entries, if current entry is marking.")
+ "Non-nil during the marking of diary entries, if current entry is marking.")
;; file-glob-attrs bound in diary-mark-entries.
(defun diary-mark-entries-1 (markfunc &optional months symbol absfunc)
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;;; Code:
(eval-and-compile
Delete converts tabs to spaces as it moves back.
Tab indents for Scheme; with argument, shifts rest
of expression rigidly with the current line.
-C-M-q does Tab on each line starting within following expression.
+\\[indent-pp-sexp] does Tab on each line starting within following expression.
Paragraphs are separated only by blank lines. Semicolons start comments.
If you accidentally suspend your process, use \\[comint-continue-subjob]
to continue it."
(when (>= count 0) (comint-update-fence))))
(defun comint-kill-region (beg end)
- "Like `kill-region', but ignores read-only properties, if safe.
+ "Like `kill-region', but ignore read-only properties, if safe.
This command assumes that the buffer contains read-only
\"prompts\" which are regions with front-sticky read-only
properties at the beginning of a line, with the preceding newline
The following commands are available:
\\<widget-keymap>\
-Move to next button, link or editable field. \\[widget-forward]
-Move to previous button, link or editable field. \\[widget-backward]
+Move to next button, link or editable field. \\[widget-forward]
+Move to previous button, link or editable field. \\[widget-backward]
\\<custom-field-keymap>\
Complete content of editable text field. \\[widget-complete]
\\<custom-mode-map>\
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;;; Code:
(require 'widget)
major-mode)))
(defun dabbrev--goto-start-of-abbrev ()
- "Back over all abbrev type characters and then moves forward over
-all skip characters."
+ "Back over all abbrev type characters then move forward over all skip characters."
;; Move backwards over abbrev chars
(save-match-data
(when (> (point) (minibuffer-prompt-end))
(user-error
"No compression rule found for \
`dired-compress-directory-default-suffix' %s, see `dired-compress-files-alist' for\
- the supported suffixes list."
+ the supported suffixes list"
dired-compress-directory-default-suffix)))
(let* ((suffix (or dired-compress-file-default-suffix ".gz"))
(out-name (concat file suffix))
dired-compress-file-alist)))
(if (not rule)
(user-error "No compression rule found for suffix %s, \
-see `dired-compress-file-alist' for the supported suffixes list."
+see `dired-compress-file-alist' for the supported suffixes list"
dired-compress-file-default-suffix)
(and (file-exists-p file)
(or (not (file-exists-p out-name))
output file, for example one you got from an ftp server. With
ange-ftp, you can even Dired a directory containing an ls-lR file,
visit that file and turn on Virtual Dired mode. But don't try to save
-this file, as dired-virtual indents the listing and thus changes the
+this file, as `dired-virtual' indents the listing and thus changes the
buffer.
If you have saved a Dired buffer in a file you can use \\[dired-virtual] to
If several COMMANDs are given, the first one will be the default
and the rest will be added temporarily to the history and can be retrieved
-with \\[previous-history-element] (M-p) .
+with `previous-history-element' (\\<minibuffer-mode-map>\\[previous-history-element]).
The variable `dired-guess-shell-case-fold-search' controls whether
REGEXP is matched case-sensitively."
;; Autoload cookie needed by desktop.el
;;;###autoload
(defun dired-mode (&optional dirname switches)
- "\
-Mode for \"editing\" directory listings.
+ "Mode for \"editing\" directory listings.
In Dired, you are \"editing\" a list of the files in a directory and
(optionally) its subdirectories, in the format of `ls -lR'.
Each directory is a page: use \\[backward-page] and \\[forward-page] to move pagewise.
(defun dired-mark-files-in-region (start end)
(let ((inhibit-read-only t))
(if (> start end)
- (error "start > end"))
+ (error "Start > End"))
(goto-char start) ; assumed at beginning of line
(while (< (point) end)
;; Skip subdir line and following garbage like the `total' line:
;;;###autoload
(define-minor-mode display-fill-column-indicator-mode
- "Toggle display of fill-column indicator.
+ "Toggle display of `fill-column' indicator.
This uses `display-fill-column-indicator' internally.
To change the position of the column displayed by default
:type '(repeat string))
(defcustom dos-codepage-setup-hook nil
- "List of functions to be called after the DOS terminal and coding
-systems are set up. This is the place, e.g., to set specific entries
-in `standard-display-table' as appropriate for your codepage, if
+ "List of functions to call after setting up DOS terminal and coding systems.
+This is the place, e.g., to set specific entries in
+`standard-display-table' as appropriate for your codepage, if
`IT-display-table-setup' doesn't do a perfect job."
:type '(hook)
:version "20.3.3")
(memq cmd-noremap '(call-last-kbd-macro kmacro-call-macro kmacro-end-or-call-macro kmacro-end-and-call-macro))
(member keys '("\r" [return])))
(or last-kbd-macro
- (y-or-n-p "No keyboard macro defined. Create one? ")
+ (y-or-n-p "No keyboard macro defined. Create one?")
(keyboard-quit))
(setq mac (or last-kbd-macro ""))
(setq keys nil)
(and (fboundp cmd) (not (arrayp (symbol-function cmd)))
(not (get cmd 'kmacro))
(not (y-or-n-p
- (format "Command %s is already defined; %s"
- cmd "proceed? ")))
+ (format
+ "Command %s is already defined; proceed?"
+ cmd)))
(keyboard-quit))))
t)
((looking-at "Key:\\(.*\\)$")
(not (or (arrayp (symbol-function b))
(get b 'kmacro))))
(not (y-or-n-p
- (format "Key %s is already defined; %s"
- (edmacro-format-keys key 1)
- "proceed? ")))
+ (format
+ "Key %s is already defined; proceed?"
+ (edmacro-format-keys key 1))))
(keyboard-quit))))))
t)
((looking-at "Counter:[ \t]*\\([^ \t\n]*\\)[ \t]*$")
just skip that character instead, so that hitting ( followed by ) results
in \"()\" rather than \"())\".
-This can be convenient for people who find it easier to hit ) than C-f.
+This can be convenient for people who find it easier to hit ) than \\[forward-char].
Can also be a function of one argument (the closer char just
inserted), in which case that function's return value is
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;;; Code:
(require 'epa)
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;;; Code:
-;;; Dependencies
(require 'epa)
(require 'epa-hook)
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;;; Code:
(defgroup epa-file nil
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;;; Code:
-;;; Dependencies
(require 'epa)
(require 'mail-utils)
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;;; Code:
-;;; Dependencies
(require 'epg)
(eval-when-compile (require 'subr-x))
;;;###autoload
(defun epa-select-keys (context prompt &optional names secret)
"Display a user's keyring and ask him to select keys.
-CONTEXT is an epg-context.
+CONTEXT is an `epg-context'.
PROMPT is a string to prompt with.
NAMES is a list of strings to be matched with keys. If it is nil, all
the keys are listed.
;;;###autoload
(defun epa-verify-cleartext-in-region (start end)
- "Verify OpenPGP cleartext signed messages in the current region
-between START and END.
+ "Verify OpenPGP cleartext signed messages in current region from START to END.
Don't use this command in Lisp programs!
See the reason described in the `epa-verify-region' documentation."
;;;###autoload
(defun epa-import-armor-in-region (start end)
- "Import keys in the OpenPGP armor format in the current region
-between START and END."
+ "Import keys in the OpenPGP armor format in the current region from START to END."
(interactive "r")
(save-excursion
(save-restriction
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;;; Code:
;;; Prelude
(when (and epg-key-id
(string-match "\\`passphrase\\." string))
(unless (epg-context-passphrase-callback context)
- (error "passphrase-callback not set"))
+ (error "Variable `passphrase-callback' not set"))
(let (inhibit-quit
passphrase
passphrase-with-new-line
(defcustom buffer-face-mode-face 'variable-pitch
"The face specification used by `buffer-face-mode'.
It may contain any value suitable for a `face' text property,
-including a face name, a list of face names, a face-attribute
+including a face name, a list of face names, a face attribute
plist, etc."
:type '(choice (face)
(repeat :tag "List of faces" face)
(defalias 'x-defined-colors 'defined-colors)
(defun defined-colors-with-face-attributes (&optional frame foreground)
- "Return a list of colors supported for a particular frame.
-See `defined-colors' for arguments and return value. In contrast
+ "Return a list of colors supported for a particular FRAME.
+See `defined-colors' for arguments and return value. In contrast
to `defined-colors' the elements of the returned list are color
strings with text properties, that make the color names render
with the color they represent as background color (if FOREGROUND
mesg) nil)
((string-match "not responding$" mesg) mesg)
;; v19:
- ;; (file-error "connection failed" "permission denied"
+ ;; (file-error "Connection failed" "permission denied"
;; "nonesuch" "ffap-machine-p")
- ;; (file-error "connection failed" "host is unreachable"
+ ;; (file-error "Connection failed" "host is unreachable"
;; "gopher.house.gov" "ffap-machine-p")
- ;; (file-error "connection failed" "address already in use"
+ ;; (file-error "Connection failed" "address already in use"
;; "ftp.uu.net" "ffap-machine-p")
((equal mesg "connection failed")
(if (string= (downcase (nth 2 error)) "permission denied")
(latex-mode "--:\\\\$+<>@-Z_[:alpha:]~*?" "<@" "@>;.,!:")
(tex-mode "--:\\\\$+<>@-Z_[:alpha:]~*?" "<@" "@>;.,!:")
)
- "Alist of (MODE CHARS BEG END), where MODE is a symbol,
-possibly a major-mode name, or one of the symbols
+ "Alist of (MODE CHARS BEG END), where MODE is a symbol.
+This is possibly a major-mode name, or one of the symbols
`file', `url', `machine', and `nocolon'.
Function `ffap-string-at-point' uses the data fields as follows:
1. find a maximal string of CHARS around point,
(defcustom fileloop-revert-buffers 'silent
"Whether to revert files during fileloop operation.
+This can be one of:
`silent' means to only do it if `revert-without-query' is applicable;
t means to offer to do it for all applicable files;
nil means never to do it"
already exists unless optional fourth argument OK-IF-ALREADY-EXISTS
is non-nil. A number as fourth arg means request confirmation if
the new name already exists. This is what happens in interactive
-use with M-x."
+use with \\[execute-extended-command]."
(interactive
(let ((default-coding (or file-name-coding-system
default-file-name-coding-system))
(current-buffer))))
\f
(defun insert-file-contents-literally (filename &optional visit beg end replace)
- "Like `insert-file-contents', but only reads in the file literally.
+ "Like `insert-file-contents', but only read in the file literally.
See `insert-file-contents' for an explanation of the parameters.
A buffer may be modified in several ways after reading into the buffer,
due to Emacs features such as format decoding, character code
(defvar filesets-updated-buffers nil
"A list of buffers with updated menu bars.")
(defvar filesets-menu-use-cached-flag nil
- "Use cached data. See `filesets-menu-ensure-use-cached' for details.")
+ "Non-nil means use cached data.
+See `filesets-menu-ensure-use-cached' for details.")
(defvar filesets-update-cache-file-flag nil
"Non-nil means the cache needs updating.")
(defvar filesets-ignore-next-set-default nil
(:ignore-on-read-text t)
;; (:constraintp ,pic-cmd)
))))
- "Alist of file patterns and external viewers for use with
-`filesets-find-or-display-file'.
+ "Alist of file patterns and external viewers.
+This is intended for use with `filesets-find-or-display-file'.
Has the form ((FILE-PATTERN VIEWER PROPERTIES) ...), VIEWER being either a
function or a command name as string.
filesets-data nil)))
(entry (or (assoc name filesets-data)
(when (y-or-n-p
- (format "Fileset %s does not exist. Create it? "
+ (format "Fileset %s does not exist. Create it?"
name))
(progn
(add-to-list 'filesets-data (list name '(:files)))
nil))
(defun filesets-build-dir-submenu (entry lookup-name dir patt)
- "Build a :tree submenu named LOOKUP-NAME with base directory DIR including
-all files matching PATT for filesets ENTRY."
+ "Build a `:tree' submenu named LOOKUP-NAME.
+It has base directory DIR including all files matching PATT for
+filesets ENTRY."
(let ((fd (filesets-entry-get-filter-dirs-flag entry))
(depth (or (filesets-entry-get-tree-max-level entry)
filesets-tree-max-level)))
;;;###autoload
(defun find-name-dired (dir pattern)
- "Search DIR recursively for files matching the globbing pattern PATTERN,
+ "Search DIR recursively for files matching the globbing PATTERN,
and run Dired on those files.
PATTERN is a shell wildcard (not an Emacs regexp) and need not be quoted.
The default command run (after changing into DIR) is
Normally the body and the immediate subheadings are exposed, but
optional arg EXPOSURE \(interactively with prefix arg) changes this:-
- EXPOSURE > 0 exposes n levels of subheadings (c.f. show-children)
+ EXPOSURE > 0 exposes n levels of subheadings (c.f. `show-children')
EXPOSURE < 0 exposes only the body
EXPOSURE = 0 exposes the entire subtree"
(interactive "P")
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;;; Code:
;; This variable is used by mode packages that support Font Lock mode by
;;; Other commands
(defun forms-toggle-read-only (arg)
- "Toggles read-only mode of a forms mode buffer.
+ "Toggle read-only mode of a forms mode buffer.
With an argument, enables read-only mode if the argument is positive.
Otherwise enables edit mode if the visited file is writable."
(setq forms--search-regexp regexp))
(defun forms-save-buffer (&optional args)
- "Forms mode replacement for save-buffer.
+ "Forms mode replacement for `save-buffer'.
It saves the data buffer instead of the forms buffer.
Calls `forms-write-file-filter' before, and `forms-read-file-filter'
after writing out the data."
;; startup stuff.
-(easy-menu-define hexl-menu hexl-mode-map "Hexl Mode menu"
+(easy-menu-define hexl-menu hexl-mode-map "Hexl Mode menu."
'("Hexl"
:help "Hexl-specific Features"
"String used to identify hi-lock patterns at the start of files.")
(defvar hi-lock-archaic-interface-message-used nil
- "True if user alerted that `global-hi-lock-mode' is now the global switch.
+ "Non-nil if user alerted that `global-hi-lock-mode' is now the global switch.
Earlier versions of hi-lock used `hi-lock-mode' as the global switch;
the message is issued if it appears that `hi-lock-mode' is used assuming
that older functionality. This variable avoids multiple reminders.")
(defcustom image-dired-show-all-from-dir-max-files 50
"Maximum number of files to show using `image-dired-show-all-from-dir'
-before warning the user."
+before warning."
:type 'integer)
(defmacro image-dired--with-db-file (&rest body)
(image-dired-display-image (dired-get-filename) arg))
(defun image-dired-image-at-point-p ()
- "Return true if there is an image-dired thumbnail at point."
+ "Return non-nil if there is an `image-dired' thumbnail at point."
(get-text-property (point) 'image-dired-thumbnail))
(defun image-dired-rotate-thumbnail (degrees)
(defvar imenu-buffer-menubar nil)
(defvar-local imenu-menubar-modified-tick 0
- "The value of (buffer-chars-modified-tick) as of the last call
-to `imenu-update-menubar'.")
+ "Value of (buffer-chars-modified-tick) when `imenu-update-menubar' was called.")
(defun imenu-update-menubar ()
(when (and (current-local-map)
(put-text-property begin to prop (funcall func val) object))))
(defun increase-left-margin (from to inc)
- "Increase or decrease the left-margin of the region.
+ "Increase or decrease the `left-margin' of the region.
With no prefix argument, this adds `standard-indent' of indentation.
A prefix arg (optional third arg INC noninteractively) specifies the amount
to change the margin by, in characters.
(defun beginning-of-line-text (&optional n)
"Move to the beginning of the text on this line.
-With optional argument, move forward N-1 lines first.
-From the beginning of the line, moves past the left-margin indentation, the
-fill-prefix, and any indentation used for centering or right-justifying the
-line, but does not move past any whitespace that was explicitly inserted
-\(such as a tab used to indent the first line of a paragraph)."
+
+With optional argument N, move forward N-1 lines first.
+
+From the beginning of the line, moves past the `left-margin'
+indentation, the `fill-prefix', and any indentation used for
+centering or right-justifying the line, but does not move past
+any whitespace that was explicitly inserted (such as a tab used
+to indent the first line of a paragraph)."
(interactive "^p")
(beginning-of-line n)
(skip-chars-forward " \t")
(defun info-lookup-symbol (symbol &optional mode)
"Display the definition of SYMBOL, as found in the relevant manual.
When this command is called interactively, it reads SYMBOL from the
-minibuffer. In the minibuffer, use M-n to yank the default argument
+minibuffer. In the minibuffer, use \\<minibuffer-local-completion-map>\
+\\[next-history-element] to yank the default argument
value into the minibuffer so you can edit it. The default symbol is the
one found at point.
(defun info-lookup-file (file &optional mode)
"Display the documentation of a file.
When this command is called interactively, it reads FILE from the minibuffer.
-In the minibuffer, use M-n to yank the default file name
+In the minibuffer, use \\<minibuffer-local-completion-map>\
+\\[next-history-element] to yank the default file name
into the minibuffer so you can edit it.
The default file name is the one found at point.
(ccl-embed-data (cons symbol prop)))
(defun ccl-embed-string (len str)
- "Embed string STR of length LEN in `ccl-program-vector' at
-`ccl-current-ic'."
+ "Embed string STR of length LEN in `ccl-program-vector' at `ccl-current-ic'."
(if (> len #xFFFFF)
(error "CCL: String too long: %d" len))
(if (> (string-bytes str) len)
(defvar ccl-loop-head nil
"If non-nil, index of the start of the current loop.")
(defvar ccl-breaks nil
- "If non-nil, list of absolute addresses of the breaking points of
-the current loop.")
+ "If non-nil, list of absolute addresses of breaking points of the current loop.")
;;;###autoload
(defun ccl-compile (ccl-program)
(cdr (cdr cmd))))
(defun ccl-compile-branch-expression (expr cmd)
- "Compile EXPRESSION part of BRANCH statement and return register
-which holds a value of the expression."
+ "Compile EXPRESSION part of BRANCH statement.
+Return register which holds a value of the expression."
(if (listp expr)
;; EXPR has the form `(EXPR2 OP ARG)'. Compile it as SET
;; statement of the form `(r7 = (EXPR2 OP ARG))'.
MAP-IDs := MAP-ID ...
MAP-SET := MAP-IDs | (MAP-IDs) MAP-SET
-MAP-ID := integer
-"
+MAP-ID := integer"
(declare (doc-string 3))
`(let ((prog ,(unwind-protect
(progn
vs. corresponding command to be called.
If SIMPLE is non-nil, then we do not alter the meanings of
-commands such as C-f, C-b, C-n, C-p and TAB; they are treated as
+commands such as \\[forward-char], \\[backward-char], \\[next-line], \
+\\[previous-line] and \\[indent-for-tab-command]; they are treated as
non-Quail commands."
(let (translation-keymap conversion-keymap)
(if deterministic (setq forget-last-selection t))
(?c \"AC\"
(?d \"ACD\")
(?e \"ACE\")))
- (?b \"B\"))
-")
+ (?b \"B\"))")
;;;###autoload
(defmacro robin-define-package (name docstring &rest rules)
When the arg RECURSIVE-EDIT is non-nil, this function behaves modally and
does not return to the calling function until the search is completed.
-To behave this way it enters a recursive-edit and exits it when done
+To behave this way it enters a recursive edit and exits it when done
isearching.
The arg REGEXP-FUNCTION, if non-nil, should be a function. It is
(defcustom jit-lock-chunk-size 1500
"Jit-lock fontifies chunks of at most this many characters at a time.
-This variable controls both display-time and stealth fontification.
+This variable controls both `display-time' and stealth fontification.
The optimum value is a little over the typical number of buffer
characters which fit in a typical window."
(defun kmacro-bind-to-key (_arg)
"When not defining or executing a macro, offer to bind last macro to a key.
-The key sequences [C-x C-k 0] through [C-x C-k 9] and [C-x C-k A]
-through [C-x C-k Z] are reserved for user bindings, and to bind to
+The key sequences `C-x C-k 0' through `C-x C-k 9' and `C-x C-k A'
+through `C-x C-k Z' are reserved for user bindings, and to bind to
one of these sequences, just enter the digit or letter, rather than
the whole sequence.
;; So we use this auxiliary variable to keep track of the last (t . SYMBOL)
;; that occurred.
(defvar loadhist--restore-autoload nil
- "If non-nil, this is a symbol for which we should
-restore a previous autoload if possible.")
+ "If non-nil, is a symbol for which to try to restore a previous autoload.")
(cl-defmethod loadhist-unload-element ((x (head t)))
(setq loadhist--restore-autoload (cdr x)))
;; from a shell prompt. GNU locate and BSD find expect the file databases
;; to either be in standard places or located via environment variables.
;; If the latter, make sure these environment variables are set in
-;; your emacs process.
+;; your Emacs process.
;;
;; Locate-mode assumes that each line output from the locate-command
;; consists exactly of a file name, possibly preceded or trailed by
;;;###autoload
(defun kbd-macro-query (flag)
"Query user during kbd macro execution.
- With prefix argument, enters recursive edit, reading keyboard
-commands even within a kbd macro. You can give different commands
-each time the macro executes.
- Without prefix argument, asks whether to continue running the macro.
+
+With prefix argument FLAG, enter recursive edit, reading
+keyboard commands even within a kbd macro. You can give
+different commands each time the macro executes.
+
+Without prefix argument, ask whether to continue running the
+macro.
+
Your options are: \\<query-replace-map>
+
\\[act] Finish this iteration normally and continue with the next.
\\[skip] Skip the rest of this iteration, and start the next.
\\[exit] Stop the macro entirely right now.
(> count 1)))
(defcustom yank-menu-length 20
- "Maximum length to display in the yank-menu."
+ "Maximum length to display in the `yank-menu'."
:type 'integer
:group 'menu)
It must accept a buffer as its only required argument.")
(defun menu-bar-buffer-vector (alist)
- ;; turn ((name . buffer) ...) into a menu
+ "Turn ((name . buffer) ...) into a menu."
(let ((buffers-vec (make-vector (length alist) nil))
(i (length alist)))
(dolist (pair alist)
buffers-vec))
(defun menu-bar-update-buffers (&optional force)
- ;; If user discards the Buffers item, play along.
+ "If user discards the Buffers item, play along."
(and (lookup-key (current-global-map) [menu-bar buffer])
(or force (frame-or-buffer-changed-p))
(let ((buffers (buffer-list))
(= (cdr start-col-row) (cdr end-col-row)))))
(defvar mouse-drag-electric-col-scrolling t
- "If non-nil, mouse-drag on a long line enables truncate-lines.")
+ "If non-nil, mouse-drag on a long line enables `truncate-lines'.")
(defun mouse-drag-should-do-col-scrolling ()
"Determine if it's wise to enable col-scrolling for the current window.
:type 'boolean)
(defcustom mouse-drag-copy-region nil
- "If non-nil, copy to kill-ring upon mouse adjustments of the region.
+ "If non-nil, copy to kill ring upon mouse adjustments of the region.
This affects `mouse-save-then-kill' (\\[mouse-save-then-kill]) in
addition to mouse drags.
;; because Emacs turns C-c C-i into C-c TAB which is hard to type and
;; not mnemonic.
"Major mode for editing XML.
-
+\\<nxml-mode-map>
\\[nxml-finish-element] finishes the current element by inserting an end-tag.
+
C-c C-i closes a start-tag with `>' and then inserts a balancing end-tag
leaving point between the start-tag and end-tag.
\\[nxml-balanced-close-start-tag-block] is similar but for block rather than inline elements:
nil
(error "Buffer does not have a filename")))
((and prompt
- (not (y-or-n-p (format "Save %s to %s "
+ (not (y-or-n-p (format "Save %s to %s?"
(if type-id
"type identifier"
"schema location")
locating-file-uri))))))
(indent-according-to-mode)
(when (or (not modified)
- (y-or-n-p (format "Save file %s "
+ (y-or-n-p (format "Save file %s?"
(buffer-file-name))))
(save-buffer))))))))
(and type t)))
(defun rng-process-start-tag (tag-type)
- "TAG-TYPE is `start-tag' for a start-tag, `empty-element' for
-an empty element. `partial-empty-element' should be passed
-as empty-element."
+ "TAG-TYPE is `start-tag' for a start-tag, `empty-element' for an empty element.
+`partial-empty-element' should be passed as empty-element."
(and rng-collecting-text (rng-flush-text))
(setq rng-collecting-text nil)
(setq rng-pending-contents nil)
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;;; Code:
(eval-when-compile (require 'cl-lib))
(defun 5x5-crack (breeder)
"Attempt to find a solution for 5x5.
-5x5-crack takes the argument BREEDER which should be a function that takes
+`5x5-crack' takes the argument BREEDER which should be a function that takes
two parameters, the first will be a grid vector array that is the current
solution and the second will be the best solution so far. The function
should return a grid vector array that is the new solution."
grid)))
(defun 5x5-vec-to-grid (grid-matrix)
- "Convert a grid matrix GRID-MATRIX in Calc format to a grid in
-5x5 format. See function `5x5-grid-to-vec'."
+ "Convert a grid matrix GRID-MATRIX in Calc format to a grid in 5x5 format.
+See function `5x5-grid-to-vec'."
(apply
#'vector
(mapcar
(defun doc// (x) x)
(defmacro doc$ (what)
- "Quoted arg form of doctor-$."
+ "Quoted arg form of `doctor-$'."
`(doctor-$ ',what))
(defun doctor-$ (what)
(defun doctor-subjsearch (sent key type)
"Search for the subject of a sentence SENT, looking for the noun closest
-to and preceding KEY by at least TYPE words. Set global variable doctor-subj to
+to and preceding KEY by at least TYPE words. Set global variable `doctor-subj' to
the subject noun, and return the portion of the sentence following it."
(let ((i (- (length sent) (length (memq key sent)) type)))
(while (and (> i -1) (not (doctor-nounp (nth i sent))))
(list obj-pc) ;; pc-area
nil nil nil nil nil nil
)
- "These are objects in a room that are only described in the
-room description. They are permanent.")
+ "These are objects in a room that are only described in the room description.
+They are permanent.")
(defvar dun-inventory '(1))
(defconst dun-objects
nil nil
("There is a bus here.")
nil nil nil)
- "These are the descriptions for the negative numbered objects from
-`dun-room-objects'.")
+ "Descriptions for the negative numbered objects from `dun-room-objects'.")
(defconst dun-physobj-desc '(
(dun-mprincl "You are on the bus."))))
(defun dun-special-object ()
- "There is a special object in the room. This object's description,
-or lack thereof, depends on certain conditions."
+ "There is a special object in the room.
+This object's description, or lack thereof, depends on certain
+conditions."
(cond
((= dun-current-room computer-room)
(if dun-computer
(defun hanoi-unix-64 ()
"Like `hanoi-unix', but pretend to have a 64-bit clock.
This is, necessarily (as of Emacs 20.3), a crock. When the
-current-time interface is made s2G-compliant, hanoi.el will need
+`current-time' interface is made s2G-compliant, hanoi.el will need
to be updated."
(interactive)
(let* ((start (ftruncate (float-time)))
;; Some variables for game tracking
;;---------------------------------
(defvar mpuz-in-progress nil
- "True if a game is currently in progress.")
+ "Non-nil if a game is currently in progress.")
(defvar mpuz-found-digits (make-bool-vector 10 nil)
"A vector recording which digits have been decrypted.")
rotate the shape to fit in with those at the bottom of the screen so
as to form complete rows.
-tetris-mode keybindings:
+`tetris-mode' keybindings:
\\<tetris-mode-map>
\\[tetris-start-game] Start a new game of Tetris
\\[tetris-end-game] Terminate the current game
(set VARIABLE (eval VALUE))
- Note that VALUE can be any valid lisp expression. So, don't
+ Note that VALUE can be any valid Lisp expression. So, don't
forget to quote symbols and constant lists.
If VARIABLE is the special keyword `inherits-from:', VALUE must
be a symbol name setting defined in `pr-setting-database' from
`https://linux.die.net/man/1/lp'
* GNU utilities for w32 (cp.exe)
- `http://unxutils.sourceforge.net/'
-"
+ `http://unxutils.sourceforge.net/'"
:type '(repeat
(list
:tag "PostScript Printer"
(set (make-local-variable VARIABLE-SYM) (eval VALUE))
- Note that VALUE can be any valid lisp expression. So, don't
+ Note that VALUE can be any valid Lisp expression. So, don't
forget to quote symbols and constant lists.
If VARIABLE is the special keyword `inherits-from:', VALUE must
be a symbol name setting defined in `pr-setting-database' from
* GNU Enscript documentation (Windows, GNU or Unix)
`https://people.ssh.com/mtr/genscript/enscript.man.html'
- (on GNU or Unix, type `man enscript')
-"
+ (on GNU or Unix, type `man enscript')"
:type '(repeat
(list :tag "PS File Utility"
(symbol :tag "Utility Symbol")
Interactively, you have the following situations:
- M-x pr-ps-fast-fire RET
+ \\[pr-ps-fast-fire]
The command prompts the user for a N-UP value and printing will
immediately be done using the current active printer.
;;; Entries
(defun profiler-format-entry (entry)
- "Format ENTRY in human readable string. ENTRY would be a
-function name of a function itself."
+ "Format ENTRY in human readable string.
+ENTRY would be a function name of a function itself."
(cond ((memq (car-safe entry) '(closure lambda))
(format "#<lambda %#x>" (sxhash entry)))
((byte-code-function-p entry)
"The current profile.")
(defvar-local profiler-report-reversed nil
- "True if calltree is rendered in bottom-up.
+ "Non-nil if calltree is rendered in bottom-up.
Do not touch this variable directly.")
(defvar-local profiler-report-order nil
'(progn)))
(defmacro cc-provide (feature)
- "A replacement for the `provide' form that restores the environment
-after the compilation. Don't use within `eval-when-compile'."
+ "A replacement for `provide' that restores the environment after the compilation.
+Don't use within `eval-when-compile'."
(declare (debug t))
`(progn
(eval-when-compile (cc-bytecomp-restore-environment))
(eval-when-compile (cc-bytecomp-setup-environment))))
(defmacro cc-bytecomp-defvar (var)
- "Bind the symbol as a variable during compilation of the file,
-to silence the byte compiler. Don't use within `eval-when-compile'."
+ "Bind the symbol VAR as a variable during compilation of the file.
+This can be used to silence the byte compiler. Don't use within
+`eval-when-compile'."
(declare (debug nil))
`(eval-when-compile
(if (boundp ',var)
"cc-bytecomp-defvar: Covered variable %s" ',var))))))
(defmacro cc-bytecomp-defun (fun)
- "Bind the symbol as a function during compilation of the file,
-to silence the byte compiler. Don't use within `eval-when-compile'.
+ "Bind the symbol FUN as a function during compilation of the file.
+This can be used to silence the byte compiler. Don't use within
+`eval-when-compile'.
If the symbol already is bound as a function, it will keep that
definition. That means that this macro will not shut up warnings
"cc-bytecomp-defun: Covered function %s" ',fun))))))
(defmacro cc-bytecomp-put (symbol propname value)
- "Set a property on a symbol during compilation (and evaluation) of
-the file. Don't use outside `eval-when-compile'."
+ "Set a property on SYMBOL during compilation (and evaluation) of the file.
+Don't use outside `eval-when-compile'."
(declare (debug t))
`(eval-when-compile
(if (not (assoc (cons ,symbol ,propname) cc-bytecomp-original-properties))
,propname ,symbol ,value)))
(defmacro cc-bytecomp-boundp (symbol)
- "Return non-nil if the given symbol is bound as a variable outside
-the compilation. This is the same as using `boundp' but additionally
-exclude any variables that have been bound during compilation with
+ "Return non-nil if SYMBOL is bound as a variable outside the compilation.
+This is the same as using `boundp' but additionally exclude any
+variables that have been bound during compilation with
`cc-bytecomp-defvar'."
(declare (debug t))
(if (and (cc-bytecomp-is-compiling)
`(boundp ,symbol)))
(defmacro cc-bytecomp-fboundp (symbol)
- "Return non-nil if the given symbol is bound as a function outside
-the compilation. This is the same as using `fboundp' but additionally
-exclude any functions that have been bound during compilation with
+ "Return non-nil if SYMBOL is bound as a function outside the compilation.
+This is the same as using `fboundp' but additionally exclude any
+functions that have been bound during compilation with
`cc-bytecomp-defun'."
(declare (debug t))
(let (fun-elem)
(defun c-context-open-line ()
"Insert a line break suitable to the context and leave point before it.
-This is the `c-context-line-break' equivalent to `open-line', which is
-normally bound to C-o. See `c-context-line-break' for the details."
+This is the `c-context-line-break' equivalent to `open-line'
+\(bound to \\[open-line]). See `c-context-line-break' for the
+details."
(interactive "*")
(let ((here (point)))
(unwind-protect
;; impossible to get a feel for how that function works.
(defmacro c-go-list-forward (&optional pos limit)
- "Move forward across one balanced group of parentheses starting at POS or
-point. Return POINT when we succeed, NIL when we fail. In the latter case,
-leave point unmoved.
+ "Move forward across one balanced group of parentheses starting at POS or point.
+Return POINT when we succeed, NIL when we fail. In the latter
+case, leave point unmoved.
A LIMIT for the search may be given. The start position is assumed to be
before it."
(when dest (goto-char dest) dest)))
(defmacro c-go-list-backward (&optional pos limit)
- "Move backward across one balanced group of parentheses starting at POS or
-point. Return POINT when we succeed, NIL when we fail. In the latter case,
-leave point unmoved.
+ "Move backward across one balanced group of parentheses starting at POS or point.
+Return POINT when we succeed, NIL when we fail. In the latter
+case, leave point unmoved.
A LIMIT for the search may be given. The start position is assumed to be
after it."
(defvar c-lang-constants-under-evaluation nil
"Alist of constants in the process of being evaluated.
The `cdr' of each entry indicates how far we've looked in the list
-of definitions, so that the def for var FOO in c-mode can be defined in
+of definitions, so that the def for var FOO in `c-mode' can be defined in
terms of the def for that same var FOO (which will then rely on the
fallback definition for all modes, to break the cycle).")
nil))))))
(defun c-at-statement-start-p ()
- "Return non-nil if the point is at the first token in a statement
+ "Return non-nil if point is at the first token in a statement
or somewhere in the syntactic whitespace before it.
A \"statement\" here is not restricted to those inside code blocks.
(c-crosses-statement-barrier-p (point) end)))))
(defun c-at-expression-start-p ()
- "Return non-nil if the point is at the first token in an expression or
+ "Return non-nil if point is at the first token in an expression or
statement, or somewhere in the syntactic whitespace before it.
An \"expression\" here is a bit different from the normal language
nil))))
(defun c-forward-over-token-and-ws (&optional balanced)
- "Move forward over a token and any following whitespace
+ "Move forward over a token and any following whitespace.
Return t if we moved, nil otherwise (i.e. we were at EOB, or a
non-token or BALANCED is non-nil and we can't move). If we
are at syntactic whitespace, move over this in place of a token.
(defvar safe-pos-list) ; bound in c-syntactic-skip-backward
(defun c-syntactic-skip-backward (skip-chars &optional limit paren-level)
- "Like `skip-chars-backward' but only look at syntactically relevant chars,
-i.e. don't stop at positions inside syntactic whitespace or string
+ "Like `skip-chars-backward' but only look at syntactically relevant chars.
+This means don't stop at positions inside syntactic whitespace or string
literals. Preprocessor directives are also ignored, with the exception
of the one that the point starts within, if any. If LIMIT is given,
it's assumed to be at a syntactically relevant position.
(> (match-beginning 0) (point-min))
(memq (c-get-char-property (1- (match-beginning 0)) 'face)
'(font-lock-comment-face font-lock-string-face
- font-lock-comment-delimiter-face))))
+ font-lock-comment-delimiter-face))))
(when found
(setq open-delim (cons (match-beginning 1)
(cons (match-end 1) (match-beginning 2)))
(cdr c-emacs-variable-inits))))
(defun c-make-init-lang-vars-fun (mode)
- "Create a function that initializes all the language dependent variables
-for the given mode.
+ "Create a function that initializes all language dependent variables for MODE.
This function should be evaluated at compile time, so that the
function it returns is byte compiled with all the evaluated results
(and (memq (char-before) c-string-delims)
(not (nth 4 s))))) ; Check we're actually out of the
; comment. not stuck at EOB
- (unless
+ (unless
(and c-ml-string-opener-re
(c-maybe-re-mark-ml-string))
(if (c-unescaped-nls-in-string-p (1- (point)))
;; Anchor pos: None.
))
(defcustom c-offsets-alist nil
- "Association list of syntactic element symbols and indentation offsets.
+ "Alist of syntactic element symbols and indentation offsets.
As described below, each cons cell in this list has the form:
(SYNTACTIC-SYMBOL . OFFSET)
:type 'boolean)
(defcustom c-macro-prompt-flag nil
- "Non-nil makes `c-macro-expand' prompt for preprocessor arguments."
+ "Non-nil means `c-macro-expand' will prompt for preprocessor arguments."
:type 'boolean)
(defcustom c-macro-preprocessor
,(expand-file-name "compilation.txt" data-directory)))
(defvar compilation-error-case-fold-search nil
- "If non-nil, use case-insensitive matching of compilation errors
-by the regexps of `compilation-error-regexp-alist' and
-`compilation-error-regexp-alist-alist'.
+ "If non-nil, use case-insensitive matching of compilation errors.
If nil, matching is case-sensitive.
+Compilation errors are given by the regexps in
+`compilation-error-regexp-alist' and
+`compilation-error-regexp-alist-alist'.
+
This variable should only be set for backward compatibility as a temporary
measure. The proper solution is to use a regexp that matches the
messages without case-folding.")
;; :group 'cperl)
(defcustom cperl-info-on-command-no-prompt nil
- "Not-nil (and non-null) means not to prompt on C-h f.
+ "Not-nil (and non-null) means not to prompt on \\[cperl-info-on-command].
The opposite behavior is always available if prefixed with C-c.
Can be overwritten by `cperl-hairy' if nil."
:type '(choice (const null) boolean)
:group 'cperl-affected-by-hairy)
(defcustom cperl-clobber-lisp-bindings nil
- "Not-nil (and non-null) means not overwrite C-h f.
+ "Not-nil (and non-null) means not overwrite \\[describe-function].
The function is available on \\[cperl-info-on-command], \\[cperl-get-help].
Can be overwritten by `cperl-hairy' if nil."
:type '(choice (const null) boolean)
default))
(defun cpp-choose-default-face (type)
- ;; Choose default face list for screen of TYPE.
- ;; Type must be one of the types defined in `cpp-face-type-list'.
+ "Choose default face list for screen of TYPE.
+Type must be one of the types defined in `cpp-face-type-list'."
(interactive (list (if cpp-button-event
(x-popup-menu cpp-button-event
(list "Screen type"
(if data (list 'cpp-data data))))))
(defun cpp-push-button (event)
- ;; Pushed a CPP button.
+ "Pushed a CPP button."
(interactive "@e")
(set-buffer (window-buffer (posn-window (event-start event))))
(let ((pos (posn-point (event-start event))))
These variables control the look of expanded templates.
dcl-imenu-generic-expression
- Default value for imenu-generic-expression. The default includes
+ Default value for `imenu-generic-expression'. The default includes
SUBROUTINE labels in the main listing and sub-listings for
other labels, CALL, GOTO and GOSUB statements.
;;;-------------------------------------------------------------------------
(defun dcl-delete-indentation (&optional arg)
- "Join this line to previous like delete-indentation.
+ "Join this line to previous like `delete-indentation'.
Also remove the continuation mark if easily detected."
(interactive "*P")
(delete-indentation arg)
;;; YACC-Code = "any C definition".
(defun ebnf-yac-parser (start)
- "yacc/Bison parser."
+ "Yacc/Bison parser."
(let ((total (+ (- ebnf-limit start) 1))
(bias (1- start))
(origin (point))
;; the variable f90-comment-region in every line of the region.
;; One common convention for free vs. fixed format is that free format
-;; files have the ending .f90 or .f95 while fixed format files have
-;; the ending .f. Emacs automatically loads Fortran files in the
+;; files have the ending ".f90" or ".f95" while fixed format files have
+;; the ending ".f". Emacs automatically loads Fortran files in the
;; appropriate mode based on extension. You can modify this by
;; adjusting the variable `auto-mode-alist'.
;; For example:
;; FIXME trivial to extend this to enum. Worth it?
(defun f90-imenu-type-matcher ()
"Search backward for the start of a derived type.
-Set subexpression 1 in the match-data to the name of the type."
+Set subexpression 1 in the `match-data' to the name of the type."
(let (found)
(while (and (re-search-backward "^[ \t0-9]*type[ \t]*" nil t)
(not (setq found
(put :warning 'flymake-category 'flymake-warning)
(put :note 'flymake-category 'flymake-note)
-(defvar flymake-diagnostic-types-alist '() "")
+(defvar flymake-diagnostic-types-alist '())
(make-obsolete-variable
'flymake-diagnostic-types-alist
"Set properties on the diagnostic symbols instead. See Info
\f
;;; Mode-line and menu
;;;
-(easy-menu-define flymake-menu flymake-mode-map "Flymake"
+(easy-menu-define flymake-menu flymake-mode-map "Flymake menu."
'("Flymake"
[ "Go to next problem" flymake-goto-next-error t ]
[ "Go to previous problem" flymake-goto-prev-error t ]
;; TODO Some commands can't be called with --all (give a notice about
;; it in setting doc)
(defcustom gdb-gud-control-all-threads t
- "When non-nil, GUD execution commands affect all threads when
-in non-stop mode. Otherwise, only current thread is affected."
+ "When non-nil, GUD execution commands affect all threads when in non-stop mode.
+Otherwise, only current thread is affected."
:type 'boolean
:group 'gdb-non-stop
:version "23.2")
(expr (nth 1 var)) (children (nth 2 var)))
(if (or (<= (string-to-number children) gdb-max-children)
(y-or-n-p
- (format "%s has %s children. Continue? " expr children)))
+ (format "%s has %s children. Continue?" expr children)))
(gdb-var-list-children token))))
((string-search "-" text) ;contract this node
(dolist (var gdb-var-list)
Some grep programs are able to surround matches with special
markers in grep output. Such markers can be used to highlight
matches in grep mode. This requires `font-lock-mode' to be active
-in grep buffers, so if you have globally disabled font-lock-mode,
+in grep buffers, so if you have globally disabled `font-lock-mode',
you will not get highlighting.
This option sets the environment variable GREP_COLORS to specify
<F> - file names and wildcards to search.
<X> - file names and wildcards to exclude.
<R> - the regular expression searched for.
- <N> - place to insert null-device.
+ <N> - place to insert `null-device'.
In interactive usage, the actual value of this variable is set up
by `grep-compute-defaults'; to change the default value, use
;; activated or deactivated, `hs-minor-mode-hook' is run w/ `run-hooks'.
;;
;; Additionally, Joseph Eydelnant writes:
-;; I enjoy your package hideshow.el Ver. 5.24 2001/02/13
+;; I enjoy your package hideshow.el Version 5.24 2001/02/13
;; a lot and I've been looking for the following functionality:
;; toggle hide/show all with a single key.
;; Here are a few lines of code that lets me do just that.
(defun idlwave-delete-user-catalog-file (&rest _ignore)
(if (yes-or-no-p
- (format "Delete file %s " idlwave-user-catalog-file))
+ (format "Delete file %s?" idlwave-user-catalog-file))
(progn
(delete-file idlwave-user-catalog-file)
(message "%s has been deleted" idlwave-user-catalog-file))))
:group 'languages)
(defconst opascal-debug nil
- "True if in debug mode.")
+ "Non-nil if in debug mode.")
(define-obsolete-variable-alias
'delphi-search-path 'opascal-search-path "24.4")
(define-obsolete-function-alias 'delphi-mode #'opascal-mode "24.4")
;;;###autoload
(define-derived-mode opascal-mode prog-mode "OPascal"
- "Major mode for editing OPascal code.\\<opascal-mode-map>
+ "Major mode for editing OPascal code.
+\\<opascal-mode-map>
\\[opascal-find-unit]\t- Search for a OPascal source file.
\\[opascal-fill-comment]\t- Fill the current comment.
\\[opascal-new-comment-line]\t- If in a // comment, do a new comment line.
third argument of `compose-region'.")
(defun prettify-symbols-default-compose-p (start end _match)
- "Return true iff the symbol MATCH should be composed.
+ "Return non-nil iff the symbol MATCH should be composed.
The symbol starts at position START and ends at position END.
This is the default for `prettify-symbols-compose-predicate'
which is suitable for most programming languages such as C or Lisp."
"A predicate for deciding if the currently matched symbol is to be composed.
The matched symbol is the car of one entry in `prettify-symbols-alist'.
The predicate receives the match's start and end positions as well
-as the match-string as arguments.")
+as the `match-string' as arguments.")
(defun prettify-symbols--compose-symbol (alist)
"Compose a sequence of characters into a symbol.
(defun project-query-replace-regexp (from to)
"Query-replace REGEXP in all the files of the project.
Stops when a match is found and prompts for whether to replace it.
-If you exit the query-replace, you can later continue the query-replace
-loop using the command \\[fileloop-continue]."
+If you exit the `query-replace', you can later continue the
+`query-replace' loop using the command \\[fileloop-continue]."
(interactive
(pcase-let ((`(,from ,to)
(query-replace-read-args "Query replace (regexp)" t t)))
;; "----" ["MB" nil :help "Help MB"]))
(defun verilog-define-abbrev-table (tablename definitions &optional docstring &rest props)
- "Filter `define-abbrev-table' TABLENAME DEFINITIONS
+ "Filter `define-abbrev-table' TABLENAME DEFINITIONS.
Provides DOCSTRING PROPS in newer Emacs (23.1)."
(condition-case nil
(apply #'define-abbrev-table tablename definitions docstring props)
expand the above into:
/*AUTOINSERTLISP(my-verilog-insert-hello \"world\")*/
- // Beginning of automatic insert lisp
+ // Beginning of automatic insert Lisp
initial $write(\"hello world\");
// End of automatics
(setq alist alist-cdr)))))
(defun vhdl-aget (alist key)
- "Return the value in ALIST that is associated with KEY. If KEY is
-not found, then nil is returned."
+ "Return the value in ALIST that is associated with KEY.
+If KEY is not found, then nil is returned."
(cdr (assoc key alist)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar vhdl-sources-menu nil)
(defun vhdl-directory-files (directory &optional full match)
- "Call `directory-files' if DIRECTORY exists, otherwise generate error
-message."
+ "Call `directory-files' if DIRECTORY exists, otherwise generate error message."
(if (not (file-directory-p directory))
(vhdl-warning-when-idle "No such directory: \"%s\"" directory)
(let ((dir (directory-files directory full match)))
(save-excursion (re-search-forward "\\\\" (vhdl-point 'eol) t)))))
(defun vhdl-forward-comment (&optional direction)
- "Skip all comments (including whitespace). Skip backwards if DIRECTION is
-negative, skip forward otherwise."
+ "Skip all comments (including whitespace).
+Skip backwards if DIRECTION is negative, skip forward otherwise."
(interactive "p")
(if (and direction (< direction 0))
;; skip backwards
(concat vhdl-case-alternative-re "\\|" vhdl-case-header-key))
(defun vhdl-skip-case-alternative (&optional lim)
- "Skip forward over case/when bodies, with optional maximal
-limit. If no next case alternative is found, nil is returned and
-point is not moved."
+ "Skip forward over case/when bodies, with optional maximal limit.
+If no next case alternative is found, nil is returned and point
+is not moved."
(let ((lim (or lim (point-max)))
(here (point))
donep foundp)
foundp))
(defun vhdl-backward-skip-label (&optional lim)
- "Skip backward over a label, with optional maximal
-limit. If label is not found, nil is returned and point
-is not moved."
+ "Skip backward over a label, with optional maximal limit.
+If label is not found, nil is returned and point is not moved."
(let ((lim (or lim (point-min)))
placeholder)
(if (save-excursion
))
(defun vhdl-forward-skip-label (&optional lim)
- "Skip forward over a label, with optional maximal
-limit. If label is not found, nil is returned and point
-is not moved."
+ "Skip forward over a label, with optional maximal limit.
+If label is not found, nil is returned and point is not moved."
(let ((lim (or lim (point-max))))
(if (looking-at vhdl-label-key)
(progn
(- ce-curcol cs-curcol -1))))
(defun vhdl-lineup-comment (_langelem)
- "Support old behavior for comment indentation. We look at
-vhdl-comment-only-line-offset to decide how to indent comment
-only-lines."
+ "Support old behavior for comment indentation.
+We look at `vhdl-comment-only-line-offset' to decide how to
+indent comment only-lines."
(save-excursion
(back-to-indentation)
;; at or to the right of comment-column
(setq this-command 'vhdl-electric-tab)))
(defun vhdl-electric-return ()
- "newline-and-indent or indent-new-comment-line if in comment and preceding
+ "`newline-and-indent' or `indent-new-comment-line' if in comment and preceding
character is a space."
(interactive)
(if (and (= (preceding-char) ? ) (vhdl-in-comment-p))
(newline-and-indent)))
(defun vhdl-indent-line ()
- "Indent the current line as VHDL code. Returns the amount of
-indentation change."
+ "Indent the current line as VHDL code.
+Return the amount of indentation change."
(interactive)
(let* ((syntax (and vhdl-indent-syntax-based (vhdl-get-syntactic-context)))
(pos (- (point-max) (point)))
;; Align code
(defvar vhdl-align-try-all-clauses t
- "If REGEXP is not found on the first line of the region that clause
-is ignored. If this variable is non-nil, then the clause is tried anyway.")
+ "If REGEXP is not found on the first line of the region that clause is ignored.
+If this variable is non-nil, then the clause is tried anyway.")
(defun vhdl-do-group (function &optional spacing)
"Apply FUNCTION on group of lines between empty lines."
(funcall function beg end spacing)))
(defun vhdl-do-list (function &optional spacing)
- "Apply FUNCTION to the lines of a list surrounded by a balanced group of
-parentheses."
+ "Apply FUNCTION to lines of a list surrounded by a balanced group of parentheses."
(let (beg end)
(save-excursion
;; search for beginning of balanced group of parentheses
(funcall function beg end spacing)))
(defun vhdl-align-region-1 (begin end &optional spacing alignment-list _indent)
- "Attempt to align a range of lines based on the content of the
-lines. The definition of `alignment-list' determines the matching
-order and the manner in which the lines are aligned. If ALIGNMENT-LIST
-is not specified `vhdl-align-alist' is used. If INDENT is non-nil,
-indentation is done before aligning."
+ "Attempt to align a range of lines based on the content of the lines.
+The definition of `alignment-list' determines the matching order
+and the manner in which the lines are aligned. If ALIGNMENT-LIST
+is not specified `vhdl-align-alist' is used. If INDENT is
+non-nil, indentation is done before aligning."
(interactive "r\np")
(setq alignment-list (or alignment-list vhdl-align-alist))
(setq spacing (or spacing 1))
;; Help functions
(defun vhdl-electric-space (count)
- "Expand abbreviations and self-insert space(s), do indent-new-comment-line
+ "Expand abbreviations and self-insert space(s), do `indent-new-comment-line'
if in comment and past end-comment-column."
(interactive "p")
(cond ((vhdl-in-comment-p)
string)))
(defun vhdl-paste-group-comment (string indent)
- "Paste comment and empty lines from STRING between groups of lines
-with INDENT."
+ "Paste comment and empty lines from STRING between groups of lines with INDENT."
(let ((pos (point-marker)))
(when (> indent 0)
(while (string-match "^\\(--\\)" string)
(setq project-alist (cdr project-alist)))))
(defun vhdl-speedbar-insert-project-hierarchy (project indent &optional rescan)
- "Insert hierarchy of PROJECT. Rescan directories if RESCAN is non-nil,
+ "Insert hierarchy of PROJECT.
+Rescan directories if optional argument RESCAN is non-nil,
otherwise use cached data."
(when (or rescan (and (not (assoc project vhdl-file-alist))
(not (vhdl-load-cache project))))
(vhdl-speedbar-expand-units project))
(defun vhdl-speedbar-insert-dir-hierarchy (directory depth &optional rescan)
- "Insert hierarchy of DIRECTORY. Rescan directory if RESCAN is non-nil,
+ "Insert hierarchy of DIRECTORY.
+Rescan directory if optional argument RESCAN is non-nil,
otherwise use cached data."
(when (or rescan (and (not (assoc directory vhdl-file-alist))
(not (vhdl-load-cache directory))))
(defun xref--outdated-p (item)
"Check that the match location at current position is up-to-date.
-ITEMS is an xref item which "
+ITEMS is an xref item which " ; FIXME: Expand documentation.
;; FIXME: The check should most likely be a generic function instead
;; of the assumption that all matches' summaries relate to the
;; buffer text in a particular way.
(<= (+ y2 h2) y1)))))
(defun rectangle-dimensions (start end)
- "Return the dimensions of the rectangle with corners at START
-and END. The returned value has the form of (WIDTH . HEIGHT)."
+ "Return the dimensions of the rectangle with corners at START and END.
+The returned value has the form of (WIDTH . HEIGHT)."
(save-excursion
(let* ((height (1+ (abs (- (line-number-at-pos end)
(line-number-at-pos start)))))
((null last-repeatable-command)
(error "There is nothing to repeat"))
((eq last-repeatable-command 'mode-exit)
- (error "last-repeatable-command is mode-exit & can't be repeated"))
+ (error "`last-repeatable-command' is `mode-exit' and can't be repeated"))
((memq last-repeatable-command repeat-too-dangerous)
(error "Command %S too dangerous to repeat automatically"
last-repeatable-command)))
:version "24.3")
(defvar query-replace-history nil
- "Default history list for query-replace commands.
+ "Default history list for `query-replace' commands.
See `query-replace-from-history-variable' and
`query-replace-to-history-variable'.")
(car (symbol-value query-replace-from-history-variable)))))
(defun query-replace-read-from (prompt regexp-flag)
- "Query and return the `from' argument of a query-replace operation.
+ "Query and return the `from' argument of a `query-replace' operation.
Prompt with PROMPT. REGEXP-FLAG non-nil means the response should be a regexp.
The return value can also be a pair (FROM . TO) indicating that the user
wants to replace FROM with TO."
(defun query-replace-read-to (from prompt regexp-flag)
- "Query and return the `to' argument of a query-replace operation.
-Prompt with PROMPT. REGEXP-FLAG non-nil means the response should a regexp."
+ "Query and return the `to' argument of a `query-replace' operation.
+Prompt with PROMPT. REGEXP-FLAG non-nil means the response
+should a regexp."
(query-replace-compile-replacement
(save-excursion
(let* ((history-add-new-input nil)
(defcustom occur-mode-find-occurrence-hook nil
"Hook run by Occur after locating an occurrence.
This will be called with the cursor position at the occurrence. An application
-for this is to reveal context in an outline-mode when the occurrence is hidden."
+for this is to reveal context in an outline mode when the occurrence is hidden."
:type 'hook
:group 'matching)
noedit)
(defvar replace-update-post-hook nil
- "Function(s) to call after query-replace has found a match in the buffer.")
+ "Function(s) to call after `query-replace' has found a match in the buffer.")
(defvar replace-search-function nil
"Function to use when searching for strings to replace.
(defun ruler-mode-text-scaled-width (width)
"Compute scaled text width according to current font scaling.
Convert a width of char units into a text-scaled char width units,
-Ex. `window-hscroll'."
+for example `window-hscroll'."
(/ (* width (frame-char-width)) (default-font-width)))
(defun ruler-mode-text-scaled-window-hscroll ()
`-suspend'
Suspend this terminal, i.e., stop the client process.
- Sent when the user presses C-z."
+ Sent when the user presses \\[suspend-frame]."
(server-log (concat "Received " string) proc)
;; First things first: let's check the authentication
(unless (process-get proc :authenticated)
ses-center-span ses-dashfill ses-dashfill-span
ses-tildefill-span
ses-prin1)
- "List of print functions to be included in initial history of
-printer functions. None of these standard-printer functions,
-except function `ses-prin1', is suitable for use as a column
-printer or a global-default printer because they invoke the
-column or default printer and then modify its output.")
+ "List of print functions to be included in initial history of printer functions.
+None of these standard-printer functions, except function
+`ses-prin1', is suitable for use as a column printer or a
+global-default printer because they invoke the column or default
+printer and then modify its output.")
;;----------------------------------------------------------------------------
(put 'shell-mode 'mode-class 'special)
(define-derived-mode shell-mode comint-mode "Shell"
- "Major mode for interacting with an inferior shell.\\<shell-mode-map>
+ "Major mode for interacting with an inferior shell.
+\\<shell-mode-map>
\\[comint-send-input] after the end of the process' output sends the text from
the end of process to the end of the current line.
\\[comint-send-input] before end of process output copies the current line minus the prompt to
(defun next-error-buffer-on-selected-frame (&optional _avoid-current
extra-test-inclusive
extra-test-exclusive)
- "Return a single visible next-error buffer on the selected frame."
+ "Return a single visible `next-error' buffer on the selected frame."
(let ((window-buffers
(delete-dups
(delq nil (mapcar (lambda (w)
command-names)))
(defcustom suggest-key-bindings t
- "Non-nil means show the equivalent key-binding when M-x command has one.
+ "Non-nil means show the equivalent keybinding when \
+\\[execute-extended-command] has one.
The value can be a length of time to show the message for.
If the value is non-nil and not a number, we wait 2 seconds.
Also see `extended-command-suggest-shorter'.
Equivalent key-bindings are also shown in the completion list of
-M-x for all commands that have them."
+\\[execute-extended-command] for all commands that have them."
:group 'keyboard
:type '(choice (const :tag "off" nil)
(integer :tag "time" 2)
(other :tag "on")))
(defcustom extended-command-suggest-shorter t
- "If non-nil, show a shorter M-x invocation when there is one.
+ "If non-nil, show a shorter \\[execute-extended-command] invocation \
+when there is one.
Also see `suggest-key-bindings'."
:group 'keyboard
;; called or in some cases on a timer called after a change is made in
;; any buffer.
(defvar-local undo-auto--last-boundary-cause nil
- "Describe the cause of the last undo-boundary.
+ "Describe the cause of the last `undo-boundary'.
If `explicit', the last boundary was caused by an explicit call to
`undo-boundary', that is one not called by the code in this
The argument `COMMAND' should be a symbol.
-Running `M-x COMMAND RET' for the first time prompts for which
+Running `\\[execute-extended-command] COMMAND RET' for \
+the first time prompts for which
alternative to use and records the selected command as a custom
variable.
-Running `C-u M-x COMMAND RET' prompts again for an alternative
+Running `\\[universal-argument] \\[execute-extended-command] COMMAND RET' \
+prompts again for an alternative
and overwrites the previous choice.
The variable `COMMAND-alternatives' contains an alist with
;; considered internal-use only (with `global-so-long-mode' the interface
;; for enabling or disabling the automated behaviour). FIXME: Establish a
;; way to support the original use-case, or rename to `so-long--enabled'.
- "Internal use. Non-nil when any so-long functionality has been used.")
+ "Internal use. Non-nil when any `so-long' functionality has been used.")
(defvar-local so-long--active nil ; internal use
"Non-nil when `so-long' mitigations are in effect.")
;;;###autoload
(defun so-long-commentary ()
- "View the so-long library's documentation in `outline-mode'."
+ "View the `so-long' library's documentation in `outline-mode'."
(interactive)
(let ((buf "*So Long: Commentary*"))
(when (buffer-live-p (get-buffer buf))
;;;###autoload
(defun so-long-enable ()
- "Enable the so-long library's functionality.
+ "Enable the `so-long' library's functionality.
Equivalent to calling (global-so-long-mode 1)"
(interactive)
(global-so-long-mode 1))
(defun so-long-disable ()
- "Disable the so-long library's functionality.
+ "Disable the `so-long' library's functionality.
Equivalent to calling (global-so-long-mode 0)"
(interactive)
(setq col-start (min col-beg1 col-end1))
(setq col-end (max col-beg1 col-end1))
(if (search-backward "\t" beg1 t)
- (error "sort-columns does not work with tabs -- use M-x untabify"))
+ (error (substitute-command-keys
+ "sort-columns does not work with tabs -- use \\[untabify]")))
(if (not (or (memq system-type '(windows-nt))
(let ((pos beg1) plist fontified)
(catch 'found
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;;; Code:
;; declare-function's args use &rest, not &optional, for compatibility
;;; tempo-is-user-element
(defun tempo-is-user-element (element)
- "Tries all the user-defined element handlers in `tempo-user-elements'."
+ "Try all the user-defined element handlers in `tempo-user-elements'."
;; Sigh... I need (some list)
(catch 'found
(mapc (lambda (handler)
(defvar term-home-marker) ; Marks the "home" position for cursor addressing.
(defvar term-saved-home-marker nil
"When using alternate sub-buffer,
-contains saved term-home-marker from original sub-buffer.")
+contains saved `term-home-marker' from original sub-buffer.")
(defvar term-start-line-column 0
"(current-column) at start of screen line, or nil if unknown.")
(defvar term-current-column 0 "If non-nil, is cache for (current-column).")
(defvar term-scroll-with-delete nil
"If t, forward scrolling should be implemented by delete to
top-most line(s); and if nil, scrolling should be implemented
-by moving term-home-marker. It is set to t if there is a
+by moving `term-home-marker'. It is set to t if there is a
\(non-default) scroll-region OR the alternate buffer is used.")
(defvar term-pending-delete-marker) ; New user input in line mode
; needs to be deleted, because it gets echoed by the inferior.
"Keymap used in Term pager mode.")
(defvar term-ptyp t
- "True if communications via pty; false if by pipe. Buffer local.
+ "Non-nil if communications via pty; false if by pipe. Buffer local.
This is to work around a bug in Emacs process signaling.")
(defvar term-last-input-match ""
(process-send-string proc chars))))
(defun term-send-raw ()
- "Send the last character typed through the terminal-emulator
-without any interpretation."
+ "Send last typed character to the terminal-emulator without any interpretation."
(interactive)
(let ((keys (this-command-keys)))
(term-send-raw-string (string (aref keys (1- (length keys)))))))
(force-mode-line-update))
(defun term-check-proc (buffer)
- "True if there is a process associated w/buffer BUFFER, and it
-is alive. BUFFER can be either a buffer or the name of one."
+ "Non-nil if there is a process associated w/buffer BUFFER, and it is alive.
+BUFFER can be either a buffer or the name of one."
(let ((proc (get-buffer-process buffer)))
(and proc (memq (process-status proc) '(run stop open listen connect)))))
Some other integer if Bash is new or not in use.
Nil if unknown.")
(defun term--bash-needs-EMACSp ()
- "t if Bash is old, nil if it is new or not in use."
+ "Return t if Bash is old, nil if it is new or not in use."
(eq 43
(or term--bash-needs-EMACS-status
(setf
in the buffer. E.g.,
If the interpreter is the csh,
- term-get-old-input is the default: take the current line, discard any
- initial string matching regexp term-prompt-regexp.
- term-input-filter-functions monitors input for \"cd\", \"pushd\", and
+ `term-get-old-input' is the default: take the current line, discard any
+ initial string matching regexp `term-prompt-regexp'.
+ `term-input-filter-functions' monitors input for \"cd\", \"pushd\", and
\"popd\" commands. When it sees one, it cd's the buffer.
- term-input-filter is the default: returns t if the input isn't all white
+ `term-input-filter' is the default: returns t if the input isn't all white
space.
If the term is Lucid Common Lisp,
- term-get-old-input snarfs the sexp ending at point.
- term-input-filter-functions does nothing.
- term-input-filter returns nil if the input matches input-filter-regexp,
+ `term-get-old-input' snarfs the sexp ending at point.
+ `term-input-filter-functions' does nothing.
+ `term-input-filter' returns nil if the input matches input-filter-regexp,
which matches (1) all whitespace (2) :a, :c, etc.
Similarly for Soar, Scheme, etc."
(kill-region pmark (point)))))
(defun term-delchar-or-maybe-eof (arg)
- "Delete ARG characters forward, or send an EOF to process if at end of
-buffer."
+ "Delete ARG characters forward, or send an EOF to process if at end of buffer."
(interactive "p")
(if (eobp)
(process-send-eof)
Set in `pre-command-hook' in char mode by `term-set-goto-process-mark'.")
(defun term-set-goto-process-mark ()
- "Sets `term-goto-process-mark'.
+ "Set `term-goto-process-mark'.
Always set to nil if `term-char-mode-point-at-process-mark' is nil.
(t)))
(defun term--reset-scroll-region ()
- "Sets the scroll region to the full height of the terminal."
+ "Set the scroll region to the full height of the terminal."
(term-set-scroll-region 0 (term--last-line)))
(defun term-set-scroll-region (top bottom)
(defun term-erase-in-display (kind)
"Erase (that is blank out) part of the window.
-If KIND is 0, erase from (point) to (point-max);
+If KIND is 0, erase from point to point-max;
if KIND is 1, erase from home to point; else erase from home to point-max."
(term-handle-deferred-scroll)
(cond ((eq kind 0)
(defcustom bib-auto-capitalize t
- "True to automatically capitalize appropriate fields in Bib mode."
+ "Non-nil to automatically capitalize appropriate fields in Bib mode."
:type 'boolean)
(defconst bib-capitalized-fields "%[AETCBIJR]")
;;* flyspell-highlight-duplicate-region ... */
;;*---------------------------------------------------------------------*/
(defun flyspell-highlight-duplicate-region (beg end poss)
- "Set up an overlay on a duplicate misspelled word, in the buffer from BEG to END.
+ "Set up overlay on duplicate misspelled word, in the buffer from BEG to END.
POSS is a list of possible spelling/correction lists,
as returned by `ispell-parse-output'."
(let ((inhibit-read-only t))
'makeinfo-compilation-sentinel-region)))))))
(defun makeinfo-next-error (_arg _reset)
- "This function is used to disable `next-error' if the user has
-used `makeinfo-region'. Since the compilation process is used on
-a temporary file in that case, calling `next-error' would give
-nonsensical results."
+ "This is used to disable `next-error' if the user has used `makeinfo-region'.
+Since the compilation process is used on a temporary file in that
+case, calling `next-error' would give nonsensical results."
(error "Use `makeinfo-buffer' to gain use of the `next-error' command"))
;; Actually run makeinfo. COMMAND is the command to run. If
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;;; Code:
(eval-when-compile (require 'cl-lib))
complex processing.")
(defun refill-after-change-function (_beg end _len)
- "Function for `after-change-functions' which just sets `refill-doit'."
+ "Set `refill-doit'. Used by `after-change-functions'."
(unless undo-in-progress
(setq refill-doit end)))
;;;###autoload
(defun reftex-view-crossref (&optional arg auto-how fail-quietly)
- "View cross reference of macro at point. Point must be on the KEY
-argument. When at a `\\ref' macro, show corresponding `\\label'
-definition, also in external documents (`xr'). When on a label, show
-a locations where KEY is referenced. Subsequent calls find additional
-locations. When on a `\\cite', show the associated `\\bibitem' macro or
-the BibTeX database entry. When on a `\\bibitem', show a `\\cite' macro
-which uses this KEY. When on an `\\index', show other locations marked
-by the same index entry.
+ "View cross reference of macro at point.
+
+Point must be on the KEY argument. When at a `\\ref' macro, show
+corresponding `\\label' definition, also in external
+documents (`xr'). When on a label, show a locations where KEY is
+referenced. Subsequent calls find additional locations. When on
+a `\\cite', show the associated `\\bibitem' macro or the BibTeX
+database entry. When on a `\\bibitem', show a `\\cite' macro
+which uses this KEY. When on an `\\index', show other locations
+marked by the same index entry.
+
To define additional cross referencing items, use the option
`reftex-view-crossref-extra'. See also `reftex-view-crossref-from-bibtex'.
With one or two \\[universal-argument] prefixes, enforce rescanning of the document.
(while (setq file (pop files))
(unless (file-exists-p file)
(ding)
- (or (y-or-n-p (format "No such file %s. Continue? " file))
+ (or (y-or-n-p (format "No such file %s. Continue?" file))
(error "Abort")))
(unless (file-writable-p file)
(ding)
- (or (y-or-n-p (format "No write access to %s. Continue? " file))
+ (or (y-or-n-p (format "No write access to %s. Continue?" file))
(error "Abort")))
(when (and (setq buf (find-buffer-visiting file))
(with-current-buffer buf
buffer-read-only))
(ding)
- (or (y-or-n-p (format "Buffer %s is read-only. Continue? "
+ (or (y-or-n-p (format "Buffer %s is read-only. Continue?"
(buffer-name buf)))
(error "Abort"))))))
(t nil))))
(defun reftex-index-analyze-entry (data)
- ;; This splits the index context so that key, attribute and visual
- ;; values are accessible individually.
+ "Split index context so that key, attribute and visual
+values are accessible individually."
(interactive)
(let* ((arg (nth 5 data))
(context (nth 2 data))
;;;###autoload
(defun reftex-section-info (file)
"Return a section entry for the current match.
-Careful: This function expects the match-data to be still in place!"
+Careful: This function expects the `match-data' to still be in
+place!"
(let* ((marker (set-marker (make-marker) (1- (match-beginning 3))))
(macro (reftex-match-string 3))
(prefix (save-match-data
;;;###autoload
(defun reftex-index-info (file)
"Return an index entry for the current match.
-Careful: This function expects the match-data to be still in place!"
+Careful: This function expects the `match-data' to still be in
+place!"
(catch 'exit
(let* ((macro (reftex-match-string 10))
(bom (match-beginning 10))
"The maximum level of toc entries which will be included in the TOC.
Section headings with a bigger level will be ignored. In RefTeX, chapters
are level 1, sections are level 2 etc.
-This variable can be changed from within the *toc* buffer with the `t' key."
+This variable can be changed from within the *toc* buffer with \
+\\<reftex-toc-mode-map>\\[reftex-toc-max-level]."
:group 'reftex-table-of-contents-browser
:type 'integer)
:type '(repeat (file)))
(defcustom reftex-sort-bibtex-matches 'reverse-year
- "Sorting of the entries found in BibTeX databases by reftex-citation.
+ "Sorting of the entries found in BibTeX databases by `reftex-citation'.
Possible values:
nil Do not sort entries.
`author' Sort entries by author name.
:type '(choice (const nil) function))
(defcustom reftex-select-bib-mode-hook nil
- "Mode hook for reftex-select-bib-mode."
+ "Mode hook for `reftex-select-bib-mode'."
:group 'reftex-citation-support
:type 'hook)
(defcustom reftex-initialize-temporary-buffers nil
"Non-nil means do initializations even when visiting file temporarily.
-When nil, RefTeX may turn off find-file hooks and other stuff to briefly
+When nil, RefTeX may turn off `find-file' hooks and other stuff to briefly
visit a file.
When t, the full default initializations are done (find-file-hook etc.).
Instead of t or nil, this variable may also be a list of hook functions to
"Text of the copyright notice and copying permissions.")
(defun texinfo-copying ()
- "Copy the copyright notice and copying permissions from the Texinfo file,
-as indicated by the @copying ... @end copying command;
-insert the text with the @insertcopying command."
+ "Copy the copyright notice and copying permissions from Texinfo file.
+This is indicated by the \"@copying ... @end copying\" command;
+insert the text with the \"@insertcopying\" command."
(let ((beg (progn (beginning-of-line) (point)))
(end (progn (re-search-forward "^@end copying[ \t]*\n") (point))))
(setq texinfo-copying-text
(delete-region beg end)))
(defun texinfo-insertcopying ()
- "Insert the copyright notice and copying permissions from the Texinfo file,
-which are indicated by the @copying ... @end copying command."
+ "Insert the copyright notice and copying permissions from Texinfo file.
+This is indicated by the \"@copying ... @end copying\" command."
(insert (concat "\n" texinfo-copying-text)))
(put 'begin 'texinfo-format 'texinfo-format-begin)
"smalllisp"
"\\)")
"Regexp specifying end of environments in which @kbd does not put `...'
-around argument. (See `texinfo-format-kbd-regexp')")
+around argument.
+
+See `texinfo-format-kbd-regexp'.")
(put 'kbd 'texinfo-format 'texinfo-format-kbd)
(defun texinfo-format-kbd ()
(defvar transient--exitp nil "Whether to exit the transient.")
(defvar transient--showp nil "Whether the transient is show in a popup buffer.")
-(defvar transient--helpp nil "Whether help-mode is active.")
-(defvar transient--editp nil "Whether edit-mode is active.")
+(defvar transient--helpp nil "Whether `help-mode' is active.")
+(defvar transient--editp nil "Whether `edit-mode' is active.")
(defvar transient--active-infix nil "The active infix awaiting user input.")
(remove-function (local 'revert-buffer-function) #'wdired-revert))
(defun wdired-abort-changes ()
- "Abort changes and return to dired mode."
+ "Abort changes and return to `dired-mode'."
(interactive)
(remove-hook 'before-change-functions #'wdired--before-change-fn t)
(let ((inhibit-read-only t))
;; FIXME: Can't we use the normal mechanism for that? --Stef
(if (and
(buffer-modified-p)
- (not (y-or-n-p "Buffer changed. Discard changes and kill buffer?")))
+ (not (y-or-n-p "Buffer changed. Discard changes and kill buffer?")))
(error "Error")))
;; Added to after-change-functions in wdired-change-to-wdired-mode to
(defvar whitespace-indentation 'whitespace-indentation
- "Symbol face used to visualize `tab-width' or more SPACEs at beginning of
-line. Used when `whitespace-style' includes the value `indentation'.")
+ "Symbol face used to visualize `tab-width' or more SPACEs at beginning of line.
+Used when `whitespace-style' includes the value `indentation'.")
(make-obsolete-variable 'whitespace-indentation "use the face instead." "24.4")
(defface whitespace-indentation
(defun whitespace-display-vector-p (vec)
- "Return true if every character in vector VEC can be displayed."
+ "Return non-nil if every character in vector VEC can be displayed."
(let ((i (length vec)))
(when (> i 0)
(while (and (>= (setq i (1- i)) 0)
(buffer-enable-undo))
(defcustom widget-menu-max-size 40
- "Largest number of items allowed in a popup-menu.
+ "Largest number of items allowed in a popup menu.
Larger menus are read through the minibuffer."
:group 'widgets
:type 'integer)
:type 'integer)
(defcustom widget-menu-minibuffer-flag nil
- "Control how to ask for a choice from the keyboard.
-Non-nil means use the minibuffer;
-nil means read a single character."
+ "Non-nil means use the minibuffer; to ask for a choice from the keyboard.
+If nil, read a single character."
:group 'widgets
:type 'boolean)
;; That comment was moved after the symbol `woman-menu' to make
;; find-function-search-for-symbol work. -- rost
woman-mode-map
- "WoMan Menu"
+ "WoMan Menu."
`("WoMan"
["WoMan..." woman t] ; [NAME CALLBACK ENABLE]
"--"
;; variable. zsoelim is always run as the very first preprocessor.
(defvar woman-emulate-tbl nil
- "True if WoMan should emulate the tbl preprocessor.
+ "Non-nil if WoMan should emulate the tbl preprocessor.
This applies to text between .TE and .TS directives.
Currently set only from \\='\\\" t in the first line of the source file.")
projects / emacs.git / commitdiff