Doxygenization of comments.

1 files changed, 227 insertions, 245 deletions

diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index 8f5ff050dd6..f315da53393 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -14,7 +14,12 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 
-/* This file defines all compare functions */
+/**
+  @file
+
+  @brief
+  This file defines all compare functions
+*/
 
 #ifdef USE_PRAGMA_IMPLEMENTATION
 #pragma implementation				// gcc: Class implementation
@@ -104,7 +109,7 @@ static int cmp_row_type(Item* item1, Item* item2)
 }
 
 
-/*
+/**
   Aggregates result types from the array of items.
 
   SYNOPSIS:
@@ -117,11 +122,13 @@ static int cmp_row_type(Item* item1, Item* item2)
     This function aggregates result types from the array of items. Found type
     supposed to be used later for comparison of values of these items.
     Aggregation itself is performed by the item_cmp_type() function.
-    The function also checks compatibility of row signatures for the
-    submitted items (see the spec for the cmp_row_type function). 
+  @param[out] type    the aggregated type
+  @param      items        array of items to aggregate the type from
+  @param      nitems       number of items in the array
 
-  RETURN VALUES
+  @retval
     1  type incompatibility has been detected
+  @retval
     0  otherwise
 */
 
@@ -257,10 +264,11 @@ void Item_func_not::print(String *str)
   str->append(')');
 }
 
-/*
-  special NOT for ALL subquery
+/**
+  special NOT for ALL subquery.
 */
 
+
 longlong Item_func_not_all::val_int()
 {
   DBUG_ASSERT(fixed == 1);
@@ -293,10 +301,13 @@ void Item_func_not_all::print(String *str)
 }
 
 
-/*
-  Special NOP (No OPeration) for ALL subquery it is like  Item_func_not_all
-  (return TRUE if underlying subquery do not return rows) but if subquery
-  returns some rows it return same value as argument (TRUE/FALSE).
+/**
+  Special NOP (No OPeration) for ALL subquery. It is like
+  Item_func_not_all.
+
+  @return
+    (return TRUE if underlying subquery do not return rows) but if subquery
+    returns some rows it return same value as argument (TRUE/FALSE).
 */
 
 longlong Item_func_nop_all::val_int()
@@ -316,16 +327,9 @@ longlong Item_func_nop_all::val_int()
 }
 
 
-/*
-  Convert a constant item to an int and replace the original item
+/**
+  Convert a constant item to an int and replace the original item.
 
-  SYNOPSIS
-    convert_constant_item()
-    thd             thread handle
-    field           item will be converted using the type of this field
-    item  [in/out]  reference to the item to convert
-
-  DESCRIPTION
     The function converts a constant expression or string to an integer.
     On successful conversion the original item is substituted for the
     result of the item evaluation.
@@ -333,16 +337,21 @@ longlong Item_func_nop_all::val_int()
     also when comparing bigint to strings (in which case strings
     are converted to bigints).
 
-  NOTES
+  @param  thd             thread handle
+  @param  field           item will be converted using the type of this field
+  @param[in,out] item     reference to the item to convert
+
+  @note
     This function is called only at prepare stage.
     As all derived tables are filled only after all derived tables
     are prepared we do not evaluate items with subselects here because
     they can contain derived tables and thus we may attempt to use a
     table that has not been populated yet.
 
-  RESULT VALUES
-  0	Can't convert item
-  1	Item was replaced with an integer version of the item
+  @retval
+    0	Can't convert item
+  @retval
+    1	Item was replaced with an integer version of the item
 */
 
 static bool convert_constant_item(THD *thd, Field *field, Item **item)
@@ -1013,13 +1022,15 @@ int Arg_comparator::compare_string()
 }
 
 
-/*
+/**
   Compare strings byte by byte. End spaces are also compared.
 
-  RETURN
-   < 0	*a < *b
-   0	*b == *b
-   > 0	*a > *b
+  @retval
+    <0	*a < *b
+  @retval
+    0	*b == *b
+  @retval
+    >0	*a > *b
 */
 
 int Arg_comparator::compare_binary_string()
