ncx.m4

一个用来实现偏微分方程中网格的计算库

	*xpp = (void *)((char *)(*xpp) + nelems);

	if(rndup)
	{
		(void) memcpy(*xpp, nada, rndup);
		*xpp = (void *)((char *)(*xpp) + rndup);
	}
	
	return ENOERR;
`dnl
')dnl
dnl dnl dnl
dnl
dnl NCX_PUTN_SCHAR(Type)
dnl
define(`NCX_PUTN_SCHAR',dnl
`dnl
int
ncx_putn_schar_$1(void **xpp, size_t nelems, const $1 *tp)
{
	int status = ENOERR;
	schar *xp = (schar *) *xpp;

	while(nelems-- != 0)
	{
		if(*tp > X_SCHAR_MAX || *tp < X_SCHAR_MIN)
			status = NC_ERANGE;
		*xp++ = (schar) *tp++;
	}

	*xpp = (void *)xp;
	return status;
}
')dnl
dnl dnl dnl
dnl
dnl NCX_PAD_PUTN_SCHAR(Type)
dnl
define(`NCX_PAD_PUTN_SCHAR',dnl
`dnl
int
ncx_pad_putn_schar_$1(void **xpp, size_t nelems, const $1 *tp)
{
	int status = ENOERR;
	size_t rndup = nelems % X_ALIGN;
	schar *xp = (schar *) *xpp;

	if(rndup)
		rndup = X_ALIGN - rndup;

	while(nelems-- != 0)
	{
		/* N.B. schar as signed */
		if(*tp > X_SCHAR_MAX || *tp < X_SCHAR_MIN)
			status = NC_ERANGE;
		*xp++ = (schar) *tp++;
	}


	if(rndup)
	{
		(void) memcpy(xp, nada, rndup);
		xp += rndup;
	}

	*xpp = (void *)xp;
	return status;
}
')dnl
dnl dnl dnl
dnl
dnl NCX_PUTNo(XType, Type) deprecated
dnl
define(`NCX_PUTNo',dnl
`dnl
int
ncx_putn_$1_$2(void **xpp, size_t nelems, const $2 *tp)
{
	char *xp = (char *) *xpp;
	int status = ENOERR;
	$1 xx;

	for( ; nelems != 0; nelems--, xp += Xsizeof($1), tp++)
	{
		xx = ($1) *tp;
		{
		int lstatus = ncx_put_$1_$1(xp, &xx);
		if(lstatus != ENOERR)
			status = lstatus;
		}
	}

	*xpp = (void *)xp;
	return status;
}
')dnl
dnl dnl dnl
dnl
dnl NCX_PUTN(XType, Type)
dnl
define(`NCX_PUTN',dnl
`dnl
int
ncx_putn_$1_$2(void **xpp, size_t nelems, const $2 *tp)
{
	char *xp = (char *) *xpp;
	int status = ENOERR;

	for( ; nelems != 0; nelems--, xp += Xsizeof($1), tp++)
	{
		int lstatus = ncx_put_$1_$2(xp, tp);
		if(lstatus != ENOERR)
			status = lstatus;
	}

	*xpp = (void *)xp;
	return status;
}
')dnl
dnl dnl dnl
dnl
dnl NCX_PAD_PUTN_SHORT(Type)
dnl
define(`NCX_PAD_PUTN_SHORT',dnl
`dnl
int
ncx_pad_putn_short_$1(void **xpp, size_t nelems, const $1 *tp)
{
	const size_t rndup = nelems % 2;

	char *xp = (char *) *xpp;
	int status = ENOERR;

	for( ; nelems != 0; nelems--, xp += Xsizeof(short), tp++)
	{
		int lstatus = ncx_put_short_$1(xp, tp);
		if(lstatus != ENOERR)
			status = lstatus;
	}

	if(rndup != 0)
	{
		(void) memcpy(xp, nada, X_SIZEOF_SHORT);
		xp += X_SIZEOF_SHORT;	
	}
		
	*xpp = (void *)xp;
	return status;
}
')dnl


dnl dnl dnl
dnl
dnl Declare & define routines
dnl
dnl dnl dnl

/* schar */

dnl NCX_GETN_SCHAR(schar)
int
ncx_getn_schar_schar(const void **xpp, size_t nelems, schar *tp)
{
	NCX_GETN_Byte_Body
}
dnl NCX_GETN_SCHAR(uchar)
int
ncx_getn_schar_uchar(const void **xpp, size_t nelems, uchar *tp)
{
	NCX_GETN_Byte_Body
}
NCX_GETN_SCHAR(short)
NCX_GETN_SCHAR(int)
NCX_GETN_SCHAR(long)
NCX_GETN_SCHAR(float)
NCX_GETN_SCHAR(double)

dnl NCX_PAD_GETN_SCHAR(schar)
int
ncx_pad_getn_schar_schar(const void **xpp, size_t nelems, schar *tp)
{
	NCX_PAD_GETN_Byte_Body
}
dnl NCX_PAD_GETN_SCHAR(uchar)
int
ncx_pad_getn_schar_uchar(const void **xpp, size_t nelems, uchar *tp)
{
	NCX_PAD_GETN_Byte_Body
}
NCX_PAD_GETN_SCHAR(short)
NCX_PAD_GETN_SCHAR(int)
NCX_PAD_GETN_SCHAR(long)
NCX_PAD_GETN_SCHAR(float)
NCX_PAD_GETN_SCHAR(double)

dnl NCX_PUTN_SCHAR(schar)
int
ncx_putn_schar_schar(void **xpp, size_t nelems, const schar *tp)
{
	NCX_PUTN_Byte_Body
}
dnl NCX_PUTN_SCHAR(uchar)
int
ncx_putn_schar_uchar(void **xpp, size_t nelems, const uchar *tp)
{
	NCX_PUTN_Byte_Body
}
NCX_PUTN_SCHAR(short)
NCX_PUTN_SCHAR(int)
NCX_PUTN_SCHAR(long)
NCX_PUTN_SCHAR(float)
NCX_PUTN_SCHAR(double)

dnl NCX_PAD_PUTN_SCHAR(schar)
int
ncx_pad_putn_schar_schar(void **xpp, size_t nelems, const schar *tp)
{
	NCX_PAD_PUTN_Byte_Body
}
dnl NCX_PAD_PUTN_SCHAR(uchar)
int
ncx_pad_putn_schar_uchar(void **xpp, size_t nelems, const uchar *tp)
{
	NCX_PAD_PUTN_Byte_Body
}
NCX_PAD_PUTN_SCHAR(short)
NCX_PAD_PUTN_SCHAR(int)
NCX_PAD_PUTN_SCHAR(long)
NCX_PAD_PUTN_SCHAR(float)
NCX_PAD_PUTN_SCHAR(double)


/* short */

NCX_GETN(short, schar)
NCX_GETN(short, uchar)
#if X_SIZEOF_SHORT == SIZEOF_SHORT
/* optimized version */
int
ncx_getn_short_short(const void **xpp, size_t nelems, short *tp)
{
#ifdef WORDS_BIGENDIAN
	(void) memcpy(tp, *xpp, nelems * sizeof(short));
# else
	swapn2b(tp, *xpp, nelems);
# endif
	*xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_SHORT);
	return ENOERR;
}
#else
NCX_GETN(short, short)
#endif
NCX_GETN(short, int)
NCX_GETN(short, long)
NCX_GETN(short, float)
NCX_GETN(short, double)

NCX_PAD_GETN_SHORT(schar)
NCX_PAD_GETN_SHORT(uchar)
NCX_PAD_GETN_SHORT(short)
NCX_PAD_GETN_SHORT(int)
NCX_PAD_GETN_SHORT(long)
NCX_PAD_GETN_SHORT(float)
NCX_PAD_GETN_SHORT(double)

NCX_PUTN(short, schar)
NCX_PUTN(short, uchar)
#if X_SIZEOF_SHORT == SIZEOF_SHORT
/* optimized version */
int
ncx_putn_short_short(void **xpp, size_t nelems, const short *tp)
{
#ifdef WORDS_BIGENDIAN
	(void) memcpy(*xpp, tp, nelems * X_SIZEOF_SHORT);
# else
	swapn2b(*xpp, tp, nelems);
# endif
	*xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_SHORT);
	return ENOERR;
}
#else
NCX_PUTN(short, short)
#endif
NCX_PUTN(short, int)
NCX_PUTN(short, long)
NCX_PUTN(short, float)
NCX_PUTN(short, double)

NCX_PAD_PUTN_SHORT(schar)
NCX_PAD_PUTN_SHORT(uchar)
NCX_PAD_PUTN_SHORT(short)
NCX_PAD_PUTN_SHORT(int)
NCX_PAD_PUTN_SHORT(long)
NCX_PAD_PUTN_SHORT(float)
NCX_PAD_PUTN_SHORT(double)


/* int */

NCX_GETN(int, schar)
NCX_GETN(int, uchar)
NCX_GETN(int, short)
#if X_SIZEOF_INT == SIZEOF_INT
/* optimized version */
int
ncx_getn_int_int(const void **xpp, size_t nelems, int *tp)
{
#ifdef WORDS_BIGENDIAN
	(void) memcpy(tp, *xpp, nelems * sizeof(int));
# else
	swapn4b(tp, *xpp, nelems);
# endif
	*xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_INT);
	return ENOERR;
}
#else
NCX_GETN(int, int)
#endif
#if X_SIZEOF_INT == SIZEOF_LONG
/* optimized version */
int
ncx_getn_int_long(const void **xpp, size_t nelems, long *tp)
{
#ifdef WORDS_BIGENDIAN
	(void) memcpy(tp, *xpp, nelems * sizeof(long));
# else
	swapn4b(tp, *xpp, nelems);
# endif
	*xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_INT);
	return ENOERR;
}
#else
NCX_GETN(int, long)
#endif
NCX_GETN(int, float)
NCX_GETN(int, double)

NCX_PUTN(int, schar)
NCX_PUTN(int, uchar)
NCX_PUTN(int, short)
#if X_SIZEOF_INT == SIZEOF_INT
/* optimized version */
int
ncx_putn_int_int(void **xpp, size_t nelems, const int *tp)
{
#ifdef WORDS_BIGENDIAN
	(void) memcpy(*xpp, tp, nelems * X_SIZEOF_INT);
# else
	swapn4b(*xpp, tp, nelems);
# endif
	*xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_INT);
	return ENOERR;
}
#else
NCX_PUTN(int, int)
#endif
#if X_SIZEOF_INT == SIZEOF_LONG
/* optimized version */
int
ncx_putn_int_long(void **xpp, size_t nelems, const long *tp)
{
#ifdef WORDS_BIGENDIAN
	(void) memcpy(*xpp, tp, nelems * X_SIZEOF_INT);
# else
	swapn4b(*xpp, tp, nelems);
# endif
	*xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_INT);
	return ENOERR;
}
#else
NCX_PUTN(int, long)
#endif
NCX_PUTN(int, float)
NCX_PUTN(int, double)


/* float */

NCX_GETN(float, schar)
NCX_GETN(float, uchar)
NCX_GETN(float, short)
NCX_GETN(float, int)
NCX_GETN(float, long)
#if X_SIZEOF_FLOAT == SIZEOF_FLOAT && !defined(NO_IEEE_FLOAT)
/* optimized version */
int
ncx_getn_float_float(const void **xpp, size_t nelems, float *tp)
{
#ifdef WORDS_BIGENDIAN
	(void) memcpy(tp, *xpp, nelems * sizeof(float));
# else
	swapn4b(tp, *xpp, nelems);
# endif
	*xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_FLOAT);
	return ENOERR;
}
#elif vax
int
ncx_getn_float_float(const void **xpp, size_t nfloats, float *ip)
{
	float *const end = ip + nfloats;

	while(ip < end)
	{
GET_VAX_DFLOAT_Body(`(*xpp)')

		ip++;
		*xpp = (char *)(*xpp) + X_SIZEOF_FLOAT;
	}
	return ENOERR;
}
#elif _SX && _FLOAT2
int
ncx_getn_float_float(const void **xpp, size_t nelems, float *tp)
{
	const char *const xp = *xpp;

	const int ncnv = ie3_fl2(xp, tp, 4, 8, nelems);

	*xpp = xp + nelems * X_SIZEOF_FLOAT;
	return (nelems == ncnv ? ENOERR : NC_ERANGE);
}
#else
int
ncx_getn_float_float(const void **xpp, size_t nelems, float *tp)
{
	const char *xp = *xpp;
	int status = ENOERR;

	for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOAT, tp++)
	{
		const int lstatus = ncx_get_float_float(xp, tp);
		if(lstatus != ENOERR)
			status = lstatus;
	}

	*xpp = (const void *)xp;
	return status;
}

