[Doxygen-develop] Patches for doxygen

[Brendon C. <bc...@av...>]

Hi all,

I have been working on a project that interoperates with Doxygen to
produce accurate/complete documentation of C++ exception propagation.
Anyhow, in order to get my project to work I have had to make a few
patches to doxygen.

In particular the patches include:

-----------------
* Facility to match template types with "explicit" parameters for
defaults. For example:

void Function(std::vector<int>&);

can now be identified using:

void Function(std::vector<int,std::allocator<int> >&)

This works recursively and matches as best it can.


-----------------
* Merging of two sets of documentation for a single node.

For example:

/** \brief Brief 1.
 *
 * Detailed 1.
 */
void Function();

/** \fn Function1()
 * \brief Brief 2.
 *
 * Detailed 2.
 */

The patch will attempt to merge the two documentation blocks instead
of just ignoring the second. The resulting detailed section will include:

Detailed 1.
Detailed 2.

Where as the brief will only keep the first brief found. This is
because I could not think of a good way to merge two brief sections. I
may later choose to merge the second brief as a part of the detailed
section so it is not lots completely.


-----------------
* Updated processing of input source files to be processed in the
order they are declared in the doxygen configuration file instead of
alphabetical order.

   This was necessary because of the previous patch. I.e. the order of
processing was important to ensure that the "correct" brief
description was used for the documentation.


-----------------
* Type matches can now ignore a reference parameter to obtain a match.

   This is generally not a good idea. I can understand if this patch
is not accepted. I had to do it because of a limitation in my project.
The reasons for this are described below:

int BackFunction(std::string);
class C
{
   int Function(std::string s)
   {
      return BackFunction(s);
   }
};

The above code when compiled with GCC will be MODIFIED internally by
the compiler to look like:

int BackFunction(std::string);
class C
{
   int Function(std::string& s)
   {
      return BackFunction(s);
   }
};

Notice the & added after the std::string. My project uses GCC to
generate data files that are then processed and as such when it emits
the results, the function is emitted like:
int C::Function(std::string&)

which doxygen does not consider the same as:
int C::Function(std::string)

For good reason as it is NOT the same. Anyhow i needed to support this
(at least for now). I can understand if this would not be accepted
into doxygen as a result. I need to speak with the GCC devs more to
find out if there is a method of obtaining the actual declared name
for the above function that does not include the &.




Would the doxygen community be interested in accepting some or all of
these patches?

If so i will have to clean them up a little first (I used STL strings
and lists as I am comfortable with them and have never used the QT
ones before, so i will have to update the code to make use of the QT
utilities before submission of the patch).

For a reference the project is called EDoc++
http://edoc.sourceforge.net/


Thanks,
Brendon.