CEDET

>>> David PONCE <david.ponce@...> seems to think that:
>Eric,
>
>I think I found the cause of the "Wrong type argument: arrayp, nil"
>in the incremental parser.  In fact, the error occurred in the
>function `semantic-edits-change-between-tokens' when handling a
>change after the last available tag.  In that case, in the
>
>(while (and list-to-search ... loop, 
>
> `(semantic-tag-start (car (cdr list-to-search)))'
>
>failed with the above error because (cdr list-to-search) is nil.
>
>Following is a patch that seems to have fixed the problem.
>Does it look good for you?
  [ ... ]

That seams like a good idea.  I tried writing some automated tests
for this thing, but I don't have much yet.

When fiddling with the incremental parser, I turn on
semantic-highlight-edits-mode and turn  off auto parse mode.  I will
then make edits (and see them highlight), and bovinate the buffer by
hand to see what it chooses to do, and if it succeeds.

Below find what little bit of unit testing I have for the incremental
parser.  Perhaps it will prove useful.

Eric
-------------
;;; semantic-utest.el --- Tests for semantic's parsing system.

;;; Copyright (C) 2003, 2004 Eric M. Ludlam

;; Author: Eric M. Ludlam <zappo@...>
;; X-RCS: $Id: semantic.el,v 1.173 2003/09/02 14:50:25 ponced Exp $

;; This file is not part of GNU Emacs.

;; Semantic is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; This software is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

;;; Commentary:
;;
;; Semantic's parsing and partial parsing system is pretty complex.
;; These unit tests attempt to emulate semantic's partial reparsing
;; and full reparsing system, and anything else I may feel the urge
;; to write a test for.

