src/OpenFOAM/db/error/error.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM 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 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include "error.H"
  28 #include "OStringStream.H"
  29 #include "fileName.H"
  30 #include "dictionary.H"
  31 #include "JobInfo.H"
  32 #include "Pstream.H"
  33 #include "OSspecific.H"
  34
  35 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  36
  37 Foam::error::error(const string& title)
  38 :
  39     std::exception(),
  40     messageStream(title, messageStream::FATAL),
  41     functionName_("unknown"),
  42     sourceFileName_("unknown"),
  43     sourceFileLineNumber_(0),
  44     abort_(env("FOAM_ABORT")),
  45     throwExceptions_(false),
  46     messageStreamPtr_(new OStringStream())
  47 {
  48     if (!messageStreamPtr_->good())
  49     {
  50         Perr<< endl
  51             << "error::error(const string& title) : cannot open error stream"
  52             << endl;
  53         exit(1);
  54     }
  55 }
  56
  57
  58 Foam::error::error(const dictionary& errDict)
  59 :
  60     std::exception(),
  61     messageStream(errDict),
  62     functionName_(errDict.lookup("functionName")),
  63     sourceFileName_(errDict.lookup("sourceFileName")),
  64     sourceFileLineNumber_(readLabel(errDict.lookup("sourceFileLineNumber"))),
  65     abort_(env("FOAM_ABORT")),
  66     throwExceptions_(false),
  67     messageStreamPtr_(new OStringStream())
  68 {
  69     if (!messageStreamPtr_->good())
  70     {
  71         Perr<< endl
  72             << "error::error(const dictionary& errDict) : "
  73                "cannot open error stream"
  74             << endl;
  75         exit(1);
  76     }
  77 }
  78
  79
  80 Foam::error::error(const error& err)
  81 :
  82     std::exception(),
  83     messageStream(err),
  84     functionName_(err.functionName_),
  85     sourceFileName_(err.sourceFileName_),
  86     sourceFileLineNumber_(err.sourceFileLineNumber_),
  87     abort_(err.abort_),
  88     throwExceptions_(err.throwExceptions_),
  89     messageStreamPtr_(new OStringStream(*err.messageStreamPtr_))
  90 {
  91     //*messageStreamPtr_ << err.message();
  92 }
  93
  94
  95 Foam::error::~error() throw()
  96 {
  97     delete messageStreamPtr_;
  98 }
  99
 100
 101 Foam::OSstream& Foam::error::operator()
 102 (
 103     const char* functionName,
 104     const char* sourceFileName,
 105     const int sourceFileLineNumber
 106 )
 107 {
 108     messageStreamPtr_->rewind();
 109     functionName_ = functionName;
 110     sourceFileName_ = sourceFileName;
 111     sourceFileLineNumber_ = sourceFileLineNumber;
 112
 113     return operator OSstream&();
 114 }
 115
 116
 117 Foam::OSstream& Foam::error::operator()
 118 (
 119     const string& functionName,
 120     const char* sourceFileName,
 121     const int sourceFileLineNumber
 122 )
 123 {
 124     return operator()
 125     (
 126         functionName.c_str(),
 127         sourceFileName,
 128         sourceFileLineNumber
 129     );
 130 }
 131
 132
 133 Foam::error::operator OSstream&()
 134 {
 135     if (!messageStreamPtr_->good())
 136     {
 137         Perr<< endl
 138             << "error::operator OSstream&() : error stream has failed"
 139             << endl;
 140         printStack(Perr);
 141         abort();
 142     }
 143
 144     return *messageStreamPtr_;
 145 }
 146
 147
 148 Foam::error::operator dictionary() const
 149 {
 150     dictionary errDict;
 151
 152     string oneLineMessage(message());
 153     oneLineMessage.replaceAll('\n', ' ');
 154
 155     errDict.add("type", word("Foam::error"));
 156     errDict.add("message", oneLineMessage);
 157     errDict.add("function", functionName());
 158     errDict.add("sourceFile", sourceFileName());
 159     errDict.add("sourceFileLineNumber", sourceFileLineNumber());
 160
 161     return errDict;
 162 }
 163
 164
 165 Foam::string Foam::error::message() const
 166 {
 167     return messageStreamPtr_->str();
 168 }
 169
 170
 171 void Foam::error::exit(const int errNo)
 172 {
 173     if (!throwExceptions_ && JobInfo::constructed)
 174     {
 175         jobInfo.add("FatalError", operator dictionary());
 176         jobInfo.exit();
 177     }
 178
 179     if (abort_)
 180     {
 181         printStack(*this);
 182         Perr<< endl << *this << endl
 183             << "\nFOAM aborting (FOAM_ABORT set)\n" << endl;
 184         abort();
 185     }
 186
 187     if (Pstream::parRun())
 188     {
 189         Perr<< endl << *this << endl
 190             << "\nFOAM parallel run exiting\n" << endl;
 191         Pstream::exit(errNo);
 192     }
 193     else
 194     {
 195         if (throwExceptions_)
 196         {
 197             throw *this;
 198         }
 199         else
 200         {
 201             Perr<< endl << *this << endl
 202                 << "\nFOAM exiting\n" << endl;
 203             ::exit(1);
 204         }
 205     }
 206 }
 207
 208
 209 void Foam::error::abort()
 210 {
 211     if (!throwExceptions_ && JobInfo::constructed)
 212     {
 213         jobInfo.add("FatalError", operator dictionary());
 214         jobInfo.abort();
 215     }
 216
 217     if (abort_)
 218     {
 219         printStack(*this);
 220         Perr<< endl << *this << endl
 221             << "\nFOAM aborting (FOAM_ABORT set)\n" << endl;
 222         ::abort();
 223     }
 224
 225     if (Pstream::parRun())
 226     {
 227         printStack(*this);
 228         Perr<< endl << *this << endl
 229             << "\nFOAM parallel run aborting\n" << endl;
 230         Pstream::abort();
 231     }
 232     else
 233     {
 234         if (throwExceptions_)
 235         {
 236             throw *this;
 237         }
 238         else
 239         {
 240             printStack(*this);
 241             Perr<< endl << *this << endl
 242                 << "\nFOAM aborting\n" << endl;
 243             ::abort();
 244         }
 245     }
 246 }
 247
 248
 249 Foam::Ostream& Foam::operator<<(Ostream& os, const error& fErr)
 250 {
 251     os  << endl << fErr.message().c_str();
 252
 253     if (error::level >= 2 && fErr.sourceFileLineNumber())
 254     {
 255         os  << endl << endl
 256             << "    From function " << fErr.functionName().c_str() << endl
 257             << "    in file " << fErr.sourceFileName().c_str()
 258             << " at line " << fErr.sourceFileLineNumber() << '.';
 259     }
 260
 261     return os;
 262 }
 263
 264
 265 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 266 // Global error definitions
 267
 268 Foam::error Foam::FatalError("--> FOAM FATAL ERROR : ");
 269
 270 // ************************************************************************* //