@@ -1041,10 +1052,11 @@ int Arg_comparator::compare_binary_string()
 }
 
 
-/*
-  Compare strings, but take into account that NULL == NULL
+/**
+  Compare strings, but take into account that NULL == NULL.
 */
 
+
 int Arg_comparator::compare_e_string()
 {
   String *res1,*res2;
@@ -1185,7 +1197,7 @@ int Arg_comparator::compare_int_signed()
 }
 
 
-/*
+/**
   Compare values as BIGINT UNSIGNED.
 */
 
@@ -1208,7 +1220,7 @@ int Arg_comparator::compare_int_unsigned()
 }
 
 
-/*
+/**
   Compare signed (*a) with unsigned (*B)
 */
 
@@ -1233,7 +1245,7 @@ int Arg_comparator::compare_int_signed_unsigned()
 }
 
 
-/*
+/**
   Compare unsigned (*a) with signed (*B)
 */
 
@@ -1269,7 +1281,7 @@ int Arg_comparator::compare_e_int()
   return test(val1 == val2);
 }
 
-/*
+/**
   Compare unsigned *a with signed *b or signed *a with unsigned *b.
 */
 int Arg_comparator::compare_e_int_diff_signedness()
@@ -1558,7 +1570,7 @@ longlong Item_func_eq::val_int()
 }
 
 
-/* Same as Item_func_eq, but NULL = NULL */
+/** Same as Item_func_eq, but NULL = NULL. */
 
 void Item_func_equal::fix_length_and_dec()
 {
@@ -1709,21 +1721,18 @@ void Item_func_interval::fix_length_and_dec()
 }
 
 
-/*
-  Execute Item_func_interval()
-
-  SYNOPSIS
-    Item_func_interval::val_int()
+/**
+  Execute Item_func_interval().
 
-  NOTES
-    If we are doing a decimal comparison, we are
-    evaluating the first item twice.
+  @note
+    If we are doing a decimal comparison, we are evaluating the first
+    item twice.
 
-  RETURN
-    -1 if null value,
-    0 if lower than lowest
-    1 - arg_count-1 if between args[n] and args[n+1]
-    arg_count if higher than biggest argument
+  @return
+    - -1 if null value,
+    - 0 if lower than lowest
+    - 1 - arg_count-1 if between args[n] and args[n+1]
+    - arg_count if higher than biggest argument
 */
 
 longlong Item_func_interval::val_int()
@@ -1795,32 +1804,31 @@ longlong Item_func_interval::val_int()
 }
 
 
-/*
-  Perform context analysis of a BETWEEN item tree
-
-  SYNOPSIS:
-    fix_fields()
-    thd     reference to the global context of the query thread
-    tables  list of all open tables involved in the query
-    ref     pointer to Item* variable where pointer to resulting "fixed"
-            item is to be assigned
+/**
+  Perform context analysis of a BETWEEN item tree.
 
-  DESCRIPTION
     This function performs context analysis (name resolution) and calculates
     various attributes of the item tree with Item_func_between as its root.
     The function saves in ref the pointer to the item or to a newly created
     item that is considered as a replacement for the original one.
 
-  NOTES
+  @param thd     reference to the global context of the query thread
+  @param ref     pointer to Item* variable where pointer to resulting "fixed"
+                 item is to be assigned
+
+  @note
     Let T0(e)/T1(e) be the value of not_null_tables(e) when e is used on
     a predicate/function level. Then it's easy to show that:
+    @verbatim
       T0(e BETWEEN e1 AND e2)     = union(T1(e),T1(e1),T1(e2))
       T1(e BETWEEN e1 AND e2)     = union(T1(e),intersection(T1(e1),T1(e2)))
       T0(e NOT BETWEEN e1 AND e2) = union(T1(e),intersection(T1(e1),T1(e2)))
       T1(e NOT BETWEEN e1 AND e2) = union(T1(e),intersection(T1(e1),T1(e2)))
+    @endverbatim
 
-  RETURN
+  @retval
     0   ok
+  @retval
     1   got error
 */
 
