src/gromacs/gmxlib/gmxfio_rw.c

   1 /* -*- mode: c; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; c-file-style: "stroustrup"; -*-
   2  *
   3  *
   4  *                This source code is part of
   5  *
   6  *                 G   R   O   M   A   C   S
   7  *
   8  *          GROningen MAchine for Chemical Simulations
   9  *
  10  *                        VERSION 3.2.0
  11  * Written by David van der Spoel, Erik Lindahl, Berk Hess, and others.
  12  * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
  13  * Copyright (c) 2001-2004, The GROMACS development team,
  14  * check out http://www.gromacs.org for more information.
  15
  16  * This program is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU General Public License
  18  * as published by the Free Software Foundation; either version 2
  19  * of the License, or (at your option) any later version.
  20  *
  21  * If you want to redistribute modifications, please consider that
  22  * scientific software is very special. Version control is crucial -
  23  * bugs must be traceable. We will be happy to consider code for
  24  * inclusion in the official distribution, but derived work must not
  25  * be called official GROMACS. Details are found in the README & COPYING
  26  * files - if they are missing, get the official version at www.gromacs.org.
  27  *
  28  * To help us fund GROMACS development, we humbly ask that you cite
  29  * the papers on the package - you can find them in the top README file.
  30  *
  31  * For more info, check our website at http://www.gromacs.org
  32  *
  33  * And Hey:
  34  * GROningen Mixture of Alchemy and Childrens' Stories
  35  */
  36 #ifdef HAVE_CONFIG_H
  37 #include <config.h>
  38 #endif
  39
  40 #include <ctype.h>
  41 #include <stdio.h>
  42 #include <errno.h>
  43 #ifdef HAVE_IO_H
  44 #include <io.h>
  45 #endif
  46
  47 #include "gmx_fatal.h"
  48 #include "macros.h"
  49 #include "smalloc.h"
  50 #include "futil.h"
  51 #include "filenm.h"
  52 #include "string2.h"
  53 #include "gmxfio.h"
  54 #include "md5.h"
  55
  56 #ifdef GMX_THREAD_MPI
  57 #include "thread_mpi.h"
  58 #endif
  59
  60 #include "gmxfio_int.h"
  61
  62
  63 /*******************************************************************
  64  *
  65  * READ/WRITE FUNCTIONS
  66  *
  67  *******************************************************************/
  68
  69 gmx_bool gmx_fio_reade_real(t_fileio *fio, real *item,
  70                             const char *desc, const char *srcfile, int line)
  71 {
  72     gmx_bool ret;
  73     gmx_fio_lock(fio);
  74     ret = fio->iotp->nread(fio, item, 1, eioREAL, desc, srcfile, line);
  75     gmx_fio_unlock(fio);
  76     return ret;
  77 }
  78
  79 gmx_bool gmx_fio_reade_float(t_fileio *fio, float *item,
  80                              const char *desc, const char *srcfile, int line)
  81 {
  82     gmx_bool ret;
  83     gmx_fio_lock(fio);
  84     ret = fio->iotp->nread(fio, item, 1, eioFLOAT, desc, srcfile, line);
  85     gmx_fio_unlock(fio);
  86     return ret;
  87 }
  88
  89
  90 gmx_bool gmx_fio_reade_double(t_fileio *fio, double *item,
  91                               const char *desc, const char *srcfile, int line)
  92 {
  93     gmx_bool ret;
  94     gmx_fio_lock(fio);
  95     ret = fio->iotp->nread(fio, item, 1, eioDOUBLE, desc, srcfile, line);
  96     gmx_fio_unlock(fio);
  97     return ret;
  98 }
  99
 100 gmx_bool gmx_fio_reade_int(t_fileio *fio, int *item,
 101                            const char *desc, const char *srcfile, int line)
 102 {
 103     gmx_bool ret;
 104     gmx_fio_lock(fio);
 105     ret = fio->iotp->nread(fio, item, 1, eioINT, desc, srcfile, line);
 106     gmx_fio_unlock(fio);
 107     return ret;
 108 }
 109
 110 gmx_bool gmx_fio_reade_gmx_large_int(t_fileio *fio, gmx_large_int_t *item,
 111                                      const char *desc, const char *srcfile, int line)
 112 {
 113     gmx_bool ret;
 114     gmx_fio_lock(fio);
 115     ret = fio->iotp->nread(fio, item, 1, eioGMX_LARGE_INT, desc, srcfile, line);
 116     gmx_fio_unlock(fio);
 117     return ret;
 118 }
 119
 120 gmx_bool gmx_fio_reade_uchar(t_fileio *fio, unsigned char *item,
 121                              const char *desc, const char *srcfile, int line)
 122 {
 123     gmx_bool ret;
 124     gmx_fio_lock(fio);
 125     ret = fio->iotp->nread(fio, item, 1, eioUCHAR, desc, srcfile, line);
 126     gmx_fio_unlock(fio);
 127     return ret;
 128 }
 129
 130
 131 gmx_bool gmx_fio_reade_ushort(t_fileio *fio, unsigned short *item,
 132                               const char *desc, const char *srcfile, int line)
 133 {
 134     gmx_bool ret;
 135     gmx_fio_lock(fio);
 136     ret = fio->iotp->nread(fio, item, 1, eioUSHORT, desc, srcfile, line);
 137     gmx_fio_unlock(fio);
 138     return ret;
 139 }
 140
 141 gmx_bool gmx_fio_reade_rvec(t_fileio *fio, rvec *item,
 142                             const char *desc, const char *srcfile, int line)
 143 {
 144     gmx_bool ret;
 145     gmx_fio_lock(fio);
 146     ret = fio->iotp->nread(fio, item, 1, eioRVEC, desc, srcfile, line);
 147     gmx_fio_unlock(fio);
 148     return ret;
 149 }
 150
 151 gmx_bool gmx_fio_reade_ivec(t_fileio *fio, ivec *item,
 152                             const char *desc, const char *srcfile, int line)
 153 {
 154     gmx_bool ret;
 155     gmx_fio_lock(fio);
 156     ret = fio->iotp->nread(fio, item, 1, eioIVEC, desc, srcfile, line);
 157     gmx_fio_unlock(fio);
 158     return ret;
 159 }
 160
 161 gmx_bool gmx_fio_reade_string(t_fileio *fio, char *item,
 162                               const char *desc, const char *srcfile, int line)
 163 {
 164     gmx_bool ret;
 165     gmx_fio_lock(fio);
 166     ret = fio->iotp->nread(fio, item, 1, eioSTRING, desc, srcfile, line);
 167     gmx_fio_unlock(fio);
 168     return ret;
 169 }
 170
 171
 172 /* Write */
 173
 174 gmx_bool gmx_fio_writee_real(t_fileio *fio, real item,
 175                              const char *desc, const char *srcfile, int line)
 176 {
 177     gmx_bool ret;
 178     gmx_fio_lock(fio);
 179     ret = fio->iotp->nwrite(fio, &item, 1, eioREAL, desc, srcfile, line);
 180     gmx_fio_unlock(fio);
 181     return ret;
 182 }
 183
 184 gmx_bool gmx_fio_writee_float(t_fileio *fio, float item,
 185                               const char *desc, const char *srcfile, int line)
 186 {
 187     gmx_bool ret;
 188     gmx_fio_lock(fio);
 189     ret = fio->iotp->nwrite(fio, &item, 1, eioFLOAT, desc, srcfile, line);
 190     gmx_fio_unlock(fio);
 191     return ret;
 192 }
 193
 194 gmx_bool gmx_fio_writee_double(t_fileio *fio, double item,
 195                                const char *desc, const char *srcfile, int line)
 196 {
 197     gmx_bool ret;
 198     gmx_fio_lock(fio);
 199     ret = fio->iotp->nwrite(fio, &item, 1, eioDOUBLE, desc, srcfile, line);
 200     gmx_fio_unlock(fio);
 201     return ret;
 202 }
 203
 204
 205 gmx_bool gmx_fio_writee_int(t_fileio *fio, int item,
 206                             const char *desc, const char *srcfile, int line)
 207 {
 208     gmx_bool ret;
 209     gmx_fio_lock(fio);
 210     ret = fio->iotp->nwrite(fio, &item, 1, eioINT, desc, srcfile, line);
 211     gmx_fio_unlock(fio);
 212     return ret;
 213 }
 214
 215 gmx_bool gmx_fio_writee_gmx_large_int(t_fileio *fio, gmx_large_int_t item,
 216                                       const char *desc, const char *srcfile, int line)
 217 {
 218     gmx_bool ret;
 219     gmx_fio_lock(fio);
 220     ret = fio->iotp->nwrite(fio, &item, 1, eioGMX_LARGE_INT, desc, srcfile, line);
 221     gmx_fio_unlock(fio);
 222     return ret;
 223 }
 224
 225 gmx_bool gmx_fio_writee_uchar(t_fileio *fio, unsigned char item,
 226                               const char *desc, const char *srcfile, int line)
 227 {
 228     gmx_bool ret;
 229     gmx_fio_lock(fio);
 230     ret = fio->iotp->nwrite(fio, &item, 1, eioUCHAR, desc, srcfile, line);
 231     gmx_fio_unlock(fio);
 232     return ret;
 233 }
 234
 235 gmx_bool gmx_fio_writee_ushort(t_fileio *fio, unsigned short item,
 236                                const char *desc, const char *srcfile, int line)
 237 {
 238     gmx_bool ret;
 239     gmx_fio_lock(fio);
 240     ret = fio->iotp->nwrite(fio, &item, 1, eioUSHORT, desc, srcfile, line);
 241     gmx_fio_unlock(fio);
 242     return ret;
 243 }
 244
 245 gmx_bool gmx_fio_writee_rvec(t_fileio *fio, rvec *item,
 246                              const char *desc, const char *srcfile, int line)
 247 {
 248     gmx_bool ret;
 249     gmx_fio_lock(fio);
 250     ret = fio->iotp->nwrite(fio, item, 1, eioRVEC, desc, srcfile, line);
 251     gmx_fio_unlock(fio);
 252     return ret;
 253 }
 254
 255 gmx_bool gmx_fio_writee_ivec(t_fileio *fio, ivec *item,
 256                              const char *desc, const char *srcfile, int line)
 257 {
 258     gmx_bool ret;
 259     gmx_fio_lock(fio);
 260     ret = fio->iotp->nwrite(fio, item, 1, eioIVEC, desc, srcfile, line);
 261     gmx_fio_unlock(fio);
 262     return ret;
 263 }
 264
 265 gmx_bool gmx_fio_writee_string(t_fileio *fio, const char *item,
 266                                const char *desc, const char *srcfile, int line)
 267 {
 268     gmx_bool ret;
 269     gmx_fio_lock(fio);
 270     ret = fio->iotp->nwrite(fio, item, 1, eioSTRING, desc, srcfile, line);
 271     gmx_fio_unlock(fio);
 272     return ret;
 273 }
 274
 275
 276
 277 /* Read/write functions */
 278
 279 gmx_bool gmx_fio_doe_real(t_fileio *fio, real *item,
 280                           const char *desc, const char *srcfile, int line)
 281 {
 282     gmx_bool ret;
 283     gmx_fio_lock(fio);
 284     if (fio->bRead)
 285     {
 286         ret = fio->iotp->nread(fio, item, 1, eioREAL, desc, srcfile, line);
 287     }
 288     else
 289     {
 290         ret = fio->iotp->nwrite(fio, item, 1, eioREAL, desc, srcfile, line);
 291     }
 292     gmx_fio_unlock(fio);
 293     return ret;
 294
 295 }
 296
 297 gmx_bool gmx_fio_doe_float(t_fileio *fio, float *item,
 298                            const char *desc, const char *srcfile, int line)
 299 {
 300     gmx_bool ret;
 301     gmx_fio_lock(fio);
 302     if (fio->bRead)
 303     {
 304         ret = fio->iotp->nread(fio, item, 1, eioFLOAT, desc, srcfile, line);
 305     }
 306     else
 307     {
 308         ret = fio->iotp->nwrite(fio, item, 1, eioFLOAT, desc, srcfile, line);
 309     }
 310     gmx_fio_unlock(fio);
 311     return ret;
 312 }
 313
 314 gmx_bool gmx_fio_doe_double(t_fileio *fio, double *item,
 315                             const char *desc, const char *srcfile, int line)
 316 {
 317     gmx_bool ret;
 318     gmx_fio_lock(fio);
 319     if (fio->bRead)
 320     {
 321         ret = fio->iotp->nread(fio, item, 1, eioDOUBLE, desc, srcfile, line);
 322     }
 323     else
 324     {
 325         ret = fio->iotp->nwrite(fio, item, 1, eioDOUBLE, desc, srcfile, line);
 326     }
 327     gmx_fio_unlock(fio);
 328     return ret;
 329 }
 330
 331
 332 gmx_bool gmx_fio_doe_gmx_bool(t_fileio *fio, gmx_bool *item,
 333                               const char *desc, const char *srcfile, int line)
 334 {
 335     gmx_bool ret;
 336     int      itmp;
 337
 338     gmx_fio_lock(fio);
 339     if (fio->bRead)
 340     {
 341         ret   = fio->iotp->nread(fio, &itmp, 1, eioINT, desc, srcfile, line);
 342         *item = itmp;
 343     }
 344     else
 345     {
 346         itmp = *item;
 347         ret  = fio->iotp->nwrite(fio, &itmp, 1, eioINT, desc, srcfile, line);
 348     }
 349     gmx_fio_unlock(fio);
 350     return ret;
 351 }
 352
 353 gmx_bool gmx_fio_doe_int(t_fileio *fio, int *item,
 354                          const char *desc, const char *srcfile, int line)
 355 {
 356     gmx_bool ret;
 357     gmx_fio_lock(fio);
 358     if (fio->bRead)
 359     {
 360         ret = fio->iotp->nread(fio, item, 1, eioINT, desc, srcfile, line);
 361     }
 362     else
 363     {
 364         ret = fio->iotp->nwrite(fio, item, 1, eioINT, desc, srcfile, line);
 365     }
 366     gmx_fio_unlock(fio);
 367     return ret;
 368 }
 369
 370 gmx_bool gmx_fio_doe_gmx_large_int(t_fileio *fio, gmx_large_int_t *item,
 371                                    const char *desc, const char *srcfile, int line)
 372 {
 373     gmx_bool ret;
 374     gmx_fio_lock(fio);
 375     if (fio->bRead)
 376     {
 377         ret = fio->iotp->nread(fio, item, 1, eioGMX_LARGE_INT, desc, srcfile, line);
 378     }
 379     else
 380     {
 381         ret = fio->iotp->nwrite(fio, item, 1, eioGMX_LARGE_INT, desc, srcfile, line);
 382     }
 383     gmx_fio_unlock(fio);
 384     return ret;
 385 }
 386
 387 gmx_bool gmx_fio_doe_uchar(t_fileio *fio, unsigned char *item,
 388                            const char *desc, const char *srcfile, int line)
 389 {
 390     gmx_bool ret;
 391     gmx_fio_lock(fio);
 392     if (fio->bRead)
 393     {
 394         ret = fio->iotp->nread(fio, item, 1, eioUCHAR, desc, srcfile, line);
 395     }
 396     else
 397     {
 398         ret = fio->iotp->nwrite(fio, item, 1, eioUCHAR, desc, srcfile, line);
 399     }
 400     gmx_fio_unlock(fio);
 401     return ret;
 402 }
 403
 404 gmx_bool gmx_fio_doe_ushort(t_fileio *fio, unsigned short *item,
 405                             const char *desc, const char *srcfile, int line)
 406 {
 407     gmx_bool ret;
 408     gmx_fio_lock(fio);
 409     if (fio->bRead)
 410     {
 411         ret = fio->iotp->nread(fio, item, 1, eioUSHORT, desc, srcfile, line);
 412     }
 413     else
 414     {
 415         ret = fio->iotp->nwrite(fio, item, 1, eioUSHORT, desc, srcfile, line);
 416     }
 417     gmx_fio_unlock(fio);
 418     return ret;
 419 }
 420
 421 gmx_bool gmx_fio_doe_rvec(t_fileio *fio, rvec *item,
 422                           const char *desc, const char *srcfile, int line)
 423 {
 424     gmx_bool ret;
 425     gmx_fio_lock(fio);
 426     if (fio->bRead)
 427     {
 428         ret = fio->iotp->nread(fio, item, 1, eioRVEC, desc, srcfile, line);
 429     }
 430     else
 431     {
 432         ret = fio->iotp->nwrite(fio, item, 1, eioRVEC, desc, srcfile, line);
 433     }
 434     gmx_fio_unlock(fio);
 435     return ret;
 436 }
 437
 438 gmx_bool gmx_fio_doe_ivec(t_fileio *fio, ivec *item,
 439                           const char *desc, const char *srcfile, int line)
 440 {
 441     gmx_bool ret;
 442     gmx_fio_lock(fio);
 443     if (fio->bRead)
 444     {
 445         ret = fio->iotp->nread(fio, item, 1, eioIVEC, desc, srcfile, line);
 446     }
 447     else
 448     {
 449         ret = fio->iotp->nwrite(fio, item, 1, eioIVEC, desc, srcfile, line);
 450     }
 451     gmx_fio_unlock(fio);
 452     return ret;
 453 }
 454
 455 gmx_bool gmx_fio_doe_string(t_fileio *fio, char *item,
 456                             const char *desc, const char *srcfile, int line)
 457 {
 458     gmx_bool ret;
 459     gmx_fio_lock(fio);
 460     if (fio->bRead)
 461     {
 462         ret = fio->iotp->nread(fio, item, 1, eioSTRING, desc, srcfile, line);
 463     }
 464     else
 465     {
 466         ret = fio->iotp->nwrite(fio, item, 1, eioSTRING, desc, srcfile, line);
 467     }
 468     gmx_fio_unlock(fio);
 469     return ret;
 470 }
 471
 472
 473
 474
 475
 476
 477
 478 /* Array reading & writing */
 479
 480 gmx_bool gmx_fio_nreade_real(t_fileio *fio, real *item, int n,
 481                              const char *desc, const char *srcfile, int line)
 482 {
 483     gmx_bool ret = TRUE;
 484     int      i;
 485     gmx_fio_lock(fio);
 486     for (i = 0; i < n; i++)
 487     {
 488         ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioREAL, desc, srcfile, line);
 489     }
 490     gmx_fio_unlock(fio);
 491     return ret;
 492 }
 493
 494 gmx_bool gmx_fio_nreade_float(t_fileio *fio, float *item, int n,
 495                               const char *desc, const char *srcfile, int line)
 496 {
 497     gmx_bool ret = TRUE;
 498     int      i;
 499     gmx_fio_lock(fio);
 500     for (i = 0; i < n; i++)
 501     {
 502         ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioFLOAT, desc,
 503                                       srcfile, line);
 504     }
 505     gmx_fio_unlock(fio);
 506     return ret;
 507 }
 508
 509
 510 gmx_bool gmx_fio_nreade_double(t_fileio *fio, double *item, int n,
 511                                const char *desc, const char *srcfile, int line)
 512 {
 513     gmx_bool ret = TRUE;
 514     int      i;
 515     gmx_fio_lock(fio);
 516     for (i = 0; i < n; i++)
 517     {
 518         ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioDOUBLE, desc,
 519                                       srcfile, line);
 520     }
 521     gmx_fio_unlock(fio);
 522     return ret;
 523 }
 524
 525 gmx_bool gmx_fio_nreade_int(t_fileio *fio, int *item, int n,
 526                             const char *desc, const char *srcfile, int line)
 527 {
 528     gmx_bool ret = TRUE;
 529     int      i;
 530     gmx_fio_lock(fio);
 531     for (i = 0; i < n; i++)
 532     {
 533         ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioINT, desc, srcfile, line);
 534     }
 535     gmx_fio_unlock(fio);
 536     return ret;
 537 }
 538
 539 gmx_bool gmx_fio_nreade_gmx_large_int(t_fileio *fio, gmx_large_int_t *item, int n,
 540                                       const char *desc, const char *srcfile, int line)
 541 {
 542     gmx_bool ret = TRUE;
 543     int      i;
 544     gmx_fio_lock(fio);
 545     for (i = 0; i < n; i++)
 546     {
 547         ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioGMX_LARGE_INT, desc,
 548                                       srcfile, line);
 549     }
 550     gmx_fio_unlock(fio);
 551     return ret;
 552 }
 553
 554
 555 gmx_bool gmx_fio_nreade_uchar(t_fileio *fio, unsigned char *item, int n,
 556                               const char *desc, const char *srcfile, int line)
 557 {
 558     gmx_bool ret;
 559     gmx_fio_lock(fio);
 560     ret = fio->iotp->nread(fio, item, n, eioNUCHAR, desc, srcfile, line);
 561     gmx_fio_unlock(fio);
 562     return ret;
 563 }
 564
 565 gmx_bool gmx_fio_nreade_ushort(t_fileio *fio, unsigned short *item, int n,
 566                                const char *desc, const char *srcfile, int line)
 567 {
 568     gmx_bool ret = TRUE;
 569     int      i;
 570     gmx_fio_lock(fio);
 571     for (i = 0; i < n; i++)
 572     {
 573         ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioUSHORT, desc,
 574                                       srcfile, line);
 575     }
 576     gmx_fio_unlock(fio);
 577     return ret;
 578 }
 579
 580 gmx_bool gmx_fio_nreade_rvec(t_fileio *fio, rvec *item, int n,
 581                              const char *desc, const char *srcfile, int line)
 582 {
 583     gmx_bool ret;
 584     gmx_fio_lock(fio);
 585     ret = fio->iotp->nread(fio, item, n, eioNRVEC, desc, srcfile, line);
 586     gmx_fio_unlock(fio);
 587     return ret;
 588 }
 589
 590 gmx_bool gmx_fio_nreade_ivec(t_fileio *fio, ivec *item, int n,
 591                              const char *desc, const char *srcfile, int line)
 592 {
 593     gmx_bool ret = TRUE;
 594     int      i;
 595     gmx_fio_lock(fio);
 596     for (i = 0; i < n; i++)
 597     {
 598         ret = ret && fio->iotp->nread(fio, item[i], 1, eioIVEC, desc, srcfile, line);
 599     }
 600     gmx_fio_unlock(fio);
 601     return ret;
 602 }
 603
 604 gmx_bool gmx_fio_nreade_string(t_fileio *fio, char *item[], int n,
 605                                const char *desc, const char *srcfile, int line)
 606 {
 607     gmx_bool ret = TRUE;
 608     int      i;
 609     gmx_fio_lock(fio);
 610     for (i = 0; i < n; i++)
 611     {
 612         ret = ret && fio->iotp->nread(fio, item[i], 1, eioSTRING, desc, srcfile, line);
 613     }
 614     gmx_fio_unlock(fio);
 615     return ret;
 616 }
 617
 618
 619
 620
 621 /* Array writing */
 622
 623 gmx_bool gmx_fio_nwritee_real(t_fileio *fio, const real *item, int n,
 624                               const char *desc, const char *srcfile, int line)
 625 {
 626     gmx_bool ret = TRUE;
 627     int      i;
 628     gmx_fio_lock(fio);
 629     for (i = 0; i < n; i++)
 630     {
 631         ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioREAL, desc,
 632                                        srcfile, line);
 633     }
 634     gmx_fio_unlock(fio);
 635     return ret;
 636 }
 637
 638 gmx_bool gmx_fio_nwritee_float(t_fileio *fio, const float *item, int n,
 639                                const char *desc, const char *srcfile, int line)
 640 {
 641     gmx_bool ret = TRUE;
 642     int      i;
 643     gmx_fio_lock(fio);
 644     for (i = 0; i < n; i++)
 645     {
 646         ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioFLOAT, desc,
 647                                        srcfile, line);
 648     }
 649     gmx_fio_unlock(fio);
 650     return ret;
 651 }
 652
 653 gmx_bool gmx_fio_nwritee_double(t_fileio *fio, const double *item, int n,
 654                                 const char *desc, const char *srcfile, int line)
 655 {
 656     gmx_bool ret = TRUE;
 657     int      i;
 658     gmx_fio_lock(fio);
 659     for (i = 0; i < n; i++)
 660     {
 661         ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioDOUBLE, desc,
 662                                        srcfile, line);
 663     }
 664     gmx_fio_unlock(fio);
 665     return ret;
 666 }
 667
 668 gmx_bool gmx_fio_nwritee_int(t_fileio *fio, const int *item, int n,
 669                              const char *desc, const char *srcfile, int line)
 670 {
 671     gmx_bool ret = TRUE;
 672     int      i;
 673     gmx_fio_lock(fio);
 674     for (i = 0; i < n; i++)
 675     {
 676         ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioINT, desc, srcfile,
 677                                        line);
 678     }
 679     gmx_fio_unlock(fio);
 680     return ret;
 681 }
 682
 683 gmx_bool gmx_fio_nwritee_gmx_large_int(t_fileio *fio,
 684                                        const gmx_large_int_t *item, int n,
 685                                        const char *desc, const char *srcfile, int line)
 686 {
 687     gmx_bool ret = TRUE;
 688     int      i;
 689     gmx_fio_lock(fio);
 690     for (i = 0; i < n; i++)
 691     {
 692         ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioGMX_LARGE_INT,
 693                                        desc, srcfile, line);
 694     }
 695     gmx_fio_unlock(fio);
 696     return ret;
 697 }
 698
 699 gmx_bool gmx_fio_nwritee_uchar(t_fileio *fio, const unsigned char *item, int n,
 700                                const char *desc, const char *srcfile, int line)
 701 {
 702     gmx_bool ret;
 703     gmx_fio_lock(fio);
 704     ret = fio->iotp->nwrite(fio, item, n, eioNUCHAR, desc, srcfile, line);
 705     gmx_fio_unlock(fio);
 706     return ret;
 707 }
 708
 709 gmx_bool gmx_fio_nwritee_ushort(t_fileio *fio, const unsigned short *item, int n,
 710                                 const char *desc, const char *srcfile, int line)
 711 {
 712     gmx_bool ret = TRUE;
 713     int      i;
 714     gmx_fio_lock(fio);
 715     for (i = 0; i < n; i++)
 716     {
 717         ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioUSHORT, desc,
 718                                        srcfile, line);
 719     }
 720     gmx_fio_unlock(fio);
 721     return ret;
 722 }
 723
 724
 725 gmx_bool gmx_fio_nwritee_rvec(t_fileio *fio, const rvec *item, int n,
 726                               const char *desc, const char *srcfile, int line)
 727 {
 728     gmx_bool ret;
 729     gmx_fio_lock(fio);
 730     ret = fio->iotp->nwrite(fio, item, n, eioNRVEC, desc, srcfile, line);
 731     gmx_fio_unlock(fio);
 732     return ret;
 733 }
 734
 735 gmx_bool gmx_fio_nwritee_ivec(t_fileio *fio, const ivec *item, int n,
 736                               const char *desc, const char *srcfile, int line)
 737 {
 738     gmx_bool ret = TRUE;
 739     int      i;
 740     gmx_fio_lock(fio);
 741     for (i = 0; i < n; i++)
 742     {
 743         ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioIVEC, desc,
 744                                        srcfile, line);
 745     }
 746     gmx_fio_unlock(fio);
 747     return ret;
 748 }
 749
 750
 751 gmx_bool gmx_fio_nwritee_string(t_fileio *fio, const char *item[], int n,
 752                                 const char *desc, const char *srcfile, int line)
 753 {
 754     gmx_bool ret = TRUE;
 755     int      i;
 756     gmx_fio_lock(fio);
 757     for (i = 0; i < n; i++)
 758     {
 759         ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioSTRING, desc, srcfile,
 760                                        line);
 761     }
 762     gmx_fio_unlock(fio);
 763     return ret;
 764 }
 765
 766
 767
 768 /* array read/write functions */
 769
 770 gmx_bool gmx_fio_ndoe_real(t_fileio *fio, real *item, int n,
 771                            const char *desc, const char *srcfile, int line)
 772 {
 773     gmx_bool ret = TRUE;
 774     int      i;
 775     gmx_fio_lock(fio);
 776     for (i = 0; i < n; i++)
 777     {
 778         if (fio->bRead)
 779         {
 780             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioREAL, desc,
 781                                           srcfile, line);
 782         }
 783         else
 784         {
 785             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioREAL, desc,
 786                                            srcfile, line);
 787         }
 788     }
 789     gmx_fio_unlock(fio);
 790     return ret;
 791 }
 792
 793
 794
 795 gmx_bool gmx_fio_ndoe_float(t_fileio *fio, float *item, int n,
 796                             const char *desc, const char *srcfile, int line)
 797 {
 798     gmx_bool ret = TRUE;
 799     int      i;
 800     gmx_fio_lock(fio);
 801     for (i = 0; i < n; i++)
 802     {
 803         if (fio->bRead)
 804         {
 805             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioFLOAT, desc,
 806                                           srcfile, line);
 807         }
 808         else
 809         {
 810             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioFLOAT, desc,
 811                                            srcfile, line);
 812         }
 813     }
 814     gmx_fio_unlock(fio);
 815     return ret;
 816 }
 817
 818
 819
 820 gmx_bool gmx_fio_ndoe_double(t_fileio *fio, double *item, int n,
 821                              const char *desc, const char *srcfile, int line)
 822 {
 823     gmx_bool ret = TRUE;
 824     int      i;
 825     gmx_fio_lock(fio);
 826     for (i = 0; i < n; i++)
 827     {
 828         if (fio->bRead)
 829         {
 830             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioDOUBLE, desc,
 831                                           srcfile, line);
 832         }
 833         else
 834         {
 835             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioDOUBLE, desc,
 836                                            srcfile, line);
 837         }
 838     }
 839     gmx_fio_unlock(fio);
 840     return ret;
 841 }
 842
 843
 844
 845 gmx_bool gmx_fio_ndoe_gmx_bool(t_fileio *fio, gmx_bool *item, int n,
 846                                const char *desc, const char *srcfile, int line)
 847 {
 848     gmx_bool ret = TRUE;
 849     int      i, itmp;
 850
 851     gmx_fio_lock(fio);
 852     for (i = 0; i < n; i++)
 853     {
 854         if (fio->bRead)
 855         {
 856             ret = ret && fio->iotp->nread(fio, &itmp, 1, eioINT, desc,
 857                                           srcfile, line);
 858             item[i] = itmp;
 859         }
 860         else
 861         {
 862             itmp = item[i];
 863             ret  = ret && fio->iotp->nwrite(fio, &itmp, 1, eioINT, desc,
 864                                             srcfile, line);
 865         }
 866     }
 867     gmx_fio_unlock(fio);
 868     return ret;
 869 }
 870
 871 gmx_bool gmx_fio_ndoe_int(t_fileio *fio, int *item, int n,
 872                           const char *desc, const char *srcfile, int line)
 873 {
 874     gmx_bool ret = TRUE;
 875     int      i;
 876     gmx_fio_lock(fio);
 877     for (i = 0; i < n; i++)
 878     {
 879         if (fio->bRead)
 880         {
 881             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioINT, desc,
 882                                           srcfile, line);
 883         }
 884         else
 885         {
 886             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioINT, desc,
 887                                            srcfile, line);
 888         }
 889     }
 890     gmx_fio_unlock(fio);
 891     return ret;
 892 }
 893
 894
 895
 896 gmx_bool gmx_fio_ndoe_gmx_large_int(t_fileio *fio, gmx_large_int_t *item, int n,
 897                                     const char *desc, const char *srcfile, int line)
 898 {
 899     gmx_bool ret = TRUE;
 900     int      i;
 901     gmx_fio_lock(fio);
 902     for (i = 0; i < n; i++)
 903     {
 904         if (fio->bRead)
 905         {
 906             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioGMX_LARGE_INT, desc,
 907                                           srcfile, line);
 908         }
 909         else
 910         {
 911             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioGMX_LARGE_INT, desc,
 912                                            srcfile, line);
 913         }
 914     }
 915     gmx_fio_unlock(fio);
 916     return ret;
 917 }
 918
 919
 920
 921 gmx_bool gmx_fio_ndoe_uchar(t_fileio *fio, unsigned char *item, int n,
 922                             const char *desc, const char *srcfile, int line)
 923 {
 924     gmx_bool ret = TRUE;
 925     gmx_fio_lock(fio);
 926     if (fio->bRead)
 927     {
 928         ret = ret && fio->iotp->nread(fio, item, n, eioNUCHAR, desc,
 929                                       srcfile, line);
 930     }
 931     else
 932     {
 933         ret = ret && fio->iotp->nwrite(fio, item, n, eioNUCHAR, desc,
 934                                        srcfile, line);
 935     }
 936     gmx_fio_unlock(fio);
 937     return ret;
 938 }
 939
 940
 941
 942 gmx_bool gmx_fio_ndoe_ushort(t_fileio *fio, unsigned short *item, int n,
 943                              const char *desc, const char *srcfile, int line)
 944 {
 945     gmx_bool ret = TRUE;
 946     int      i;
 947     gmx_fio_lock(fio);
 948     for (i = 0; i < n; i++)
 949     {
 950         if (fio->bRead)
 951         {
 952             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioUSHORT, desc,
 953                                           srcfile, line);
 954         }
 955         else
 956         {
 957             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioUSHORT, desc,
 958                                            srcfile, line);
 959         }
 960     }
 961     gmx_fio_unlock(fio);
 962     return ret;
 963 }
 964
 965
 966
 967 gmx_bool gmx_fio_ndoe_rvec(t_fileio *fio, rvec *item, int n,
 968                            const char *desc, const char *srcfile, int line)
 969 {
 970     gmx_bool ret = TRUE;
 971     gmx_fio_lock(fio);
 972     if (fio->bRead)
 973     {
 974         ret = ret && fio->iotp->nread(fio, item, n, eioNRVEC, desc, srcfile, line);
 975     }
 976     else
 977     {
 978         ret = ret && fio->iotp->nwrite(fio, item, n, eioNRVEC, desc, srcfile,
 979                                        line);
 980     }
 981     gmx_fio_unlock(fio);
 982     return ret;
 983 }
 984
 985
 986
 987 gmx_bool gmx_fio_ndoe_ivec(t_fileio *fio, ivec *item, int n,
 988                            const char *desc, const char *srcfile, int line)
 989 {
 990     gmx_bool ret = TRUE;
 991     int      i;
 992     gmx_fio_lock(fio);
 993     for (i = 0; i < n; i++)
 994     {
 995         if (fio->bRead)
 996         {
 997             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioIVEC, desc,
 998                                           srcfile, line);
 999         }
1000         else
1001         {
1002             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioIVEC, desc,
1003                                            srcfile, line);
1004         }
1005     }
1006     gmx_fio_unlock(fio);
1007     return ret;
1008 }
1009
1010
1011
1012 gmx_bool gmx_fio_ndoe_string(t_fileio *fio, char *item[], int n,
1013                              const char *desc, const char *srcfile, int line)
1014 {
1015     gmx_bool ret = TRUE;
1016     int      i;
1017     gmx_fio_lock(fio);
1018     for (i = 0; i < n; i++)
1019     {
1020         if (fio->bRead)
1021         {
1022             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioSTRING, desc,
1023                                           srcfile, line);
1024         }
1025         else
1026         {
1027             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioSTRING, desc,
1028                                            srcfile, line);
1029         }
1030     }
1031     gmx_fio_unlock(fio);
1032     return ret;
1033 }