(fe66246c) · Commits · 郑智淋 / lammps

src/XTC/Install.csh

+6 −0

Original line number	Diff line number	Diff line
		@@ -8,6 +8,9 @@ if ($1 == 1) then

		cp dump_xtc.h ..

		cp xdr_compat.cpp ..
		cp xdr_compat.h ..

		else if ($1 == 0) then

		rm ../style_xtc.h
		@@ -17,4 +20,7 @@ else if ($1 == 0) then

		rm ../dump_xtc.h

		rm ../xdr_compat.cpp
		rm ../xdr_compat.h

		endif

src/XTC/dump_xtc.cpp

+58 −23

Original line number	Diff line number	Diff line
		@@ -23,8 +23,6 @@
		#include "stdlib.h"
		#include "string.h"
		#include "limits.h"
		#include "rpc/rpc.h"
		#include "rpc/xdr.h"
		#include "dump_xtc.h"
		#include "domain.h"
		#include "atom.h"
		@@ -46,11 +44,17 @@ int xdrclose(XDR *) ;
		void xdrfreebuf();
		int xdr3dfcoord(XDR , float , int , float );

		// include XDR compatibility code

		#ifdef LAMMPS_USE_XDR_COMPAT
		#include "xdr_compat.c"
		#endif

		/* ---------------------------------------------------------------------- */

		DumpXTC::DumpXTC(LAMMPS lmp, int narg, char *arg) : Dump(lmp, narg, arg)
		{
		if (narg != 5 && narg != 6) error->all("Illegal dump xtc command");
		if (narg != 5) error->all("Illegal dump xtc command");
		if (igroup != group->find("all")) error->all("Dump xtc must use group all");
		if (binary \|\| compressed \|\| multifile \|\| multiproc)
		error->all("Invalid dump xtc filename");
		@@ -58,17 +62,8 @@ DumpXTC::DumpXTC(LAMMPS lmp, int narg, char *arg) : Dump(lmp, narg, arg)
		size_one = 4;
		format_default = NULL;
		flush_flag = 0;

		// parse extra argument

		unwrap_flag = 0;
		precision = 1000.0;
		if (narg == 6) {
		precision = atof(arg[5]);
		if ((fabs(precision-10.0) > EPS) && (fabs(precision-100.0) > EPS) &&
		(fabs(precision-1000.0) > EPS) && (fabs(precision-10000.0) > EPS) &&
		(fabs(precision-100000.0) > EPS) && (fabs(precision-1000000.0) > EPS))
		error->all("Illegal dump xtc command");
		}

		// allocate global array for atom coords

		@@ -79,6 +74,7 @@ DumpXTC::DumpXTC(LAMMPS lmp, int narg, char *arg) : Dump(lmp, narg, arg)
		coords = (float ) memory->smalloc(3natoms*sizeof(float),"dump:coords");

		// sfactor = conversion of coords to XTC units
		// GROMACS standard is nanometers, not Angstroms

		sfactor = 0.1;
		if (strcmp(update->unit_style,"lj") == 0) sfactor = 1.0;
		@@ -92,6 +88,7 @@ DumpXTC::DumpXTC(LAMMPS lmp, int narg, char *arg) : Dump(lmp, narg, arg)
		DumpXTC::~DumpXTC()
		{
		memory->sfree(coords);

		if (me == 0) {
		xdrclose(&xd);
		xdrfreebuf();
		@@ -107,6 +104,29 @@ void DumpXTC::init()
		if (flush_flag) error->all("Cannot set dump_modify flush for dump xtc");
		}

		/* ---------------------------------------------------------------------- */

		int DumpXTC::modify_param(int narg, char **arg)
		{
		if (strcmp(arg[0],"unwrap") == 0) {
		if (narg < 2) error->all("Illegal dump_modify command");
		if (strcmp(arg[1],"yes") == 0) unwrap_flag = 1;
		else if (strcmp(arg[1],"no") == 0) unwrap_flag = 0;
		else error->all("Illegal dump_modify command");
		return 2;
		} else if (strcmp(arg[0],"precision") == 0) {
		if (narg < 2) error->all("Illegal dump_modify command");
		precision = atof(arg[1]);
		if ((fabs(precision-10.0) > EPS) && (fabs(precision-100.0) > EPS) &&
		(fabs(precision-1000.0) > EPS) && (fabs(precision-10000.0) > EPS) &&
		(fabs(precision-100000.0) > EPS) &&
		(fabs(precision-1000000.0) > EPS))
		error->all("Illegal dump_modify command");
		return 2;
		}
		return 0;
		}

		/* ----------------------------------------------------------------------
		return # of bytes of allocated memory in buf and global coords array
		------------------------------------------------------------------------- */
		@@ -154,9 +174,9 @@ void DumpXTC::write_header(int n)
		// cell basis vectors

		float zero = 0.0;
		float xdim = domain->boxhi[0] - domain->boxlo[0];
		float ydim = domain->boxhi[1] - domain->boxlo[1];
		float zdim = domain->boxhi[2] - domain->boxlo[2];
		float xdim = sfactor * (domain->boxhi[0] - domain->boxlo[0]);
		float ydim = sfactor * (domain->boxhi[1] - domain->boxlo[1]);
		float zdim = sfactor * (domain->boxhi[2] - domain->boxlo[2]);

		xdr_float(&xd,&xdim); xdr_float(&xd,&zero); xdr_float(&xd,&zero);
		xdr_float(&xd,&zero); xdr_float(&xd,&ydim); xdr_float(&xd,&zero);
		@@ -176,17 +196,32 @@ int DumpXTC::pack()
		{
		int *tag = atom->tag;
		double **x = atom->x;
		int *image = atom->image;
		int nlocal = atom->nlocal;

		// assume group all, so no need to perform mask check

		int m = 0;
		if (unwrap_flag == 1) {
		double xprd = domain->xprd;
		double yprd = domain->yprd;
		double zprd = domain->zprd;

		for (int i = 0; i < nlocal; i++) {
		buf[m++] = tag[i];
		buf[m++] = sfactor(x[i][0] + ((image[i] & 1023) - 512) xprd);
		buf[m++] = sfactor(x[i][1] + ((image[i] >> 10 & 1023) - 512) yprd);
		buf[m++] = sfactor(x[i][2] + ((image[i] >> 20) - 512) zprd);
		}

		} else {
		for (int i = 0; i < nlocal; i++) {
		buf[m++] = tag[i];
		buf[m++] = sfactor*x[i][0];
		buf[m++] = sfactor*x[i][1];
		buf[m++] = sfactor*x[i][2];
		}
		}

		return m;
		}
		@@ -264,7 +299,6 @@ void DumpXTC::write_frame()
		static FILE *xdrfiles[MAXID];
		static XDR *xdridptr[MAXID];
		static char xdrmodes[MAXID];
		static unsigned int cnt;
		static int *ip = NULL;
		static int *buf = NULL;

		@@ -384,6 +418,7 @@ int xdrclose(XDR *xdrs)
		}
		fprintf(stderr, "xdrclose: no such open xdr file\n");
		exit(1);
		return 1;
		}

		/*_________________________________________________________________________

src/XTC/dump_xtc.h

+8 −1

Original line number	Diff line number	Diff line
		@@ -15,8 +15,13 @@
		#define DUMP_XTC_H

		#include "dump.h"

		#ifdef LAMMPS_XDR
		#include "xdr_compat.h"
		#else
		#include "rpc/rpc.h"
		#include "rpc/xdr.h"
		#endif

		namespace LAMMPS_NS {

		@@ -29,11 +34,13 @@ class DumpXTC : public Dump {

		private:
		int natoms,ntotal;
		float precision;
		int unwrap_flag; // 1 if atom coords are unwrapped, 0 if no
		float precision; // user-adjustable precision setting
		float *coords;
		double sfactor;
		XDR xd;

		int modify_param(int, char **);
		void openfile();
		void write_header(int);
		int count();

src/XTC/xdr_compat.cpp

0 → 100644

+717 −0

Original line number	Diff line number	Diff line
		#ifdef LAMMPS_XDR

		#include <stdlib.h>
		#include <limits.h>
		#include <string.h>
		#include "xdr_compat.h"

		/* This file is needed for systems, that do not provide XDR support
		* in their system libraries. It was written for windows, but will
		* most probably work on other platforms too. better make sure you
		* test that the xtc files produced are ok before using it.
		*
		* It is also needed on BG/L and Cray XT3/XT4 as we don't have
		* XDR support in the lightweight kernel runtimes either.
		*
		* This file contains the definitions for Sun External Data
		* Representation (XDR) headers and routines.
		*
		* Although the rest of LAMPPS is GPL, you can copy and use the XDR
		* routines in any way you want as long as you obey Sun's license:
		*
		* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
		* unrestricted use provided that this legend is included on all tape
		* media and as a part of the software program in whole or part. Users
		* may copy or modify Sun RPC without charge, but are not authorized
		* to license or distribute it to anyone else except as part of a product or
		* program developed by the user.
		*
		* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
		* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
		* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
		*
		* Sun RPC is provided with no support and without any obligation on the
		* part of Sun Microsystems, Inc. to assist in its use, correction,
		* modification or enhancement.
		*
		* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
		* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
		* OR ANY PART THEREOF.
		*
		* In no event will Sun Microsystems, Inc. be liable for any lost revenue
		* or profits or other special, indirect and consequential damages, even if
		* Sun has been advised of the possibility of such damages.
		*
		* Sun Microsystems, Inc.
		* 2550 Garcia Avenue
		* Mountain View, California 94043
		*/

		#ifdef __cplusplus
		extern "C" {
		#endif

		/*
		* for unit alignment
		*/
		static char xdr_zero[BYTES_PER_XDR_UNIT] = {0, 0, 0, 0};

		static xdr_uint32_t xdr_swapbytes(xdr_uint32_t x)
		{
		xdr_uint32_t y;
		int i;
		char px=(char )&x;
		char py=(char )&y;

		for(i=0;i<4;i++)
		py[i]=px[3-i];

		return y;
		}

		static xdr_uint32_t xdr_htonl(xdr_uint32_t x)
		{
		short s=0x0F00;
		if( ((char )&s)==(char)0x0F) {
		/* bigendian, do nothing */
		return x;
		} else {
		/* smallendian,swap bytes */
		return xdr_swapbytes(x);
		}
		}

		static xdr_uint32_t xdr_ntohl(xdr_uint32_t x)
		{
		short s=0x0F00;
		if( ((char )&s)==(char)0x0F) {
		/* bigendian, do nothing */
		return x;
		} else {
		/* smallendian, swap bytes */
		return xdr_swapbytes(x);
		}
		}


		/*
		* Free a data structure using XDR
		* Not a filter, but a convenient utility nonetheless
		*/
		void
		xdr_free (xdrproc_t proc, char *objp)
		{
		XDR x;

		x.x_op = XDR_FREE;
		(*proc) (&x, objp);
		}

		/*
		* XDR nothing
		*/
		bool_t
		xdr_void (void)
		{
		return TRUE;
		}

		/*
		* XDR integers
		*/
		bool_t
		xdr_int (XDR xdrs, int ip)
		{
		xdr_int32_t l;

		switch (xdrs->x_op)
		{
		case XDR_ENCODE:
		l = (xdr_int32_t) (*ip);
		return xdr_putint32 (xdrs, &l);

		case XDR_DECODE:
		if (!xdr_getint32 (xdrs, &l))
		{
		return FALSE;
		}
		*ip = (int) l;

		case XDR_FREE:
		return TRUE;
		}
		return FALSE;
		}


		/*
		* XDR unsigned integers
		*/
		bool_t
		xdr_u_int (XDR xdrs, unsigned int up)
		{
		xdr_uint32_t l;

		switch (xdrs->x_op)
		{
		case XDR_ENCODE:
		l = (xdr_uint32_t) (*up);
		return xdr_putuint32 (xdrs, &l);

		case XDR_DECODE:
		if (!xdr_getuint32 (xdrs, &l))
		{
		return FALSE;
		}
		*up = (unsigned int) l;

		case XDR_FREE:
		return TRUE;
		}
		return FALSE;
		}




		/*
		* XDR short integers
		*/
		bool_t
		xdr_short (XDR xdrs, short sp)
		{
		xdr_int32_t l;

		switch (xdrs->x_op)
		{
		case XDR_ENCODE:
		l = (xdr_int32_t) *sp;
		return xdr_putint32 (xdrs, &l);

		case XDR_DECODE:
		if (!xdr_getint32 (xdrs, &l))
		{
		return FALSE;
		}
		*sp = (short) l;
		return TRUE;

		case XDR_FREE:
		return TRUE;
		}
		return FALSE;
		}


		/*
		* XDR unsigned short integers
		*/
		bool_t
		xdr_u_short (XDR xdrs, unsigned short usp)
		{
		xdr_uint32_t l;

		switch (xdrs->x_op)
		{
		case XDR_ENCODE:
		l = (xdr_uint32_t) *usp;
		return xdr_putuint32 (xdrs, &l);

		case XDR_DECODE:
		if (!xdr_getuint32 (xdrs, &l))
		{
		return FALSE;
		}
		*usp = (unsigned short) l;
		return TRUE;

		case XDR_FREE:
		return TRUE;
		}
		return FALSE;
		}


		/*
		* XDR a char
		*/
		bool_t
		xdr_char (XDR xdrs, char cp)
		{
		int i;

		i = (*cp);
		if (!xdr_int (xdrs, &i))
		{
		return FALSE;
		}
		*cp = i;
		return TRUE;
		}

		/*
		* XDR an unsigned char
		*/
		bool_t
		xdr_u_char (XDR xdrs, unsigned char cp)
		{
		unsigned int u;

		u = (*cp);
		if (!xdr_u_int (xdrs, &u))
		{
		return FALSE;
		}
		*cp = u;
		return TRUE;
		}

		/*
		* XDR booleans
		*/
		bool_t
		xdr_bool (XDR xdrs, int bp)
		{
		#define XDR_FALSE ((xdr_int32_t) 0)
		#define XDR_TRUE ((xdr_int32_t) 1)

		xdr_int32_t lb;

		switch (xdrs->x_op)
		{
		case XDR_ENCODE:
		lb = *bp ? XDR_TRUE : XDR_FALSE;
		return xdr_putint32 (xdrs, &lb);

		case XDR_DECODE:
		if (!xdr_getint32 (xdrs, &lb))
		{
		return FALSE;
		}
		*bp = (lb == XDR_FALSE) ? FALSE : TRUE;
		return TRUE;

		case XDR_FREE:
		return TRUE;
		}
		return FALSE;
		#undef XDR_FALSE
		#undef XDR_TRUE
		}



		/*
		* XDR opaque data
		* Allows the specification of a fixed size sequence of opaque bytes.
		* cp points to the opaque object and cnt gives the byte length.
		*/
		bool_t
		xdr_opaque (XDR xdrs, char cp, unsigned int cnt)
		{
		unsigned int rndup;
		static char crud[BYTES_PER_XDR_UNIT];

		/*
		* if no data we are done
		*/
		if (cnt == 0)
		return TRUE;

		/*
		* round byte count to full xdr units
		*/
		rndup = cnt % BYTES_PER_XDR_UNIT;
		if (rndup > 0)
		rndup = BYTES_PER_XDR_UNIT - rndup;

		switch (xdrs->x_op)
		{
		case XDR_DECODE:
		if (!xdr_getbytes (xdrs, cp, cnt))
		{
		return FALSE;
		}
		if (rndup == 0)
		return TRUE;
		return xdr_getbytes (xdrs, (char *)crud, rndup);

		case XDR_ENCODE:
		if (!xdr_putbytes (xdrs, cp, cnt))
		{
		return FALSE;
		}
		if (rndup == 0)
		return TRUE;
		return xdr_putbytes (xdrs, xdr_zero, rndup);

		case XDR_FREE:
		return TRUE;
		}
		return FALSE;
		}


		/*
		* XDR null terminated ASCII strings
		* xdr_string deals with "C strings" - arrays of bytes that are
		* terminated by a NULL character. The parameter cpp references a
		* pointer to storage; If the pointer is null, then the necessary
		* storage is allocated. The last parameter is the max allowed length
		* of the string as specified by a protocol.
		*/
		bool_t
		xdr_string (XDR xdrs, char *cpp, unsigned int maxsize)
		{
		char sp = cpp; /* sp is the actual string pointer */
		unsigned int size = 0;
		unsigned int nodesize = 0;

		/*
		* first deal with the length since xdr strings are counted-strings
		*/
		switch (xdrs->x_op)
		{
		case XDR_FREE:
		if (sp == NULL)
		{
		return TRUE; /* already free */
		}
		/* fall through... */
		case XDR_ENCODE:
		if (sp == NULL)
		return FALSE;
		size = strlen (sp);
		break;
		case XDR_DECODE:
		break;
		}

		if (!xdr_u_int (xdrs, &size))
		{
		return FALSE;
		}
		if (size > maxsize)
		{
		return FALSE;
		}
		nodesize = size + 1;

		/*
		* now deal with the actual bytes
		*/
		switch (xdrs->x_op)
		{
		case XDR_DECODE:
		if (nodesize == 0)
		{
		return TRUE;
		}
		if (sp == NULL)
		cpp = sp = (char ) malloc (nodesize);
		if (sp == NULL)
		{
		(void) fputs ("xdr_string: out of memory\n", stderr);
		return FALSE;
		}
		sp[size] = 0;
		/* fall into ... */

		case XDR_ENCODE:
		return xdr_opaque (xdrs, sp, size);

		case XDR_FREE:
		free (sp);
		*cpp = NULL;
		return TRUE;
		}
		return FALSE;
		}



		/* Floating-point stuff */

		bool_t
		xdr_float(XDR xdrs, float fp)
		{
		xdr_int32_t tmp;

		switch (xdrs->x_op) {

		case XDR_ENCODE:
		tmp = (xdr_int32_t )fp;
		return (xdr_putint32(xdrs, &tmp));

		break;

		case XDR_DECODE:
		if (xdr_getint32(xdrs, &tmp)) {
		(xdr_int32_t )fp = tmp;
		return (TRUE);
		}

		break;

		case XDR_FREE:
		return (TRUE);
		}
		return (FALSE);
		}


		bool_t
		xdr_double(XDR xdrs, double dp)
		{

		/* Windows and some other systems dont define double-precision
		* word order in the header files, so unfortunately we have
		* to calculate it!
		*/
		static int LSW=-1; /* Least significant fp word */
		int *ip;
		xdr_int32_t tmp[2];

		if(LSW<0) {
		double x=0.987654321; /* Just a number */

		/* Possible representations in IEEE double precision:
		* (S=small endian, B=big endian)
		*
		* Byte order, Word order, Hex
		* S S b8 56 0e 3c dd 9a ef 3f
		* B S 3c 0e 56 b8 3f ef 9a dd
		* S B dd 9a ef 3f b8 56 0e 3c
		* B B 3f ef 9a dd 3c 0e 56 b8
		*/

		unsigned char ix = ((char )&x);

		if(ix==0xdd \|\| ix==0x3f)
		LSW=1; /* Big endian word order */
		else if(ix==0xb8 \|\| ix==0x3c)
		LSW=0; /* Small endian word order */
		else { /* Catch strange errors */
		printf("Error when detecting floating-point word order.\n"
		"Do you have a non-IEEE system?\n"
		"If possible, use the XDR libraries provided with your system,\n"
		"instead of the Gromacs fallback XDR source.\n");
		exit(0);
		}
		}

		switch (xdrs->x_op) {

		case XDR_ENCODE:
		ip = (int *)dp;
		tmp[0] = ip[!LSW];
		tmp[1] = ip[LSW];
		return (xdr_putint32(xdrs, tmp) &&
		xdr_putint32(xdrs, tmp+1));

		break;

		case XDR_DECODE:
		ip = (int *)dp;
		if (xdr_getint32(xdrs, tmp+!LSW) &&
		xdr_getint32(xdrs, tmp+LSW)) {
		ip[0] = tmp[0];
		ip[1] = tmp[1];
		return (TRUE);
		}

		break;

		case XDR_FREE:
		return (TRUE);
		}
		return (FALSE);
		}


		/* Array routines */

		/*
		* xdr_vector():
		*
		* XDR a fixed length array. Unlike variable-length arrays,
		* the storage of fixed length arrays is static and unfreeable.
		* > basep: base of the array
		* > size: size of the array
		* > elemsize: size of each element
		* > xdr_elem: routine to XDR each element
		*/
		bool_t
		xdr_vector (XDR xdrs, char basep, unsigned int nelem,
		unsigned int elemsize, xdrproc_t xdr_elem)
		{
		#define LASTUNSIGNED ((unsigned int)0-1)
		unsigned int i;
		char *elptr;

		elptr = basep;
		for (i = 0; i < nelem; i++)
		{
		if (!(*xdr_elem) (xdrs, elptr, LASTUNSIGNED))
		{
		return FALSE;
		}
		elptr += elemsize;
		}
		return TRUE;
		#undef LASTUNSIGNED
		}



		static bool_t xdrstdio_getbytes (XDR , char , unsigned int);
		static bool_t xdrstdio_putbytes (XDR , char , unsigned int);
		static unsigned int xdrstdio_getpos (XDR *);
		static bool_t xdrstdio_setpos (XDR *, unsigned int);
		static xdr_int32_t xdrstdio_inline (XDR , int);
		static void xdrstdio_destroy (XDR *);
		static bool_t xdrstdio_getint32 (XDR , xdr_int32_t );
		static bool_t xdrstdio_putint32 (XDR , xdr_int32_t );
		static bool_t xdrstdio_getuint32 (XDR , xdr_uint32_t );
		static bool_t xdrstdio_putuint32 (XDR , xdr_uint32_t );

		/*
		* Ops vector for stdio type XDR
		*/
		static const struct xdr_ops xdrstdio_ops =
		{
		xdrstdio_getbytes, /* deserialize counted bytes */
		xdrstdio_putbytes, /* serialize counted bytes */
		xdrstdio_getpos, /* get offset in the stream */
		xdrstdio_setpos, /* set offset in the stream */
		xdrstdio_inline, /* prime stream for inline macros */
		xdrstdio_destroy, /* destroy stream */
		xdrstdio_getint32, /* deserialize a int */
		xdrstdio_putint32, /* serialize a int */
		xdrstdio_getuint32, /* deserialize a int */
		xdrstdio_putuint32 /* serialize a int */
		};

		/*
		* Initialize a stdio xdr stream.
		* Sets the xdr stream handle xdrs for use on the stream file.
		* Operation flag is set to op.
		*/
		void
		xdrstdio_create (XDR xdrs, FILE file, enum xdr_op op)
		{
		xdrs->x_op = op;
		/* We have to add the const since the `struct xdr_ops' in `struct XDR'
		is not `const'. */
		xdrs->x_ops = (struct xdr_ops *) &xdrstdio_ops;
		xdrs->x_private = (char *) file;
		xdrs->x_handy = 0;
		xdrs->x_base = 0;
		}

		/*
		* Destroy a stdio xdr stream.
		* Cleans up the xdr stream handle xdrs previously set up by xdrstdio_create.
		*/
		static void
		xdrstdio_destroy (XDR *xdrs)
		{
		(void) fflush ((FILE *) xdrs->x_private);
		/* xx should we close the file ?? */
		}


		static bool_t
		xdrstdio_getbytes (XDR xdrs, char addr, unsigned int len)
		{
		if ((len != 0) && (fread (addr, (int) len, 1,
		(FILE *) xdrs->x_private) != 1))
		return FALSE;
		return TRUE;
		}

		static bool_t
		xdrstdio_putbytes (XDR xdrs, char addr, unsigned int len)
		{
		if ((len != 0) && (fwrite (addr, (int) len, 1,
		(FILE *) xdrs->x_private) != 1))
		return FALSE;
		return TRUE;
		}

		static unsigned int
		xdrstdio_getpos (XDR *xdrs)
		{
		return (unsigned int) ftell ((FILE *) xdrs->x_private);
		}

		static bool_t
		xdrstdio_setpos (XDR *xdrs, unsigned int pos)
		{
		return fseek ((FILE *) xdrs->x_private, (xdr_int32_t) pos, 0) < 0 ? FALSE : TRUE;
		}

		static xdr_int32_t *
		xdrstdio_inline (XDR *xdrs, int len)
		{
		/*
		* Must do some work to implement this: must insure
		* enough data in the underlying stdio buffer,
		* that the buffer is aligned so that we can indirect through a
		* long *, and stuff this pointer in xdrs->x_buf. Doing
		* a fread or fwrite to a scratch buffer would defeat
		* most of the gains to be had here and require storage
		* management on this buffer, so we don't do this.
		*/
		return NULL;
		}

		static bool_t
		xdrstdio_getint32 (XDR xdrs, xdr_int32_t ip)
		{
		xdr_int32_t mycopy;

		if (fread ((char ) &mycopy, 4, 1, (FILE ) xdrs->x_private) != 1)
		return FALSE;
		*ip = xdr_ntohl (mycopy);
		return TRUE;
		}

		static bool_t
		xdrstdio_putint32 (XDR xdrs, xdr_int32_t ip)
		{
		xdr_int32_t mycopy = xdr_htonl (*ip);

		ip = &mycopy;
		if (fwrite ((char ) ip, 4, 1, (FILE ) xdrs->x_private) != 1)
		return FALSE;
		return TRUE;
		}

		static bool_t
		xdrstdio_getuint32 (XDR xdrs, xdr_uint32_t ip)
		{
		xdr_uint32_t mycopy;

		if (fread ((char ) &mycopy, 4, 1, (FILE ) xdrs->x_private) != 1)
		return FALSE;
		*ip = xdr_ntohl (mycopy);
		return TRUE;
		}

		static bool_t
		xdrstdio_putuint32 (XDR xdrs, xdr_uint32_t ip)
		{
		xdr_uint32_t mycopy = xdr_htonl (*ip);

		ip = &mycopy;
		if (fwrite ((char ) ip, 4, 1, (FILE ) xdrs->x_private) != 1)
		return FALSE;
		return TRUE;
		}

		#ifdef __cplusplus
		}
		#endif

		#endif

src/XTC/xdr_compat.h

0 → 100644

+222 −0

File added.

Preview size limit exceeded, changes collapsed.

Admin message