@@ -2156,30 +2164,29 @@ Item_func_ifnull::str_op(String *str)
 }
 
 
-/*
-  Perform context analysis of an IF item tree
-
-  SYNOPSIS:
-    fix_fields()
-    thd     reference to the global context of the query thread
-    tables  list of all open tables involved in the query
-    ref     pointer to Item* variable where pointer to resulting "fixed"
-            item is to be assigned
+/**
+  Perform context analysis of an IF item tree.
 
-  DESCRIPTION
     This function performs context analysis (name resolution) and calculates
     various attributes of the item tree with Item_func_if as its root.
     The function saves in ref the pointer to the item or to a newly created
     item that is considered as a replacement for the original one.
 
-  NOTES
+  @param thd     reference to the global context of the query thread
+  @param ref     pointer to Item* variable where pointer to resulting "fixed"
+                 item is to be assigned
+
+  @note
     Let T0(e)/T1(e) be the value of not_null_tables(e) when e is used on
     a predicate/function level. Then it's easy to show that:
+    @verbatim
       T0(IF(e,e1,e2)  = T1(IF(e,e1,e2))
       T1(IF(e,e1,e2)) = intersection(T1(e1),T1(e2))
+    @endverbatim
 
-  RETURN
+  @retval
     0   ok
+  @retval
     1   got error
 */
 
@@ -2321,11 +2328,14 @@ Item_func_nullif::fix_length_and_dec()
 }
 
 
-/*
-  nullif () returns NULL if arguments are equal, else it returns the
-  first argument.
+/**
+  @note
   Note that we have to evaluate the first argument twice as the compare
   may have been done with a different type than return value
+  @return
+    NULL  if arguments are equal
+  @return
+    the first argument if not equal
 */
 
 double
@@ -2397,14 +2407,7 @@ Item_func_nullif::is_null()
 }
 
 
-/*
-  Return the matching ITEM or NULL if all compares (including else) failed
-
-  SYNOPSIS
-    find_item()
-      str      Buffer string
-
-  DESCRIPTION
+/**
     Find and return matching items for CASE or ELSE item if all compares
     are failed or NULL if ELSE item isn't defined.
 
@@ -2418,9 +2421,10 @@ Item_func_nullif::is_null()
     to it according to their int values i.e. STRING_RESULT is mapped to bit
     0, REAL_RESULT to bit 1, so on.
 
-  RETURN
-    NULL - Nothing found and there is no ELSE expression defined
-    item - Found item or ELSE item if defined and all comparisons are
+  @retval
+    NULL  Nothing found and there is no ELSE expression defined
+  @retval
+    item  Found item or ELSE item if defined and all comparisons are
            failed
 */
 
@@ -2645,7 +2649,10 @@ uint Item_func_case::decimal_precision() const
 }
 
 
-/* TODO:  Fix this so that it prints the whole CASE expression */
+/**
+  @todo
+    Fix this so that it prints the whole CASE expression
+*/
 
 void Item_func_case::print(String *str)
 {
@@ -2687,7 +2694,7 @@ void Item_func_case::cleanup()
 }
 
 
-/*
+/**
   Coalesce - return first not NULL argument.
 */
 
@@ -3305,32 +3312,31 @@ bool Item_func_in::nulls_in_row()
 }
 
 