(require 'semantic)

(defvar semantic-utest-C-buffer-contents
  "/* Test file for C language for Unit Tests */

#include <stdio.h>
#include \"sutest.h\"

struct mystruct1 {
  int slot11;
  char slot12;
  float slot13;
};

int var1;

float funp1(char arg11, char arg12);

char fun2(int arg_21, int arg_22) /*1*/
{
  struct mystruct1 *ms1 = malloc(sizeof(struct mystruct1));

  char sv = calc_sv(var1);

  if (var1 == 0) {
     sv = 1;
  } else if (arg_21 == 0) {
     sv = 2;
  } else if (arg_22 == 0) {
     sv = 3;
  } else {
     sv = 4;
  }

  printf(\"SV = %d\\n\", sv);

  /* Memory Leak */
  ms1.slot1 = sv;

  return 'A' + sv;
}
"
  "Contents of a C buffer initialized by this unit test.
Be sure to change `semantic-utest-C-name-contents' when you
change this variable.")

(defvar semantic-utest-C-h-buffer-contents
  "/* Test file for C language header file for Unit Tests */

int calc_sv(int);

"
  "Contents of a C header file buffer initialized by this unit test.")


(defvar semantic-utest-filename "/tmp/sutest.c"
  "File to open and erase during this teset.")

(defvar semantic-utest-filename-h 
  (concat (file-name-sans-extension semantic-utest-filename)
	  ".h")
  "Header file filename")


(defun semantic-utest ()
  "Run semantic's unit test."
  (interactive)
  (save-excursion
    (let ((buff (find-file-noselect semantic-utest-filename))
	  (buff2 (find-file-noselect semantic-utest-filename-h))
	  )
      (set-buffer buff2)
      (erase-buffer)
      (insert semantic-utest-C-h-buffer-contents)
      (semantic-fetch-tags)
      (set-buffer buff)
      (erase-buffer)
      (insert semantic-utest-C-buffer-contents)
      ;; Turn off a range of modes
      (semantic-idle-scheduler-mode -1)

      ;; Turn on some modes
      (semantic-highlight-edits-mode 1)

      ;; Update tags, and show it.
      (semantic-fetch-tags)
      (switch-to-buffer buff)
      (sit-for 0)
      
      ;; Run the tests.
      (message "First parsing test.")
      (semantic-utest-verify-names)

      (message "Invalid tag test.")
      (semantic-utest-last-invalid)
      (semantic-utest-verify-names)

      ;; Clean up
      ;; (kill-buffer buff)
      ;; (kill-buffer buff2)
      ))
  (message "All tests passed.")
  )

;;; Buffer contents validation
;;
(defvar semantic-utest-C-name-contents
  '("stdio.h"
    "sutest.h"
    "mystruct1"
    "var1"
    "funp1"
    "fun2")
  "List of expected tag names.")

(defun semantic-utest-verify-names (&rest skipnames)
  "Verify the names of the test buffer.
Argument SKIPNAMES is a list of names that should be skipped
when analyzing the file."
  (let ((names semantic-utest-C-name-contents)
	(table (semantic-fetch-tags))
	)
    (while skipnames
      (setq names (remove (car skipnames) names))
      (setq skipnames (cdr skipnames)))
    (while (and names table)
      (if (not (string= (car names) (semantic-tag-name (car table))))
	  (error "Expected %s, found %s" (car names)
		 (semantic-tag-name (car table))))
      (setq names (cdr names)
	    table (cdr table)))
    (when names (error "Items forgotten: %S" names))
    (when table (error "Items extra: %S" table))))

;;; Kill indicator line
;;
(defvar semantic-utest-last-kill-text nil
  "The text from the last kill.")

(defvar semantic-utest-last-kill-pos nil
  "The position of the last kill.")

(defun semantic-utest-kill-indicator (indicator)
  "Kill the line with INDICATOR on it."
  (goto-char (point-min))
  (re-search-forward (concat "/\\*" indicator "\\*/"))
  (beginning-of-line)
  (setq semantic-utest-last-kill-pos (point))
  (setq semantic-utest-last-kill-text
	(buffer-substring (point) (point-at-eol)))
  (delete-region (point) (point-at-eol))
  (insert "/* Deleted this line */")
  (sit-for 0)
)

(defun semantic-utest-unkill-indicator ()
  "Unkill the last indicator."
  (goto-char semantic-utest-last-kill-pos)
  (delete-region (point) (point-at-eol))
  (insert semantic-utest-last-kill-text)
  (sit-for 0)
  )

;;;  EDITING TESTS
;;

(defun semantic-utest-last-invalid ()
  "Make the last fcn invalid."
  (semantic-utest-kill-indicator "1")
  (semantic-utest-verify-names "fun2")
  (semantic-utest-unkill-indicator)
  )

-- 
          Eric Ludlam:                 zappo@..., eric@...
   Home: http://www.ludlam.net            Siege: http://www.siege-engine.com
Emacs: http://cedet.sourceforge.net               GNU: http://www.gnu.org

>>> David PONCE <david.ponce@...> seems to think that:
>Hi Eric,
>
>__ I moved this discussion to cedet-devel to avoid polluting the JDEE
>   ML with consideration about CEDET internals ;-) __
>
>[...]
>>>Please, could you try the following patch to semantic-edit.el that
>>>makes `semantic-edits-incremental-parser' distinguish between expected
>>>incremental parse failures, that schedule a full re-parse, and other
>>>unexpected errors which shouldn't be caught, in order to produce a
>>>backtrace when `debug-on-error' is set.
>>>
>>>Eric, WDYT of that patch?  Is it worth committing it?
>> 
>>   [ ... ]
>> 
>> That does sound helpful.  Thanks!
>
>I checked the patch in.
>
>> Should it use 'semantic-safe' the fling signals?
>> 
>> Should the condition-case change to only accept the new
>> 'semantic-parse-changes-failed' signal?
>
>I am not sure to understand.  The patch changed the `condition-case'
>to only accept expected `semantic-parse-changes-failed' conditions,

You are right.  I misinterpreted a chunk of the patch.

Catch and throw might be better suited to this task.  It is roughly
the same since application developers would not be using our declared
signal anyway.

>that schedule a full re-parse.  For now true errors are not handled.
>Probably we could use `semantic-safe' to catch those errors and issue
>a message when `debug-on-error' is not set.  Is that what you meant?
>
>For example, `semantic-edits-incremental-parser' could be renamed
>`semantic-edits-incremental-parser-1' and the new implementation of
>`semantic-edits-incremental-parser' could look like this:
>
>;;;###autoload
>(defun semantic-edits-incremental-parser ()
>  "Incrementally reparse the current buffer.
>Incremental parser allows semantic to only reparse those sections of
>the buffer that have changed.  This function depends on
>`semantic-edits-change-function-handle-changes' setting up change
>overlays in the current buffer.  Those overlays are analyzed against
>the semantic cache to see what needs to be changed."
>    (semantic-safe "incremental parser error: %S"
>      (semantic-edits-incremental-parser-1)))
>
>I can commit that change too, if you agree.
  [ ... ]

For someone not debugging the incremental parser, we certainly want
problems to be mostly hidden if possible.  This makes good sense too.

Thanks.
Eric

-- 
          Eric Ludlam:                 zappo@..., eric@...
   Home: http://www.ludlam.net            Siege: http://www.siege-engine.com
Emacs: http://cedet.sourceforge.net               GNU: http://www.gnu.org

[...]
>>>Should it use 'semantic-safe' the fling signals?
>>>
>>>Should the condition-case change to only accept the new
>>>'semantic-parse-changes-failed' signal?
>>
>>I am not sure to understand.  The patch changed the `condition-case'
>>to only accept expected `semantic-parse-changes-failed' conditions,
> 
> 
> You are right.  I misinterpreted a chunk of the patch.
> 
> Catch and throw might be better suited to this task.  It is roughly
> the same since application developers would not be using our declared
> signal anyway.

Good point!

[...]
> For someone not debugging the incremental parser, we certainly want
> problems to be mostly hidden if possible.  This makes good sense
> too.

So, WDYT of the following implementation?  If it is good for you, I
will commit it in semantic-edit.el.

Thanks!

David

Index: semantic-edit.el
===================================================================
RCS file: /cvsroot/cedet/cedet/semantic/semantic-edit.el,v
retrieving revision 1.24
diff -c -r1.24 semantic-edit.el
*** semantic-edit.el	9 Jun 2004 06:56:02 -0000	1.24
--- semantic-edit.el	9 Jun 2004 12:57:58 -0000
***************
*** 442,467 ****
  ;;
  ;; Logic about how to group changes for effective reparsing and splicing.
  
  (defsubst semantic-edits-incremental-fail ()
    "When the incremental parser fails, we mark that we need a full reparse."
    ;;(debug)
    (semantic-parse-tree-set-needs-rebuild)
    (message "Force full reparse (%s)" (buffer-name (current-buffer)))
!   (run-hooks 'semantic-edits-incremental-reparse-failed-hooks)
!   )
! 
! ;; Error symbol for expected parse changes failures
! (put 'semantic-parse-changes-failed 'error-conditions
!      '(error semantic-parse-changes-failed))
! (put 'semantic-parse-changes-failed 'error-message
!      "Semantic parse changes failed")
! 
! (defun semantic-parse-changes-failed (&rest args)
!   "Signal that Semantic failed to parse changes.
! Make error message by passing all args to `format'."
!   (while t
!     (signal 'semantic-parse-changes-failed
!             (list (apply 'format args)))))
  
  ;;;###autoload
  (defun semantic-edits-incremental-parser ()
--- 442,460 ----
  ;;
  ;; Logic about how to group changes for effective reparsing and splicing.
  
+ (defun semantic-parse-changes-failed (&rest args)
+   "Signal that Semantic failed to parse changes.
+ That is, display a message by passing all ARGS to `format', then throw
+ a 'semantic-parse-changes-failed exception with value t."
+   (message "Semantic parse changes failed: %S" (apply 'format args))
+   (throw 'semantic-parse-changes-failed t))
+ 
  (defsubst semantic-edits-incremental-fail ()
    "When the incremental parser fails, we mark that we need a full reparse."
    ;;(debug)
    (semantic-parse-tree-set-needs-rebuild)
    (message "Force full reparse (%s)" (buffer-name (current-buffer)))
!   (run-hooks 'semantic-edits-incremental-reparse-failed-hooks))
  
  ;;;###autoload
  (defun semantic-edits-incremental-parser ()
***************
*** 471,750 ****
  `semantic-edits-change-function-handle-changes' setting up change
  overlays in the current buffer.  Those overlays are analyzed against
  the semantic cache to see what needs to be changed."
!   (let ((changed-tokens nil))
!     (condition-case errobj
!         (let* ((debug-on-quit t) ; try to find this annoying bug!
! 	       (changes (semantic-changes-in-region
!                          (point-min) (point-max)))
!                (tokens nil)		;tokens found at changes
!                (newf-tokens nil)        ;newfound tokens in change
!                (parse-start nil)        ;location to start parsing
!                (parse-end nil)          ;location to end parsing
!                (parent-token nil)	;parent of the cache list.
!                (cache-list nil)         ;list of children within which
! 					;we incrementally reparse.
!                (reparse-symbol nil)     ;The ruled we start at for reparse.
!                (change-group nil)       ;changes grouped in this reparse
!                )
!           (or changes
!               ;; If we were called, and there are no changes, then we
!               ;; don't know what to do.  Force a full reparse.
!               (semantic-parse-changes-failed "Don't know what to do"))
!           ;; Else, we have some changes.  Loop over them attempting to
!           ;; patch things up.
!           (while changes
!             ;; Calculate the reparse boundary.
!             ;; We want to take some set of changes, and group them
!             ;; together into a small change group. One change forces
!             ;; a reparse of a larger region (the size of some set of
!             ;; tokens it encompases.)  It may contain several tokens.
!             ;; That region may have other changes in it (several small
!             ;; changes in one function, for example.)
!             ;; Optimize for the simple cases here, but try to handle
!             ;; complex ones too.
! 
!             (while (and changes         ; we still have changes
!                         (or (not parse-start)
!                             ;; Below, if the change we are looking at
!                             ;; is not the first change for this
!                             ;; iteration, and it starts before the end
!                             ;; of current parse region, then it is
!                             ;; encompased within the bounds of tokens
!                             ;; modified by the previous iteration's
!                             ;; change.
!                             (< (semantic-overlay-start (car changes))
!                                parse-end)))
! 
! 	      ;; REMOVE LATER
! 	      (if (eq (car changes) (car change-group))
! 		  (semantic-parse-changes-failed
!                    "Possible infinite loop detected"))
! 
!               ;; Store this change in this change group.
!               (setq change-group (cons (car changes) change-group))
  
!               (cond
!                ;; Is this is a new parse group?
!                ((not parse-start)
!                 (let (tmp)
!                   (cond
  
  ;;;; Are we encompassed all in one token?
!                    ((setq tmp (semantic-edits-change-leaf-token (car changes)))
!                     (setq tokens (list tmp)
!                           parse-start (semantic-tag-start tmp)
!                           parse-end (semantic-tag-end tmp)
!                           ))
  
  ;;;; Did the change occur between some tokens?
!                    ((setq cache-list (semantic-edits-change-between-tokens
!                                       (car changes)))
!                     ;; The CAR of cache-list is the token just before
!                     ;; our change, but wasn't modified.  Hmmm.
!                     ;; Bound our reparse between these two tokens
!                     (setq tokens nil
!                           parent-token
!                           (car (semantic-find-tag-by-overlay
!                                 parse-start)))
!                     (cond
!                       ;; A change at the beginning of the buffer.
!                      ((> (semantic-tag-start (car cache-list))
!                          (semantic-overlay-end (car changes)))
!                       (setq parse-start
!                             ;; Don't worry about parents since
!                             ;; there there would be an exact
!                             ;; match in the token list otherwise
!                             ;; and the routine would fail.
!                             (point-min)
!                             parse-end
!                             (semantic-tag-start (car cache-list)))
!                       )
!                      ;; A change stuck on the first surrounding token.
!                      ((= (semantic-tag-end (car cache-list))
!                          (semantic-overlay-start (car changes)))
!                       ;; Reparse that first token.
!                       (setq parse-start
!                             (semantic-tag-start (car cache-list))
!                             parse-end
!                             (semantic-overlay-end (car changes))
!                             tokens
!                             (list (car cache-list)))
!                       )
!                      ;; A change at the end of the buffer.
!                      ((not (car (cdr cache-list)))
!                       (setq parse-start (semantic-tag-end
!                                          (car cache-list))
!                             parse-end (point-max))
!                       )
!                      (t
!                       (setq parse-start
!                             (semantic-tag-end (car cache-list))
!                             parse-end
!                             (semantic-tag-start (car (cdr cache-list)))
!                             ))))
  
  ;;;; Did the change completely overlap some number of tokens?
!                    ((setq tmp (semantic-edits-change-over-tokens
!                                (car changes)))
!                     ;; Extract the information
!                     (setq tokens (aref tmp 0)
!                           cache-list (aref tmp 1)
!                           parent-token (aref tmp 2))
!                     ;; We can calculate parse begin/end by checking
!                     ;; out what is in TOKENS.  The one near start is
!                     ;; always first.  Make sure the reprase includes
!                     ;; the `whitespace' around the snarfed tokens.
!                     ;; Since cache-list is positioned properly, use it
!                     ;; to find that boundary.
!                     (if (eq (car tokens) (car cache-list))
!                         ;; Beginning of the buffer!
!                         (let ((end-marker (nth (length tokens)
!                                                cache-list)))
!                           (setq parse-start (point-min))
!                           (if end-marker
!                               (setq parse-end
!                                     (semantic-tag-start end-marker))
!                             (setq parse-end (semantic-overlay-end
!                                              (car changes)))))
!                       ;; Middle of the buffer.
!                       (setq parse-start
!                             (semantic-tag-end (car cache-list)))
!                       ;; For the end, we need to scoot down some
!                       ;; number of tokens.  We 1+ the length of tokens
!                       ;; because we want to skip the first token
!                       ;; (remove 1-) then want the token after the end
!                       ;; of the list (1+)
!                       (let ((end-marker (nth (1+ (length tokens)) cache-list)))
!                         (if end-marker
!                             (setq parse-end (semantic-tag-start end-marker))
!                           ;; No marker.  It is the last token in our
!                           ;; list of tokens.  Only possible if END
!                           ;; already matches the end of that token.
!                           (setq parse-end
!                                 (semantic-overlay-end (car changes)))))
!                       ))
  
  ;;;; Unhandled case.
!                    ;; Throw error, and force full reparse.
!                    ((semantic-parse-changes-failed "Unhandled change group")))
!                   ))
!                ;; Is this change inside the previous parse group?
!                ;; We already checked start.
!                ((< (semantic-overlay-end (car changes)) parse-end)
!                 nil)
!                ;; This change extends the current parse group.
!                ;; Find any new tokens, and see how to append them.
!                ((semantic-parse-changes-failed
!                  "Unhandled secondary change overlapping boundary"))
!                )
!               ;; Prepare for the next iteration.
!               (setq changes (cdr changes)))
! 
!             ;; By the time we get here, all TOKENS are children of
!             ;; some parent.  They should all have the same start symbol
!             ;; since that is how the multi-token parser works.  Grab
!             ;; the reparse symbol from the first of the returned tokens.
!             (setq reparse-symbol
!                   (semantic--tag-get-property (car (or tokens cache-list))
! 					      'reparse-symbol))
!             ;; Find a parent if not provided.
!             (and (not parent-token) tokens
!                  (setq parent-token
! 		       (semantic-find-tag-parent-by-overlay
! 			(car tokens))))
!             ;; We can do the same trick for our parent and resulting
!             ;; cache list.
!             (or cache-list
!                 (setq cache-list
!                       ;; We need to get all children in case we happen
!                       ;; to have a mix of positioned and non-positioned
!                       ;; children.
!                       (semantic-tag-components parent-token)))
!             ;; Use the boundary to calculate the new tokens found.
!             (setq newf-tokens (semantic-parse-region
!                                parse-start parse-end reparse-symbol))
!             ;; Make sure all these tokens are given overlays.
!             ;; They have already been cooked by the parser and just
!             ;; need the overlays.
!             (let ((tmp newf-tokens))
!               (while tmp
!                 (semantic--tag-link-to-buffer (car tmp))
!                 (setq tmp (cdr tmp))))
  
!             ;; See how this change lays out.
!             (cond
  
  ;;;; Whitespace change
!              ((and (not tokens) (not newf-tokens))
!               ;; A change that occured outside of any existing tokens
!               ;; and there are no new tokens to replace it.
!               (message "White space changes")
!               nil
!               )
  
  ;;;; New tokens in old whitespace area.
!              ((and (not tokens) newf-tokens)
!               ;; A change occured outside existing tokens which added
!               ;; a new token.  We need to splice these tokens back
!               ;; into the cache at the right place.
!               (semantic-edits-splice-insert newf-tokens parent-token cache-list)
! 
!               (setq changed-tokens
!                     (append newf-tokens changed-tokens))
! 
!               (message "Inserted tokens: (%s)"
!                        (semantic-format-tag-name (car newf-tokens)))
!               )
  
  ;;;; Old tokens removed
!              ((and tokens (not newf-tokens))
!               ;; A change occured where pre-existing tokens were
!               ;; deleted!  Remove the token from the cache.
!               (semantic-edits-splice-remove tokens parent-token cache-list)
! 
!               (setq changed-tokens
!                     (append tokens changed-tokens))
! 
!               (message "Deleted tokens: (%s)"
!                        (semantic-format-tag-name (car tokens)))
!               )
  
  ;;;; One token was updated.
!              ((and (= (length tokens) 1) (= (length newf-tokens) 1))
!               ;; One old token was modified, and it is replaced by
!               ;; One newfound token.  Splice the new token into the
!               ;; position of the old token.
!               ;; Do the splice.
!               (semantic-edits-splice-replace (car tokens) (car newf-tokens))
!               ;; Add this token to our list of changed toksns
!               (setq changed-tokens (cons (car tokens) changed-tokens))
!               ;; Debug
!               (message "Update Tag Table: %s"
!                        (semantic-format-tag-name (car tokens) nil t))
!               ;; Flush change regardless of above if statement.
!               )
  
  ;;;; Some unhandled case.
!              ((semantic-parse-changes-failed "Don't know what to do")))
! 
!             ;; We got this far, and we didn't flag a full reparse.
!             ;; Clear out this change group.
!             (while change-group
!               (semantic-edits-flush-change (car change-group))
!               (setq change-group (cdr change-group)))
! 
!             ;; Don't increment change here because an earlier loop
!             ;; created change-groups.
!             (setq parse-start nil)
!             )
!           ;; Mark that we are done with this glop
!           (semantic-parse-tree-set-up-to-date))
! 
!       ;; Force a full reparse.
!       (semantic-parse-changes-failed
!        (message (error-message-string errobj))
!        (semantic-edits-incremental-fail)))
  
      ;; Return the list of tokens that changed.  The caller will
      ;; use this information to call hooks which can fix themselves.
      changed-tokens))
--- 464,751 ----
  `semantic-edits-change-function-handle-changes' setting up change
  overlays in the current buffer.  Those overlays are analyzed against
  the semantic cache to see what needs to be changed."
!     (semantic-safe "incremental parser error: %S"
!       (let ((changed-tags (catch 'semantic-parse-changes-failed
!                             (semantic-edits-incremental-parser-1))))
!         (when (eq changed-tags t)
!           ;; Force a full reparse.
!           (semantic-edits-incremental-fail)
!           (setq changed-tags nil))
!         changed-tags)))
  
! (defun semantic-edits-incremental-parser-1 ()
!   "Incrementally reparse the current buffer.
! Return the list of tags that changed.
! If the incremental parse fails, throw a 'semantic-parse-changes-failed
! exception with value t, that can be caught to schedule a full reparse.
! This function is for internal use by `semantic-edits-incremental-parser'."
!   (let* ((changed-tokens nil)
!          (debug-on-quit t)            ; try to find this annoying bug!
!          (changes (semantic-changes-in-region
!                    (point-min) (point-max)))
!          (tokens nil)                   ;tokens found at changes
!          (newf-tokens nil)              ;newfound tokens in change
!          (parse-start nil)              ;location to start parsing
!          (parse-end nil)                ;location to end parsing
!          (parent-token nil)             ;parent of the cache list.
!          (cache-list nil)               ;list of children within which
! 					;we incrementally reparse.
!          (reparse-symbol nil)      ;The ruled we start at for reparse.
!          (change-group nil)           ;changes grouped in this reparse
!          )
!     (or changes
!         ;; If we were called, and there are no changes, then we
!         ;; don't know what to do.  Force a full reparse.
!         (semantic-parse-changes-failed "Don't know what to do"))
!     ;; Else, we have some changes.  Loop over them attempting to
!     ;; patch things up.
!     (while changes
!       ;; Calculate the reparse boundary.
!       ;; We want to take some set of changes, and group them
!       ;; together into a small change group. One change forces
!       ;; a reparse of a larger region (the size of some set of
!       ;; tokens it encompases.)  It may contain several tokens.
!       ;; That region may have other changes in it (several small
!       ;; changes in one function, for example.)
!       ;; Optimize for the simple cases here, but try to handle
!       ;; complex ones too.
! 
!       (while (and changes               ; we still have changes
!                   (or (not parse-start)
!                       ;; Below, if the change we are looking at
!                       ;; is not the first change for this
!                       ;; iteration, and it starts before the end
!                       ;; of current parse region, then it is
!                       ;; encompased within the bounds of tokens
!                       ;; modified by the previous iteration's
!                       ;; change.
!                       (< (semantic-overlay-start (car changes))
!                          parse-end)))
! 
!         ;; REMOVE LATER
!         (if (eq (car changes) (car change-group))
!             (semantic-parse-changes-failed
!              "Possible infinite loop detected"))
! 
!         ;; Store this change in this change group.
!         (setq change-group (cons (car changes) change-group))
! 
!         (cond
!          ;; Is this is a new parse group?
!          ((not parse-start)
!           (let (tmp)
!             (cond
  
  ;;;; Are we encompassed all in one token?
!              ((setq tmp (semantic-edits-change-leaf-token (car changes)))
!               (setq tokens (list tmp)
!                     parse-start (semantic-tag-start tmp)
!                     parse-end (semantic-tag-end tmp)
!                     ))
  
  ;;;; Did the change occur between some tokens?
!              ((setq cache-list (semantic-edits-change-between-tokens
!                                 (car changes)))
!               ;; The CAR of cache-list is the token just before
!               ;; our change, but wasn't modified.  Hmmm.
!               ;; Bound our reparse between these two tokens
!               (setq tokens nil
!                     parent-token
!                     (car (semantic-find-tag-by-overlay
!                           parse-start)))
!               (cond
!                ;; A change at the beginning of the buffer.
!                ((> (semantic-tag-start (car cache-list))
!                    (semantic-overlay-end (car changes)))
!                 (setq parse-start
!                       ;; Don't worry about parents since
!                       ;; there there would be an exact
!                       ;; match in the token list otherwise
!                       ;; and the routine would fail.
!                       (point-min)
!                       parse-end
!                       (semantic-tag-start (car cache-list)))
!                 )
!                ;; A change stuck on the first surrounding token.
!                ((= (semantic-tag-end (car cache-list))
!                    (semantic-overlay-start (car changes)))
!                 ;; Reparse that first token.
!                 (setq parse-start
!                       (semantic-tag-start (car cache-list))
!                       parse-end
!                       (semantic-overlay-end (car changes))
!                       tokens
!                       (list (car cache-list)))
!                 )
!                ;; A change at the end of the buffer.
!                ((not (car (cdr cache-list)))
!                 (setq parse-start (semantic-tag-end
!                                    (car cache-list))
!                       parse-end (point-max))
!                 )
!                (t
!                 (setq parse-start
!                       (semantic-tag-end (car cache-list))
!                       parse-end
!                       (semantic-tag-start (car (cdr cache-list)))
!                       ))))
  
  ;;;; Did the change completely overlap some number of tokens?
!              ((setq tmp (semantic-edits-change-over-tokens
!                          (car changes)))
!               ;; Extract the information
!               (setq tokens (aref tmp 0)
!                     cache-list (aref tmp 1)
!                     parent-token (aref tmp 2))
!               ;; We can calculate parse begin/end by checking
!               ;; out what is in TOKENS.  The one near start is
!               ;; always first.  Make sure the reprase includes
!               ;; the `whitespace' around the snarfed tokens.
!               ;; Since cache-list is positioned properly, use it
!               ;; to find that boundary.
!               (if (eq (car tokens) (car cache-list))
!                   ;; Beginning of the buffer!
!                   (let ((end-marker (nth (length tokens)
!                                          cache-list)))
!                     (setq parse-start (point-min))
!                     (if end-marker
!                         (setq parse-end
!                               (semantic-tag-start end-marker))
!                       (setq parse-end (semantic-overlay-end
!                                        (car changes)))))
!                 ;; Middle of the buffer.
!                 (setq parse-start
!                       (semantic-tag-end (car cache-list)))
!                 ;; For the end, we need to scoot down some
!                 ;; number of tokens.  We 1+ the length of tokens
!                 ;; because we want to skip the first token
!                 ;; (remove 1-) then want the token after the end
!                 ;; of the list (1+)
!                 (let ((end-marker (nth (1+ (length tokens)) cache-list)))
!                   (if end-marker
!                       (setq parse-end (semantic-tag-start end-marker))
!                     ;; No marker.  It is the last token in our
!                     ;; list of tokens.  Only possible if END
!                     ;; already matches the end of that token.
!                     (setq parse-end
!                           (semantic-overlay-end (car changes)))))
!                 ))
  
  ;;;; Unhandled case.
!              ;; Throw error, and force full reparse.
!              ((semantic-parse-changes-failed "Unhandled change group")))
!             ))
!          ;; Is this change inside the previous parse group?
!          ;; We already checked start.
!          ((< (semantic-overlay-end (car changes)) parse-end)
!           nil)
!          ;; This change extends the current parse group.
!          ;; Find any new tokens, and see how to append them.
!          ((semantic-parse-changes-failed
!            "Unhandled secondary change overlapping boundary"))
!          )
!         ;; Prepare for the next iteration.
!         (setq changes (cdr changes)))
! 
!       ;; By the time we get here, all TOKENS are children of
!       ;; some parent.  They should all have the same start symbol
!       ;; since that is how the multi-token parser works.  Grab
!       ;; the reparse symbol from the first of the returned tokens.
!       (setq reparse-symbol
!             (semantic--tag-get-property (car (or tokens cache-list))
!                                         'reparse-symbol))
!       ;; Find a parent if not provided.
!       (and (not parent-token) tokens
!            (setq parent-token
!                  (semantic-find-tag-parent-by-overlay
!                   (car tokens))))
!       ;; We can do the same trick for our parent and resulting
!       ;; cache list.
!       (or cache-list
!           (setq cache-list
!                 ;; We need to get all children in case we happen
!                 ;; to have a mix of positioned and non-positioned
!                 ;; children.
!                 (semantic-tag-components parent-token)))
!       ;; Use the boundary to calculate the new tokens found.
!       (setq newf-tokens (semantic-parse-region
!                          parse-start parse-end reparse-symbol))
!       ;; Make sure all these tokens are given overlays.
!       ;; They have already been cooked by the parser and just
!       ;; need the overlays.
!       (let ((tmp newf-tokens))
!         (while tmp
!           (semantic--tag-link-to-buffer (car tmp))
!           (setq tmp (cdr tmp))))
  
!       ;; See how this change lays out.
!       (cond
  
  ;;;; Whitespace change
!        ((and (not tokens) (not newf-tokens))
!         ;; A change that occured outside of any existing tokens
!         ;; and there are no new tokens to replace it.
!         (message "White space changes")
!         nil
!         )
  
  ;;;; New tokens in old whitespace area.
!        ((and (not tokens) newf-tokens)
!         ;; A change occured outside existing tokens which added
!         ;; a new token.  We need to splice these tokens back
!         ;; into the cache at the right place.
!         (semantic-edits-splice-insert newf-tokens parent-token cache-list)
! 
!         (setq changed-tokens
!               (append newf-tokens changed-tokens))
! 
!         (message "Inserted tokens: (%s)"
!                  (semantic-format-tag-name (car newf-tokens)))
!         )
  
  ;;;; Old tokens removed
!        ((and tokens (not newf-tokens))
!         ;; A change occured where pre-existing tokens were
!         ;; deleted!  Remove the token from the cache.
!         (semantic-edits-splice-remove tokens parent-token cache-list)
! 
!         (setq changed-tokens
!               (append tokens changed-tokens))
! 
!         (message "Deleted tokens: (%s)"
!                  (semantic-format-tag-name (car tokens)))
!         )
  
  ;;;; One token was updated.
!        ((and (= (length tokens) 1) (= (length newf-tokens) 1))
!         ;; One old token was modified, and it is replaced by
!         ;; One newfound token.  Splice the new token into the
!         ;; position of the old token.
!         ;; Do the splice.
!         (semantic-edits-splice-replace (car tokens) (car newf-tokens))
!         ;; Add this token to our list of changed toksns
!         (setq changed-tokens (cons (car tokens) changed-tokens))
!         ;; Debug
!         (message "Update Tag Table: %s"
!                  (semantic-format-tag-name (car tokens) nil t))
!         ;; Flush change regardless of above if statement.
!         )
  
  ;;;; Some unhandled case.
!        ((semantic-parse-changes-failed "Don't know what to do")))
  
+       ;; We got this far, and we didn't flag a full reparse.
+       ;; Clear out this change group.
+       (while change-group
+         (semantic-edits-flush-change (car change-group))
+         (setq change-group (cdr change-group)))
+ 
+       ;; Don't increment change here because an earlier loop
+       ;; created change-groups.
+       (setq parse-start nil)
+       )
+     ;; Mark that we are done with this glop
+     (semantic-parse-tree-set-up-to-date)
      ;; Return the list of tokens that changed.  The caller will
      ;; use this information to call hooks which can fix themselves.
      changed-tokens))

>>> David PONCE <david.ponce@...> seems to think that:
>[...]
>>>>Should it use 'semantic-safe' the fling signals?
>>>>
>>>>Should the condition-case change to only accept the new
>>>>'semantic-parse-changes-failed' signal?
>>>
>>>I am not sure to understand.  The patch changed the `condition-case'
>>>to only accept expected `semantic-parse-changes-failed' conditions,
>> 
>> 
>> You are right.  I misinterpreted a chunk of the patch.
>> 
>> Catch and throw might be better suited to this task.  It is roughly
>> the same since application developers would not be using our declared
>> signal anyway.
>
>Good point!
>
>[...]
>> For someone not debugging the incremental parser, we certainly want
>> problems to be mostly hidden if possible.  This makes good sense
>> too.
>
>So, WDYT of the following implementation?  If it is good for you, I
>will commit it in semantic-edit.el.
>
  [ ... ]

Looks good.  Thanks!

Eric

-- 
          Eric Ludlam:                 zappo@..., eric@...
   Home: http://www.ludlam.net            Siege: http://www.siege-engine.com
Emacs: http://cedet.sourceforge.net               GNU: http://www.gnu.org