CEDET

Hi Klaus,

> The parsing of defstruct fails in some cases.
> 
> The docstring of `defstruct' in GNU Emacs is wrong, because also the
> following is allowed:
> 
> (defstruct tramp-file-name multi-method method user host path)
> 
> So the following (current) parser fails:
> 
[...]
> 
> This parser works:
> 
> (semantic-elisp-setup-form-parser
>     (lambda (form start end)
>       (semantic-tag-new-type
>        (symbol-name (if (consp (nth 1 form))
>                         (car-safe (nth 1 form))
>                       (nth 1 form)))
>        "struct"
>        (semantic-elisp-desymbolify (nthcdr 2 form))
>        (cons nil nil)
>        ))
>   defstruct
>   )
> 
> (see implementation of defstruct to see why this is necessary)

This is a good point.  The following version also takes into account
that the first element of the slot list can be a doc string.

(semantic-elisp-setup-form-parser
    (lambda (form start end)
      (let ((slots (nthcdr 2 form)))
        ;; Skip doc string if present.
        (and (stringp (car slots))
             (setq slots (cdr slots)))
        (semantic-tag-new-type
         (symbol-name (if (consp (nth 1 form))
                          (car (nth 1 form))
                        (nth 1 form)))
         "struct"
         (semantic-elisp-desymbolify slots)
         (cons nil nil)
         )))
  defstruct
  )

Perhaps could you submit a bug report to the Emacs developers to fix
the `defstruct' doc string?

> In addition i have added a nifty parser for defalias:
> 
[...]

Maybe it would be better to keep the information that this function is
an alias of another one. We could use a new :definition attribute that
would hold the aliased definition and implicitly indicate that this
function is an alias.  That should also work for `defvaralias'
expressions. Something like this (untested):

(semantic-elisp-setup-form-parser
    (lambda (form start end)
      (semantic-tag-new-function
       (symbol-name (if (equal (nth 0 (nth 1 form)) 'quote)
                        (nth 1 (nth 1 form))
                      ;; if the alias is not a quoted symbol we have to
                      ;; evaluate this code to get the symbol
                      (eval (nth 1 form))))
       nil ;; No type for Lisp functions
       nil ;; The arglist is the one of the aliased function
       ;; The following attribute hold the aliased definition.  When
       ;; non-nil it also indicates that this function is an alias of
       ;; another one.
       :definition (nth 2 form)
       ))
  defalias
  )

Finally not duplicating the arglist in the tag will not unnecessarily
increase the size of the tags database, and should please Eric ;)

Anyway thanks for your good work!

I wish you an happy new year.

David

Re: [CEDET-devel] Bug in semantic-el.el and a nifty new parser for defalias From: David PONCE <david.ponce@wa...> - 2005-01-03 13:17 > Finally not duplicating the arglist in the tag will not unnecessarily > increase the size of the tags database, and should please Eric ;) I forgot to say that we could enhance the function `semantic-tag-function-arguments' with your code to extract the arglist of the aliased function when the :definition attribute is non-nil. Eric, any thoughts?

