branches/zip: Add @file comments, and convert decorative

/*********************************
comments to Doxygen /** style like this:
/*****************************//**

This conversion was performed by the following command:

perl -i -e 'while(<ARGV>){if (m|^/\*{30}\**$|) {
s|\*{4}$|//**| if ++$com>1; $_ .= "\@file $ARGV\n" if $com==2}
print; if(eof){$.=0;undef $com}}' */*[ch] include/univ.i

btr/btr0pcur.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file btr/btr0pcur.c
 The index tree persistent cursor
 
 Created 2/23/1996 Heikki Tuuri
@@ -32,7 +33,7 @@ Created 2/23/1996 Heikki Tuuri
 #include "rem0cmp.h"
 #include "trx0trx.h"
 
-/******************************************************************
+/**************************************************************//**
 Allocates memory for a persistent cursor object and initializes the cursor.
 @return	own: persistent cursor */
 UNIV_INTERN
@@ -50,7 +51,7 @@ btr_pcur_create_for_mysql(void)
 	return(pcur);
 }
 
-/******************************************************************
+/**************************************************************//**
 Frees the memory for a persistent cursor object. */
 UNIV_INTERN
 void
@@ -76,7 +77,7 @@ btr_pcur_free_for_mysql(
 	mem_free(cursor);
 }
 
-/******************************************************************
+/**************************************************************//**
 The position of the cursor is stored by taking an initial segment of the
 record the cursor is positioned on, before, or after, and copying it to the
 cursor data structure, or just setting a flag if the cursor id before the
@@ -157,7 +158,7 @@ btr_pcur_store_position(
 	cursor->modify_clock = buf_block_get_modify_clock(block);
 }
 
-/******************************************************************
+/**************************************************************//**
 Copies the stored position of a pcur to another pcur. */
 UNIV_INTERN
 void
@@ -187,7 +188,7 @@ btr_pcur_copy_stored_position(
 	pcur_receive->old_n_fields = pcur_donate->old_n_fields;
 }
 
-/******************************************************************
+/**************************************************************//**
 Restores the stored position of a persistent cursor bufferfixing the page and
 obtaining the specified latches. If the cursor position was saved when the
 (1) cursor was positioned on a user record: this function restores the position
@@ -349,7 +350,7 @@ btr_pcur_restore_position(
 	return(FALSE);
 }
 
-/******************************************************************
+/**************************************************************//**
 If the latch mode of the cursor is BTR_LEAF_SEARCH or BTR_LEAF_MODIFY,
 releases the page latch and bufferfix reserved by the cursor.
 NOTE! In the case of BTR_LEAF_MODIFY, there should not exist changes
@@ -376,7 +377,7 @@ btr_pcur_release_leaf(
 	cursor->pos_state = BTR_PCUR_WAS_POSITIONED;
 }
 
-/*************************************************************
+/*********************************************************//**
 Moves the persistent cursor to the first record on the next page. Releases the
 latch on the current page, and bufferunfixes it. Note that there must not be
 modifications on the current page, as then the x-latch can be released only in
@@ -427,7 +428,7 @@ btr_pcur_move_to_next_page(
 	page_check_dir(next_page);
 }
 
-/*************************************************************
+/*********************************************************//**
 Moves the persistent cursor backward if it is on the first record of the page.
 Commits mtr. Note that to prevent a possible deadlock, the operation
 first stores the position of the cursor, commits mtr, acquires the necessary
@@ -509,7 +510,7 @@ btr_pcur_move_backward_from_page(
 	cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
 }
 
-/*************************************************************
+/*********************************************************//**
 Moves the persistent cursor to the previous record in the tree. If no records
 are left, the cursor stays 'before first in tree'.
 @return	TRUE if the cursor was not before first in tree */
@@ -543,7 +544,7 @@ btr_pcur_move_to_prev(
 	return(TRUE);
 }
 
-/******************************************************************
+/**************************************************************//**
 If mode is PAGE_CUR_G or PAGE_CUR_GE, opens a persistent cursor on the first
 user record satisfying the search condition, in the case PAGE_CUR_L or
 PAGE_CUR_LE, on the last user record. If no such user record exists, then

btr/btr0sea.c

@@ -23,7 +23,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/************************************************************************
+/********************************************************************//**
+@file btr/btr0sea.c
 The index tree adaptive search
 
 Created 2/17/1996 Heikki Tuuri
@@ -88,7 +89,7 @@ before hash index building is started */
 
 #define BTR_SEARCH_BUILD_LIMIT		100
 
-/************************************************************************
+/********************************************************************//**
 Builds a hash index on a page with the given parameters. If the page already
 has a hash index with different parameters, the old hash index is removed.
 If index is non-NULL, this function checks if n_fields and n_bytes are
@@ -105,7 +106,7 @@ btr_search_build_page_hash_index(
 				field */
 	ibool		left_side);/*!< in: hash for searches from left side? */
 
-/*********************************************************************
+/*****************************************************************//**
 This function should be called before reserving any btr search mutex, if
 the intended operation might add nodes to the search system hash table.
 Because of the latching order, once we have reserved the btr search system
@@ -151,7 +152,7 @@ btr_search_check_free_space_in_heap(void)
 	}
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Creates and initializes the adaptive search system at a database start. */
 UNIV_INTERN
 void
@@ -172,7 +173,7 @@ btr_search_sys_create(
 	btr_search_sys->hash_index = ha_create(hash_size, 0, 0);
 }
 
-/************************************************************************
+/********************************************************************//**
 Disable the adaptive hash search system and empty the index. */
 UNIV_INTERN
 void
@@ -195,7 +196,7 @@ btr_search_disable(void)
 	mutex_exit(&btr_search_enabled_mutex);
 }
 
-/************************************************************************
+/********************************************************************//**
 Enable the adaptive hash search system. */
 UNIV_INTERN
 void
@@ -211,7 +212,7 @@ btr_search_enable(void)
 	mutex_exit(&btr_search_enabled_mutex);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Creates and initializes a search info struct.
 @return	own: search info struct */
 UNIV_INTERN
@@ -252,7 +253,7 @@ btr_search_info_create(
 	return(info);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Returns the value of ref_count. The value is protected by
 btr_search_latch.
 @return	ref_count value. */
@@ -278,7 +279,7 @@ btr_search_info_get_ref_count(
 	return(ret);
 }
 
-/*************************************************************************
+/*********************************************************************//**
 Updates the search info of an index about hash successes. NOTE that info
 is NOT protected by any semaphore, to save CPU time! Do not assume its fields
 are consistent. */
@@ -398,7 +399,7 @@ btr_search_info_update_hash(
 	}
 }
 
-/*************************************************************************
+/*********************************************************************//**
 Updates the block search info on hash successes. NOTE that info and
 block->n_hash_helps, n_fields, n_bytes, side are NOT protected by any
 semaphore, to save CPU time! Do not assume the fields are consistent.
@@ -476,7 +477,7 @@ btr_search_update_block_hash_info(
 	return(FALSE);
 }
 
-/*************************************************************************
+/*********************************************************************//**
 Updates a hash node reference when it has been unsuccessfully used in a
 search which could have succeeded with the used hash parameters. This can
 happen because when building a hash index for a page, we do not check
@@ -546,7 +547,7 @@ btr_search_update_hash_ref(
 	}
 }
 
-/*************************************************************************
+/*********************************************************************//**
 Updates the search info. */
 UNIV_INTERN
 void
@@ -623,7 +624,7 @@ btr_search_info_update_slow(
 	}
 }
 
-/**********************************************************************
+/******************************************************************//**
 Checks if a guessed position for a tree cursor is right. Note that if
 mode is PAGE_CUR_LE, which is used in inserts, and the function returns
 TRUE, then cursor->up_match and cursor->low_match both have sensible values.
@@ -769,7 +770,7 @@ btr_search_check_guess(
 	return(success);
 }
 
-/**********************************************************************
+/******************************************************************//**
 Tries to guess the right search position based on the hash search info
 of the index. Note that if mode is PAGE_CUR_LE, which is used in inserts,
 and the function returns TRUE, then cursor->up_match and cursor->low_match
@@ -978,7 +979,7 @@ btr_search_guess_on_hash(
 	return(FALSE);
 }
 
-/************************************************************************
+/********************************************************************//**
 Drops a page hash index. */
 UNIV_INTERN
 void
