mach0data.ic

这是linux下运行的mysql软件包,可用于linux 下安装 php + mysql + apach 的网络配置

/***********************************************************
The following function is used to store data in 6 consecutive
bytes. We store the most significant byte to the lowest address. */
UNIV_INLINE
void 
mach_write_to_6(
/*============*/
	byte*   b,      /* in: pointer to 6 bytes where to store */
	dulint	n)      /* in: dulint integer to be stored */ 
{
	ut_ad(b);

	mach_write_to_2(b, ut_dulint_get_high(n));
	mach_write_to_4(b + 2, ut_dulint_get_low(n));
}

/************************************************************
The following function is used to fetch data from 6 consecutive
bytes. The most significant byte is at the lowest address. */
UNIV_INLINE
dulint 
mach_read_from_6(
/*=============*/
			/* out: dulint integer */
	byte*   b)      /* in: pointer to 7 bytes */
{
	ulint	high;
	ulint	low;

	ut_ad(b);

	high = mach_read_from_2(b);
	low = mach_read_from_4(b + 2);

	return(ut_dulint_create(high, low)); 
}

/*************************************************************
Writes a dulint in a compressed form (5..9 bytes). */
UNIV_INLINE
ulint
mach_dulint_write_compressed(
/*=========================*/
			/* out: size in bytes */
	byte*   b,      /* in: pointer to memory where to store */
	dulint  n)     	/* in: dulint integer to be stored */ 
{
	ulint	size;

	ut_ad(b);

	size = mach_write_compressed(b, ut_dulint_get_high(n));
	mach_write_to_4(b + size, ut_dulint_get_low(n));

	return(size + 4);
}

/*************************************************************
Returns the size of a dulint when written in the compressed form. */
UNIV_INLINE
ulint
mach_dulint_get_compressed_size(
/*============================*/
			/* out: compressed size in bytes */
	dulint   n)     /* in: dulint integer to be stored */ 
{
	return(4 + mach_get_compressed_size(ut_dulint_get_high(n)));
}

/*************************************************************
Reads a dulint in a compressed form. */
UNIV_INLINE
dulint
mach_dulint_read_compressed(
/*========================*/
			/* out: read dulint */
	byte*   b)      /* in: pointer to memory from where to read */
{
	ulint	high;
	ulint	low;
	ulint	size;

	ut_ad(b);

	high = mach_read_compressed(b);

	size = mach_get_compressed_size(high);

	low = mach_read_from_4(b + size);

	return(ut_dulint_create(high, low)); 
}

/*************************************************************
Writes a dulint in a compressed form (1..11 bytes). */
UNIV_INLINE
ulint
mach_dulint_write_much_compressed(
/*==============================*/
			/* out: size in bytes */
	byte*   b,      /* in: pointer to memory where to store */
	dulint  n)     	/* in: dulint integer to be stored */ 
{
	ulint	size;

	ut_ad(b);
	
	if (ut_dulint_get_high(n) == 0) {
		return(mach_write_compressed(b, ut_dulint_get_low(n)));
	}
	
	*b = (byte)0xFF;
	size = 1 + mach_write_compressed(b + 1, ut_dulint_get_high(n));

	size += mach_write_compressed(b + size, ut_dulint_get_low(n));

	return(size);
}

/*************************************************************
Returns the size of a dulint when written in the compressed form. */
UNIV_INLINE
ulint
mach_dulint_get_much_compressed_size(
/*=================================*/
			/* out: compressed size in bytes */
	dulint   n)     /* in: dulint integer to be stored */ 
{
	if (0 == ut_dulint_get_high(n)) {
		return(mach_get_compressed_size(ut_dulint_get_low(n)));
	}

	return(1 + mach_get_compressed_size(ut_dulint_get_high(n))
	       + mach_get_compressed_size(ut_dulint_get_low(n)));
}

/*************************************************************
Reads a dulint in a compressed form. */
UNIV_INLINE
dulint
mach_dulint_read_much_compressed(
/*=============================*/
			/* out: read dulint */
	byte*   b)      /* in: pointer to memory from where to read */
{
	ulint	high;
	ulint	low;
	ulint	size;

	ut_ad(b);

	if (*b != (byte)0xFF) {
		high = 0;
		size = 0;
	} else {
		high = mach_read_compressed(b + 1);

		size = 1 + mach_get_compressed_size(high);
	}

	low = mach_read_compressed(b + size);

	return(ut_dulint_create(high, low)); 
}

