attr.m4

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

	{
		status = NC_sync(ncp);
		if(status != NC_NOERR)
			return status;
	}

	return NC_NOERR;
}


int
nc_copy_att(int ncid_in, int varid_in, const char *name, int ncid_out, int ovarid)
{
	int status;
	NC_attr *iattrp;
	NC *ncp;
	NC_attrarray *ncap;
	NC_attr **attrpp;
	NC_attr *old = NULL;
	NC_attr *attrp;

	status = NC_lookupattr(ncid_in, varid_in, name, &iattrp);
	if(status != NC_NOERR)
		return status;

	status = NC_check_id(ncid_out, &ncp);
	if(status != NC_NOERR)
		return status;

	if(NC_readonly(ncp))
		return NC_EPERM;

	ncap = NC_attrarray0(ncp, ovarid);
	if(ncap == NULL)
		return NC_ENOTVAR;

	attrpp = NC_findattr(ncap, name);
	if(attrpp != NULL) /* name in use */
	{
		if(!NC_indef(ncp) )
		{
			attrp = *attrpp; /* convenience */
	
			if(iattrp->xsz > attrp->xsz)
				return NC_ENOTINDEFINE;
			/* else, we can reuse existing without redef */
			
			attrp->xsz = iattrp->xsz;
			attrp->type = iattrp->type;
			attrp->nelems = iattrp->nelems;

			(void) memcpy(attrp->xvalue, iattrp->xvalue,
				iattrp->xsz);
			
			set_NC_hdirty(ncp);

			if(NC_doHsync(ncp))
			{
				status = NC_sync(ncp);
				if(status != NC_NOERR)
					return status;
			}

			return NC_NOERR;
		}
		/* else, redefine using existing array slot */
		old = *attrpp;
	} 
	else
	{
		if(!NC_indef(ncp))
			return NC_ENOTINDEFINE;

		if(ncap->nelems >= NC_MAX_ATTRS)
			return NC_EMAXATTS;
	}

	attrp = new_NC_attr(name, iattrp->type, iattrp->nelems);
	if(attrp == NULL)
		return NC_ENOMEM;

	(void) memcpy(attrp->xvalue, iattrp->xvalue,
		iattrp->xsz);

	if(attrpp != NULL)
	{
		assert(old != NULL);
		*attrpp = attrp;
		free_NC_attr(old);
	}
	else
	{
		status = incr_NC_attrarray(ncap, attrp);
		if(status != NC_NOERR)
		{
			free_NC_attr(attrp);
			return status;
		}
	}

	return NC_NOERR;
}


int
nc_del_att(int ncid, int varid, const char *name)
{
	int status;
	NC *ncp;
	NC_attrarray *ncap;
	NC_attr **attrpp;
	NC_attr *old = NULL;
	int attrid;
	size_t slen;

	status = NC_check_id(ncid, &ncp);
	if(status != NC_NOERR)
		return status;

	if(!NC_indef(ncp))
		return NC_ENOTINDEFINE;

	ncap = NC_attrarray0(ncp, varid);
	if(ncap == NULL)
		return NC_ENOTVAR;

			/* sortof inline NC_findattr() */
	slen = strlen(name);

	attrpp = (NC_attr **) ncap->value;
	for(attrid = 0; (size_t) attrid < ncap->nelems; attrid++, attrpp++)
	{
		if( slen == (*attrpp)->name->nchars &&
			strncmp(name, (*attrpp)->name->cp, slen) == 0)
		{
			old = *attrpp;
			break;
		}
	}
	if( (size_t) attrid == ncap->nelems )
		return NC_ENOTATT;
			/* end inline NC_findattr() */

	/* shuffle down */
	for(attrid++; (size_t) attrid < ncap->nelems; attrid++)
	{
		*attrpp = *(attrpp + 1);
		attrpp++;
	}
	*attrpp = NULL;
	/* decrement count */
	ncap->nelems--;

	free_NC_attr(old);

	return NC_NOERR;
}

