CEDET

Hi Eric

I have a few small adjustments for XEmacs sitting on my disc for a while now. 
And I thought I might tell you, so you can add them to CVS somehow.

The first this is in semantic-fw.el: semantic-find-file-noselect:

XEmacs' find-file-noselect has only 3 parameters, so I get an error about 
wrong number of arguments (being 4). The wildcards parameter GNU Emacs has, 
is missing in XEmacs.

Patch for illustration:

--- semantic/semantic-fw.el     10 Oct 2008 21:33:52 -0000      1.64
+++ semantic/semantic-fw.el     26 Nov 2008 19:04:51 -0000
@@ -393,7 +393,10 @@ FILE, NOWARN, RAWFILE, and WILDCARDS are
         ;; Disable revision control
         (vc-handled-backends nil)
         )
+               (if (featurep 'xemacs)
+                               (find-file-noselect file nowarn rawfile)
     (find-file-noselect file nowarn rawfile wildcards)
+                       )
     ))


The other issues are in semantic-decorate-include.el:

First it uses a face "region" for highlighting includes, which doesn't exist 
in XEmacs and gives an error. I'd suggest to use "highlight" instead. It 
seems fitting and exists in both GNU Emacs and XEmacs.

Another (less important) thing here is, that it uses mouse-3 for for the right 
mouse button, which doesn't exist in XEmacs. It's called button3 there.

Then semantic-decoration-include-menu even seems to be called, however 
something is wrong about the argument.