-/*
-  Perform context analysis of an IN item tree
-
-  SYNOPSIS:
-    fix_fields()
-    thd     reference to the global context of the query thread
-    tables  list of all open tables involved in the query
-    ref     pointer to Item* variable where pointer to resulting "fixed"
-            item is to be assigned
+/**
+  Perform context analysis of an IN item tree.
 
-  DESCRIPTION
     This function performs context analysis (name resolution) and calculates
     various attributes of the item tree with Item_func_in as its root.
     The function saves in ref the pointer to the item or to a newly created
     item that is considered as a replacement for the original one.
 
-  NOTES
+  @param thd     reference to the global context of the query thread
+  @param ref     pointer to Item* variable where pointer to resulting "fixed"
+                 item is to be assigned
+
+  @note
     Let T0(e)/T1(e) be the value of not_null_tables(e) when e is used on
     a predicate/function level. Then it's easy to show that:
+    @verbatim
       T0(e IN(e1,...,en))     = union(T1(e),intersection(T1(ei)))
       T1(e IN(e1,...,en))     = union(T1(e),intersection(T1(ei)))
       T0(e NOT IN(e1,...,en)) = union(T1(e),union(T1(ei)))
       T1(e NOT IN(e1,...,en)) = union(T1(e),intersection(T1(ei)))
+    @endverbatim
 
-  RETURN
+  @retval
     0   ok
+  @retval
     1   got error
 */
 
@@ -3805,25 +3811,22 @@ bool Item_cond::walk(Item_processor processor, bool walk_subquery, uchar *arg)
 }
 
 
-/*
-  Transform an Item_cond object with a transformer callback function
-   
-  SYNOPSIS
-    transform()
-      transformer   the transformer callback function to be applied to the nodes
-                    of the tree of the object
-      arg           parameter to be passed to the transformer
-  
-  DESCRIPTION
+/**
+  Transform an Item_cond object with a transformer callback function.
+
     The function recursively applies the transform method to each
-     member item of the condition list.
+    member item of the condition list.
     If the call of the method for a member item returns a new item
     the old item is substituted for a new one.
     After this the transformer is applied to the root node
-    of the Item_cond object. 
-     
-  RETURN VALUES
-    Item returned as the result of transformation of the root node 
+    of the Item_cond object.
+ 
+  @param transformer   the transformer callback function to be applied to
+                       the nodes of the tree of the object
+  @param arg           parameter to be passed to the transformer
+
+  @return
+    Item returned as the result of transformation of the root node
 */
 
 Item *Item_cond::transform(Item_transformer transformer, uchar *arg)
@@ -3851,19 +3854,10 @@ Item *Item_cond::transform(Item_transformer transformer, uchar *arg)
 }
 
 
-/*
-  Compile Item_cond object with a processor and a transformer callback functions
-   
-  SYNOPSIS
-    compile()
-      analyzer      the analyzer callback function to be applied to the nodes
-                    of the tree of the object
-      arg_p         in/out parameter to be passed to the analyzer
-      transformer   the transformer callback function to be applied to the nodes
-                    of the tree of the object
-      arg_t         parameter to be passed to the transformer
-  
-  DESCRIPTION
+/**
+  Compile Item_cond object with a processor and a transformer
+  callback functions.
+
     First the function applies the analyzer to the root node of
     the Item_func object. Then if the analyzer succeeeds (returns TRUE)
     the function recursively applies the compile method to member
@@ -3872,9 +3866,16 @@ Item *Item_cond::transform(Item_transformer transformer, uchar *arg)
     the old item is substituted for a new one.
     After this the transformer is applied to the root node
     of the Item_cond object. 
-     
-  RETURN VALUES
-    Item returned as the result of transformation of the root node 
+
+  @param analyzer      the analyzer callback function to be applied to the
+                       nodes of the tree of the object
+  @param[in,out] arg_p parameter to be passed to the analyzer
+  @param transformer   the transformer callback function to be applied to the
+                       nodes of the tree of the object
+  @param arg_t         parameter to be passed to the transformer
+
+  @return
+    Item returned as the result of transformation of the root node
 */
 
 Item *Item_cond::compile(Item_analyzer analyzer, uchar **arg_p,
@@ -3923,23 +3924,21 @@ void Item_cond::traverse_cond(Cond_traverser traverser,
   }
 }
 