Re[2]: [CEDET-devel] Bug in semantic-el.el and a nifty new parser for defalias From: Eric M. Ludlam <eric@si...> - 2005-01-04 01:58 >>> David PONCE <david.ponce@...> seems to think that: >> Finally not duplicating the arglist in the tag will not unnecessarily >> increase the size of the tags database, and should please Eric ;) > >I forgot to say that we could enhance the function >`semantic-tag-function-arguments' with your code to extract the >arglist of the aliased function when the :definition attribute is >non-nil. > >Eric, any thoughts? Hi, Fixing defstruct parsing sounds like a good idea. I'm not surprised it was broken as I probably never tested it. C has something like an alias that you can declare in a "typedef", and it is a special kind of type which is the type it is aliasing through the "parent" slot. A function being aliased will not always be loaded into Emacs for the finding so it may be unreliable to attempt any extra extraction. It may be best to postpone such searching till later for other reasons as well. For example with these definitions: Emacs Lisp: (defalias 'newsym 'oldsym "why an alias") (defalias 'newsym (lambda (a) "Say what?") "What say?") C: #define NEWSYM oldsym These ought to be addressed in the same way, though the C one isn't captured in the TAG structure yet. It may be that an "alias" is something special to deal with for multiple languages. For example: (semantic-format-tag-summarize ALIAS) Alias: ALIAS == SOURCE-OF-ALIAS and the analyzer would then be able to correctly translate anything marked as an alias for something else. This could be valuable... depending on the prevalence of aliasing languages. It would certainly make some aspects of the C pre-processor much easier to deal with. 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

Re: [CEDET-devel] Bug in semantic-el.el and a nifty new parser for defalias From: David PONCE <david.ponce@wa...> - 2005-01-05 09:19 Hi Eric, > Fixing defstruct parsing sounds like a good idea. I'm not surprised > it was broken as I probably never tested it. OK, I committed the fix. > C has something like an alias that you can declare in a "typedef", > and it is a special kind of type which is the type it is aliasing > through the "parent" slot. > > A function being aliased will not always be loaded into Emacs for > the finding so it may be unreliable to attempt any extra extraction. > It may be best to postpone such searching till later for other reasons > as well. For example with these definitions: > > Emacs Lisp: > (defalias 'newsym 'oldsym "why an alias") > (defalias 'newsym (lambda (a) "Say what?") "What say?") > > C: > #define NEWSYM oldsym > > These ought to be addressed in the same way, though the C one isn't > captured in the TAG structure yet. It may be that an "alias" is > something special to deal with for multiple languages. For example: > > (semantic-format-tag-summarize ALIAS) > Alias: ALIAS == SOURCE-OF-ALIAS > > and the analyzer would then be able to correctly translate anything > marked as an alias for something else. This could be > valuable... depending on the prevalence of aliasing languages. It > would certainly make some aspects of the C pre-processor much easier > to deal with. Good points Eric! So what do you think of this definition inspired from what the C parser produces for typedefs? (semantic-elisp-setup-form-parser (lambda (form start end) (let ((alias (nth 1 form))) (semantic-tag-new-type ;; If not a quoted symbol evaluate the alias expression. ;; Signal an error if the alias is not a symbol. (symbol-name (if (eq (car alias) 'quote) (cadr alias) (eval alias))) "typedef" ;; Indicate an alias nil nil ;; The following attribute hold the aliased definition. :typedef (nth 2 form) ))) defalias ) Thanks! I which you and your family an happy new year. David

Re: [CEDET-devel] Bug in semantic-el.el and a nifty new parser for defalias From: David PONCE <david.ponce@wa...> - 2005-01-05 12:41 Hi Klaus, > Please wait a moment, because IMO your latest defstruct parser has a bug > (or at least an annoying behavior, see below). here is a working one: > > (semantic-elisp-setup-form-parser > (lambda (form start end) > (let ((slots (nthcdr 2 form))) > ;; Skip doc string if present. > (and (stringp (car slots)) > (setq slots (cdr slots))) > (semantic-tag-new-type > (symbol-name (if (consp (nth 1 form)) > (car (nth 1 form)) > (nth 1 form))) > "struct" > ;; make tags for the members > (mapcar (lambda (m) > (semantic-tag-new-variable > m nil nil)) > (semantic-elisp-desymbolify (nthcdr 2 form))) > ;; (semantic-elisp-desymbolify slots) > (cons nil nil) > ))) > defstruct > ) > [...] > Well, now we know the problem, the question is now how to deal with - in my > opinion there are several possible approaches: > 1. Only semantic tags are allowed as childrens (:members) of a semantic-tag > (e.g. variable-tags for the members of structs (c, c++) or defstructs > (elisp) > 2. ECB (and all other tools using semantic) have to take care that children of > a tag are not needed to be semantic-tags too and have to deal suitable with > them > 3. cedet/semantic allows all API-functions dealing with tags to be called also > with plain strings (or whatever) and return something suitable > (e.g. (semantic-tag-name "klaus") returns "klaus" and does not fail > > I would vote for 1. but admit that i do really see if this would have > serious drawbacks?! Approach 2. would be a lot of work for tools like ECB. > Approach 3. is - hmm, how to say - also somehow clumsy and ugly..... > > What do xou think?? I think 1 is the good solution, for example it is what the java parser produces. So if Eric agree, please commit your fix for the `defstruct' parser. [...] >>> C has something like an alias that you can declare in a "typedef", >>>and it is a special kind of type which is the type it is aliasing >>>through the "parent" slot. [...] >>Good points Eric! So what do you think of this definition inspired >>from what the C parser produces for typedefs? >> >>(semantic-elisp-setup-form-parser >> (lambda (form start end) >> (let ((alias (nth 1 form))) >> (semantic-tag-new-type >> ;; If not a quoted symbol evaluate the alias expression. >> ;; Signal an error if the alias is not a symbol. >> (symbol-name (if (eq (car alias) 'quote) >> (cadr alias) >> (eval alias))) >> "typedef" ;; Indicate an alias >> nil nil >> ;; The following attribute hold the aliased definition. >> :typedef (nth 2 form) >> ))) >> defalias >> ) > > > well, i have tried this parser and then i get the following ECB-display of an > defalias (excerpt of the methods-browser of ECB: > [...] > > Well, i understand Eric's points and i agree in some aspects but nevertheless > i found this display of a defalias not really satisfying - for a defvaralias > it makes more sense - but IMHO a defalias is NOT a type but just another name > for a function (refernces in C++ are also just other names!) > > IMO a defalias should ba parsed as something like a function ans a defvaralias > as something like a variable because exactly these they are. Both of them are > not types! I will let Eric reply to that. Thanks! David

Re[2]: [CEDET-devel] Bug in semantic-el.el and a nifty new parser for defalias From: Eric M. Ludlam <eric@si...> - 2005-01-05 14:21 >>> David PONCE <david.ponce@...> seems to think that: >Hi Eric, > >> Fixing defstruct parsing sounds like a good idea. I'm not surprised >> it was broken as I probably never tested it. > >OK, I committed the fix. Thanks >> C has something like an alias that you can declare in a "typedef", >> and it is a special kind of type which is the type it is aliasing >> through the "parent" slot. >> >> A function being aliased will not always be loaded into Emacs for >> the finding so it may be unreliable to attempt any extra extraction. >> It may be best to postpone such searching till later for other reasons >> as well. For example with these definitions: >> >> Emacs Lisp: >> (defalias 'newsym 'oldsym "why an alias") >> (defalias 'newsym (lambda (a) "Say what?") "What say?") >> >> C: >> #define NEWSYM oldsym >> >> These ought to be addressed in the same way, though the C one isn't >> captured in the TAG structure yet. It may be that an "alias" is >> something special to deal with for multiple languages. For example: >> >> (semantic-format-tag-summarize ALIAS) >> Alias: ALIAS == SOURCE-OF-ALIAS >> >> and the analyzer would then be able to correctly translate anything >> marked as an alias for something else. This could be >> valuable... depending on the prevalence of aliasing languages. It >> would certainly make some aspects of the C pre-processor much easier >> to deal with. > >Good points Eric! So what do you think of this definition inspired >from what the C parser produces for typedefs? > >(semantic-elisp-setup-form-parser > (lambda (form start end) > (let ((alias (nth 1 form))) > (semantic-tag-new-type > ;; If not a quoted symbol evaluate the alias expression. > ;; Signal an error if the alias is not a symbol. > (symbol-name (if (eq (car alias) 'quote) > (cadr alias) > (eval alias))) > "typedef" ;; Indicate an alias > nil nil > ;; The following attribute hold the aliased definition. > :typedef (nth 2 form) > ))) > defalias > ) [ ... ] The typedef I used previously was merely mimicking the nature of the C language. If a goal is to tackle an "alias" so it can be used in different languages, then perhaps a notation like this would be good. (Using very loose grammar notation) (ALIAS-TAG "name" 'meta-tag-class "value") Thus defalias: open-paren DEFALIAS symbol symbol opt-docstring close-paren (ALIAS-TAG $3 'function $4 :documentation $5) ; defvaralias: open-paren DEFVARALIAS symbol symbol opt-docstring close-paren (ALIAS-TAG $3 'variable $4 :documentation $5) ; or in C: typedef: TYPEDEF old_c_type new_name (ALIAS-TAG $3 'type $2) ; macro: HASH DEFINE name expression (ALIAS-TAG $3 nil $4) ; Now in C code, you might have this: #define MOOSE 1 #define PENGUIN (a->b) #define EMU (a->b.c) int myfunc(sometype a) { int tmp = PENGUIN-!- return EMU + MOOSE; } The tooltip like help for PENGUIN, EMU or MOOSE would be the literal translation from the alias. On the other hand, if the cursor were at the -!- location and completions were requested, the name of the alias would be found as complete, but a substitution would be needed, at which point the completion engine may find that ".c" would be a good completion. In Emacs Lisp code like this: (defalias 'this 'that) (defun myfunc () (this -!-)) the tool help would show that "this" is "that". Because it has a meta-tag-class of 'function, it would choose to look up "that" and extract the argument list. Big Lofty Goals. The best kind. ;) Would this aliasing mechanism be used in other languages besides C and Lisp? Additional thoughts would be useful. 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

