Some problems in `add-log-current-defun'

* Some problems in `add-log-current-defun'
@ 2006-12-27 10:32 Herbert Euler
  2006-12-27 10:45 ` David Kastrup
                   ` (3 more replies)
  0 siblings, 4 replies; 19+ messages in thread
From: Herbert Euler @ 2006-12-27 10:32 UTC (permalink / raw)

I encountered a problem in add-log.el, and solved it somehow (see
http://lists.gnu.org/archive/html/emacs-devel/2006-09/msg00869.html).
However, after re-reading the implementation of
`add-log-current-defun', I found there are still many problems (bugs)
in `add-log-current-defun' for the C like languages.  I'm going to
work on it, but before doing anything, I'd like to write them down.
This message is intended to describe the problems I found, rather than
talking about any proposal.  Please help me find whether there are
more problems not found yet.

Please locate to the function `add-log-current-defun' in `add-log.el'
before continuing reading.

I. The end of a function

The point is moved to the start position of a function or an empty
line (lines consist of only white space characters) with the following
code.

    ;; See if we are in the beginning part of a function,
    ;; before the open brace.  If so, advance forward.
    (while (not (looking-at "{\\|\\(\\s *$\\)"))
      (forward-line 1))

But this is not reliable.  If someone forgets to put a newline after a
function, `add-log-current-defun' will report wrong name.  Please
consider the following example:

    int
    f1 ()
    {
      /* If point is here `add-log-current-defun' gets wrong result.  */
    }
    int
    f2 ()
    {
      /* ...  */
    }

When the point is inside the body of `f1', invoking
`add-log-current-defun' will get `f2', rather than `f1'.

II. On the change of `beginning-of-defun' in CC mode

When the point is in the docstring of Emacs C source code, the
following forms are evaluated.

    (let (maybe-beg)
      ;; Try to find the containing defun.
      (beginning-of-defun)
      (end-of-defun)

But I found the result is wrong with the newest CC mode.  Consider the
following Emacs C source code:

    DEFUN ("catch", Fcatch, Scatch, 1, UNEVALLED, 0,
           doc: /* Eval BODY allowing nonlocal exits using `throw'.
    TAG is evalled to get the tag to use; it must not be nil.

    Then the BODY is executed.
    Within BODY, a call to `throw' with the same TAG exits BODY and this 
`catch'.
    If no throw happens, `catch' returns the value of the last BODY form.
    If a throw happens, it specifies the value to return from `catch'.
    usage: (catch TAG BODY...)  */)

Now suppose the point is at the beginning of the second paragarph,
i.e. before ``Then''.  This is where the point will be before
evaluating the forms given above if one invokes
`add-log-current-defun' when the point is in the first paragraph of
the docstring.  In the past, CC mode does not consider the arguments
of DEFUN as a defun, so `beginning-of-defun' will move point to the
beginning of the function that appear before this DEFUN.  With the
forms in `add-log-current-defun', the result is correct.  But I found
in the newest CC mode considers the arguments (starting with
``("catch"'', ending with ``*/)'') as a defun, so that
`beginning-of-defun' will move point to the beginning of the
arguments, i.e. between the space that is after ``DEFUN'' and the left
paren before ``"catch"''.  As a result, one cannot produce correct
change log entry when point is in the first paragraph of this
function, for example, when point is between ``Eval'' and ``BODY'' in
the first paragraph.

III. Different styles

The function skips typedefs and arglist with the following forms.

        ;; Skip back over typedefs and arglist.
        ;; Stop at the function definition itself
        ;; or at the line that follows end of function doc string.
        (forward-line -1)
        (while (and (not (bobp))
                    (looking-at "[ \t\n]")
                    (not (looking-back "[*]/)\n" (- (point) 4))))
          (forward-line -1))

This is not general: it cannot process programs in some style.  In
section 7.7 of the 3rd edition of The C++ Programming Language by
Bjarne Stroustrup, there is a shell sort implementation:

    void ssort(void * base, size_t n, size_t sz, CFT cmp)
    /*
        Sort the "n" elements of vector "base" into increasing order
        using the comparison function pointed to by "cmp".
        The elements are of size "sz".

        Shell sort (Knuth, Vol3, pg84)
    */
    {
        /* ...  */
    }

The current implementation cannot handle programs in this style
correctly.

IV. On the C++ names

And what I tried to fix is not general too.  My fix is

    (while (not (looking-back "\\(^\\|[ \t]\\)"))
      (forward-sexp -1))

This is not general too: C++ permits the nested name to be put in many
lines.  For example, the following name is valid:

    void
    class_1
    ::
    sub_class_2
    ::
    method_3 ()
    {
      /* ...  */
    }

The current implementation cannot handle this name correctly.

Regards,
Guanpeng Xu

_________________________________________________________________
Express yourself instantly with MSN Messenger! Download today it's FREE! 
http://messenger.msn.click-url.com/go/onm00200471ave/direct/01/

^ permalink raw reply	[flat|nested] 19+ messages in thread