#endif
NCX_GETN(float, double)

NCX_PUTN(float, schar)
NCX_PUTN(float, uchar)
NCX_PUTN(float, short)
NCX_PUTN(float, int)
NCX_PUTN(float, long)
#if X_SIZEOF_FLOAT == SIZEOF_FLOAT && !defined(NO_IEEE_FLOAT)
/* optimized version */
int
ncx_putn_float_float(void **xpp, size_t nelems, const float *tp)
{
#ifdef WORDS_BIGENDIAN
	(void) memcpy(*xpp, tp, nelems * X_SIZEOF_FLOAT);
# else
	swapn4b(*xpp, tp, nelems);
# endif
	*xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_FLOAT);
	return ENOERR;
}
#elif vax
int
ncx_putn_float_float(void **xpp, size_t nfloats, const float *ip)
{
	const float *const end = ip + nfloats;

	while(ip < end)
	{
PUT_VAX_DFLOAT_Body(`(*xpp)')
	
		ip++;
		*xpp = (char *)(*xpp) + X_SIZEOF_FLOAT;
	}
	return ENOERR;
}
#elif _SX && _FLOAT2
int
ncx_putn_float_float(void **xpp, size_t nelems, const float *tp)
{
	char *const xp = *xpp;

	const int ncnv = fl2_ie3(tp, xp, 8, 4, nelems);

	*xpp = xp + nelems * X_SIZEOF_FLOAT;
	return (nelems == ncnv ? ENOERR : NC_ERANGE);
}
#else
int
ncx_putn_float_float(void **xpp, size_t nelems, const float *tp)
{
	char *xp = *xpp;
	int status = ENOERR;

	for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOAT, tp++)
	{
		int lstatus = ncx_put_float_float(xp, tp);
		if(lstatus != ENOERR)
			status = lstatus;
	}

	*xpp = (void *)xp;
	return status;
}

#endif
NCX_PUTN(float, double)


/* double */

NCX_GETN(double, schar)
NCX_GETN(double, uchar)
NCX_GETN(double, short)
NCX_GETN(double, int)
NCX_GETN(double, long)
NCX_GETN(double, float)
dnl NCX_GETN(double, double)
#if X_SIZEOF_DOUBLE == SIZEOF_DOUBLE && !defined(NO_IEEE_FLOAT)
/* optimized version */
int
ncx_getn_double_double(const void **xpp, size_t nelems, double *tp)
{
#ifdef WORDS_BIGENDIAN
	(void) memcpy(tp, *xpp, nelems * sizeof(double));
# else
	swapn8b(tp, *xpp, nelems);
# endif
	*xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_DOUBLE);
	return ENOERR;
}
#elif vax
int
ncx_getn_double_double(const void **xpp, size_t ndoubles, double *ip)
{
	double *const end = ip + ndoubles;

	while(ip < end)
	{
GET_VAX_DDOUBLE_Body(`(*xpp)')
		ip++;
		*xpp = (char *)(*xpp) + X_SIZEOF_DOUBLE;
	}
	return ENOERR;
}
	/* vax */
#elif _SX && _FLOAT2
int
ncx_getn_double_double(const void **xpp, size_t nelems, double *tp)
{
	const char *const xp = *xpp;

	const int ncnv = ie3_fl2(xp, tp, 8, 8, nelems);

	*xpp = xp + nelems * X_SIZEOF_DOUBLE;
	return (nelems == ncnv ? ENOERR : NC_ERANGE);
}
#else
int
ncx_getn_double_double(const void **xpp, size_t nelems, double *tp)
{
	const char *xp = *xpp;
	int status = ENOERR;

	for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLE, tp++)
	{
		const int lstatus = ncx_get_double_double(xp, tp);
		if(lstatus != ENOERR)
			status = lstatus;
	}

	*xpp = (const void *)xp;
	return status;
}