-/*
-  Move SUM items out from item tree and replace with reference
+/**
+  Move SUM items out from item tree and replace with reference.
 
-  SYNOPSIS
-    split_sum_func()
-    thd			Thread handler
-    ref_pointer_array	Pointer to array of reference fields
-    fields		All fields in select
-
-  NOTES
-   This function is run on all expression (SELECT list, WHERE, HAVING etc)
-   that have or refer (HAVING) to a SUM expression.
-
-   The split is done to get an unique item for each SUM function
-   so that we can easily find and calculate them.
-   (Calculation done by update_sum_func() and copy_sum_funcs() in
-   sql_select.cc)
+  The split is done to get an unique item for each SUM function
+  so that we can easily find and calculate them.
+  (Calculation done by update_sum_func() and copy_sum_funcs() in
+  sql_select.cc)
+
+  @param thd			Thread handler
+  @param ref_pointer_array	Pointer to array of reference fields
+  @param fields		All fields in select
+
+  @note
+    This function is run on all expression (SELECT list, WHERE, HAVING etc)
+    that have or refer (HAVING) to a SUM expression.
 */
 
 void Item_cond::split_sum_func(THD *thd, Item **ref_pointer_array,
@@ -4010,20 +4009,22 @@ void Item_cond::neg_arguments(THD *thd)
 }
 
 
-/*
-  Evaluation of AND(expr, expr, expr ...)
+/**
+  Evaluation of AND(expr, expr, expr ...).
 
-  NOTES:
+  @note
     abort_if_null is set for AND expressions for which we don't care if the
     result is NULL or 0. This is set for:
     - WHERE clause
     - HAVING clause
     - IF(expression)
 
-  RETURN VALUES
+  @retval
     1  If all expressions are true
+  @retval
     0  If all expressions are false or if we find a NULL expression and
-       'abort_on_null' is set.
+    'abort_on_null' is set.
+  @retval
     NULL if all expression are either 1 or NULL
 */
 
@@ -4065,24 +4066,23 @@ longlong Item_cond_or::val_int()
   return 0;
 }
 
-/*
-  Create an AND expression from two expressions
+/**
+  Create an AND expression from two expressions.
 
-  SYNOPSIS
-   and_expressions()
-   a		expression or NULL
-   b    	expression.
-   org_item	Don't modify a if a == *org_item
-		If a == NULL, org_item is set to point at b,
-		to ensure that future calls will not modify b.
-
-  NOTES
+  @param a	expression or NULL
+  @param b    	expression.
+  @param org_item	Don't modify a if a == *org_item.
+                       If a == NULL, org_item is set to point at b,
+                       to ensure that future calls will not modify b.
+
+  @note
     This will not modify item pointed to by org_item or b
     The idea is that one can call this in a loop and create and
     'and' over all items without modifying any of the original items.
 
-  RETURN
+  @retval
     NULL	Error
+  @retval
     Item
 */
 
@@ -4140,7 +4140,9 @@ longlong Item_is_not_null_test::val_int()
     DBUG_RETURN(1);
 }
 
-/* Optimize case of not_null_column IS NULL */
+/**
+  Optimize case of not_null_column IS NULL.
+*/
 void Item_is_not_null_test::update_used_tables()
 {
   if (!args[0]->maybe_null)
@@ -4200,7 +4202,9 @@ longlong Item_func_like::val_int()
 }
 
 
