Switch from autodoc to doxygen for SDK C++ documentation.

* New build prerequisite doxygen (controllable via --with-doxygen).
* Adapted various headers to slightly different doxygen documentation
  syntax, but much clean up still remains to be done (i.e., warnings
  emitted by doxygen fixed).

13 files changed, 80 insertions, 78 deletions

diff --git a/cppu/inc/com/sun/star/uno/Any.h b/cppu/inc/com/sun/star/uno/Any.h
index eb29273c16aa..a2fe589682f4 100644
--- a/cppu/inc/com/sun/star/uno/Any.h
+++ b/cppu/inc/com/sun/star/uno/Any.h
@@ -55,19 +55,17 @@ namespace uno
 class Any : public uno_Any
 {
 public:
+    /// @cond INTERNAL
     // these are here to force memory de/allocation to sal lib.
-    /** @internal */
     inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () )
         { return ::rtl_allocateMemory( nSize ); }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
         { ::rtl_freeMemory( pMem ); }
-    /** @internal */
     inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () )
         { return pMem; }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
         {}
+    /// @endcond
 
     /** Default constructor: Any holds no value; its type is void.
     */
@@ -263,7 +261,7 @@ private:
 
 /** Template function to generically construct an any from a C++ value.
 
-    @tplparam C value type
+    @tparam C value type
     @param value a value
     @return an any
 */
@@ -279,7 +277,7 @@ class Type;
 
 /** Template binary <<= operator to set the value of an any.
 
-    @tplparam C value type
+    @tparam C value type
     @param rAny destination any (left side)
     @param value source value (right side)
 */
@@ -294,7 +292,7 @@ inline void SAL_CALL operator <<= ( Any & rAny, bool const & value )
     If the any does not contain a value that can be assigned without data loss, then this
     operation will fail returning false.
 
-    @tplparam C value type
+    @tparam C value type
     @param rAny source any (left side)
     @param value destination value (right side)
     @return true if assignment was possible without data loss
@@ -307,7 +305,7 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, C & value ) SAL_THROW(
     This operator can be implemented as template member function, if all supported compilers
     can cope with template member functions.
 
-    @tplparam C value type
+    @tparam C value type
     @param rAny another any (left side)
     @param value a value (right side)
     @return true if values are equal, false otherwise
@@ -319,7 +317,7 @@ inline sal_Bool SAL_CALL operator == ( const Any & rAny, const C & value ) SAL_T
     This operator can be implemented as template member function, if all supported compilers
     can cope with template member functions.
 
-    @tplparam C value type
+    @tparam C value type
     @param rAny another any (left side)
     @param value a value (right side)
     @return true if values are unequal, false otherwise
@@ -373,7 +371,8 @@ inline sal_Bool SAL_CALL operator == ( const Any & rAny, const BaseReference & v
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type any
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const ::com::sun::star::uno::Any * ) SAL_THROW( () )
diff --git a/cppu/inc/com/sun/star/uno/Reference.h b/cppu/inc/com/sun/star/uno/Reference.h
index 071cadcfde7b..d3611ac73105 100644
--- a/cppu/inc/com/sun/star/uno/Reference.h
+++ b/cppu/inc/com/sun/star/uno/Reference.h
@@ -164,7 +164,7 @@ enum UnoReference_QueryThrow
     */
     UNO_REF_QUERY_THROW
 };
-/** Enum defining UNO_SET_THROW for throwing if attempts are made to assign a <NULL/>
+/** Enum defining UNO_SET_THROW for throwing if attempts are made to assign a null
     interface
 
     @since UDK 3.2.8
@@ -238,19 +238,17 @@ class Reference : public BaseReference
     }
 
 public:
+    /// @cond INTERNAL
     // these are here to force memory de/allocation to sal lib.
-    /** @internal */
     inline static void * SAL_CALL operator new ( ::size_t nSize ) SAL_THROW( () )
         { return ::rtl_allocateMemory( nSize ); }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
         { ::rtl_freeMemory( pMem ); }
-    /** @internal */
     inline static void * SAL_CALL operator new ( ::size_t, void * pMem ) SAL_THROW( () )
         { return pMem; }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
         {}
+    /// @endcond
 
     /** Destructor: Releases interface if set.
     */
