+2007-08-08 Glenn Morris <rgm@gnu.org>
+
+ * emacs-lisp/checkdoc.el (checkdoc-ispell-lisp-words): Remove `iff'.
+
+ * Replace `iff' in doc-strings and comments.
+
2007-08-08 Martin Rudalics <rudalics@gmx.at>
* dired.el (dired-pop-to-buffer):
;;;###autoload
(defun gmm-widget-p (symbol)
- "Non-nil iff SYMBOL is a widget."
+ "Non-nil if SYMBOL is a widget."
(get symbol 'widget-type))
;; Copy of the `nnmail-lazy' code from `nnmail.el':
(pop alist))))))
(defun gnus-async-prefetched-article-entry (group article)
- "Return the entry for ARTICLE in GROUP iff it has been prefetched."
+ "Return the entry for ARTICLE in GROUP if it has been prefetched."
(let ((entry (save-excursion
(gnus-async-set-buffer)
(assq (intern (format "%s-%d" group article)
This is done because new users often reply by mistake when reading
news.
This can also be a function receiving the group name as the only
-parameter which should return non-nil iff a confirmation is needed, or
-a regexp, in which case a confirmation is asked for iff the group name
+parameter, which should return non-nil if a confirmation is needed; or
+a regexp, in which case a confirmation is asked for if the group name
matches the regexp."
:version "22.1"
:group 'gnus-message
:type '(choice (const :tag "No" nil)
(const :tag "Yes" t)
- (regexp :tag "Iff group matches regexp")
- (function :tag "Iff function evaluates to non-nil")))
+ (regexp :tag "If group matches regexp")
+ (function :tag "If function evaluates to non-nil")))
(defcustom gnus-confirm-treat-mail-like-news
nil
(const :tag "ask" nil)))
(defcustom gnus-score-default-fold nil
- "Use case folding for new score file entries iff not nil."
+ "Non-nil means use case folding for new score file entries."
:group 'gnus-score-default
:type 'boolean)
`(setq ,alist (delq (,fun ,key ,alist) ,alist))))
(defun gnus-globalify-regexp (re)
- "Return a regexp that matches a whole line, iff RE matches a part of it."
+ "Return a regexp that matches a whole line, if RE matches a part of it."
(concat (unless (string-match "^\\^" re) "^.*")
re
(unless (string-match "\\$$" re) ".*$")))
(imap-mailbox-get-1 'search imap-current-mailbox)))))
(defun imap-message-flag-permanent-p (flag &optional mailbox buffer)
- "Return t iff FLAG can be permanently (between IMAP sessions) saved on articles, in MAILBOX on server in BUFFER."
+ "Return t if FLAG can be permanently (between IMAP sessions) saved on articles, in MAILBOX on server in BUFFER."
(with-current-buffer (or buffer (current-buffer))
(or (member "\\*" (imap-mailbox-get 'permanentflags mailbox))
(member flag (imap-mailbox-get 'permanentflags mailbox)))))
results)))
(defun mailcap-mailcap-entry-passes-test (info)
- "Return non-nil iff mailcap entry INFO passes its test clause.
+ "Return non-nil if mailcap entry INFO passes its test clause.
Also return non-nil if no test clause is present."
(let ((test (assq 'test info)) ; The test clause
status)
(defvar mailcap-viewer-test-cache nil)
(defun mailcap-viewer-passes-test (viewer-info type-info)
- "Return non-nil iff viewer specified by VIEWER-INFO passes its test clause.
+ "Return non-nil if viewer specified by VIEWER-INFO passes its test clause.
Also return non-nil if it has no test clause. TYPE-INFO is an argument
to supply to the test."
(let* ((test-info (assq 'test viewer-info))
;;;
(defun mailcap-viewer-lessp (x y)
- "Return t iff viewer X is more desirable than viewer Y."
+ "Return t if viewer X is more desirable than viewer Y."
(let ((x-wild (string-match "[*?]" (or (cdr-safe (assq 'type x)) "")))
(y-wild (string-match "[*?]" (or (cdr-safe (assq 'type y)) "")))
(x-lisp (not (stringp (or (cdr-safe (assq 'viewer x)) ""))))
result)))
(defun nnimap-mark-permanent-p (mark &optional group)
- "Return t iff MARK can be permanently (between IMAP sessions) saved on articles, in GROUP."
+ "Return t if MARK can be permanently (between IMAP sessions) saved on articles, in GROUP."
(imap-message-flag-permanent-p (nnimap-mark-to-flag mark)))
(when nnimap-debug
res-size
;; 8. File modes, as a string of ten letters or dashes as in ls -l.
res-filemodes
- ;; 9. t iff file's gid would change if file were deleted and
+ ;; 9. t if file's gid would change if file were deleted and
;; recreated. Will be set in `tramp-convert-file-attributes'
t
;; 10. inode number.
(and (tramp-file-name-p obj) (aref obj 4)))
(defun tramp-tramp-file-p (name)
- "Return t iff NAME is a tramp file."
+ "Return t if NAME is a tramp file."
(save-match-data
(string-match tramp-file-name-regexp name)))
;; Just a directory.
directory)
(t
- ;; A directory iff the file name matches the regexp.
+ ;; A directory if the file name matches the regexp.
(let ((bufile (expand-file-name buffer-file-truename))
(case-fold-search nil))
(when (save-match-data (string-match (car directory) bufile))
general value, or `antlr-read-boolean' with ARGs = \(PROMPT TABLE) which
reads a boolean value or a member of TABLE. PROMPT is the prompt when
asking for a new value. If non-nil, TABLE is a table for completion or
-a function evaluating to such a table. The return value is quoted iff
+a function evaluating to such a table. The return value is quoted if
AS-STRING is non-nil and is either t or a symbol which is a member of
`antlr-options-style'.")
part \(CLASS-SPEC ...) in the result of `antlr-directory-dependencies'.
The result looks like \(OPTION WITH-UNKNOWN GLIB ...). OPTION is the
-complete \"-glib\" option. WITH-UNKNOWN has value t iff there is none
-or more than one grammar file for at least one super grammar.
+complete \"-glib\" option. WITH-UNKNOWN is t if there is none or more
+than one grammar file for at least one super grammar.
Each GLIB looks like \(GRAMMAR-FILE \. EVOCAB). GRAMMAR-FILE is a file
in which a super-grammar is defined. EVOCAB is the value of the export
(defun c-awk-get-NL-prop-prev-line (&optional do-lim)
;; Get the c-awk-NL-prop text-property from the previous line, calculating
- ;; it if necessary. Return nil iff we're already at BOB.
+ ;; it if necessary. Return nil if we're at BOB.
;; See c-awk-after-if-for-while-condition-p for a description of DO-LIM.
;;
;; This function might do hidden buffer changes.
;; Foo::Foo (int b) : Base (b) {}
;; car ^ ^ point
;;
- ;; The cdr of the return value is non-nil iff a
+ ;; The cdr of the return value is non-nil if a
;; `c-typedef-decl-kwds' specifier is found in the declaration,
;; i.e. the declared identifier(s) are types.
;;
(bq-process type)))))))))
(defun c-valid-offset (offset)
- "Return non-nil iff OFFSET is a valid offset for a syntactic symbol.
+ "Return non-nil if OFFSET is a valid offset for a syntactic symbol.
See `c-offsets-alist'."
(or (eq offset '+)
(eq offset '-)
(modify-syntax-entry starter (if (eq starter ?\\) "\\" ".") st)
(if ender (modify-syntax-entry ender "." st))))
;; i: have 2 args, after end of the first arg
- ;; i2: start of the second arg, if any (before delim iff `ender').
+ ;; i2: start of the second arg, if any (before delim if `ender').
;; ender: the last arg bounded by parens-like chars, the second one of them
;; starter: the starting delimiter of the first arg
;; go-forward: has 2 args, and the second part is empty
(defun cperl-beautify-regexp-piece (b e embed level)
;; b is before the starting delimiter, e before the ending
;; e should be a marker, may be changed, but remains "correct".
- ;; EMBED is nil iff we process the whole REx.
+ ;; EMBED is nil if we process the whole REx.
;; The REx is guaranteed to have //x
;; LEVEL shows how many levels deep to go
;; position at enter and at leave is not defined
(defun cpp-edit-toggle-known (arg)
"Toggle writable status for known conditionals.
-With optional argument ARG, make them writable iff ARG is positive."
+With optional argument ARG, make them writable if ARG is positive,
+otherwise make them unwritable."
(interactive "@P")
(if (or (and (null arg) cpp-known-writable)
(<= (prefix-numeric-value arg) 0))
(defun cpp-edit-toggle-unknown (arg)
"Toggle writable status for unknown conditionals.
-With optional argument ARG, make them writable iff ARG is positive."
+With optional argument ARG, make them writable if ARG is positive,
+otherwise make them unwritable."
(interactive "@P")
(if (or (and (null arg) cpp-unknown-writable)
(<= (prefix-numeric-value arg) 0))
(defvar tags-included-tables-function nil
"Function to do the work of `tags-included-tables' (which see).")
(defvar verify-tags-table-function nil
- "Function to return t iff current buffer contains valid tags file.")
+ "Function to return t if current buffer contains valid tags file.")
\f
;; Initialize the tags table in the current buffer.
-;; Returns non-nil iff it is a valid tags table. On
+;; Returns non-nil if it is a valid tags table. On
;; non-nil return, the tags table state variable are
;; made buffer-local and initialized to nil.
(defun initialize-new-tags-table ()
(defun tags-verify-table (file)
"Read FILE into a buffer and verify that it is a valid tags table.
Sets the current buffer to one visiting FILE (if it exists).
-Returns non-nil iff it is a valid table."
+Returns non-nil if it is a valid table."
(if (get-file-buffer file)
;; The file is already in a buffer. Check for the visited file
;; having changed since we last used it.
(verify-tags-table-function . etags-verify-tags-table)
))))
-;; Return non-nil iff the current buffer is a valid etags TAGS file.
(defun etags-verify-tags-table ()
+ "Return non-nil if the current buffer is a valid etags TAGS file."
;; Use eq instead of = in case char-after returns nil.
(eq (char-after (point-min)) ?\f))
;; From: ralf@up3aud1.gwdg.de (Ralf Fassel)
;; Test if TAB format continuation lines work.
(defun fortran-is-in-string-p (where)
- "Return non-nil iff WHERE (a buffer position) is inside a Fortran string."
+ "Return non-nil if WHERE (a buffer position) is inside a Fortran string."
(save-excursion
(goto-char where)
(cond
(defun gdb-many-windows (arg)
"Toggle the number of windows in the basic arrangement.
-With arg, display additional buffers iff arg is positive."
+With prefix argument ARG, display additional buffers if ARG is positive,
+otherwise use a single window."
(interactive "P")
(setq gdb-many-windows
(if (null arg)
(defun gdb-use-separate-io-buffer (arg)
"Toggle separate IO for debugged program.
-With arg, use separate IO iff arg is positive."
+With prefix argument ARG, use separate IO if ARG is positive,
+otherwise do not."
(interactive "P")
(setq gdb-use-separate-io-buffer
(if (null arg)
(defun gdb-speedbar-auto-raise (arg)
"Toggle automatic raising of the speedbar for watch expressions.
-With arg, automatically raise speedbar iff arg is positive."
+With prefix argument ARG, automatically raise speedbar if ARG is
+positive, otherwise don't automatically raise it."
(interactive "P")
(setq gdb-speedbar-auto-raise
(if (null arg)
(defun gdb-find-source-frame (arg)
"Toggle trying to find a source frame further up stack.
-With arg, look for a source frame further up stack iff arg is positive."
+With prefix argument ARG, look for a source frame further up
+stack if ARG is positive, otherwise don't look further up."
(interactive "P")
(setq gdb-find-source-frame
(if (null arg)
(defun gud-tooltip-dereference (&optional arg)
"Toggle whether tooltips should show `* expr' or `expr'.
-With arg, dereference expr iff arg is positive."
+With arg, dereference expr if ARG is positive, otherwise do not derereference."
(interactive "P")
(setq gud-tooltip-dereference
(if (null arg)
t -- open both code and comment blocks
nil -- open neither code nor comment blocks
-This has effect iff `search-invisible' is set to `open'."
+This has effect only if `search-invisible' is set to `open'."
:type '(choice (const :tag "open only code blocks" code)
(const :tag "open only comment blocks" comment)
(const :tag "open both code and comment blocks" t)
(goto-char (if repos-end end beg)))
(defun hs-hide-block-at-point (&optional end comment-reg)
- "Hide block iff on block beginning.
+ "Hide block if on block beginning.
Optional arg END means reposition at end.
Optional arg COMMENT-REG is a list of the form (BEGIN END) and
specifies the limits of the comment, or nil if the block is not
(goto-char maxp))
(defmacro hs-life-goes-on (&rest body)
- "Evaluate BODY forms iff variable `hs-minor-mode' is non-nil.
+ "Evaluate BODY forms if variable `hs-minor-mode' is non-nil.
In the dynamic context of this macro, `inhibit-point-motion-hooks'
and `case-fold-search' are both t."
`(when hs-minor-mode
(describe-function major-mode))
(defsubst octave-in-comment-p ()
- "Returns t if point is inside an Octave comment, nil otherwise."
+ "Return t if point is inside an Octave comment."
(interactive)
(save-excursion
(nth 4 (parse-partial-sexp (line-beginning-position) (point)))))
(defsubst octave-in-string-p ()
- "Returns t if point is inside an Octave string, nil otherwise."
+ "Return t if point is inside an Octave string."
(interactive)
(save-excursion
(nth 3 (parse-partial-sexp (line-beginning-position) (point)))))
(defsubst octave-not-in-string-or-comment-p ()
- "Returns t iff point is not inside an Octave string or comment."
+ "Return t if point is not inside an Octave string or comment."
(let ((pps (parse-partial-sexp (line-beginning-position) (point))))
(not (or (nth 3 pps) (nth 4 pps)))))
(defun octave-in-block-p ()
- "Returns t if point is inside an Octave block, nil otherwise.
+ "Return t if point is inside an Octave block.
The block is taken to start at the first letter of the begin keyword and
to end after the end keyword."
(let ((pos (point)))
(< pos (point)))))
(defun octave-in-defun-p ()
- "Returns t iff point is inside an Octave function declaration.
+ "Return t if point is inside an Octave function declaration.
The function is taken to start at the `f' of `function' and to end after
the end keyword."
(let ((pos (point)))
(error nil))))))))
(defun python-comment-line-p ()
- "Return non-nil iff current line has only a comment."
+ "Return non-nil if current line has only a comment."
(save-excursion
(end-of-line)
(when (eq 'comment (syntax-ppss-context (syntax-ppss)))
(looking-at (rx (or (syntax comment-start) line-end))))))
(defun python-blank-line-p ()
- "Return non-nil iff current line is blank."
+ "Return non-nil if current line is blank."
(save-excursion
(beginning-of-line)
(looking-at "\\s-*$")))
"Skip out of any nested brackets.
Skip forward if FORWARD is non-nil, else backward.
If SYNTAX is non-nil it is the state returned by `syntax-ppss' at point.
-Return non-nil iff skipping was done."
+Return non-nil if skipping was done."
(let ((depth (syntax-ppss-depth (or syntax (syntax-ppss))))
(forward (if forward -1 1)))
(unless (zerop depth)
(define-key map "\C-c\C-l" 'python-load-file)
(define-key map "\C-c\C-v" 'python-check)
;; Note that we _can_ still use these commands which send to the
- ;; Python process even at the prompt iff we have a normal prompt,
+ ;; Python process even at the prompt provided we have a normal prompt,
;; i.e. '>>> ' and not '... '. See the comment before
;; python-send-region. Fixme: uncomment these if we address that.
When Which Function mode is enabled, the current function name is
continuously displayed in the mode line, in certain major modes.
-With prefix ARG, turn Which Function mode on iff arg is positive,
+With prefix ARG, turn Which Function mode on if arg is positive,
and off otherwise."
:global t :group 'which-func
(if which-function-mode
(sleep-for 1)))
(defun xscheme-process-running-p ()
- "True iff there is a Scheme process whose status is `run'."
+ "True if there is a Scheme process whose status is `run'."
(let ((process (get-process xscheme-process-name)))
(and process
(eq (process-status process) 'run))))
(and buffer (get-buffer-window buffer))))
(defun xscheme-process-buffer-current-p ()
- "True iff the current buffer is the Scheme process buffer."
+ "True if the current buffer is the Scheme process buffer."
(eq (xscheme-process-buffer) (current-buffer)))
\f
;;;; Process Filter Operations
projects / emacs.git / commitdiff