string-equal-ignore-case: new function

* lisp/cedet/semantic/complete.el (semantic-collector-calculate-completions):
  Use `string-prefix-p' instead of explicit `compare-strings'.
* lisp/emacs-lisp/byte-opt.el (side-effect-free-fns):
  Add `string-equal-ignore-case'.
* lisp/emacs-lisp/cl-extra.el (cl-equalp): Use `string-equal-ignore-case'.
* lisp/emacs-lisp/shadow.el (load-path-shadows-find): Likewise.
* lisp/emacs-lisp/shortdoc.el (string): Add `string-equal-ignore-case'.
* lisp/files.el (file-truename): Use `string-equal-ignore-case'.
(file-relative-name): Likewise.
* lisp/gnus/gnus-art.el (article-hide-boring-headers):
  Use `string-equal-ignore-case' instead of `gnus-string-equal'.
* lisp/gnus/gnus-util.el (gnus-string-equal):
  Remove, use `string-equal-ignore-case' instead.
* lisp/international/mule-cmds.el (describe-language-environment):
  Use `string-equal-ignore-case'.
(locale-charset-match-p): Likewise.
* lisp/man.el (Man-softhyphen-to-minus): Use `string-prefix-p'.
* lisp/minibuffer.el (completion--string-equal-p):
  Remove, use `string-equal-ignore-case' instead.
(completion--twq-all): Use `string-equal-ignore-case'.
(completion--do-completion): Likewise.
* lisp/net/browse-url.el (browse-url-default-windows-browser):
  Use `string-prefix-p' instead of explicit `compare-strings'.
* lisp/org/ob-core.el (org-babel-results-keyword):
  Use `string-equal-ignore-case' instead of explicit `compare-strings'.
(org-babel-insert-result): Likewise.
* lisp/org/org-compat.el (string-equal-ignore-case):
  Define unless defined already.
(org-mode-flyspell-verify): Use `string-equal-ignore-case'.
* lisp/org/org-lint.el (org-lint-duplicate-custom-id): Likewise.
* lisp/org/ox.el (org-export-resolve-radio-link): Use
  `string-equal-ignore-case' and `string-clean-whitespace'.
* lisp/progmodes/flymake-proc.el
  (flymake-proc--check-patch-master-file-buffer):
  Use `string-prefix-p' instead of explicit `compare-strings'.
* lisp/progmodes/idlwave.el (idlwave-class-or-superclass-with-tag):
  Use `string-equal-ignore-case' instead of explicit `compare-strings'.
* lisp/subr.el (member-ignore-case): Use `string-equal-ignore-case'.
(string-equal-ignore-case): Compare strings ignoring case.
* lisp/textmodes/bibtex.el (bibtex-string=): Remove.
(bibtex-format-entry, bibtex-font-lock-url, bibtex-autofill-entry)
(bibtex-print-help-message, bibtex-validate, bibtex-validate-globally)
(bibtex-clean-entry, bibtex-completion-at-point-function, (bibtex-url):
  Use `string-equal-ignore-case' instead of `bibtex-string='.
* lisp/textmodes/sgml-mode.el (sgml-get-context):
  Use `string-equal-ignore-case' instead of explicit `compare-strings'.
