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