~drizzle-trunk/drizzle/development : contents of storage/innobase/include/ut0ut.h at revision 28.1.20

~drizzle-trunk/drizzle/development : (revision 28.1.20)

/**********************************************************************
Various utilities

(c) 1994, 1995 Innobase Oy

Created 1/20/1994 Heikki Tuuri
***********************************************************************/

#ifndef ut0ut_h
#define ut0ut_h

#include "univ.i"
#include <time.h>
#ifndef MYSQL_SERVER
#include <ctype.h>
#endif

typedef time_t	ib_time_t;

/************************************************************
Gets the high 32 bits in a ulint. That is makes a shift >> 32,
but since there seem to be compiler bugs in both gcc and Visual C++,
we do this by a special conversion. */

ulint
ut_get_high32(
/*==========*/
			/* out: a >> 32 */
	ulint	a);	/* in: ulint */
/**********************************************************
Calculates the minimum of two ulints. */
UNIV_INLINE
ulint
ut_min(
/*===*/
			/* out: minimum */
	ulint	 n1,	/* in: first number */
	ulint	 n2);	/* in: second number */
/**********************************************************
Calculates the maximum of two ulints. */
UNIV_INLINE
ulint
ut_max(
/*===*/
			/* out: maximum */
	ulint	 n1,	/* in: first number */
	ulint	 n2);	/* in: second number */
/********************************************************************
Calculates minimum of two ulint-pairs. */
UNIV_INLINE
void
ut_pair_min(
/*========*/
	ulint*	a,	/* out: more significant part of minimum */
	ulint*	b,	/* out: less significant part of minimum */
	ulint	a1,	/* in: more significant part of first pair */
	ulint	b1,	/* in: less significant part of first pair */
	ulint	a2,	/* in: more significant part of second pair */
	ulint	b2);	/* in: less significant part of second pair */
/**********************************************************
Compares two ulints. */
UNIV_INLINE
int
ut_ulint_cmp(
/*=========*/
			/* out: 1 if a > b, 0 if a == b, -1 if a < b */
	ulint	a,	/* in: ulint */
	ulint	b);	/* in: ulint */
/***********************************************************
Compares two pairs of ulints. */
UNIV_INLINE
int
ut_pair_cmp(
/*========*/
			/* out: -1 if a < b, 0 if a == b,
			1 if a > b */
	ulint	a1,	/* in: more significant part of first pair */
	ulint	a2,	/* in: less significant part of first pair */
	ulint	b1,	/* in: more significant part of second pair */
	ulint	b2);	/* in: less significant part of second pair */
/*****************************************************************
Calculates fast the remainder when divided by a power of two. */
UNIV_INLINE
ulint
ut_2pow_remainder(
/*==============*/	/* out: remainder */
	ulint	n,	/* in: number to be divided */
	ulint	m);	/* in: divisor; power of 2 */
/*****************************************************************
Calculates fast value rounded to a multiple of a power of 2. */
UNIV_INLINE
ulint
ut_2pow_round(
/*==========*/		/* out: value of n rounded down to nearest
			multiple of m */
	ulint	n,	/* in: number to be rounded */
	ulint	m);	/* in: divisor; power of 2 */
/*****************************************************************
Calculates fast the 2-logarithm of a number, rounded upward to an
integer. */
UNIV_INLINE
ulint
ut_2_log(
/*=====*/
			/* out: logarithm in the base 2, rounded upward */
	ulint	n);	/* in: number */
/*****************************************************************
Calculates 2 to power n. */
UNIV_INLINE
ulint
ut_2_exp(
/*=====*/
			/* out: 2 to power n */
	ulint	n);	/* in: number */
/*****************************************************************
Calculates fast the number rounded up to the nearest power of 2. */

ulint
ut_2_power_up(
/*==========*/
			/* out: first power of 2 which is >= n */
	ulint	n)	/* in: number != 0 */
	__attribute__((const));

/* Determine how many bytes (groups of 8 bits) are needed to
store the given number of bits. */
#define UT_BITS_IN_BYTES(b) (((b) + 7) / 8)

/****************************************************************
Sort function for ulint arrays. */

void
ut_ulint_sort(ulint* arr, ulint* aux_arr, ulint low, ulint high);
/*============================================================*/
/************************************************************
The following function returns elapsed CPU time in milliseconds. */

ulint
ut_clock(void);
/**************************************************************
Returns system time. We do not specify the format of the time returned:
the only way to manipulate it is to use the function ut_difftime. */

