src/gromacs/fileio/gmx_internal_xdr.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
   5  * Copyright (c) 2001-2004, The GROMACS development team.
   6  * Copyright (c) 2013,2014,2015,2018,2019, by the GROMACS development team, led by
   7  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   8  * and including many others, as listed in the AUTHORS file in the
   9  * top-level source directory and at http://www.gromacs.org.
  10  *
  11  * GROMACS is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public License
  13  * as published by the Free Software Foundation; either version 2.1
  14  * of the License, or (at your option) any later version.
  15  *
  16  * GROMACS is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with GROMACS; if not, see
  23  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  25  *
  26  * If you want to redistribute modifications to GROMACS, please
  27  * consider that scientific software is very special. Version
  28  * control is crucial - bugs must be traceable. We will be happy to
  29  * consider code for inclusion in the official distribution, but
  30  * derived work must not be called official GROMACS. Details are found
  31  * in the README & COPYING files - if they are missing, get the
  32  * official version at http://www.gromacs.org.
  33  *
  34  * To help us fund GROMACS development, we humbly ask that you cite
  35  * the research papers on the package. Check out http://www.gromacs.org.
  36  */
  37 #include "gmxpre.h"
  38
  39 #include "config.h"
  40
  41 #if GMX_INTERNAL_XDR
  42
  43
  44 #    include "gmx_internal_xdr.h"
  45
  46 #    include <cstdlib>
  47 #    include <cstring>
  48
  49
  50 /* NB - THIS FILE IS ONLY USED ON MICROSOFT WINDOWS, since that
  51  * system doesn't provide any standard XDR system libraries. It will
  52  * most probably work on other platforms too, but make sure you
  53  * test that the xtc files produced are ok before using it.
  54  *
  55  * This header file contains Gromacs versions of the definitions for
  56  * Sun External Data Representation (XDR) headers and routines.
  57  *
  58  * On most UNIX systems this is already present as part of your
  59  * system libraries, but since we want to make Gromacs portable to
  60  * platforms like Microsoft Windows we have created a private version
  61  * of the necessary routines and distribute them with the Gromacs source.
  62  *
  63  * Although the rest of Gromacs is LGPL, you can copy and use the XDR
  64  * routines in any way you want as long as you obey Sun's license:
  65  *
  66  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  67  * unrestricted use provided that this legend is included on all tape
  68  * media and as a part of the software program in whole or part.  Users
  69  * may copy or modify Sun RPC without charge, but are not authorized
  70  * to license or distribute it to anyone else except as part of a product or
  71  * program developed by the user.
  72  *
  73  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  74  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  75  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  76  *
  77  * Sun RPC is provided with no support and without any obligation on the
  78  * part of Sun Microsystems, Inc. to assist in its use, correction,
  79  * modification or enhancement.
  80  *
  81  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  82  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  83  * OR ANY PART THEREOF.
  84  *
  85  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  86  * or profits or other special, indirect and consequential damages, even if
  87  * Sun has been advised of the possibility of such damages.
  88  *
  89  * Sun Microsystems, Inc.
  90  * 2550 Garcia Avenue
  91  * Mountain View, California  94043
  92  */
  93
  94
  95 /*
  96  * for unit alignment
  97  */
  98 static char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 };
  99
 100 static xdr_uint32_t xdr_swapbytes(xdr_uint32_t x)
 101 {
 102     xdr_uint32_t y;
 103     int          i;
 104     char*        px = reinterpret_cast<char*>(&x);
 105     char*        py = reinterpret_cast<char*>(&y);
 106
 107     for (i = 0; i < 4; i++)
 108     {
 109         py[i] = px[3 - i];
 110     }
 111
 112     return y;
 113 }
 114
 115 static xdr_uint32_t xdr_htonl(xdr_uint32_t x)
 116 {
 117     short s = 0x0F00;
 118     if (*(reinterpret_cast<char*>(&s)) == static_cast<char>(0x0F))
 119     {
 120         /* bigendian, do nothing */
 121         return x;
 122     }
 123     else
 124     {
 125         /* smallendian,swap bytes */
 126         return xdr_swapbytes(x);
 127     }
 128 }
 129
 130 static xdr_uint32_t xdr_ntohl(xdr_uint32_t x)
 131 {
 132     short s = 0x0F00;
 133     if (*(reinterpret_cast<char*>(&s)) == static_cast<char>(0x0F))
 134     {
 135         /* bigendian, do nothing */
 136         return x;
 137     }
 138     else
 139     {
 140         /* smallendian, swap bytes */
 141         return xdr_swapbytes(x);
 142     }
 143 }
 144
 145
 146 /*
 147  * Free a data structure using XDR
 148  * Not a filter, but a convenient utility nonetheless
 149  */
 150 void xdr_free(xdrproc_t proc, char* objp)
 151 {
 152     XDR x;
 153
 154     x.x_op = XDR_FREE;
 155     (*proc)(&x, objp);
 156 }
 157
 158 /*
 159  * XDR nothing
 160  */
 161 bool_t xdr_void()
 162 {
 163     return TRUE;
 164 }
 165
 166 /*
 167  * XDR integers
 168  */
 169 bool_t xdr_int(XDR* xdrs, int* ip)
 170 {
 171     xdr_int32_t l;
 172
 173     switch (xdrs->x_op)
 174     {
 175         case XDR_ENCODE: l = static_cast<xdr_int32_t>(*ip); return xdr_putint32(xdrs, &l);
 176
 177         case XDR_DECODE:
 178             if (!xdr_getint32(xdrs, &l))
 179             {
 180                 return FALSE;
 181             }
 182             *ip = static_cast<int>(l);
 183             return TRUE;
 184
 185         case XDR_FREE: return TRUE;
 186     }
 187     return FALSE;
 188 }
 189
 190
 191 /*
 192  * XDR unsigned integers
 193  */
 194 bool_t xdr_u_int(XDR* xdrs, unsigned int* up)
 195 {
 196     xdr_uint32_t l;
 197
 198     switch (xdrs->x_op)
 199     {
 200         case XDR_ENCODE: l = static_cast<xdr_uint32_t>(*up); return xdr_putuint32(xdrs, &l);
 201
 202         case XDR_DECODE:
 203             if (!xdr_getuint32(xdrs, &l))
 204             {
 205                 return FALSE;
 206             }
 207             *up = static_cast<unsigned int>(l);
 208             return TRUE;
 209
 210         case XDR_FREE: return TRUE;
 211     }
 212     return FALSE;
 213 }
 214
 215
 216 /*
 217  * XDR short integers
 218  */
 219 bool_t xdr_short(XDR* xdrs, short* sp)
 220 {
 221     xdr_int32_t l;
 222
 223     switch (xdrs->x_op)
 224     {
 225         case XDR_ENCODE: l = static_cast<xdr_int32_t>(*sp); return xdr_putint32(xdrs, &l);
 226
 227         case XDR_DECODE:
 228             if (!xdr_getint32(xdrs, &l))
 229             {
 230                 return FALSE;
 231             }
 232             *sp = static_cast<short>(l);
 233             return TRUE;
 234
 235         case XDR_FREE: return TRUE;
 236     }
 237     return FALSE;
 238 }
 239
 240
 241 /*
 242  * XDR unsigned short integers
 243  */
 244 bool_t xdr_u_short(XDR* xdrs, unsigned short* usp)
 245 {
 246     xdr_uint32_t l;
 247
 248     switch (xdrs->x_op)
 249     {
 250         case XDR_ENCODE: l = static_cast<xdr_uint32_t>(*usp); return xdr_putuint32(xdrs, &l);
 251
 252         case XDR_DECODE:
 253             if (!xdr_getuint32(xdrs, &l))
 254             {
 255                 return FALSE;
 256             }
 257             *usp = static_cast<unsigned short>(l);
 258             return TRUE;
 259
 260         case XDR_FREE: return TRUE;
 261     }
 262     return FALSE;
 263 }
 264
 265
 266 /*
 267  * XDR a char
 268  */
 269 bool_t xdr_char(XDR* xdrs, char* cp)
 270 {
 271     int i;
 272
 273     i = (*cp);
 274     if (!xdr_int(xdrs, &i))
 275     {
 276         return FALSE;
 277     }
 278     *cp = i;
 279     return TRUE;
 280 }
 281
 282 /*
 283  * XDR an unsigned char
 284  */
 285 bool_t xdr_u_char(XDR* xdrs, unsigned char* cp)
 286 {
 287     unsigned int u;
 288
 289     u = (*cp);
 290     if (!xdr_u_int(xdrs, &u))
 291     {
 292         return FALSE;
 293     }
 294     *cp = u;
 295     return TRUE;
 296 }
 297
 298 /*
 299  * XDR booleans
 300  */
 301 bool_t xdr_bool(XDR* xdrs, int* bp)
 302 {
 303 #    define XDR_FALSE ((xdr_int32_t)0)
 304 #    define XDR_TRUE ((xdr_int32_t)1)
 305
 306     xdr_int32_t lb;
 307
 308     switch (xdrs->x_op)
 309     {
 310         case XDR_ENCODE: lb = *bp ? XDR_TRUE : XDR_FALSE; return xdr_putint32(xdrs, &lb);
 311
 312         case XDR_DECODE:
 313             if (!xdr_getint32(xdrs, &lb))
 314             {
 315                 return FALSE;
 316             }
 317             *bp = (lb == XDR_FALSE) ? FALSE : TRUE;
 318             return TRUE;
 319
 320         case XDR_FREE: return TRUE;
 321     }
 322     return FALSE;
 323 #    undef XDR_FALSE
 324 #    undef XDR_TRUE
 325 }
 326
 327
 328 /*
 329  * XDR opaque data
 330  * Allows the specification of a fixed size sequence of opaque bytes.
 331  * cp points to the opaque object and cnt gives the byte length.
 332  */
 333 bool_t xdr_opaque(XDR* xdrs, char* cp, unsigned int cnt)
 334 {
 335     unsigned int rndup;
 336     char         crud[BYTES_PER_XDR_UNIT];
 337
 338     /*
 339      * if no data we are done
 340      */
 341     if (cnt == 0)
 342     {
 343         return TRUE;
 344     }
 345
 346     /*
 347      * round byte count to full xdr units
 348      */
 349     rndup = cnt % BYTES_PER_XDR_UNIT;
 350     if (rndup > 0)
 351     {
 352         rndup = BYTES_PER_XDR_UNIT - rndup;
 353     }
 354
 355     switch (xdrs->x_op)
 356     {
 357         case XDR_DECODE:
 358             if (!xdr_getbytes(xdrs, cp, cnt))
 359             {
 360                 return FALSE;
 361             }
 362             if (rndup == 0)
 363             {
 364                 return TRUE;
 365             }
 366             return xdr_getbytes(xdrs, crud, rndup);
 367
 368         case XDR_ENCODE:
 369             if (!xdr_putbytes(xdrs, cp, cnt))
 370             {
 371                 return FALSE;
 372             }
 373             if (rndup == 0)
 374             {
 375                 return TRUE;
 376             }
 377             return xdr_putbytes(xdrs, xdr_zero, rndup);
 378
 379         case XDR_FREE: return TRUE;
 380     }
 381     return FALSE;
 382 }
 383
 384
 385 /*
 386  * XDR null terminated ASCII strings
 387  * xdr_string deals with "C strings" - arrays of bytes that are
 388  * terminated by a NULL character.  The parameter cpp references a
 389  * pointer to storage; If the pointer is null, then the necessary
 390  * storage is allocated.  The last parameter is the max allowed length
 391  * of the string as specified by a protocol.
 392  */
 393 bool_t xdr_string(XDR* xdrs, char** cpp, unsigned int maxsize)
 394 {
 395     char*        sp       = *cpp; /* sp is the actual string pointer */
 396     unsigned int size     = 0;
 397     unsigned int nodesize = 0;
 398
 399     /*
 400      * first deal with the length since xdr strings are counted-strings
 401      */
 402     switch (xdrs->x_op)
 403     {
 404         case XDR_FREE:
 405             if (sp == nullptr)
 406             {
 407                 return TRUE; /* already free */
 408             }
 409             size = std::strlen(sp);
 410             break;
 411
 412         case XDR_ENCODE:
 413             if (sp == nullptr)
 414             {
 415                 return FALSE;
 416             }
 417             size = std::strlen(sp);
 418             break;
 419         case XDR_DECODE: break;
 420     }
 421
 422     if (!xdr_u_int(xdrs, &size))
 423     {
 424         return FALSE;
 425     }
 426     if (size > maxsize)
 427     {
 428         return FALSE;
 429     }
 430     nodesize = size + 1;
 431
 432     /*
 433      * now deal with the actual bytes
 434      */
 435     switch (xdrs->x_op)
 436     {
 437         case XDR_DECODE:
 438             if (nodesize == 0)
 439             {
 440                 return TRUE;
 441             }
 442             if (sp == nullptr)
 443             {
 444                 *cpp = sp = static_cast<char*>(std::malloc(nodesize));
 445             }
 446             if (sp == nullptr)
 447             {
 448                 (void)fputs("xdr_string: out of memory\n", stderr);
 449                 return FALSE;
 450             }
 451             sp[size] = 0;
 452             return xdr_opaque(xdrs, sp, size);
 453
 454         case XDR_ENCODE: return xdr_opaque(xdrs, sp, size);
 455
 456         case XDR_FREE:
 457             free(sp);
 458             *cpp = nullptr;
 459             return TRUE;
 460     }
 461     return FALSE;
 462 }
 463
 464
 465 /* Floating-point stuff */
 466
 467 bool_t xdr_float(XDR* xdrs, float* fp)
 468 {
 469     xdr_int32_t tmp;
 470
 471     switch (xdrs->x_op)
 472     {
 473
 474         case XDR_ENCODE:
 475             tmp = *(reinterpret_cast<xdr_int32_t*>(fp));
 476             return (xdr_putint32(xdrs, &tmp));
 477
 478         case XDR_DECODE:
 479             if (xdr_getint32(xdrs, &tmp))
 480             {
 481                 *(reinterpret_cast<xdr_int32_t*>(fp)) = tmp;
 482                 return (TRUE);
 483             }
 484
 485             break;
 486
 487         case XDR_FREE: return (TRUE);
 488     }
 489     return (FALSE);
 490 }
 491
 492
 493 bool_t xdr_double(XDR* xdrs, double* dp)
 494 {
 495
 496     /* Windows and some other systems dont define double-precision
 497      * word order in the header files, so unfortunately we have
 498      * to calculate it!
 499      *
 500      * For thread safety, we calculate it every time: locking this would
 501      * be more expensive.
 502      */
 503     /*static int LSW=-1;*/ /* Least significant fp word */
 504     int LSW = -1;          /* Least significant fp word */
 505
 506
 507     int*        ip;
 508     xdr_int32_t tmp[2];
 509
 510     if (LSW < 0)
 511     {
 512         double x = 0.987654321; /* Just a number */
 513
 514         /* Possible representations in IEEE double precision:
 515          * (S=small endian, B=big endian)
 516          *
 517          * Byte order, Word order, Hex
 518          *     S           S       b8 56 0e 3c dd 9a ef 3f
 519          *     B           S       3c 0e 56 b8 3f ef 9a dd
 520          *     S           B       dd 9a ef 3f b8 56 0e 3c
 521          *     B           B       3f ef 9a dd 3c 0e 56 b8
 522          */
 523
 524         unsigned char ix = *(reinterpret_cast<char*>(&x));
 525
 526         if (ix == 0xdd || ix == 0x3f)
 527         {
 528             LSW = 1; /* Big endian word order */
 529         }
 530         else if (ix == 0xb8 || ix == 0x3c)
 531         {
 532             LSW = 0; /* Small endian word order */
 533         }
 534         else /* Catch strange errors */
 535         {
 536             printf("Error when detecting floating-point word order.\n"
 537                    "Do you have a non-IEEE system?\n"
 538                    "If possible, use the XDR libraries provided with your system,\n"
 539                    "instead of the GROMACS fallback XDR source.\n");
 540             exit(0);
 541         }
 542     }
 543
 544     switch (xdrs->x_op)
 545     {
 546
 547         case XDR_ENCODE:
 548             ip     = reinterpret_cast<int*>(dp);
 549             tmp[0] = ip[bool(LSW == 0)];
 550             tmp[1] = ip[LSW];
 551             return static_cast<bool_t>(bool(xdr_putint32(xdrs, tmp)) && bool(xdr_putint32(xdrs, tmp + 1)));
 552
 553         case XDR_DECODE:
 554             ip = reinterpret_cast<int*>(dp);
 555             if (xdr_getint32(xdrs, tmp + !LSW) && xdr_getint32(xdrs, tmp + LSW))
 556             {
 557                 ip[0] = tmp[0];
 558                 ip[1] = tmp[1];
 559                 return (TRUE);
 560             }
 561
 562             break;
 563
 564         case XDR_FREE: return (TRUE);
 565     }
 566     return (FALSE);
 567 }
 568
 569
 570 /* Array routines */
 571
 572 /*
 573  * xdr_vector():
 574  *
 575  * XDR a fixed length array. Unlike variable-length arrays,
 576  * the storage of fixed length arrays is static and unfreeable.
 577  * > basep: base of the array
 578  * > size: size of the array
 579  * > elemsize: size of each element
 580  * > xdr_elem: routine to XDR each element
 581  */
 582 bool_t xdr_vector(XDR* xdrs, char* basep, unsigned int nelem, unsigned int elemsize, xdrproc_t xdr_elem)
 583 {
 584 #    define LASTUNSIGNED ((unsigned int)0 - 1)
 585     unsigned int i;
 586     char*        elptr;
 587
 588     elptr = basep;
 589     for (i = 0; i < nelem; i++)
 590     {
 591         if (!(*xdr_elem)(xdrs, elptr, LASTUNSIGNED))
 592         {
 593             return FALSE;
 594         }
 595         elptr += elemsize;
 596     }
 597     return TRUE;
 598 #    undef LASTUNSIGNED
 599 }
 600
 601
 602 static bool_t       xdrstdio_getbytes(XDR* /*xdrs*/, char* /*addr*/, unsigned int /*len*/);
 603 static bool_t       xdrstdio_putbytes(XDR* /*xdrs*/, char* /*addr*/, unsigned int /*len*/);
 604 static unsigned int xdrstdio_getpos(XDR* /*xdrs*/);
 605 static bool_t       xdrstdio_setpos(XDR* /*xdrs*/, unsigned int /*pos*/);
 606 static xdr_int32_t* xdrstdio_inline(XDR* /*xdrs*/, int /*len*/);
 607 static void         xdrstdio_destroy(XDR* /*xdrs*/);
 608 static bool_t       xdrstdio_getint32(XDR* /*xdrs*/, xdr_int32_t* /*ip*/);
 609 static bool_t       xdrstdio_putint32(XDR* /*xdrs*/, xdr_int32_t* /*ip*/);
 610 static bool_t       xdrstdio_getuint32(XDR* /*xdrs*/, xdr_uint32_t* /*ip*/);
 611 static bool_t       xdrstdio_putuint32(XDR* /*xdrs*/, xdr_uint32_t* /*ip*/);
 612
 613 /*
 614  * Destroy a stdio xdr stream.
 615  * Cleans up the xdr stream handle xdrs previously set up by xdrstdio_create.
 616  */
 617 static void xdrstdio_destroy(XDR* xdrs)
 618 {
 619     fflush(reinterpret_cast<FILE*>(xdrs->x_private));
 620     /* xx should we close the file ?? */
 621 }
 622
 623
 624 static bool_t xdrstdio_getbytes(XDR* xdrs, char* addr, unsigned int len)
 625 {
 626     if ((len != 0)
 627         && (fread(addr, static_cast<int>(len), 1, reinterpret_cast<FILE*>(xdrs->x_private)) != 1))
 628     {
 629         return FALSE;
 630     }
 631     return TRUE;
 632 }
 633
 634 static bool_t xdrstdio_putbytes(XDR* xdrs, char* addr, unsigned int len)
 635 {
 636     if ((len != 0)
 637         && (fwrite(addr, static_cast<int>(len), 1, reinterpret_cast<FILE*>(xdrs->x_private)) != 1))
 638     {
 639         return FALSE;
 640     }
 641     return TRUE;
 642 }
 643
 644 static unsigned int xdrstdio_getpos(XDR* xdrs)
 645 {
 646     return static_cast<int>(ftell(reinterpret_cast<FILE*>(xdrs->x_private)));
 647 }
 648
 649 static bool_t xdrstdio_setpos(XDR* xdrs, unsigned int pos)
 650 {
 651     return fseek(reinterpret_cast<FILE*>(xdrs->x_private), static_cast<xdr_int32_t>(pos), 0) < 0 ? FALSE
 652                                                                                                  : TRUE;
 653 }
 654
 655 static xdr_int32_t* xdrstdio_inline(XDR* xdrs, int len)
 656 {
 657     (void)xdrs;
 658     (void)len;
 659     /*
 660      * Must do some work to implement this: must insure
 661      * enough data in the underlying stdio buffer,
 662      * that the buffer is aligned so that we can indirect through a
 663      * long *, and stuff this pointer in xdrs->x_buf.  Doing
 664      * a fread or fwrite to a scratch buffer would defeat
 665      * most of the gains to be had here and require storage
 666      * management on this buffer, so we don't do this.
 667      */
 668     return nullptr;
 669 }
 670
 671 static bool_t xdrstdio_getint32(XDR* xdrs, xdr_int32_t* ip)
 672 {
 673     xdr_int32_t mycopy;
 674
 675     if (fread(&mycopy, 4, 1, reinterpret_cast<FILE*>(xdrs->x_private)) != 1)
 676     {
 677         return FALSE;
 678     }
 679     *ip = xdr_ntohl(mycopy);
 680     return TRUE;
 681 }
 682
 683 static bool_t xdrstdio_putint32(XDR* xdrs, xdr_int32_t* ip)
 684 {
 685     xdr_int32_t mycopy = xdr_htonl(*ip);
 686
 687     ip = &mycopy;
 688     if (fwrite(ip, 4, 1, reinterpret_cast<FILE*>(xdrs->x_private)) != 1)
 689     {
 690         return FALSE;
 691     }
 692     return TRUE;
 693 }
 694
 695 static bool_t xdrstdio_getuint32(XDR* xdrs, xdr_uint32_t* ip)
 696 {
 697     xdr_uint32_t mycopy;
 698
 699     if (fread(&mycopy, 4, 1, reinterpret_cast<FILE*>(xdrs->x_private)) != 1)
 700     {
 701         return FALSE;
 702     }
 703     *ip = xdr_ntohl(mycopy);
 704     return TRUE;
 705 }
 706
 707 static bool_t xdrstdio_putuint32(XDR* xdrs, xdr_uint32_t* ip)
 708 {
 709     xdr_uint32_t mycopy = xdr_htonl(*ip);
 710
 711     ip = &mycopy;
 712     if (fwrite(ip, 4, 1, reinterpret_cast<FILE*>(xdrs->x_private)) != 1)
 713     {
 714         return FALSE;
 715     }
 716     return TRUE;
 717 }
 718
 719 /*
 720  * Ops vector for stdio type XDR
 721  */
 722 static struct XDR::xdr_ops xdrstdio_ops = {
 723     xdrstdio_getbytes,  /* deserialize counted bytes */
 724     xdrstdio_putbytes,  /* serialize counted bytes */
 725     xdrstdio_getpos,    /* get offset in the stream */
 726     xdrstdio_setpos,    /* set offset in the stream */
 727     xdrstdio_inline,    /* prime stream for inline macros */
 728     xdrstdio_destroy,   /* destroy stream */
 729     xdrstdio_getint32,  /* deserialize a int */
 730     xdrstdio_putint32,  /* serialize a int */
 731     xdrstdio_getuint32, /* deserialize a int */
 732     xdrstdio_putuint32  /* serialize a int */
 733 };
 734
 735 /*
 736  * Initialize a stdio xdr stream.
 737  * Sets the xdr stream handle xdrs for use on the stream file.
 738  * Operation flag is set to op.
 739  */
 740 void xdrstdio_create(XDR* xdrs, FILE* file, enum xdr_op op)
 741 {
 742     xdrs->x_op      = op;
 743     xdrs->x_ops     = &xdrstdio_ops;
 744     xdrs->x_private = reinterpret_cast<char*>(file);
 745     xdrs->x_handy   = 0;
 746     xdrs->x_base    = nullptr;
 747 }
 748 #endif /* GMX_INTERNAL_XDR */