emacs: Rename incremental JSON internal variables

[notmuch] / emacs / notmuch.el

diff --git a/emacs/notmuch.el b/emacs/notmuch.el
index 60e8bf957ca45da525e78b3e485ed8d2ace3fba9..428b0117fadcba0a00b0526a685a3ba09e142292 100644 (file)
--- a/emacs/notmuch.el
+++ b/emacs/notmuch.el
@@ -820,11 +820,15 @@ non-authors is found, assume that all of the authors match."
     (insert (apply #'format string objects))
     (insert "\n")))
 
-(defvar notmuch-search-process-state nil
-  "Parsing state of the search process filter.")
+;; These two variables are internal variables to the parsing
+;; routines. They are always used buffer local but need to be declared
+;; globally to avoid compiler warnings.
 
-(defvar notmuch-search-json-parser nil
-  "Incremental JSON parser for the search process filter.")
+(defvar notmuch-json-state nil
+  "Internal incremental JSON parser object: local to the buffer being parsed.")
+
+(defvar notmuch-json-parser nil
+  "State of the internal JSON parser: local to the buffer being parsed.")
 
 (defun notmuch-search-process-filter (proc string)
   "Process and filter the output of \"notmuch search\""
@@ -838,41 +842,63 @@ non-authors is found, assume that all of the authors match."
        ;; Insert new data
        (save-excursion
          (goto-char (point-max))
-         (insert string)))
-      (with-current-buffer results-buf
-       (while (not done)
-         (condition-case nil
-             (case notmuch-search-process-state
+         (insert string))
+       (notmuch-json-parse-partial-list 'notmuch-search-show-result
+                                        'notmuch-search-show-error
+                                        results-buf)))))
+
+(defun notmuch-json-parse-partial-list (result-function error-function results-buf)
+  "Parse a partial JSON list from current buffer.
+
+This function consumes a JSON list from the current buffer,
+applying RESULT-FUNCTION in buffer RESULT-BUFFER to each complete
+value in the list.  It operates incrementally and should be
+called whenever the buffer has been extended with additional
+data.
+
+If there is a syntax error, this will attempt to resynchronize
+with the input and will apply ERROR-FUNCTION in buffer
+RESULT-BUFFER to any input that was skipped.
+
+It sets up all the needed internal variables: the caller just
+needs to call it with point in the same place that the parser
+left it."
+  (let (done)
+    (unless (local-variable-p 'notmuch-json-parser)
+      (set (make-local-variable 'notmuch-json-parser)
+          (notmuch-json-create-parser (current-buffer)))
+      (set (make-local-variable 'notmuch-json-state) 'begin))
+    (while (not done)
+      (condition-case nil
+         (case notmuch-json-state
                ((begin)
                 ;; Enter the results list
                 (if (eq (notmuch-json-begin-compound
-                         notmuch-search-json-parser) 'retry)
+                         notmuch-json-parser) 'retry)
                     (setq done t)
-                  (setq notmuch-search-process-state 'result)))
+                  (setq notmuch-json-state 'result)))
                ((result)
                 ;; Parse a result
-                (let ((result (notmuch-json-read notmuch-search-json-parser)))
+                (let ((result (notmuch-json-read notmuch-json-parser)))
                   (case result
-                    ((retry) (setq done t))
-                    ((end) (setq notmuch-search-process-state 'end))
-                    (otherwise (notmuch-search-show-result result)))))
+                        ((retry) (setq done t))
+                        ((end) (setq notmuch-json-state 'end))
+                        (otherwise (with-current-buffer results-buf
+                                     (funcall result-function result))))))
                ((end)
                 ;; Any trailing data is unexpected
-                (notmuch-json-eof notmuch-search-json-parser)
+                (notmuch-json-eof notmuch-json-parser)
                 (setq done t)))
-           (json-error
-            ;; Do our best to resynchronize and ensure forward
-            ;; progress
-            (notmuch-search-show-error
-             "%s"
-             (with-current-buffer parse-buf
-               (let ((bad (buffer-substring (line-beginning-position)
-                                            (line-end-position))))
-                 (forward-line)
-                 bad))))))
-       ;; Clear out what we've parsed
-       (with-current-buffer parse-buf
-         (delete-region (point-min) (point)))))))
+       (json-error
+        ;; Do our best to resynchronize and ensure forward
+        ;; progress
+        (let ((bad (buffer-substring (line-beginning-position)
+                                     (line-end-position))))
+          (forward-line)
+          (with-current-buffer results-buf
+            (funcall error-function "%s" bad))))))
+    ;; Clear out what we've parsed
+    (delete-region (point-min) (point))))
 
 (defun notmuch-search-tag-all (&optional tag-changes)
   "Add/remove tags from all messages in current search buffer.
@@ -984,9 +1010,6 @@ Other optional parameters are used as follows:
              ;; This buffer will be killed by the sentinel, which
              ;; should be called no matter how the process dies.
              (parse-buf (generate-new-buffer " *notmuch search parse*")))
-         (set (make-local-variable 'notmuch-search-process-state) 'begin)
-         (set (make-local-variable 'notmuch-search-json-parser)
-              (notmuch-json-create-parser parse-buf))
          (process-put proc 'parse-buf parse-buf)
          (set-process-sentinel proc 'notmuch-search-process-sentinel)
          (set-process-filter proc 'notmuch-search-process-filter)