ib_time_t
ut_time(void);
/*=========*/
/**************************************************************
Returns system time. */

void
ut_usectime(
/*========*/
	ulint*	sec,	/* out: seconds since the Epoch */
	ulint*	ms);	/* out: microseconds since the Epoch+*sec */
/**************************************************************
Returns the difference of two times in seconds. */

double
ut_difftime(
/*========*/
				/* out: time2 - time1 expressed in seconds */
	ib_time_t	time2,	/* in: time */
	ib_time_t	time1);	/* in: time */
/**************************************************************
Prints a timestamp to a file. */

void
ut_print_timestamp(
/*===============*/
	FILE*  file); /* in: file where to print */
/**************************************************************
Sprintfs a timestamp to a buffer, 13..14 chars plus terminating NUL. */

void
ut_sprintf_timestamp(
/*=================*/
	char*	buf); /* in: buffer where to sprintf */
/**************************************************************
Sprintfs a timestamp to a buffer with no spaces and with ':' characters
replaced by '_'. */

void
ut_sprintf_timestamp_without_extra_chars(
/*=====================================*/
	char*	buf); /* in: buffer where to sprintf */
/**************************************************************
Returns current year, month, day. */

void
ut_get_year_month_day(
/*==================*/
	ulint*	year,	/* out: current year */
	ulint*	month,	/* out: month */
	ulint*	day);	/* out: day */
/*****************************************************************
Runs an idle loop on CPU. The argument gives the desired delay
in microseconds on 100 MHz Pentium + Visual C++. */

ulint
ut_delay(
/*=====*/
			/* out: dummy value */
	ulint	delay);	/* in: delay in microseconds on 100 MHz Pentium */
/*****************************************************************
Prints the contents of a memory buffer in hex and ascii. */

void
ut_print_buf(
/*=========*/
	FILE*		file,	/* in: file where to print */
	const void*	buf,	/* in: memory buffer */
	ulint		len);	/* in: length of the buffer */

/**************************************************************************
Outputs a NUL-terminated file name, quoted with apostrophes. */

void
ut_print_filename(
/*==============*/
	FILE*		f,	/* in: output stream */
	const char*	name);	/* in: name to print */

/* Forward declaration of transaction handle */
struct trx_struct;

/**************************************************************************
Outputs a fixed-length string, quoted as an SQL identifier.
If the string contains a slash '/', the string will be
output as two identifiers separated by a period (.),
as in SQL database_name.identifier. */

void
ut_print_name(
/*==========*/
	FILE*		f,	/* in: output stream */
	struct trx_struct*trx,	/* in: transaction */
	ibool		table_id,/* in: TRUE=print a table name,
				FALSE=print other identifier */
	const char*	name);	/* in: name to print */

/**************************************************************************
Outputs a fixed-length string, quoted as an SQL identifier.
If the string contains a slash '/', the string will be
output as two identifiers separated by a period (.),
as in SQL database_name.identifier. */

void
ut_print_namel(
/*===========*/
	FILE*		f,	/* in: output stream */
	struct trx_struct*trx,	/* in: transaction (NULL=no quotes) */
	ibool		table_id,/* in: TRUE=print a table name,
				FALSE=print other identifier */
	const char*	name,	/* in: name to print */
	ulint		namelen);/* in: length of name */

/**************************************************************************
Catenate files. */

void
ut_copy_file(
/*=========*/
	FILE*	dest,	/* in: output file */
	FILE*	src);	/* in: input file to be appended to output */

/**************************************************************************
snprintf(). */

#ifdef __WIN__
int
ut_snprintf(
				/* out: number of characters that would
				have been printed if the size were
				unlimited, not including the terminating
				'\0'. */
	char*		str,	/* out: string */
	size_t		size,	/* in: str size */
	const char*	fmt,	/* in: format */
	...);			/* in: format values */
#else
#define ut_snprintf	snprintf
#endif /* __WIN__ */

#ifndef UNIV_NONINL
#include "ut0ut.ic"
#endif

#endif