@@ -1145,7 +1146,7 @@ btr_search_drop_page_hash_index(
 	mem_free(folds);
 }
 
-/************************************************************************
+/********************************************************************//**
 Drops a page hash index when a page is freed from a fseg to the file system.
 Drops possible hash index if the page happens to be in the buffer pool. */
 UNIV_INTERN
@@ -1191,7 +1192,7 @@ btr_search_drop_page_hash_when_freed(
 	mtr_commit(&mtr);
 }
 
-/************************************************************************
+/********************************************************************//**
 Builds a hash index on a page with the given parameters. If the page already
 has a hash index with different parameters, the old hash index is removed.
 If index is non-NULL, this function checks if n_fields and n_bytes are
@@ -1386,7 +1387,7 @@ btr_search_build_page_hash_index(
 	}
 }
 
-/************************************************************************
+/********************************************************************//**
 Moves or deletes hash entries for moved records. If new_page is already hashed,
 then the hash index for page, if any, is dropped. If new_page is not hashed,
 and page is hashed, then a new hash index is built to new_page with the same
@@ -1452,7 +1453,7 @@ btr_search_move_or_delete_hash_entries(
 	rw_lock_s_unlock(&btr_search_latch);
 }
 
-/************************************************************************
+/********************************************************************//**
 Updates the page hash index when a single record is deleted from a page. */
 UNIV_INTERN
 void
@@ -1505,7 +1506,7 @@ btr_search_update_hash_on_delete(
 	rw_lock_x_unlock(&btr_search_latch);
 }
 
-/************************************************************************
+/********************************************************************//**
 Updates the page hash index when a single record is inserted on a page. */
 UNIV_INTERN
 void
@@ -1556,7 +1557,7 @@ btr_search_update_hash_node_on_insert(
 	}
 }
 
-/************************************************************************
+/********************************************************************//**
 Updates the page hash index when a single record is inserted on a page. */
 UNIV_INTERN
 void
@@ -1706,7 +1707,7 @@ btr_search_update_hash_on_insert(
 	}
 }
 
-/************************************************************************
+/********************************************************************//**
 Validates the search system.
 @return	TRUE if ok */
 UNIV_INTERN

buf/buf0buddy.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file buf/buf0buddy.c
 Binary buddy allocator for compressed pages
 
 Created December 2006 by Marko Makela
@@ -44,7 +45,7 @@ static ulint buf_buddy_n_frames;
 Protected by buf_pool_mutex. */
 UNIV_INTERN buf_buddy_stat_t buf_buddy_stat[BUF_BUDDY_SIZES + 1];
 
-/**************************************************************************
+/**********************************************************************//**
 Get the offset of the buddy of a compressed page frame.
 @return	the buddy relative of page */
 UNIV_INLINE
@@ -66,7 +67,7 @@ buf_buddy_get(
 	}
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Add a block to the head of the appropriate buddy free list. */
 UNIV_INLINE
 void
