~drizzle-trunk/drizzle/development

/**********************************************************************

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

#define	TEMP_INDEX_PREFIX	'\377'	/* Index name prefix in fast index

					creation */

typedef time_t	ib_time_t;

/*************************************************************************

Delays execution for at most max_wait_us microseconds or returns earlier

if cond becomes true; cond is evaluated every 2 ms. */

#define UT_WAIT_FOR(cond, max_wait_us)				\

do {								\

	ullint	start_us;					\

	start_us = ut_time_us(NULL);				\

	while (!(cond) 						\

	       && ut_time_us(NULL) - start_us < (max_wait_us)) {\

								\

		os_thread_sleep(2000 /* 2 ms */);		\

	}							\

} while (0)

/************************************************************

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. */

UNIV_INTERN

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 */

/*****************************************************************

Determines if a number is zero or a power of two. */

#define ut_is_2pow(n) UNIV_LIKELY(!((n) & ((n) - 1)))

/*****************************************************************

Calculates fast the remainder of n/m when m is a power of two. */

#define ut_2pow_remainder(n, m) ((n) & ((m) - 1))

/*****************************************************************

Calculates the biggest multiple of m that is not bigger than n

when m is a power of two.  In other words, rounds n down to m * k. */

#define ut_2pow_round(n, m) ((n) & ~((m) - 1))

#define ut_calc_align_down(n, m) ut_2pow_round(n, m)

/************************************************************

Calculates the smallest multiple of m that is not smaller than n

when m is a power of two.  In other words, rounds n up to m * k. */

#define ut_calc_align(n, m) (((n) + ((m) - 1)) & ~((m) - 1))

/*****************************************************************

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. */

UNIV_INTERN

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)

/**************************************************************

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. */

UNIV_INTERN

ib_time_t

ut_time(void);

/*=========*/

/**************************************************************

Returns system time.

Upon successful completion, the value 0 is returned; otherwise the

value -1 is returned and the global variable errno is set to indicate the

error. */

UNIV_INTERN

int

ut_usectime(

/*========*/

			/* out: 0 on success, -1 otherwise */

	ulint*	sec,	/* out: seconds since the Epoch */

	ulint*	ms);	/* out: microseconds since the Epoch+*sec */

/**************************************************************

Returns the number of microseconds since epoch. Similar to

time(3), the return value is also stored in *tloc, provided

that tloc is non-NULL. */

UNIV_INTERN

ullint

ut_time_us(

/*=======*/

			/* out: us since epoch */

	ullint*	tloc);	/* out: us since epoch, if non-NULL */

/**************************************************************

Returns the difference of two times in seconds. */

UNIV_INTERN

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. */

UNIV_INTERN

void

ut_print_timestamp(

/*===============*/

	FILE*  file); /* in: file where to print */

/**************************************************************

Sprintfs a timestamp to a buffer, 13..14 chars plus terminating NUL. */

UNIV_INTERN

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 '_'. */

UNIV_INTERN

void

ut_sprintf_timestamp_without_extra_chars(

/*=====================================*/

	char*	buf); /* in: buffer where to sprintf */

/**************************************************************

Returns current year, month, day. */

UNIV_INTERN

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++. */

UNIV_INTERN

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. */

UNIV_INTERN

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. */

UNIV_INTERN

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. */

UNIV_INTERN

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. */

UNIV_INTERN

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. */

UNIV_INTERN

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