Debugger entered--Lisp error: (wrong-type-argument listp #<buttondown-event 
button3>)
  semantic-decoration-include-menu(#<buttondown-event button3>)
  call-interactively(semantic-decoration-include-menu)


Patch for illustration:

--- semantic/semantic-decorate-include.el       27 Oct 2008 01:39:39 -0000      
1.17
+++ semantic/semantic-decorate-include.el       26 Nov 2008 19:04:51 -0000
@@ -47,7 +47,8 @@ Used by the decoration style: `semantic-

 (defvar semantic-decoration-on-include-map
   (let ((km (make-sparse-keymap)))
-    (define-key km [ mouse-3 ] 'semantic-decoration-include-menu)
+;    (define-key km [ mouse-3 ] 'semantic-decoration-include-menu)
+    (define-key km [ button3 ] 'semantic-decoration-include-menu)
     km)
   "Keymap used on includes.")

@@ -108,7 +109,8 @@ Used by the decoration style: `semantic-
 (defvar semantic-decoration-on-unknown-include-map
   (let ((km (make-sparse-keymap)))
     ;(define-key km [ mouse-2 ] 
'semantic-decoration-unknown-include-describe)
-    (define-key km [ mouse-3 ] 'semantic-decoration-unknown-include-menu)
+;    (define-key km [ mouse-3 ] 'semantic-decoration-unknown-include-menu)
+    (define-key km [ button3 ] 'semantic-decoration-unknown-include-menu)
     km)
   "Keymap used on unparsed includes.")

@@ -161,7 +163,8 @@ Used by the decoration style: `semantic-

 (defvar semantic-decoration-on-unparsed-include-map
   (let ((km (make-sparse-keymap)))
-    (define-key km [ mouse-3 ] 'semantic-decoration-unparsed-include-menu)
+;    (define-key km [ mouse-3 ] 'semantic-decoration-unparsed-include-menu)
+    (define-key km [ button3 ] 'semantic-decoration-unparsed-include-menu)
     km)
   "Keymap used on unparsed includes.")

@@ -268,7 +271,7 @@ This mode provides a nice context menu o
                                     (semantic-tag-end tag)
                                     face))
          )
-      (semantic-overlay-put ol 'mouse-face 'region)
+      (semantic-overlay-put ol 'mouse-face 'highlight)
       (semantic-overlay-put ol 'keymap map)
       (semantic-overlay-put ol 'help-echo
                            "Header File : mouse-3 - Context menu")



Something else, not specific to XEmacs: I use push-tag-mark to save positions 
when jumping. This works quite well for jumping backwards. Maybe you might 
want to add it as well. (The push-mark mechanism is IMHO pointless in this 
case. And mru-bookmark-mode, while looking promising, I found it not to be 
really efficiently usable.)

Patch for illustration:

--- semantic/semantic-ia.el     7 Oct 2008 01:50:52 -0000       1.25
+++ semantic/semantic-ia.el     26 Nov 2008 19:14:37 -0000
@@ -269,6 +269,7 @@ This helper manages the mark, buffer swi
   ;; 1) Push the mark, so you can pop global mark back, or
   ;;    use semantic-mru-bookmark mode to do so.
-   (push-mark)
+       (push-tag-mark)
   ;; 2) Visits the tag.
   (semantic-go-to-tag dest)
   ;; 3) go-to-tag doesn't switch the buffer in the current window,


Oh, on a related note: in semantic-ia--fast-jump-heper (I guess there is an 
"l" missing? ;) there is a comment:

  ;; We have a tag, but in C++, we usually get a prototype instead
  ;; because of header files.  Lets try to find the actual
  ;; implementaion instead.

Is this supposed to be working? Because it doesn't for me... :) Would be great 
to have though. It always jumps to the prototype i.e. the .h file. Even when 
the implementation is actually in the same .cpp file.


Allright, I think that's all for today :)

Greets 

Michael

Hi,

I found that tags for cpp files are not output in class structure, while
using namespace

For example,

// main.cpp
namespace bread_name{
    int bread::funca()
    {
        return 0;
    }

    int bread::funcb()
    {
        return 0;
    }

    int panda::funca()
    {
        return 0;
    }

    int panda::funcb()
    {
        return 0;
    }
}

The tags in imenu and speedbar will look like this:

bread:namespace ->
                                     funca:int
                                     funcb:int
                                     funca:int
                                     funcb:int

If the delete "namespace bread_name", it will look like this:

bread:struct ->
                           funca:int
                           funcb:int

panda:struct ->
                           funca:int
                           funcb:int

So i think it will be better for the former to display like this:

bread_name:namespace
            bread:struct ->
                                       funca:int
                                       funcb:int

            bread:struct ->
                                       funca:int
                                       funcb:int

Thanks.

-- 
Zhiqiu Kong (孔直秋)

EDA Labs
Dept. Computer Science & Technology
Tsinghua University
P.R China
100084

Hi,

  Comments are inline.

>>> bread <breaddawson@...> seems to think that:
>Hi,
>
>1. Thank you very much for your reply, now i know why it did not work for me
>and i've changed my coding style :)
>
>Another issue about semantic completions is like this:
>
>I found the position of "using namespace ***" will effect the completions,
>for example, I have a simple bread.hpp which writes like this:
>
  [ ... ]
>namespace panda{
>
>    using namespace bread_name;
>    int func()
>    {
>        bread test;
>        test.
  [ ... ]
>The completions will not show up. Since the codes above can be compiled, i
>think maybe there's something wrong with semantic's analyzing?

The case for finding those using statements was just missing.  I
checked in a fix into semantic-c.el, and also added some tests for
this case.

>2. Sometimes, even if 'semantic-analyze-debug-assist' could show me all the
>possible completions, 'semantic-ia-complete-symbol-menu' might not show all.
>For example, after i added two other functions to bread.hpp:
>
  [ ... ]
>It seems that all the members are got by semantic. But this infomation can
>be losed after i closed emacs and reopen it, which means, after i reopen
>panda.cpp, i just find that even semantic-analyze-debug-assist can not get
>the possible completions. I need to manually 'C-u M-x bovinate' to make them
>work.

Did you enabled ebrowse or exuberent ctags parsing backends?

Are there any error messages when you use 

M-x semanticdb-save-all-db RET

?

>What's more, after i use 'C-u M-x bovinate' to make the completions menu
>work properly, i found function overloading may not be processed. That
>happened after i added another version of set:
>
>void set(float, char);
>
>I can see it via 'semantic-analyze-debug-assist' but it's not in completions
>menu. It seems the newer one is hidden by the older one.

I will need to investigate this one some more.

>3. I'm confused with "semantic-idle-scheduler-work-idle-time" and
>"semantic-idle-scheduler-idle-time".
>As what i thought before, i think the formmer is the one which controls the
>analyzing interval, which means, if i set this as 60, then semantic will
>analyze my codes every 60s. And speak of the latter, i thought it controls
>how long i need to wait till the summary of current context will show in the
>minibuffer. But now i'm confused because:
>
>1) what does idle mean? does it mean, if i type whithout stop, semantic will
>not do anything?

"idle" means that you have not touched Emacs for some amount of time.
If you type then do nothing for 1 second, then a 1 second idle timer
will execute.

If you type without stopping, the timer will never go off.  If you
want semantic to do something, you need to bind a key, like "." to
then execute some semantic command.

>2) i've set the idle-summary-function as
>"semantic-format-tag-uml-prototype", but i found the info showed after i
>stop a while on some function is different with the one showed up when i
>manually tirgger 'semantic-ia-show-summary', so idle-summary-function
>controls which one?

All the `semantic-ia-' functions are examples that show how to use the
semantic analyzer API.  They do not share configuration with tools
like the idle based summary mode.

>3) even i set semantic-idle-scheduler-idle-time as 1s, i found the summary
>of current context (for example, a funciton) will not always show up. Since
>i've set semantic-idle-scheduler-work-idle-time as 5 seconds, does the two
>conflict with each other?

The idle time should always be less that the idle-work time.  The idle
timer keeps the current buffer up to date, and can run useful code
help commands.  These commands will not refresh complex data
structures because that can be time-consuming, and interrupt typing.

The work timer goes out of its way to update many buffers and files,
and to rebuild caches that may prove useful from the idle timer.

When idle summary mode or completion mode fails to provide a piece of
information, it may be some cache is out of date.  User commands will
not do this, and will take the time to recalculate complex data
structures.

It's all about not interrupting as you type.

Enjoy
Eric

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

Hello,

  You are right, the identification of -> and subsequent change of
data type should belong in a C specific function.

  If you look in cedet/semantic/bovine/semantic-c.el you will see an
overload for semantic-analyze-dereference-metatype.  This is used by
semantic-analyze-tag-type.  A short hack might be to augment this to
identify a class with a -> operator, and do a transformation.

  Alternately, it occurs to me, this could be augmented with a
user-supplied list of transformations to handle smart pointers.

  To know if we want to translate smart pointers as a metatype, we
need to identify when we use -> vs . and capture that information in
the local context parser.  It may be necessary to write a whole new
routine that can parse more complex statements.  Semantic already
misses a wide range of cast syntax.  This should probably be a custom
C parser.

  Anyway, I'd recommend the metatype hack to get started.  It may be
that is good enough for you in the short term.  Longer term projects
of identifying -> and such will take longer, and will be able to take
advantage of what you learn.

Eric

>>> Raf <raf.ml@...> seems to think that:
>Hi Eric,
>
>It's progressing :
>
>variable declaration recognized with template specifier : ok
>
>in semantic-analyze-tag-type I've both the variableTag plus its classTag.
>so here I' can :
>  - if in classTag there is a "->" function, I can replace classTag with 
>the one returned by the "->" function (in case of template I use 
>variableTag.template-specifier classTag)
>
>but
>
>* I' don't know if its correct to deal with a specific language issue in 
>a non language-specific function.
>
>* I' think it's more correct to set classTag to the class returned bye 
>the -> operator (if a c++ class redefine the "->" operator it want to 
>act like a pointer of the type returned by the operator) rather than to 
>the class owning the -> operator. Ideally it has to be determined by the 
>context (is the token followed by a "->" or a "." maybe with overlay 
>info, but now I don't know where to find this info. Another compromise 
>is to mix the slots of both class : the original + the pointed one, but 
>it sound difficult, and also I' don't know how.
>
>Do you think semantic-analyze-tag-type is the correct place to handle this ?
>Any risks of bad side effects here ?
>
>For now I've just written dirty code to see if it can work, and it do in 
>my limited test cases.
>
>I' will propose you a patch when I' will find the time to write cleaner 
>code.
>
>Any hints are welcome.
>
>thanks.
>
>raf.
>
>Eric M. Ludlam a écrit :
>> Hi,
>>
>> I knew operator overloads would eventually show up. :)  I've looked
>> into this before, and it is not an incremental change.
>>
>> The existing parser parses templates just enough to get past them, and
>> that works for a large number of templated classes.
>>
>> The preprocessor cannot do substitutions for anything other than
>> symbols.  This is as intended.  A full up lexical redefinition would
>> be needed.
>>
>> As you suggest below, the "right" solution is to remember the template
>> specifier for variables.  This seems like the best approach, and
>> should be handled in the derived datatype of the variable.  All the
>> type dereferencing through the template specifier could then be
>> handled nicely as a minor C++ tweak.
>>
>> In c.by, typeformbase already has a comment waiting to be modified.
>> Perhaps like this:
>>
>> *** c.by.~1.49.~	2008-09-19 23:29:45.000000000 -0400
>> --- c.by	2008-11-21 11:49:50.000000000 -0500
>> ***************
>> *** 664,671 ****
>>       (TYPE-TAG $2 $1 nil nil )
>>     | builtintype
>>       ( ,$1 )
>> !  ;;| symbol template-specifier
>> !  ;;  ( $1 type "class" )
>>    ;;| namespace-symbol opt-stars opt-template-specifier
>>    ;;| namespace-symbol opt-template-specifier
>>     | namespace-symbol opt-template-specifier
>> --- 664,671 ----
>>       (TYPE-TAG $2 $1 nil nil )
>>     | builtintype
>>       ( ,$1 )
>> !   | symbol template-specifier
>> !     (TYPE-TAG $1 "class" nil nil :template-specifier $2)
>>    ;;| namespace-symbol opt-stars opt-template-specifier
>>    ;;| namespace-symbol opt-template-specifier
>>     | namespace-symbol opt-template-specifier
>> ----------------------------
>>
>> would get you just far enough to get by w/ non-namespace based
>> symbols.  Ideally someone would get around to a parser re-write in
>> wisent which is sorely needed.
>>
>> Anyway, once that is available, the name and datatype resolver in the
>> analyzer would need to be made aware of template specifiers, and the
>> context parser would need to start tracking operator overloading.
>>
>> I'd be happy to work through some of this if you don't mind working
>> through some of the issues w/ me.
>>
>> Eric
>>
>>   
>>>>> Raf <raf.ml@...> seems to think that:
>>>>>         
>>> Hello,
>>>
>>> I'm currently testing the CVS version of semantic. Thanks for this great 
>>> and impressive tool.
>>>
>>> I'm trying to make completion for smart_pointer to work (since most of 
>>> my code use it).
>>>
>>> here is a sample :
>>> -----------------------------------
>>> template class<T>
>>> class ref<T> {
>>> public:
>>>  T* operator->();
>>> };
>>>
>>>
>>> class Foo {
>>> public:
>>>  int getValue();  
>>>  double getResult();
>>> };
>>>
>>>
>>> void
>>> main(void) {
>>>  ref<Foo> d;
>>>
>>>  d->;
>>> }
>>> -------------------------------------
>>>
>>> => I've tried this :
>>> (setq semantic-lex-c-preprocessor-symbol-map
>>>      '(
>>>        ( "ref<Foo>" . ((symbol "Foo" 1 1) (punctuation "*" 1 1)) )
>>>       ))
>>>
>>> but it doesn't work because of the "<" character in the keyword.
>>>
>>> => I've looking in c.by
>>> here the template parameters of the variable declaration seems to be 
>>> ignored :
>>>
>>> namespace-symbol
>>>  : symbol opt-template-specifier COLON COLON namespace-symbol
>>>    ( (concat $1 "::" (car $5)) )
>>>  | symbol opt-template-specifier
>>>    ( $1 )
>>>  ;
>>>
>>> It would be nice if we could set a variable that drive substitutions 
>>> before the lexer start.
>>> Something like "'ref<Foo>' should be read as 'Foo *'"
>>> this would add smart_pointer completion support by just a fews lines 
>>> (there is usually fews smart pointers types, so identifying them in a 
>>> variable is no pain and a lot benefits)
>>>
>>> ideally the parser should produce tag with the corrects infos, but maybe 
>>> it's too complicated for just one use case. (the type tag already have 
>>> the infos, but not the variable tag)
>>>
>>> thanks in advance for any hints, help, suggestions on how to make this work.
>>>
>>> raf.
>>>     
>>   [ ... ]
>>
>>   
>
>

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