"Set by `cus-test-apropos' to a list of options with :get property.")
(defvar cus-test-vars-with-changed-state nil
- "Set by `cus-test-apropos' to a list of options with state 'changed.")
+ "Set by `cus-test-apropos' to a list of options with state \\='changed.")
(defvar cus-test-deps-errors nil
"List of require/load problems found by `cus-test-deps'.")
(defun modus-themes--paren (normalbg intensebg)
"Conditional use of intense colors for matching parentheses.
-NORMALBG should be the special palette color 'bg-paren-match' or
+NORMALBG should be the special palette color `bg-paren-match' or
something similar. INTENSEBG must be easier to discern next to
other backgrounds, such as the special palette color
-'bg-paren-match-intense'."
+`bg-paren-match-intense'."
(let ((properties (modus-themes--list-or-warn 'modus-themes-paren-match)))
(list :inherit
(if (memq 'bold properties)
(defun modus-themes--agenda-habit (default traffic simple &optional default-d traffic-d simple-d)
"Specify background values for `modus-themes-org-agenda' habits.
DEFAULT is the original foregrounc color. TRAFFIC is to be used
-when the 'traffic-light' style is applied, while SIMPLE
-corresponds to the 'simplified style'.
+when the `traffic-light' style is applied, while SIMPLE
+corresponds to the \"simplified style\".
Optional DEFAULT-D, TRAFFIC-D, SIMPLE-D are alternatives to the
main colors, meant for dopia when `modus-themes-deuteranopia' is
secret)))
(defun auth-source-pick-first-password (&rest spec)
- "Pick the first secret found by applying 'auth-source-search' to SPEC."
+ "Pick the first secret found by applying `auth-source-search' to SPEC."
(auth-info-password (car (apply #'auth-source-search (plist-put spec :max 1)))))
(defun auth-source-format-prompt (prompt alist)
(defun auth-source--decode-octal-string (string)
- "Convert octal STRING to utf-8 string. E.g: 'a\134b' to 'a\b'."
+ "Convert octal STRING to utf-8 string. E.g: \"a\134b\" to \"a\b\"."
(let ((list (string-to-list string))
(size (length string)))
(decode-coding-string
LONG is a desired text for a wide window, SHORT is a desired
abbreviated text, and width is the buffer width, which will be
-some fraction of the 'parent' window width (At the time of
+some fraction of the \"parent\" window width (At the time of
writing, 2/3 for calc, 1/3 for trail). The optional FUDGE is a
trial-and-error adjustment number for the edge-cases at the
border of the two cases."
(defun ede-flush-directory-hash ()
"Flush the project directory hash.
Do this only when developing new projects that are incorrectly putting
-'nomatch tokens into the hash."
+`nomatch' tokens into the hash."
(interactive)
(setq ede-project-directory-hash (make-hash-table :test 'equal))
;; Also slush the current project's locator hash.
(defvar semantic-working-type 'percent
"The type of working message to use when parsing.
-'percent means we are doing a linear parse through the buffer.
-'dynamic means we are reparsing specific tags.")
+`percent' means we are doing a linear parse through the buffer.
+`dynamic' means we are reparsing specific tags.")
(defvar semantic-minimum-working-buffer-size (* 1024 5)
"The minimum size of a buffer before working messages are displayed.
(defvar semanticdb-project-predicate-functions nil
"List of predicates to try that indicate a directory belongs to a project.
This list is used when `semanticdb-persistent-path' contains the value
-'project. If the predicate list is nil, then presume all paths are valid.
+`project'. If the predicate list is nil, then presume all paths are valid.
Project Management software (such as EDE and JDE) should add their own
predicates with `add-hook' to this variable, and semanticdb will save tag
If optional argument SEARCH-PARTS is non-nil, all sub-parts of tags
are searched. The overloadable function `semantic-tag-components' is
used for the searching child lists. If SEARCH-PARTS is the symbol
-'positiononly, then only children that have positional information are
+`positiononly', then only children that have positional information are
searched.
If SEARCH-INCLUDES has not been implemented.
Return the list of FUN results. If optional PROPERTY is non-nil only
call FUN for javadoc keywords which have a value for PROPERTY. FUN
receives two arguments: the javadoc keyword and its associated
-'javadoc property list. It can return any value. All nil values are
+`javadoc' property list. It can return any value. All nil values are
removed from the result list."
(delq nil
(mapcar
(point))))))
(defun semantic-lex-spp-get-overlay (&optional point)
- "Return first overlay which has a 'semantic-spp property."
+ "Return first overlay which has a `semantic-spp' property."
(let ((overlays (overlays-at (or point (point)))))
(while (and overlays
(null (overlay-get (car overlays) 'semantic-spp)))
root of a project, and returns non-nil if the tool represented by KEY
is supported.
-If no tools are supported, then 'grep is assumed.")
+If no tools are supported, then `grep' is assumed.")
(defun semantic-symref-calculate-rootdir ()
"Calculate the root directory for a symref search.
Return the Semantic tag associated with HIT.
SEARCHTXT is the text that is being searched for.
Used to narrow the in-buffer search.
-SEARCHTYPE is the type of search (such as 'symbol or 'tagname).
+SEARCHTYPE is the type of search (such as `symbol' or `tagname').
If there is no database, or if the searchtype is wrong, return nil."
;; Allowed search types for this mechanism:
;; tagname, tagregexp, tagcompletions
Return the Semantic tag associated with HIT.
SEARCHTXT is the text that is being searched for.
Used to narrow the in-buffer search.
-SEARCHTYPE is the type of search (such as 'symbol or 'tagname).
+SEARCHTYPE is the type of search (such as `symbol' or `tagname').
Optional OPEN-BUFFERS, when nil will use a faster version of
`find-file' when a file needs to be opened. If non-nil, then
normal buffer initialization will be used.
(defvar doc-view-doc-type nil
"The type of document in the current buffer.
-Can be `dvi', `pdf', `ps', `djvu', `odf', 'epub', `cbz', `fb2',
-`'xps' or `oxps'.")
+Can be `dvi', `pdf', `ps', `djvu', `odf', `epub', `cbz', `fb2',
+`xps' or `oxps'.")
;; FIXME: The doc-view-current-* definitions below are macros because they
;; map to accessors which we want to use via `setf' as well!
(defun electric-pair--syntax-ppss (&optional pos where)
"Like `syntax-ppss', but sometimes fallback to `parse-partial-sexp'.
-WHERE is a list defaulting to '(string comment) and indicates
+WHERE is a list defaulting to \\='(string comment) and indicates
when to fallback to `parse-partial-sexp'."
(let* ((pos (or pos (point)))
(where (or where '(string comment)))
(push x defun-declarations-alist)))
(defun cl--optimize (f _args &rest qualities)
- "Serve 'cl-optimize' in function declarations.
+ "Serve `cl-optimize' in function declarations.
Example:
(defun foo (x)
(declare (cl-optimize (speed 3) (safety 0)))
(defvar comp-curr-allocation-class 'd-default
"Current allocation class.
-Can be one of: 'd-default', 'd-impure' or 'd-ephemeral'. See `comp-ctxt'.")
+Can be one of: `d-default', `d-impure' or `d-ephemeral'. See `comp-ctxt'.")
(defconst comp-passes '(comp-spill-lap
comp-limplify
(defun comp-alloc-class-to-container (alloc-class)
"Given ALLOC-CLASS, return the data container for the current context.
-Assume allocation class 'd-default as default."
+Assume allocation class `d-default' as default."
(cl-struct-slot-value 'comp-ctxt (or alloc-class 'd-default) comp-ctxt))
(defsubst comp-add-const-to-relocs (obj)
do (comp-emit-call-cstr target insn-cell cstr)))))))
(defun comp-add-cstrs (_)
- "Rewrite conditional branches adding appropriate 'assume' insns.
-This is introducing and placing 'assume' insns in use by fwprop
+ "Rewrite conditional branches adding appropriate `assume' insns.
+This is introducing and placing `assume' insns in use by fwprop
to propagate conditional branch test information on target basic
blocks."
(maphash (lambda (_ f)
(defun comp-remove-type-hints-func ()
"Remove type hints from the current function.
-These are substituted with a normal 'set' op."
+These are substituted with a normal `set' op."
(cl-loop
for b being each hash-value of (comp-func-blocks comp-func)
do (comp-loop-insn-in-block b
Force the produced .eln to be outputted in the eln system
directory (the last entry in `native-comp-eln-load-path') unless
`native-compile-target-directory' is non-nil. If the environment
-variable 'NATIVE_DISABLED' is set, only byte compile."
+variable \"NATIVE_DISABLED\" is set, only byte compile."
(comp-ensure-native-compiler)
(if (equal (getenv "NATIVE_DISABLED") "1")
(batch-byte-compile)
(defun my-test-explain (args...)
(let ((faceup-test-explain t))
(the-test args...)))
- (put 'my-test 'ert-explainer 'my-test-explain)
+ (put \\='my-test \\='ert-explainer \\='my-test-explain)
Alternative, you can use the macro `faceup-defexplainer' as follows:
"Return file-name extension of package-desc object PKG-DESC.
Depending on the `package-desc-kind' of PKG-DESC, this is one of:
- 'single - \".el\"
- 'tar - \".tar\"
- 'dir - \"\"
+ \\='single - \".el\"
+ \\='tar - \".tar\"
+ \\='dir - \"\"
Signal an error if the kind is none of the above."
(pcase (package-desc-kind pkg-desc)
means that the match region is ended if the value changes. For
instance, this means that if you loop with
- (while (setq prop (text-property-search-forward 'face))
+ (while (setq prop (text-property-search-forward \\='face))
...)
you will get all distinct regions with non-nil `face' values in
Set undo boundary if UNDO is non-nil.
Rectangle is padded if PAD = t or numeric and (cua--rectangle-virtual-edges)
Perform auto-tabify after operation if TABIFY is non-nil.
-Mark is kept if keep-clear is 'keep and cleared if keep-clear is 'clear."
+Mark is kept if keep-clear is `keep' and cleared if keep-clear is `clear'."
(declare (indent 4))
(let* ((inhibit-field-text-motion t)
(start (cua--rectangle-top))
(defun erc-bounds-of-word-at-point ()
"Return the bounds of word at point, or nil if we're not at a word.
If no `subword-mode' is active, then this is
-\(bounds-of-thing-at-point 'word)."
+\(bounds-of-thing-at-point \\='word)."
(if (or (erc-word-at-arg-p (point))
(erc-word-at-arg-p (1- (point))))
(save-excursion
available in most of Emacs, with the exception of filename completion
in the minibuffer:
- (advice-add 'expand-file-name :around #'my-expand-multiple-dots)
+ (advice-add \\='expand-file-name :around #\\='my-expand-multiple-dots)
(defun my-expand-multiple-dots (orig-fun filename &rest args)
(apply orig-fun (eshell-expand-multiple-dots filename) args))"
(while (string-match "\\(?:\\`\\|/\\)\\.\\.\\(\\.+\\)\\(?:\\'\\|/\\)"
NAME an environment or Lisp variable value
\"LONG-NAME\" disambiguates the length of the name
- 'LONG-NAME' as above
+ `LONG-NAME' as above
{COMMAND} result of command is variable's value
(LISP-FORM) result of Lisp form is variable's value
<COMMAND> write the output of command to a temporary file;
Storing information about resize operations is off by default.
If you set the variable `frame-size-history' like this
-(setq frame-size-history '(100))
+(setq frame-size-history \\='(100))
then Emacs will save information about the next 100 significant
operations affecting any frame's size in that variable. This
(defun gnus-search-prepare-query (query-spec)
"Accept a search query in raw format, and prepare it.
QUERY-SPEC is an alist produced by functions such as
-`gnus-group-make-search-group', and contains at least a 'query
+`gnus-group-make-search-group', and contains at least a `query'
key, and possibly some meta keys. This function extracts any
-additional meta keys from the 'query string, and parses the
+additional meta keys from the `query' string, and parses the
remaining string, then adds all that to the top-level spec."
(let ((query (alist-get 'query query-spec))
val)
(defun gnus-collect-urls-from-article ()
"Select the article and return the list of URLs in it.
-See 'gnus-collect-urls'."
+See `gnus-collect-urls'."
(gnus-summary-select-article)
(gnus-with-article-buffer
(article-goto-body)
This is meant to be used for MIME handlers: Setting the handler
for \"x-scheme-handler/mailto;\" to \"emacs -f message-mailto %u\"
will then start up Emacs ready to compose mail. For emacsclient use
- emacsclient -e '(message-mailto \"%u\")'"
+ emacsclient -e \\='(message-mailto \"%u\")'"
(interactive)
;; <a href="mailto:someone@example.com?subject=This%20is%20the%20subject&cc=someone_else@example.com&body=This%20is%20the%20body">Send email</a>
(message-mail)
(defvar nnmairix-widget-other
'(threads flags)
"Other editable mairix commands when using customization widgets.
-Currently there are 'threads and 'flags.")
+Currently there are `threads' and `flags'.")
(defvar nnmairix-interactive-query-parameters
'((?f "from" "f" "From") (?t "to" "t" "To") (?c "to" "tc" "To or Cc")
(defun nnselect-generate-artlist (group &optional specs)
"Generate the artlist for GROUP using SPECS.
-SPECS should be an alist including an 'nnselect-function and an
-'nnselect-args. The former applied to the latter should create
+SPECS should be an alist including an `nnselect-function' and an
+`nnselect-args'. The former applied to the latter should create
the artlist. If SPECS is nil retrieve the specs from the group
parameters."
(let* ((specs
so, that further checks are needed. The value t means that the
message is definitely not spam, and that further spam checks
should be inhibited. Otherwise, a mailgroup name or the symbol
-'spam (depending on `spam-split-symbolic-return') is returned where
+`spam' (depending on `spam-split-symbolic-return') is returned where
the mail should go, and further checks are also inhibited. The
usual mailgroup name is the value of `spam-split-group', meaning
that the message is definitely a spam."
data, and IMAGE-FORMAT should be a symbol with a MIME format name
like \"image/webp\". For instance:
- (image-convert data-string 'image/bmp)
+ (image-convert data-string \\='image/bmp)
IMAGE can also be an image object as returned by `create-image'.
(ccl-check-register expr cmd)))
(defun ccl-compile-branch-blocks (code rrr blocks)
- "Compile BLOCKs of BRANCH statement. CODE is 'branch or 'read-branch.
+ "Compile BLOCKs of BRANCH statement. CODE is `branch' or `read-branch'.
REG is a register which holds a value of EXPRESSION part. BLOCKs
is a list of CCL-BLOCKs."
(let ((branches (length blocks))
Here's some example key sequences.
- \"f\" (the key 'f')
- \"S o m\" (a three key sequence of the keys 'S', 'o' and 'm')
- \"C-c o\" (a two key sequence of the keys 'c' with the control modifier
- and then the key 'o')
+ \"f\" (the key `f')
+ \"S o m\" (a three key sequence of the keys `S', `o' and `m')
+ \"C-c o\" (a two key sequence of the keys `c' with the control modifier
+ and then the key `o')
\"H-<left>\" (the key named \"left\" with the hyper modifier)
\"M-RET\" (the \"return\" key with a meta modifier)
\"C-M-<space>\" (the \"space\" key with both the control and meta modifiers)
nil)
(defun ls-lisp--sanitize-switches (switches)
- "Convert long options of GNU 'ls' to their short form.
+ "Convert long options of GNU \"ls\" to their short form.
Conversion is done only for flags supported by ls-lisp.
Long options not supported by ls-lisp are removed.
Supported options are: A a B C c F G g h i n R r S s t U u v X.
Example advice for mail-send:
- (advice-add 'mail-send :around #'my-feedmail-mail-send-advice)
+ (advice-add \\='mail-send :around #\\='my-feedmail-mail-send-advice)
(defun my-feedmail-mail-send-advice (orig-fun &rest args)
(let ((feedmail-queue-buffer-file-name buffer-file-name)
(buffer-file-name nil))
feedmail FQM message file from a queue. You could use something like
this:
- (add-to-list 'auto-mode-alist \\='(\"\\\\.fqm\\\\\\='\" . feedmail-vm-mail-mode))"
+ (add-to-list \\='auto-mode-alist \\='(\"\\\\.fqm\\\\\\='\" . feedmail-vm-mail-mode))"
(feedmail-say-debug ">in-> feedmail-vm-mail-mode")
(let ((the-buf (current-buffer)))
(vm-mail)
;;; Support Routines
(defun mh-subject-to-sequence (all)
- "Put all following messages with same subject in sequence 'subject.
+ "Put all following messages with same subject in sequence `subject'.
If arg ALL is t, move to beginning of folder buffer to collect all
messages.
If arg ALL is nil, collect only messages from current one on forward.
(mh-subject-to-sequence-unthreaded all)))
(defun mh-subject-to-sequence-threaded (all)
- "Put all messages with the same subject in the 'subject sequence.
+ "Put all messages with the same subject in the `subject' sequence.
This function works when the folder is threaded. In this
situation the subject could get truncated and so the normal
It would be desirable to avoid hard-coding this.")
(defun mh-subject-to-sequence-unthreaded (all)
- "Put all following messages with same subject in sequence 'subject.
+ "Put all following messages with same subject in sequence `subject'.
This function only works with an unthreaded folder. If arg ALL is
t, move to beginning of folder buffer to collect all messages. If
;;;###mh-autoload
(defun mh-have-file-command ()
"Return t if `file' command is on the system.
-'file -i' is used to get MIME type of composition insertion."
+\"file -i\" is used to get MIME type of composition insertion."
(when (eq mh-have-file-command 'undefined)
(setq mh-have-file-command
(and (executable-find "file") ; file command exists
into
(prefix \"f\" any \"o\" any \"o\" any point)
which is at the core of flex logic. The extra
-'any' is optimized away later on."
+`any' is optimized away later on."
(mapcan (lambda (elem)
(if (stringp elem)
(mapcan (lambda (char)
"Return the status of the CONNECTION.
Possible return values are the symbols:
nil: argument is not a connection object
- 'none: argument is not connected
- 'up: connection is open and buffer is existing
- 'down: connection is closed
- 'alone: connection is not associated with a buffer"
+ `none': argument is not connected
+ `up': connection is open and buffer is existing
+ `down': connection is closed
+ `alone': connection is not associated with a buffer"
(when (dictionary-connection-p connection)
(let ((process (dictionary-connection-process connection))
(buffer (dictionary-connection-buffer connection)))
(defvar eww-accept-content-types
"text/html, text/plain, text/sgml, text/css, application/xhtml+xml, */*;q=0.01"
- "Value used for the HTTP 'Accept' header.")
+ "Value used for the HTTP \"Accept\" header.")
(defvar-keymap eww-link-keymap
:parent shr-map
unchanged after expansion (i.e. no host, no user or no port
were specified), that sublist is not used. For e.g.
- '((\"-a\" \"-b\") (\"-l\" \"%u\"))
+ \\='((\"-a\" \"-b\") (\"-l\" \"%u\"))
that means that (\"-l\" \"%u\") is used only if the user was
specified, and it is thus effectively optional.
Dragging extends region/selection.
Multi-clicking selects word/lines/paragraphs, as determined by
-'mouse-sel-determine-selection-thing.
+`mouse-sel-determine-selection-thing'.
Clicking mouse-2 while selecting copies selected text to the kill-ring.
Clicking mouse-1 or mouse-3 kills the selected text.
Dragging extends the secondary selection.
Multi-clicking selects word/lines/paragraphs, as determined by
-'mouse-sel-determine-selection-thing.
+`mouse-sel-determine-selection-thing'.
Clicking mouse-2 while selecting copies selected text to the kill-ring.
Clicking mouse-1 or mouse-3 kills the selected text.
evaluates to a string. The closure is evaluated when the source
block is being evaluated (e.g. during execution or export), with
point at the source block. It is not possible to use an
-arbitrary function symbol (e.g. 'some-func), since org uses
+arbitrary function symbol (e.g. `some-func'), since org uses
lexical binding. To achieve the same functionality, call the
function within a closure (e.g. (lambda () (some-func))).
(defun org-babel-julia-evaluate-external-process
(body result-type result-params column-names-p)
"Evaluate BODY in external julia process.
-If RESULT-TYPE equals 'output then return standard output as a
-string. If RESULT-TYPE equals 'value then return the value of the
+If RESULT-TYPE equals `output' then return standard output as a
+string. If RESULT-TYPE equals `value' then return the value of the
last statement in BODY, as elisp."
(cl-case result-type
(value
(defun org-babel-julia-evaluate-session
(session body result-type result-params column-names-p)
"Evaluate BODY in SESSION.
-If RESULT-TYPE equals 'output then return standard output as a
-string. If RESULT-TYPE equals 'value then return the value of the
+If RESULT-TYPE equals `output' then return standard output as a
+string. If RESULT-TYPE equals `value' then return the value of the
last statement in BODY, as elisp."
(cl-case result-type
(value
(org-babel-lua-table-or-string results)))))
(defun org-babel-lua-read-string (string)
- "Strip 's from around Lua string."
+ "Strip \\=' characters from around Lua string."
(org-unbracket-string "'" "'" string))
(provide 'ob-lua)
If the header at `org-hd-marker' is blocked according to
`org-entry-blocked-p', then if `org-agenda-dim-blocked-tasks' is
-'invisible and the header is not blocked by checkboxes, set the
+`invisible' and the header is not blocked by checkboxes, set the
text property `org-todo-blocked' to `invisible', otherwise set it
to t."
(when (get-text-property 0 'todo-state entry)
When in a restricted subtree, remove it.
The restriction will span over the entire file if TYPE is `file',
-or if type is '(4), or if the cursor is before the first headline
+or if type is \\='(4), or if the cursor is before the first headline
in the file. Otherwise, only apply the restriction to the current
subtree."
(interactive "P")
collect (cons n (/ (length m) normaliser)))))
(defun org--plot/prime-factors (value)
- "Return the prime decomposition of VALUE, e.g. for 12, '(3 2 2)."
+ "Return the prime decomposition of VALUE, e.g. for 12, \\='(3 2 2)."
(let ((factors '(1)) (i 1))
(while (/= 1 value)
(setq i (1+ i))
(nreverse table)))))
(defun org-table-collapse-header (table &optional separator max-header-lines)
- "Collapse the lines before 'hline into a single header.
+ "Collapse the lines before `hline' into a single header.
The given TABLE is a list of lists as returned by `org-table-to-lisp'.
The leading lines before the first `hline' symbol are considered
(defun org-html--unlabel-latex-environment (latex-frag)
"Change environment in LATEX-FRAG string to an unnumbered one.
-For instance, change an 'equation' environment to 'equation*'."
+For instance, change an `equation' environment to `equation*'."
(replace-regexp-in-string
"\\`[ \t]*\\\\begin{\\([^*]+?\\)}"
"\\1*"
latter case, optional argument BACKEND has to be set to the
back-end where the option is defined, e.g.,
- (org-publish-find-property file :subtitle 'latex)
+ (org-publish-find-property file :subtitle \\='latex)
Return value may be a string or a list, depending on the type of
PROPERTY, i.e. \"behavior\" parameter from `org-export-options-alist'."
(defun outline--cycle-state ()
"Return the cycle state of current heading.
-Return either 'hide-all, 'headings-only, or 'show-all."
+Return either `hide-all', `headings-only', or `show-all'."
(save-excursion
(let (start end ov-list heading-end)
(outline-back-to-heading)
Objects that cannot be taken but might move and are
described during room description are negative.
Stuff that is described and might change are 255, and are
-handled specially by 'dun-describe-room.")
+handled specially by `dun-describe-room'.")
(defconst dun-room-silents (list nil
(list obj-tree obj-coconut) ;; dead-end
(defun elisp--xref-make-xref (type symbol file &optional summary)
"Return an xref for TYPE SYMBOL in FILE.
TYPE must be a type in `find-function-regexp-alist' (use nil for
-'defun). If SUMMARY is non-nil, use it for the summary;
+`defun'). If SUMMARY is non-nil, use it for the summary;
otherwise build the summary from TYPE and SYMBOL."
(xref-make (or summary
(format elisp--xref-format (or type 'defun) symbol))
If buffer has trigger associated with it in `gdb-buffer-rules',
this trigger is subscribed to `gdb-buf-publisher' and called with
-'update argument."
+`update' argument."
(or (gdb-get-buffer buffer-type thread)
(let ((rules (assoc buffer-type gdb-buffer-rules))
(new (generate-new-buffer "limbo")))
Add functions to the hook with `add-hook':
- (add-hook 'tcl-mode-hook #'tcl-guess-application)")
+ (add-hook \\='tcl-mode-hook #\\='tcl-guess-application)")
(defvar tcl-proc-list
Meaning of *single* declaration:
E.g. In a module's port-list -
module test(input clk, rst, x, output [1:0] y);
- Here 'input clk, rst, x' is 1 *single* declaration statement,
-and 'output [1:0] y' is the other single declaration. In the 1st single
-declaration, POINT is moved to start of 'clk'. And in the 2nd declaration,
-POINT is moved to 'y'."
+ Here `input clk, rst, x' is 1 *single* declaration statement,
+and `output [1:0] y' is the other single declaration. In the 1st single
+declaration, POINT is moved to start of `clk'. And in the 2nd declaration,
+POINT is moved to `y'."
(let (maxpoint old-point)
(xref--find-ignores-arguments ignores dir)))
(defun xref--find-ignores-arguments (ignores dir)
- "Convert IGNORES and DIR to a list of arguments for 'find'.
+ "Convert IGNORES and DIR to a list of arguments for `find'.
IGNORES is a list of glob patterns. DIR is an absolute
directory, used as the root of the ignore globs."
(cl-assert (not (string-match-p "\\`~" dir)))
"Recalculate and reprint the current cell or range.
If CURCELL is non nil use it as current cell or range
-without any check, otherwise function (ses-check-curcell 'range)
+without any check, otherwise function (ses-check-curcell \\='range)
is called.
For an individual cell, shows the error if the formula or printer
\"%.2f\" or (\"%.2f\") for left alignment.
or a lambda expression, e.g. for formatting in ISO format dates
-created with a '(calcFunc-date YEAR MONTH DAY)' formula:
+created with a `(calcFunc-date YEAR MONTH DAY)' formula:
(lambda (x)
(cond
((null val) \"\")
- ((eq (car-safe x) 'date)
- (let ((calc-format-date '(X YYYY \"-\" MM \"-\" DD)))
+ ((eq (car-safe x) \\='date)
+ (let ((calc-format-date \\='(X YYYY \"-\" MM \"-\" DD)))
(math-format-date x)))
- (t (ses-center-span val ?# 'ses-prin1))))
+ (t (ses-center-span val ?# \\='ses-prin1))))
If NAME is already used to name a local printer function, then
the current definition is proposed as default value, and the
(ses-center-span value ?~ printer))
(defun ses-prin1 (value)
- "Shorthand for '(prin1-to-string VALUE t)'.
+ "Shorthand for `(prin1-to-string VALUE t)'.
Useful to handle the default behavior in custom lambda based
printer functions."
(prin1-to-string value t))
(defun tab-bar--key-to-number (key)
"Return the tab number represented by KEY.
-If KEY is a symbol 'tab-N', where N is a tab number, the value is N.
+If KEY is a symbol `tab-N', where N is a tab number, the value is N.
If KEY is \\='current-tab, the value is nil.
For any other value of KEY, the value is t."
(cond
or if you want to disable the tab bar individually on each
new frame when the global `tab-bar-mode' is enabled, by using
- (add-hook 'after-make-frame-functions 'toggle-frame-tab-bar)"
+ (add-hook \\='after-make-frame-functions #\\='toggle-frame-tab-bar)"
(interactive)
(set-frame-parameter frame 'tab-bar-lines
(if (> (frame-parameter frame 'tab-bar-lines) 0) 0 1))
If the reference key of the entry is empty or a prefix argument is given,
calculate a new reference key. (Note: this works only if fields in entry
begin on separate lines prior to calling `bibtex-clean-entry' or if
-'realign is contained in `bibtex-entry-format'.)
+`realign' is contained in `bibtex-entry-format'.)
Don't call `bibtex-clean-entry' on @Preamble entries.
At end of the cleaning process, the functions in
`bibtex-clean-entry-hook' are called with region narrowed to entry."
`rst-insert-list-new-tag'.
If user selects enumerations, a further prompt is given. User need to
-input a starting item, for example 'e' for 'A)' style. The position is
+input a starting item, for example `e' for `A)' style. The position is
also arranged by `rst-insert-list-new-tag'."
(let* ((itemstyle (completing-read
(format-prompt "Select preferred item style" "#.")
you are contemplating using it in your own code, then you should
probably use this instead:
- (get COMMAND 'transient--suffix)"
+ (get COMMAND \\='transient--suffix)"
(when command
(cl-check-type command command))
(if (or transient--prefix
"Find the key bindings used in the tutorial that have changed.
Return a list with elements of the form
- '(KEY DEF-FUN DEF-FUN-TXT WHERE REMARK QUIET)
+ (KEY DEF-FUN DEF-FUN-TXT WHERE REMARK QUIET)
where
(defun url-digest-auth-build-response (key url realm attrs)
"Compute authorization string for the given challenge using KEY.
-The string looks like 'Digest username=\"John\", realm=\"The
-Realm\", ...'
+The string looks like \"Digest username=\"John\", realm=\"The
+Realm\", ...\"
Part of the challenge is already solved in a pre-computed KEY
which is list of a realm (or a directory), user name, and hash
(defun vc-rcs-consult-headers (file)
"Search for RCS headers in FILE, and set properties accordingly.
-Returns: nil if no headers were found
- 'rev if a workfile revision was found
- 'rev-and-lock if revision and lock info was found"
+Returns: nil if no headers were found
+ `rev' if a workfile revision was found
+ `rev-and-lock' if revision and lock info was found"
(cond
((not (get-file-buffer file)) nil)
((let (status version)
value is nil. Avoid returning the selected window if possible.
Optional argument NOT-SELECTED non-nil means never return the
selected window. Optional argument NO-OTHER non-nil means to
-never return a window whose 'no-other-window' parameter is
+never return a window whose `no-other-window' parameter is
non-nil.
The following non-nil values of the optional argument ALL-FRAMES
are dedicated, the value is nil. Optional argument NOT-SELECTED
non-nil means never return the selected window. Optional
argument NO-OTHER non-nil means to never return a window whose
-'no-other-window' parameter is non-nil.
+`no-other-window' parameter is non-nil.
The following non-nil values of the optional argument ALL-FRAMES
have special meanings:
are dedicated, the value is nil. Optional argument NOT-SELECTED
non-nil means never return the selected window. Optional
argument NO-OTHER non-nil means to never return a window whose
-'no-other-window' parameter is non-nil.
+`no-other-window' parameter is non-nil.
The following non-nil values of the optional argument ALL-FRAMES
have special meanings:
more details.
If WINDOW's dedicated flag is t, try to delete WINDOW. If it
-equals the value 'side', restore that value when WINDOW is not
+equals the value `side', restore that value when WINDOW is not
deleted.
Optional second argument BURY-OR-KILL tells how to proceed with
For instance:
- (setq display-buffer-alist '((\".*\" display-buffer-at-bottom)))
+ (setq display-buffer-alist \\='((\".*\" display-buffer-at-bottom)))
Buffer display can be further customized to a very high degree;
the rest of this docstring explains some of the many
the window specified in frame lines), a floating point
number (the fraction of its total height with respect to the
total height of the frame's root window), a cons cell whose
- car is 'body-lines' and whose cdr is an integer that
+ car is `body-lines' and whose cdr is an integer that
specifies the height of the window's body in frame lines, or
a function to be called with one argument - the chosen
window. That function is supposed to adjust the height of
the window specified in frame lines), a floating point
number (the fraction of its total width with respect to the
width of the frame's root window), a cons cell whose car is
- 'body-columns' and whose cdr is an integer that specifies the
+ `body-columns' and whose cdr is an integer that specifies the
width of the window's body in frame columns, or a function to
be called with one argument - the chosen window. That
function is supposed to adjust the width of the window.
alone on their frame and specifies the desired size of that
window either as a cons of integers (the total width and
height of the window on that frame), a cons cell whose car is
- 'body-chars' and whose cdr is a cons of integers (the desired
+ `body-chars' and whose cdr is a cons of integers (the desired
width and height of the window's body in columns and lines of
its frame), or a function to be called with one argument -
the chosen window. That function is supposed to adjust the
;; be used to compare such calc expressions.
(defun calc-tests-equal (a b)
"Like `equal' but allow for different representations of numbers.
-For example: (calc-tests-equal 10 '(float 1 1)) => t.
+For example: (calc-tests-equal 10 \\='(float 1 1)) => t.
A and B should be calc expressions."
(cond ((math-numberp a)
(and (math-numberp b)
;;; MAP DUMP TESTING
(defun srecode-utest-map-reset ()
"Reset, then dump the map of SRecoder templates.
-Probably should be called 'describe-srecode-maps'."
+Probably should be called `describe-srecode-maps'."
(interactive)
(message "SRecode Template Path: %S" srecode-map-load-path)
;; Interactive call allows us to dump.
(eval-when-compile (require 'cl-lib))
(defun mh-thread-tests-before-from ()
- "Generate the fields of a scan line up to where the 'From' field would start.
+ "Generate the fields of a scan line up to where the \"From\" field would start.
The exact contents are not important, but the number of characters is."
(concat (make-string mh-cmd-note ?9)
(make-string mh-scan-cmd-note-width ?A)
((("FOOBAR:" . "something") nil "hi there"))
((FOOBAR:something nil "hi there"))))
"List of strings which are parsed using namespace expansion.
-Parser is called with and without 'symbol-qnames argument.")
+Parser is called with and without `symbol-qnames' argument.")
(ert-deftest xml-parse-tests ()
"Test XML parsing."
(defun regex-tests-compare (string what-failed bounds-ref &optional substring-ref)
"I just ran a search, looking at STRING. WHAT-FAILED describes
-what failed, if anything; valid values are 'search-failed,
-'compilation-failed and nil. I compare the beginning/end of each
+what failed, if anything; valid values are `search-failed',
+`compilation-failed' and nil. I compare the beginning/end of each
group with their expected values. This is done with either
BOUNDS-REF or SUBSTRING-REF; one of those should be non-nil.
BOUNDS-REF is a sequence [start-ref0 end-ref0 start-ref1
obtained by indexing the input string by start/end-ref.
If the search was supposed to fail then start-ref0/substring-ref0
-is 'search-failed. If the search wasn't even supposed to compile
+is `search-failed'. If the search wasn't even supposed to compile
successfully, then start-ref0/substring-ref0 is
-'compilation-failed. If I only care about a match succeeding,
+`compilation-failed'. If I only care about a match succeeding,
this can be set to t.
This function returns a string that describes the failure, or nil
....].
If the search was supposed to fail then start-ref0 is
-'search-failed. If the search wasn't even supposed to compile
-successfully, then start-ref0 is 'compilation-failed.
+`search-failed'. If the search wasn't even supposed to compile
+successfully, then start-ref0 is `compilation-failed'.
This function returns a string that describes the failure, or nil
on success"
projects / emacs.git / commitdiff