Mirrors
/
mariadb
mirror of https://github.com/MariaDB/server
3
0
Fork 0
Code Releases Activity
Browse Source

branches/innodb+: Add missing UNIV_INTERN linkage specifiers.

pull/73/head
marko 17 years ago
parent
7dc3e545c3
commit
f50e5536ad
4 changed files with 42 additions and 43 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      ibuf/ibuf0ibuf.c
  2. 2
      include/ibuf0ibuf.h
  3. 40
      include/ut0rbt.h
  4. 41
      ut/ut0rbt.c

2
ibuf/ibuf0ibuf.c
View File

@ -1229,7 +1229,7 @@ ibuf_rec_get_op_type(
/********************************************************************
Read the first two bytes from a record's fourth field (counter field in new
records; something else in older records). */
UNIV_INTERN
ulint
ibuf_rec_get_fake_counter(
/*======================*/

2
include/ibuf0ibuf.h
View File

@ -334,7 +334,7 @@ ibuf_print(
/********************************************************************
Read the first two bytes from a record's fourth field (counter field in new
records; something else in older records). */
UNIV_INTERN
ulint
ibuf_rec_get_fake_counter(
/*======================*/

40
include/ut0rbt.h
View File

@ -95,14 +95,14 @@ struct ib_rbt_bound_struct {
/************************************************************************
Free an instance of a red black tree */
extern
UNIV_INTERN
void
rbt_free(
/*=====*/
ib_rbt_t* tree); /* in: rb tree to free */
/************************************************************************
Create an instance of a red black tree */
extern
UNIV_INTERN
ib_rbt_t*
rbt_create(
/*=======*/
@ -111,7 +111,7 @@ rbt_create(
ib_rbt_compare compare); /* in: comparator */
/************************************************************************
Delete a node from the red black tree, identified by key */
extern
UNIV_INTERN
ibool
rbt_delete(
/*=======*/
@ -121,7 +121,7 @@ rbt_delete(
/************************************************************************
Remove a node from the red black tree, NOTE: This function will not delete
the node instance, THAT IS THE CALLERS RESPONSIBILITY.*/
extern
UNIV_INTERN
ib_rbt_node_t*
rbt_remove_node(
/*============*/
@ -136,7 +136,7 @@ rbt_remove_node(
/************************************************************************
Return a node from the red black tree, identified by
key, NULL if not found */
extern
UNIV_INTERN
const ib_rbt_node_t*
rbt_lookup(
/*=======*/
@ -146,7 +146,7 @@ rbt_lookup(
const void* key); /* in: key to lookup */
/************************************************************************
Add data to the red black tree, identified by key (no dups yet!)*/
extern
UNIV_INTERN
const ib_rbt_node_t*
rbt_insert(
/*=======*/
@ -157,7 +157,7 @@ rbt_insert(
copied to the node.*/
/************************************************************************
Add a new node to the tree, useful for data that is pre-sorted.*/
extern
UNIV_INTERN
const ib_rbt_node_t*
rbt_add_node(
/*=========*/
@ -168,7 +168,7 @@ rbt_add_node(
to the node */
/************************************************************************
Return the left most data node in the tree*/
extern
UNIV_INTERN
const ib_rbt_node_t*
rbt_first(
/*======*/
@ -176,7 +176,7 @@ rbt_first(
const ib_rbt_t* tree); /* in: rb tree */
/************************************************************************
Return the right most data node in the tree*/
extern
UNIV_INTERN
const ib_rbt_node_t*
rbt_last(
/*=====*/
@ -184,7 +184,7 @@ rbt_last(
const ib_rbt_t* tree); /* in: rb tree */
/************************************************************************
Return the next node from current.*/
extern
UNIV_INTERN
const ib_rbt_node_t*
rbt_next(
/*=====*/
@ -195,7 +195,7 @@ rbt_next(
current);
/************************************************************************
Return the prev node from current.*/
extern
UNIV_INTERN
const ib_rbt_node_t*
rbt_prev(
/*=====*/
@ -206,7 +206,7 @@ rbt_prev(
current);
/************************************************************************
Find the node that has the lowest key that is >= key.*/
extern
UNIV_INTERN
const ib_rbt_node_t*
rbt_lower_bound(
/*============*/
@ -217,7 +217,7 @@ rbt_lower_bound(
const void* key); /* in: key to search */
/************************************************************************
Find the node that has the greatest key that is <= key.*/
extern
UNIV_INTERN
const ib_rbt_node_t*
rbt_upper_bound(
/*============*/
@ -230,7 +230,7 @@ rbt_upper_bound(
Search for the key, a node will be retuned in parent.last, whether it
was found or not. If not found then parent.last will contain the
parent node for the possibly new key otherwise the matching node.*/
extern
UNIV_INTERN
int
rbt_search(
/*=======*/
@ -243,7 +243,7 @@ rbt_search(
Search for the key, a node will be retuned in parent.last, whether it
was found or not. If not found then parent.last will contain the
parent node for the possibly new key otherwise the matching node.*/
extern
UNIV_INTERN
int
rbt_search_cmp(
/*===========*/
@ -255,14 +255,14 @@ rbt_search_cmp(
ib_rbt_compare compare); /* in: comparator */
/************************************************************************
Clear the tree, deletes (and free's) all the nodes.*/
extern
UNIV_INTERN
void
rbt_clear(
/*======*/
ib_rbt_t* tree); /* in: rb tree */
/************************************************************************
Merge the node from dst into src. Return the number of nodes merged.*/
extern
UNIV_INTERN
ulint
rbt_merge_uniq(
/*===========*/
@ -275,7 +275,7 @@ Delete the nodes from src after copying node to dst. As a side effect
the duplicates will be left untouched in the src, since we don't support
duplicates (yet). NOTE: src and dst must be similar, the function doesn't
check for this condition (yet).*/
extern
UNIV_INTERN
ulint
rbt_merge_uniq_destructive(
/*=======================*/
@ -285,7 +285,7 @@ rbt_merge_uniq_destructive(
/************************************************************************
Verify the integrity of the RB tree. For debugging. 0 failure else height
of tree (in count of black nodes).*/
extern
UNIV_INTERN
ibool
rbt_validate(
/*=========*/
@ -294,7 +294,7 @@ rbt_validate(
const ib_rbt_t* tree); /* in: tree to validate */
/************************************************************************
Iterate over the tree in depth first order.*/
extern
UNIV_INTERN
void
rbt_print(
/*======*/

41
ut/ut0rbt.c
View File

@ -726,7 +726,7 @@ rbt_free_node(
/************************************************************************
Free all the nodes and free the tree. */
UNIV_INTERN
void
rbt_free(
/*=====*/
@ -739,7 +739,7 @@ rbt_free(
/************************************************************************
Create an instance of a red black tree. */
UNIV_INTERN
ib_rbt_t*
rbt_create(
/*=======*/
@ -777,7 +777,7 @@ rbt_create(
/************************************************************************
Generic insert of a value in the rb tree. */
UNIV_INTERN
const ib_rbt_node_t*
rbt_insert(
/*=======*/
@ -806,7 +806,7 @@ rbt_insert(
/************************************************************************
Add a new node to the tree, useful for data that is pre-sorted. */
UNIV_INTERN
const ib_rbt_node_t*
rbt_add_node(
/*=========*/
@ -844,7 +844,7 @@ rbt_add_node(
/************************************************************************
Find a matching node in the rb tree. */
UNIV_INTERN
const ib_rbt_node_t*
rbt_lookup(
/*=======*/
@ -873,7 +873,7 @@ rbt_lookup(
/************************************************************************
Delete a node indentified by key. */
UNIV_INTERN
ibool
rbt_delete(
/*=======*/
@ -898,7 +898,7 @@ rbt_delete(
/************************************************************************
Remove a node from the rb tree, the node is not free'd, that is the
callers responsibility. */
UNIV_INTERN
ib_rbt_node_t*
rbt_remove_node(
/*============*/
@ -922,7 +922,7 @@ rbt_remove_node(
/************************************************************************
Find the node that has the lowest key that is >= key. */
UNIV_INTERN
const ib_rbt_node_t*
rbt_lower_bound(
/*============*/
@ -958,7 +958,7 @@ rbt_lower_bound(
/************************************************************************
Find the node that has the greatest key that is <= key. */
UNIV_INTERN
const ib_rbt_node_t*
rbt_upper_bound(
/*============*/
@ -994,7 +994,7 @@ rbt_upper_bound(
/************************************************************************
Find the node that has the greatest key that is <= key. */
UNIV_INTERN
int
rbt_search(
/*=======*/
@ -1029,7 +1029,7 @@ rbt_search(
/************************************************************************
Find the node that has the greatest key that is <= key. But use the
supplied comparison function. */
UNIV_INTERN
int
rbt_search_cmp(
/*===========*/
@ -1064,7 +1064,7 @@ rbt_search_cmp(
/************************************************************************
Return the left most node in the tree. */
UNIV_INTERN
const ib_rbt_node_t*
rbt_first(
/*======*/
@ -1084,7 +1084,7 @@ rbt_first(
/************************************************************************
Return the right most node in the tree. */
UNIV_INTERN
const ib_rbt_node_t*
rbt_last(
/*=====*/
@ -1105,7 +1105,7 @@ rbt_last(
/************************************************************************
Return the next node. */
UNIV_INTERN
const ib_rbt_node_t*
rbt_next(
/*=====*/
@ -1119,7 +1119,7 @@ rbt_next(
/************************************************************************
Return the previous node. */
UNIV_INTERN
const ib_rbt_node_t*
rbt_prev(
/*=====*/
@ -1133,7 +1133,7 @@ rbt_prev(
/************************************************************************
Reset the tree. Delete all the nodes. */
UNIV_INTERN
void
rbt_clear(
/*======*/
@ -1147,7 +1147,7 @@ rbt_clear(
/************************************************************************
Merge the node from dst into src. Return the number of nodes merged. */
UNIV_INTERN
ulint
rbt_merge_uniq(
/*===========*/
@ -1178,7 +1178,7 @@ rbt_merge_uniq(
Merge the node from dst into src. Return the number of nodes merged.
Delete the nodes from src after copying node to dst. As a side effect
the duplicates will be left untouched in the src. */
UNIV_INTERN
ulint
rbt_merge_uniq_destructive(
/*=======================*/
@ -1225,7 +1225,7 @@ rbt_merge_uniq_destructive(
/************************************************************************
Check that every path from the root to the leaves has the same count and
the tree nodes are in order. */
UNIV_INTERN
ibool
rbt_validate(
/*=========*/
@ -1241,7 +1241,7 @@ rbt_validate(
/************************************************************************
Iterate over the tree in depth first order. */
UNIV_INTERN
void
rbt_print(
/*======*/
@ -1250,4 +1250,3 @@ rbt_print(
{
rbt_print_subtree(tree, ROOT(tree), print);
}
Write Preview
Loading…
Cancel
Save