(sgml-calculate-indent): Likewise
* test/lisp/subr-tests.el (string-comparison-test):
  Add tests for `string-equal-ignore-case'.

4 files changed, 21 insertions, 20 deletions

diff --git a/lisp/org/ob-core.el b/lisp/org/ob-core.el
index 04af84d2e44..3d159ed38a9 100644
--- a/lisp/org/ob-core.el
+++ b/lisp/org/ob-core.el
@@ -136,8 +136,7 @@ used."
   :type 'string
   :safe (lambda (v)
           (and (stringp v)
-               (eq (compare-strings "RESULTS" nil nil v nil nil t)
-                   t))))
+               (string-equal-ignore-case "RESULTS" v))))
 
 (defcustom org-babel-noweb-wrap-start "<<"
   "String used to begin a noweb reference in a code block.
@@ -2435,7 +2434,7 @@ INFO may provide the values of these header arguments (in the
                        ;; Escape contents from "export" wrap.  Wrap
                        ;; inline results within an export snippet with
                        ;; appropriate value.
-                       ((eq t (compare-strings type nil nil "export" nil nil t))
+                       ((string-equal-ignore-case type "export")
                         (let ((backend (pcase split
                                          (`(,_) "none")
                                          (`(,_ ,b . ,_) b))))
@@ -2446,14 +2445,14 @@ INFO may provide the values of these header arguments (in the
                                            backend) "@@)}}}")))
                        ;; Escape contents from "example" wrap.  Mark
                        ;; inline results as verbatim.
-                       ((eq t (compare-strings type nil nil "example" nil nil t))
+                       ((string-equal-ignore-case type "example")
                         (funcall wrap
                                  opening-line closing-line
                                  nil nil
                                  "{{{results(=" "=)}}}"))
                        ;; Escape contents from "src" wrap.  Mark
                        ;; inline results as inline source code.
-                       ((eq t (compare-strings type nil nil "src" nil nil t))
+                       ((string-equal-ignore-case type "src")
                         (let ((inline-open
                                (pcase split
                                  (`(,_)
diff --git a/lisp/org/org-compat.el b/lisp/org/org-compat.el
index a65bf6f677a..085e32d6774 100644
--- a/lisp/org/org-compat.el
+++ b/lisp/org/org-compat.el
@@ -934,6 +934,14 @@ Implements `define-error' for older emacsen."
     (put name 'error-conditions
          (copy-sequence (cons name (get 'error 'error-conditions))))))
 
+(unless (fboundp 'string-equal-ignore-case)
+  ;; From Emacs subr.el.
+  (defun string-equal-ignore-case (string1 string2)
+    "Like `string-equal', but case-insensitive.
+Upper-case and lower-case letters are treated as equal.
+Unibyte strings are converted to multibyte for comparison."
+    (eq t (compare-strings string1 0 nil string2 0 nil t))))
+
 (unless (fboundp 'string-suffix-p)
   ;; From Emacs subr.el.
   (defun string-suffix-p (suffix string  &optional ignore-case)
@@ -1125,10 +1133,8 @@ ELEMENT is the element at point."
           (and log
                (let ((drawer (org-element-lineage element '(drawer))))
                  (and drawer
-                      (eq (compare-strings
-                           log nil nil
-                           (org-element-property :drawer-name drawer) nil nil t)
-                          t)))))
+                      (string-equal-ignore-case
+                       log (org-element-property :drawer-name drawer))))))
         nil)
        (t
         (cl-case (org-element-type element)
diff --git a/lisp/org/org-lint.el b/lisp/org/org-lint.el
index 83c2d08a907..6d8cf3f2374 100644
--- a/lisp/org/org-lint.el
+++ b/lisp/org/org-lint.el
@@ -334,10 +334,8 @@ called with one argument, the key used for comparison."
    ast
    'node-property
    (lambda (property)
-     (and (eq (compare-strings "CUSTOM_ID" nil nil
-                               (org-element-property :key property) nil nil
-                               t)
-              t)
+     (and (string-equal-ignore-case
+           "CUSTOM_ID" (org-element-property :key property))
           (org-element-property :value property)))
    (lambda (property _) (org-element-property :begin property))
    (lambda (key) (format "Duplicate CUSTOM_ID property \"%s\"" key))))
diff --git a/lisp/org/ox.el b/lisp/org/ox.el
index 55258bc79da..1bdf4dead89 100644
--- a/lisp/org/ox.el
+++ b/lisp/org/ox.el
@@ -80,6 +80,7 @@
 (require 'org-element)
 (require 'org-macro)
 (require 'tabulated-list)
+(require 'subr-x)
 
 (declare-function org-src-coderef-format "org-src" (&optional element))
 (declare-function org-src-coderef-regexp "org-src" (fmt &optional label))
@@ -4436,15 +4437,12 @@ INFO is a plist used as a communication channel.
 
 Return value can be a radio-target object or nil.  Assume LINK
 has type \"radio\"."
-  (let ((path (replace-regexp-in-string
-               "[ \r\t\n]+" " " (org-element-property :path link))))
+  (let ((path (string-clean-whitespace (org-element-property :path link))))
     (org-element-map (plist-get info :parse-tree) 'radio-target
       (lambda (radio)
-        (and (eq (compare-strings
-                  (replace-regexp-in-string
-                   "[ \r\t\n]+" " " (org-element-property :value radio))
-                  nil nil path nil nil t)
-                 t)
+        (and (string-equal-ignore-case
+              (string-clean-whitespace (org-element-property :value radio))
+              path)
              radio))
       info 'first-match)))