src/gromacs/fileio/warninp.cpp

   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,2015,2016,2017,2018,2019, by the GROMACS development team, led by
   7  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   8  * and including many others, as listed in the AUTHORS file in the
   9  * top-level source directory and at http://www.gromacs.org.
  10  *
  11  * GROMACS is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public License
  13  * as published by the Free Software Foundation; either version 2.1
  14  * of the License, or (at your option) any later version.
  15  *
  16  * GROMACS is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with GROMACS; if not, see
  23  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  25  *
  26  * If you want to redistribute modifications to GROMACS, please
  27  * consider that scientific software is very special. Version
  28  * control is crucial - bugs must be traceable. We will be happy to
  29  * consider code for inclusion in the official distribution, but
  30  * derived work must not be called official GROMACS. Details are found
  31  * in the README & COPYING files - if they are missing, get the
  32  * official version at http://www.gromacs.org.
  33  *
  34  * To help us fund GROMACS development, we humbly ask that you cite
  35  * the research papers on the package. Check out http://www.gromacs.org.
  36  */
  37 #include "gmxpre.h"
  38
  39 #include "warninp.h"
  40
  41 #include <cstring>
  42
  43 #include <string>
  44
  45 #include "gromacs/utility/cstringutil.h"
  46 #include "gromacs/utility/fatalerror.h"
  47 #include "gromacs/utility/smalloc.h"
  48
  49 typedef struct warninp
  50 {
  51     gmx_bool    bAllowWarnings;
  52     int         nwarn_note;
  53     int         nwarn_warn;
  54     int         nwarn_error;
  55     int         maxwarn;
  56     int         lineno;
  57     std::string filenm;
  58 } t_warninp;
  59
  60 warninp_t init_warning(gmx_bool bAllowWarnings, int maxwarning)
  61 {
  62     warninp_t wi = new warninp;
  63
  64     wi->bAllowWarnings = bAllowWarnings;
  65     wi->maxwarn        = maxwarning;
  66     warning_reset(wi);
  67     wi->filenm = "unknown";
  68     wi->lineno = 0;
  69
  70     return wi;
  71 }
  72
  73 void warning_reset(warninp_t wi)
  74 {
  75     wi->nwarn_note  = 0;
  76     wi->nwarn_warn  = 0;
  77     wi->nwarn_error = 0;
  78 }
  79
  80 void set_warning_line(warninp_t wi, const char* s, int line)
  81 {
  82     if (s != nullptr)
  83     {
  84         wi->filenm = s;
  85     }
  86     wi->lineno = line;
  87 }
  88
  89 int get_warning_line(warninp_t wi)
  90 {
  91     return wi->lineno;
  92 }
  93
  94 const char* get_warning_file(warninp_t wi)
  95 {
  96     return wi->filenm.c_str();
  97 }
  98
  99 static void low_warning(warninp_t wi, const char* wtype, int n, const char* s)
 100 {
 101 #define indent 2
 102     char *temp, *temp2;
 103     int   i;
 104
 105     if (s == nullptr)
 106     {
 107         s = "Empty error message.";
 108     }
 109     snew(temp, std::strlen(s) + indent + 1);
 110     for (i = 0; i < indent; i++)
 111     {
 112         temp[i] = ' ';
 113     }
 114     temp[indent] = '\0';
 115     std::strcat(temp, s);
 116     temp2 = wrap_lines(temp, 78 - indent, indent, FALSE);
 117     if (!wi->filenm.empty())
 118     {
 119         if (wi->lineno != -1)
 120         {
 121             fprintf(stderr, "\n%s %d [file %s, line %d]:\n%s\n\n", wtype, n, wi->filenm.c_str(),
 122                     wi->lineno, temp2);
 123         }
 124         else
 125         {
 126             fprintf(stderr, "\n%s %d [file %s]:\n%s\n\n", wtype, n, wi->filenm.c_str(), temp2);
 127         }
 128     }
 129     else
 130     {
 131         fprintf(stderr, "\n%s %d:\n%s\n\n", wtype, n, temp2);
 132     }
 133     sfree(temp);
 134     sfree(temp2);
 135 }
 136
 137 void warning(warninp_t wi, const char* s)
 138 {
 139     if (wi->bAllowWarnings)
 140     {
 141         wi->nwarn_warn++;
 142         low_warning(wi, "WARNING", wi->nwarn_warn, s);
 143     }
 144     else
 145     {
 146         warning_error(wi, s);
 147     }
 148 }
 149
 150 void warning(warninp_t wi, const std::string& s)
 151 {
 152     warning(wi, s.c_str());
 153 }
 154
 155 void warning_note(warninp_t wi, const char* s)
 156 {
 157     wi->nwarn_note++;
 158     low_warning(wi, "NOTE", wi->nwarn_note, s);
 159 }
 160
 161 void warning_note(warninp_t wi, const std::string& s)
 162 {
 163     warning_note(wi, s.c_str());
 164 }
 165
 166 void warning_error(warninp_t wi, const char* s)
 167 {
 168     wi->nwarn_error++;
 169     low_warning(wi, "ERROR", wi->nwarn_error, s);
 170 }
 171
 172 void warning_error(warninp_t wi, const std::string& s)
 173 {
 174     warning_error(wi, s.c_str());
 175 }
 176
 177 static void print_warn_count(const char* type, int n)
 178 {
 179     if (n > 0)
 180     {
 181         fprintf(stderr, "\nThere %s %d %s%s\n", (n == 1) ? "was" : "were", n, type, (n == 1) ? "" : "s");
 182     }
 183 }
 184
 185 // Note it is the caller's responsibility to ensure that exiting is correct behaviour
 186 [[noreturn]] static void check_warning_error_impl(warninp_t wi, int f_errno, const char* file, int line)
 187 {
 188     print_warn_count("note", wi->nwarn_note);
 189     print_warn_count("warning", wi->nwarn_warn);
 190
 191     gmx_fatal(f_errno, file, line, "There %s %d error%s in input file(s)",
 192               (wi->nwarn_error == 1) ? "was" : "were", wi->nwarn_error, (wi->nwarn_error == 1) ? "" : "s");
 193 }
 194
 195 void check_warning_error(warninp_t wi, int f_errno, const char* file, int line)
 196 {
 197     if (wi->nwarn_error > 0)
 198     {
 199         check_warning_error_impl(wi, f_errno, file, line);
 200     }
 201 }
 202
 203 void warning_error_and_exit(warninp_t wi, const char* s, int f_errno, const char* file, int line)
 204 {
 205     warning_error(wi, s);
 206     check_warning_error_impl(wi, f_errno, file, line);
 207 }
 208
 209 void warning_error_and_exit(warninp_t wi, const std::string& s, int f_errno, const char* file, int line)
 210 {
 211     warning_error_and_exit(wi, s.c_str(), f_errno, file, line);
 212 }
 213
 214 gmx_bool warning_errors_exist(warninp_t wi)
 215 {
 216     return (wi->nwarn_error > 0);
 217 }
 218
 219 void done_warning(warninp_t wi, int f_errno, const char* file, int line)
 220 {
 221     // If we've had an error, then this will report the number of
 222     // notes and warnings, and then exit.
 223     check_warning_error(wi, f_errno, file, line);
 224
 225     // Otherwise, we report the number of notes and warnings.
 226     print_warn_count("note", wi->nwarn_note);
 227     print_warn_count("warning", wi->nwarn_warn);
 228
 229     if (wi->maxwarn >= 0 && wi->nwarn_warn > wi->maxwarn)
 230     {
 231         gmx_fatal(f_errno, file, line,
 232                   "Too many warnings (%d).\n"
 233                   "If you are sure all warnings are harmless, use the -maxwarn option.",
 234                   wi->nwarn_warn);
 235     }
 236
 237     free_warning(wi);
 238 }
 239
 240 void free_warning(warninp_t wi)
 241 {
 242     delete wi;
 243 }
 244
 245 void _too_few(warninp_t wi, const char* fn, int line)
 246 {
 247     char buf[STRLEN];
 248
 249     sprintf(buf, "Too few parameters on line (source file %s, line %d)", fn, line);
 250     warning(wi, buf);
 251 }
 252
 253 void _incorrect_n_param(warninp_t wi, const char* fn, int line)
 254 {
 255     char buf[STRLEN];
 256
 257     sprintf(buf, "Incorrect number of parameters on line (source file %s, line %d)", fn, line);
 258     warning(wi, buf);
 259 }