CEDET

>>> Michael Reiher <redm@...> seems to think that:
>Hi Eric
>
>So I played around a little, trying to find a nice way to do jumping to tags 
>and back again. But it all seems a little tricky. Here is a list of problems 
>I came across.
>
>I used the following code for testing:
>
  [ ... ]
>
>First problem is that semantic-ia-fast-jump doesn't always jump where I want. 
>I'm in main.cpp at bar->bbb(). It seems first to try to find the 
>implementation of Foo::bbb() in the local buffer and jumps there, if present. 
>Fine. But if it's not there it jumps to the declaration in the header file 
>foo.h, while I would like it to jump to the implementation in the foo.cpp. 

When I tried your example, I soon ran into the problem that some of
the optimizations I've done recently completely lost the file
information from whence the analyzed tags came.

I suspect this is the cause of a majority of the issues you discussed.

If you do:

M-x semantic-adebug-analyze RET

you can snoop through the structure, and you will see that bbb is in
an unknown buffer.  That is consistent with your later conclusions to
current behavior.  I'll look into getting that fixed.

  [ ... ]
>Then I tried C-c , j / C-c , J. It shows both declaration and definition in 
>the completion buffer, however I don't see how to select the one I want. In 
>the example for instance it shows two entries called "bbb" in the completions 
>buffer. If I have bbb and simply press Return it says "[Not unique]", 
>well ... but how am I supposed to choose one or the other?? I can, using the 
>mouse, of course. But still, there are two entries with the same name, and I 
>ask myself: which one is wich? :)

It has been a long time since I exercised these functions, and I did
so almost entirely in functional programs.  I tried it again today and
found some bugs I introduced recently in the core search routines
they use.

When they do work, each time you press TAB after the first TAB you
press, it will highlight different tags.  Once it highlights the one
you want, press RET to go there.

>Regarding jumping back:
>
>Your suggestion regarding pop-global-mark seems to have a number of issues in 
>principle. For one thing marks get pushed to global-mark-ring only if the 
>last mark was in another buffer. So you can't jump back several steps within 
>the same buffer. For another, global-mark-ring gets filled with all kinds a 
>other marks, which interfere a little with jumping through symbols. So often 
>the last mark is just some random position within a buffer. If I see it right, 
>bookmark mode is what should be really used instead ...?

I'm open to suggestions on which kinds of marks to push.  The various
jump routines are all pretty simple so you are welcome to try the tags
one.

The code I found in etags that uses the tag ring looks vaguely like this:

      (let ((marker (make-marker)))
	  (set-marker marker (point))
	  (ring-insert tags-location-ring marker)
	  )

which you could insert into some functions just before the actual
jump.  If you like it let me know and I'll make it the default.

>Next I tried the suggested semantic-mru-bookmark-mode. However it doesn't 
>work here :) When I call semantic-ia-fast-jump (or C-c , j/J) and then C-x B, 
>it just says: "Semantic Bookmark ring is currently empty". Also editing 
>doesn't seem to insert anything there, should it? After a short time things 
>seem entirely broken, I get only signal errors... (see below). And sometimes 
>things kind of lock up. No matter where I call semantic-ia-fast-jump i get 
>"No context of type function to advance in". Even in the tree buffers of ECB 
>I can't select an entries anymore, but get "Wrong type argument: arrayp, nil" 
>instead.... weird.

Hmmm.  Something is indeed broken when jumping between files.  I'll
look into it.

Thanks for the backtraces too.  I think CEDET is suffering from too
much optimization this week. :)

Eric

-- 
          Eric Ludlam:                       eric@...
   Siege: http://www.siege-engine.com          Emacs: http://cedet.sourceforge.net

>>> Michael Reiher <redm@...> seems to think that:
>On Wednesday 06 February 2008 18:56, Eric M. Ludlam wrote:
>> >>> Michael Reiher <redm@...> seems to think that:
  [ ... ]
>Regarding jumping to symbols:
>
>First problem is that semantic-ia-fast-jump doesn't always jump where I want. 
>I'm in main.cpp at bar->bbb(). It seems first to try to find the 
>implementation of Foo::bbb() in the local buffer and jumps there, if present. 
>Fine. But if it's not there it jumps to the declaration in the header file 
>foo.h, while I would like it to jump to the implementation in the foo.cpp. 
>
>Generally I think it would make sense to have two commands one jumping to 
>implementations and one jumping to declarations, e.g. semantic-ia-fast-jump 
>and semantic-ia-fast-jump-declaration, depending on what I want.
>
>If semantic-ia-fast-jump can't find a symbol it somehow jumps to a random 
>place within the local buffer, while it probably should just do nothing. In 
>the example: when the cursor is over bbb at "bar->bbb" and only main.cpp is 
>opened.
>
  [ ... ]

In CEDET/CVS, I had optimized the analyzer to make it much faster, but
file location of tags got lost which caused it to jump into random
locations.  I've attempted to save file names with tags as the
analyzer runs, and now the jump routine is a bit more robust.  (Now in
CVS.)

For your specific question about going to an implementation instead of
the in class declaration.  The ia-jump command is an example that
shows how to run the analyzer, and that you can jump to the tags that
it finds.  The analyzer only rummages around in your header files, so
naturally that is what it will find.

If you ran this in the past, the analyzer used to gather in externally
defined methods, and would pick one of those instead of the in-class
prototype.  I had removed that feature to make the analyzer run
faster, cutting analyzer execution time in about half.  Restoring that
behavior is possible, but should be outside the analyzer, and in the
ia routine instead.

It is certainly possible to get that list, and your thought about
using senator's key binding for C-c , J is correct.  That routine
should do what you want.

I had trouble getting this to work on some code I have at work, and
the problem was with the brutish search path routine.  I'm still not
sure what's up with that, but it's on my todo list.  When it is
working, just press TAB alot and it will show how to distinguish
between similarly named tags.

Eric

-- 
          Eric Ludlam:                       eric@...
   Siege: http://www.siege-engine.com          Emacs: http://cedet.sourceforge.net

On Wednesday 13 February 2008 05:10, Eric M. Ludlam wrote:
>
> In CEDET/CVS, I had optimized the analyzer to make it much faster, but
> file location of tags got lost which caused it to jump into random
> locations.  I've attempted to save file names with tags as the
> analyzer runs, and now the jump routine is a bit more robust.  (Now in
> CVS.)
I tested it, also with bigger source files, and ia-jumping seems to work 
pretty well now. Thanks a lot! It seems my observation that it jumps to a 
local implementation, if present, was also a bug...it _always_ jumps to the 
header file, right?

>
> For your specific question about going to an implementation instead of
> the in class declaration.  The ia-jump command is an example that
> shows how to run the analyzer, and that you can jump to the tags that
> it finds.  The analyzer only rummages around in your header files, so
> naturally that is what it will find.
I see.

>
> If you ran this in the past, the analyzer used to gather in externally
> defined methods, and would pick one of those instead of the in-class
> prototype.  I had removed that feature to make the analyzer run
> faster, cutting analyzer execution time in about half.  Restoring that
> behavior is possible, but should be outside the analyzer, and in the
> ia routine instead.
Well, the use case is when you try to follow a code path through several 
functions. Then you are obviously only interested in the implementations. As 
there are also use cases for jumping to the declaration (e.g. in order to 
read the associated documentation), I think for the future it really makes 
sense to have two separate functions, to use depending on where you intend to 
go (at least until someone implements a jumping-follows-mind.el). As a 
workaround I think I can jump to the header file and then switch over to the 
corresponding .cpp file using an own function... yes, that'll do.

>
> It is certainly possible to get that list, and your thought about
> using senator's key binding for C-c , J is correct.  That routine
> should do what you want.
>
> I had trouble getting this to work on some code I have at work, and
> the problem was with the brutish search path routine.  I'm still not
> sure what's up with that, but it's on my todo list.  When it is
> working, just press TAB alot and it will show how to distinguish
> between similarly named tags.

Hmm, I mostly tried that because you suggested it in some other thread. 
However I think in most cases personally I'm faster with my workaround, 
mentioned above. So no need to hurry from my side :)

Greets Michael

On Tuesday 12 February 2008 21:10, Eric M. Ludlam wrote:
>
> >Regarding jumping back:
> >
> >Your suggestion regarding pop-global-mark seems to have a number of issues
> > in principle. For one thing marks get pushed to global-mark-ring only if
> > the last mark was in another buffer. So you can't jump back several steps
> > within the same buffer. For another, global-mark-ring gets filled with
> > all kinds a other marks, which interfere a little with jumping through
> > symbols. So often the last mark is just some random position within a
> > buffer. If I see it right, bookmark mode is what should be really used
> > instead ...?
>
> I'm open to suggestions on which kinds of marks to push.  The various
> jump routines are all pretty simple so you are welcome to try the tags
> one.
>
> The code I found in etags that uses the tag ring looks vaguely like this:
>
>       (let ((marker (make-marker)))
> 	  (set-marker marker (point))
> 	  (ring-insert tags-location-ring marker)
> 	  )
>
> which you could insert into some functions just before the actual
> jump.  If you like it let me know and I'll make it the default.
Hmm, I don't seem to have a tags-location-ring... either this is a GNU Emacs 
thing or my XEmacs/etags.el is just too old. However I do have push-tag-mark. 
Simply replacing push-mark by push-tag-mark in semantic-ia-fast-jump seems to 
work perfectly well! Etags has to be loaded for that though...

