From 87dbce239d067244c9586b9cdda08bbb57814acf Mon Sep 17 00:00:00 2001 From: Nicolas Goaziou Date: Tue, 17 Jun 2014 23:07:16 +0200 Subject: [PATCH] org-element: Extend format for cache sync requests * lisp/org-element.el (org-element--cache-sync-requests): Also store beginning position for buffer modifications. (org-element--cache-sync, org-element--cache-process-request) (org-element--cache-submit-request): Adapt to new request template. This change is required for a future cache optimization. --- lisp/org-element.el | 48 +++++++++++++++++++++++++----------------------- 1 file changed, 25 insertions(+), 23 deletions(-) diff --git a/lisp/org-element.el b/lisp/org-element.el index 61e8965aa..f2db17868 100644 --- a/lisp/org-element.el +++ b/lisp/org-element.el @@ -4694,19 +4694,19 @@ This cache is used in `org-element-context'.") A request is a vector with the following pattern: - \[NEXT END OFFSET PARENT PHASE] + \[NEXT BEG END OFFSET PARENT PHASE] -Processing a synchronization request consists in three phases: +Processing a synchronization request consists of three phases: 0. Delete modified elements, 1. Fill missing area in cache, 2. Shift positions and re-parent elements after the changes. During phase 0, NEXT is the key of the first element to be -removed and END is buffer position delimiting the modifications. -Every element starting between these are removed. PARENT is an -element to be removed. Every element contained in it will also -be removed. +removed, BEG and END is buffer position delimiting the +modifications. Every element starting between these are removed. +PARENT is an element to be removed. Every element contained in +it will also be removed. During phase 1, NEXT is the key of the next known element in cache. Parse buffer between that element and the one before it @@ -5053,9 +5053,9 @@ state." ;; Request processed. Merge current and next offsets and ;; transfer phase number and ending position. (when next - (incf (aref next 2) (aref request 2)) - (aset next 1 (aref request 1)) - (aset next 4 (aref request 4))) + (incf (aref next 3) (aref request 3)) + (aset next 2 (aref request 2)) + (aset next 5 (aref request 5))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) ;; If more requests are awaiting, set idle timer accordingly. @@ -5080,7 +5080,7 @@ after this time or when Emacs exits idle state. Throw `interrupt' if the process stops before completing the request." (catch 'quit - (when (= (aref request 4) 0) + (when (= (aref request 5) 0) ;; Phase 1. ;; ;; Delete all elements starting after BEG, but not after buffer @@ -5094,11 +5094,11 @@ request." ;; a deletion modifies structure of the balanced tree. (catch 'end-phase (let ((beg (aref request 0)) - (end (aref request 1)) - (deleted-parent (aref request 3))) + (end (aref request 2)) + (deleted-parent (aref request 4))) (while t (when (org-element--cache-interrupt-p time-limit) - (aset request 3 deleted-parent) + (aset request 4 deleted-parent) (throw 'interrupt nil)) ;; Find first element in cache with key BEG or after it. ;; We don't use `org-element--cache-find' because it @@ -5134,13 +5134,13 @@ request." next))) (> pos end)) (aset request 0 data-key) - (aset request 1 pos) - (aset request 4 1) + (aset request 2 pos) + (aset request 5 1) (throw 'end-phase nil)) (t (org-element--cache-remove data) (when (= (org-element-property :end data) end) (setq deleted-parent data))))))))))) - (when (= (aref request 4) 1) + (when (= (aref request 5) 1) ;; Phase 2. ;; ;; Phase 1 left a hole in the parse tree. Some elements after @@ -5179,8 +5179,8 @@ request." (let ((limit (+ (aref request 1) (aref request 2)))) (when (and threshold (< threshold limit)) (throw 'interrupt nil)) (let ((parent (org-element--parse-to limit t time-limit))) - (aset request 3 parent) - (aset request 4 2) + (aset request 4 parent) + (aset request 5 2) (throw 'end-phase nil))))) ;; Phase 3. ;; @@ -5194,8 +5194,8 @@ request." ;; pending, exit. Before leaving, the current synchronization ;; request is updated. (let ((start (aref request 0)) - (offset (aref request 2)) - (parent (aref request 3)) + (offset (aref request 3)) + (parent (aref request 4)) (node (org-element--cache-root)) (stack (list nil)) (leftp t) @@ -5215,7 +5215,7 @@ request." ;; Handle interruption request. Update current request. (when (or exit-flag (org-element--cache-interrupt-p time-limit)) (aset request 0 key) - (aset request 3 parent) + (aset request 4 parent) (throw 'interrupt nil)) ;; Shift element. (unless (zerop offset) @@ -5526,7 +5526,7 @@ change, as an integer." ;; Changes happened before the first known element. Shift the ;; rest of the cache. ((and first-element (> (org-element-property :begin first-element) end)) - (push (vector (org-element--cache-key first-element) nil offset nil 2) + (push (vector (org-element--cache-key first-element) nil nil offset nil 2) org-element--cache-sync-requests)) ;; There is at least an element to remove. Find position past ;; every element containing END. @@ -5539,7 +5539,9 @@ change, as an integer." (while (and (setq up (org-element-property :parent up)) (>= (org-element-property :begin up) beg)) (setq end (org-element-property :end up)))))) - (push (vector (org-element--cache-key first-element) end offset nil 0) + (push (vector (org-element--cache-key first-element) + (org-element-property :begin first-element) + end offset nil 0) org-element--cache-sync-requests)) ;; No element to remove. No need to re-parent either. Simply ;; shift additional elements, if any, by OFFSET. -- 2.11.4.GIT