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