bug-gnu-emacs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

bug#22541: 25.0.50; highlight-regexp from isearch has is case-sensitive


From: Tino Calancha
Subject: bug#22541: 25.0.50; highlight-regexp from isearch has is case-sensitive even if case-fold is active
Date: Thu, 27 Apr 2017 23:22:05 +0900
User-agent: Gnus/5.13 (Gnus v5.13) Emacs/26.0.50 (gnu/linux)

Juri Linkov <address@hidden> writes:

Thanks for the feedback!

>> -(defun hi-lock-set-pattern (regexp face)
>> -  "Highlight REGEXP with face FACE."
>> +(defun hi-lock-set-pattern (regexp face &optional case-fold)
>> +  "Highlight REGEXP with face FACE.
>> +If optional arg CASE-FOLD is non-nil, then bind `case-fold-search' to it."
>>    ;; Hashcons the regexp, so it can be passed to remove-overlays later.
>>    (setq regexp (hi-lock--hashcons regexp))
>> -  (let ((pattern (list regexp (list 0 (list 'quote face) 'prepend))))
>> +  (let ((pattern (list (if (eq case-fold 'undefined)
>> +                           regexp
>> +                         (cons regexp
>> +                               (byte-compile
>> +                          `(lambda (limit)
>> +                             (let ((case-fold-search ,case-fold))
>> +                               (re-search-forward ,regexp limit t))))))
>> +                       (list 0 (list 'quote face) 'prepend))))
>
> Do you need to remember also the value of ‘case-fold-search’
> (together with ‘regexp’)?
AFAICT i don't need it.

>> @@ -1950,7 +1950,12 @@ isearch-highlight-regexp
>>                            (regexp-quote s))))
>>                      isearch-string ""))
>>                    (t (regexp-quote isearch-string)))))
>> -    (hi-lock-face-buffer regexp (hi-lock-read-face-name)))
>> +    (hi-lock-face-buffer regexp (hi-lock-read-face-name)
>> +                         (if (and (eq isearch-case-fold-search t)
>> +                                  search-upper-case)
>> +                             (isearch-no-upper-case-p
>> +                              isearch-string isearch-regexp)
>> +                           isearch-case-fold-search)))
>>    (and isearch-recursive-edit (exit-recursive-edit)))
>
> If this works reliably, then we could remove that ugly hack
> from ‘isearch-highlight-regexp’, I mean the one with the comment
> “Turn isearch-string into a case-insensitive regexp”.
That's right.  We don't need such trick here anymore.  But this hack
turned ut to be useful in hi-lock.el.

The new patch, in addition to fix this bug report, it also
helps with the 5. in bug#22520, that is:
emacs -Q
M-s hr t RET RET ; Highlight with regexp "[Tt]"
M-s hu t RET ; Unhighlight the buffer.

--8<-----------------------------cut here---------------start------------->8---
>From 5183897b88b93060ce391f166cdeebf605785362 Mon Sep 17 00:00:00 2001
From: Tino Calancha <address@hidden>
Date: Thu, 27 Apr 2017 23:02:41 +0900
Subject: [PATCH] highlight-regexp: Honor case-fold-search

* lisp/hi-lock.el (hi-lock-face-buffer, hi-lock-set-pattern):
Add optional arg CASE-FOLD.  All callers updated.
* lisp/isearch.el (isearch-highlight-regexp): Call hi-lock-face-buffer
with 3 arguments.
---
 lisp/hi-lock.el | 30 +++++++++++++++++++-----------
 lisp/isearch.el |  7 ++++++-
 2 files changed, 25 insertions(+), 12 deletions(-)

diff --git a/lisp/hi-lock.el b/lisp/hi-lock.el
index 5139e01fa8..55ad3ccb58 100644
--- a/lisp/hi-lock.el
+++ b/lisp/hi-lock.el
@@ -432,7 +432,7 @@ hi-lock-line-face-buffer
 ;;;###autoload
 (defalias 'highlight-regexp 'hi-lock-face-buffer)
 ;;;###autoload