Re: [CEDET-devel] Bug in semantic-el.el and a nifty new parser for defalias From: David PONCE <david.ponce@wa...> - 2005-01-05 15:37 > The typedef I used previously was merely mimicking the nature of the C > language. If a goal is to tackle an "alias" so it can be used in > different languages, then perhaps a notation like this would be > good. (Using very loose grammar notation) > > (ALIAS-TAG "name" 'meta-tag-class "value") > > Thus > > defalias: open-paren DEFALIAS symbol symbol opt-docstring close-paren > (ALIAS-TAG $3 'function $4 :documentation $5) > ; > > defvaralias: open-paren DEFVARALIAS symbol symbol opt-docstring close-paren > (ALIAS-TAG $3 'variable $4 :documentation $5) > ; > > or in C: > > typedef: TYPEDEF old_c_type new_name > (ALIAS-TAG $3 'type $2) > ; > > macro: HASH DEFINE name expression > (ALIAS-TAG $3 nil $4) > ; > > > > Now in C code, you might have this: > > #define MOOSE 1 > #define PENGUIN (a->b) > #define EMU (a->b.c) > > > int myfunc(sometype a) > { > int tmp = PENGUIN-!- > > return EMU + MOOSE; > } > > The tooltip like help for PENGUIN, EMU or MOOSE would be the literal > translation from the alias. > > On the other hand, if the cursor were at the -!- location and > completions were requested, the name of the alias would be found as > complete, but a substitution would be needed, at which point the > completion engine may find that ".c" would be a good completion. > > In Emacs Lisp code like this: > > (defalias 'this 'that) > > (defun myfunc () > (this -!-)) > > the tool help would show that "this" is "that". Because it has a > meta-tag-class of 'function, it would choose to look up "that" and > extract the argument list. > > Big Lofty Goals. The best kind. ;) I like a lot your idea which looks generic enough to me. Here is my first idea on how the core tag API could be implemented: ;;; Tags of class `alias' ;; (defsubst semantic-tag-new-alias (name meta-tag-class value &rest attributes) "Create a semantic tag of class alias. NAME is a name for this alias. META-TAG-CLASS is the class of the tag this tag is an alias. VALUE is the aliased definition. ATTRIBUTES is a list of additional attributes belonging to this tag." (apply 'semantic-tag name 'alias :class meta-tag-class :value value attributes)) (defsubst semantic-tag-alias-class (tag) "Return the class of tag TAG is an alias." (semantic-tag-get-attribute tag :class)) ;;;###autoload (define-overload semantic-tag-alias-definition (tag) "Return the definition TAG is an alias. The returned value is a tag of the class that `semantic-tag-alias-class' returns for TAG. The default is to return the value of the :value attribute. Return nil if TAG is not of class 'alias." (when (semantic-tag-of-class-p tag 'alias) (:override (semantic-tag-get-attribute tag :value)))) Using an overload for `semantic-tag-alias-definition' will allow to handle the alias definition based on language specific needs. For example, for Emacs lisp, the override could look up to the aliased function or variable and return either an already existing tag (maybe from a db) or a new built ad hoc one. David