-/* We can optimize a where if first character isn't a wildcard */
+/**
+  We can optimize a where if first character isn't a wildcard
+*/
 
 Item_func::optimize_type Item_func_like::select_optimize() const
 {
@@ -4463,10 +4467,9 @@ void Item_func_regex::cleanup()
 #endif
 
 
-/**********************************************************************
-  turboBM_compute_suffixes()
+/**
   Precomputation dependent only on pattern_len.
-**********************************************************************/
+*/
 
 void Item_func_like::turboBM_compute_suffixes(int *suff)
 {
@@ -4520,10 +4523,9 @@ void Item_func_like::turboBM_compute_suffixes(int *suff)
 }
 
 
-/**********************************************************************
-   turboBM_compute_good_suffix_shifts()
-   Precomputation dependent only on pattern_len.
-**********************************************************************/
+/**
+  Precomputation dependent only on pattern_len.
+*/
 
 void Item_func_like::turboBM_compute_good_suffix_shifts(int *suff)
 {
@@ -4565,10 +4567,9 @@ void Item_func_like::turboBM_compute_good_suffix_shifts(int *suff)
 }
 
 
-/**********************************************************************
-   turboBM_compute_bad_character_shifts()
-   Precomputation dependent on pattern_len.
-**********************************************************************/
+/**
+  Precomputation dependent on pattern_len.
+*/
 
 void Item_func_like::turboBM_compute_bad_character_shifts()
 {
@@ -4594,10 +4595,12 @@ void Item_func_like::turboBM_compute_bad_character_shifts()
 }
 
 
-/**********************************************************************
-  turboBM_matches()
-  Search for pattern in text, returns true/false for match/no match
-**********************************************************************/
+/**
+  Search for pattern in text.
+
+  @return
+    returns true/false for match/no match
+*/
 
 bool Item_func_like::turboBM_matches(const char* text, int text_len) const
 {
@@ -4677,24 +4680,20 @@ bool Item_func_like::turboBM_matches(const char* text, int text_len) const
 }
 
 
-/*
+/**
   Make a logical XOR of the arguments.
 
-  SYNOPSIS
-    val_int()
-
-  DESCRIPTION
   If either operator is NULL, return NULL.
 
-  NOTE
-    As we don't do any index optimization on XOR this is not going to be
-    very fast to use.
-
-  TODO (low priority)
-    Change this to be optimized as:
-      A XOR B   ->  (A) == 1 AND (B) <> 1) OR (A <> 1 AND (B) == 1)
+  @todo
+    (low priority) Change this to be optimized as: @n
+    A XOR B   ->  (A) == 1 AND (B) <> 1) OR (A <> 1 AND (B) == 1) @n
     To be able to do this, we would however first have to extend the MySQL
     range optimizer to handle OR better.
+
+  @note
+    As we don't do any index optimization on XOR this is not going to be
+    very fast to use.
 */
 
 longlong Item_cond_xor::val_int()
@@ -4716,15 +4715,12 @@ longlong Item_cond_xor::val_int()
   return (longlong) result;
 }
 
-/*
+/**
   Apply NOT transformation to the item and return a new one.
 
-  SYNOPSIS
-    neg_transformer()
-    thd		thread handler
 
-  DESCRIPTION
     Transform the item using next rules:
+    @verbatim
        a AND b AND ...    -> NOT(a) OR NOT(b) OR ...
        a OR b OR ...      -> NOT(a) AND NOT(b) AND ...
        NOT(a)             -> a
@@ -4736,8 +4732,11 @@ longlong Item_cond_xor::val_int()
        a <= b             -> a > b
        IS NULL(a)         -> IS NOT NULL(a)
        IS NOT NULL(a)     -> IS NULL(a)
+    @endverbatim
 
-  RETURN
+  @param thd		thread handler
+
+  @return
     New item or
     NULL if we cannot apply NOT transformation (see Item::neg_transformer()).
 */
@@ -4755,7 +4754,9 @@ Item *Item_bool_rowready_func2::neg_transformer(THD *thd)
 }
 
 
-/* a IS NULL  ->  a IS NOT NULL */
+/**
+  a IS NULL  ->  a IS NOT NULL.
+*/
 Item *Item_func_isnull::neg_transformer(THD *thd)
 {
   Item *item= new Item_func_isnotnull(args[0]);
@@ -4763,7 +4764,9 @@ Item *Item_func_isnull::neg_transformer(THD *thd)
 }
 
 
