src/gromacs/fileio/gmxfio_asc.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
  38
  39 #include "config.h"
  40
  41 #include <ctype.h>
  42 #include <errno.h>
  43 #include <stdio.h>
  44 #include <string.h>
  45 #ifdef HAVE_IO_H
  46 #include <io.h>
  47 #endif
  48
  49 #include "gromacs/utility/fatalerror.h"
  50 #include "macros.h"
  51 #include "gromacs/utility/smalloc.h"
  52 #include "gromacs/utility/futil.h"
  53 #include "filenm.h"
  54 #include "gromacs/utility/cstringutil.h"
  55 #include "gmxfio.h"
  56 #include "md5.h"
  57
  58 #include "gmxfio_int.h"
  59
  60
  61 /* This is the part that reads dummy and ascii files.  */
  62
  63
  64
  65
  66 /* file type functions */
  67 static gmx_bool do_ascread(t_fileio *fio, void *item, int nitem, int eio,
  68                            const char *desc, const char *srcfile, int line);
  69 static gmx_bool do_ascwrite(t_fileio *fio, const void *item, int nitem, int eio,
  70                             const char *desc, const char *srcfile, int line);
  71 static gmx_bool do_dummyread(t_fileio *fio, void *item, int nitem, int eio,
  72                              const char *desc, const char *srcfile, int line);
  73 static gmx_bool do_dummywrite(t_fileio *fio, const void *item, int nitem, int eio,
  74                               const char *desc, const char *srcfile, int line);
  75
  76
  77 const t_iotype asc_iotype = {do_ascread, do_ascwrite};
  78 const t_iotype dummy_iotype = {do_dummyread, do_dummywrite};
  79
  80
  81
  82
  83
  84
  85 static gmx_bool do_dummyread(t_fileio gmx_unused *fio, void gmx_unused *item, int gmx_unused nitem, int gmx_unused eio,
  86                              const char gmx_unused *desc, const char gmx_unused *srcfile, int gmx_unused line)
  87 {
  88     gmx_fatal(FARGS, "File type not set!");
  89     return FALSE;
  90 }
  91
  92 static gmx_bool do_dummywrite(t_fileio gmx_unused *fio, const void gmx_unused *item, int gmx_unused nitem, int gmx_unused eio,
  93                               const char gmx_unused *desc, const char gmx_unused *srcfile, int gmx_unused line)
  94 {
  95     gmx_fatal(FARGS, "File type not set!");
  96     return FALSE;
  97 }
  98
  99
 100
 101 static void encode_string(int maxlen, char dst[], const char src[])
 102 {
 103     int i;
 104
 105     for (i = 0; (i < maxlen - 1) && (src[i] != '\0'); i++)
 106     {
 107         if ((src[i] == ' ') || (src[i] == '\t'))
 108         {
 109             dst[i] = '_';
 110         }
 111         else
 112         {
 113             dst[i] = src[i];
 114         }
 115     }
 116     dst[i] = '\0';
 117
 118     if (i == maxlen)
 119     {
 120         fprintf(stderr, "String '%s' truncated to '%s'\n", src, dst);
 121     }
 122 }
 123
 124 static void decode_string(int maxlen, char dst[], const char src[])
 125 {
 126     int i;
 127
 128     for (i = 0; (i < maxlen - 1) && (src[i] != '\0'); i++)
 129     {
 130         if (src[i] == '_')
 131         {
 132             dst[i] = ' ';
 133         }
 134         else
 135         {
 136             dst[i] = src[i];
 137         }
 138     }
 139     dst[i] = '\0';
 140
 141     if (i == maxlen)
 142     {
 143         fprintf(stderr, "String '%s' truncated to '%s'\n", src, dst);
 144     }
 145 }
 146
 147 static gmx_bool do_ascwrite(t_fileio *fio, const void *item, int nitem, int eio,
 148                             const char *desc, const char *srcfile, int line)
 149 {
 150     int            i;
 151     int            res = 0, *iptr;
 152     real          *ptr;
 153     char           strbuf[256];
 154     char           buf[GMX_FIO_BUFLEN];
 155     unsigned char *ucptr;
 156     FILE          *fp = fio->fp;
 157
 158     gmx_fio_check_nitem(eio, nitem, srcfile, line);
 159     switch (eio)
 160     {
 161         case eioREAL:
 162         case eioFLOAT:
 163         case eioDOUBLE:
 164             res = fprintf(fp, "%18.10e%s\n", *((real *) item),
 165                           gmx_fio_dbgstr(fio, desc, buf));
 166             break;
 167         case eioINT:
 168             res = fprintf(fp, "%18d%s\n", *((int *) item), gmx_fio_dbgstr(fio,
 169                                                                           desc,
 170                                                                           buf));
 171             break;
 172         case eioINT64:
 173             sprintf(strbuf, "%s%s%s", "%", GMX_PRId64, "\n");
 174             res = fprintf(fp, strbuf, *((gmx_int64_t *) item),
 175                           gmx_fio_dbgstr(fio, desc, buf));
 176             break;
 177         case eioUCHAR:
 178             res = fprintf(fp, "%4d%s\n", *((unsigned char *) item),
 179                           gmx_fio_dbgstr(fio, desc, buf));
 180             break;
 181         case eioNUCHAR:
 182             ucptr = (unsigned char *) item;
 183             for (i = 0; (i < nitem); i++)
 184             {
 185                 res = fprintf(fp, "%4d", (int) ucptr[i]);
 186             }
 187             fprintf(fio->fp, "%s\n", gmx_fio_dbgstr(fio, desc, buf));
 188             break;
 189         case eioUSHORT:
 190             res = fprintf(fp, "%18d%s\n", *((unsigned short *) item),
 191                           gmx_fio_dbgstr(fio, desc, buf));
 192             break;
 193         case eioRVEC:
 194             ptr = (real *) item;
 195             res = fprintf(fp, "%18.10e%18.10e%18.10e%s\n", ptr[XX],
 196                           ptr[YY], ptr[ZZ], gmx_fio_dbgstr(fio, desc, buf));
 197             break;
 198         case eioNRVEC:
 199             for (i = 0; (i < nitem); i++)
 200             {
 201                 ptr = ((rvec *) item)[i];
 202                 res = fprintf(fp, "%18.10e%18.10e%18.10e%s\n", ptr[XX],
 203                               ptr[YY], ptr[ZZ], gmx_fio_dbgstr(fio, desc, buf));
 204             }
 205             break;
 206         case eioIVEC:
 207             iptr = (int *) item;
 208             res  = fprintf(fp, "%18d%18d%18d%s\n", iptr[XX], iptr[YY],
 209                            iptr[ZZ], gmx_fio_dbgstr(fio, desc, buf));
 210             break;
 211         case eioSTRING:
 212             encode_string(256, strbuf, (char *) item);
 213             res = fprintf(fp, "%-18s%s\n", strbuf, gmx_fio_dbgstr(fio, desc, buf));
 214             break;
 215         default:
 216             gmx_fio_fe(fio, eio, desc, srcfile, line);
 217     }
 218     if ((res <= 0) && fio->bDebug)
 219     {
 220         fprintf(stderr,
 221                 "Error writing %s %s to file %s (source %s, line %d)\n",
 222                 eioNames[eio], desc, fio->fn, srcfile, line);
 223     }
 224
 225     return (res > 0);
 226 }
 227
 228
 229 static char *next_item(FILE *fp, char *buf, int buflen)
 230 {
 231     int      rd;
 232     gmx_bool in_comment = FALSE;
 233     gmx_bool in_token   = FALSE;
 234     int      i          = 0;
 235     /* This routine reads strings from the file fp, strips comment
 236      * and buffers. For thread-safety reasons, It reads through getc()  */
 237
 238     rd = getc(fp);
 239     if (rd == EOF)
 240     {
 241         gmx_file("End of file");
 242     }
 243     do
 244     {
 245         if (in_comment)
 246         {
 247             if (rd == '\n')
 248             {
 249                 in_comment = FALSE;
 250             }
 251         }
 252         else if (in_token)
 253         {
 254             if (isspace(rd) || rd == ';')
 255             {
 256                 break;
 257             }
 258             buf[i++] = (char) rd;
 259         }
 260         else
 261         {
 262             if (!isspace(rd))
 263             {
 264                 if (rd == ';')
 265                 {
 266                     in_comment = TRUE;
 267                 }
 268                 else
 269                 {
 270                     in_token = TRUE;
 271                     buf[i++] = (char) (rd);
 272                 }
 273             }
 274         }
 275         if (i >= buflen - 2)
 276         {
 277             break;
 278         }
 279     }
 280     while ((rd = getc(fp)) != EOF);
 281
 282     fprintf(stderr, "WARNING, ftpASC file type not tested!\n");
 283
 284     buf[i] = 0;
 285
 286     return buf;
 287 }
 288
 289 static gmx_bool do_ascread(t_fileio *fio, void *item, int nitem, int eio,
 290                            const char *desc, const char *srcfile, int line)
 291 {
 292     FILE           *fp = fio->fp;
 293     int             i, m, res = 0, *iptr, ix;
 294     gmx_int64_t     s;
 295     double          d, x;
 296     real           *ptr;
 297     unsigned char   uc, *ucptr;
 298     char           *cptr;
 299 #define NEXT_ITEM_BUF_LEN 128
 300     char            ni_buf[NEXT_ITEM_BUF_LEN];
 301
 302     gmx_fio_check_nitem(eio, nitem, srcfile, line);
 303     switch (eio)
 304     {
 305         case eioREAL:
 306         case eioFLOAT:
 307         case eioDOUBLE:
 308             res = sscanf(next_item(fp, ni_buf, NEXT_ITEM_BUF_LEN), "%lf", &d);
 309             if (item)
 310             {
 311                 *((real *) item) = d;
 312             }
 313             break;
 314         case eioINT:
 315             res = sscanf(next_item(fp, ni_buf, NEXT_ITEM_BUF_LEN), "%d", &i);
 316             if (item)
 317             {
 318                 *((int *) item) = i;
 319             }
 320             break;
 321         case eioINT64:
 322             res = sscanf(next_item(fp, ni_buf, NEXT_ITEM_BUF_LEN),
 323                          "%"GMX_SCNd64, &s);
 324             if (item)
 325             {
 326                 *((gmx_int64_t *) item) = s;
 327             }
 328             break;
 329         case eioUCHAR:
 330             res = sscanf(next_item(fp, ni_buf, NEXT_ITEM_BUF_LEN), "%c", &uc);
 331             if (item)
 332             {
 333                 *((unsigned char *) item) = uc;
 334             }
 335             break;
 336         case eioNUCHAR:
 337             ucptr = (unsigned char *) item;
 338             for (i = 0; (i < nitem); i++)
 339             {
 340                 res = sscanf(next_item(fp, ni_buf, NEXT_ITEM_BUF_LEN), "%d", &ix);
 341                 if (item)
 342                 {
 343                     ucptr[i] = ix;
 344                 }
 345             }
 346             break;
 347         case eioUSHORT:
 348             res = sscanf(next_item(fp, ni_buf, NEXT_ITEM_BUF_LEN), "%d", &i);
 349             if (item)
 350             {
 351                 *((unsigned short *) item) = i;
 352             }
 353             break;
 354         case eioRVEC:
 355             ptr = (real *) item;
 356             for (m = 0; (m < DIM); m++)
 357             {
 358                 res    = sscanf(next_item(fp, ni_buf, NEXT_ITEM_BUF_LEN), "%lf\n", &x);
 359                 ptr[m] = x;
 360             }
 361             break;
 362         case eioNRVEC:
 363             for (i = 0; (i < nitem); i++)
 364             {
 365                 ptr = ((rvec *) item)[i];
 366                 for (m = 0; (m < DIM); m++)
 367                 {
 368                     res = sscanf(next_item(fp, ni_buf, NEXT_ITEM_BUF_LEN), "%lf\n",
 369                                  &x);
 370                     if (item)
 371                     {
 372                         ptr[m] = x;
 373                     }
 374                 }
 375             }
 376             break;
 377         case eioIVEC:
 378             iptr = (int *) item;
 379             for (m = 0; (m < DIM); m++)
 380             {
 381                 res = sscanf(next_item(fp, ni_buf, NEXT_ITEM_BUF_LEN), "%d\n", &ix);
 382                 if (item)
 383                 {
 384                     iptr[m] = ix;
 385                 }
 386             }
 387             break;
 388         case eioSTRING:
 389             cptr = next_item(fp, ni_buf, NEXT_ITEM_BUF_LEN);
 390             if (item)
 391             {
 392                 decode_string(strlen(cptr) + 1, (char *) item, cptr);
 393                 /* res = sscanf(cptr,"%s",(char *)item);*/
 394                 res = 1;
 395             }
 396             break;
 397         default:
 398             gmx_fio_fe(fio, eio, desc, srcfile, line);
 399     }
 400
 401     if ((res <= 0) && fio->bDebug)
 402     {
 403         fprintf(stderr,
 404                 "Error reading %s %s from file %s (source %s, line %d)\n",
 405                 eioNames[eio], desc, fio->fn, srcfile, line);
 406     }
 407     return (res > 0);
 408 }