>
> >Next I tried the suggested semantic-mru-bookmark-mode. However it doesn't
> >work here :) When I call semantic-ia-fast-jump (or C-c , j/J) and then C-x
> > B, it just says: "Semantic Bookmark ring is currently empty". Also
> > editing doesn't seem to insert anything there, should it? After a short
> > time things seem entirely broken, I get only signal errors... (see
> > below). And sometimes things kind of lock up. No matter where I call
> > semantic-ia-fast-jump i get "No context of type function to advance in".
> > Even in the tree buffers of ECB I can't select an entries anymore, but
> > get "Wrong type argument: arrayp, nil" instead.... weird.
>
> Hmmm.  Something is indeed broken when jumping between files.  I'll
> look into it.
Should your fixes regarding jumping address these problems too? If yes, they 
didn't ... :)

Greets Michael

Hi,

  I finally had a chance to debug this.  The problem I was able to
reproduce resulted when the cursor was between tags, so there was no
tag to push into the tag-ring.  I checked in a fix for that part.

Enjoy
Eric

>>> Michael Reiher <redm@...> seems to think that:
  [ ... ]
>Next I tried the suggested semantic-mru-bookmark-mode. However it doesn't 
>work here :) When I call semantic-ia-fast-jump (or C-c , j/J) and then C-x B, 
>it just says: "Semantic Bookmark ring is currently empty". Also editing 
>doesn't seem to insert anything there, should it? After a short time things 
>seem entirely broken, I get only signal errors... (see below). And sometimes 
>things kind of lock up. No matter where I call semantic-ia-fast-jump i get 
>"No context of type function to advance in". Even in the tree buffers of ECB 
>I can't select an entries anymore, but get "Wrong type argument: arrayp, nil" 
>instead.... weird.
>
>Greets Michael
>
>
>Signal error message says: 
>idle error: "# <buffer \"main.cpp\"> - Wrong type argument: arrayp, nil"
>
>Debug 1:
>
>Debugger entered--Lisp error: (error "Object type has no properties" [object 
>semantic-bookmark-ring "Ring" (0 1 . [[object semantic-bookmark 
>"main" ("main" function (:arguments (("argc" variable (:type "int") 
>(reparse-symbol arg-sub-list) [114 123]) ("argv" variable (:pointer 2 :type 
>"char") (reparse-symbol arg-sub-list) [124 136])) :type "int") nil [105 227]) 
>nil 120 "/home/michael/Temp/semantic_test2/main.cpp" 11 edit] nil nil nil nil 
>nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil]) 0])
>  byte-code("..." [obj eieio-class-definition 0 defclass] 2)
>  eieio-oref([object semantic-bookmark-ring "Ring" (0 1 . [... nil nil nil nil 
>nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil]) 0] ring)
>  semantic-mrub-cache-flush-fcn()
>  run-hooks(semantic-mrub-cache-flush-fcn)
>  semantic-clear-toplevel-cache()
>  semantic-fetch-tags()
>  byte-code("..." [semantic-fetch-tags nil] 1)
>  semantic-idle-scheduler-refresh-tags()
>  byte-code("..." [others buffers service semantic-current-input-throw-symbol 
>b semantic-idle-scheduler-max-buffer-size nil delq mapcar #<compiled-function 
>(b) "...(7)" [b buffer-file-name] 2> buffer-list 0 buffer-size 
>semantic-idle-scheduler-refresh-tags input-pending-p throw 
>parsing-mode-buffers idle-queue working-temp-message "IDLE: execture service 
>%s..." "IDLE: execture service %s...done" parsing-other-buffers 
>--dolist-temp--52012 --dolist-temp--52013 --dolist-temp--52014 mode 
>semantic-idle-scheduler-mode semantic-debug-enabled semantic-lex-debug safe 
>major-mode semantic-idle-scheduler-verbose-flag inhibit-quit 
>semantic-idle-scheduler-queue] 8)
>  semantic-idle-core-handler()
>  byte-code("..." [match-data match-data ((store-match-data match-data)) 
>semantic-idle-core-handler] 1)
>  semantic-idle-scheduler-function()
>  apply(semantic-idle-scheduler-function nil)
>  byte-code("..." [this-command inhibit-quit quit-flag match-data itimer 
>current-itimer match-data ((store-match-data match-data)) nil 
>itimer-uses-arguments apply itimer-function itimer-function-arguments 
>last-event-time next-wakeup itimers time-elapsed] 5)
>  itimer-run-expired-timers(9.998977)
>  itimer-timer-driver(nil)
>
  [ ... ]

Hi

Unfortunately this doesn't seem to fix anything for me. When jumping and then 
calling "C-x B" I still just get "Semantic Bookmark ring is currently empty". 

Also the idle error and "lockups" are still present. However I found how to 
reproduce it. I used the example below. I start XEmacs, load main.cpp, place 
the cursor at the and of the line "bar->bbb( ccc );". Now things either break 
right away, after removing the semicolon or after readding it. Saving the 
file might play a role, I'm not sure, but that's basically it. After it broke 
I get those idle errors and I can't open files anymore, for instance.

... ah, now I think I see what you meant in your reply by "between tags, so 
there was no tag to push" ... :) However your fix didn't help.

Greets Michael


foo.h:

class Foo
{
public:
  Foo();
  ~Foo();

  aaa( int x );
  bbb( const char* y );

private:
  int i;

  void blah( int i );
};


main.cpp:

#include "foo.h"

void foo2() {

}

void foo1() {
  foo2();
}

int main(int argc, char **argv )
{
  int bbbb;
  const char* ccc = "sfas";
  long asdf;
  Foo* bar;
  foo1();
  bar->bbb( ccc );
}



On Friday 22 February 2008 01:31, Eric M. Ludlam wrote:
> Hi,
>
>   I finally had a chance to debug this.  The problem I was able to
> reproduce resulted when the cursor was between tags, so there was no
> tag to push into the tag-ring.  I checked in a fix for that part.
>
> Enjoy
> Eric
>
> >>> Michael Reiher <redm@...> seems to think that:
>
>   [ ... ]
>
> >Next I tried the suggested semantic-mru-bookmark-mode. However it doesn't
> >work here :) When I call semantic-ia-fast-jump (or C-c , j/J) and then C-x
> > B, it just says: "Semantic Bookmark ring is currently empty". Also
> > editing doesn't seem to insert anything there, should it? After a short
> > time things seem entirely broken, I get only signal errors... (see
> > below). And sometimes things kind of lock up. No matter where I call
> > semantic-ia-fast-jump i get "No context of type function to advance in".
> > Even in the tree buffers of ECB I can't select an entries anymore, but
> > get "Wrong type argument: arrayp, nil" instead.... weird.
> >
> >Greets Michael
> >
> >
> >Signal error message says:
> >idle error: "# <buffer \"main.cpp\"> - Wrong type argument: arrayp, nil"
> >
> >Debug 1:
> >
> >Debugger entered--Lisp error: (error "Object type has no properties"
> > [object semantic-bookmark-ring "Ring" (0 1 . [[object semantic-bookmark
> >"main" ("main" function (:arguments (("argc" variable (:type "int")
> >(reparse-symbol arg-sub-list) [114 123]) ("argv" variable (:pointer 2
> > :type "char") (reparse-symbol arg-sub-list) [124 136])) :type "int") nil
> > [105 227]) nil 120 "/home/michael/Temp/semantic_test2/main.cpp" 11 edit]
> > nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil
> > nil]) 0]) byte-code("..." [obj eieio-class-definition 0 defclass] 2)
> >  eieio-oref([object semantic-bookmark-ring "Ring" (0 1 . [... nil nil nil
> > nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil]) 0]
> > ring) semantic-mrub-cache-flush-fcn()
> >  run-hooks(semantic-mrub-cache-flush-fcn)
> >  semantic-clear-toplevel-cache()
> >  semantic-fetch-tags()
> >  byte-code("..." [semantic-fetch-tags nil] 1)
> >  semantic-idle-scheduler-refresh-tags()
> >  byte-code("..." [others buffers service
> > semantic-current-input-throw-symbol b
> > semantic-idle-scheduler-max-buffer-size nil delq mapcar
> > #<compiled-function (b) "...(7)" [b buffer-file-name] 2> buffer-list 0
> > buffer-size
> >semantic-idle-scheduler-refresh-tags input-pending-p throw
> >parsing-mode-buffers idle-queue working-temp-message "IDLE: execture
> > service %s..." "IDLE: execture service %s...done" parsing-other-buffers
> >--dolist-temp--52012 --dolist-temp--52013 --dolist-temp--52014 mode
> >semantic-idle-scheduler-mode semantic-debug-enabled semantic-lex-debug
> > safe major-mode semantic-idle-scheduler-verbose-flag inhibit-quit
> >semantic-idle-scheduler-queue] 8)
> >  semantic-idle-core-handler()
> >  byte-code("..." [match-data match-data ((store-match-data match-data))
> >semantic-idle-core-handler] 1)
> >  semantic-idle-scheduler-function()
> >  apply(semantic-idle-scheduler-function nil)
> >  byte-code("..." [this-command inhibit-quit quit-flag match-data itimer
> >current-itimer match-data ((store-match-data match-data)) nil
> >itimer-uses-arguments apply itimer-function itimer-function-arguments
> >last-event-time next-wakeup itimers time-elapsed] 5)
> >  itimer-run-expired-timers(9.998977)
> >  itimer-timer-driver(nil)
>
>   [ ... ]
>
> -------------------------------------------------------------------------
> This SF.net email is sponsored by: Microsoft
> Defy all challenges. Microsoft(R) Visual Studio 2008.
> http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
> _______________________________________________
> cedet-semantic mailing list
> cedet-semantic@...
> https://lists.sourceforge.net/lists/listinfo/cedet-semantic