@@ -517,14 +515,15 @@ public:
     inline static Reference< interface_type > SAL_CALL query( XInterface * pInterface ) SAL_THROW( (RuntimeException) );
 };
 
-/** @internal
-    Enables boost::mem_fn and boost::bind to recognize Reference.
+/// @cond INTERNAL
+/** Enables boost::mem_fn and boost::bind to recognize Reference.
 */
 template <typename T>
 inline T * get_pointer( Reference<T> const& r )
 {
     return r.get();
 }
+/// @endcond
 
 }
 }
diff --git a/cppu/inc/com/sun/star/uno/Sequence.h b/cppu/inc/com/sun/star/uno/Sequence.h
index 68abc9d24748..13a4bf008352 100644
--- a/cppu/inc/com/sun/star/uno/Sequence.h
+++ b/cppu/inc/com/sun/star/uno/Sequence.h
@@ -57,41 +57,39 @@ namespace uno
     so the sequence keeps a handle to its data.  To keep value semantics,
     copies are only generated if the sequence is to be modified (new handle).
 
-    @tplparam E element type of sequence
+    @tparam E element type of sequence
 */
 template< class E >
 class Sequence
 {
     /** sequence handle
-        @internal
     */
     uno_Sequence * _pSequence;
 
 public:
+    /// @cond INTERNAL
+
     // these are here to force memory de/allocation to sal lib.
-    /** @internal */
     inline static void * SAL_CALL operator new ( ::size_t nSize )
         SAL_THROW( () )
         { return ::rtl_allocateMemory( nSize ); }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void * pMem )
         SAL_THROW( () )
         { ::rtl_freeMemory( pMem ); }
-    /** @internal */
     inline static void * SAL_CALL operator new ( ::size_t, void * pMem )
         SAL_THROW( () )
         { return pMem; }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void *, void * )
         SAL_THROW( () )
         {}
 
     /** Static pointer to typelib type of sequence.
         Don't use directly, call getCppuType().
-        @internal
     */
     static typelib_TypeDescriptionReference * s_pType;
 
+    /// @endcond
+
     /** typedefs the element type of the sequence
     */
     typedef E ElementType;
@@ -252,8 +250,9 @@ inline ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL toUnoSequence(
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @tplparam E element type of sequence
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
+    @tparam E element type of sequence
     @return type of IDL sequence
 */
 template< class E >
@@ -268,7 +267,7 @@ SAL_CALL getCppuType( const ::com::sun::star::uno::Sequence< E > * )
 
     @attention
     the given element type must be the same as the template argument type!
-    @tplparam E element type of sequence
+    @tparam E element type of sequence
     @param rElementType element type of sequence
     @return type of IDL sequence
 */
@@ -280,7 +279,8 @@ SAL_CALL getCppuSequenceType( const ::com::sun::star::uno::Type & rElementType )
 /** Gets the meta type of IDL sequence< char >.
     This function has been introduced due to ambiguities with unsigned short.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL sequence< char >
 */
 inline const ::com::sun::star::uno::Type &
diff --git a/cppu/inc/com/sun/star/uno/Sequence.hxx b/cppu/inc/com/sun/star/uno/Sequence.hxx
index 8a9b43d1339e..c86c629df7bc 100644
--- a/cppu/inc/com/sun/star/uno/Sequence.hxx
+++ b/cppu/inc/com/sun/star/uno/Sequence.hxx
@@ -45,9 +45,10 @@ namespace star
 namespace uno
 {
 
-//______________________________________________________________________________
+/// @cond INTERNAL
 template< class E >
 typelib_TypeDescriptionReference * Sequence< E >::s_pType = 0;
+/// @endcond
 
 //______________________________________________________________________________
 template< class E >
diff --git a/cppu/inc/com/sun/star/uno/Type.h b/cppu/inc/com/sun/star/uno/Type.h
index 6490fa4ab7f1..2072d6accc82 100644
--- a/cppu/inc/com/sun/star/uno/Type.h
+++ b/cppu/inc/com/sun/star/uno/Type.h
@@ -66,24 +66,21 @@ enum UnoType_NoAcquire
 class Type
 {
     /** the C typelib reference pointer
-        @internal
     */
     typelib_TypeDescriptionReference * _pType;
 
 public:
+    /// @cond INTERNAL
     // these are here to force memory de/allocation to sal lib.
-    /** @internal */
     inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () )
         { return ::rtl_allocateMemory( nSize ); }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
         { ::rtl_freeMemory( pMem ); }
-    /** @internal */
     inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () )
         { return pMem; }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
         {}
+    /// @endcond
 
     /** Default Constructor: Type is set to void.
     */
@@ -222,7 +219,8 @@ public:
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type "type"
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const ::com::sun::star::uno::Type * ) SAL_THROW( () );
@@ -252,7 +250,8 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getBooleanCppuType() SAL_THR
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type boolean
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Bool * ) SAL_THROW( () );
@@ -261,7 +260,8 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Bool
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type boolean
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType(
@@ -283,7 +283,8 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuCharType() SAL_THROW(
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type byte
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int8 * ) SAL_THROW( () );
@@ -293,7 +294,8 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int8
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type string
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const ::rtl::OUString * ) SAL_THROW( () );
@@ -303,7 +305,8 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const ::rtl::OU
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type short
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int16 * ) SAL_THROW( () );
@@ -313,7 +316,8 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int16
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type unsigned short
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt16 * ) SAL_THROW( () );
@@ -323,7 +327,8 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt1
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type long
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int32 * ) SAL_THROW( () );
@@ -333,7 +338,8 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int32
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type unsigned long
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt32 * ) SAL_THROW( () );
@@ -343,7 +349,8 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt3
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type hyper
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int64 * ) SAL_THROW( () );
@@ -353,7 +360,8 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int64
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type unsigned hyper
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt64 * ) SAL_THROW( () );
@@ -363,7 +371,8 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt6
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type float
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const float * ) SAL_THROW( () );
@@ -373,7 +382,8 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const float * )
     There are cases (involving templates) where uses of getCppuType are known to
     not compile.  Use cppu::UnoType or cppu::getTypeFavourUnsigned instead.
 