#endif

NCX_PUTN(double, schar)
NCX_PUTN(double, uchar)
NCX_PUTN(double, short)
NCX_PUTN(double, int)
NCX_PUTN(double, long)
NCX_PUTN(double, float)
dnl NCX_PUTN(double, double)
#if X_SIZEOF_DOUBLE == SIZEOF_DOUBLE && !defined(NO_IEEE_FLOAT)
/* optimized version */
int
ncx_putn_double_double(void **xpp, size_t nelems, const double *tp)
{
#ifdef WORDS_BIGENDIAN
	(void) memcpy(*xpp, tp, nelems * X_SIZEOF_DOUBLE);
# else
	swapn8b(*xpp, tp, nelems);
# endif
	*xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_DOUBLE);
	return ENOERR;
}
#elif vax
int
ncx_putn_double_double(void **xpp, size_t ndoubles, const double *ip)
{
	const double *const end = ip + ndoubles;

	while(ip < end)
	{
PUT_VAX_DDOUBLE_Body(`(*xpp)')
		ip++;
		*xpp = (char *)(*xpp) + X_SIZEOF_DOUBLE;
	}
	return ENOERR;
}
	/* vax */
#elif _SX && _FLOAT2
int
ncx_putn_double_double(void **xpp, size_t nelems, const double *tp)
{
	char *const xp = *xpp;

	const int ncnv = fl2_ie3(tp, xp, 8, 8, nelems);

	*xpp = xp + nelems * X_SIZEOF_DOUBLE;
	return (nelems == ncnv ? ENOERR : NC_ERANGE);
}
#else
int
ncx_putn_double_double(void **xpp, size_t nelems, const double *tp)
{
	char *xp = *xpp;
	int status = ENOERR;

	for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLE, tp++)
	{
		int lstatus = ncx_put_double_double(xp, tp);
		if(lstatus != ENOERR)
			status = lstatus;
	}

	*xpp = (void *)xp;
	return status;
}

#endif


/*
 * Other aggregate conversion functions.
 */

/* text */

int
ncx_getn_text(const void **xpp, size_t nelems, char *tp)
{
NCX_GETN_Byte_Body
}

int
ncx_pad_getn_text(const void **xpp, size_t nelems, char *tp)
{
NCX_PAD_GETN_Byte_Body
}

int
ncx_putn_text(void **xpp, size_t nelems, const char *tp)
{
NCX_PUTN_Byte_Body
}

int
ncx_pad_putn_text(void **xpp, size_t nelems, const char *tp)
{
NCX_PAD_PUTN_Byte_Body
}


/* opaque */

int
ncx_getn_void(const void **xpp, size_t nelems, void *tp)
{
NCX_GETN_Byte_Body
}

int
ncx_pad_getn_void(const void **xpp, size_t nelems, void *tp)
{
NCX_PAD_GETN_Byte_Body
}

int
ncx_putn_void(void **xpp, size_t nelems, const void *tp)
{
NCX_PUTN_Byte_Body
}

int
ncx_pad_putn_void(void **xpp, size_t nelems, const void *tp)
{
NCX_PAD_PUTN_Byte_Body
}