>>> Michael Reiher <redm@...> seems to think that:
>Hi
>
>Unfortunately this doesn't seem to fix anything for me. When jumping and then 
>calling "C-x B" I still just get "Semantic Bookmark ring is currently empty". 

Hi,

  This is because the ring is empty. :) The ia-fast-jump command
doesn't explicitly push a semantic bookmark.  I changed the bookmark
code to add advice to 'push-mark' instead of `set-mark-command'.  So
long as semantic-ia-fast-jump still has the `push-mark' in your
version, this should solve that problem.


>Also the idle error and "lockups" are still present. However I found how to 
>reproduce it. I used the example below. I start XEmacs, load main.cpp, place 
>the cursor at the and of the line "bar->bbb( ccc );". Now things either break 
>right away, after removing the semicolon or after readding it. Saving the 
>file might play a role, I'm not sure, but that's basically it. After it broke 
>I get those idle errors and I can't open files anymore, for instance.

I had not realized you were using XEmacs.  Not that I know how that
might make things different either.  While debugging some of your
issues I've seen idle errors which I've fixed along the way, but I can
no longer reproduce this one.

Next time the message comes up, you might be able to get a stack trace
by doing this:

M-: (semantic-idle-summary-current-symbol-info) RET

Good Luck
Eric

-- 
          Eric Ludlam:                       eric@...
   Siege: http://www.siege-engine.com          Emacs: http://cedet.sourceforge.net

On Sunday 24 February 2008 16:14, Eric M. Ludlam wrote:
> >>> Michael Reiher <redm@...> seems to think that:
> >
> >Hi
> >
> >Unfortunately this doesn't seem to fix anything for me. When jumping and
> > then calling "C-x B" I still just get "Semantic Bookmark ring is
> > currently empty".
>
> Hi,
>
>   This is because the ring is empty. :) The ia-fast-jump command
> doesn't explicitly push a semantic bookmark.  I changed the bookmark
Ah, I somehow thought it was supposed to do that ...

> code to add advice to 'push-mark' instead of `set-mark-command'.  So
> long as semantic-ia-fast-jump still has the `push-mark' in your
> version, this should solve that problem.
>
Hmm, somehow the bookmark ring is still empty after calling push-mark... C-h f 
says that push-mark is adviced, but it doesn't seem to call 
semantic-mrub-push. ... I tracked it down to the line

  (when (and semantic-mru-bookmark-mode (interactive-p))

in the defadvice. Replacing "(interactive-p)" with "t" (or removing the line 
all together) makes it insert something into the bookmark ring. Not sure what 
I'm doing here though :)

However then calling C-x B gives an error. But maybe this is simply related to 
the other issue.

  # bind (standard-output stack-trace-on-signal debug-on-signal 
stack-trace-on-error debug-on-error)
  signal(wrong-type-argument ((or object-p class-p) nil))
  # bind (field obj)
  eieio-oref(nil :object-name)
  # bind (assoclist list field)
  object-assoc-list(:object-name ([object semantic-bookmark "main" ("main" 
function ... nil #<extent [64, 194) semantic 0x8e352e0 in buffer main.cpp>) 
nil 103 "/home/michael/Temp/semantic_test3/main.cpp" 1 mark] nil nil nil nil 
nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil))
  # bind (ans first elts prompt)
  semantic-mrub-completing-read("Switch to tag")
  (list (semantic-mrub-completing-read "Switch to tag"))
  call-interactively(semantic-mrub-switch-tags)
  # (condition-case ... . error)
  # (catch top-level ...)


> >Also the idle error and "lockups" are still present. However I found how
> > to reproduce it. I used the example below. I start XEmacs, load main.cpp,
> > place the cursor at the and of the line "bar->bbb( ccc );". Now things
> > either break right away, after removing the semicolon or after readding
> > it. Saving the file might play a role, I'm not sure, but that's basically
> > it. After it broke I get those idle errors and I can't open files
> > anymore, for instance.
>
> I had not realized you were using XEmacs.  Not that I know how that
> might make things different either.  While debugging some of your
> issues I've seen idle errors which I've fixed along the way, but I can
> no longer reproduce this one.
>
> Next time the message comes up, you might be able to get a stack trace
> by doing this:
>
> M-: (semantic-idle-summary-current-symbol-info) RET
When I'm over "foo1();" (in main()) I get:

("foo1" function (:type "void") (:filename 
"/home/michael/Temp/semantic_test3/main.cpp") #<extent [37, 62) semantic 
0x8677c64 in buffer main.cpp>)

Otherwise I get just "nil", e.g. over "bar" or "bbb" in the line 
"bar->bbb( ccc );".


For the idle error, I get the following stack trace: [Trace 1] (see below).

Now that I try it, it seems the idle error (or the state of brokenness for 
that matter) is easier to trigger when using ECB ([Trace 1]). But I was able 
to trigger it also without ECB being loaded ([Trace 3]).

There are also other weird things going on, when bookmark mode is enabled... 
E.g. at some point I can't select text in non-source buffers anymore (Args 
out of range: #<buffer " *Message-Log*">, 0, 0) ... I can't open files 
anymore [Trace 4] ... Even when things seems normal and I turn on 
stack-trace-on-signal I get quite a few of them. Are these all errors, or is 
this normal, e.g. [Trace 2]?


Another note: I just installed the GNU Emacs (21.4a), and all this happens the 
same here. So it's not XEmacs specific.

Hope that helps a bit ...

Greets Michael


[Trace 1]:

  # bind (standard-output stack-trace-on-signal debug-on-signal 
stack-trace-on-error debug-on-error class)
  eieiomt-next(nil)
  # bind (lambdas mclass class key method)
  eieiomt-method-list(semantic-mrub-preflush 0 nil)
  # bind (newargs mclass lambdas tlambdas keys eieio-generic-call-methodname 
eieio-generic-call-arglst firstarg primarymethodlist args method)
  eieio-generic-call(semantic-mrub-preflush (nil))
  # bind (local-args)
  semantic-mrub-preflush(nil)
  # bind (--dolist-temp--52026 e elts buf)
  semantic-mrub-cache-flush-fcn()
  run-hooks(semantic-mrub-cache-flush-fcn)
  semantic-clear-toplevel-cache()
  # bind (semantic-unmatched-syntax-cache 
semantic-unmatched-syntax-cache-check semantic-parser-warnings res 
semantic-lex-block-streams gc-cons-threshold)
  semantic-fetch-tags()
  # (unwind-protect ...)
  # (unwind-protect ...)
  byte-code("..." [semantic-fetch-tags nil] 1)
  # (catch idle-scheduler ...)
  # bind (semantic-flex-unterminated-syntax-end-function 
semantic-lex-unterminated-syntax-end-function)
  # (unwind-protect ...)
  # bind (lexically-safe working-status-percentage-type 
working-status-dynamic-type working-use-echo-area-p inhibit-quit 
semantic-working-type)
  semantic-idle-scheduler-refresh-tags()
  # (unwind-protect ...)
  # bind (mode safe others buffers inhibit-quit)
  byte-code("..." [others buffers service semantic-current-input-throw-symbol 
b semantic-idle-scheduler-max-buffer-size nil delq mapcar #<compiled-function 
(b) "...(7)" [b buffer-file-name] 2> buffer-list 0 buffer-size 
semantic-idle-scheduler-refresh-tags input-pending-p throw 
parsing-mode-buffers idle-queue working-temp-message "IDLE: execture service 
%s..." "IDLE: execture service %s...done" parsing-other-buffers 
--dolist-temp--52013 --dolist-temp--52014 --dolist-temp--52015 mode 
semantic-idle-scheduler-mode semantic-debug-enabled semantic-lex-debug safe 
major-mode semantic-idle-scheduler-verbose-flag inhibit-quit 
semantic-idle-scheduler-queue] 8)
  # (catch idle-timer ...)
  # bind (semantic-current-input-throw-symbol)
  semantic-idle-core-handler()
  # (unwind-protect ...)
  # bind (match-data)
  byte-code("..." [match-data match-data ((store-match-data match-data)) 
semantic-idle-core-handler] 1)
  # (condition-case ... . ((error (byte-code "ÁÂÃÄpÅ !#\"ˆÆ‡" ... 7))))
  # (unwind-protect ...)
  semantic-idle-scheduler-function()
  apply(semantic-idle-scheduler-function nil)
  # bind (time-elapsed itimers itimer next-wakeup last-event-time this-command 
