From: Michael Welsh Duggan <mwd@cert.org>
To: Alan Mackenzie <acm@muc.de>
Cc: "11749@debbugs.gnu.org" <11749@debbugs.gnu.org>,
Kim Storm <storm@cua.dk>
Subject: bug#11749: Acknowledgement (24.1; C-mode indentation gives wrong-type-argument error.)
Date: Fri, 01 Feb 2013 17:18:44 -0500 [thread overview]
Message-ID: <tnt8v778ypn.fsf@waterbuck.yellow.cert.org> (raw)
In-Reply-To: <20130129113737.GA4544@acm.acm> (Alan Mackenzie's message of "Tue, 29 Jan 2013 11:37:37 +0000")
Alan Mackenzie <acm@muc.de> writes:
> Hi, Michael.
I've been running with this for a few days, and have yet to run into a
problem. I'll let you know when/if I do in the future.
> On Wed, Jan 23, 2013 at 10:39:34AM -0500, Michael Welsh Duggan wrote:
>> Alan Mackenzie <acm@muc.de> writes:
>
>> > However, this isn't the end of the story -
>
>> > (i) Start your test case in rwtransfer.c, and M-v until the top of the
>> > file. (This shouldn't display any inconsistency messages)
>> > (ii) M-x goto-char <ret> 20001 <ret>. This should go to EOL 671, just
>> > after a "}".
>> > (iii) Type <space> }. (Two characters)
>> > (iv) C-v, possibly twice.
>
>> > This displays a message something like:
>> > c-parse-state inconsistency at 21070: using cache: ((20458 . 20935)),
>> > from scratch: ((20838 . 20877))
>> > , together with a state dump.
>
>> > This bug isn't a new one, but I've just come across it. I'll be working
>> > on it in the meantime.
>
>> Oh, good. I haven't reported any "type stuff" errors I have been
>> getting because they are harder to reproduce. (Unless it is triggered
>> the first time you've typed in the buffer, it's hard to replicate the
>> exact scenario.) I usually wait until you've fixed the last thing I
>> sent in before attempting to report another, just in case the thing you
>> are fixing is related.
>
> OK, I think I've fixed that above bug. I've also done a moderate amount
> of refactoring to simplify things for the next bug, if any.
>
> I've removed the scanning strategy "start at the 2nd previous column-0
> beginning-of-defun", because it was returning false results, even in C
> Mode. I'd already disabled it for C++ Mode (because hackers frequently
> put things inside namespaces at column 0). One consequence is that
> running with `c-toggle-parse-state-debug' is somewhat slower. Sorry for
> that.
>
> Could you try this new version, please. The patch is based on the
> emacs-24 branch of the savannah bzr repository. This should be identical
> to the trunk.
>
>
>
> === modified file 'lisp/progmodes/cc-engine.el'
> *** lisp/progmodes/cc-engine.el 2013-01-23 18:58:11 +0000
> --- lisp/progmodes/cc-engine.el 2013-01-29 11:03:35 +0000
> ***************
> *** 2477,2496 ****
>
> ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
> ;; Defuns which analyze the buffer, yet don't change `c-state-cache'.
> - (defun c-get-fallback-scan-pos (here)
> - ;; Return a start position for building `c-state-cache' from
> - ;; scratch. This will be at the top level, 2 defuns back.
> - (save-excursion
> - ;; Go back 2 bods, but ignore any bogus positions returned by
> - ;; beginning-of-defun (i.e. open paren in column zero).
> - (goto-char here)
> - (let ((cnt 2))
> - (while (not (or (bobp) (zerop cnt)))
> - (c-beginning-of-defun-1) ; Pure elisp BOD.
> - (if (eq (char-after) ?\{)
> - (setq cnt (1- cnt)))))
> - (point)))
> -
> (defun c-state-balance-parens-backwards (here- here+ top)
> ;; Return the position of the opening paren/brace/bracket before HERE- which
> ;; matches the outermost close p/b/b between HERE+ and TOP. Except when
> --- 2477,2482 ----
> ***************
> *** 2548,2594 ****
> ;; o - ('forward START-POINT) - scan forward from START-POINT,
> ;; which is not less than the highest position in `c-state-cache' below here.
> ;; o - ('backward nil) - scan backwards (from HERE).
> - ;; o - ('BOD START-POINT) - scan forwards from START-POINT, which is at the
> - ;; top level.
> ;; o - ('IN-LIT nil) - point is inside the literal containing point-min.
> (let ((cache-pos (c-get-cache-scan-pos here)) ; highest position below HERE in cache (or 1)
> ! BOD-pos ; position of 2nd BOD before HERE.
> ! strategy ; 'forward, 'backward, 'BOD, or 'IN-LIT.
> ! start-point
> ! how-far) ; putative scanning distance.
> (setq good-pos (or good-pos (c-state-get-min-scan-pos)))
> (cond
> ((< here (c-state-get-min-scan-pos))
> ! (setq strategy 'IN-LIT
> ! start-point nil
> ! cache-pos nil
> ! how-far 0))
> ((<= good-pos here)
> (setq strategy 'forward
> ! start-point (max good-pos cache-pos)
> ! how-far (- here start-point)))
> ((< (- good-pos here) (- here cache-pos)) ; FIXME!!! ; apply some sort of weighting.
> ! (setq strategy 'backward
> ! how-far (- good-pos here)))
> (t
> (setq strategy 'forward
> ! how-far (- here cache-pos)
> ! start-point cache-pos)))
> !
> ! ;; Might we be better off starting from the top level, two defuns back,
> ! ;; instead? This heuristic no longer works well in C++, where
> ! ;; declarations inside namespace brace blocks are frequently placed at
> ! ;; column zero.
> ! (when (and (not (c-major-mode-is 'c++-mode))
> ! (> how-far c-state-cache-too-far))
> ! (setq BOD-pos (c-get-fallback-scan-pos here)) ; somewhat EXPENSIVE!!!
> ! (if (< (- here BOD-pos) how-far)
> ! (setq strategy 'BOD
> ! start-point BOD-pos)))
> !
> ! (list
> ! strategy
> ! (and (memq strategy '(forward BOD)) start-point))))
>
>
> ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
> --- 2534,2556 ----
> ;; o - ('forward START-POINT) - scan forward from START-POINT,
> ;; which is not less than the highest position in `c-state-cache' below here.
> ;; o - ('backward nil) - scan backwards (from HERE).
> ;; o - ('IN-LIT nil) - point is inside the literal containing point-min.
> (let ((cache-pos (c-get-cache-scan-pos here)) ; highest position below HERE in cache (or 1)
> ! strategy ; 'forward, 'backward, or 'IN-LIT.
> ! start-point)
> (setq good-pos (or good-pos (c-state-get-min-scan-pos)))
> (cond
> ((< here (c-state-get-min-scan-pos))
> ! (setq strategy 'IN-LIT))
> ((<= good-pos here)
> (setq strategy 'forward
> ! start-point (max good-pos cache-pos)))
> ((< (- good-pos here) (- here cache-pos)) ; FIXME!!! ; apply some sort of weighting.
> ! (setq strategy 'backward))
> (t
> (setq strategy 'forward
> ! start-point cache-pos)))
> ! (list strategy (and (eq strategy 'forward) start-point))))
>
>
> ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
> ***************
> *** 2630,2636 ****
>
> (setq c-state-point-min (point-min)))
>
> ! (defun c-append-lower-brace-pair-to-state-cache (from &optional upper-lim)
> ;; If there is a brace pair preceding FROM in the buffer, at the same level
> ;; of nesting (not necessarily immediately preceding), push a cons onto
> ;; `c-state-cache' to represent it. FROM must not be inside a literal. If
> --- 2592,2598 ----
>
> (setq c-state-point-min (point-min)))
>
> ! (defun c-append-lower-brace-pair-to-state-cache (from here &optional upper-lim)
> ;; If there is a brace pair preceding FROM in the buffer, at the same level
> ;; of nesting (not necessarily immediately preceding), push a cons onto
> ;; `c-state-cache' to represent it. FROM must not be inside a literal. If
> ***************
> *** 2654,2661 ****
> ;; reduce the time wasted in repeated fruitless searches in brace deserts.
> (save-excursion
> (save-restriction
> ! (let* ((here (point-max))
> ! new-cons
> (cache-pos (c-state-cache-top-lparen)) ; might be nil.
> (macro-start-or-from
> (progn (goto-char from)
> --- 2616,2622 ----
> ;; reduce the time wasted in repeated fruitless searches in brace deserts.
> (save-excursion
> (save-restriction
> ! (let* (new-cons
> (cache-pos (c-state-cache-top-lparen)) ; might be nil.
> (macro-start-or-from
> (progn (goto-char from)
> ***************
> *** 2690,2696 ****
> ;; search bound, even though the algorithm below would skip
> ;; over the new paren pair.
> (cache-lim (and cache-pos (< cache-pos from) cache-pos)))
> - (widen)
> (narrow-to-region
> (cond
> ((and desert-lim cache-lim)
> --- 2651,2656 ----
> ***************
> *** 2698,2704 ****
> (desert-lim)
> (cache-lim)
> ((point-min)))
> ! (point-max)))
>
> ;; In the next pair of nested loops, the inner one moves back past a
> ;; pair of (mis-)matching parens or brackets; the outer one moves
> --- 2658,2666 ----
> (desert-lim)
> (cache-lim)
> ((point-min)))
> ! ;; The top limit is EOB to ensure that `bra' is inside the
> ! ;; accessible part of the buffer at the next scan operation.
> ! (1+ (buffer-size))))
>
> ;; In the next pair of nested loops, the inner one moves back past a
> ;; pair of (mis-)matching parens or brackets; the outer one moves
> ***************
> *** 2765,2789 ****
> (if (consp (car c-state-cache))
> (cdr c-state-cache)
> c-state-cache)))
> ! ;; N.B. This defsubst codes one method for the simple, normal case,
> ;; and a more sophisticated, slower way for the general case. Don't
> ;; eliminate this defsubst - it's a speed optimization.
> ! (c-append-lower-brace-pair-to-state-cache (1- bra+1)))))
>
> ! (defun c-append-to-state-cache (from)
> ! ;; Scan the buffer from FROM to (point-max), adding elements into
> ! ;; `c-state-cache' for braces etc. Return a candidate for
> ! ;; `c-state-cache-good-pos'.
> ;;
> ;; FROM must be after the latest brace/paren/bracket in `c-state-cache', if
> ;; any. Typically, it is immediately after it. It must not be inside a
> ;; literal.
> ! (let ((here-bol (c-point 'bol (point-max)))
> (macro-start-or-here
> ! (save-excursion (goto-char (point-max))
> (if (c-beginning-of-macro)
> (point)
> ! (point-max))))
> pa+1 ; pos just after an opening PAren (or brace).
> (ren+1 from) ; usually a pos just after an closing paREN etc.
> ; Is actually the pos. to scan for a (/{/[ from,
> --- 2727,2750 ----
> (if (consp (car c-state-cache))
> (cdr c-state-cache)
> c-state-cache)))
> ! ;; N.B. This defsubst codes one method for the simple, normal case,
> ;; and a more sophisticated, slower way for the general case. Don't
> ;; eliminate this defsubst - it's a speed optimization.
> ! (c-append-lower-brace-pair-to-state-cache (1- bra+1) (point-max)))))
>
> ! (defun c-append-to-state-cache (from here)
> ! ;; Scan the buffer from FROM to HERE, adding elements into `c-state-cache'
> ! ;; for braces etc. Return a candidate for `c-state-cache-good-pos'.
> ;;
> ;; FROM must be after the latest brace/paren/bracket in `c-state-cache', if
> ;; any. Typically, it is immediately after it. It must not be inside a
> ;; literal.
> ! (let ((here-bol (c-point 'bol here))
> (macro-start-or-here
> ! (save-excursion (goto-char here)
> (if (c-beginning-of-macro)
> (point)
> ! here)))
> pa+1 ; pos just after an opening PAren (or brace).
> (ren+1 from) ; usually a pos just after an closing paREN etc.
> ; Is actually the pos. to scan for a (/{/[ from,
> ***************
> *** 2796,2870 ****
> mstart) ; start of a macro.
>
> (save-excursion
> ! ;; Each time round the following loop, we enter a successively deeper
> ! ;; level of brace/paren nesting. (Except sometimes we "continue at
> ! ;; the existing level".) `pa+1' is a pos inside an opening
> ! ;; brace/paren/bracket, usually just after it.
> ! (while
> ! (progn
> ! ;; Each time round the next loop moves forward over an opening then
> ! ;; a closing brace/bracket/paren. This loop is white hot, so it
> ! ;; plays ugly tricks to go fast. DON'T PUT ANYTHING INTO THIS
> ! ;; LOOP WHICH ISN'T ABSOLUTELY NECESSARY!!! It terminates when a
> ! ;; call of `scan-lists' signals an error, which happens when there
> ! ;; are no more b/b/p's to scan.
> ! (c-safe
> ! (while t
> ! (setq pa+1 (scan-lists ren+1 1 -1) ; Into (/{/[; might signal
> ! paren+1s (cons pa+1 paren+1s))
> ! (setq ren+1 (scan-lists pa+1 1 1)) ; Out of )/}/]; might signal
> ! (if (and (eq (char-before pa+1) ?{)) ; Check for a macro later.
> ! (setq bra+1 pa+1))
> ! (setcar paren+1s ren+1)))
>
> ! (if (and pa+1 (> pa+1 ren+1))
> ! ;; We've just entered a deeper nesting level.
> ! (progn
> ! ;; Insert the brace pair (if present) and the single open
> ! ;; paren/brace/bracket into `c-state-cache' It cannot be
> ! ;; inside a macro, except one around point, because of what
> ! ;; `c-neutralize-syntax-in-CPP' has done.
> ! (c-state-push-any-brace-pair bra+1 macro-start-or-here)
> ! ;; Insert the opening brace/bracket/paren position.
> ! (setq c-state-cache (cons (1- pa+1) c-state-cache))
> ! ;; Clear admin stuff for the next more nested part of the scan.
> ! (setq ren+1 pa+1 pa+1 nil bra+1 nil bra+1s nil)
> ! t) ; Carry on the loop
> !
> ! ;; All open p/b/b's at this nesting level, if any, have probably
> ! ;; been closed by matching/mismatching ones. We're probably
> ! ;; finished - we just need to check for having found an
> ! ;; unmatched )/}/], which we ignore. Such a )/}/] can't be in a
> ! ;; macro, due the action of `c-neutralize-syntax-in-CPP'.
> ! (c-safe (setq ren+1 (scan-lists ren+1 1 1)))))) ; acts as loop control.
> !
> ! ;; Record the final, innermost, brace-pair if there is one.
> ! (c-state-push-any-brace-pair bra+1 macro-start-or-here)
> !
> ! ;; Determine a good pos
> ! (while (and (setq paren+1 (car paren+1s))
> ! (> (if (> paren+1 macro-start-or-here)
> ! paren+1
> ! (goto-char paren+1)
> ! (setq mstart (and (c-beginning-of-macro)
> ! (point)))
> ! (or mstart paren+1))
> ! here-bol))
> ! (setq paren+1s (cdr paren+1s)))
> ! (cond
> ! ((and paren+1 mstart)
> ! (min paren+1 mstart))
> ! (paren+1)
> ! (t from)))))
>
> ! (defun c-remove-stale-state-cache (start-point pps-point)
> ;; Remove stale entries from the `c-cache-state', i.e. those which will
> ! ;; not be in it when it is amended for position (point-max).
> ! ;; Additionally, the "outermost" open-brace entry before (point-max)
> ! ;; will be converted to a cons if the matching close-brace is scanned.
> ;;
> ;; START-POINT is a "maximal" "safe position" - there must be no open
> ! ;; parens/braces/brackets between START-POINT and (point-max).
> ;;
> ;; As a second thing, calculate the result of parse-partial-sexp at
> ;; PPS-POINT, w.r.t. START-POINT. The motivation here is that
> --- 2757,2833 ----
> mstart) ; start of a macro.
>
> (save-excursion
> ! (save-restriction
> ! (narrow-to-region (point-min) here)
> ! ;; Each time round the following loop, we enter a successively deeper
> ! ;; level of brace/paren nesting. (Except sometimes we "continue at
> ! ;; the existing level".) `pa+1' is a pos inside an opening
> ! ;; brace/paren/bracket, usually just after it.
> ! (while
> ! (progn
> ! ;; Each time round the next loop moves forward over an opening then
> ! ;; a closing brace/bracket/paren. This loop is white hot, so it
> ! ;; plays ugly tricks to go fast. DON'T PUT ANYTHING INTO THIS
> ! ;; LOOP WHICH ISN'T ABSOLUTELY NECESSARY!!! It terminates when a
> ! ;; call of `scan-lists' signals an error, which happens when there
> ! ;; are no more b/b/p's to scan.
> ! (c-safe
> ! (while t
> ! (setq pa+1 (scan-lists ren+1 1 -1) ; Into (/{/[; might signal
> ! paren+1s (cons pa+1 paren+1s))
> ! (setq ren+1 (scan-lists pa+1 1 1)) ; Out of )/}/]; might signal
> ! (if (and (eq (char-before pa+1) ?{)) ; Check for a macro later.
> ! (setq bra+1 pa+1))
> ! (setcar paren+1s ren+1)))
>
> ! (if (and pa+1 (> pa+1 ren+1))
> ! ;; We've just entered a deeper nesting level.
> ! (progn
> ! ;; Insert the brace pair (if present) and the single open
> ! ;; paren/brace/bracket into `c-state-cache' It cannot be
> ! ;; inside a macro, except one around point, because of what
> ! ;; `c-neutralize-syntax-in-CPP' has done.
> ! (c-state-push-any-brace-pair bra+1 macro-start-or-here)
> ! ;; Insert the opening brace/bracket/paren position.
> ! (setq c-state-cache (cons (1- pa+1) c-state-cache))
> ! ;; Clear admin stuff for the next more nested part of the scan.
> ! (setq ren+1 pa+1 pa+1 nil bra+1 nil bra+1s nil)
> ! t) ; Carry on the loop
> !
> ! ;; All open p/b/b's at this nesting level, if any, have probably
> ! ;; been closed by matching/mismatching ones. We're probably
> ! ;; finished - we just need to check for having found an
> ! ;; unmatched )/}/], which we ignore. Such a )/}/] can't be in a
> ! ;; macro, due the action of `c-neutralize-syntax-in-CPP'.
> ! (c-safe (setq ren+1 (scan-lists ren+1 1 1)))))) ; acts as loop control.
> !
> ! ;; Record the final, innermost, brace-pair if there is one.
> ! (c-state-push-any-brace-pair bra+1 macro-start-or-here)
> !
> ! ;; Determine a good pos
> ! (while (and (setq paren+1 (car paren+1s))
> ! (> (if (> paren+1 macro-start-or-here)
> ! paren+1
> ! (goto-char paren+1)
> ! (setq mstart (and (c-beginning-of-macro)
> ! (point)))
> ! (or mstart paren+1))
> ! here-bol))
> ! (setq paren+1s (cdr paren+1s)))
> ! (cond
> ! ((and paren+1 mstart)
> ! (min paren+1 mstart))
> ! (paren+1)
> ! (t from))))))
>
> ! (defun c-remove-stale-state-cache (start-point here pps-point)
> ;; Remove stale entries from the `c-cache-state', i.e. those which will
> ! ;; not be in it when it is amended for position HERE. Additionally, the
> ! ;; "outermost" open-brace entry before HERE will be converted to a cons if
> ! ;; the matching close-brace is scanned.
> ;;
> ;; START-POINT is a "maximal" "safe position" - there must be no open
> ! ;; parens/braces/brackets between START-POINT and HERE.
> ;;
> ;; As a second thing, calculate the result of parse-partial-sexp at
> ;; PPS-POINT, w.r.t. START-POINT. The motivation here is that
> ***************
> *** 2881,2903 ****
> ;; last element to be removed from `c-state-cache', when that elt is a
> ;; cons, otherwise nil.
> ;; o - PPS-STATE is the parse-partial-sexp state at PPS-POINT.
> ! (save-restriction
> ! (narrow-to-region 1 (point-max))
> ! (save-excursion
> ! (let* ((in-macro-start ; start of macro containing (point-max) or nil.
> (save-excursion
> ! (goto-char (point-max))
> (and (c-beginning-of-macro)
> (point))))
> (start-point-actual-macro-start ; Start of macro containing
> ; start-point or nil
> ! (and (< start-point (point-max))
> (save-excursion
> (goto-char start-point)
> (and (c-beginning-of-macro)
> (point)))))
> (start-point-actual-macro-end ; End of this macro, (maybe
> ! ; (point-max)), or nil.
> (and start-point-actual-macro-start
> (save-excursion
> (goto-char start-point-actual-macro-start)
> --- 2844,2866 ----
> ;; last element to be removed from `c-state-cache', when that elt is a
> ;; cons, otherwise nil.
> ;; o - PPS-STATE is the parse-partial-sexp state at PPS-POINT.
> ! (save-excursion
> ! (save-restriction
> ! (narrow-to-region 1 (point-max))
> ! (let* ((in-macro-start ; start of macro containing HERE or nil.
> (save-excursion
> ! (goto-char here)
> (and (c-beginning-of-macro)
> (point))))
> (start-point-actual-macro-start ; Start of macro containing
> ; start-point or nil
> ! (and (< start-point here)
> (save-excursion
> (goto-char start-point)
> (and (c-beginning-of-macro)
> (point)))))
> (start-point-actual-macro-end ; End of this macro, (maybe
> ! ; HERE), or nil.
> (and start-point-actual-macro-start
> (save-excursion
> (goto-char start-point-actual-macro-start)
> ***************
> *** 2909,2922 ****
> scan-back-pos
> pair-beg pps-point-state target-depth)
>
> ! ;; Remove entries beyond (point-max). Also remove any entries inside
> ! ;; a macro, unless (point-max) is in the same macro.
> (setq upper-lim
> (if (or (null c-state-old-cpp-beg)
> ! (and (> (point-max) c-state-old-cpp-beg)
> ! (< (point-max) c-state-old-cpp-end)))
> ! (point-max)
> ! (min (point-max) c-state-old-cpp-beg)))
> (while (and c-state-cache (>= (c-state-cache-top-lparen) upper-lim))
> (setq scan-back-pos (car-safe (car c-state-cache)))
> (setq c-state-cache (cdr c-state-cache)))
> --- 2872,2885 ----
> scan-back-pos
> pair-beg pps-point-state target-depth)
>
> ! ;; Remove entries beyond HERE. Also remove any entries inside
> ! ;; a macro, unless HERE is in the same macro.
> (setq upper-lim
> (if (or (null c-state-old-cpp-beg)
> ! (and (> here c-state-old-cpp-beg)
> ! (< here c-state-old-cpp-end)))
> ! here
> ! (min here c-state-old-cpp-beg)))
> (while (and c-state-cache (>= (c-state-cache-top-lparen) upper-lim))
> (setq scan-back-pos (car-safe (car c-state-cache)))
> (setq c-state-cache (cdr c-state-cache)))
> ***************
> *** 2934,2940 ****
> ;; time round; the corresponding elements in `c-state-cache' are
> ;; removed. `pos' is just after the brace-pair or the open paren at
> ;; (car c-state-cache). There can be no open parens/braces/brackets
> ! ;; between `start-point'/`start-point-actual-macro-start' and (point-max),
> ;; due to the interface spec to this function.
> (setq pos (if (and start-point-actual-macro-end
> (not (eq start-point-actual-macro-start
> --- 2897,2903 ----
> ;; time round; the corresponding elements in `c-state-cache' are
> ;; removed. `pos' is just after the brace-pair or the open paren at
> ;; (car c-state-cache). There can be no open parens/braces/brackets
> ! ;; between `start-point'/`start-point-actual-macro-start' and HERE,
> ;; due to the interface spec to this function.
> (setq pos (if (and start-point-actual-macro-end
> (not (eq start-point-actual-macro-start
> ***************
> *** 2944,2950 ****
> start-point))
> (goto-char pos)
> (while (and c-state-cache
> ! (< (point) (point-max)))
> (cond
> ((null pps-state) ; first time through
> (setq target-depth -1))
> --- 2907,2915 ----
> start-point))
> (goto-char pos)
> (while (and c-state-cache
> ! (or (numberp (car c-state-cache)) ; Have we a { at all?
> ! (cdr c-state-cache))
> ! (< (point) here))
> (cond
> ((null pps-state) ; first time through
> (setq target-depth -1))
> ***************
> *** 2956,2962 ****
> ;; Scan!
> (setq pps-state
> (parse-partial-sexp
> ! (point) (if (< (point) pps-point) pps-point (point-max))
> target-depth
> nil pps-state))
>
> --- 2921,2927 ----
> ;; Scan!
> (setq pps-state
> (parse-partial-sexp
> ! (point) (if (< (point) pps-point) pps-point here)
> target-depth
> nil pps-state))
>
> ***************
> *** 3209,3215 ****
> ;; Do we need to add in an earlier brace pair, having lopped one off?
> (if (and dropped-cons
> (< too-high-pa (+ here c-state-cache-too-far)))
> ! (c-append-lower-brace-pair-to-state-cache too-high-pa here-bol))
> (setq c-state-cache-good-pos (or (c-state-cache-after-top-paren)
> (c-state-get-min-scan-pos)))))
>
> --- 3174,3180 ----
> ;; Do we need to add in an earlier brace pair, having lopped one off?
> (if (and dropped-cons
> (< too-high-pa (+ here c-state-cache-too-far)))
> ! (c-append-lower-brace-pair-to-state-cache too-high-pa here here-bol))
> (setq c-state-cache-good-pos (or (c-state-cache-after-top-paren)
> (c-state-get-min-scan-pos)))))
>
> ***************
> *** 3285,3331 ****
> strategy (car res)
> start-point (cadr res))
>
> - (when (eq strategy 'BOD)
> - (setq c-state-cache nil
> - c-state-cache-good-pos start-point))
> -
> ;; SCAN!
> ! (save-restriction
> ! (cond
> ! ((memq strategy '(forward BOD))
> ! (narrow-to-region (point-min) here)
> ! (setq res (c-remove-stale-state-cache start-point here-bopl))
> ! (setq cache-pos (car res)
> ! scan-backward-pos (cadr res)
> ! bopl-state (car (cddr res))) ; will be nil if (< here-bopl
> ; start-point)
> ! (if scan-backward-pos
> ! (c-append-lower-brace-pair-to-state-cache scan-backward-pos))
> ! (setq good-pos
> ! (c-append-to-state-cache cache-pos))
> ! (setq c-state-cache-good-pos
> ! (if (and bopl-state
> ! (< good-pos (- here c-state-cache-too-far)))
> ! (c-state-cache-non-literal-place here-bopl bopl-state)
> ! good-pos)))
> !
> ! ((eq strategy 'backward)
> ! (setq res (c-remove-stale-state-cache-backwards here)
> ! good-pos (car res)
> ! scan-backward-pos (cadr res)
> ! scan-forward-p (car (cddr res)))
> ! (if scan-backward-pos
> ! (c-append-lower-brace-pair-to-state-cache
> ! scan-backward-pos))
> ! (setq c-state-cache-good-pos
> ! (if scan-forward-p
> ! (progn (narrow-to-region (point-min) here)
> ! (c-append-to-state-cache good-pos))
> ! good-pos)))
>
> ! (t ; (eq strategy 'IN-LIT)
> ! (setq c-state-cache nil
> ! c-state-cache-good-pos nil)))))
>
> c-state-cache)
>
> --- 3250,3288 ----
> strategy (car res)
> start-point (cadr res))
>
> ;; SCAN!
> ! (cond
> ! ((eq strategy 'forward)
> ! (setq res (c-remove-stale-state-cache start-point here here-bopl))
> ! (setq cache-pos (car res)
> ! scan-backward-pos (cadr res)
> ! bopl-state (car (cddr res))) ; will be nil if (< here-bopl
> ; start-point)
> ! (if scan-backward-pos
> ! (c-append-lower-brace-pair-to-state-cache scan-backward-pos here))
> ! (setq good-pos
> ! (c-append-to-state-cache cache-pos here))
> ! (setq c-state-cache-good-pos
> ! (if (and bopl-state
> ! (< good-pos (- here c-state-cache-too-far)))
> ! (c-state-cache-non-literal-place here-bopl bopl-state)
> ! good-pos)))
> !
> ! ((eq strategy 'backward)
> ! (setq res (c-remove-stale-state-cache-backwards here)
> ! good-pos (car res)
> ! scan-backward-pos (cadr res)
> ! scan-forward-p (car (cddr res)))
> ! (if scan-backward-pos
> ! (c-append-lower-brace-pair-to-state-cache scan-backward-pos here))
> ! (setq c-state-cache-good-pos
> ! (if scan-forward-p
> ! (c-append-to-state-cache good-pos here)
> ! good-pos)))
>
> ! (t ; (eq strategy 'IN-LIT)
> ! (setq c-state-cache nil
> ! c-state-cache-good-pos nil))))
>
> c-state-cache)
>
> ***************
> *** 8559,8566 ****
> ))
>
> (defun c-looking-at-special-brace-list (&optional lim)
> ! ;; If we're looking at the start of a pike-style list, ie `({ })',
> ! ;; `([ ])', `(< >)' etc, a cons of a cons of its starting and ending
> ;; positions and its entry in c-special-brace-lists is returned, nil
> ;; otherwise. The ending position is nil if the list is still open.
> ;; LIM is the limit for forward search. The point may either be at
> --- 8516,8523 ----
> ))
>
> (defun c-looking-at-special-brace-list (&optional lim)
> ! ;; If we're looking at the start of a pike-style list, ie `({Â })',
> ! ;; `([Â ])', `(<Â >)' etc, a cons of a cons of its starting and ending
> ;; positions and its entry in c-special-brace-lists is returned, nil
> ;; otherwise. The ending position is nil if the list is still open.
> ;; LIM is the limit for forward search. The point may either be at
>
>
>> --
>> Michael Welsh Duggan
>> (mwd@cert.org)
--
Michael Welsh Duggan
(mwd@cert.org)
next prev parent reply other threads:[~2013-02-01 22:18 UTC|newest]
Thread overview: 55+ messages / expand[flat|nested] mbox.gz Atom feed top
2012-06-19 20:45 bug#11749: 24.1; C-mode indentation gives wrong-type-argument error Kim F. Storm
2012-06-21 7:17 ` Glenn Morris
2012-06-21 9:34 ` Kim Storm
2012-08-28 16:17 ` bug#11749: 24.2; wrong-type-argument Kim F. Storm
[not found] ` <handler.11749.B.13401389485673.ack@debbugs.gnu.org>
2012-08-28 22:49 ` bug#11749: Acknowledgement (24.1; C-mode indentation gives wrong-type-argument error.) Kim Storm
2012-08-31 11:01 ` Eli Zaretskii
2012-08-31 12:37 ` Kim Storm
2012-09-02 21:16 ` Alan Mackenzie
2012-09-03 9:47 ` Kim Storm
2012-09-03 13:56 ` Stefan Monnier
2012-09-03 14:20 ` Kim Storm
2012-09-03 18:52 ` Stefan Monnier
2012-09-05 20:48 ` Alan Mackenzie
2012-09-07 3:45 ` Michael Welsh Duggan
2012-09-07 14:53 ` Stefan Monnier
2012-09-07 16:16 ` Kim Storm
2012-09-08 21:14 ` Alan Mackenzie
2012-09-10 12:18 ` Michael Welsh Duggan
2012-09-10 12:48 ` Michael Welsh Duggan
2012-09-21 17:47 ` Michael Welsh Duggan
2012-10-07 10:59 ` Alan Mackenzie
2012-10-09 14:05 ` Michael Welsh Duggan
2012-10-10 20:00 ` Alan Mackenzie
2012-10-14 17:06 ` Alan Mackenzie
2012-10-23 16:13 ` Michael Welsh Duggan
2012-10-25 13:41 ` Michael Welsh Duggan
2012-10-28 11:36 ` Alan Mackenzie
2012-11-04 3:43 ` Chong Yidong
2012-11-04 20:42 ` Alan Mackenzie
2012-11-21 20:58 ` Alan Mackenzie
2012-11-22 14:52 ` Stefan Monnier
2012-11-04 20:39 ` Alan Mackenzie
2012-11-04 21:04 ` Kim Storm
2012-11-14 16:52 ` Michael Welsh Duggan
2012-11-21 21:33 ` Alan Mackenzie
2012-11-26 13:25 ` Michael Welsh Duggan
2012-12-10 3:35 ` Michael Welsh Duggan
2013-01-07 12:09 ` Alan Mackenzie
2013-01-17 16:27 ` Michael Welsh Duggan
2013-01-17 16:28 ` Michael Welsh Duggan
2013-01-23 14:16 ` Alan Mackenzie
2013-01-23 15:39 ` Michael Welsh Duggan
2013-01-29 11:37 ` Alan Mackenzie
[not found] ` <20130129113737.GA4544@acm.acm>
2013-02-01 22:18 ` Michael Welsh Duggan [this message]
2013-02-01 23:50 ` Kim Storm
2013-02-02 19:35 ` Alan Mackenzie
2012-09-10 13:10 ` Michael Welsh Duggan
2012-09-10 13:22 ` Michael Welsh Duggan
2012-09-10 18:25 ` Michael Welsh Duggan
2012-09-05 13:11 ` bug#11749: I also have this issue Denis Zalevskiy
2013-01-08 19:10 ` bug#11749: Acknowledgement (24.1; C-mode indentation gives wrong-type-argument error.) Glenn Morris
2013-01-09 22:13 ` Alan Mackenzie
2013-02-02 18:37 ` bug#11749: 24.1; C-mode indentation gives wrong-type-argument error Alan Mackenzie
2013-01-08 13:49 ` bug#13385: 24.1; TAB in C file causes type error Julian Stecklina
[not found] ` <handler.13385.D11749.1359830688892.notifdone@debbugs.gnu.org>
2013-02-03 13:00 ` bug#13385: closed (Re: 24.1; C-mode indentation gives wrong-type-argument error.) Julian Stecklina
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
List information: https://www.gnu.org/software/emacs/
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=tnt8v778ypn.fsf@waterbuck.yellow.cert.org \
--to=mwd@cert.org \
--cc=11749@debbugs.gnu.org \
--cc=acm@muc.de \
--cc=storm@cua.dk \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
Code repositories for project(s) associated with this public inbox
https://git.savannah.gnu.org/cgit/emacs.git
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).