src/gromacs/fileio/gmxfio_rw.c

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