dnl
dnl XNCX_PAD_PUTN(Type)
dnl
define(`XNCX_PAD_PUTN',dnl
`dnl
static int
ncx_pad_putn_I$1(void **xpp, size_t nelems, const $1 *tp, nc_type type)
{
	switch(type) {
	case NC_CHAR:
		return NC_ECHAR;
	case NC_BYTE:
		return ncx_pad_putn_schar_$1(xpp, nelems, tp);
	case NC_SHORT:
		return ncx_pad_putn_short_$1(xpp, nelems, tp);
	case NC_INT:
		return ncx_putn_int_$1(xpp, nelems, tp);
	case NC_FLOAT:
		return ncx_putn_float_$1(xpp, nelems, tp);
	case NC_DOUBLE:
		return ncx_putn_double_$1(xpp, nelems, tp);
	}
	assert("ncx_pad_putn_I$1 invalid type" == 0);
	return NC_EBADTYPE;
}
')dnl
dnl
dnl XNCX_PAD_GETN(Type)
dnl
define(`XNCX_PAD_GETN',dnl
`dnl
static int
ncx_pad_getn_I$1(const void **xpp, size_t nelems, $1 *tp, nc_type type)
{
	switch(type) {
	case NC_CHAR:
		return NC_ECHAR;
	case NC_BYTE:
		return ncx_pad_getn_schar_$1(xpp, nelems, tp);
	case NC_SHORT:
		return ncx_pad_getn_short_$1(xpp, nelems, tp);
	case NC_INT:
		return ncx_getn_int_$1(xpp, nelems, tp);
	case NC_FLOAT:
		return ncx_getn_float_$1(xpp, nelems, tp);
	case NC_DOUBLE:
		return ncx_getn_double_$1(xpp, nelems, tp);
	}
	assert("ncx_pad_getn_I$1 invalid type" == 0);
	return NC_EBADTYPE;
}
')dnl
dnl Implement

XNCX_PAD_PUTN(uchar)
XNCX_PAD_GETN(uchar)

XNCX_PAD_PUTN(schar)
XNCX_PAD_GETN(schar)

XNCX_PAD_PUTN(short)
XNCX_PAD_GETN(short)

XNCX_PAD_PUTN(int)
XNCX_PAD_GETN(int)

XNCX_PAD_PUTN(long)
XNCX_PAD_GETN(long)

XNCX_PAD_PUTN(float)
XNCX_PAD_GETN(float)

XNCX_PAD_PUTN(double)
XNCX_PAD_GETN(double)


int
nc_put_att_text(int ncid, int varid, const char *name,
	size_t nelems, const char *value)
{
	int status;
	NC *ncp;
	NC_attrarray *ncap;
	NC_attr **attrpp;
	NC_attr *old = NULL;
	NC_attr *attrp;

	status = NC_check_id(ncid, &ncp);
	if(status != NC_NOERR)
		return status;

	if(NC_readonly(ncp))
		return NC_EPERM;

	ncap = NC_attrarray0(ncp, varid);
	if(ncap == NULL)
		return NC_ENOTVAR;

	status = NC_check_name(name);
	if(status != NC_NOERR)
		return status;

		/* cast needed for braindead systems with signed size_t */
	if((unsigned long) nelems > X_INT_MAX) /* backward compat */
		return NC_EINVAL; /* Invalid nelems */

	if(nelems != 0 && value == NULL)
		return NC_EINVAL; /* Null arg */

	attrpp = NC_findattr(ncap, name);
	if(attrpp != NULL) /* name in use */
	{
		if(!NC_indef(ncp) )
		{
			const size_t xsz = ncx_len_NC_attrV(NC_CHAR, nelems);
			attrp = *attrpp; /* convenience */
	
			if(xsz > attrp->xsz)
				return NC_ENOTINDEFINE;
			/* else, we can reuse existing without redef */
			
			attrp->xsz = xsz;
			attrp->type = NC_CHAR;
			attrp->nelems = nelems;

			if(nelems != 0)
			{
				void *xp = attrp->xvalue;
				status = ncx_pad_putn_text(&xp, nelems, value);
				if(status != NC_NOERR)
					return status;
			}
			
			set_NC_hdirty(ncp);

			if(NC_doHsync(ncp))
			{
				status = NC_sync(ncp);
				if(status != NC_NOERR)
					return status;
			}

			return NC_NOERR;
		}
		/* else, redefine using existing array slot */
		old = *attrpp;
	} 
	else
	{
		if(!NC_indef(ncp))
			return NC_ENOTINDEFINE;

		if(ncap->nelems >= NC_MAX_ATTRS)
			return NC_EMAXATTS;
	}

	attrp = new_NC_attr(name, NC_CHAR, nelems);
	if(attrp == NULL)
		return NC_ENOMEM;

	if(nelems != 0)
	{
		void *xp = attrp->xvalue;
		status = ncx_pad_putn_text(&xp, nelems, value);
		if(status != NC_NOERR)
			return status;
	}

	if(attrpp != NULL)
	{
		assert(old != NULL);
		*attrpp = attrp;
		free_NC_attr(old);
	}
	else
	{
		status = incr_NC_attrarray(ncap, attrp);
		if(status != NC_NOERR)
		{
			free_NC_attr(attrp);
			return status;
		}
	}

	return NC_NOERR;
}


int
nc_get_att_text(int ncid, int varid, const char *name, char *str)
{
	int status;
	NC_attr *attrp;

	status = NC_lookupattr(ncid, varid, name, &attrp);
	if(status != NC_NOERR)
		return status;

	if(attrp->nelems == 0)
		return NC_NOERR;

	if(attrp->type != NC_CHAR)
		return NC_ECHAR;

	/* else */
	{
		const void *xp = attrp->xvalue;
		return ncx_pad_getn_text(&xp, attrp->nelems, str);
	}
}


dnl
dnl NC_PUT_ATT(Abbrv, Type)
dnl
define(`NC_PUT_ATT',dnl
`dnl
int
nc_put_att_$1(int ncid, int varid, const char *name,
	nc_type type, size_t nelems, const $2 *value)
{
	int status;
	NC *ncp;
	NC_attrarray *ncap;
	NC_attr **attrpp;
	NC_attr *old = NULL;
	NC_attr *attrp;

	status = NC_check_id(ncid, &ncp);
	if(status != NC_NOERR)
		return status;

	if(NC_readonly(ncp))
		return NC_EPERM;

	ncap = NC_attrarray0(ncp, varid);
	if(ncap == NULL)
		return NC_ENOTVAR;

	status = nc_cktype(type);
	if(status != NC_NOERR)
		return status;

	if(type == NC_CHAR)
		return NC_ECHAR;

		/* cast needed for braindead systems with signed size_t */
	if((unsigned long) nelems > X_INT_MAX) /* backward compat */
		return NC_EINVAL; /* Invalid nelems */

	if(nelems != 0 && value == NULL)
		return NC_EINVAL; /* Null arg */

	attrpp = NC_findattr(ncap, name);
	if(attrpp != NULL) /* name in use */
	{
		if(!NC_indef(ncp) )
		{
			const size_t xsz = ncx_len_NC_attrV(type, nelems);
			attrp = *attrpp; /* convenience */
	
			if(xsz > attrp->xsz)
				return NC_ENOTINDEFINE;
			/* else, we can reuse existing without redef */
			
			attrp->xsz = xsz;
			attrp->type = type;
			attrp->nelems = nelems;

			if(nelems != 0)
			{
				void *xp = attrp->xvalue;
				status = ncx_pad_putn_I$1(&xp, nelems,
					value, type);
			}
			
			set_NC_hdirty(ncp);

			if(NC_doHsync(ncp))
			{
				const int lstatus = NC_sync(ncp);
				/*
				 * N.B.: potentially overrides NC_ERANGE
				 * set by ncx_pad_putn_I$1
				 */
				if(lstatus != ENOERR)
					return lstatus;
			}

			return status;
		}
		/* else, redefine using existing array slot */
		old = *attrpp;
	} 
	else
	{
		if(!NC_indef(ncp))
			return NC_ENOTINDEFINE;

		if(ncap->nelems >= NC_MAX_ATTRS)
			return NC_EMAXATTS;
	}

	status = NC_check_name(name);
	if(status != NC_NOERR)
		return status;

	attrp = new_NC_attr(name, type, nelems);
	if(attrp == NULL)
		return NC_ENOMEM;

	if(nelems != 0)
	{
		void *xp = attrp->xvalue;
		status = ncx_pad_putn_I$1(&xp, nelems,
			value, type);
	}

	if(attrpp != NULL)
	{
		assert(old != NULL);
		*attrpp = attrp;
		free_NC_attr(old);
	}
	else
	{
		const int lstatus = incr_NC_attrarray(ncap, attrp);
		/*
		 * N.B.: potentially overrides NC_ERANGE
		 * set by ncx_pad_putn_I$1
		 */
		if(lstatus != NC_NOERR)
		{
			free_NC_attr(attrp);
			return lstatus;
		}
	}

	return status;
}
')dnl
dnl
dnl NC_GET_ATT(Abbrv, Type)
dnl
define(`NC_GET_ATT',dnl
`dnl
int
nc_get_att_$1(int ncid, int varid, const char *name, $2 *tp)
{
	int status;
	NC_attr *attrp;

	status = NC_lookupattr(ncid, varid, name, &attrp);
	if(status != NC_NOERR)
		return status;

	if(attrp->nelems == 0)
		return NC_NOERR;

	if(attrp->type == NC_CHAR)
		return NC_ECHAR;

	{
	const void *xp = attrp->xvalue;
	return ncx_pad_getn_I$1(&xp, attrp->nelems, tp, attrp->type);
	}
}
')dnl


NC_PUT_ATT(schar, signed char)
NC_GET_ATT(schar, signed char)

NC_PUT_ATT(uchar, unsigned char)
NC_GET_ATT(uchar, unsigned char)

NC_PUT_ATT(short, short)
NC_GET_ATT(short, short)

NC_PUT_ATT(int, int)
NC_GET_ATT(int, int)

NC_PUT_ATT(long, long)
NC_GET_ATT(long, long)

NC_PUT_ATT(float, float)
NC_GET_ATT(float, float)

NC_PUT_ATT(double, double)
NC_GET_ATT(double, double)