CC Mode 5.25 (Java); fill-paragraph confused by parentheses in comments

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Dear Barry and Martin,

Sometimes the M-q command works inside comment in java code, sometimes
it doesn't.

It works with this comment:

    /**
     * A delay with a repetition count.
     *
     * <p> This class is currently unused.  If it will be used, a
     * data member of <code>Event</code> should be of type
     * <code>Event.Time</code>, and
     * should replace both the <code>absolute_delay</code> and
     * <code>repeat</code> data members.
     **/

but it does not with this one:

    /**
     * A delay with a repetition count.
     *
     * <p> This class is currently unused.  If it will be used, a (private?)
     * data member of <code>Event</code> should be of type
     * <code>Event.Time</code>, and
     * should replace both the <code>absolute_delay</code> and
     * <code>repeat</code> data members.
     **/

I append the whole file below.  Thanks for reading this.

Emacs  : GNU Emacs 20.7.3 (i686-pc-linux-gnu, X toolkit)
 of Fri Oct 13 2000 on pot
Package: CC Mode 5.25 (Java)
Buffer Style: java

c-emacs-features: (1-bit)

current state:
==============
(setq
 c-basic-offset 4
 c-offsets-alist '((string . c-lineup-dont-change)
		   (c . c-lineup-C-comments)
		   (defun-open . 0)
		   (defun-close . 0)
		   (defun-block-intro . +)
		   (class-open . 0)
		   (class-close . 0)
		   (inline-open . 0)
		   (inline-close . 0)
		   (func-decl-cont . c-lineup-java-throws)
		   (knr-argdecl-intro . 5)
		   (knr-argdecl . 0)
		   (topmost-intro . 0)
		   (topmost-intro-cont . +)
		   (member-init-intro . +)
		   (member-init-cont . 0)
		   (inher-intro . +)
		   (inher-cont . c-lineup-java-inher)
		   (block-open . 0)
		   (block-close . 0)
		   (brace-list-open . 0)
		   (brace-list-close . 0)
		   (brace-list-intro . +)
		   (brace-list-entry . 0)
		   (brace-entry-open . 0)
		   (statement . 0)
		   (statement-cont . +)
		   (statement-block-intro . +)
		   (statement-case-intro . +)
		   (statement-case-open . +)
		   (substatement . +)
		   (substatement-open . +)
		   (case-label . 0)
		   (access-label . 0)
		   (label . 0)
		   (do-while-closure . 0)
		   (else-clause . 0)
		   (catch-clause . 0)
		   (comment-intro . c-lineup-comment)
		   (arglist-intro . c-lineup-arglist-intro-after-paren)
		   (arglist-cont . 0)
		   (arglist-cont-nonempty . c-lineup-arglist)
		   (arglist-close . c-lineup-arglist)
		   (stream-op . c-lineup-streamop)
		   (inclass . +)
		   (cpp-macro . -1000)
		   (cpp-macro-cont . c-lineup-dont-change)
		   (friend . 0)
		   (objc-method-intro . -1000)
		   (objc-method-args-cont . c-lineup-ObjC-method-args)
		   (objc-method-call-cont . c-lineup-ObjC-method-call)
		   (extern-lang-open . 0)
		   (extern-lang-close . 0)
		   (inextern-lang . +)
		   (namespace-open . 0)
		   (namespace-close . 0)
		   (innamespace . +)
		   (template-args-cont . +)
		   (inlambda . c-lineup-inexpr-block)
		   (lambda-intro-cont . +)
		   (inexpr-statement . 0)
		   (inexpr-class . +)
		   )
 c-cleanup-list '(scope-operator)
 c-comment-only-line-offset '(0 . 0)
 c-backslash-column 48
 c-delete-function 'delete-char
 c-electric-pound-behavior nil
 c-hanging-braces-alist '((brace-list-open) (brace-entry-open)
			  (substatement-open after)
			  (block-close . c-snug-do-while)
			  (extern-lang-open after)
			  (inexpr-class-open after) (inexpr-class-close before))
 c-hanging-colons-alist nil
 c-hanging-comment-starter-p nil
 c-hanging-comment-ender-p nil
 c-indent-comments-syntactically-p nil
 c-tab-always-indent t
 c-comment-continuation-stars "* "
 c-label-minimum-indentation 1
 defun-prompt-regexp "\\(class\\|/\\*\\*\\)[^{]*"
 tab-width 8
 comment-column 32
 )

===File ~/galileo/Engine/Event.java=========================
/*
 * This is part of the GaliLEO package.
 * Copyright (C) 2000 Laurent Franck and Francesco Potortì
 * See file COPYING for copying conditions.
 */

// Last revision is $Id: Event.java,v 1.5 2000/11/16 13:00:52 pot Exp $
// made on $Date: 2000/11/16 13:00:52 $ by $Author: pot $

//