-    @param dummy typed pointer for function signature
+    The dummy parameter is just a typed pointer for function signature.
+
     @return type of IDL type double
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const double * ) SAL_THROW( () );
diff --git a/cppu/inc/cppu/macros.hxx b/cppu/inc/cppu/macros.hxx
index 5c123e7aecd9..78df3151be8c 100644
--- a/cppu/inc/cppu/macros.hxx
+++ b/cppu/inc/cppu/macros.hxx
@@ -34,6 +34,8 @@
 /** Namespace name for compiler/ platform, e.g. gcc3, msci */
 #define CPPU_CURRENT_NAMESPACE CPPU_ENV
 
+/// @cond INTERNAL
+
 /** Patching the GCC 3 incomatible alignment change for Linux.
 
     This macro is appended by cppumaker to every first member of a struct, if
@@ -42,8 +44,6 @@
     bug in GCC prior to version 3.3, which would cause __alignof__ of such a
     struct to become 8 instead of 4 if CPPU_GCC3_ALIGN were added to its first
     member.)
-
-    @internal
 */
 #if defined(__GNUC__) && (__GNUC__ >= 3)
 #define CPPU_GCC3_ALIGN( base_struct ) __attribute__ ((aligned (__alignof__ (base_struct))))
@@ -56,12 +56,12 @@
 
    These macros are used in the headers generated by cppumaker for UNO exception
    types, to ensure that exception handling does not fail on GCC.
-
-   @internal
 */
 #define CPPU_GCC_DLLPUBLIC_EXPORT SAL_EXCEPTION_DLLPUBLIC_EXPORT
 #define CPPU_GCC_DLLPRIVATE SAL_EXCEPTION_DLLPRIVATE
 
+/// @endcond
+
 #endif  // _CPPU_MACROS_HXX_
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/inc/cppu/unotype.hxx b/cppu/inc/cppu/unotype.hxx
index b8df4e07a1b0..eedd01d7c7fb 100644
--- a/cppu/inc/cppu/unotype.hxx
+++ b/cppu/inc/cppu/unotype.hxx
@@ -320,6 +320,8 @@ template< typename T > inline ::com::sun::star::uno::Type const &
 getTypeFavourUnsigned(::com::sun::star::uno::Sequence< T > const *);
     // defined in com/sun/star/uno/Sequence.hxx
 
