2:30 p.m.
4 new commits in cc-mode:
https://bitbucket.org/xemacs/cc-mode/changeset/8dbdc285ad39/
changeset: 8dbdc285ad39
user: acm
date: 2012-03-05 15:14:34
summary: Optimise c-state-safe-place
affected #: 1 file
diff -r 0966dd523d17f3f03847def27b95a0b0e5c25281 -r
8dbdc285ad39c20db54cfa7624b541f218961e0e cc-engine.el
--- a/cc-engine.el
+++ b/cc-engine.el
＠＠ -2130,43 +2130,45 ＠＠
(widen)
(save-excursion
(let ((c c-state-nonlit-pos-cache)
- pos npos lit macro-beg macro-end)
+ pos npos high-pos lit macro-beg macro-end)
;; Trim the cache to take account of buffer changes.
(while (and c (> (car c) c-state-nonlit-pos-cache-limit))
(setq c (cdr c)))
(setq c-state-nonlit-pos-cache c)
(while (and c (> (car c) here))
+ (setq high-pos (car c))
(setq c (cdr c)))
(setq pos (or (car c) (point-min)))
- (while
- ;; Add an element to `c-state-nonlit-pos-cache' each iteration.
- (and
- (<= (setq npos (+ pos c-state-nonlit-pos-interval)) here)
-
- ;; Test for being in a literal.
- (progn
- (setq lit (car (cddr (c-state-pp-to-literal pos npos))))
- (or (null lit)
- (prog1 (<= (cdr lit) here)
- (setq npos (cdr lit)))))
-
- ;; Test for being in a macro.
- (progn
- (goto-char npos)
- (setq macro-beg
- (and (c-beginning-of-macro) (/= (point) npos) (point)))
- (when macro-beg
- (c-syntactic-end-of-macro)
- (or (eobp) (forward-char))
- (setq macro-end (point)))
- (or (null macro-beg)
- (prog1 (<= macro-end here)
- (setq npos macro-end)))))
-
- (setq pos npos)
- (setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache)))
+ (unless high-pos
+ (while
+ ;; Add an element to `c-state-nonlit-pos-cache' each iteration.
+ (and
+ (<= (setq npos (+ pos c-state-nonlit-pos-interval)) here)
+
+ ;; Test for being in a literal. If so, go to after it.
+ (progn
+ (setq lit (car (cddr (c-state-pp-to-literal pos npos))))
+ (or (null lit)
+ (prog1 (<= (cdr lit) here)
+ (setq npos (cdr lit)))))
+
+ ;; Test for being in a macro. If so, go to after it.
+ (progn
+ (goto-char npos)
+ (setq macro-beg
+ (and (c-beginning-of-macro) (/= (point) npos) (point)))
+ (when macro-beg
+ (c-syntactic-end-of-macro)
+ (or (eobp) (forward-char))
+ (setq macro-end (point)))
+ (or (null macro-beg)
+ (prog1 (<= macro-end here)
+ (setq npos macro-end)))))
+
+ (setq pos npos)
+ (setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache))))
(if (> pos c-state-nonlit-pos-cache-limit)
(setq c-state-nonlit-pos-cache-limit pos))
https://bitbucket.org/xemacs/cc-mode/changeset/1301ab06c9fa/
changeset: 1301ab06c9fa
user: acm
date: 2012-03-05 15:15:44
summary: Merge
affected #: 3 files
diff -r 8dbdc285ad39c20db54cfa7624b541f218961e0e -r
1301ab06c9fac5010f17a064b773f64911f48b94 .hgtags
--- a/.hgtags
+++ b/.hgtags
＠＠ -83,3 +83,4 ＠＠
d9e2f6a5fc7f15598c443cc92ff7593d4a4caa18 cc-mode-1_48
965402f1148652d2f746460a4886d3089a160d94 cc-mode-1_49
c98d6d26469325e40ca583a4405d121fa0d44ca8 cc-mode-1_50
+3eb9de826afe87ee4f9f5a718373c616a00d1c40 cc-mode-1_51
diff -r 8dbdc285ad39c20db54cfa7624b541f218961e0e -r
1301ab06c9fac5010f17a064b773f64911f48b94 ChangeLog
--- a/ChangeLog
+++ b/ChangeLog
＠＠ -1,3 +1,7 ＠＠
+2012-02-14 Norbert Koch <viteno(a)xemacs.org>
+
+ * Makefile (VERSION): XEmacs package 1.51 released.
+
2012-02-09 Norbert Koch <viteno(a)xemacs.org>
* Makefile (VERSION): XEmacs package 1.50 released.
diff -r 8dbdc285ad39c20db54cfa7624b541f218961e0e -r
1301ab06c9fac5010f17a064b773f64911f48b94 Makefile
--- a/Makefile
+++ b/Makefile
＠＠ -17,7 +17,7 ＠＠
# the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
-VERSION = 1.50
+VERSION = 1.51
AUTHOR_VERSION = 5.32.2
MAINTAINER = Alan Mackenzie <bug-cc-mode(a)gnu.org>
PACKAGE = cc-mode
https://bitbucket.org/xemacs/cc-mode/changeset/90a496f451d4/
changeset: 90a496f451d4
user: acm
date: 2012-03-05 15:20:21
summary: Optimise macro handling with a 1 element cache of beginning and end.
affected #: 4 files
diff -r 1301ab06c9fac5010f17a064b773f64911f48b94 -r
90a496f451d448a75b99ae38cd79b8ff0fd13ac6 cc-engine.el
--- a/cc-engine.el
+++ b/cc-engine.el
＠＠ -222,6 +222,38 ＠＠
(point))))
c-macro-start))
+;; One element macro cache to cope with continual movement within very large
+;; CPP macros.
+(defvar c-macro-cache nil)
+(make-variable-buffer-local 'c-macro-cache)
+;; Nil or cons of the bounds of the most recent CPP form probed by
+;; `c-beginning-of-macro', `c-end-of-macro' or `c-syntactic-end-of-macro'.
+;; The cdr will be nil if we know only the start of the CPP form.
+(defvar c-macro-cache-start-pos nil)
+(make-variable-buffer-local 'c-macro-cache-start-pos)
+;; The starting position from where we determined `c-macro-cache'.
+(defvar c-macro-cache-syntactic nil)
+(make-variable-buffer-local 'c-macro-cache-syntactic)
+;; non-nil iff `c-macro-cache' has both elements set AND the cdr is at a
+;; syntactic end of macro, not merely an apparent one.
+
+(defun c-invalidate-macro-cache (beg end)
+ ;; Called from a before-change function. If the change region is before or
+ ;; in the macro characterised by `c-macro-cache' etc., nullify it
+ ;; appropriately. BEG and END are the standard before-change-functions
+ ;; parameters. END isn't used.
+ (cond
+ ((null c-macro-cache))
+ ((< beg (car c-macro-cache))
+ (setq c-macro-cache nil
+ c-macro-cache-start-pos nil
+ c-macro-cache-syntactic nil))
+ ((and (cdr c-macro-cache)
+ (< beg (cdr c-macro-cache)))
+ (setcdr c-macro-cache nil)
+ (setq c-macro-cache-start-pos beg
+ c-macro-cache-syntactic nil))))
+
(defun c-beginning-of-macro (&optional lim)
"Go to the beginning of a preprocessor directive.
Leave point at the beginning of the directive and return t if in one,
＠＠ -229,19 +261,36 ＠＠
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info."
- (when c-opt-cpp-prefix
- (let ((here (point)))
- (save-restriction
- (if lim (narrow-to-region lim (point-max)))
- (beginning-of-line)
- (while (eq (char-before (1- (point))) ?\\)
- (forward-line -1))
- (back-to-indentation)
- (if (and (<= (point) here)
- (looking-at c-opt-cpp-start))
- t
- (goto-char here)
- nil)))))
+ (let ((here (point)))
+ (when c-opt-cpp-prefix
+ (if (and (car c-macro-cache)
+ (>= (point) (car c-macro-cache))
+ (or (and (cdr c-macro-cache)
+ (<= (point) (cdr c-macro-cache)))
+ (<= (point) c-macro-cache-start-pos)))
+ (unless (< (car c-macro-cache) (or lim (point-min)))
+ (progn (goto-char (max (or lim (point-min)) (car c-macro-cache)))
+ (setq c-macro-cache-start-pos
+ (max c-macro-cache-start-pos here))
+ t))
+ (setq c-macro-cache nil
+ c-macro-cache-start-pos nil
+ c-macro-cache-syntactic nil)
+
+ (save-restriction
+ (if lim (narrow-to-region lim (point-max)))
+ (beginning-of-line)
+ (while (eq (char-before (1- (point))) ?\\)
+ (forward-line -1))
+ (back-to-indentation)
+ (if (and (<= (point) here)
+ (looking-at c-opt-cpp-start))
+ (progn
+ (setq c-macro-cache (cons (point) nil)
+ c-macro-cache-start-pos here)
+ t)
+ (goto-char here)
+ nil))))))
(defun c-end-of-macro ()
"Go to the end of a preprocessor directive.
＠＠ -251,12 +300,24 ＠＠
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info."
- (while (progn
- (end-of-line)
- (when (and (eq (char-before) ?\\)
- (not (eobp)))
- (forward-char)
- t))))
+ (if (and (cdr c-macro-cache)
+ (<= (point) (cdr c-macro-cache))
+ (>= (point) (car c-macro-cache)))
+ (goto-char (cdr c-macro-cache))
+ (unless (and (car c-macro-cache)
+ (<= (point) c-macro-cache-start-pos)
+ (>= (point) (car c-macro-cache)))
+ (setq c-macro-cache nil
+ c-macro-cache-start-pos nil
+ c-macro-cache-syntactic nil))
+ (while (progn
+ (end-of-line)
+ (when (and (eq (char-before) ?\\)
+ (not (eobp)))
+ (forward-char)
+ t)))
+ (when (car c-macro-cache)
+ (setcdr c-macro-cache (point)))))
(defun c-syntactic-end-of-macro ()
;; Go to the end of a CPP directive, or a "safe" pos just before.
＠＠ -271,12 +332,15 ＠＠
;; at the start of cc-engine.el for more info.
(let* ((here (point))
(there (progn (c-end-of-macro) (point)))
- (s (parse-partial-sexp here there)))
- (while (and (or (nth 3 s) ; in a string
- (nth 4 s)) ; in a comment (maybe at end of line comment)
- (> there here)) ; No infinite loops, please.
- (setq there (1- (nth 8 s)))
- (setq s (parse-partial-sexp here there)))
+ s)
+ (unless c-macro-cache-syntactic
+ (setq s (parse-partial-sexp here there))
+ (while (and (or (nth 3 s) ; in a string
+ (nth 4 s)) ; in a comment (maybe at end of line comment)
+ (> there here)) ; No infinite loops, please.
+ (setq there (1- (nth 8 s)))
+ (setq s (parse-partial-sexp here there)))
+ (setq c-macro-cache-syntactic (car c-macro-cache)))
(point)))
(defun c-forward-over-cpp-define-id ()
diff -r 1301ab06c9fac5010f17a064b773f64911f48b94 -r
90a496f451d448a75b99ae38cd79b8ff0fd13ac6 cc-fonts.el
--- a/cc-fonts.el
+++ b/cc-fonts.el
＠＠ -409,7 +409,8 ＠＠
(cc-eval-when-compile
(boundp 'parse-sexp-lookup-properties)))
(BOD-limit
- (c-determine-limit 1000)))
+ (c-determine-limit 500 ;; 1000
+ )))
(goto-char
(let ((here (point)))
(if (eq (car (c-beginning-of-decl-1 BOD-limit)) 'same)
diff -r 1301ab06c9fac5010f17a064b773f64911f48b94 -r
90a496f451d448a75b99ae38cd79b8ff0fd13ac6 cc-langs.el
--- a/cc-langs.el
+++ b/cc-langs.el
＠＠ -444,8 +444,10 ＠＠
;; For documentation see the following c-lang-defvar of the same name.
;; The value here may be a list of functions or a single function.
t nil
- c++ '(c-extend-region-for-CPP c-before-change-check-<>-operators)
- (c objc) 'c-extend-region-for-CPP
+ c++ '(c-extend-region-for-CPP
+ c-before-change-check-<>-operators
+ c-invalidate-macro-cache)
+ (c objc) '(c-extend-region-for-CPP c-invalidate-macro-cache)
;; java 'c-before-change-check-<>-operators
awk 'c-awk-record-region-clear-NL)
(c-lang-defvar c-get-state-before-change-functions
diff -r 1301ab06c9fac5010f17a064b773f64911f48b94 -r
90a496f451d448a75b99ae38cd79b8ff0fd13ac6 cc-vars.el
--- a/cc-vars.el
+++ b/cc-vars.el
＠＠ -1653,7 +1653,8 ＠＠
c-macro-names-with-semicolon))))))
(defvar c-macro-names-with-semicolon
- '("Q_OBJECT" "Q_PROPERTY" "Q_DECLARE"
"Q_ENUMS")
+; '("Q_OBJECT" "Q_PROPERTY" "Q_DECLARE"
"Q_ENUMS")
+ nil
"List of #defined symbols whose expansion ends with a semicolon.
Alternatively it can be a string, a regular expression which
matches all such symbols.
https://bitbucket.org/xemacs/cc-mode/changeset/72c17e2c12a5/
changeset: 72c17e2c12a5
user: acm
date: 2012-03-05 15:25:59
summary: Depessimize the handling of very large macros.
affected #: 3 files
diff -r 90a496f451d448a75b99ae38cd79b8ff0fd13ac6 -r
72c17e2c12a5cd58f7e46f3d8a8a322d840ac564 cc-engine.el
--- a/cc-engine.el
+++ b/cc-engine.el
＠＠ -2154,6 +2154,18 ＠＠
;; reduced by buffer changes, and increased by invocations of
;; `c-state-literal-at'.
+(defvar c-state-semi-nonlit-pos-cache nil)
+(make-variable-buffer-local 'c-state-semi-nonlit-pos-cache)
+;; A list of buffer positions which are known not to be in a literal. This is
+;; ordered with higher positions at the front of the list. Only those which
+;; are less than `c-state-semi-nonlit-pos-cache-limit' are valid.
+
+(defvar c-state-semi-nonlit-pos-cache-limit 1)
+(make-variable-buffer-local 'c-state-semi-nonlit-pos-cache-limit)
+;; An upper limit on valid entries in `c-state-semi-nonlit-pos-cache'. This is
+;; reduced by buffer changes, and increased by invocations of
+;; `c-state-literal-at'. FIMXE!!!
+
(defsubst c-state-pp-to-literal (from to)
;; Do a parse-partial-sexp from FROM to TO, returning either
;; (STATE TYPE (BEG . END)) if TO is in a literal; or
＠＠ -2232,12 +2244,55 ＠＠
(setq npos macro-end)))))
(setq pos npos)
- (setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache))))
+ (setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache)))
+ ;; Add one extra element above HERE so as to to avoid the previous
+ ;; expensive calculation when the next call is close to the current
+ ;; one. This is especially useful when inside a large macro.
+ (setq c-state-nonlit-pos-cache (cons npos c-state-nonlit-pos-cache)))
(if (> pos c-state-nonlit-pos-cache-limit)
(setq c-state-nonlit-pos-cache-limit pos))
pos))))
+(defun c-state-semi-safe-place (here)
+ ;; Return a buffer position before HERE which is "safe", i.e. outside any
+ ;; string or comment. It may be in a macro.
+ (save-restriction
+ (widen)
+ (save-excursion
+ (let ((c c-state-semi-nonlit-pos-cache)
+ pos npos high-pos lit macro-beg macro-end)
+ ;; Trim the cache to take account of buffer changes.
+ (while (and c (> (car c) c-state-semi-nonlit-pos-cache-limit))
+ (setq c (cdr c)))
+ (setq c-state-semi-nonlit-pos-cache c)
+
+ (while (and c (> (car c) here))
+ (setq high-pos (car c))
+ (setq c (cdr c)))
+ (setq pos (or (car c) (point-min)))
+
+ (unless high-pos
+ (while
+ ;; Add an element to `c-state-semi-nonlit-pos-cache' each iteration.
+ (and
+ (<= (setq npos (+ pos c-state-nonlit-pos-interval)) here)
+
+ ;; Test for being in a literal. If so, go to after it.
+ (progn
+ (setq lit (car (cddr (c-state-pp-to-literal pos npos))))
+ (or (null lit)
+ (prog1 (<= (cdr lit) here)
+ (setq npos (cdr lit))))))
+
+ (setq pos npos)
+ (setq c-state-semi-nonlit-pos-cache
+ (cons pos c-state-semi-nonlit-pos-cache))))
+
+ (if (> pos c-state-semi-nonlit-pos-cache-limit)
+ (setq c-state-semi-nonlit-pos-cache-limit pos))
+ pos))))
+
(defun c-state-literal-at (here)
;; If position HERE is inside a literal, return (START . END), the
;; boundaries of the literal (which may be outside the accessible bit of the
＠＠ -3056,9 +3111,11 ＠＠
;;
;; This function is called from c-after-change.
- ;; The cache of non-literals:
+ ;; The caches of non-literals:
(if (< here c-state-nonlit-pos-cache-limit)
(setq c-state-nonlit-pos-cache-limit here))
+ (if (< here c-state-semi-nonlit-pos-cache-limit)
+ (setq c-state-semi-nonlit-pos-cache-limit here))
;; `c-state-cache':
;; Case 1: if `here' is in a literal containing point-min, everything
＠＠ -4310,7 +4367,7 ＠＠
comment at the start of cc-engine.el for more info."
(save-restriction
(widen)
- (let* ((safe-place (c-state-safe-place (point)))
+ (let* ((safe-place (c-state-semi-safe-place (point)))
(lit (c-state-pp-to-literal safe-place (point))))
(or (cadr lit)
(and detect-cpp
＠＠ -4334,7 +4391,7 ＠＠
(save-excursion
(let* ((pos (point))
- (lim (or lim (c-state-safe-place pos)))
+ (lim (or lim (c-state-semi-safe-place pos)))
(pp-to-lit (save-restriction
(widen)
(c-state-pp-to-literal lim pos)))
＠＠ -4452,7 +4509,7 ＠＠
;; Get a "safe place" approximately TRY-SIZE characters before START.
;; This doesn't preserve point.
(let* ((pos (max (- start try-size) (point-min)))
- (base (c-state-safe-place pos))
+ (base (c-state-semi-safe-place pos))
(s (parse-partial-sexp base pos)))
(if (or (nth 4 s) (nth 3 s)) ; comment or string
(nth 8 s)
diff -r 90a496f451d448a75b99ae38cd79b8ff0fd13ac6 -r
72c17e2c12a5cd58f7e46f3d8a8a322d840ac564 cc-fonts.el
--- a/cc-fonts.el
+++ b/cc-fonts.el
＠＠ -409,8 +409,7 ＠＠
(cc-eval-when-compile
(boundp 'parse-sexp-lookup-properties)))
(BOD-limit
- (c-determine-limit 500 ;; 1000
- )))
+ (c-determine-limit 1000)))
(goto-char
(let ((here (point)))
(if (eq (car (c-beginning-of-decl-1 BOD-limit)) 'same)
diff -r 90a496f451d448a75b99ae38cd79b8ff0fd13ac6 -r
72c17e2c12a5cd58f7e46f3d8a8a322d840ac564 cc-vars.el
--- a/cc-vars.el
+++ b/cc-vars.el
＠＠ -1653,8 +1653,7 ＠＠
c-macro-names-with-semicolon))))))
(defvar c-macro-names-with-semicolon
-; '("Q_OBJECT" "Q_PROPERTY" "Q_DECLARE"
"Q_ENUMS")
- nil
+ '("Q_OBJECT" "Q_PROPERTY" "Q_DECLARE"
"Q_ENUMS")
"List of #defined symbols whose expansion ends with a semicolon.
Alternatively it can be a string, a regular expression which
matches all such symbols.
Repository URL: https://bitbucket.org/xemacs/cc-mode/
--
This is a commit notification from bitbucket.org. You are receiving
this because you have the service enabled, addressing the recipient of
this email.
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://lists.xemacs.org/mailman/listinfo/xemacs-patches