-(defun hi-lock-face-buffer (regexp &optional face)
+(defun hi-lock-face-buffer (regexp &optional face case-fold)
   "Set face of each match of REGEXP to FACE.
 Interactively, prompt for REGEXP using `read-regexp', then FACE.
 Use the global history list for FACE.
@@ -444,10 +444,11 @@ hi-lock-face-buffer
    (list
     (hi-lock-regexp-okay
      (read-regexp "Regexp to highlight" 'regexp-history-last))
-    (hi-lock-read-face-name)))
+    (hi-lock-read-face-name)
+    case-fold-search))
   (or (facep face) (setq face 'hi-yellow))
   (unless hi-lock-mode (hi-lock-mode 1))
-  (hi-lock-set-pattern regexp face))
+  (hi-lock-set-pattern regexp face case-fold))
 
 ;;;###autoload
 (defalias 'highlight-phrase 'hi-lock-face-phrase-buffer)
@@ -689,11 +690,17 @@ hi-lock-read-face-name
       (add-to-list 'hi-lock-face-defaults face t))
     (intern face)))
 
-(defun hi-lock-set-pattern (regexp face)
+(defun hi-lock-set-pattern (regexp face &optional case-fold)
   "Highlight REGEXP with face FACE."
   ;; Hashcons the regexp, so it can be passed to remove-overlays later.
   (setq regexp (hi-lock--hashcons regexp))
-  (let ((pattern (list regexp (list 0 (list 'quote face) 'prepend))))
+  (let ((pattern (list (if (eq case-fold 'undefined)
+                           regexp
+                         (byte-compile
+                          `(lambda (limit)
+                             (let ((case-fold-search ,case-fold))
+                               (re-search-forward ,regexp limit t)))))
+                       (list 0 (list 'quote face) 'prepend))))
     ;; Refuse to highlight a text that is already highlighted.
     (if (assoc regexp hi-lock-interactive-patterns)
         (add-to-list 'hi-lock--unused-faces (face-name face))
@@ -712,12 +719,13 @@ hi-lock-set-pattern
                      (+ range-max (max 0 (- (point-min) range-min))))))
           (save-excursion
             (goto-char search-start)
-            (while (re-search-forward regexp search-end t)
-              (let ((overlay (make-overlay (match-beginning 0) (match-end 0))))
-                (overlay-put overlay 'hi-lock-overlay t)
-                (overlay-put overlay 'hi-lock-overlay-regexp regexp)
-                (overlay-put overlay 'face face))
-              (goto-char (match-end 0)))))))))
+            (let ((case-fold-search case-fold))
+              (while (re-search-forward regexp search-end t)
+                (let ((overlay (make-overlay (match-beginning 0) (match-end 
0))))
+                  (overlay-put overlay 'hi-lock-overlay t)
+                  (overlay-put overlay 'hi-lock-overlay-regexp regexp)
+                  (overlay-put overlay 'face face))
+                (goto-char (match-end 0))))))))))
 
 (defun hi-lock-set-file-patterns (patterns)
   "Replace file patterns list with PATTERNS and refontify."
diff --git a/lisp/isearch.el b/lisp/isearch.el
index c34739d638..250d37b45e 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -1950,7 +1950,12 @@ isearch-highlight-regexp
                              (regexp-quote s))))
                        isearch-string ""))
                      (t (regexp-quote isearch-string)))))
-    (hi-lock-face-buffer regexp (hi-lock-read-face-name)))
+    (hi-lock-face-buffer regexp (hi-lock-read-face-name)
+                         (if (and (eq isearch-case-fold-search t)
+                                  search-upper-case)
+                             (isearch-no-upper-case-p
+                              isearch-string isearch-regexp)
+                           isearch-case-fold-search)))
   (and isearch-recursive-edit (exit-recursive-edit)))
 

-- 
2.11.0

>From 32ec762b9459cf2a1b50217fa061c70541c0a241 Mon Sep 17 00:00:00 2001
From: Tino Calancha <address@hidden>
Date: Thu, 27 Apr 2017 23:05:01 +0900
Subject: [PATCH] Fix hi-lock-unface-buffer from last commit