inhibit-quit quit-flag current-itimer)
  # (unwind-protect ...)
  # bind (match-data)
  byte-code("..." [this-command inhibit-quit quit-flag match-data itimer 
current-itimer match-data ((store-match-data match-data)) nil 
itimer-uses-arguments apply itimer-function itimer-function-arguments 
last-event-time next-wakeup itimers time-elapsed] 5)
  # (condition-case ... . ((error (byte-code "ÂÃÄ	!Å !#‡" ... 5)) (quit 
(byte-code "ÁÂà !\"‡" ... 4))))
  # (unwind-protect ...)
  # bind (itimers itimer next-wakeup idle-time last-event-time 
recorded-run-time inhibit-quit time-elapsed)
  itimer-run-expired-timers(0.003969)
  # bind (sleep elapsed now itimer-inside-driver inhibit-quit ignored)
  itimer-timer-driver(nil)
  dispatch-event(#<timeout-event nil>)
  # bind (event)
  byte-code("..." [id event next-event eval-event-p event-function 
internal-make-dialog-box-exit event-object throw --cl-block-nil-- (nil) 
dispatch-event] 3)
  # (catch --cl-block-nil-- ...)
  # bind (id sym)
  byte-code("..." [thunk frames id sym eval gensym lambda (did) when eq quote 
(did) mapc (quote enable-frame) (enqueue-eval-event (quote 
internal-make-dialog-box-exit) did) remove-hook (quote 
delete-dialog-box-hook) framep add-hook delete-frame-hook 
delete-dialog-box-hook disable-frame --cl-block-nil-- (byte-code "Â  
Ã	!«•Ä	!Åa«ŽÆ	! a«‡ÇÈÉ\"ˆª„Ê	!ˆ)ª\\" [id event next-event eval-event-p 
event-function internal-make-dialog-box-exit event-object throw 
--cl-block-nil-- ... dispatch-event] 3)] 11)
  # (catch internal-dialog-box-finish ...)
  # bind (frames thunk)
  dialog-box-modal-loop((make-dialog-box-internal (quote question) (quote 
(:title "ECB - Tip of the day" :question "You can quickly toggle auto. 
expanding of the ECB-methods-buffer with 
`ecb-toggle-auto-expand-tag-tree'." :buttons ...))))
  # bind (cl-modal)
  # (unwind-protect ...)
  # bind (--letf-save--60171 --letf-bound--60172 cl-keys type)
  make-dialog-box(question :title "ECB - Tip of the day" :modal t :question 
"You can quickly toggle auto. expanding of the ECB-methods-buffer with 
`ecb-toggle-auto-expand-tag-tree'." :buttons (["Close" (identity nil) t]))
  # bind (button title button-text title-text message-str)
  ecb-message-box("You can quickly toggle auto. expanding of the 
ECB-methods-buffer with `ecb-toggle-auto-expand-tag-tree'." "Tip of the day" 
"Close")
  # bind (tip cursor)
  ecb-show-tip-of-the-day()
  # (condition-case ... . ((error)))
  # bind (stack-trace-on-error)
  ecb-activate--impl()
  ecb-activate-internal()
  # bind (new-state arg)
  ecb-minor-mode(1)
  ecb-activate()
  ecb-auto-activate-hook()
  run-hooks(ecb-auto-activate-hook)
  # bind (error-data)
  normal-top-level()
  # (condition-case ... . error)
  # (catch top-level ...)



[Trace 2]:

  # bind (standard-output stack-trace-on-signal debug-on-signal 
stack-trace-on-error debug-on-error)
  byte-code("..." [obj eieio-class-definition 0 defclass] 2)
  # (condition-case ... . ((error)))
  # bind (field obj)
  eieio-oref([object semantic-analyze-context "context" (166 . 170) (("foo1" 
function ... ... #<extent [37, 62) semantic 0x8677c64 in buffer main.cpp>)) 
(function variable) nil [object semantic-scope-cache "Cache" [object 
semanticdb-table "main.cpp" ... c++-mode ... t nil ... ... "main.cpp" 597 
nil] ("main" function ... nil #<extent [64, 194) semantic 0x8677b4c in buffer 
main.cpp>) nil nil nil nil (... ... ... ... ... ...)] #<buffer 
"main.cpp">] :prefix)
  # bind (context)
  semantic-analyze-context([object semantic-analyze-context "context" (166 . 
170) (("foo1" function ... ... #<extent [37, 62) semantic 0x8677c64 in buffer 
main.cpp>)) (function variable) nil [object semantic-scope-cache 
"Cache" [object semanticdb-table "main.cpp" ... c++-mode ... t nil ... ... 
"main.cpp" 597 nil] ("main" function ... nil #<extent [64, 194) semantic 
0x8677b4c in buffer main.cpp>) nil nil nil nil (... ... ... ... ... ...)] 
#<buffer "main.cpp">])
  apply(semantic-analyze-context [object semantic-analyze-context 
"context" (166 . 170) (("foo1" function ... ... #<extent [37, 62) semantic 
0x8677c64 in buffer main.cpp>)) (function variable) nil [object 
semantic-scope-cache "Cache" [object semanticdb-table "main.cpp" ... 
c++-mode ... t nil ... ... "main.cpp" 597 nil] ("main" function ... nil 
#<extent [64, 194) semantic 0x8677b4c in buffer main.cpp>) nil nil nil nil 
(... ... ... ... ... ...)] #<buffer "main.cpp">])
  # bind (eieio-generic-call-next-method-list has-return-val 
eieio-generic-call-key scoped-class rval lastval rvalever found newargs 
mclass lambdas tlambdas keys eieio-generic-call-methodname 
eieio-generic-call-arglst firstarg primarymethodlist args method)
  eieio-generic-call(semantic-analyze-interesting-tag ([object 
semantic-analyze-context "context" (166 . 170) (...) (function variable) nil 
[object semantic-scope-cache "Cache" ... ... nil nil nil nil ...] #<buffer 
"main.cpp">]))
  # bind (local-args)
  semantic-analyze-interesting-tag([object semantic-analyze-context 
"context" (166 . 170) (("foo1" function ... ... #<extent [37, 62) semantic 
0x8677c64 in buffer main.cpp>)) (function variable) nil [object 
semantic-scope-cache "Cache" [object semanticdb-table "main.cpp" ... 
c++-mode ... t nil ... ... "main.cpp" 597 nil] ("main" function ... nil 
#<extent [64, 194) semantic 0x8677b4c in buffer main.cpp>) nil nil nil nil 
(... ... ... ... ... ...)] #<buffer "main.cpp">])
  # bind (analysis)
  semantic-idle-summary-current-symbol-info-context()
  # (unwind-protect ...)
  # bind (semanticdb-find-default-throttle)
  semantic-idle-summary-current-symbol-info-default()
  # bind (override)
  semantic-idle-summary-current-symbol-info()
  semantic-idle-summary-idle-function()
  # bind (--dolist-temp--52014 service)
  # (unwind-protect ...)
  # bind (mode safe others buffers inhibit-quit)
  byte-code("..." [others buffers service semantic-current-input-throw-symbol 
b semantic-idle-scheduler-max-buffer-size nil delq mapcar #<compiled-function 
(b) "...(7)" [b buffer-file-name] 2> buffer-list 0 buffer-size 
semantic-idle-scheduler-refresh-tags input-pending-p throw 
parsing-mode-buffers idle-queue working-temp-message "IDLE: execture service 
%s..." "IDLE: execture service %s...done" parsing-other-buffers 
--dolist-temp--52013 --dolist-temp--52014 --dolist-temp--52015 mode 
semantic-idle-scheduler-mode semantic-debug-enabled semantic-lex-debug safe 
major-mode semantic-idle-scheduler-verbose-flag inhibit-quit 
semantic-idle-scheduler-queue] 8)
  # (catch idle-timer ...)
  # bind (semantic-current-input-throw-symbol)
  semantic-idle-core-handler()
  # (unwind-protect ...)
  # bind (match-data)
  byte-code("..." [match-data match-data ((store-match-data match-data)) 
semantic-idle-core-handler] 1)
  # (condition-case ... . ((error (byte-code "ÁÂÃÄp!#\"Æ" ... 7))))
  # (unwind-protect ...)
  semantic-idle-scheduler-function()
  apply(semantic-idle-scheduler-function nil)
  # bind (time-elapsed itimers itimer next-wakeup last-event-time this-command 
inhibit-quit quit-flag current-itimer)
  # (unwind-protect ...)
  # bind (match-data)
  byte-code("..." [this-command inhibit-quit quit-flag match-data itimer 
current-itimer match-data ((store-match-data match-data)) nil 
itimer-uses-arguments apply itimer-function itimer-function-arguments 
last-event-time next-wakeup itimers time-elapsed] 5)
  # (condition-case ... . ((error (byte-code "ÂÃÄ       !!#" ... 5)) (quit 
(byte-code "ÁÂ!\"" ... 4))))
  # (unwind-protect ...)
  # bind (itimers itimer next-wakeup idle-time last-event-time 
recorded-run-time inhibit-quit time-elapsed)
  itimer-run-expired-timers(0.160639)
  # bind (sleep elapsed now itimer-inside-driver inhibit-quit ignored)
  itimer-timer-driver(nil)
  # (condition-case ... . error)
  # (catch top-level ...)


[Trace 3]:

  # bind (standard-output stack-trace-on-signal debug-on-signal 
stack-trace-on-error debug-on-error class)
  eieiomt-next(nil)
  # bind (lambdas mclass class key method)
  eieiomt-method-list(semantic-mrub-preflush 0 nil)
  # bind (newargs mclass lambdas tlambdas keys eieio-generic-call-methodname 
eieio-generic-call-arglst firstarg primarymethodlist args method)
  eieio-generic-call(semantic-mrub-preflush (nil))
  # bind (local-args)
  semantic-mrub-preflush(nil)
  # bind (--dolist-temp--52026 e elts buf)
  semantic-mrub-cache-flush-fcn()
  run-hooks(semantic-mrub-cache-flush-fcn)
  semantic-clear-toplevel-cache()
  # bind (semantic-unmatched-syntax-cache 
semantic-unmatched-syntax-cache-check semantic-parser-warnings res 
semantic-lex-block-streams gc-cons-threshold)
  semantic-fetch-tags()
  # (unwind-protect ...)
  # (unwind-protect ...)
  byte-code("..." [semantic-fetch-tags nil] 1)
  # (catch idle-scheduler ...)
  # bind (semantic-flex-unterminated-syntax-end-function 
semantic-lex-unterminated-syntax-end-function)
  # (unwind-protect ...)
  # bind (lexically-safe working-status-percentage-type 
working-status-dynamic-type working-use-echo-area-p inhibit-quit 
semantic-working-type)
  semantic-idle-scheduler-refresh-tags()
  # (unwind-protect ...)
  # bind (mode safe others buffers inhibit-quit)
  byte-code("..." [others buffers service semantic-current-input-throw-symbol 
b semantic-idle-scheduler-max-buffer-size nil delq mapcar #<compiled-function 
(b) "...(7)" [b buffer-file-name] 2> buffer-list 0 buffer-size 
semantic-idle-scheduler-refresh-tags input-pending-p throw 
parsing-mode-buffers idle-queue working-temp-message "IDLE: execture service 
%s..." "IDLE: execture service %s...done" parsing-other-buffers 
--dolist-temp--52013 --dolist-temp--52014 --dolist-temp--52015 mode 
semantic-idle-scheduler-mode semantic-debug-enabled semantic-lex-debug safe 
major-mode semantic-idle-scheduler-verbose-flag inhibit-quit 
semantic-idle-scheduler-queue] 8)
  # (catch idle-timer ...)
  # bind (semantic-current-input-throw-symbol)
  semantic-idle-core-handler()
  # (unwind-protect ...)
  # bind (match-data)
  byte-code("..." [match-data match-data ((store-match-data match-data)) 
semantic-idle-core-handler] 1)
  # (condition-case ... . ((error (byte-code "ÁÂÃÄp!#\"Æ" ... 7))))
  # (unwind-protect ...)
  semantic-idle-scheduler-function()
  apply(semantic-idle-scheduler-function nil)
  # bind (time-elapsed itimers itimer next-wakeup last-event-time this-command 
inhibit-quit quit-flag current-itimer)
  # (unwind-protect ...)
  # bind (match-data)
  byte-code("..." [this-command inhibit-quit quit-flag match-data itimer 
current-itimer match-data ((store-match-data match-data)) nil 
itimer-uses-arguments apply itimer-function itimer-function-arguments 
last-event-time next-wakeup itimers time-elapsed] 5)
  # (condition-case ... . ((error (byte-code "ÂÃÄ       !!#" ... 5)) (quit 
(byte-code "ÁÂ!\"" ... 4))))
  # (unwind-protect ...)
  # bind (itimers itimer next-wakeup idle-time last-event-time 
recorded-run-time inhibit-quit time-elapsed)
  itimer-run-expired-timers(0.104025)
  # bind (sleep elapsed now itimer-inside-driver inhibit-quit ignored)
  itimer-timer-driver(nil)
  # (condition-case ... . error)
  # (catch top-level ...)


[Trace 4]:

  # bind (standard-output stack-trace-on-signal debug-on-signal 
stack-trace-on-error debug-on-error)
  signal(wrong-type-argument (arrayp nil))
  byte-code("..." [buf data kill-buffer signal] 3)
  # bind (data)
  # (unwind-protect ...)
  # bind (error number truename buf rawfile nowarn filename)
  find-file-noselect("~/Temp/semantic_test2/foo.cpp")
  # bind (codesys filename)
  find-file("~/Temp/semantic_test2/foo.cpp" nil)
  # bind (command-debug-status)
  call-interactively(find-file)
  # (condition-case ... . error)
  # (catch top-level ...)

>>> Michael Reiher <redm@...> seems to think that:
  [ ... ]
>> code to add advice to 'push-mark' instead of `set-mark-command'.  So
>> long as semantic-ia-fast-jump still has the `push-mark' in your
>> version, this should solve that problem.
>>
>Hmm, somehow the bookmark ring is still empty after calling push-mark... C-h f 
>says that push-mark is adviced, but it doesn't seem to call 
>semantic-mrub-push. ... I tracked it down to the line
>
>  (when (and semantic-mru-bookmark-mode (interactive-p))
>
>in the defadvice. Replacing "(interactive-p)" with "t" (or removing the line 
>all together) makes it insert something into the bookmark ring. Not sure what 
>I'm doing here though :)

That's odd.  While I agree with your assessment, I had breakpoints set
that showed I was getting past that line.  Ill take out the
interactive check.  I will make the bookmarking happen much more often.

>However then calling C-x B gives an error. But maybe this is simply related to 
>the other issue.
>
>  # bind (standard-output stack-trace-on-signal debug-on-signal 
>stack-trace-on-error debug-on-error)
>  signal(wrong-type-argument ((or object-p class-p) nil))
>  # bind (field obj)
>  eieio-oref(nil :object-name)
>  # bind (assoclist list field)
>  object-assoc-list(:object-name ([object semantic-bookmark "main" ("main" 

This stack, along with others below, shows that a 'nil' somehow got
into the bookmark ring.  You can use:

M-x semantic-adebug-mrub RET

and expand the ring to verify that somehow a nil got into the ring.


>> >Also the idle error and "lockups" are still present. However I found how
>> > to reproduce it. I used the example below. I start XEmacs, load main.cpp,
>> > place the cursor at the and of the line "bar->bbb( ccc );". Now things
>> > either break right away, after removing the semicolon or after readding
>> > it. Saving the file might play a role, I'm not sure, but that's basically
>> > it. After it broke I get those idle errors and I can't open files
>> > anymore, for instance.
>>
>> I had not realized you were using XEmacs.  Not that I know how that
>> might make things different either.  While debugging some of your
>> issues I've seen idle errors which I've fixed along the way, but I can
>> no longer reproduce this one.
>>
>> Next time the message comes up, you might be able to get a stack trace
>> by doing this:
>>
>> M-: (semantic-idle-summary-current-symbol-info) RET
>When I'm over "foo1();" (in main()) I get:
>
>("foo1" function (:type "void") (:filename 
>"/home/michael/Temp/semantic_test3/main.cpp") #<extent [37, 62) semantic 
>0x8677c64 in buffer main.cpp>)
>
>Otherwise I get just "nil", e.g. over "bar" or "bbb" in the line 
>"bar->bbb( ccc );".

Well, I guess that's good.

>For the idle error, I get the following stack trace: [Trace 1] (see below).

This is a nil in the bookmark ring again.

>Now that I try it, it seems the idle error (or the state of brokenness for 
>that matter) is easier to trigger when using ECB ([Trace 1]). But I was able 
>to trigger it also without ECB being loaded ([Trace 3]).

Also a nil in the bookmark ring.

>There are also other weird things going on, when bookmark mode is enabled... 
>E.g. at some point I can't select text in non-source buffers anymore (Args 
>out of range: #<buffer " *Message-Log*">, 0, 0) ... I can't open files 
>anymore [Trace 4] ... Even when things seems normal and I turn on 

Trace 4 seems to be missing something.  Must be a hook with an in-line
lambda expression.  The only one I would suspect is the imenu setup
hook in semantic-load.el.  If you don't use imenu, you could comment
that out and see if that makes things more stable.

>stack-trace-on-signal I get quite a few of them. Are these all errors, or is 
>this normal, e.g. [Trace 2]?


I will endeavor to debug this some more to see what I can come up
with.  I'm particularly confused how nil got into the ring.

Eric

-- 
          Eric Ludlam:                       eric@...
   Siege: http://www.siege-engine.com          Emacs: http://cedet.sourceforge.net

On Monday 25 February 2008 22:27, Eric M. Ludlam wrote:
> >Hmm, somehow the bookmark ring is still empty after calling push-mark...
> > C-h f says that push-mark is adviced, but it doesn't seem to call
> >semantic-mrub-push. ... I tracked it down to the line
> >
> >  (when (and semantic-mru-bookmark-mode (interactive-p))
> >
> >in the defadvice. Replacing "(interactive-p)" with "t" (or removing the
> > line all together) makes it insert something into the bookmark ring. Not
> > sure what I'm doing here though :)
>
> That's odd.  While I agree with your assessment, I had breakpoints set
> that showed I was getting past that line.  Ill take out the
> interactive check.  I will make the bookmarking happen much more often.
>
If I call push-mark manually like this:

(define-key global-map [(alt m)] 
    '(lambda () 
        (interactive) (push-mark)))

(interactive-p) in the defadvice seems indeed to evaluate to false. No idea 
though how things should play together here ...

> > [...]
>
> This stack, along with others below, shows that a 'nil' somehow got
> into the bookmark ring.  You can use:
>
> M-x semantic-adebug-mrub RET
>
> and expand the ring to verify that somehow a nil got into the ring.
>
To narrow things down a bit I call semantic-mrub-push directly like this:

(define-key global-map [(alt p)]
	'(lambda () 
		 (interactive) (semantic-mrub-push semantic-mru-bookmark-ring
																			 (point) 'mark)))
So I open main.cpp, go to foo1 in line "foo1();", start bookmark mode. The 
ring looks like this:

 ] Name: Ring
 ] Class: #'semantic-bookmark-ring

or

[object semantic-bookmark-ring "Ring" (0 0 . [nil nil nil nil nil nil nil nil 
nil nil nil nil nil nil nil nil nil nil nil nil]) 0]

Then I call semantic-mrub-push and the bookmark ring looks like this:

 ] Name: Ring
 ] Class: #'semantic-bookmark-ring
 ] :ring #<RING: 20>
   } #<semantic-bookmark main>
       ] Name: main
       ] Class: #'semantic-bookmark
       ] :tag main : int
         | Name: main
         | Class: 'function
         | Position: 64 -> 194 in main.cpp <live tag>
         | Position Data: #<extent>
             # detachable : 't
             # end-open : 't
             # semantic : main : int
         | Attributes:
           # :arguments : #<TAG LIST: 2 entries>
             * argc : int
             * argv : char
           # :type : int
         | Properties:
       ] parent 'nil
       ] offset 104
       ] filename /home/michael/Temp/semantic_test3/main.cpp
       ] frequency 1
       ] reason #'mark
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
   } 'nil
 ] current-index 0

or 

[object semantic-bookmark-ring "Ring" (0 1 . [[object semantic-bookmark 
"main" ("main" function (:arguments (("argc" variable (:type "int") 
(reparse-symbol arg-sub-list) #<extent [73, 82) semantic 0x8677c2c in buffer 
main.cpp>) ("argv" variable (:pointer 2 :type "char") (reparse-symbol 
arg-sub-list) #<extent [83, 96) semantic 0x8677c10 in buffer 
main.cpp>)) :type "int") nil #<extent [64, 194) semantic 0x8677c48 in buffer 
main.cpp>) nil 104 "/home/michael/Temp/semantic_test3/main.cpp" 1 mark] nil 
nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil]) 0]


Seems something goes out of bounds, accessing elements it shouldn't ...

> >> [...]
> >>
> >> Next time the message comes up, you might be able to get a stack trace
> >> by doing this:
> >>
> >> M-: (semantic-idle-summary-current-symbol-info) RET
> >
> >When I'm over "foo1();" (in main()) I get:
> >
> >("foo1" function (:type "void") (:filename
> >"/home/michael/Temp/semantic_test3/main.cpp") #<extent [37, 62) semantic
> >0x8677c64 in buffer main.cpp>)
> >
> >Otherwise I get just "nil", e.g. over "bar" or "bbb" in the line
> >"bar->bbb( ccc );".
>
> Well, I guess that's good.
>
Hmm, under normal conditions, i.e. without bookmark mode, over "bar" I get:

("bar" variable (:pointer 1 :type ("Foo" type (:type "class") nil nil)) 
(reparse-symbol bovine-inner-scope :filename 
"/home/michael/Temp/semantic_test3/main.cpp") [154 163])

> >stack-trace-on-signal I get quite a few of them. Are these all errors, or
> > is this normal, e.g. [Trace 2]?
>
> I will endeavor to debug this some more to see what I can come up
> with.  I'm particularly confused how nil got into the ring.
>
Cool. One thing to note is that all errors, except the one on C-xB, happen 
also with an empty bookmark ring.

Greets Michael

>>> Michael Reiher <redm@...> seems to think that:
>On Monday 25 February 2008 22:27, Eric M. Ludlam wrote:
>> >Hmm, somehow the bookmark ring is still empty after calling push-mark...
>> > C-h f says that push-mark is adviced, but it doesn't seem to call
>> >semantic-mrub-push. ... I tracked it down to the line
>> >
>> >  (when (and semantic-mru-bookmark-mode (interactive-p))
>> >
>> >in the defadvice. Replacing "(interactive-p)" with "t" (or removing the
>> > line all together) makes it insert something into the bookmark ring. Not
>> > sure what I'm doing here though :)
>>
>> That's odd.  While I agree with your assessment, I had breakpoints set
>> that showed I was getting past that line.  Ill take out the
>> interactive check.  I will make the bookmarking happen much more often.
>>
>If I call push-mark manually like this:
>
>(define-key global-map [(alt m)] 
>    '(lambda () 
>        (interactive) (push-mark)))
>
>(interactive-p) in the defadvice seems indeed to evaluate to false. No idea 
>though how things should play together here ...
>
>> > [...]
>>
>> This stack, along with others below, shows that a 'nil' somehow got
>> into the bookmark ring.  You can use:
>>
>> M-x semantic-adebug-mrub RET
>>
>> and expand the ring to verify that somehow a nil got into the ring.
>>
>To narrow things down a bit I call semantic-mrub-push directly like this:
>
>(define-key global-map [(alt p)]
>	'(lambda () 
>		 (interactive) (semantic-mrub-push semantic-mru-bookmark-ring
>																			 (point) 'mark)))
>So I open main.cpp, go to foo1 in line "foo1();", start bookmark mode. The 
>ring looks like this:
>
> ] Name: Ring
> ] Class: #'semantic-bookmark-ring
>
>or
>
>[object semantic-bookmark-ring "Ring" (0 0 . [nil nil nil nil nil nil nil nil 
>nil nil nil nil nil nil nil nil nil nil nil nil]) 0]
>
  [ ... ]

Hi,

  I have an older XEmacs (21.4) and it doesn't have the
`ring-elements' function.  I went through and eliminated the use of
this function from semantic-mru-bookmark.  My suspicion is that if
your XEmacs does have a ring-elements function, it is including the
list of nil, otherwise the adebug fcn would not be listing them.

  I checked in both a new version of semantic-mru-bookmark, and
semantic-adebug which should use the ring in a better way that works
for both our Emacsen.

  Since an active bookmark system hooks into the parser to keep it's
tag list safe, it is likely it was throwing errors at inopportune
times and causes other issues.

Eric

-- 
          Eric Ludlam:                       eric@...
   Siege: http://www.siege-engine.com          Emacs: http://cedet.sourceforge.net

On Tuesday 26 February 2008 02:45, Eric M. Ludlam wrote:
>
> Hi,
>
>   I have an older XEmacs (21.4) and it doesn't have the
> `ring-elements' function.  I went through and eliminated the use of
> this function from semantic-mru-bookmark.  My suspicion is that if
> your XEmacs does have a ring-elements function, it is including the
> list of nil, otherwise the adebug fcn would not be listing them.
>
Yes I have such a function, the doc is not exactly verbose though...

`ring-elements' is a compiled Lisp function
  -- loaded from "ring"
(ring-elements RING)

Documentation:
Return a list of the lements of RING.


>   I checked in both a new version of semantic-mru-bookmark, and
> semantic-adebug which should use the ring in a better way that works
> for both our Emacsen.
>
Ahh brilliant! Things are a lot more stable now!

>   Since an active bookmark system hooks into the parser to keep it's
> tag list safe, it is likely it was throwing errors at inopportune
> times and causes other issues.
>
Yes sounds reasonable. I have another issue still (hell, I must be annoying:) 
I can't select text in other, non source, buffers like *scratch* (or simply 
do a push-mark):

Args out of range: #<buffer "*scratch*">, 0, 0

Backtrace see below. The positions 5 to 7 are the characters I tried to select 
in the scratch buffer.


When jumping to a tag using C-xB XEmacs complains about get-extent-property 
being void. So in common/pulse.el:

(defalias 'pulse-overlay-get 'get-extent-property)

should probably be:

(defalias 'pulse-overlay-get 'extent-property)

Seems just a typo, at least I couldn't find any reference to 
get-extent-property on the net...

Greets Michael



  # bind (standard-output stack-trace-on-signal debug-on-signal 
stack-trace-on-error debug-on-error)
  map-extents(#<compiled-function (ex junk) "...(8)" [ex function *result* 
nil] 2> nil 0 0 nil nil nil nil)
  # bind (*result* value property flags to from buffer-or-string predicate 
function)
  mapcar-extents(identity nil nil 0 0 nil nil nil)
  # bind (value property flags to from buffer-or-string)
  extent-list(nil 0 0)
  # bind (pos)
  semantic-overlays-at(0)
  # bind (os ol)
  # (unwind-protect ...)
  # bind (buffer start)
  semantic-find-tag-by-overlay-prev(7)
  # bind (tag point)
  semantic-mrub-find-nearby-tag(7)
  # bind (ring reason point sbr)
  semantic-bookmark-ring([object semantic-bookmark-ring "Ring" (0 4 . 
[... ... ... ... nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil 
nil]) 0] 7 mark)
  apply(semantic-bookmark-ring ([object semantic-bookmark-ring "Ring" (0 
4 . ...) 0] 7 mark))
  # bind (eieio-generic-call-next-method-list has-return-val 
eieio-generic-call-key scoped-class rval lastval rvalever found newargs 
mclass lambdas tlambdas keys eieio-generic-call-methodname 
eieio-generic-call-arglst firstarg primarymethodlist args method)
  eieio-generic-call(semantic-mrub-push ([object semantic-bookmark-ring 
"Ring" (0 4 . ...) 0] 7 mark))
  # bind (local-args)
  semantic-mrub-push([object semantic-bookmark-ring "Ring" (0 4 . 
[... ... ... ... nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil 
nil]) 0] 7 mark)
  (progn (semantic-mrub-push semantic-mru-bookmark-ring (point) (quote mark)) 
(setq ad-return-value (ad-Orig-push-mark location nomsg activate-region 
buffer)))
  # bind (ad-return-value)
  (let (ad-return-value) (progn (semantic-mrub-push 
semantic-mru-bookmark-ring ... ...) (setq ad-return-value ...)) 
ad-return-value)
  # bind (buffer activate-region nomsg location)
  push-mark(5)
  # bind (start end type pair)
  default-mouse-track-maybe-own-selection((5 . 7) PRIMARY)
  # bind (result click-count event)
  default-mouse-track-drag-up-hook(#<buttonup-event button1up> 1)
  apply(default-mouse-track-drag-up-hook #<buttonup-event button1up> 1)
  # bind (retval value buffer overridden args event override hook)
  mouse-track-run-hook(mouse-track-drag-up-hook nil #<buttonup-event 
button1up> 1)
  # (unwind-protect ...)
  # bind (mouse-down xthresh ythresh orig-x orig-y buffer mouse-grabbed-buffer 
mouse-moved overriding-hooks event)
  mouse-track(#<buttonup-event button1up>)
  # bind (command-debug-status)
  call-interactively(mouse-track)
  # (condition-case ... . error)
  # (catch top-level ...)

>>> Michael Reiher <redm@...> seems to think that:
>On Tuesday 26 February 2008 02:45, Eric M. Ludlam wrote:
  [ ... ]
>>   Since an active bookmark system hooks into the parser to keep it's
>> tag list safe, it is likely it was throwing errors at inopportune
>> times and causes other issues.
>>
>Yes sounds reasonable. I have another issue still (hell, I must be annoying:) 
>I can't select text in other, non source, buffers like *scratch* (or simply 
>do a push-mark):
>
>Args out of range: #<buffer "*scratch*">, 0, 0
>
>Backtrace see below. The positions 5 to 7 are the characters I tried to select 
>in the scratch buffer.

I'm not entirely sure why `extent-list' would throw an error for
XEmacs.  It seems a bit odd.

I would guess the below patch would 'fix' the problem, but I am more
interested in any XEmacs knowledgeable folks looking at the below
function and letting me know if I'm using the API wrong.

*** semantic-fw.el	03 Sep 2007 21:11:55 -0400	1.57
--- semantic-fw.el	28 Feb 2008 10:37:32 -0500	
***************
***************
*** 50,56 ****
        (defalias 'semantic-overlay-move            'set-extent-endpoints)
        (defalias 'semantic-overlay-delete          'delete-extent)
        (defalias 'semantic-overlays-at
!         (lambda (pos) (extent-list nil pos pos)))
        (defalias 'semantic-overlays-in
          (lambda (beg end) (extent-list nil beg end)))
        (defalias 'semantic-overlay-buffer          'extent-buffer)
--- 50,60 ----
        (defalias 'semantic-overlay-move            'set-extent-endpoints)
        (defalias 'semantic-overlay-delete          'delete-extent)
        (defalias 'semantic-overlays-at
!         (lambda (pos) 
! 	  (condition-case nil
! 	      (extent-list nil pos pos)
! 	    (error nil))
! 	  ))
        (defalias 'semantic-overlays-in
          (lambda (beg end) (extent-list nil beg end)))
        (defalias 'semantic-overlay-buffer          'extent-buffer)

>When jumping to a tag using C-xB XEmacs complains about get-extent-property 
>being void. So in common/pulse.el:
>
>(defalias 'pulse-overlay-get 'get-extent-property)
>
>should probably be:
>
>(defalias 'pulse-overlay-get 'extent-property)
  [ ... ]

Thanks.  I think you are right that this is a typo.  I checked in a
fix.

Thanks
Eric

-- 
          Eric Ludlam:                       eric@...
   Siege: http://www.siege-engine.com          Emacs: http://cedet.sourceforge.net

Hi Dave,

>>> "Dave Milter" <davemilter@...> seems to think that:
>Hello.
>
>I try semantic with such code source structure:
  [ ... ]
>
>All this stuff is in
>$HOME/projects/cedet/foo
>I mean:
>$HOME/projects/cedet/foo/d1
>$HOME/projects/cedet/foo/d1/mod1.cpp
>$HOME/projects/cedet/foo/d1/mod1.hpp
>
>I have in .emacs:
>
>(setq semanticdb-project-roots
>(list "/home/dave/projects/tests/cedet/foo")
>)
>
>(ede-cpp-root-project "TEST" :file "/home/dave/projects/tests/cedet/foo/foo.cpp"
>                      :include-path '( "/" ))

First, you only need to specify semanticdb-project-roots if you do NOT
use ede-cpp-root-project.  If there is a page in the doc where this
was not clear, do you remember where it was?

Second, I found in the doc for ede-cpp-root that the doc-string was
missing a "not" that made it sound like a / was required for include
paths relative to the root.  Instead, I think you may need "." as the
include path, though that seems a little strange.

In a file, you can do:

M-x semanticdb-find-test-translate-path RET

and examine the list to see if the headers you expect are there.

There is also a chance that in an earlier parsing of the file, that
the tag representing the include file has a cached location of 'nil
stuck in it.  If you have `global-semantic-decoration-mode' enabled,
it will highlight header tags that Semantic cannot find.  Use:

C-u M-x bovinate RET

to force the file to reparse after making configuration changes so it
will look up the location the second time.

>But semantic can not find suitable competition for "hdr->"
>
>I updated to last cvs version,
>and now even things that works before show:
>Debugger entered--Lisp error: (void-function semanticdb-typecache-add-dependant)
>  semanticdb-typecache-add-dependant([object semantic-scope-cache
>"Cache" [object semanticdb-table "foo.cpp" [object
>semanticdb-project-database-file "foo/"
>"/home/evgeniy/projects/tests/cedet/foo/" semanticdb-table ...
>"/home/evgeniy/.emacs.d/semanticdb.cache/!home!evgeniy!projects!tests!cedet!foo!semantic.cache"
>"2.0pre4" "2.0pre4"] c++-mode (... ... ... ...) t nil [object

Hmmm.  I was just testing this new typecache dependency code this
morning from CVS.  Did you perhaps sync a new version of CEDET at
around 10:30pm EST?  Try getting a new version from CVS, as that
function does exist for me in my test anonymous CVS sync from this
morning.

Eric


>semanticdb-find-search-index "#<semanticdb-table foo.cpp> index" #1
>... nil] (#0) "foo.cpp" 302 nil] ("func" function (:arguments ...
>:type "void") nil #<overlay from 44 to 238 in foo.cpp>) nil nil nil
>nil (("type" variable ... ... [54 63]) ("data" variable ... ... [64
>75]) ("foo" variable ... ... [108 144]))])
>  semantic-calculate-scope(162)
>  semantic-analyze-current-context-default(162)
>  semantic-analyze-current-context(162)
>  semantic-complete-analyze-inline()
>  call-interactively(semantic-complete-analyze-inline)
>
>PS
>
>M-x emacs-version
>GNU Emacs 22.1.1 (i686-pc-linux-gnu, GTK+ Version 2.12.1) of
>2007-11-29 on oldcomp
>
>PS PS
>I wonder is it possible in emacs environment create some regression tests,
>so in my script which I used to get cedet from cvs and install,
>I can test that all things that works before works now,
>and only after that install cedet?
>
>-------------------------------------------------------------------------
>This SF.net email is sponsored by: Microsoft
>Defy all challenges. Microsoft(R) Visual Studio 2008.
>http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
>_______________________________________________
>cedet-semantic mailing list
>cedet-semantic@...
>https://lists.sourceforge.net/lists/listinfo/cedet-semantic
>

-- 
          Eric Ludlam:                       eric@...
   Siege: http://www.siege-engine.com          Emacs: http://cedet.sourceforge.net

>>> "Dave Milter" <davemilter@...> seems to think that:
>Hello.
>
>I try semantic with such code source structure:
>d1/mod1.hpp
>d1/mod1.cpp
  [ ... ]

Ignore my previous message, except for trying to recompile
semanticdb-typecache.el Your example has me a bit stumped at the
moment.

Eric

-- 
          Eric Ludlam:                       eric@...
   Siege: http://www.siege-engine.com          Emacs: http://cedet.sourceforge.net

Sorry about all the random email.

Your cpp file had this:

#include <d1/mod2.hpp>

which is system-include syntax.  I switched it to this:

#include "d1/mod2.hpp"

which is "in my project" syntax, and then completion works.

I was wrong about the include path of "/".  That was correct, and I
was clearly confused about that.


Good Luck
Eric


>>> "Eric M. Ludlam" <eric@...> seems to think that:
>>>> "Dave Milter" <davemilter@...> seems to think that:
>>Hello.
>>
>>I try semantic with such code source structure:
>>d1/mod1.hpp
>>d1/mod1.cpp
>  [ ... ]
>
>Ignore my previous message, except for trying to recompile
>semanticdb-typecache.el Your example has me a bit stumped at the
>moment.
>
>Eric
>

>Try getting a new version from CVS, as that
>function does exist for me in my test anonymous CVS sync from this
>morning.

I tried, "grep" through sources show me semanticdb-typecache-add-dependant,
but for some reason semantic-calculate-scope can not find it,
I add (require 'semanticdb-typecache) to semantic-scope.el, and things
start work for me.

>#include <d1/mod2.hpp>
>
>which is system-include syntax.  I switched it to this:
>
>#include "d1/mod2.hpp"
>
>which is "in my project" syntax, and then completion works.
>
>I was wrong about the include path of "/".  That was correct, and I
>was clearly confused about that.

I replace <> with quotes and this not helps
semanticdb-find-test-translate-path:

*#<semanticdb-table mod2.cpp (3 tags DIRTY)>
   ] Name: mod2.cpp
   ] Class: #'semanticdb-table
   ] parent-db #<semanticdb-project-database-file d1/ (1 tables DIRTY)>
   ] :major-mode #'c++-mode
   ] :tags #<TAG LIST: 3 entries>
   ] dirty 't
   ] db-refs 'nil
   ] index #<semanticdb-find-search-index #<semanticdb-table mod2.cpp> index>
   ] cache #<list o' stuff: 1 entries>
   ] :file mod2.cpp
   ] :pointmax 76
   ] :unmatched-syntax #unbound


One things what I should note, that
if I use semantic-add-system-include to add "foo" directory,
then call "C-u M-x bovinate "
(you remember that I have "foo/d1" with "foo/d1/mod2.[ch]pp")
after that cedet can find definition of structure from mod2.hpp,
and even if I change "<>" to quotes,
even than semanticdb can find suitable definition.


Thanks for help

>>> "Dave Milter" <davemilter@...> seems to think that:
>>Try getting a new version from CVS, as that
>>function does exist for me in my test anonymous CVS sync from this
>>morning.
>
>I tried, "grep" through sources show me semanticdb-typecache-add-dependant,
>but for some reason semantic-calculate-scope can not find it,
>I add (require 'semanticdb-typecache) to semantic-scope.el, and things
>start work for me.

I'll add an autoload cookie to it so this won't happen again.

>>#include <d1/mod2.hpp>
>>
>>which is system-include syntax.  I switched it to this:
>>
>>#include "d1/mod2.hpp"
>>
>>which is "in my project" syntax, and then completion works.
>>
>>I was wrong about the include path of "/".  That was correct, and I
>>was clearly confused about that.
>
>I replace <> with quotes and this not helps
>semanticdb-find-test-translate-path:
>
>*#<semanticdb-table mod2.cpp (3 tags DIRTY)>
>   ] Name: mod2.cpp
>   ] Class: #'semanticdb-table
>   ] parent-db #<semanticdb-project-database-file d1/ (1 tables DIRTY)>
>   ] :major-mode #'c++-mode
>   ] :tags #<TAG LIST: 3 entries>
>   ] dirty 't
>   ] db-refs 'nil
>   ] index #<semanticdb-find-search-index #<semanticdb-table mod2.cpp> index>
>   ] cache #<list o' stuff: 1 entries>
>   ] :file mod2.cpp
>   ] :pointmax 76
>   ] :unmatched-syntax #unbound
>
>
>One things what I should note, that
>if I use semantic-add-system-include to add "foo" directory,
>then call "C-u M-x bovinate "
>(you remember that I have "foo/d1" with "foo/d1/mod2.[ch]pp")
>after that cedet can find definition of structure from mod2.hpp,
>and even if I change "<>" to quotes,
>even than semanticdb can find suitable definition.


CPP supports the difference between system and local includes, but
most languages do not.  Thus if an include is marked 'system',
semantic takes a shortcut of not searching the project to speed things
up.  For non-system marked includes, since some langauges only support
this form, semantic will look everywhere.

It is good that you found a second solution.

It might be possible to make the system include path project local
with `ede-make-project-local-variable' and `ede-set' on your cpp-root
ede project, though I have not tried using this feature in a long time.

Eric

-- 
          Eric Ludlam:                       eric@...
   Siege: http://www.siege-engine.com          Emacs: http://cedet.sourceforge.net

On 2/10/08, Dave Milter <davemilter@...> wrote:
> I hope you find solution. It would be greate to see working
> completition with emacs.
>

Looks like there is some delay synchronization between anonymous cvs
and what you use. Now I can build cedet without problems and
modification,
and don't see any messages about errors in "* Message *" during "emacs init"
(see attachment), but when I call (semantic-complete-analyze-inline)
after "foo.",
I got this :(

Debugger entered--Lisp error: (wrong-type-argument arrayp nil)
  eieiomt-next(nil)
  eieiomt-method-list(semanticdb-cache-get 0 nil)
  eieio-generic-call(semanticdb-cache-get (nil semantic-scope-cache))
  semanticdb-cache-get(nil semantic-scope-cache)
  semantic-calculate-scope(87)
  semantic-analyze-current-context-default(87)
  semantic-analyze-current-context(87)
  semantic-complete-analyze-inline()
  call-interactively(semantic-complete-analyze-inline)

Hi,

  You need to finish installing CEDET into your .emacs file.  To get
  completion like that to work, you need a minimum of:

(load-file "~/cedet/common/cedet.el")
(semantic-load-enable-minimum-features)

  Please see the "Code Completion" chapter of cedet/common/cedet.info
  for more on this topic.

Good Luck
Eric  

>>> "Dave Milter" <davemilter@...> seems to think that:
>On 2/10/08, Dave Milter <davemilter@...> wrote:
>> I hope you find solution. It would be greate to see working
>> completition with emacs.
>>
>
>Looks like there is some delay synchronization between anonymous cvs
>and what you use. Now I can build cedet without problems and
>modification,
>and don't see any messages about errors in "* Message *" during "emacs init"
>(see attachment), but when I call (semantic-complete-analyze-inline)
>after "foo.",
>I got this :(
>
>Debugger entered--Lisp error: (wrong-type-argument arrayp nil)
>  eieiomt-next(nil)
>  eieiomt-method-list(semanticdb-cache-get 0 nil)
>  eieio-generic-call(semanticdb-cache-get (nil semantic-scope-cache))
>  semanticdb-cache-get(nil semantic-scope-cache)
>  semantic-calculate-scope(87)
>  semantic-analyze-current-context-default(87)
>  semantic-analyze-current-context(87)
>  semantic-complete-analyze-inline()
>  call-interactively(semantic-complete-analyze-inline)
>

-- 
          Eric Ludlam:                       eric@...
   Siege: http://www.siege-engine.com          Emacs: http://cedet.sourceforge.net

Hi,

On 2/10/08, Eric M. Ludlam <eric@...> wrote:
>   You need to finish installing CEDET into your .emacs file.  To get
>   completion like that to work, you need a minimum of:
>
> (load-file "~/cedet/common/cedet.el")
> (semantic-load-enable-minimum-features)
>

Thanks, actually this stuff should be done by my system:
I have (load "/usr/share/emacs/site-lisp/site-gentoo")
which call
/usr/share/emacs/site-lisp/site-gentoo.d/60cedet-gentoo.el
which has line like:
(load "/usr/share/emacs/site-lisp/cedet/common/cedet" nil t)

the problem was in
(semantic-load-enable-minimum-features)
emacs init system doesn't call it,

there is lines like:
(setq semantic-load-turn-everything-on t)
(setq semantic-load-turn-useful-things-on t)

but looks like them do not help with "cvs version",
but works with previous version: 1.0_pre4

>>> "Dave Milter" <davemilter@...> seems to think that:
>Hi,
>
>On 2/10/08, Eric M. Ludlam <eric@...> wrote:
>>   You need to finish installing CEDET into your .emacs file.  To get
>>   completion like that to work, you need a minimum of:
>>
>> (load-file "~/cedet/common/cedet.el")
>> (semantic-load-enable-minimum-features)
>>
>
>Thanks, actually this stuff should be done by my system:
>I have (load "/usr/share/emacs/site-lisp/site-gentoo")
>which call
>/usr/share/emacs/site-lisp/site-gentoo.d/60cedet-gentoo.el
>which has line like:
>(load "/usr/share/emacs/site-lisp/cedet/common/cedet" nil t)
>
>the problem was in
>(semantic-load-enable-minimum-features)
>emacs init system doesn't call it,
>
>there is lines like:
>(setq semantic-load-turn-everything-on t)
>(setq semantic-load-turn-useful-things-on t)
>
>but looks like them do not help with "cvs version",
>but works with previous version: 1.0_pre4
>

Those variables do still work, but you need to have them defined
BEFORE loading cedet.el.  I'm not sure why they would have worked
before, but not now.

I'm glad you got the system working now.

Eric

-- 
          Eric Ludlam:                       eric@...
   Siege: http://www.siege-engine.com          Emacs: http://cedet.sourceforge.net