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