/*************************************************************
Reads a double. It is stored in a little-endian format. */
UNIV_INLINE
double
mach_double_read(
/*=============*/
			/* out: double read */
	byte*   b)      /* in: pointer to memory from where to read */
{
	double 	d;
	ulint	i;
	byte*	ptr;

	ptr = (byte*)&d;

	for (i = 0; i < sizeof(double); i++) {
#ifdef WORDS_BIGENDIAN
		ptr[sizeof(double) - i - 1] = b[i];
#else
		ptr[i] = b[i];
#endif
	}

	return(d);	
}

/*************************************************************
Writes a double. It is stored in a little-endian format. */
UNIV_INLINE
void
mach_double_write(
/*==============*/
	byte*   b,      /* in: pointer to memory where to write */
	double 	d)	/* in: double */
{
	ulint	i;
	byte*	ptr;

	ptr = (byte*)&d;

	for (i = 0; i < sizeof(double); i++) {
#ifdef WORDS_BIGENDIAN
		b[i] = ptr[sizeof(double) - i - 1];
#else
		b[i] = ptr[i];
#endif
	}
}

/*************************************************************
Reads a float. It is stored in a little-endian format. */
UNIV_INLINE
float
mach_float_read(
/*=============*/
			/* out: float read */
	byte*   b)      /* in: pointer to memory from where to read */
{
	float 	d;
	ulint	i;
	byte*	ptr;

	ptr = (byte*)&d;

	for (i = 0; i < sizeof(float); i++) {
#ifdef WORDS_BIGENDIAN
		ptr[sizeof(float) - i - 1] = b[i];
#else
		ptr[i] = b[i];
#endif
	}

	return(d);	
}

/*************************************************************
Writes a float. It is stored in a little-endian format. */
UNIV_INLINE
void
mach_float_write(
/*==============*/
	byte*   b,      /* in: pointer to memory where to write */
	float 	d)	/* in: float */
{
	ulint	i;
	byte*	ptr;

	ptr = (byte*)&d;

	for (i = 0; i < sizeof(float); i++) {
#ifdef WORDS_BIGENDIAN
		b[i] = ptr[sizeof(float) - i - 1];
#else
		b[i] = ptr[i];
#endif
	}
}

/*************************************************************
Reads a ulint stored in the little-endian format. */
UNIV_INLINE
ulint
mach_read_from_n_little_endian(
/*===========================*/
				/* out: unsigned long int */
	byte*	buf,		/* in: from where to read */
	ulint	buf_size)	/* in: from how many bytes to read */
{
	ulint	n	= 0;
	byte*	ptr;

	ut_ad(buf_size <= sizeof(ulint));
	ut_ad(buf_size > 0);

	ptr = buf + buf_size;
	
	for (;;) {
		ptr--;

		n = n << 8;

		n += (ulint)(*ptr);

		if (ptr == buf) {
			break;
		}
	}

	return(n);
}

/*************************************************************
Writes a ulint in the little-endian format. */
UNIV_INLINE
void
mach_write_to_n_little_endian(
/*==========================*/
	byte*	dest,		/* in: where to write */
	ulint	dest_size,	/* in: into how many bytes to write */
	ulint	n)		/* in: unsigned long int to write */
{
	byte*	end;

	ut_ad(dest_size <= sizeof(ulint));
	ut_ad(dest_size > 0);

	end = dest + dest_size;
	
	for (;;) {
		*dest = (byte)(n & 0xFF);

		n = n >> 8;

		dest++;

		if (dest == end) {
			break;
		} 
	}

	ut_ad(n == 0);
}

/*************************************************************
Reads a ulint stored in the little-endian format. */
UNIV_INLINE
ulint
mach_read_from_2_little_endian(
/*===========================*/
				/* out: unsigned long int */
	byte*	buf)		/* in: from where to read */
{
	return((ulint)(*buf) + ((ulint)(*(buf + 1))) * 256);
}

/*************************************************************
Writes a ulint in the little-endian format. */
UNIV_INLINE
void
mach_write_to_2_little_endian(
/*==========================*/
	byte*	dest,		/* in: where to write */
	ulint	n)		/* in: unsigned long int to write */
{
	ut_ad(n < 256 * 256);

	*dest = (byte)(n & 0xFFUL);

	n = n >> 8;
	dest++;

	*dest = (byte)(n & 0xFFUL);
}