bug-gnu-emacs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

bug#11749: Acknowledgement (24.1; C-mode indentation gives wrong-type-ar


From: Michael Welsh Duggan
Subject: bug#11749: Acknowledgement (24.1; C-mode indentation gives wrong-type-argument error.)
Date: Fri, 01 Feb 2013 17:18:44 -0500
User-agent: Gnus/5.130006 (Ma Gnus v0.6) Emacs/24.3.50 (gnu/linux)

Alan Mackenzie <address@hidden> 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 <address@hidden> 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
>> (address@hidden)

-- 
Michael Welsh Duggan
(address@hidden)





reply via email to

[Prev in Thread] Current Thread [Next in Thread]