+/// @cond INTERNAL
+
 /**
    A working replacement for getCppuType (see there).
 
@@ -329,8 +331,6 @@ getTypeFavourUnsigned(::com::sun::star::uno::Sequence< T > const *);
    type CHAR but not for the UNO type UNSIGNED SHORT.  Additionally, it also
    returns the intended results for sequence types.
 
-   @internal
-
    @since UDK 3.2.3
 */
 template< typename T > inline ::com::sun::star::uno::Type const &
@@ -347,8 +347,6 @@ getTypeFavourChar(T const *) {
    type CHAR but not for the UNO type UNSIGNED SHORT.  Additionally, it also
    returns the intended results for sequence types.
 
-   @internal
-
    @since UDK 3.2.3
 */
 inline ::com::sun::star::uno::Type const &
@@ -365,14 +363,14 @@ getTypeFavourChar(::sal_Unicode const *) {
    type CHAR but not for the UNO type UNSIGNED SHORT.  Additionally, it also
    returns the intended results for sequence types.
 
-   @internal
-
    @since UDK 3.2.3
 */
 template< typename T > inline ::com::sun::star::uno::Type const &
 getTypeFavourChar(::com::sun::star::uno::Sequence< T > const *);
     // defined in com/sun/star/uno/Sequence.hxx
 
+/// @endcond
+
 }
 
 #endif
diff --git a/cppu/inc/typelib/typedescription.h b/cppu/inc/typelib/typedescription.h
index 333fc1c01dfd..6494e7c15a89 100644
--- a/cppu/inc/typelib/typedescription.h
+++ b/cppu/inc/typelib/typedescription.h
@@ -407,7 +407,6 @@ typedef struct _typelib_InterfaceAttributeTypeDescription
     typelib_TypeDescriptionReference **         ppSetExceptions;
 } typelib_InterfaceAttributeTypeDescription;
 
-/// @HTML
 /** Type description of an interface.
 
     <p>Not all members are always initialized (not yet initialized members being
@@ -871,12 +870,13 @@ CPPU_DLLPUBLIC void SAL_CALL typelib_typedescription_revokeCallback(
 /*----------------------------------------------------------------------------*/
 /*----------------------------------------------------------------------------*/
 
