#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

#else
/* satisfy compilers that do not like to compile empty files. */
static void i_am_a_dummy_subroutine(void) {
  return;
}
#endif