@@ -92,7 +93,7 @@ buf_buddy_add_to_free(
 #endif /* UNIV_DEBUG_VALGRIND */
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Remove a block from the appropriate buddy free list. */
 UNIV_INLINE
 void
@@ -122,7 +123,7 @@ buf_buddy_remove_from_free(
 #endif /* UNIV_DEBUG_VALGRIND */
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Try to allocate a block from buf_pool->zip_free[].
 @return	allocated block, or NULL if buf_pool->zip_free[] was empty */
 static
@@ -175,7 +176,7 @@ buf_buddy_alloc_zip(
 	return(bpage);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Deallocate a buffer frame of UNIV_PAGE_SIZE. */
 static
 void
@@ -214,7 +215,7 @@ buf_buddy_block_free(
 	ut_d(buf_buddy_n_frames--);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Allocate a buffer block to the buddy allocator. */
 static
 void
@@ -240,7 +241,7 @@ buf_buddy_block_register(
 	ut_d(buf_buddy_n_frames++);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Allocate a block from a bigger object.
 @return	allocated block */
 static
@@ -280,7 +281,7 @@ buf_buddy_alloc_from(
 	return(buf);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Allocate a block.  The thread calling this function must hold
 buf_pool_mutex and must not hold buf_pool_zip_mutex or any block->mutex.
 The buf_pool_mutex may only be released and reacquired if lru != NULL.
@@ -340,7 +341,7 @@ buf_buddy_alloc_low(
 	return(block);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Try to relocate the control block of a compressed page.
 @return	TRUE if relocated */
 static
@@ -394,7 +395,7 @@ buf_buddy_relocate_block(
 	return(TRUE);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Try to relocate a block.
 @return	TRUE if relocated */
 static
@@ -502,7 +503,7 @@ buf_buddy_relocate(
 	return(FALSE);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Deallocate a block. */
 UNIV_INTERN
 void

buf/buf0flu.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file buf/buf0flu.c
 The database buffer buf_pool flush algorithm
 
 Created 11/11/1995 Heikki Tuuri
@@ -44,7 +45,7 @@ Created 11/11/1995 Heikki Tuuri
 #include "trx0sys.h"
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
-/**********************************************************************
+/******************************************************************//**
 Validates the flush list.
 @return	TRUE if ok */
 static
@@ -53,7 +54,7 @@ buf_flush_validate_low(void);
 /*========================*/
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 
-/************************************************************************
+/********************************************************************//**
 Inserts a modified block into the flush list. */
 UNIV_INTERN
 void
@@ -79,7 +80,7 @@ buf_flush_insert_into_flush_list(
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 }
 
-/************************************************************************
+/********************************************************************//**
 Inserts a modified block into the flush list in the right sorted position.
 This function is used by recovery, because there the modifications do not
 necessarily come in the order of lsn's. */
@@ -122,7 +123,7 @@ buf_flush_insert_sorted_into_flush_list(
 #endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
 }
 
-/************************************************************************
+/********************************************************************//**
 Returns TRUE if the file page block is immediately suitable for replacement,
 i.e., the transition FILE_PAGE => NOT_USED allowed.
 @return	TRUE if can replace immediately */
@@ -155,7 +156,7 @@ buf_flush_ready_for_replace(
 	return(FALSE);
 }
 
-/************************************************************************
+/********************************************************************//**
 Returns TRUE if the block is modified and ready for flushing.
 @return	TRUE if can flush immediately */
 UNIV_INLINE
@@ -192,7 +193,7 @@ buf_flush_ready_for_flush(
 	return(FALSE);
 }
 
-/************************************************************************
+/********************************************************************//**
 Remove a block from the flush list of modified blocks. */
 UNIV_INTERN
 void
@@ -231,7 +232,7 @@ buf_flush_remove(
 			      ut_ad(ut_list_node_313->in_flush_list)));
 }
 
-/************************************************************************
+/********************************************************************//**
 Updates the flush system data structures when a write is completed. */
 UNIV_INTERN
 void
@@ -269,7 +270,7 @@ buf_flush_write_complete(
 	}
 }
 
-/************************************************************************
+/********************************************************************//**
 Flushes possible buffered writes from the doublewrite memory buffer to disk,
 and also wakes up the aio thread if simulated aio is used. It is very
 important to call this function after a batch of writes has been posted,
@@ -516,7 +517,7 @@ buf_flush_buffered_writes(void)
 	mutex_exit(&(trx_doublewrite->mutex));
 }
 
-/************************************************************************
+/********************************************************************//**
 Posts a buffer page for writing. If the doublewrite memory buffer is
 full, calls buf_flush_buffered_writes and waits for for free space to
 appear. */
@@ -576,7 +577,7 @@ buf_flush_post_to_doublewrite_buf(
 }
 #endif /* !UNIV_HOTBACKUP */
 
-/************************************************************************
+/********************************************************************//**
 Initializes a page for writing to the tablespace. */
 UNIV_INTERN
 void
@@ -655,7 +656,7 @@ buf_flush_init_for_writing(
 }
 
 #ifndef UNIV_HOTBACKUP
-/************************************************************************
+/********************************************************************//**
 Does an asynchronous write of a buffer page. NOTE: in simulated aio and
 also when the doublewrite buffer is used, we must call
 buf_flush_buffered_writes after we have posted a batch of writes! */
@@ -743,7 +744,7 @@ buf_flush_write_block_low(
 	}
 }
 
-/************************************************************************
+/********************************************************************//**
 Writes a flushable page asynchronously from the buffer pool to a file.
 NOTE: in simulated aio we must call
 os_aio_simulated_wake_handler_threads after we have posted a batch of
@@ -857,7 +858,7 @@ buf_flush_page(
 	buf_flush_write_block_low(bpage);
 }
 
-/***************************************************************
+/***********************************************************//**
 Flushes to disk all flushable pages within the flush area.
 @return	number of pages flushed */
 static
@@ -948,7 +949,7 @@ buf_flush_try_neighbors(
 	return(count);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 This utility flushes dirty blocks from the end of the LRU list or flush_list.
 NOTE 1: in the case of an LRU flush the calling thread may own latches to
 pages: to avoid deadlocks, this function must be written so that it cannot
@@ -1104,7 +1105,7 @@ buf_flush_batch(
 	return(page_count);
 }
 
-/**********************************************************************
+/******************************************************************//**
 Waits until a flush batch of the given type ends */
 UNIV_INTERN
 void
@@ -1117,7 +1118,7 @@ buf_flush_wait_batch_end(
 	os_event_wait(buf_pool->no_flush[type]);
 }
 
-/**********************************************************************
+/******************************************************************//**
 Gives a recommendation of how many blocks should be flushed to establish
 a big enough margin of replaceable blocks near the end of the LRU list
 and in the free list.
@@ -1169,7 +1170,7 @@ buf_flush_LRU_recommendation(void)
 	       - n_replaceable);
 }
 
-/*************************************************************************
+/*********************************************************************//**
 Flushes pages from the end of the LRU list if there is too small a margin
 of replaceable pages there or in the free list. VERY IMPORTANT: this function
 is called also by threads which have locks on pages. To avoid deadlocks, we
@@ -1197,7 +1198,7 @@ buf_flush_free_margin(void)
 }
 
 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
-/**********************************************************************
+/******************************************************************//**
 Validates the flush list.
 @return	TRUE if ok */
 static
@@ -1226,7 +1227,7 @@ buf_flush_validate_low(void)
 	return(TRUE);
 }
 
-/**********************************************************************
+/******************************************************************//**
 Validates the flush list.
 @return	TRUE if ok */
 UNIV_INTERN

buf/buf0rea.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file buf/buf0rea.c
 The database buffer read
 
 Created 11/5/1995 Heikki Tuuri
@@ -59,7 +60,7 @@ read-ahead is not done: this is to prevent flooding the buffer pool with
 i/o-fixed buffer blocks */
 #define BUF_READ_AHEAD_PEND_LIMIT	2
 
-/************************************************************************
+/********************************************************************//**
 Low-level function which reads a page asynchronously from a file to the
 buffer buf_pool if it is not already there, in which case does nothing.
 Sets the io_fix flag and sets an exclusive lock on the buffer frame. The
@@ -169,7 +170,7 @@ buf_read_page_low(
 	return(1);
 }
 
-/************************************************************************
+/********************************************************************//**
 Applies a random read-ahead in buf_pool if there are at least a threshold
 value of accessed pages from the random read-ahead area. Does not read any
 page, not even the one at the position (space, offset), if the read-ahead
@@ -325,7 +326,7 @@ buf_read_ahead_random(
 	return(count);
 }
 
-/************************************************************************
+/********************************************************************//**
 High-level function which reads a page asynchronously from a file to the
 buffer buf_pool if it is not already there. Sets the io_fix flag and sets
 an exclusive lock on the buffer frame. The flag is cleared and the x-lock
@@ -376,7 +377,7 @@ buf_read_page(
 	return(count + count2);
 }
 
-/************************************************************************
+/********************************************************************//**
 Applies linear read-ahead if in the buf_pool the page is a border page of
 a linear read-ahead area and all the pages in the area have been accessed.
 Does not read any page if the read-ahead mechanism is not activated. Note
@@ -643,7 +644,7 @@ buf_read_ahead_linear(
 	return(count);
 }
 
-/************************************************************************
+/********************************************************************//**
 Issues read requests for pages which the ibuf module wants to read in, in
 order to contract the insert buffer tree. Technically, this function is like
 a read-ahead function. */
@@ -721,7 +722,7 @@ buf_read_ibuf_merge_pages(
 #endif /* UNIV_DEBUG */
 }
 
-/************************************************************************
+/********************************************************************//**
 Issues read requests for pages which recovery wants to read in. */
 UNIV_INTERN
 void

data/data0data.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/************************************************************************
+/********************************************************************//**
+@file data/data0data.c
 SQL data field and tuple
 
 Created 5/30/1994 Heikki Tuuri
@@ -51,7 +52,7 @@ UNIV_INTERN ulint	data_dummy;
 #endif /* UNIV_DEBUG */
 
 #ifndef UNIV_HOTBACKUP
-/*************************************************************************
+/*********************************************************************//**
 Tests if dfield data length and content is equal to the given.
 @return	TRUE if equal */
 UNIV_INTERN
@@ -80,7 +81,7 @@ dfield_data_is_binary_equal(
 	return(TRUE);
 }
 
-/****************************************************************
+/************************************************************//**
 Compare two data tuples, respecting the collation of character fields.
 @return 1, 0 , -1 if tuple1 is greater, equal, less, respectively,
 than tuple2 */
@@ -122,7 +123,7 @@ dtuple_coll_cmp(
 	return(0);
 }
 
-/*************************************************************************
+/*********************************************************************//**
 Sets number of fields used in a tuple. Normally this is set in
 dtuple_create, but if you want later to set it smaller, you can use this. */
 UNIV_INTERN
@@ -138,7 +139,7 @@ dtuple_set_n_fields(
 	tuple->n_fields_cmp = n_fields;
 }
 
-/**************************************************************
+/**********************************************************//**
 Checks that a data field is typed.
 @return	TRUE if ok */
 static
@@ -160,7 +161,7 @@ dfield_check_typed_no_assert(
 	return(TRUE);
 }
 
-/**************************************************************
+/**********************************************************//**
 Checks that a data tuple is typed.
 @return	TRUE if ok */
 UNIV_INTERN
@@ -198,7 +199,7 @@ dtuple_check_typed_no_assert(
 #endif /* !UNIV_HOTBACKUP */
 
 #ifdef UNIV_DEBUG
-/**************************************************************
+/**********************************************************//**
 Checks that a data field is typed. Asserts an error if not.
 @return	TRUE if ok */
 UNIV_INTERN
@@ -221,7 +222,7 @@ dfield_check_typed(
 	return(TRUE);
 }
 
-/**************************************************************
+/**********************************************************//**
 Checks that a data tuple is typed. Asserts an error if not.
 @return	TRUE if ok */
 UNIV_INTERN
@@ -243,7 +244,7 @@ dtuple_check_typed(
 	return(TRUE);
 }
 
-/**************************************************************
+/**********************************************************//**
 Validates the consistency of a tuple which must be complete, i.e,
 all fields must have been set.
 @return	TRUE if ok */
@@ -296,7 +297,7 @@ dtuple_validate(
 #endif /* UNIV_DEBUG */
 
 #ifndef UNIV_HOTBACKUP
-/*****************************************************************
+/*************************************************************//**
 Pretty prints a dfield value according to its data type. */
 UNIV_INTERN
 void
@@ -338,7 +339,7 @@ dfield_print(
 	}
 }
 
-/*****************************************************************
+/*************************************************************//**
 Pretty prints a dfield value according to its data type. Also the hex string
 is printed if a string contains non-printable characters. */
 UNIV_INTERN
@@ -510,7 +511,7 @@ dfield_print_also_hex(
 	}
 }
 
-/*****************************************************************
+/*************************************************************//**
 Print a dfield value using ut_print_buf. */
 static
 void
@@ -533,7 +534,7 @@ dfield_print_raw(
 	}
 }
 
-/**************************************************************
+/**********************************************************//**
 The following function prints the contents of a tuple. */
 UNIV_INTERN
 void
@@ -561,7 +562,7 @@ dtuple_print(
 	ut_ad(dtuple_validate(tuple));
 }
 
-/******************************************************************
+/**************************************************************//**
 Moves parts of long fields in entry to the big record vector so that
 the size of tuple drops below the maximum record size allowed in the
 database. Moves data only from those fields which are not necessary
@@ -722,7 +723,7 @@ dtuple_convert_big_rec(
 	return(vector);
 }
 
-/******************************************************************
+/**************************************************************//**
 Puts back to entry the data stored in vector. Note that to ensure the
 fields in entry can accommodate the data, vector must have been created
 from entry with dtuple_convert_big_rec. */

data/data0type.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file data/data0type.c
 Data types
 
 Created 1/16/1996 Heikki Tuuri
@@ -38,7 +39,7 @@ charset-collation code for them. */
 
 UNIV_INTERN ulint	data_mysql_default_charset_coll;
 
-/*************************************************************************
+/*********************************************************************//**
 Determine how many bytes the first n characters of the given string occupy.
 If the string is shorter than n characters, returns the number of bytes
 the characters in the string occupy.
@@ -79,7 +80,7 @@ dtype_get_at_most_n_mbchars(
 }
 #endif /* UNIV_HOTBACKUP */
 
-/*************************************************************************
+/*********************************************************************//**
 Checks if a data main type is a string type. Also a BLOB is considered a
 string type.
 @return	TRUE if string type */
@@ -99,7 +100,7 @@ dtype_is_string_type(
 	return(FALSE);
 }
 
-/*************************************************************************
+/*********************************************************************//**
 Checks if a type is a binary string type. Note that for tables created with
 < 4.0.14, we do not know if a DATA_BLOB column is a BLOB or a TEXT column. For
 those DATA_BLOB columns this function currently returns FALSE.
@@ -121,7 +122,7 @@ dtype_is_binary_string_type(
 	return(FALSE);
 }
 
-/*************************************************************************
+/*********************************************************************//**
 Checks if a type is a non-binary string type. That is, dtype_is_string_type is
 TRUE and dtype_is_binary_string_type is FALSE. Note that for tables created
 with < 4.0.14, we do not know if a DATA_BLOB column is a BLOB or a TEXT column.
@@ -143,7 +144,7 @@ dtype_is_non_binary_string_type(
 	return(FALSE);
 }
 
-/*************************************************************************
+/*********************************************************************//**
 Forms a precise type from the < 4.1.2 format precise type plus the
 charset-collation code. */
 UNIV_INTERN
@@ -160,7 +161,7 @@ dtype_form_prtype(
 	return(old_prtype + (charset_coll << 16));
 }
 
-/*************************************************************************
+/*********************************************************************//**
 Validates a data type structure.
 @return	TRUE if ok */
 UNIV_INTERN
@@ -185,7 +186,7 @@ dtype_validate(
 }
 
 #ifndef UNIV_HOTBACKUP
-/*************************************************************************
+/*********************************************************************//**
 Prints a data type structure. */
 UNIV_INTERN
 void

dict/dict0boot.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file dict/dict0boot.c
 Data dictionary creation and booting
 
 Created 4/18/1996 Heikki Tuuri
@@ -39,7 +40,7 @@ Created 4/18/1996 Heikki Tuuri
 #include "log0recv.h"
 #include "os0file.h"
 
-/**************************************************************************
+/**********************************************************************//**
 Gets a pointer to the dictionary header and x-latches its page.
 @return	pointer to the dictionary header, page x-latched */
 UNIV_INTERN
@@ -60,7 +61,7 @@ dict_hdr_get(
 	return(header);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Returns a new table, index, or tree id.
 @return	the new id */
 UNIV_INTERN
@@ -89,7 +90,7 @@ dict_hdr_get_new_id(
 	return(id);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Writes the current value of the row id counter to the dictionary header file
 page. */
 UNIV_INTERN
@@ -114,7 +115,7 @@ dict_hdr_flush_row_id(void)
 	mtr_commit(&mtr);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Creates the file page for the dictionary header. This function is
 called only at the database creation.
 @return	TRUE if succeed */
@@ -217,7 +218,7 @@ dict_hdr_create(
 	return(TRUE);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Initializes the data dictionary memory structures when the database is
 started. This function is also called when the data dictionary is created. */
 UNIV_INTERN
@@ -429,7 +430,7 @@ dict_boot(void)
 	mutex_exit(&(dict_sys->mutex));
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Inserts the basic system table data into themselves in the database
 creation. */
 static
@@ -440,7 +441,7 @@ dict_insert_initial_data(void)
 	/* Does nothing yet */
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Creates and initializes the data dictionary at the database creation. */
 UNIV_INTERN
 void

dict/dict0crea.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file dict/dict0crea.c
 Database object creation
 
 Created 1/8/1996 Heikki Tuuri
@@ -42,7 +43,7 @@ Created 1/8/1996 Heikki Tuuri
 #include "usr0sess.h"
 #include "ut0vec.h"
 
-/*********************************************************************
+/*****************************************************************//**
 Based on a table object, this function builds the entry to be inserted
 in the SYS_TABLES system table.
 @return	the tuple which should be inserted */
@@ -134,7 +135,7 @@ dict_create_sys_tables_tuple(
 	return(entry);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Based on a table object, this function builds the entry to be inserted
 in the SYS_COLUMNS system table.
 @return	the tuple which should be inserted */
@@ -216,7 +217,7 @@ dict_create_sys_columns_tuple(
 	return(entry);
 }
 
-/*******************************************************************
+/***************************************************************//**
 Builds a table definition to insert.
 @return	DB_SUCCESS or error code */
 static
@@ -295,7 +296,7 @@ dict_build_table_def_step(
 	return(DB_SUCCESS);
 }
 
-/*******************************************************************
+/***************************************************************//**
 Builds a column definition to insert.
 @return	DB_SUCCESS */
 static
@@ -313,7 +314,7 @@ dict_build_col_def_step(
 	return(DB_SUCCESS);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Based on an index object, this function builds the entry to be inserted
 in the SYS_INDEXES system table.
 @return	the tuple which should be inserted */
@@ -403,7 +404,7 @@ dict_create_sys_indexes_tuple(
 	return(entry);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Based on an index object, this function builds the entry to be inserted
 in the SYS_FIELDS system table.
 @return	the tuple which should be inserted */
@@ -479,7 +480,7 @@ dict_create_sys_fields_tuple(
 	return(entry);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Creates the tuple with which the index entry is searched for writing the index
 tree root page number, if such a tree is created.
 @return	the tuple for search */
@@ -515,7 +516,7 @@ dict_create_search_tuple(
 	return(search_tuple);
 }
 
-/*******************************************************************
+/***************************************************************//**
 Builds an index definition row to insert.
 @return	DB_SUCCESS or error code */
 static
@@ -567,7 +568,7 @@ dict_build_index_def_step(
 	return(DB_SUCCESS);
 }
 
-/*******************************************************************
+/***************************************************************//**
 Builds a field definition row to insert.
 @return	DB_SUCCESS */
 static
@@ -588,7 +589,7 @@ dict_build_field_def_step(
 	return(DB_SUCCESS);
 }
 
-/*******************************************************************
+/***************************************************************//**
 Creates an index tree for the index if it is not a member of a cluster.
 @return	DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
 static
@@ -645,7 +646,7 @@ dict_create_index_tree_step(
 	return(DB_SUCCESS);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Drops the index tree associated with a row in SYS_INDEXES table. */
 UNIV_INTERN
 void
@@ -708,7 +709,7 @@ dict_drop_index_tree(
 				     FIL_NULL, mtr);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Truncates the index tree associated with a row in SYS_INDEXES table.
 @return	new root page number, or FIL_NULL on failure */
 UNIV_INTERN
@@ -843,7 +844,7 @@ dict_truncate_index_tree(
 	return(FIL_NULL);
 }
 
-/*************************************************************************
+/*********************************************************************//**
 Creates a table create graph.
 @return	own: table create node */
 UNIV_INTERN
@@ -879,7 +880,7 @@ tab_create_graph_create(
 	return(node);
 }
 
-/*************************************************************************
+/*********************************************************************//**
 Creates an index create graph.
 @return	own: index create node */
 UNIV_INTERN
@@ -916,7 +917,7 @@ ind_create_graph_create(
 	return(node);
 }
 
-/***************************************************************
+/***********************************************************//**
 Creates a table. This is a high-level function used in SQL execution graphs.
 @return	query thread to run next or NULL */
 UNIV_INTERN
@@ -1022,7 +1023,7 @@ dict_create_table_step(
 	return(thr);
 }
 
-/***************************************************************
+/***********************************************************//**
 Creates an index. This is a high-level function used in SQL execution
 graphs.
 @return	query thread to run next or NULL */
@@ -1153,7 +1154,7 @@ dict_create_index_step(
 	return(thr);
 }
 
-/********************************************************************
+/****************************************************************//**
 Creates the foreign key constraints system tables inside InnoDB
 at database creation or database start if they are not found or are
 not of the right form.
@@ -1274,7 +1275,7 @@ dict_create_or_check_foreign_constraint_tables(void)
 	return(error);
 }
 
-/********************************************************************
+/****************************************************************//**
 Evaluate the given foreign key SQL statement.
 @return	error code or DB_SUCCESS */
 static
@@ -1339,7 +1340,7 @@ dict_foreign_eval_sql(
 	return(DB_SUCCESS);
 }
 
-/************************************************************************
+/********************************************************************//**
 Add a single foreign key field definition to the data dictionary tables in
 the database.
 @return	error code or DB_SUCCESS */
@@ -1374,7 +1375,7 @@ dict_create_add_foreign_field_to_dictionary(
 		       table, foreign, trx));
 }
 
-/************************************************************************
+/********************************************************************//**
 Add a single foreign key definition to the data dictionary tables in the
 database. We also generate names to constraints that were not named by the
 user. A generated constraint has a name of the format
@@ -1449,7 +1450,7 @@ dict_create_add_foreign_to_dictionary(
 	return(error);
 }
 
-/************************************************************************
+/********************************************************************//**
 Adds foreign key definitions to data dictionary tables in the database.
 @return	error code or DB_SUCCESS */
 UNIV_INTERN

dict/dict0load.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file dict/dict0load.c
 Loads to the memory cache database object definitions
 from dictionary tables
 
@@ -40,7 +41,7 @@ Created 4/24/1996 Heikki Tuuri
 #include "srv0start.h"
 #include "srv0srv.h"
 
-/********************************************************************
+/****************************************************************//**
 Compare the name of an index column.
 @return	TRUE if the i'th column of index is 'name'. */
 static
@@ -59,7 +60,7 @@ name_of_col_is(
 	return(strcmp(name, dict_table_get_col_name(table, tmp)) == 0);
 }
 
-/************************************************************************
+/********************************************************************//**
 Finds the first table name in the given database.
 @return own: table name, NULL if does not exist; the caller must free
 the memory in the string! */
@@ -142,7 +143,7 @@ dict_get_first_table_name_in_db(
 	goto loop;
 }
 
-/************************************************************************
+/********************************************************************//**
 Prints to the standard output information on all tables found in the data
 dictionary system table. */
 UNIV_INTERN
@@ -235,7 +236,7 @@ dict_print(void)
 	goto loop;
 }
 
-/************************************************************************
+/********************************************************************//**
 Determine the flags of a table described in SYS_TABLES.
 @return compressed page size in kilobytes; or 0 if the tablespace is
 uncompressed, ULINT_UNDEFINED on error */
@@ -297,7 +298,7 @@ dict_sys_tables_get_flags(
 	return(flags);
 }
 
-/************************************************************************
+/********************************************************************//**
 In a crash recovery we already have all the tablespace objects created.
 This function compares the space id information in the InnoDB data dictionary
 to what we already read with fil_load_single_table_tablespaces().
@@ -419,7 +420,7 @@ dict_check_tablespaces_and_store_max_id(
 	goto loop;
 }
 
-/************************************************************************
+/********************************************************************//**
 Loads definitions for table columns. */
 static
 void
@@ -525,7 +526,7 @@ dict_load_columns(
 	mtr_commit(&mtr);
 }
 
-/************************************************************************
+/********************************************************************//**
 Loads definitions for index fields. */
 static
 void
@@ -626,7 +627,7 @@ dict_load_fields(
 	mtr_commit(&mtr);
 }
 
-/************************************************************************
+/********************************************************************//**
 Loads definitions for table indexes. Adds them to the data dictionary
 cache.
 @return DB_SUCCESS if ok, DB_CORRUPTION if corruption of dictionary
@@ -799,7 +800,7 @@ dict_load_indexes(
 	return(error);
 }
 
-/************************************************************************
+/********************************************************************//**
 Loads a table definition and also all its index definitions, and also
 the cluster definition if the table is a member in a cluster. Also loads
 all foreign key constraints where the foreign key is in the table or where
@@ -992,7 +993,7 @@ dict_load_table(
 	return(table);
 }
 
-/***************************************************************************
+/***********************************************************************//**
 Loads a table object based on the table id.
 @return	table; NULL if table does not exist */
 UNIV_INTERN
@@ -1083,7 +1084,7 @@ dict_load_table_on_id(
 	return(table);
 }
 
-/************************************************************************
+/********************************************************************//**
 This function is called when the database is booted. Loads system table
 index definitions except for the clustered index which is added to the
 dictionary cache at booting before calling this function. */
@@ -1104,7 +1105,7 @@ dict_load_sys_table(
 	mem_heap_free(heap);
 }
 
-/************************************************************************
+/********************************************************************//**
 Loads foreign key constraint col names (also for the referenced table). */
 static
 void
@@ -1176,7 +1177,7 @@ dict_load_foreign_cols(
 	mtr_commit(&mtr);
 }
 
-/***************************************************************************
+/***********************************************************************//**
 Loads a foreign key constraint to the dictionary cache.
 @return	DB_SUCCESS or error code */
 static
@@ -1301,7 +1302,7 @@ dict_load_foreign(
 	return(dict_foreign_add_to_cache(foreign, check_charsets));
 }
 
-/***************************************************************************
+/***********************************************************************//**
 Loads foreign key constraints where the table is either the foreign key
 holder or where the table is referenced by a foreign key. Adds these
 constraints to the data dictionary. Note that we know that the dictionary

dict/dict0mem.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/**********************************************************************
+/******************************************************************//**
+@file dict/dict0mem.c
 Data dictionary memory object creation
 
 Created 1/8/1996 Heikki Tuuri
@@ -39,7 +40,7 @@ Created 1/8/1996 Heikki Tuuri
 #define	DICT_HEAP_SIZE		100	/* initial memory heap size when
 					creating a table or index object */
 
-/**************************************************************************
+/**********************************************************************//**
 Creates a table memory object.
 @return	own: table object */
 UNIV_INTERN
@@ -90,7 +91,7 @@ dict_mem_table_create(
 	return(table);
 }
 
-/********************************************************************
+/****************************************************************//**
 Free a table memory object. */
 UNIV_INTERN
 void
@@ -106,7 +107,7 @@ dict_mem_table_free(
 	mem_heap_free(table->heap);
 }
 
-/********************************************************************
+/****************************************************************//**
 Append 'name' to 'col_names' (@see dict_table_t::col_names).
 @return	new column names array */
 static
@@ -154,7 +155,7 @@ dict_add_col_name(
 	return(res);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Adds a column definition to a table. */
 UNIV_INTERN
 void
@@ -211,7 +212,7 @@ dict_mem_table_add_col(
 #endif /* !UNIV_HOTBACKUP */
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Creates an index memory object.
 @return	own: index object */
 UNIV_INTERN
@@ -254,7 +255,7 @@ dict_mem_index_create(
 	return(index);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Creates and initializes a foreign constraint memory object.
 @return	own: foreign constraint struct */
 UNIV_INTERN
@@ -274,7 +275,7 @@ dict_mem_foreign_create(void)
 	return(foreign);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Adds a field definition to an index. NOTE: does not take a copy
 of the column name if the field is a column. The memory occupied
 by the column name may be released only after publishing the index. */
@@ -301,7 +302,7 @@ dict_mem_index_add_field(
 	field->prefix_len = (unsigned int) prefix_len;
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Frees an index memory object. */
 UNIV_INTERN
 void

dyn/dyn0dyn.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file dyn/dyn0dyn.c
 The dynamically allocated array
 
 Created 2/5/1996 Heikki Tuuri
@@ -27,7 +28,7 @@ Created 2/5/1996 Heikki Tuuri
 #include "dyn0dyn.ic"
 #endif
 
-/****************************************************************
+/************************************************************//**
 Adds a new block to a dyn array.
 @return	created block */
 UNIV_INTERN

eval/eval0eval.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file eval/eval0eval.c
 SQL evaluator: evaluates simple data structures, like expressions, in
 a query graph
 
@@ -40,7 +41,7 @@ the function below */
 
 static byte	eval_dummy;
 
-/*********************************************************************
+/*****************************************************************//**
 Allocate a buffer from global dynamic memory for a value of a que_node.
 NOTE that this memory must be explicitly freed when the query graph is
 freed. If the node already has an allocated buffer, that buffer is freed
@@ -83,7 +84,7 @@ eval_node_alloc_val_buf(
 	return(data);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Free the buffer from global dynamic memory for a value of a que_node,
 if it has been allocated in the above function. The freeing for pushed
 column values is done in sel_col_prefetch_buf_free. */
@@ -110,7 +111,7 @@ eval_node_free_val_buf(
 	}
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates a comparison node.
 @return	the result of the comparison */
 UNIV_INTERN
@@ -169,7 +170,7 @@ eval_cmp(
 	return(val);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates a logical operation node. */
 UNIV_INLINE
 void
@@ -210,7 +211,7 @@ eval_logical(
 	eval_node_set_ibool_val(logical_node, val);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates an arithmetic operation node. */
 UNIV_INLINE
 void
@@ -254,7 +255,7 @@ eval_arith(
 	eval_node_set_int_val(arith_node, val);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates an aggregate operation node. */
 UNIV_INLINE
 void
@@ -288,7 +289,7 @@ eval_aggregate(
 	eval_node_set_int_val(node, val);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates a predefined function node where the function is not relevant
 in benchmarks. */
 static
@@ -375,7 +376,7 @@ eval_predefined_2(
 	}
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates a notfound-function node. */
 UNIV_INLINE
 void
@@ -417,7 +418,7 @@ eval_notfound(
 	eval_node_set_ibool_val(func_node, ibool_val);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates a substr-function node. */
 UNIV_INLINE
 void
@@ -450,7 +451,7 @@ eval_substr(
 	dfield_set_data(dfield, str1 + len1, len2);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates a replstr-procedure node. */
 static
 void
@@ -490,7 +491,7 @@ eval_replstr(
 	ut_memcpy(str1 + len1, str2, len2);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates an instr-function node. */
 static
 void
@@ -562,7 +563,7 @@ eval_instr(
 	eval_node_set_int_val(func_node, int_val);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates a predefined function node. */
 UNIV_INLINE
 void
@@ -600,7 +601,7 @@ eval_binary_to_number(
 	eval_node_copy_and_alloc_val(func_node, str2, 4);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates a predefined function node. */
 static
 void
@@ -642,7 +643,7 @@ eval_concat(
 	}
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates a predefined function node. If the first argument is an integer,
 this function looks at the second argument which is the integer length in
 bytes, and converts the integer to a VARCHAR.
@@ -690,7 +691,7 @@ eval_to_binary(
 	dfield_set_data(dfield, str1 + (4 - len1), len1);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates a predefined function node. */
 UNIV_INLINE
 void
@@ -782,7 +783,7 @@ eval_predefined(
 	eval_node_set_int_val(func_node, int_val);
 }
 
-/*********************************************************************
+/*****************************************************************//**
 Evaluates a function node. */
 UNIV_INTERN
 void

eval/eval0proc.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file eval/eval0proc.c
 Executes SQL stored procedures and their control structures
 
 Created 1/20/1998 Heikki Tuuri
@@ -28,7 +29,7 @@ Created 1/20/1998 Heikki Tuuri
 #include "eval0proc.ic"
 #endif
 
-/**************************************************************************
+/**********************************************************************//**
 Performs an execution step of an if-statement node.
 @return	query thread to run next or NULL */
 UNIV_INTERN
@@ -104,7 +105,7 @@ if_step(
 	return(thr);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Performs an execution step of a while-statement node.
 @return	query thread to run next or NULL */
 UNIV_INTERN
@@ -140,7 +141,7 @@ while_step(
 	return(thr);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Performs an execution step of an assignment statement node.
 @return	query thread to run next or NULL */
 UNIV_INTERN
@@ -167,7 +168,7 @@ assign_step(
 	return(thr);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Performs an execution step of a for-loop node.
 @return	query thread to run next or NULL */
 UNIV_INTERN
@@ -229,7 +230,7 @@ for_step(
 	return(thr);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Performs an execution step of an exit statement node.
 @return	query thread to run next or NULL */
 UNIV_INTERN
@@ -261,7 +262,7 @@ exit_step(
 	return(thr);
 }
 
-/**************************************************************************
+/**********************************************************************//**
 Performs an execution step of a return-statement node.
 @return	query thread to run next or NULL */
 UNIV_INTERN

fut/fut0fut.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/**********************************************************************
+/******************************************************************//**
+@file fut/fut0fut.c
 File-based utilities
 
 Created 12/13/1995 Heikki Tuuri

fut/fut0lst.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/**********************************************************************
+/******************************************************************//**
+@file fut/fut0lst.c
 File-based list utilities
 
 Created 11/28/1995 Heikki Tuuri
@@ -31,7 +32,7 @@ Created 11/28/1995 Heikki Tuuri
 #include "buf0buf.h"
 #include "page0page.h"
 
-/************************************************************************
+/********************************************************************//**
 Adds a node to an empty list. */
 static
 void
@@ -67,7 +68,7 @@ flst_add_to_empty(
 	mlog_write_ulint(base + FLST_LEN, len + 1, MLOG_4BYTES, mtr);
 }
 
-/************************************************************************
+/********************************************************************//**
 Adds a node as the last node in a list. */
 UNIV_INTERN
 void
@@ -110,7 +111,7 @@ flst_add_last(
 	}
 }
 
-/************************************************************************
+/********************************************************************//**
 Adds a node as the first node in a list. */
 UNIV_INTERN
 void
@@ -153,7 +154,7 @@ flst_add_first(
 	}
 }
 
-/************************************************************************
+/********************************************************************//**
 Inserts a node after another in a list. */
 UNIV_INTERN
 void
@@ -208,7 +209,7 @@ flst_insert_after(
 	mlog_write_ulint(base + FLST_LEN, len + 1, MLOG_4BYTES, mtr);
 }
 
-/************************************************************************
+/********************************************************************//**
 Inserts a node before another in a list. */
 UNIV_INTERN
 void
@@ -262,7 +263,7 @@ flst_insert_before(
 	mlog_write_ulint(base + FLST_LEN, len + 1, MLOG_4BYTES, mtr);
 }
 
-/************************************************************************
+/********************************************************************//**
 Removes a node. */
 UNIV_INTERN
 void
@@ -337,7 +338,7 @@ flst_remove(
 	mlog_write_ulint(base + FLST_LEN, len - 1, MLOG_4BYTES, mtr);
 }
 
-/************************************************************************
+/********************************************************************//**
 Cuts off the tail of the list, including the node given. The number of
 nodes which will be removed must be provided by the caller, as this function
 does not measure the length of the tail. */
@@ -394,7 +395,7 @@ flst_cut_end(
 	mlog_write_ulint(base + FLST_LEN, len - n_nodes, MLOG_4BYTES, mtr);
 }
 
-/************************************************************************
+/********************************************************************//**
 Cuts off the tail of the list, not including the given node. The number of
 nodes which will be removed must be provided by the caller, as this function
 does not measure the length of the tail. */
@@ -435,7 +436,7 @@ flst_truncate_end(
 	mlog_write_ulint(base + FLST_LEN, len - n_nodes, MLOG_4BYTES, mtr);
 }
 
-/************************************************************************
+/********************************************************************//**
 Validates a file-based list.
 @return	TRUE if ok */
 UNIV_INTERN
@@ -502,7 +503,7 @@ flst_validate(
 	return(TRUE);
 }
 
-/************************************************************************
+/********************************************************************//**
 Prints info of a file-based list. */
 UNIV_INTERN
 void

ha/ha0ha.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/************************************************************************
+/********************************************************************//**
+@file ha/ha0ha.c
 The hash table with external chains
 
 Created 8/22/1994 Heikki Tuuri
@@ -35,7 +36,7 @@ Created 8/22/1994 Heikki Tuuri
 #endif /* UNIV_SYNC_DEBUG */
 #include "page0page.h"
 
-/*****************************************************************
+/*************************************************************//**
 Creates a hash table with >= n array cells. The actual number of cells is
 chosen to be a prime number slightly bigger than n.
 @return	own: created table */
@@ -88,7 +89,7 @@ ha_create_func(
 	return(table);
 }
 
-/*****************************************************************
+/*************************************************************//**
 Empties a hash table and frees the memory heaps. */
 UNIV_INTERN
 void
@@ -120,7 +121,7 @@ ha_clear(
 	}
 }
 
-/*****************************************************************
+/*************************************************************//**
 Inserts an entry into a hash table. If an entry with the same fold number
 is found, its node is updated to point to the new data, and no new node
 is inserted.
@@ -226,7 +227,7 @@ ha_insert_for_fold_func(
 	return(TRUE);
 }
 
-/***************************************************************
+/***********************************************************//**
 Deletes a hash node. */
 UNIV_INTERN
 void
@@ -248,7 +249,7 @@ ha_delete_hash_node(
 	HASH_DELETE_AND_COMPACT(ha_node_t, next, table, del_node);
 }
 
-/*****************************************************************
+/*************************************************************//**
 Deletes an entry from a hash table. */
 UNIV_INTERN
 void
@@ -270,7 +271,7 @@ ha_delete(
 	ha_delete_hash_node(table, node);
 }
 
-/*************************************************************
+/*********************************************************//**
 Looks for an element when we know the pointer to the data, and updates
 the pointer to data, if found. */
 UNIV_INTERN
@@ -311,7 +312,7 @@ ha_search_and_update_if_found_func(
 }
 
 #ifndef UNIV_HOTBACKUP
-/*********************************************************************
+/*****************************************************************//**
 Removes from the chain determined by fold all nodes whose data pointer
 points to the page given. */
 UNIV_INTERN
@@ -357,7 +358,7 @@ ha_remove_all_nodes_to_page(
 #endif
 }
 
-/*****************************************************************
+/*************************************************************//**
 Validates a given range of the cells in hash table.
 @return	TRUE if ok */
 UNIV_INTERN
@@ -402,7 +403,7 @@ ha_validate(
 	return(ok);
 }
 
-/*****************************************************************
+/*************************************************************//**
 Prints info of a hash table. */
 UNIV_INTERN
 void

ha/ha0storage.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file ha/ha0storage.c
 Hash storage.
 Provides a data structure that stores chunks of data in
 its own storage, avoiding duplicates.
@@ -34,7 +35,7 @@ Created September 22, 2007 Vasil Dimov
 #include "ha0storage.ic"
 #endif
 
-/***********************************************************************
+/*******************************************************************//**
 Retrieves a data from a storage. If it is present, a pointer to the
 stored copy of data is returned, otherwise NULL is returned. */
 static
@@ -73,7 +74,7 @@ ha_storage_get(
 	return(node->data);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Copies data into the storage and returns a pointer to the copy. If the
 same data chunk is already present, then pointer to it is returned.
 Data chunks are considered to be equal if len1 == len2 and

ha/hash0hash.c

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file ha/hash0hash.c
 The simple hash table utility
 
 Created 5/20/1997 Heikki Tuuri
@@ -30,7 +31,7 @@ Created 5/20/1997 Heikki Tuuri
 #include "mem0mem.h"
 
 #ifndef UNIV_HOTBACKUP
-/****************************************************************
+/************************************************************//**
 Reserves the mutex for a fold value in a hash table. */
 UNIV_INTERN
 void
@@ -42,7 +43,7 @@ hash_mutex_enter(
 	mutex_enter(hash_get_mutex(table, fold));
 }
 
-/****************************************************************
+/************************************************************//**
 Releases the mutex for a fold value in a hash table. */
 UNIV_INTERN
 void
@@ -54,7 +55,7 @@ hash_mutex_exit(
 	mutex_exit(hash_get_mutex(table, fold));
 }
 
-/****************************************************************
+/************************************************************//**
 Reserves all the mutexes of a hash table, in an ascending order. */
 UNIV_INTERN
 void
@@ -70,7 +71,7 @@ hash_mutex_enter_all(
 	}
 }
 
-/****************************************************************
+/************************************************************//**
 Releases all the mutexes of a hash table. */
 UNIV_INTERN
 void
@@ -87,7 +88,7 @@ hash_mutex_exit_all(
 }
 #endif /* !UNIV_HOTBACKUP */
 
-/*****************************************************************
+/*************************************************************//**
 Creates a hash table with >= n array cells. The actual number of cells is
 chosen to be a prime number slightly bigger than n.
 @return	own: created table */
@@ -126,7 +127,7 @@ hash_create(
 	return(table);
 }
 
-/*****************************************************************
+/*************************************************************//**
 Frees a hash table. */
 UNIV_INTERN
 void
@@ -143,7 +144,7 @@ hash_table_free(
 }
 
 #ifndef UNIV_HOTBACKUP
-/*****************************************************************
+/*************************************************************//**
 Creates a mutex array to protect a hash table. */
 UNIV_INTERN
 void

handler/ha_innodb.h

@@ -252,7 +252,8 @@ void thd_mark_transaction_to_rollback(MYSQL_THD thd, bool all);
 }
 
 typedef struct trx_struct trx_t;
-/************************************************************************
+/********************************************************************//**
+@file handler/ha_innodb.h
 Converts an InnoDB error code to a MySQL error code and also tells to MySQL
 about a possible transaction rollback inside InnoDB caused by a lock wait
 timeout or a deadlock.
@@ -265,7 +266,7 @@ convert_error_code_to_mysql(
 	ulint		flags,	/*!< in: InnoDB table flags, or 0 */
 	MYSQL_THD	thd);	/*!< in: user thread handle or NULL */
 
-/*************************************************************************
+/*********************************************************************//**
 Allocates an InnoDB transaction for a MySQL handler object.
 @return	InnoDB transaction handle */
 extern "C"

handler/handler0alter.cc

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file handler/handler0alter.cc
 Smart ALTER TABLE
 *******************************************************/
 
@@ -36,7 +37,7 @@ extern "C" {
 #include "ha_innodb.h"
 #include "handler0vars.h"
 
-/*****************************************************************
+/*************************************************************//**
 Copies an InnoDB column to a MySQL field.  This function is
 adapted from row_sel_field_store_in_mysql_format(). */
 static
@@ -122,7 +123,7 @@ innobase_col_to_mysql(
 	}
 }
 
-/*****************************************************************
+/*************************************************************//**
 Copies an InnoDB record to table->record[0]. */
 extern "C" UNIV_INTERN
 void
@@ -172,7 +173,7 @@ innobase_rec_to_mysql(
 	}
 }
 
-/*****************************************************************
+/*************************************************************//**
 Resets table->record[0]. */
 extern "C" UNIV_INTERN
 void
@@ -188,7 +189,7 @@ innobase_rec_reset(
 	}
 }
 
-/**********************************************************************
+/******************************************************************//**
 Removes the filename encoding of a database and table name. */
 static
 void
@@ -222,7 +223,7 @@ innobase_convert_tablename(
 	}
 }
 
-/***********************************************************************
+/*******************************************************************//**
 This function checks that index keys are sensible.
 @return	0 or error number */
 static
@@ -322,7 +323,7 @@ innobase_check_index_keys(
 	return(0);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Create index field definition for key part */
 static
 void
@@ -364,7 +365,7 @@ innobase_create_index_field_def(
 	DBUG_VOID_RETURN;
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Create index definition for key */
 static
 void
@@ -418,7 +419,7 @@ innobase_create_index_def(
 	DBUG_VOID_RETURN;
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Copy index field definition */
 static
 void
@@ -437,7 +438,7 @@ innobase_copy_index_field_def(
 	DBUG_VOID_RETURN;
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Copy index definition for the index */
 static
 void
@@ -475,7 +476,7 @@ innobase_copy_index_def(
 	DBUG_VOID_RETURN;
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Create an index table where indexes are ordered as follows:
 
 IF a new primary key is defined for the table THEN
@@ -582,7 +583,7 @@ innobase_create_key_def(
 	DBUG_RETURN(indexdefs);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Create a temporary tablename using query id, thread id, and id
 @return	temporary tablename */
 static
@@ -607,7 +608,7 @@ innobase_create_temporary_tablename(
 	return(name);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Create indexes.
 @return	0 or error number */
 UNIV_INTERN
@@ -911,7 +912,7 @@ ha_innobase::add_index(
 	DBUG_RETURN(error);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Prepare to drop some indexes of a table.
 @return	0 or error number */
 UNIV_INTERN
@@ -1112,7 +1113,7 @@ ha_innobase::prepare_drop_index(
 	DBUG_RETURN(err);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Drop the indexes that were passed to a successful prepare_drop_index().
 @return	0 or error number */
 UNIV_INTERN

handler/handler0vars.h

@@ -16,12 +16,13 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/***********************************************************************
+/*******************************************************************//**
+@file handler/handler0vars.h
 This file contains accessor functions for dynamic plugin on Windows.
 ***********************************************************************/
 
 #if defined __WIN__ && defined MYSQL_DYNAMIC_PLUGIN
-/***********************************************************************
+/*******************************************************************//**
 This is a list of externals that can not be resolved by delay loading.
 They have to be resolved indirectly via their addresses in the .map file.
 All of them are external variables. */

handler/i_s.cc

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file handler/i_s.cc
 InnoDB INFORMATION SCHEMA tables interface to MySQL.
 
 Created July 18, 2007 Vasil Dimov
@@ -111,7 +112,7 @@ bool schema_table_store_record(THD *thd, TABLE *table);
 void localtime_to_TIME(MYSQL_TIME *to, struct tm *from);
 bool check_global_access(THD *thd, ulong want_access);
 
-/***********************************************************************
+/*******************************************************************//**
 Common function to fill any of the dynamic tables:
 INFORMATION_SCHEMA.innodb_trx
 INFORMATION_SCHEMA.innodb_locks
@@ -125,7 +126,7 @@ trx_i_s_common_fill_table(
 	TABLE_LIST*	tables,	/*!< in/out: tables to fill */
 	COND*		cond);	/*!< in: condition (not used) */
 
-/***********************************************************************
+/*******************************************************************//**
 Unbind a dynamic INFORMATION_SCHEMA table.
 @return	0 on success */
 static
@@ -134,7 +135,7 @@ i_s_common_deinit(
 /*==============*/
 	void*	p);	/*!< in/out: table schema object */
 
-/***********************************************************************
+/*******************************************************************//**
 Auxiliary function to store time_t value in MYSQL_TYPE_DATETIME
 field.
 @return	0 on success */
@@ -162,7 +163,7 @@ field_store_time_t(
 	return(field->store_time(&my_time, MYSQL_TIMESTAMP_DATETIME));
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Auxiliary function to store char* value in MYSQL_TYPE_STRING field.
 @return	0 on success */
 static
@@ -189,7 +190,7 @@ field_store_string(
 	return(ret);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Auxiliary function to store ulint value in MYSQL_TYPE_LONGLONG field.
 If the value is ULINT_UNDEFINED then the field it set to NULL.
 @return	0 on success */
@@ -293,7 +294,7 @@ static ST_FIELD_INFO	innodb_trx_fields_info[] =
 	END_OF_ST_FIELD_INFO
 };
 
-/***********************************************************************
+/*******************************************************************//**
 Read data from cache buffer and fill the INFORMATION_SCHEMA.innodb_trx
 table with it.
 @return	0 on success */
@@ -378,7 +379,7 @@ fill_innodb_trx_from_cache(
 	DBUG_RETURN(0);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Bind the dynamic table INFORMATION_SCHEMA.innodb_trx
 @return	0 on success */
 static
@@ -550,7 +551,7 @@ static ST_FIELD_INFO	innodb_locks_fields_info[] =
 	END_OF_ST_FIELD_INFO
 };
 
-/***********************************************************************
+/*******************************************************************//**
 Read data from cache buffer and fill the INFORMATION_SCHEMA.innodb_locks
 table with it.
 @return	0 on success */
@@ -658,7 +659,7 @@ fill_innodb_locks_from_cache(
 	DBUG_RETURN(0);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Bind the dynamic table INFORMATION_SCHEMA.innodb_locks
 @return	0 on success */
 static
@@ -770,7 +771,7 @@ static ST_FIELD_INFO	innodb_lock_waits_fields_info[] =
 	END_OF_ST_FIELD_INFO
 };
 
-/***********************************************************************
+/*******************************************************************//**
 Read data from cache buffer and fill the
 INFORMATION_SCHEMA.innodb_lock_waits table with it.
 @return	0 on success */
@@ -841,7 +842,7 @@ fill_innodb_lock_waits_from_cache(
 	DBUG_RETURN(0);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Bind the dynamic table INFORMATION_SCHEMA.innodb_lock_waits
 @return	0 on success */
 static
@@ -911,7 +912,7 @@ UNIV_INTERN struct st_mysql_plugin	i_s_innodb_lock_waits =
 	STRUCT_FLD(__reserved1, NULL)
 };
 
-/***********************************************************************
+/*******************************************************************//**
 Common function to fill any of the dynamic tables:
 INFORMATION_SCHEMA.innodb_trx
 INFORMATION_SCHEMA.innodb_locks
@@ -1072,7 +1073,7 @@ static ST_FIELD_INFO	i_s_cmp_fields_info[] =
 };
 
 
-/***********************************************************************
+/*******************************************************************//**
 Fill the dynamic table information_schema.innodb_cmp or
 innodb_cmp_reset.
 @return	0 on success, 1 on failure */
@@ -1130,7 +1131,7 @@ i_s_cmp_fill_low(
 	DBUG_RETURN(status);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Fill the dynamic table information_schema.innodb_cmp.
 @return	0 on success, 1 on failure */
 static
@@ -1144,7 +1145,7 @@ i_s_cmp_fill(
 	return(i_s_cmp_fill_low(thd, tables, cond, FALSE));
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Fill the dynamic table information_schema.innodb_cmp_reset.
 @return	0 on success, 1 on failure */
 static
@@ -1158,7 +1159,7 @@ i_s_cmp_reset_fill(
 	return(i_s_cmp_fill_low(thd, tables, cond, TRUE));
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Bind the dynamic table information_schema.innodb_cmp.
 @return	0 on success */
 static
@@ -1176,7 +1177,7 @@ i_s_cmp_init(
 	DBUG_RETURN(0);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Bind the dynamic table information_schema.innodb_cmp_reset.
 @return	0 on success */
 static
@@ -1340,7 +1341,7 @@ static ST_FIELD_INFO	i_s_cmpmem_fields_info[] =
 	END_OF_ST_FIELD_INFO
 };
 
-/***********************************************************************
+/*******************************************************************//**
 Fill the dynamic table information_schema.innodb_cmpmem or
 innodb_cmpmem_reset.
 @return	0 on success, 1 on failure */
@@ -1396,7 +1397,7 @@ i_s_cmpmem_fill_low(
 	DBUG_RETURN(status);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Fill the dynamic table information_schema.innodb_cmpmem.
 @return	0 on success, 1 on failure */
 static
@@ -1410,7 +1411,7 @@ i_s_cmpmem_fill(
 	return(i_s_cmpmem_fill_low(thd, tables, cond, FALSE));
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Fill the dynamic table information_schema.innodb_cmpmem_reset.
 @return	0 on success, 1 on failure */
 static
@@ -1424,7 +1425,7 @@ i_s_cmpmem_reset_fill(
 	return(i_s_cmpmem_fill_low(thd, tables, cond, TRUE));
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Bind the dynamic table information_schema.innodb_cmpmem.
 @return	0 on success */
 static
@@ -1442,7 +1443,7 @@ i_s_cmpmem_init(
 	DBUG_RETURN(0);
 }
 
-/***********************************************************************
+/*******************************************************************//**
 Bind the dynamic table information_schema.innodb_cmpmem_reset.
 @return	0 on success */
 static
@@ -1559,7 +1560,7 @@ UNIV_INTERN struct st_mysql_plugin	i_s_innodb_cmpmem_reset =
 	STRUCT_FLD(__reserved1, NULL)
 };
 
-/***********************************************************************
+/*******************************************************************//**
 Unbind a dynamic INFORMATION_SCHEMA table.
 @return	0 on success */
 static

handler/i_s.h

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file handler/i_s.h
 InnoDB INFORMATION SCHEMA tables interface to MySQL.
 
 Created July 18, 2007 Vasil Dimov

handler/mysql_addons.cc

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/******************************************************
+/**************************************************//**
+@file handler/mysql_addons.cc
 This file contains functions that need to be added to
 MySQL code but have not been added yet.
 

include/btr0types.h

@@ -16,7 +16,8 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 
 *****************************************************************************/
 
-/************************************************************************
+/********************************************************************//**
+@file include/btr0types.h
 The index tree general types
 
 Created 2/17/1996 Heikki Tuuri