+/// @cond INTERNAL
+
 /** Returns true, if the type description reference may lose the type description. Otherwise
     pType is a valid pointer and cannot be discarded through the lifetime of this reference.
     Remark: If the pWeakObj of the type is set too, you can avoid the call of
     ...getDescription(...) and use the description directly. pWeakObj == 0 means, that the
     description is not initialized.
-    @internal
 */
 #define TYPELIB_TYPEDESCRIPTIONREFERENCE_ISREALLYWEAK( eTypeClass ) \
     ((eTypeClass) == typelib_TypeClass_INTERFACE_METHOD || \
@@ -885,7 +885,6 @@ CPPU_DLLPUBLIC void SAL_CALL typelib_typedescription_revokeCallback(
 /** Gets a description from the reference. The description may not be locked by this call.
     You must use the TYPELIB_DANGER_RELEASE macro to release the description fetched with
     this macro.
-    @internal
 */
 #define TYPELIB_DANGER_GET( ppDescription, pTypeRef ) \
 { \
@@ -908,7 +907,6 @@ CPPU_DLLPUBLIC void SAL_CALL typelib_typedescription_revokeCallback(
 }
 
 /** Releases the description previouse fetched by TYPELIB_DANGER_GET.
-    @internal
 */
 #define TYPELIB_DANGER_RELEASE( pDescription ) \
 { \
@@ -916,6 +914,8 @@ CPPU_DLLPUBLIC void SAL_CALL typelib_typedescription_revokeCallback(
         typelib_typedescription_release( pDescription ); \
 }
 
+/// @endcond
+
 /** Creates a type description reference. This is a weak reference not holding the description.
     If the description is already registered, the previous one is returned.
 
diff --git a/cppu/inc/typelib/typedescription.hxx b/cppu/inc/typelib/typedescription.hxx
index 3997f3d9c14d..2e3e72f5491d 100644
--- a/cppu/inc/typelib/typedescription.hxx
+++ b/cppu/inc/typelib/typedescription.hxx
@@ -55,19 +55,17 @@ class TypeDescription
     mutable typelib_TypeDescription * _pTypeDescr;
 
 public:
+    /// @cond INTERNAL
     // these are here to force memory de/allocation to sal lib.
-    /** @internal */
     inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () )
         { return ::rtl_allocateMemory( nSize ); }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
         { ::rtl_freeMemory( pMem ); }
-    /** @internal */
     inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () )
         { return pMem; }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
         {}
+    /// @endcond
 
     /** Constructor:
 
diff --git a/cppu/inc/uno/current_context.hxx b/cppu/inc/uno/current_context.hxx
index 01d59a460eca..80a7ad8d56b3 100644
--- a/cppu/inc/uno/current_context.hxx
+++ b/cppu/inc/uno/current_context.hxx
@@ -77,11 +77,9 @@ inline bool SAL_CALL setCurrentContext(
 class ContextLayer
 {
     /** this C++ environment type name.
-        @internal
     */
     ::rtl::OUString m_aEnvTypeName;
     /** previous context
-        @internal
     */
     Reference< XCurrentContext > m_xPreviousContext;
 
diff --git a/cppu/inc/uno/dispatcher.hxx b/cppu/inc/uno/dispatcher.hxx
index 90fdb3db6df7..c6573354729f 100644
--- a/cppu/inc/uno/dispatcher.hxx
+++ b/cppu/inc/uno/dispatcher.hxx
@@ -31,6 +31,7 @@
 
 #include "uno/dispatcher.h"
 
+/// @cond INTERNAL
 
 namespace com
 {
@@ -45,7 +46,7 @@ namespace uno
     subject to changes.
 
     @see uno_Interface
-    @internal
+    @attention
               not for public use!
 */
 class UnoInterfaceReference
@@ -172,6 +173,8 @@ inline void UnoInterfaceReference::dispatch(
 }
 }
 
+/// @endcond
+
 #endif
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/inc/uno/environment.hxx b/cppu/inc/uno/environment.hxx
index 8fa4f3ea5063..61b6b7aa275e 100644
--- a/cppu/inc/uno/environment.hxx
+++ b/cppu/inc/uno/environment.hxx
@@ -66,19 +66,17 @@ public:
     */
     inline static Environment getCurrent(rtl::OUString const & typeName = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(CPPU_STRINGIFY(CPPU_ENV)))) SAL_THROW( () );
 
+    /// @cond INTERNAL
     // these are here to force memory de/allocation to sal lib.
-    /** @internal */
     inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () )
         { return ::rtl_allocateMemory( nSize ); }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
         { ::rtl_freeMemory( pMem ); }
-    /** @internal */
     inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () )
         { return pMem; }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
         {}
+    /// @endcond
 
     /** Constructor: acquires given environment
 
diff --git a/cppu/inc/uno/mapping.hxx b/cppu/inc/uno/mapping.hxx
index a183cf089de3..2e50164d1c14 100644
--- a/cppu/inc/uno/mapping.hxx
+++ b/cppu/inc/uno/mapping.hxx
@@ -60,18 +60,16 @@ class Mapping
 
 public:
     // these are here to force memory de/allocation to sal lib.
-    /** @internal */
+    /// @cond INTERNAL
     inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () )
         { return ::rtl_allocateMemory( nSize ); }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
         { ::rtl_freeMemory( pMem ); }
-    /** @internal */
     inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () )
         { return pMem; }
-    /** @internal */
     inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
         {}
+    /// @endcond
 
     /** Holds a mapping from the specified source to the specified destination by environment
         type names.
@@ -305,7 +303,7 @@ inline void * Mapping::mapInterface(
 
     Maps an binary C UNO interface to be used in the currently used compiler environment.
 
-    @tplparam C interface type
+    @tparam C interface type
     @param ppRet inout returned interface pointer
     @param pUnoI binary C UNO interface
     @return true if successful, false otherwise
@@ -328,7 +326,7 @@ inline sal_Bool mapToCpp( Reference< C > * ppRet, uno_Interface * pUnoI ) SAL_TH
 
     Maps an UNO interface of the currently used compiler environment to binary C UNO.
 
-    @tplparam C interface type
+    @tparam C interface type
     @param ppRet inout returned interface pointer
     @param x interface reference
     @return true if successful, false otherwise