src/gmxlib/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  * check out http://www.gromacs.org for more information.
   7  * Copyright (c) 2012, by the GROMACS development team, led by
   8  * David van der Spoel, Berk Hess, Erik Lindahl, and including many
   9  * others, as listed in the AUTHORS file in the top-level source
  10  * directory and at http://www.gromacs.org.
  11  *
  12  * GROMACS is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public License
  14  * as published by the Free Software Foundation; either version 2.1
  15  * of the License, or (at your option) any later version.
  16  *
  17  * GROMACS is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with GROMACS; if not, see
  24  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  25  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  26  *
  27  * If you want to redistribute modifications to GROMACS, please
  28  * consider that scientific software is very special. Version
  29  * control is crucial - bugs must be traceable. We will be happy to
  30  * consider code for inclusion in the official distribution, but
  31  * derived work must not be called official GROMACS. Details are found
  32  * in the README & COPYING files - if they are missing, get the
  33  * official version at http://www.gromacs.org.
  34  *
  35  * To help us fund GROMACS development, we humbly ask that you cite
  36  * the research papers on the package. Check out http://www.gromacs.org.
  37  */
  38 #ifdef HAVE_CONFIG_H
  39 #include <config.h>
  40 #endif
  41
  42 #include <ctype.h>
  43 #include <stdio.h>
  44 #include <errno.h>
  45 #ifdef HAVE_IO_H
  46 #include <io.h>
  47 #endif
  48
  49 #include "gmx_fatal.h"
  50 #include "macros.h"
  51 #include "smalloc.h"
  52 #include "futil.h"
  53 #include "filenm.h"
  54 #include "string2.h"
  55 #include "gmxfio.h"
  56 #include "md5.h"
  57
  58 #ifdef GMX_THREAD_MPI
  59 #include "thread_mpi.h"
  60 #endif
  61
  62 #include "gmxfio_int.h"
  63
  64
  65 /*******************************************************************
  66  *
  67  * READ/WRITE FUNCTIONS
  68  *
  69 *******************************************************************/
  70
  71 gmx_bool gmx_fio_reade_real(t_fileio *fio, real *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, eioREAL, desc, srcfile, line);
  77     gmx_fio_unlock(fio);
  78     return ret;
  79 }
  80
  81 gmx_bool gmx_fio_reade_float(t_fileio *fio, float *item,
  82                           const char *desc, const char *srcfile, int line)
  83 {
  84     gmx_bool ret;
  85     gmx_fio_lock(fio);
  86     ret=fio->iotp->nread(fio, item, 1, eioFLOAT, desc, srcfile, line);
  87     gmx_fio_unlock(fio);
  88     return ret;
  89 }
  90
  91
  92 gmx_bool gmx_fio_reade_double(t_fileio *fio, double *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, eioDOUBLE, desc, srcfile, line);
  98     gmx_fio_unlock(fio);
  99     return ret;
 100 }
 101
 102 gmx_bool gmx_fio_reade_int(t_fileio *fio, int *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, eioINT, desc, srcfile, line);
 108     gmx_fio_unlock(fio);
 109     return ret;
 110 }
 111
 112 gmx_bool gmx_fio_reade_gmx_large_int(t_fileio *fio, gmx_large_int_t *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, eioGMX_LARGE_INT, desc, srcfile, line);
 118     gmx_fio_unlock(fio);
 119     return ret;
 120 }
 121
 122 gmx_bool gmx_fio_reade_uchar(t_fileio *fio, unsigned char *item,
 123                          const char *desc, const char *srcfile, int line)
 124 {
 125     gmx_bool ret;
 126     gmx_fio_lock(fio);
 127     ret=fio->iotp->nread(fio, item, 1, eioUCHAR, desc, srcfile, line);
 128     gmx_fio_unlock(fio);
 129     return ret;
 130 }
 131
 132
 133 gmx_bool gmx_fio_reade_ushort(t_fileio *fio, unsigned short *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, eioUSHORT, desc, srcfile, line);
 139     gmx_fio_unlock(fio);
 140     return ret;
 141 }
 142
 143 gmx_bool gmx_fio_reade_rvec(t_fileio *fio, rvec *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, eioRVEC, desc, srcfile, line);
 149     gmx_fio_unlock(fio);
 150     return ret;
 151 }
 152
 153 gmx_bool gmx_fio_reade_ivec(t_fileio *fio, ivec *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, eioIVEC, desc, srcfile, line);
 159     gmx_fio_unlock(fio);
 160     return ret;
 161 }
 162
 163 gmx_bool gmx_fio_reade_string(t_fileio *fio, char *item,
 164                           const char *desc, const char *srcfile, int line)
 165 {
 166     gmx_bool ret;
 167     gmx_fio_lock(fio);
 168     ret=fio->iotp->nread(fio, item, 1, eioSTRING, desc, srcfile, line);
 169     gmx_fio_unlock(fio);
 170     return ret;
 171 }
 172
 173
 174 /* Write */
 175
 176 gmx_bool gmx_fio_writee_real(t_fileio *fio, real 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, eioREAL, desc, srcfile, line);
 182     gmx_fio_unlock(fio);
 183     return ret;
 184 }
 185
 186 gmx_bool gmx_fio_writee_float(t_fileio *fio, float 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, eioFLOAT, desc, srcfile, line);
 192     gmx_fio_unlock(fio);
 193     return ret;
 194 }
 195
 196 gmx_bool gmx_fio_writee_double(t_fileio *fio, double item,
 197                            const char *desc, const char *srcfile, int line)
 198 {
 199     gmx_bool ret;
 200     gmx_fio_lock(fio);
 201     ret=fio->iotp->nwrite(fio, &item, 1, eioDOUBLE, desc, srcfile, line);
 202     gmx_fio_unlock(fio);
 203     return ret;
 204 }
 205
 206
 207 gmx_bool gmx_fio_writee_int(t_fileio *fio, int 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, eioINT, desc, srcfile, line);
 213     gmx_fio_unlock(fio);
 214     return ret;
 215 }
 216
 217 gmx_bool gmx_fio_writee_gmx_large_int(t_fileio *fio, gmx_large_int_t 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, eioGMX_LARGE_INT, desc, srcfile, line);
 223     gmx_fio_unlock(fio);
 224     return ret;
 225 }
 226
 227 gmx_bool gmx_fio_writee_uchar(t_fileio *fio, unsigned char 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, eioUCHAR, desc, srcfile, line);
 233     gmx_fio_unlock(fio);
 234     return ret;
 235 }
 236
 237 gmx_bool gmx_fio_writee_ushort(t_fileio *fio, unsigned short 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, eioUSHORT, desc, srcfile, line);
 243     gmx_fio_unlock(fio);
 244     return ret;
 245 }
 246
 247 gmx_bool gmx_fio_writee_rvec(t_fileio *fio, rvec *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, eioRVEC, desc, srcfile, line);
 253     gmx_fio_unlock(fio);
 254     return ret;
 255 }
 256
 257 gmx_bool gmx_fio_writee_ivec(t_fileio *fio, ivec *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, eioIVEC, desc, srcfile, line);
 263     gmx_fio_unlock(fio);
 264     return ret;
 265 }
 266
 267 gmx_bool gmx_fio_writee_string(t_fileio *fio, const char *item,
 268                            const char *desc, const char *srcfile, int line)
 269 {
 270     gmx_bool ret;
 271     gmx_fio_lock(fio);
 272     ret=fio->iotp->nwrite(fio, item, 1, eioSTRING, desc, srcfile, line);
 273     gmx_fio_unlock(fio);
 274     return ret;
 275 }
 276
 277
 278
 279 /* Read/write functions */
 280
 281 gmx_bool gmx_fio_doe_real(t_fileio *fio, real *item,
 282                       const char *desc, const char *srcfile, int line)
 283 {
 284     gmx_bool ret;
 285     gmx_fio_lock(fio);
 286     if (fio->bRead)
 287         ret=fio->iotp->nread(fio, item, 1, eioREAL, desc, srcfile, line);
 288     else
 289         ret=fio->iotp->nwrite(fio, item, 1, eioREAL, desc, srcfile, line);
 290     gmx_fio_unlock(fio);
 291     return ret;
 292
 293 }
 294
 295 gmx_bool gmx_fio_doe_float(t_fileio *fio, float *item,
 296                         const char *desc, const char *srcfile, int line)
 297 {
 298     gmx_bool ret;
 299     gmx_fio_lock(fio);
 300     if (fio->bRead)
 301         ret=fio->iotp->nread(fio, item, 1, eioFLOAT, desc, srcfile, line);
 302     else
 303         ret=fio->iotp->nwrite(fio, item, 1, eioFLOAT, desc, srcfile, line);
 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         ret=fio->iotp->nread(fio, item, 1, eioDOUBLE, desc, srcfile, line);
 315     else
 316         ret=fio->iotp->nwrite(fio, item, 1, eioDOUBLE, desc, srcfile, line);
 317     gmx_fio_unlock(fio);
 318     return ret;
 319 }
 320
 321
 322 gmx_bool gmx_fio_doe_gmx_bool(t_fileio *fio, gmx_bool *item,
 323                       const char *desc, const char *srcfile, int line)
 324 {
 325     gmx_bool ret;
 326     int itmp;
 327
 328     gmx_fio_lock(fio);
 329     if (fio->bRead)
 330     {
 331         ret=fio->iotp->nread(fio, &itmp, 1, eioINT, desc, srcfile, line);
 332         *item = itmp;
 333     }
 334     else
 335     {
 336         itmp = *item;
 337         ret=fio->iotp->nwrite(fio, &itmp, 1, eioINT, desc, srcfile, line);
 338     }
 339     gmx_fio_unlock(fio);
 340     return ret;
 341 }
 342
 343 gmx_bool gmx_fio_doe_int(t_fileio *fio, int *item,
 344                      const char *desc, const char *srcfile, int line)
 345 {
 346     gmx_bool ret;
 347     gmx_fio_lock(fio);
 348     if (fio->bRead)
 349         ret=fio->iotp->nread(fio, item, 1, eioINT, desc, srcfile, line);
 350     else
 351         ret=fio->iotp->nwrite(fio, item, 1, eioINT, desc, srcfile, line);
 352     gmx_fio_unlock(fio);
 353     return ret;
 354 }
 355
 356 gmx_bool gmx_fio_doe_gmx_large_int(t_fileio *fio, gmx_large_int_t *item,
 357                            const char *desc, const char *srcfile, int line)
 358 {
 359     gmx_bool ret;
 360     gmx_fio_lock(fio);
 361     if (fio->bRead)
 362         ret=fio->iotp->nread(fio, item, 1, eioGMX_LARGE_INT, desc, srcfile, line);
 363     else
 364         ret=fio->iotp->nwrite(fio, item, 1, eioGMX_LARGE_INT, desc, srcfile, line);
 365     gmx_fio_unlock(fio);
 366     return ret;
 367 }
 368
 369 gmx_bool gmx_fio_doe_uchar(t_fileio *fio, unsigned char *item,
 370                        const char *desc, const char *srcfile, int line)
 371 {
 372     gmx_bool ret;
 373     gmx_fio_lock(fio);
 374     if (fio->bRead)
 375         ret=fio->iotp->nread(fio, item, 1, eioUCHAR, desc, srcfile, line);
 376     else
 377         ret=fio->iotp->nwrite(fio, item, 1, eioUCHAR, desc, srcfile, line);
 378     gmx_fio_unlock(fio);
 379     return ret;
 380 }
 381
 382 gmx_bool gmx_fio_doe_ushort(t_fileio *fio, unsigned short *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         ret=fio->iotp->nread(fio, item, 1, eioUSHORT, desc, srcfile, line);
 389     else
 390         ret=fio->iotp->nwrite(fio, item, 1, eioUSHORT, desc, srcfile, line);
 391     gmx_fio_unlock(fio);
 392     return ret;
 393 }
 394
 395 gmx_bool gmx_fio_doe_rvec(t_fileio *fio, rvec *item,
 396                       const char *desc, const char *srcfile, int line)
 397 {
 398     gmx_bool ret;
 399     gmx_fio_lock(fio);
 400     if (fio->bRead)
 401         ret=fio->iotp->nread(fio, item, 1, eioRVEC, desc, srcfile, line);
 402     else
 403         ret=fio->iotp->nwrite(fio, item, 1, eioRVEC, desc, srcfile, line);
 404     gmx_fio_unlock(fio);
 405     return ret;
 406 }
 407
 408 gmx_bool gmx_fio_doe_ivec(t_fileio *fio, ivec *item,
 409                       const char *desc, const char *srcfile, int line)
 410 {
 411     gmx_bool ret;
 412     gmx_fio_lock(fio);
 413     if (fio->bRead)
 414         ret=fio->iotp->nread(fio, item, 1, eioIVEC, desc, srcfile, line);
 415     else
 416         ret=fio->iotp->nwrite(fio, item, 1, eioIVEC, desc, srcfile, line);
 417     gmx_fio_unlock(fio);
 418     return ret;
 419 }
 420
 421 gmx_bool gmx_fio_doe_string(t_fileio *fio, char *item,
 422                         const char *desc, const char *srcfile, int line)
 423 {
 424     gmx_bool ret;
 425     gmx_fio_lock(fio);
 426     if (fio->bRead)
 427         ret=fio->iotp->nread(fio, item, 1, eioSTRING, desc, srcfile, line);
 428     else
 429         ret=fio->iotp->nwrite(fio, item, 1, eioSTRING, desc, srcfile, line);
 430     gmx_fio_unlock(fio);
 431     return ret;
 432 }
 433
 434
 435
 436
 437
 438
 439
 440 /* Array reading & writing */
 441
 442 gmx_bool gmx_fio_nreade_real(t_fileio *fio, real *item, int n,
 443                           const char *desc, const char *srcfile, int line)
 444 {
 445     gmx_bool ret=TRUE;
 446     int i;
 447     gmx_fio_lock(fio);
 448     for(i=0;i<n;i++)
 449         ret=ret && fio->iotp->nread(fio, &(item[i]), 1, eioREAL, desc, srcfile, line);
 450     gmx_fio_unlock(fio);
 451     return ret;
 452 }
 453
 454 gmx_bool gmx_fio_nreade_float(t_fileio *fio, float *item, int n,
 455                             const char *desc, const char *srcfile, int line)
 456 {
 457     gmx_bool ret=TRUE;
 458     int i;
 459     gmx_fio_lock(fio);
 460     for(i=0;i<n;i++)
 461         ret= ret && fio->iotp->nread(fio, &(item[i]), 1, eioFLOAT, desc,
 462                                      srcfile, line);
 463     gmx_fio_unlock(fio);
 464     return ret;
 465 }
 466
 467
 468 gmx_bool gmx_fio_nreade_double(t_fileio *fio, double *item, int n,
 469                             const char *desc, const char *srcfile, int line)
 470 {
 471     gmx_bool ret=TRUE;
 472     int i;
 473     gmx_fio_lock(fio);
 474     for(i=0;i<n;i++)
 475         ret= ret && fio->iotp->nread(fio, &(item[i]), 1, eioDOUBLE, desc,
 476                                      srcfile, line);
 477     gmx_fio_unlock(fio);
 478     return ret;
 479 }
 480
 481 gmx_bool gmx_fio_nreade_int(t_fileio *fio, int *item, int n,
 482                          const char *desc, const char *srcfile, int line)
 483 {
 484     gmx_bool ret=TRUE;
 485     int i;
 486     gmx_fio_lock(fio);
 487     for(i=0;i<n;i++)
 488         ret=ret && fio->iotp->nread(fio, &(item[i]), 1, eioINT, desc, srcfile, line);
 489     gmx_fio_unlock(fio);
 490     return ret;
 491 }
 492
 493 gmx_bool gmx_fio_nreade_gmx_large_int(t_fileio *fio, gmx_large_int_t *item, int n,
 494                                const char *desc, const char *srcfile, int line)
 495 {
 496     gmx_bool ret=TRUE;
 497     int i;
 498     gmx_fio_lock(fio);
 499     for(i=0;i<n;i++)
 500         ret=ret && fio->iotp->nread(fio, &(item[i]), 1, eioGMX_LARGE_INT, desc,
 501                               srcfile, line);
 502     gmx_fio_unlock(fio);
 503     return ret;
 504 }
 505
 506
 507 gmx_bool gmx_fio_nreade_uchar(t_fileio *fio, unsigned char *item, int n,
 508                            const char *desc, const char *srcfile, int line)
 509 {
 510     gmx_bool ret;
 511     gmx_fio_lock(fio);
 512     ret=fio->iotp->nread(fio, item, n, eioNUCHAR, desc, srcfile, line);
 513     gmx_fio_unlock(fio);
 514     return ret;
 515 }
 516
 517 gmx_bool gmx_fio_nreade_ushort(t_fileio *fio, unsigned short *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         ret=ret && fio->iotp->nread(fio, &(item[i]), 1, eioUSHORT, desc,
 525                                     srcfile, line);
 526     gmx_fio_unlock(fio);
 527     return ret;
 528 }
 529
 530 gmx_bool gmx_fio_nreade_rvec(t_fileio *fio, rvec *item, int n,
 531                           const char *desc, const char *srcfile, int line)
 532 {
 533     gmx_bool ret;
 534     gmx_fio_lock(fio);
 535     ret=fio->iotp->nread(fio, item, n, eioNRVEC, desc, srcfile, line);
 536     gmx_fio_unlock(fio);
 537     return ret;
 538 }
 539
 540 gmx_bool gmx_fio_nreade_ivec(t_fileio *fio, ivec *item, int n,
 541                           const char *desc, const char *srcfile, int line)
 542 {
 543     gmx_bool ret=TRUE;
 544     int i;
 545     gmx_fio_lock(fio);
 546     for(i=0;i<n;i++)
 547         ret=ret && fio->iotp->nread(fio, item[i], 1, eioIVEC, desc, srcfile, line);
 548     gmx_fio_unlock(fio);
 549     return ret;
 550 }
 551
 552 gmx_bool gmx_fio_nreade_string(t_fileio *fio, char *item[], int n,
 553                            const char *desc, const char *srcfile, int line)
 554 {
 555     gmx_bool ret=TRUE;
 556     int i;
 557     gmx_fio_lock(fio);
 558     for(i=0;i<n;i++)
 559         ret=ret && fio->iotp->nread(fio, item[i], 1, eioSTRING, desc, srcfile, line);
 560     gmx_fio_unlock(fio);
 561     return ret;
 562 }
 563
 564
 565
 566
 567 /* Array writing */
 568
 569 gmx_bool gmx_fio_nwritee_real(t_fileio *fio, const real *item, int n,
 570                           const char *desc, const char *srcfile, int line)
 571 {
 572     gmx_bool ret=TRUE;
 573     int i;
 574     gmx_fio_lock(fio);
 575     for(i=0;i<n;i++)
 576         ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioREAL, desc,
 577                                      srcfile, line);
 578     gmx_fio_unlock(fio);
 579     return ret;
 580 }
 581
 582 gmx_bool gmx_fio_nwritee_float(t_fileio *fio, const float *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         ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioFLOAT, desc,
 590                                      srcfile, line);
 591     gmx_fio_unlock(fio);
 592     return ret;
 593 }
 594
 595 gmx_bool gmx_fio_nwritee_double(t_fileio *fio, const double *item, int n,
 596                             const char *desc, const char *srcfile, int line)
 597 {
 598     gmx_bool ret=TRUE;
 599     int i;
 600     gmx_fio_lock(fio);
 601     for(i=0;i<n;i++)
 602         ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioDOUBLE, desc,
 603                                      srcfile, line);
 604     gmx_fio_unlock(fio);
 605     return ret;
 606 }
 607
 608 gmx_bool gmx_fio_nwritee_int(t_fileio *fio, const int *item, int n,
 609                          const char *desc, const char *srcfile, int line)
 610 {
 611     gmx_bool ret=TRUE;
 612     int i;
 613     gmx_fio_lock(fio);
 614     for(i=0;i<n;i++)
 615         ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioINT, desc, srcfile,
 616                                      line);
 617     gmx_fio_unlock(fio);
 618     return ret;
 619 }
 620
 621 gmx_bool gmx_fio_nwritee_gmx_large_int(t_fileio *fio,
 622                                const gmx_large_int_t *item, int n,
 623                                const char *desc, const char *srcfile, int line)
 624 {
 625     gmx_bool ret=TRUE;
 626     int i;
 627     gmx_fio_lock(fio);
 628     for(i=0;i<n;i++)
 629         ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioGMX_LARGE_INT,
 630                                      desc, srcfile, line);
 631     gmx_fio_unlock(fio);
 632     return ret;
 633 }
 634
 635 gmx_bool gmx_fio_nwritee_uchar(t_fileio *fio, const unsigned char *item, int n,
 636                            const char *desc, const char *srcfile, int line)
 637 {
 638     gmx_bool ret;
 639     gmx_fio_lock(fio);
 640     ret=fio->iotp->nwrite(fio, item, n, eioNUCHAR, desc, srcfile, line);
 641     gmx_fio_unlock(fio);
 642     return ret;
 643 }
 644
 645 gmx_bool gmx_fio_nwritee_ushort(t_fileio *fio, const unsigned short *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         ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioUSHORT, desc,
 653                                      srcfile, line);
 654     gmx_fio_unlock(fio);
 655     return ret;
 656 }
 657
 658
 659 gmx_bool gmx_fio_nwritee_rvec(t_fileio *fio, const rvec *item, int n,
 660                           const char *desc, const char *srcfile, int line)
 661 {
 662     gmx_bool ret;
 663     gmx_fio_lock(fio);
 664     ret=fio->iotp->nwrite(fio, item, n, eioNRVEC, desc, srcfile, line);
 665     gmx_fio_unlock(fio);
 666     return ret;
 667 }
 668
 669 gmx_bool gmx_fio_nwritee_ivec(t_fileio *fio, const ivec *item, int n,
 670                           const char *desc, const char *srcfile, int line)
 671 {
 672     gmx_bool ret=TRUE;
 673     int i;
 674     gmx_fio_lock(fio);
 675     for(i=0;i<n;i++)
 676         ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioIVEC, desc,
 677                                      srcfile, line);
 678     gmx_fio_unlock(fio);
 679     return ret;
 680 }
 681
 682
 683 gmx_bool gmx_fio_nwritee_string(t_fileio *fio, const char *item[], int n,
 684                             const char *desc, const char *srcfile, int line)
 685 {
 686     gmx_bool ret=TRUE;
 687     int i;
 688     gmx_fio_lock(fio);
 689     for(i=0;i<n;i++)
 690         ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioSTRING, desc, srcfile,
 691                                line);
 692     gmx_fio_unlock(fio);
 693     return ret;
 694 }
 695
 696
 697
 698 /* array read/write functions */
 699
 700 gmx_bool gmx_fio_ndoe_real(t_fileio *fio, real *item, int n,
 701                        const char *desc, const char *srcfile, int line)
 702 {
 703     gmx_bool ret=TRUE;
 704     int i;
 705     gmx_fio_lock(fio);
 706     for(i=0;i<n;i++)
 707     {
 708         if (fio->bRead)
 709         {
 710             ret=ret && fio->iotp->nread(fio, &(item[i]), 1, eioREAL, desc,
 711                                   srcfile, line);
 712         }
 713         else
 714         {
 715             ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioREAL, desc,
 716                                    srcfile, line);
 717         }
 718     }
 719     gmx_fio_unlock(fio);
 720     return ret;
 721 }
 722
 723
 724
 725 gmx_bool gmx_fio_ndoe_float(t_fileio *fio, float *item, int n,
 726                         const char *desc, const char *srcfile, int line)
 727 {
 728     gmx_bool ret=TRUE;
 729     int i;
 730     gmx_fio_lock(fio);
 731     for(i=0;i<n;i++)
 732     {
 733         if (fio->bRead)
 734         {
 735             ret=ret && fio->iotp->nread(fio, &(item[i]), 1, eioFLOAT, desc,
 736                                   srcfile, line);
 737         }
 738         else
 739         {
 740             ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioFLOAT, desc,
 741                                    srcfile, line);
 742         }
 743     }
 744     gmx_fio_unlock(fio);
 745     return ret;
 746 }
 747
 748
 749
 750 gmx_bool gmx_fio_ndoe_double(t_fileio *fio, double *item, int n,
 751                          const char *desc, const char *srcfile, int line)
 752 {
 753     gmx_bool ret=TRUE;
 754     int i;
 755     gmx_fio_lock(fio);
 756     for(i=0;i<n;i++)
 757     {
 758         if (fio->bRead)
 759         {
 760             ret=ret && fio->iotp->nread(fio, &(item[i]), 1, eioDOUBLE, desc,
 761                                   srcfile, line);
 762         }
 763         else
 764         {
 765             ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioDOUBLE, desc,
 766                                    srcfile, line);
 767         }
 768     }
 769     gmx_fio_unlock(fio);
 770     return ret;
 771 }
 772
 773
 774
 775 gmx_bool gmx_fio_ndoe_gmx_bool(t_fileio *fio, gmx_bool *item, int n,
 776                       const char *desc, const char *srcfile, int line)
 777 {
 778     gmx_bool ret=TRUE;
 779     int i,itmp;
 780
 781     gmx_fio_lock(fio);
 782     for(i=0;i<n;i++)
 783     {
 784         if (fio->bRead)
 785         {
 786             ret=ret && fio->iotp->nread(fio, &itmp, 1, eioINT, desc,
 787                                   srcfile, line);
 788             item[i] = itmp;
 789         }
 790         else
 791         {
 792             itmp = item[i];
 793             ret=ret && fio->iotp->nwrite(fio, &itmp, 1, eioINT, desc,
 794                                    srcfile, line);
 795         }
 796     }
 797     gmx_fio_unlock(fio);
 798     return ret;
 799 }
 800
 801 gmx_bool gmx_fio_ndoe_int(t_fileio *fio, int *item, int n,
 802                       const char *desc, const char *srcfile, int line)
 803 {
 804     gmx_bool ret=TRUE;
 805     int i;
 806     gmx_fio_lock(fio);
 807     for(i=0;i<n;i++)
 808     {
 809         if (fio->bRead)
 810         {
 811             ret=ret && fio->iotp->nread(fio, &(item[i]), 1, eioINT, desc,
 812                                   srcfile, line);
 813         }
 814         else
 815         {
 816             ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioINT, desc,
 817                                    srcfile, line);
 818         }
 819     }
 820     gmx_fio_unlock(fio);
 821     return ret;
 822 }
 823
 824
 825
 826 gmx_bool gmx_fio_ndoe_gmx_large_int(t_fileio *fio, gmx_large_int_t *item, int n,
 827                             const char *desc, const char *srcfile, int line)
 828 {
 829     gmx_bool ret=TRUE;
 830     int i;
 831     gmx_fio_lock(fio);
 832     for(i=0;i<n;i++)
 833     {
 834         if (fio->bRead)
 835         {
 836             ret=ret && fio->iotp->nread(fio, &(item[i]), 1, eioGMX_LARGE_INT, desc,
 837                                   srcfile, line);
 838         }
 839         else
 840         {
 841             ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioGMX_LARGE_INT, desc,
 842                                    srcfile, line);
 843         }
 844     }
 845     gmx_fio_unlock(fio);
 846     return ret;
 847 }
 848
 849
 850
 851 gmx_bool gmx_fio_ndoe_uchar(t_fileio *fio, unsigned char *item, int n,
 852                         const char *desc, const char *srcfile, int line)
 853 {
 854     gmx_bool ret=TRUE;
 855     gmx_fio_lock(fio);
 856     if (fio->bRead)
 857     {
 858         ret=ret && fio->iotp->nread(fio, item, n, eioNUCHAR, desc,
 859                                     srcfile, line);
 860     }
 861     else
 862     {
 863         ret=ret && fio->iotp->nwrite(fio, item, n, eioNUCHAR, desc,
 864                                      srcfile, line);
 865     }
 866     gmx_fio_unlock(fio);
 867     return ret;
 868 }
 869
 870
 871
 872 gmx_bool gmx_fio_ndoe_ushort(t_fileio *fio, unsigned short *item, int n,
 873                         const char *desc, const char *srcfile, int line)
 874 {
 875     gmx_bool ret=TRUE;
 876     int i;
 877     gmx_fio_lock(fio);
 878     for(i=0;i<n;i++)
 879     {
 880         if (fio->bRead)
 881         {
 882             ret=ret && fio->iotp->nread(fio, &(item[i]), 1, eioUSHORT, desc,
 883                                   srcfile, line);
 884         }
 885         else
 886         {
 887             ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioUSHORT, desc,
 888                                    srcfile, line);
 889         }
 890     }
 891     gmx_fio_unlock(fio);
 892     return ret;
 893 }
 894
 895
 896
 897 gmx_bool gmx_fio_ndoe_rvec(t_fileio *fio, rvec *item, int n,
 898                        const char *desc, const char *srcfile, int line)
 899 {
 900     gmx_bool ret=TRUE;
 901     gmx_fio_lock(fio);
 902     if (fio->bRead)
 903     {
 904         ret=ret && fio->iotp->nread(fio, item, n, eioNRVEC, desc, srcfile, line);
 905     }
 906     else
 907     {
 908         ret=ret && fio->iotp->nwrite(fio, item, n, eioNRVEC, desc, srcfile,
 909                                line);
 910     }
 911     gmx_fio_unlock(fio);
 912     return ret;
 913 }
 914
 915
 916
 917 gmx_bool gmx_fio_ndoe_ivec(t_fileio *fio, ivec *item, int n,
 918                        const char *desc, const char *srcfile, int line)
 919 {
 920     gmx_bool ret=TRUE;
 921     int i;
 922     gmx_fio_lock(fio);
 923     for(i=0;i<n;i++)
 924     {
 925         if (fio->bRead)
 926         {
 927             ret=ret && fio->iotp->nread(fio, &(item[i]), 1, eioIVEC, desc,
 928                                   srcfile, line);
 929         }
 930         else
 931         {
 932             ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioIVEC, desc,
 933                                    srcfile, line);
 934         }
 935     }
 936     gmx_fio_unlock(fio);
 937     return ret;
 938 }
 939
 940
 941
 942 gmx_bool gmx_fio_ndoe_string(t_fileio *fio, char *item[], int n,
 943                          const char *desc, const char *srcfile, int line)
 944 {
 945     gmx_bool ret=TRUE;
 946     int i;
 947     gmx_fio_lock(fio);
 948     for(i=0;i<n;i++)
 949     {
 950         if (fio->bRead)
 951         {
 952             ret=ret && fio->iotp->nread(fio, &(item[i]), 1, eioSTRING, desc,
 953                                   srcfile, line);
 954         }
 955         else
 956         {
 957             ret=ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioSTRING, desc,
 958                                    srcfile, line);
 959         }
 960     }
 961     gmx_fio_unlock(fio);
 962     return ret;
 963 }
 964
 965
 966
 967
 968