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