Perform the matches of REGEXP as `isearch-forward' i.e., in interactive
calls determine the case fold with `search-upper-case' and
`case-fold-search' (Bug#22541).
* lisp/hi-lock.el (hi-lock-face-buffer): Update docstring.
Determine the case fold with `search-upper-case' and
`case-fold-search'.
(hi-lock--regexps-at-point, hi-lock-unface-buffer):
Handle when pattern is a cons (REGEXP . FUNCTION).
(hi-lock-read-face-name): Update docstring.
(hi-lock--case-insensitive-regexp,
hi-lock--case-insensitive-regexp-p): New defuns.
(hi-lock-set-pattern, hi-lock-unface-buffer): Use them.
* lisp/isearch.el (isearch-highlight-regexp): Delete hack for
case-insensitive search; this is now handled in
hi-lock-face-buffer.
* test/lisp/hi-lock-tests.el (hi-lock-face-buffer-test, hi-lock-bug22520):
Add tests.
---
 lisp/hi-lock.el            | 153 +++++++++++++++++++++++++++++++++------------
 lisp/isearch.el            |  10 +--
 test/lisp/hi-lock-tests.el |  91 ++++++++++++++++++++++++++-
 3 files changed, 204 insertions(+), 50 deletions(-)

diff --git a/lisp/hi-lock.el b/lisp/hi-lock.el
index 55ad3ccb58..5862974844 100644
--- a/lisp/hi-lock.el
+++ b/lisp/hi-lock.el
@@ -434,6 +434,7 @@ 'highlight-regexp
 ;;;###autoload
 (defun hi-lock-face-buffer (regexp &optional face case-fold)
   "Set face of each match of REGEXP to FACE.
+If optional arg CASE-FOLD is non-nil, then bind `case-fold-search' to it.
 Interactively, prompt for REGEXP using `read-regexp', then FACE.
 Use the global history list for FACE.
 
@@ -441,11 +442,15 @@ hi-lock-face-buffer
 use overlays for highlighting.  If overlays are used, the
 highlighting will not update as you type."
   (interactive
-   (list
-    (hi-lock-regexp-okay
-     (read-regexp "Regexp to highlight" 'regexp-history-last))
-    (hi-lock-read-face-name)
-    case-fold-search))
+   (let* ((regexp
+           (hi-lock-regexp-okay
+            (read-regexp "Regexp to highlight" 'regexp-history-last)))
+          (face (hi-lock-read-face-name))
+          (case-fold
+           (if search-upper-case
+               (isearch-no-upper-case-p regexp t)
+             case-fold-search)))
+     (list regexp face case-fold)))
   (or (facep face) (setq face 'hi-yellow))
   (unless hi-lock-mode (hi-lock-mode 1))
   (hi-lock-set-pattern regexp face case-fold))
@@ -531,10 +536,17 @@ hi-lock--regexps-at-point
           ;; highlighted text at point.  Use this later in
           ;; during completing-read.
           (dolist (hi-lock-pattern hi-lock-interactive-patterns)
-            (let ((regexp (car hi-lock-pattern)))
-              (if (string-match regexp hi-text)
-                  (push regexp regexps)))))))
-    regexps))
+            (let ((regexp-or-fn (car hi-lock-pattern)))
+              (cond ((stringp regexp-or-fn)
+                     (when (string-match regexp-or-fn hi-text)
+                       (push regexp-or-fn regexps)))
+                    (t
+                     (with-temp-buffer
+                       (insert hi-text)
+                       (goto-char 1)
+                       (when (funcall regexp-or-fn nil)
+                         (push regexp-or-fn regexps)))))))
+    ))) regexps))
 
 (defvar-local hi-lock--unused-faces nil
   "List of faces that is not used and is available for highlighting new text.
@@ -562,13 +574,15 @@ hi-lock-unface-buffer
          (cons
           `keymap
           (cons "Select Pattern to Unhighlight"
-                (mapcar (lambda (pattern)
-                          (list (car pattern)
-                                (format
-                                 "%s (%s)" (car pattern)
-                                 (hi-lock-keyword->face pattern))
-                                (cons nil nil)
-                                (car pattern)))
+                 (mapcar (lambda (pattern)
+                           (let ((regexp (or (car-safe (car pattern))
+                                             (car pattern))))
+                             (list regexp
+                                   (format
+                                    "%s (%s)" regexp
+                                    (hi-lock-keyword->face pattern))
+                                   (cons nil nil)
+                                   regexp)))
                         hi-lock-interactive-patterns))))
         ;; If the user clicks outside the menu, meaning that they
         ;; change their mind, x-popup-menu returns nil, and
