summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorNicolas Goaziou <mail@nicolasgoaziou.fr>2014-06-17 21:07:16 (GMT)
committer Nicolas Goaziou <mail@nicolasgoaziou.fr>2014-06-19 20:32:22 (GMT)
commit87dbce239d067244c9586b9cdda08bbb57814acf (patch)
treedf052d1902da1653a14acd4e78a4967a197e6a10
parent2084ff06d8b10f4c26be0b3316a949585a87e439 (diff)
downloadorg-mode-87dbce239d067244c9586b9cdda08bbb57814acf.zip
org-mode-87dbce239d067244c9586b9cdda08bbb57814acf.tar.gz
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.
-rw-r--r--lisp/org-element.el48
1 files changed, 25 insertions, 23 deletions
diff --git a/lisp/org-element.el b/lisp/org-element.el
index 61e8965..f2db178 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.