src/foam/db/error/IOerror.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation, either version 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "error.H"
  27 #include "OStringStream.H"
  28 #include "fileName.H"
  29 #include "dictionary.H"
  30 #include "JobInfo.H"
  31 #include "Pstream.H"
  32
  33 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  34
  35 Foam::IOerror::IOerror(const string& title)
  36 :
  37     error(title),
  38     ioFileName_("unknown"),
  39     ioStartLineNumber_(-1),
  40     ioEndLineNumber_(-1)
  41 {}
  42
  43
  44 Foam::IOerror::IOerror(const dictionary& errDict)
  45 :
  46     error(errDict),
  47     ioFileName_(errDict.lookup("ioFileName")),
  48     ioStartLineNumber_(readLabel(errDict.lookup("ioStartLineNumber"))),
  49     ioEndLineNumber_(readLabel(errDict.lookup("ioEndLineNumber")))
  50 {}
  51
  52
  53 Foam::IOerror::~IOerror() throw()
  54 {}
  55
  56
  57 Foam::OSstream& Foam::IOerror::operator()
  58 (
  59     const char* functionName,
  60     const char* sourceFileName,
  61     const int sourceFileLineNumber,
  62     const string& ioFileName,
  63     const label ioStartLineNumber,
  64     const label ioEndLineNumber
  65 )
  66 {
  67     error::operator()(functionName, sourceFileName, sourceFileLineNumber);
  68     ioFileName_ = ioFileName;
  69     ioStartLineNumber_ = ioStartLineNumber;
  70     ioEndLineNumber_ = ioEndLineNumber;
  71
  72     return operator OSstream&();
  73 }
  74
  75
  76 Foam::OSstream& Foam::IOerror::operator()
  77 (
  78     const char* functionName,
  79     const char* sourceFileName,
  80     const int sourceFileLineNumber,
  81     const IOstream& ioStream
  82 )
  83 {
  84     return operator()
  85     (
  86         functionName,
  87         sourceFileName,
  88         sourceFileLineNumber,
  89         ioStream.name(),
  90         ioStream.lineNumber(),
  91         -1
  92     );
  93 }
  94
  95
  96 Foam::OSstream& Foam::IOerror::operator()
  97 (
  98     const char* functionName,
  99     const char* sourceFileName,
 100     const int sourceFileLineNumber,
 101     const dictionary& dict
 102 )
 103 {
 104     return operator()
 105     (
 106         functionName,
 107         sourceFileName,
 108         sourceFileLineNumber,
 109         dict.name(),
 110         dict.startLineNumber(),
 111         dict.endLineNumber()
 112     );
 113 }
 114
 115
 116 Foam::IOerror::operator Foam::dictionary() const
 117 {
 118     dictionary errDict(error::operator dictionary());
 119
 120     errDict.remove("type");
 121     errDict.add("type", word("Foam::IOerror"));
 122
 123     errDict.add("ioFileName", ioFileName());
 124     errDict.add("ioStartLineNumber", ioStartLineNumber());
 125     errDict.add("ioEndLineNumber", ioEndLineNumber());
 126
 127     return errDict;
 128 }
 129
 130
 131 void Foam::IOerror::exit(const int)
 132 {
 133     if (!throwExceptions_ && JobInfo::constructed)
 134     {
 135         jobInfo.add("FatalIOError", operator dictionary());
 136         jobInfo.exit();
 137     }
 138
 139     if (abort_)
 140     {
 141         Perr<< endl << *this << endl
 142             << "\nFOAM aborting (FOAM_ABORT set)\n" << endl;
 143         printStack(Perr);
 144         ::abort();
 145     }
 146
 147     if (Pstream::parRun())
 148     {
 149         Perr<< endl << *this << endl
 150             << "\nFOAM parallel run exiting\n" << endl;
 151         Pstream::exit(1);
 152     }
 153     else
 154     {
 155         if (throwExceptions_)
 156         {
 157             // Make a copy of the error to throw
 158             IOerror errorException(*this);
 159
 160             // Rewind the message buffer for the next error message
 161             messageStreamPtr_->rewind();
 162
 163             throw errorException;
 164         }
 165         else
 166         {
 167             Perr<< endl << *this << endl
 168                 << "\nFOAM exiting\n" << endl;
 169             ::exit(1);
 170         }
 171     }
 172 }
 173
 174
 175 void Foam::IOerror::abort()
 176 {
 177     if (!throwExceptions_ && JobInfo::constructed)
 178     {
 179         jobInfo.add("FatalIOError", operator dictionary());
 180         jobInfo.abort();
 181     }
 182
 183     if (abort_)
 184     {
 185         Perr<< endl << *this << endl
 186             << "\nFOAM aborting (FOAM_ABORT set)\n" << endl;
 187         printStack(Perr);
 188         ::abort();
 189     }
 190
 191     if (Pstream::parRun())
 192     {
 193         Perr<< endl << *this << endl
 194             << "\nFOAM parallel run aborting\n" << endl;
 195         printStack(Perr);
 196         Pstream::abort();
 197     }
 198     else
 199     {
 200         if (throwExceptions_)
 201         {
 202             // Make a copy of the error to throw
 203             IOerror errorException(*this);
 204
 205             // Rewind the message buffer for the next error message
 206             messageStreamPtr_->rewind();
 207
 208             throw errorException;
 209         }
 210         else
 211         {
 212             Perr<< endl << *this << endl
 213                 << "\nFOAM aborting\n" << endl;
 214             printStack(Perr);
 215             ::abort();
 216         }
 217     }
 218 }
 219
 220
 221 Foam::Ostream& Foam::operator<<(Ostream& os, const IOerror& ioErr)
 222 {
 223     os  << endl
 224         << ioErr.title().c_str() << endl
 225         << ioErr.message().c_str() << endl << endl;
 226
 227     os  << "file: " << ioErr.ioFileName().c_str();
 228
 229     if (ioErr.ioStartLineNumber() >= 0 && ioErr.ioEndLineNumber() >= 0)
 230     {
 231         os  << " from line " << ioErr.ioStartLineNumber()
 232             << " to line " << ioErr.ioEndLineNumber() << '.';
 233     }
 234     else if (ioErr.ioStartLineNumber() >= 0)
 235     {
 236         os  << " at line " << ioErr.ioStartLineNumber() << '.';
 237     }
 238
 239     if (IOerror::level >= 2 && ioErr.sourceFileLineNumber())
 240     {
 241         os  << endl << endl
 242             << "    From function " << ioErr.functionName().c_str() << endl
 243             << "    in file " << ioErr.sourceFileName().c_str()
 244             << " at line " << ioErr.sourceFileLineNumber() << '.';
 245     }
 246
 247     return os;
 248 }
 249
 250
 251 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 252 // Global error definitions
 253
 254 Foam::IOerror Foam::FatalIOError("--> FOAM FATAL IO ERROR: ");
 255
 256 // ************************************************************************* //