@@ -582,16 +596,30 @@ hi-lock-unface-buffer
        (error "No highlighting to remove"))
      ;; Infer the regexp to un-highlight based on cursor position.
      (let* ((defaults (or (hi-lock--regexps-at-point)
-                          (mapcar #'car hi-lock-interactive-patterns))))
-       (list
-        (completing-read (if (null defaults)
-                             "Regexp to unhighlight: "
-                           (format "Regexp to unhighlight (default %s): "
-                                   (car defaults)))
-                         hi-lock-interactive-patterns
-                        nil t nil nil defaults))))))
-  (dolist (keyword (if (eq regexp t) hi-lock-interactive-patterns
-                     (list (assoc regexp hi-lock-interactive-patterns))))
+                          (mapcar (lambda (x)
+                                    (or (car-safe (car x))
+                                        (car x)))
+                                    hi-lock-interactive-patterns)))
+            (regexp (completing-read (if (null defaults)
+                                         "Regexp to unhighlight: "
+                                       (format "Regexp to unhighlight (default 
%s): "
+                                               (car defaults)))
+                                     hi-lock-interactive-patterns
+                                    nil nil nil nil defaults)))
+               (when (and (or (not search-upper-case)
+                              (isearch-no-upper-case-p regexp t))
+                          case-fold-search
+                          (not (hi-lock--case-insensitive-regexp-p regexp)))
+         (setq regexp (hi-lock--case-insensitive-regexp regexp)))
+       (list regexp)))))
+  (let* ((patterns hi-lock-interactive-patterns)
+         (keys (or (assoc regexp patterns)
+                   (assoc
+                    (assoc regexp (mapcar #'car patterns))
+                    patterns))))
+    (dolist (keyword (if (eq regexp t)
+                         patterns
+                       (list keys)))
     (when keyword
       (let ((face (hi-lock-keyword->face keyword)))
         ;; Make `face' the next one to use by default.
@@ -606,8 +634,10 @@ hi-lock-unface-buffer
       (setq hi-lock-interactive-patterns
             (delq keyword hi-lock-interactive-patterns))
       (remove-overlays
-       nil nil 'hi-lock-overlay-regexp (hi-lock--hashcons (car keyword)))
-      (font-lock-flush))))
+       nil nil 'hi-lock-overlay-regexp (hi-lock--hashcons
+                                        (or (car-safe (car keyword))
+                                            (car keyword))))
+      (font-lock-flush)))))
 
 ;;;###autoload
 (defun hi-lock-write-interactive-patterns ()
@@ -690,23 +720,67 @@ hi-lock-read-face-name
       (add-to-list 'hi-lock-face-defaults face t))
     (intern face)))
 
+(defun hi-lock--case-insensitive-regexp-p (regexp)
+  (let (case-fold-search)
+    (and (string-match-p regexp (downcase regexp))
+         (string-match-p regexp (upcase regexp)))))
+
+(defun hi-lock--case-insensitive-regexp (regexp)
+  "Turn regexp into a case-insensitive regexp."
+  (let ((count 0)
+        (upper-re "[[:upper:]]")
+        (slash-upper-re "\\(\\\\\\)\\([[:upper:]]\\)")
+        case-fold-search)
+    (cond ((or (hi-lock--case-insensitive-regexp-p regexp)
+               (and (string-match upper-re regexp)
+                    (not (string-match slash-upper-re regexp))))
+           regexp)
+          (t
+           (let ((string regexp))
+             (while (string-match slash-upper-re string)
+               (setq string (replace-match "" t t string 1)))
+             (setq regexp string)
+             (mapconcat
+              (lambda (c)
+                (let ((s (string c)))
+                  (cond ((or (eq c ?\\)
+                             (and (= count 1) (string= s (upcase s))))
+                         (setq count (1+ count)) s)
+                        (t
+                         (setq count 0)
+                         (if (string-match "[[:alpha:]]" s)
+                            (format "[%s%s]" (upcase s) (downcase s))
+                          (regexp-quote s))))))
+              regexp ""))))))
+
 (defun hi-lock-set-pattern (regexp face &optional case-fold)
-  "Highlight REGEXP with face FACE."
+  "Highlight REGEXP with face FACE.
+If optional arg CASE-FOLD is non-nil, then bind `case-fold-search' to it."
   ;; Hashcons the regexp, so it can be passed to remove-overlays later.
   (setq regexp (hi-lock--hashcons regexp))
-  (let ((pattern (list (if (eq case-fold 'undefined)
+  (let* ((pattern (list (if (eq case-fold 'undefined)
                            regexp
-                         (byte-compile
-                          `(lambda (limit)
-                             (let ((case-fold-search ,case-fold))
-                               (re-search-forward ,regexp limit t)))))
-                       (list 0 (list 'quote face) 'prepend))))
+                         (cons regexp
+                               (byte-compile
+                                `(lambda (limit)
+                                   (let ((case-fold-search ,case-fold))
+                                     (re-search-forward ,regexp limit t))))))
+                       (list 0 (list 'quote face) 'prepend)))
+         (regexp-fold
+          (cond ((not (consp (car pattern)))
+                 (car pattern))
+                (t
+                 (if (not case-fold)
+                     (caar pattern)
+                  (hi-lock--case-insensitive-regexp (caar pattern)))))))
     ;; Refuse to highlight a text that is already highlighted.
-    (if (assoc regexp hi-lock-interactive-patterns)
+    (if (or (assoc regexp hi-lock-interactive-patterns)
+            (assoc regexp-fold hi-lock-interactive-patterns)
+            (assoc regexp-fold (mapcar #'car hi-lock-interactive-patterns)))
         (add-to-list 'hi-lock--unused-faces (face-name face))
-      (push pattern hi-lock-interactive-patterns)
       (if (and font-lock-mode (font-lock-specified-p major-mode))
-         (progn
+          (progn
+            (setq pattern (list regexp-fold (list 0 (list 'quote face) 
'prepend)))
            (font-lock-add-keywords nil (list pattern) t)
            (font-lock-flush))
         (let* ((range-min (- (point) (/ hi-lock-highlight-range 2)))
@@ -725,7 +799,8 @@ hi-lock-set-pattern
                   (overlay-put overlay 'hi-lock-overlay t)
                   (overlay-put overlay 'hi-lock-overlay-regexp regexp)
                   (overlay-put overlay 'face face))
-                (goto-char (match-end 0))))))))))
+                (goto-char (match-end 0)))))))
+      (push pattern hi-lock-interactive-patterns))))
 
 (defun hi-lock-set-file-patterns (patterns)
   "Replace file patterns list with PATTERNS and refontify."
diff --git a/lisp/isearch.el b/lisp/isearch.el
index 250d37b45e..2496e092a6 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -1940,15 +1940,7 @@ isearch-highlight-regexp
                           (isearch-no-upper-case-p
                            isearch-string isearch-regexp)
                         isearch-case-fold-search)
-                      ;; Turn isearch-string into a case-insensitive
-                      ;; regexp.
-                      (mapconcat
-                       (lambda (c)
-                         (let ((s (string c)))
-                           (if (string-match "[[:alpha:]]" s)
-                               (format "[%s%s]" (upcase s) (downcase s))
-                             (regexp-quote s))))
-                       isearch-string ""))
+                       isearch-string)
                      (t (regexp-quote isearch-string)))))
     (hi-lock-face-buffer regexp (hi-lock-read-face-name)
                          (if (and (eq isearch-case-fold-search t)
diff --git a/test/lisp/hi-lock-tests.el b/test/lisp/hi-lock-tests.el
index 2cb662cfac..1d97e1f054 100644
--- a/test/lisp/hi-lock-tests.el
+++ b/test/lisp/hi-lock-tests.el
@@ -22,6 +22,7 @@
 
 (require 'ert)
 (require 'hi-lock)
+(eval-when-compile (require 'cl-lib))
 
 (ert-deftest hi-lock-bug26666 ()
   "Test for http://debbugs.gnu.org/26666 ."
@@ -29,12 +30,98 @@
     (with-temp-buffer
       (insert "a A b B\n")
       (cl-letf (((symbol-function 'completing-read)
-                   (lambda (prompt coll x y z hist defaults)
-                     (car defaults))))
+                 (lambda (prompt coll x y z hist defaults)
+                   (car defaults))))
         (dotimes (_ 2)
           (let ((face (hi-lock-read-face-name)))
             (hi-lock-set-pattern "a" face))))
       (should (equal hi-lock--unused-faces (cdr faces))))))
 
+(defun hi-lock--count (face)
+  (let ((count 0))
+    (save-excursion
+      (goto-char (point-min))
+      (cond ((and font-lock-mode (font-lock-specified-p major-mode))
+             (when (and (consp (get-text-property (point) 'face))
+                        (memq 'hi-yellow (get-text-property (point) 'face)))
+               (cl-incf count))
+             (while (next-property-change (point))
+               (goto-char (next-property-change (point)))
+               (when (and (consp (get-text-property (point) 'face))
+                          (memq 'hi-yellow (get-text-property (point) 'face)))
+                 (cl-incf count))))
+            (t
+             (dolist (ov (car (overlay-lists)))
+               (let ((props (memq 'face (overlay-properties ov))))
+                 (when (eq (cadr props) face)
+                   (cl-incf count)))))))
+    count))
+
+(defun hi-lock--highlight-and-count (regexp face case-fold)
+  "Highlight REGEXP with FACE with case fold CASE-FOLD.
+Return number of matches."
+  (hi-lock-unface-buffer t)
+  (should (eq 0 (hi-lock--count face)))
+  (hi-lock-face-buffer regexp face case-fold)
+  (hi-lock--count face))
+
+(defun hi-lock--interactive-test-1 (regexp face res ucase cfold)
+  (hi-lock-unface-buffer t)
+  (should (eq 0 (hi-lock--count face)))
+  (cl-letf (((symbol-function 'read-regexp)
+             (lambda (x y) (ignore x y) regexp))
+            ((symbol-function 'hi-lock-read-face-name)
+             (lambda () face)))
+    (setq search-upper-case ucase
+          case-fold-search cfold)
+    (call-interactively 'hi-lock-face-buffer)
+    (should (= res (hi-lock--count face)))))
+
+;; Interactive test should not depend on the major mode.
+(defun hi-lock--interactive-test (regexp face res ucase cfold)
+  (lisp-interaction-mode)
+  (hi-lock--interactive-test-1 regexp face res ucase cfold)
+  (fundamental-mode)
+  (hi-lock--interactive-test-1 regexp face res ucase cfold))
+
+;; In batch calls to `hi-lock-face-buffer', case is given by
+;; its third argument.  In interactive calls, case depends
+;; on `search-upper-case' and `case-fold-search'.
+(ert-deftest hi-lock-face-buffer-test ()
+  "Test for http://debbugs.gnu.org/22541 ."
+  (let ((face 'hi-yellow)
+        (regexp "a")
+        case-fold-search search-upper-case)
+    (with-temp-buffer
+      (insert "a A\n")
+      (should (= 1 (hi-lock--highlight-and-count regexp face nil)))
+      (should (= 2 (hi-lock--highlight-and-count regexp face t)))
+      ;; Case depends on the regexp.
+      (hi-lock--interactive-test regexp face 2 t nil)
+      (hi-lock--interactive-test "A" face 1 t nil)
+      (hi-lock--interactive-test "\\A" face 2 t nil)
+      ;; Case depends on `case-fold-search'.
+      (hi-lock--interactive-test "a" face 1 nil nil)
+      (hi-lock--interactive-test "A" face 1 nil nil)
+      (hi-lock--interactive-test "\\A" face 1 nil nil)
+      ;;
+      (hi-lock--interactive-test "a" face 2 nil t)
+      (hi-lock--interactive-test "A" face 2 nil t)
+      (hi-lock--interactive-test "\\A" face 2 nil t))))
+
+(ert-deftest hi-lock-bug22520 ()
+  "Test for http://debbugs.gnu.org/22520 ."
+  (with-temp-buffer
+    (erase-buffer)
+    (insert "foo and Foo")
+    (dolist (ucase '(nil t))
+      (dolist (cfold '(nil t))
+        (let ((res (cond ((null ucase)
+                          (if cfold 2 1))
+                         (t 2))))
+        (hi-lock--interactive-test "f" 'hi-yellow res ucase cfold)
+        (hi-lock-unface-buffer "f")
+        (should (= 0 (hi-lock--count 'hi-yellow))))))))
+
 (provide 'hi-lock-tests)
 ;;; hi-lock-tests.el ends here
-- 
2.11.0

--8<-----------------------------cut here---------------end--------------->8---
In GNU Emacs 26.0.50 (build 1, x86_64-pc-linux-gnu, GTK+ Version 3.22.11)
 of 2017-04-27
Repository revision: 79c5ea9911a9aba7db0ba0e367e06507cee2fc02





reply via email to

[Prev in Thread] Current Thread [Next in Thread]