Re[2]: [CEDET-devel] Bug in semantic-el.el and a nifty new parser for defalias From: Eric M. Ludlam <eric@si...> - 2005-01-05 16:23 >>> David PONCE <david.ponce@...> seems to think that: [ ... ] > >I like a lot your idea which looks generic enough to me. Here is my >first idea on how the core tag API could be implemented: > >;;; Tags of class `alias' >;; >(defsubst semantic-tag-new-alias (name meta-tag-class value &rest attributes) > "Create a semantic tag of class alias. >NAME is a name for this alias. >META-TAG-CLASS is the class of the tag this tag is an alias. >VALUE is the aliased definition. >ATTRIBUTES is a list of additional attributes belonging to this tag." > (apply 'semantic-tag name 'alias > :class meta-tag-class > :value value > attributes)) Hi David, Such speedy coding. ;) I would be wary of having an attribute name of :class. It has several possible meanings, not the least of which is the pre-existing dedicated class slot in the tag. :metaclass, or :aliasclass, or something that better expresses that this is an alias that represents something of that class would be nice. >(defsubst semantic-tag-alias-class (tag) > "Return the class of tag TAG is an alias." > (semantic-tag-get-attribute tag :class)) > >;;;###autoload >(define-overload semantic-tag-alias-definition (tag) > "Return the definition TAG is an alias. >The returned value is a tag of the class that >`semantic-tag-alias-class' returns for TAG. >The default is to return the value of the :value attribute. >Return nil if TAG is not of class 'alias." > (when (semantic-tag-of-class-p tag 'alias) > (:override > (semantic-tag-get-attribute tag :value)))) > >Using an overload for `semantic-tag-alias-definition' will allow to >handle the alias definition based on language specific needs. For >example, for Emacs lisp, the override could look up to the aliased >function or variable and return either an already existing tag (maybe >from a db) or a new built ad hoc one. [ ... ] An excellent notion for the overload function. This seems like a great start and is certainly what I was thinking of. Adding this would result in a need for some additional work including updating the C and Emacs Lisp parsers, adding grammar macros, writing some new semantic-format code and then propagating the change out to the rest of the tools. I can already imagine a senator function that replaces a symbol with the alias variable in a temporary manner. Nifty! Have fun 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