-/* a IS NOT NULL  ->  a IS NULL */
+/**
+  a IS NOT NULL  ->  a IS NULL.
+*/
 Item *Item_func_isnotnull::neg_transformer(THD *thd)
 {
   Item *item= new Item_func_isnull(args[0]);
@@ -4846,7 +4849,9 @@ Item *Item_func_le::negated_item()		/* a <= b  ->  a > b */
   return new Item_func_gt(args[0], args[1]);
 }
 
-// just fake method, should never be called
+/**
+  just fake method, should never be called.
+*/
 Item *Item_bool_rowready_func2::negated_item()
 {
   DBUG_ASSERT(0);
@@ -4911,19 +4916,17 @@ uint Item_equal::members()
 }
 
 
-/*
-  Check whether a field is referred in the multiple equality 
+/**
+  Check whether a field is referred in the multiple equality.
 
-  SYNOPSIS
-    contains()
-    field   field whose occurrence is to be checked
-  
-  DESCRIPTION
-    The function checks whether field is occurred in the Item_equal object 
-    
-  RETURN VALUES
+  The function checks whether field is occurred in the Item_equal object .
+
+  @param field   field whose occurrence is to be checked
+
+  @retval
     1       if nultiple equality contains a reference to field
-    0       otherwise    
+  @retval
+    0       otherwise
 */
 
 bool Item_equal::contains(Field *field)
@@ -4939,22 +4942,15 @@ bool Item_equal::contains(Field *field)
 }
 
 
-/*
-  Join members of another Item_equal object  
+/**
+  Join members of another Item_equal object.
 
-  SYNOPSIS
-    merge()
-    item    multiple equality whose members are to be joined
-  
-  DESCRIPTION
     The function actually merges two multiple equalities.
     After this operation the Item_equal object additionally contains
     the field items of another item of the type Item_equal.
     If the optional constant items are not equal the cond_false flag is
     set to 1.  
-       
-  RETURN VALUES
-    none    
+  @param item    multiple equality whose members are to be joined
 */
 
 void Item_equal::merge(Item_equal *item)
@@ -4974,28 +4970,21 @@ void Item_equal::merge(Item_equal *item)
 } 
 
 
-/*
-  Order field items in multiple equality according to a sorting criteria 
+/**
+  Order field items in multiple equality according to a sorting criteria.
 
-  SYNOPSIS
-    sort()
-    cmp          function to compare field item 
-    arg          context extra parameter for the cmp function
-  
-  DESCRIPTION
     The function perform ordering of the field items in the Item_equal
     object according to the criteria determined by the cmp callback parameter.
     If cmp(item_field1,item_field2,arg)<0 than item_field1 must be
     placed after item_fiel2.
 
-  IMPLEMENTATION
     The function sorts field items by the exchange sort algorithm.
     The list of field items is looked through and whenever two neighboring
     members follow in a wrong order they are swapped. This is performed
     again and again until we get all members in a right order.
-         
-  RETURN VALUES
-    None    
+
+  @param cmp          function to compare field item
+  @param arg          context extra parameter for the cmp function
 */
 
 void Item_equal::sort(Item_field_cmpfunc cmp, void *arg)
@@ -5030,21 +5019,14 @@ void Item_equal::sort(Item_field_cmpfunc cmp, void *arg)
 }
 
 
-/*
-  Check appearance of new constant items in the multiple equality object
+/**
+  Check appearance of new constant items in the multiple equality object.
 
-  SYNOPSIS
-    update_const()
-  
-  DESCRIPTION
     The function checks appearance of new constant items among
     the members of multiple equalities. Each new constant item is
     compared with the designated constant item if there is any in the
     multiple equality. If there is none the first new constant item
     becomes designated.
-      
-  RETURN VALUES
-    none    
 */
 
 void Item_equal::update_const()