src/OpenFOAM/db/error/IOerror.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
  34 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  35
  36 Foam::IOerror::IOerror(const string& title)
  37 :
  38     error(title),
  39     ioFileName_("unknown"),
  40     ioStartLineNumber_(-1),
  41     ioEndLineNumber_(-1)
  42 {}
  43
  44
  45 Foam::IOerror::IOerror(const dictionary& errDict)
  46 :
  47     error(errDict),
  48     ioFileName_(errDict.lookup("ioFileName")),
  49     ioStartLineNumber_(readLabel(errDict.lookup("ioStartLineNumber"))),
  50     ioEndLineNumber_(readLabel(errDict.lookup("ioEndLineNumber")))
  51 {}
  52
  53
  54 Foam::IOerror::~IOerror() throw()
  55 {}
  56
  57
  58 Foam::OSstream& Foam::IOerror::operator()
  59 (
  60     const char* functionName,
  61     const char* sourceFileName,
  62     const int sourceFileLineNumber,
  63     const string& ioFileName,
  64     const label ioStartLineNumber,
  65     const label ioEndLineNumber
  66 )
  67 {
  68     error::operator()(functionName, sourceFileName, sourceFileLineNumber);
  69     ioFileName_ = ioFileName;
  70     ioStartLineNumber_ = ioStartLineNumber;
  71     ioEndLineNumber_ = ioEndLineNumber;
  72
  73     return operator OSstream&();
  74 }
  75
  76
  77 Foam::OSstream& Foam::IOerror::operator()
  78 (
  79     const char* functionName,
  80     const char* sourceFileName,
  81     const int sourceFileLineNumber,
  82     const IOstream& ioStream
  83 )
  84 {
  85     return operator()
  86     (
  87         functionName,
  88         sourceFileName,
  89         sourceFileLineNumber,
  90         ioStream.name(),
  91         ioStream.lineNumber(),
  92         -1
  93     );
  94 }
  95
  96
  97 Foam::OSstream& Foam::IOerror::operator()
  98 (
  99     const char* functionName,
 100     const char* sourceFileName,
 101     const int sourceFileLineNumber,
 102     const dictionary& dict
 103 )
 104 {
 105     return operator()
 106     (
 107         functionName,
 108         sourceFileName,
 109         sourceFileLineNumber,
 110         dict.name(),
 111         dict.startLineNumber(),
 112         dict.endLineNumber()
 113     );
 114 }
 115
 116
 117 Foam::IOerror::operator Foam::dictionary() const
 118 {
 119     dictionary errDict(error::operator dictionary());
 120
 121     errDict.remove("type");
 122     errDict.add("type", word("Foam::IOerror"));
 123
 124     errDict.add("ioFileName", ioFileName());
 125     errDict.add("ioStartLineNumber", ioStartLineNumber());
 126     errDict.add("ioEndLineNumber", ioEndLineNumber());
 127
 128     return errDict;
 129 }
 130
 131
 132 void Foam::IOerror::exit(const int)
 133 {
 134     if (!throwExceptions_ && JobInfo::constructed)
 135     {
 136         jobInfo.add("FatalIOError", operator dictionary());
 137         jobInfo.exit();
 138     }
 139
 140     if (abort_)
 141     {
 142         Perr<< endl << *this << endl
 143             << "\nFOAM aborting (FOAM_ABORT set)\n" << endl;
 144         printStack(Perr);
 145         ::abort();
 146     }
 147
 148     if (Pstream::parRun())
 149     {
 150         Perr<< endl << *this << endl
 151             << "\nFOAM parallel run exiting\n" << endl;
 152         Pstream::exit(1);
 153     }
 154     else
 155     {
 156         if (throwExceptions_)
 157         {
 158             throw *this;
 159         }
 160         else
 161         {
 162             Perr<< endl << *this << endl
 163                 << "\nFOAM exiting\n" << endl;
 164             ::exit(1);
 165         }
 166     }
 167 }
 168
 169
 170 void Foam::IOerror::abort()
 171 {
 172     if (!throwExceptions_ && JobInfo::constructed)
 173     {
 174         jobInfo.add("FatalIOError", operator dictionary());
 175         jobInfo.abort();
 176     }
 177
 178     if (abort_)
 179     {
 180         Perr<< endl << *this << endl
 181             << "\nFOAM aborting (FOAM_ABORT set)\n" << endl;
 182         printStack(Perr);
 183         ::abort();
 184     }
 185
 186     if (Pstream::parRun())
 187     {
 188         Perr<< endl << *this << endl
 189             << "\nFOAM parallel run aborting\n" << endl;
 190         printStack(Perr);
 191         Pstream::abort();
 192     }
 193     else
 194     {
 195         if (throwExceptions_)
 196         {
 197             throw *this;
 198         }
 199         else
 200         {
 201             Perr<< endl << *this << endl
 202                 << "\nFOAM aborting\n" << endl;
 203             printStack(Perr);
 204             ::abort();
 205         }
 206     }
 207 }
 208
 209
 210 Foam::Ostream& Foam::operator<<(Ostream& os, const IOerror& ioErr)
 211 {
 212     os  << endl << ioErr.message().c_str() << endl << endl;
 213
 214     os  << "file: " << ioErr.ioFileName().c_str();
 215
 216     if (ioErr.ioStartLineNumber() >= 0 && ioErr.ioEndLineNumber() >= 0)
 217     {
 218         os  << " from line " << ioErr.ioStartLineNumber()
 219             << " to line " << ioErr.ioEndLineNumber() << '.';
 220     }
 221     else if (ioErr.ioStartLineNumber() >= 0)
 222     {
 223         os  << " at line " << ioErr.ioStartLineNumber() << '.';
 224     }
 225
 226     if (IOerror::level >= 2 && ioErr.sourceFileLineNumber())
 227     {
 228         os  << endl << endl
 229             << "    From function " << ioErr.functionName().c_str() << endl
 230             << "    in file " << ioErr.sourceFileName().c_str()
 231             << " at line " << ioErr.sourceFileLineNumber() << '.';
 232     }
 233
 234     return os;
 235 }
 236
 237
 238 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 239 // Global error definitions
 240
 241 Foam::IOerror Foam::FatalIOError("--> FOAM FATAL IO ERROR : ");
 242
 243 // ************************************************************************* //