1 by brian clean slate	1	/**********************************************************************
	2	Various utilities
	3
	4	(c) 1994, 1995 Innobase Oy
	5
	6	Created 1/20/1994 Heikki Tuuri
	7	***********************************************************************/
	8
	9	#ifndef ut0ut_h
	10	#define ut0ut_h
	11
	12	#include "univ.i"
	13	#include <time.h>
	14	#ifndef MYSQL_SERVER
	15	#include <ctype.h>
	16	#endif
	17
	18	typedef time_t ib_time_t;
	19
	20	/************************************************************
	21	Gets the high 32 bits in a ulint. That is makes a shift >> 32,
	22	but since there seem to be compiler bugs in both gcc and Visual C++,
	23	we do this by a special conversion. */
	24
	25	ulint
	26	ut_get_high32(
	27	/==========/
	28	/* out: a >> 32 */
	29	ulint a); /* in: ulint */
	30	/**********************************************************
	31	Calculates the minimum of two ulints. */
	32	UNIV_INLINE
	33	ulint
	34	ut_min(
	35	/===/
	36	/* out: minimum */
	37	ulint n1, /* in: first number */
	38	ulint n2); /* in: second number */
	39	/**********************************************************
	40	Calculates the maximum of two ulints. */
	41	UNIV_INLINE
	42	ulint
	43	ut_max(
	44	/===/
	45	/* out: maximum */
	46	ulint n1, /* in: first number */
	47	ulint n2); /* in: second number */
	48	/********************************************************************
	49	Calculates minimum of two ulint-pairs. */
	50	UNIV_INLINE
	51	void
	52	ut_pair_min(
	53	/========/
	54	ulint* a, /* out: more significant part of minimum */
	55	ulint* b, /* out: less significant part of minimum */
	56	ulint a1, /* in: more significant part of first pair */
	57	ulint b1, /* in: less significant part of first pair */
	58	ulint a2, /* in: more significant part of second pair */
	59	ulint b2); /* in: less significant part of second pair */
	60	/**********************************************************
	61	Compares two ulints. */
	62	UNIV_INLINE
	63	int
	64	ut_ulint_cmp(
65	/=========/
66	/* out: 1 if a > b, 0 if a == b, -1 if a < b */
67	ulint a, /* in: ulint */
68	ulint b); /* in: ulint */
69	/***********************************************************
70	Compares two pairs of ulints. */
71	UNIV_INLINE
72	int
73	ut_pair_cmp(
74	/========/
75	/* out: -1 if a < b, 0 if a == b,
76	1 if a > b */
77	ulint a1, /* in: more significant part of first pair */
78	ulint a2, /* in: less significant part of first pair */
79	ulint b1, /* in: more significant part of second pair */
80	ulint b2); /* in: less significant part of second pair */
81	/*****************************************************************
82	Calculates fast the remainder when divided by a power of two. */
83	UNIV_INLINE
84	ulint
85	ut_2pow_remainder(
86	/==============/ /* out: remainder */
87	ulint n, /* in: number to be divided */
88	ulint m); /* in: divisor; power of 2 */
89	/*****************************************************************
90	Calculates fast value rounded to a multiple of a power of 2. */
91	UNIV_INLINE
92	ulint
93	ut_2pow_round(
94	/==========/ /* out: value of n rounded down to nearest
95	multiple of m */
96	ulint n, /* in: number to be rounded */
97	ulint m); /* in: divisor; power of 2 */
98	/*****************************************************************
99	Calculates fast the 2-logarithm of a number, rounded upward to an
100	integer. */
101	UNIV_INLINE
102	ulint
103	ut_2_log(
104	/=====/
105	/* out: logarithm in the base 2, rounded upward */
106	ulint n); /* in: number */
107	/*****************************************************************
108	Calculates 2 to power n. */
109	UNIV_INLINE
110	ulint
111	ut_2_exp(
112	/=====/
113	/* out: 2 to power n */
114	ulint n); /* in: number */
115	/*****************************************************************
116	Calculates fast the number rounded up to the nearest power of 2. */
117
118	ulint
119	ut_2_power_up(
120	/==========/
121	/* out: first power of 2 which is >= n */
122	ulint n) /* in: number != 0 */
123	__attribute__((const));
124
125	/* Determine how many bytes (groups of 8 bits) are needed to
126	store the given number of bits. */
127	#define UT_BITS_IN_BYTES(b) (((b) + 7) / 8)
128
129	/****************************************************************
130	Sort function for ulint arrays. */
131
132	void
133	ut_ulint_sort(ulint* arr, ulint* aux_arr, ulint low, ulint high);
134	/============================================================/
135	/************************************************************
136	The following function returns elapsed CPU time in milliseconds. */
137
138	ulint
139	ut_clock(void);
140	/**************************************************************
141	Returns system time. We do not specify the format of the time returned:
142	the only way to manipulate it is to use the function ut_difftime. */
143
144	ib_time_t
145	ut_time(void);
146	/=========/
147	/**************************************************************
148	Returns system time. */
149
150	void
151	ut_usectime(
152	/========/
153	ulint* sec, /* out: seconds since the Epoch */
154	ulint* ms); /* out: microseconds since the Epoch+sec /
155	/**************************************************************
156	Returns the difference of two times in seconds. */
157
158	double
159	ut_difftime(
160	/========/
161	/* out: time2 - time1 expressed in seconds */
162	ib_time_t time2, /* in: time */
163	ib_time_t time1); /* in: time */
164	/**************************************************************
165	Prints a timestamp to a file. */
166
167	void
168	ut_print_timestamp(
169	/===============/
170	FILE* file); /* in: file where to print */
171	/**************************************************************
172	Sprintfs a timestamp to a buffer, 13..14 chars plus terminating NUL. */
173
174	void
175	ut_sprintf_timestamp(
176	/=================/
177	char* buf); /* in: buffer where to sprintf */
178	/**************************************************************
179	Sprintfs a timestamp to a buffer with no spaces and with ':' characters
180	replaced by '_'. */
181
182	void
183	ut_sprintf_timestamp_without_extra_chars(
184	/=====================================/
185	char* buf); /* in: buffer where to sprintf */
186	/**************************************************************
187	Returns current year, month, day. */
188
189	void
190	ut_get_year_month_day(
191	/==================/
192	ulint* year, /* out: current year */
193	ulint* month, /* out: month */
194	ulint* day); /* out: day */
195	/*****************************************************************
196	Runs an idle loop on CPU. The argument gives the desired delay
197	in microseconds on 100 MHz Pentium + Visual C++. */
198
199	ulint
200	ut_delay(
201	/=====/
202	/* out: dummy value */
203	ulint delay); /* in: delay in microseconds on 100 MHz Pentium */
204	/*****************************************************************
205	Prints the contents of a memory buffer in hex and ascii. */
206
207	void
208	ut_print_buf(
209	/=========/
210	FILE* file, /* in: file where to print */
211	const void* buf, /* in: memory buffer */
212	ulint len); /* in: length of the buffer */
213
214	/**************************************************************************
215	Outputs a NUL-terminated file name, quoted with apostrophes. */
216
217	void
218	ut_print_filename(
219	/==============/
220	FILE* f, /* in: output stream */
221	const char* name); /* in: name to print */
222
223	/* Forward declaration of transaction handle */
224	struct trx_struct;
225
226	/**************************************************************************
227	Outputs a fixed-length string, quoted as an SQL identifier.
228	If the string contains a slash '/', the string will be
229	output as two identifiers separated by a period (.),
230	as in SQL database_name.identifier. */
231
232	void
233	ut_print_name(
234	/==========/
235	FILE* f, /* in: output stream */
236	struct trx_structtrx, / in: transaction */
237	ibool table_id,/* in: TRUE=print a table name,
238	FALSE=print other identifier */
239	const char* name); /* in: name to print */
240
241	/**************************************************************************
242	Outputs a fixed-length string, quoted as an SQL identifier.
243	If the string contains a slash '/', the string will be
244	output as two identifiers separated by a period (.),
245	as in SQL database_name.identifier. */
246
247	void
248	ut_print_namel(
249	/===========/
250	FILE* f, /* in: output stream */
251	struct trx_structtrx, / in: transaction (NULL=no quotes) */
252	ibool table_id,/* in: TRUE=print a table name,
253	FALSE=print other identifier */
254	const char* name, /* in: name to print */
255	ulint namelen);/* in: length of name */
256
257	/**************************************************************************
258	Catenate files. */
259
260	void
261	ut_copy_file(
262	/=========/
263	FILE* dest, /* in: output file */
264	FILE* src); /* in: input file to be appended to output */
265
266	/**************************************************************************
267	snprintf(). */
268
269	#ifdef __WIN__
270	int
271	ut_snprintf(
272	/* out: number of characters that would
273	have been printed if the size were
274	unlimited, not including the terminating
275	'\0'. */
276	char* str, /* out: string */
277	size_t size, /* in: str size */
278	const char* fmt, /* in: format */
279	...); /* in: format values */
280	#else
281	#define ut_snprintf snprintf
282	#endif /* __WIN__ */
283
284	#ifndef UNIV_NONINL
285	#include "ut0ut.ic"
286	#endif
287
288	#endif
289