Re: [CEDET-devel] Bug in semantic-el.el and a nifty new parser for defalias From: David PONCE <david.ponce@wa...> - 2005-01-06 09:59 Hi Eric, > I would be wary of having an attribute name of :class. It has > several possible meanings, not the least of which is the > pre-existing dedicated class slot in the tag. > > :metaclass, or :aliasclass, or something that better expresses that > this is an alias that represents something of that class would be > nice. OK, I used :aliasclass because :metaclass could have other meaning. I also replaced the :value attribute by a more meaningful :definition attribute. Following is a patch for semantic-tag.el. If you agree, I can commit it as a starting point to implement the alias stuff. [...] > Adding this would result in a need for some additional work including > updating the C and Emacs Lisp parsers, adding grammar macros, writing > some new semantic-format code and then propagating the change out to > the rest of the tools. Agree. I will work (probably slowly) on some of the above items. Thanks! David 2005-01-06 David Ponce <david@...> * cedet/semantic/semantic-tag.el (semantic-tag-new-alias, semantic-tag-alias-class) (semantic-tag-alias-definition): New functions. Index: semantic-tag.el =================================================================== RCS file: /cvsroot/cedet/cedet/semantic/semantic-tag.el,v retrieving revision 1.29 diff -c -r1.29 semantic-tag.el *** semantic-tag.el 5 Oct 2004 10:59:01 -0000 1.29 --- semantic-tag.el 6 Jan 2005 09:48:32 -0000 *************** *** 590,595 **** --- 590,623 ---- That is the value of the attribute `:detail'." (semantic-tag-get-attribute tag :detail)) + ;;; Tags of class `alias' + ;; + (defsubst semantic-tag-new-alias (name meta-tag-class value &rest attributes) + "Create a semantic tag of class alias. + NAME is a name for this alias. + META-TAG-CLASS is the class of the tag this tag is an alias. + VALUE is the aliased definition. + ATTRIBUTES is a list of additional attributes belonging to this tag." + (apply 'semantic-tag name 'alias + :aliasclass meta-tag-class + :definition value + attributes)) + + (defsubst semantic-tag-alias-class (tag) + "Return the class of tag TAG is an alias." + (semantic-tag-get-attribute tag :aliasclass)) + + ;;;###autoload + (define-overload semantic-tag-alias-definition (tag) + "Return the definition TAG is an alias. + The returned value is a tag of the class that + `semantic-tag-alias-class' returns for TAG. + The default is to return the value of the :definition attribute. + Return nil if TAG is not of class 'alias." + (when (semantic-tag-of-class-p tag 'alias) + (:override + (semantic-tag-get-attribute tag :definition)))) + ;;; Language Specific Tag access via overload ;; ;;;###autoload

