src/gmxlib/gmxfio_rw.c

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