package GaliLEO.Engine;

import GaliLEO.Tools.*;

/**
   An event is something which is scheduled to happen in the
   simulation.  Events are stored in a delta list or in a calendar
   queue and are corresponding to the scheduled triggering of a given
   selector.

   @see DeltaList
   @see Calendar
*/
public class Event implements Linkable
{
    /**
     * A delay with a repetition count.
     *
     * <p> This class is currently unused.  If it will be used, a (private?)
     * data member of <code>Event</code> should be of type
     * <code>Event.Time</code>, and
     * should replace both the <code>absolute_delay</code> and
     * <code>repeat</code> data members.
     **/
    public static class Time
    {
	private double delay;
	private double count;

	/**
	 * Contructor for events that will never be scheduled.  Use like this:
	 * <code> new Time(null) </code>.
	 */
	public Time(Object o)
	{
	    delay = 0; count = 0;
	}

	/**
	 * Contructor for one-shot events to be scheduled after a delay.
	 *
	 * @param a non-negative double representing the delay
	 */
	public Time(double d)
	{
	    Debug.assert(d >= 0, "delay is negative");
	    delay = d; count = 1;
	}

	/**
	 * Contructor for repetitive events to be scheduled periodically.
	 *
	 * @param a non-negative double representing the period length.  The
	 * first event is scheduled after this delay.
	 * @param an integer greater than <code>1</code> representing the
	 * number of times the event will be scheduled, or <code>0</code>
	 * meaning forever.
	 */
	public Time(double d, int c)
	{
	    Debug.assert(d >= 0, "delay is negative");
	    Debug.assert(c > 1 || c == 0,
			 "count is not zero nor greater than one");
	    delay = d; count = c;
	}

	/**
	 * Get next expire time for this event and decrement the count.  If
	 * the returned value is negative, this event should be deleted.  This
	 * call modifies the state of this object, and should be called
	 * exactly once for each time the event is scheduled.
	 *
	 * @return a double representing the delay after wich the event should
	 * be triggered.  If it is negative, the event should be deleted.
	 */
	public double nextDelay()
	{
	    if (--count < 0)
		return -1;
	    else
		return delay;
	}
    }

    public Entity target_entity;
    public Selector selector;
    public Selector.Params params;
    public double absolute_delay;
    public double deadline;
    public int repeat;

    private Linkable next;

    /**
     * Basic constructor
     * @param target_entity the entity the selector is applied to
     * @param selector the selector invoked by this event
     * @param params parameters used with the selector
     * @param absolute_delay the delay to wait before triggering the
     * selector
     * @param repeart number of iteration
     */
    public Event(Entity target_entity, Selector selector,
		 Selector.Params params, double absolute_delay, int repeat)
    {
	this.target_entity=target_entity;
	this.selector=selector;
	this.params=params;
	this.absolute_delay=absolute_delay;
	this.repeat=repeat;
    }

    /********************************************************************/

    /**
     * Check if this event has the same target as another event
     * This event is equal to the template in <code>event</code> if
     * 1) They use the same selector and the same entity
     *    -> <code>event</code> provides entity and selector
     * 2) They use the same selector
     *    -> <code>event</code> shows a <code>null</code> target entity
     *       meaning all entities supporting this selector.
     * 3) They use the same entity
     *    -> <code>event</code> shows a <code>null</code> selector, the target entity
     *       denotes the entity that is concerned.
     *
     * @param the event udes as template
     *
     * @return a boolean telling whether the two events are identical
     */
    public boolean sameTargetAs(Event event)
    {

	// Rule 1
	if(target_entity==event.target_entity &&
	   selector==event.selector)
	    {
		return(true);
	    }

	// Rule 2
	if(event.target_entity==null &&
	   event.selector!=null)
	    {
		if(selector.selector_id.
		   equals(event.selector.selector_id) &&
		   selector.entity_type.
		   equals(event.selector.entity_type))
		    {
			return(true);
		    }
	    }

	// Rule 3
	if(event.selector==null &&
	   event.target_entity!=null &&
	   event.target_entity==target_entity)
	    {
		return(true);
	    }

	return(false);
    }

    /********************************************************************/

    /**
     * Utility function to convert an event to a String
     *
     * @return a string representing the event
     */
    public String toString()
    {
	return("At " +
	       absolute_delay +
	       " (" + deadline +") -> " +
	       selector + "  on " + target_entity);
    }

    /**
     * Attach an event to this event
     *
     * @param object The event to attach
     */
    public void attach(Linkable object)
    {
	next=object;
    }

    /**
     * Get the attached object
     *
     * @return the Linkable object to this one
     */
    public Linkable nextOf()
    {
	return(next);
    }
}

/****
Local variables:
compile-command: "make -C .. -k"
tags-file-name: "../TAGS"
change-log-default-name: "../ChangeLog"
End:
****/
============================================================