Re[2]: [CEDET-devel] Bug in semantic-el.el and a nifty new parser for defalias From: Eric M. Ludlam <eric@si...> - 2005-01-06 12:01 >>> David PONCE <david.ponce@...> seems to think that: >Hi Eric, > >> I would be wary of having an attribute name of :class. It has >> several possible meanings, not the least of which is the >> pre-existing dedicated class slot in the tag. >> >> :metaclass, or :aliasclass, or something that better expresses that >> this is an alias that represents something of that class would be >> nice. > >OK, I used :aliasclass because :metaclass could have other meaning. >I also replaced the :value attribute by a more meaningful :definition >attribute. > >Following is a patch for semantic-tag.el. If you agree, I can commit >it as a starting point to implement the alias stuff. Looks good. Please check them in. >[...] >> Adding this would result in a need for some additional work including >> updating the C and Emacs Lisp parsers, adding grammar macros, writing >> some new semantic-format code and then propagating the change out to >> the rest of the tools. > >Agree. I will work (probably slowly) on some of the above items. [ ... ] I too. When you check this in, I will then look into the C language usage and how it is handled in semantic-format and supporting tools. 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

Re: [CEDET-devel] Bug in semantic-el.el and a nifty new parser for defalias From: David PONCE <david.ponce@wa...> - 2005-01-06 12:20 > Looks good. Please check them in. Done. >>>Adding this would result in a need for some additional work including >>>updating the C and Emacs Lisp parsers, adding grammar macros, writing >>>some new semantic-format code and then propagating the change out to >>>the rest of the tools. >> >>Agree. I will work (probably slowly) on some of the above items. > > [ ... ] > > I too. When you check this in, I will then look into the C language > usage and how it is handled in semantic-format and supporting tools. Great! Thanks David

1 message has been excluded from this view by a project administrator.