442 lines
9.8 KiB
C++
442 lines
9.8 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// File: mgexcept.h
|
|
// Created by: Jerzy Majewski - jmajewsk@meil.pw.edu.pl
|
|
// Modified by:
|
|
//
|
|
// Copyright notice:
|
|
// Copyright (C) 2000-2003 Jerzy Majewski
|
|
//
|
|
// This is free software. You can redistribute it and/or
|
|
// modify it under the terms of the GNU Lesser General Public License
|
|
// as published by the Free Software Foundation.
|
|
//
|
|
// This software is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY. See the GNU Lesser General Public License
|
|
// for more details.
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef __MGEXCEPT_H__
|
|
#define __MGEXCEPT_H__
|
|
|
|
|
|
#define THIS_FILE __FILE__ // defines name of header or implementation file
|
|
|
|
// constants used for exception handling
|
|
extern const MGInt EX_FILE_CODE;
|
|
extern const MGInt EX_MATH_CODE;
|
|
extern const MGInt EX_MEMORY_CODE;
|
|
extern const MGInt EX_INTERNAL_CODE;
|
|
extern const MGInt EX_ASSERT_CODE;
|
|
extern const MGInt EX_REXP_CODE;
|
|
|
|
extern const char EX_FILE_STR[];
|
|
extern const char EX_MATH_STR[];
|
|
extern const char EX_MEMORY_STR[];
|
|
extern const char EX_INTERNAL_STR[];
|
|
extern const char EX_ASSERT_STR[];
|
|
extern const char EX_REXP_STR[];
|
|
|
|
|
|
// name of file used for tracing
|
|
extern const char TRACE_FILE_NAME[];
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
/// class Trace
|
|
//////////////////////////////////////////////////////////////////////
|
|
class Trace
|
|
{
|
|
public:
|
|
Trace()
|
|
{
|
|
//FILE *ftrc = fopen( TRACE_FILE_NAME, "wt"); Verify(ftrc);
|
|
//fclose( ftrc);
|
|
}
|
|
|
|
FILE* Open()
|
|
{
|
|
//FILE *ftrc = fopen( TRACE_FILE_NAME, "at"); Verify(ftrc);
|
|
//return ftrc;
|
|
return NULL;
|
|
}
|
|
void Close( FILE *f)
|
|
{
|
|
//fclose( f);
|
|
}
|
|
void Verify( FILE *f);
|
|
void Out( char *sfile, MGInt nline);
|
|
};
|
|
|
|
inline void Trace::Verify( FILE *f)
|
|
{
|
|
//if ( !f)
|
|
// printf( "mgtrace file '%s' opening error\n", TRACE_FILE_NAME);
|
|
}
|
|
|
|
inline void Trace::Out( char *sfile, MGInt nline)
|
|
{
|
|
//FILE *ftrc = Open();
|
|
//fprintf( ftrc, "FILE:%s - LINE:%d; ", sfile, nline);
|
|
//Close( ftrc);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// macros for traceing
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
//-----------------------------------------
|
|
#ifdef _DEBUG
|
|
//-----------------------------------------
|
|
#define INIT_TRACE Trace mgtrace
|
|
|
|
#ifdef TRACE
|
|
#undef TRACE
|
|
#endif
|
|
#ifdef TRACE1
|
|
#undef TRACE1
|
|
#endif
|
|
#ifdef TRACE2
|
|
#undef TRACE2
|
|
#endif
|
|
|
|
#define TRACE(sz) /*\
|
|
{ \
|
|
FILE *f = mgtrace.Open(); \
|
|
mgtrace.Out(THIS_FILE, __LINE__); \
|
|
fprintf( f, sz); \
|
|
fprintf( f, "\n"); \
|
|
mgtrace.Close( f); \
|
|
}*/
|
|
|
|
#define TRACE1(sz, x1) /*\
|
|
{ \
|
|
FILE *f = mgtrace.Open(); \
|
|
mgtrace.Out(THIS_FILE, __LINE__); \
|
|
fprintf( f, sz, x1); \
|
|
fprintf( f, "\n"); \
|
|
mgtrace.Close( f); \
|
|
}*/
|
|
|
|
#define TRACE2(sz, x1, x2) /*\
|
|
{ \
|
|
FILE *f = mgtrace.Open(); \
|
|
mgtrace.Out(THIS_FILE, __LINE__); \
|
|
fprintf( f, sz, x1, x2); \
|
|
fprintf( f, "\n"); \
|
|
mgtrace.Close( f); \
|
|
}*/
|
|
|
|
#define TRACE_EXCEPTION(e) /*\
|
|
{ \
|
|
FILE *f = mgtrace.Open(); \
|
|
(e).WriteInfo( f); \
|
|
mgtrace.Close( f); \
|
|
}*/
|
|
|
|
|
|
extern Trace mgtrace;
|
|
|
|
//-----------------------------------------
|
|
#else // _DEBUG
|
|
//-----------------------------------------
|
|
|
|
#define INIT_TRACE
|
|
|
|
#ifndef TRACE
|
|
#define TRACE(sz) \
|
|
{ \
|
|
}
|
|
#endif
|
|
|
|
#ifndef TRACE1
|
|
#define TRACE1(sz, x1) \
|
|
{ \
|
|
}
|
|
#endif
|
|
|
|
#ifndef TRACE2
|
|
#define TRACE2(sz, x1, x2) \
|
|
{ \
|
|
}
|
|
#endif
|
|
|
|
#ifndef TRACE_EXCEPTION
|
|
#define TRACE_EXCEPTION(e) \
|
|
{ \
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------
|
|
#endif // _DEBUG
|
|
//-----------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
#define TRACE_TO_STDERR(e) \
|
|
{ \
|
|
(e).WriteInfo( stderr); \
|
|
}
|
|
|
|
#define TRACE_TO_CERR TRACE_TO_STDERR
|
|
|
|
|
|
/*
|
|
#define INIT_TRACE
|
|
|
|
#define TRACE(sz) \
|
|
{ \
|
|
}
|
|
|
|
#define TRACE1(sz, x1) \
|
|
{ \
|
|
}
|
|
|
|
#define TRACE2(sz, x1, x2) \
|
|
{ \
|
|
}
|
|
|
|
#define TRACE_EXCEPTION(e) \
|
|
{ \
|
|
}
|
|
|
|
#define TRACE_TO_STDERR(e) \
|
|
{ \
|
|
}
|
|
|
|
#define TRACE_TO_CERR TRACE_TO_STDERR
|
|
*/
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// class Except - base, abstract class for all exceptions
|
|
//////////////////////////////////////////////////////////////////////
|
|
class Except
|
|
{
|
|
public:
|
|
Except() { mComment = mFileName = ""; mLineNo = 0;}
|
|
Except( const Except& ex)
|
|
: mComment(ex.mComment), mFileName(ex.mFileName), mLineNo(ex.mLineNo) {};
|
|
|
|
Except( MGString com, MGString fname, MGInt line)
|
|
: mComment(com), mFileName(fname), mLineNo(line) {};
|
|
|
|
virtual ~Except() {};
|
|
|
|
Except& operator = (const Except& ex);
|
|
|
|
virtual MGInt GetExType() const = 0;
|
|
virtual MGString GetExPrefix() const = 0;
|
|
|
|
virtual void WriteInfo( FILE *f);
|
|
|
|
protected:
|
|
MGString mFileName;
|
|
MGInt mLineNo;
|
|
MGString mComment;
|
|
};
|
|
|
|
|
|
inline Except& Except::operator = (const Except& ex)
|
|
{
|
|
mFileName = ex.mFileName;
|
|
mLineNo = ex.mLineNo;
|
|
mComment = ex.mComment;
|
|
return *this;
|
|
}
|
|
|
|
inline void Except::WriteInfo( FILE *f)
|
|
{
|
|
fprintf( f, "FILE:%s - LINE:%d;\n", mFileName.c_str(), mLineNo);
|
|
fprintf( f, " %s: %s\n", (GetExPrefix()).c_str(), mComment.c_str() );
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// class ExceptFile
|
|
// used when some problems occur with opening, reading and parsing
|
|
// information from files
|
|
// passes to handler comment + add. info. (e.g. file name)
|
|
//////////////////////////////////////////////////////////////////////
|
|
class ExceptFile : public Except
|
|
{
|
|
protected:
|
|
MGString mFileInfo;
|
|
|
|
public:
|
|
ExceptFile() { mFileInfo = "";}
|
|
ExceptFile( MGString com, MGString info, MGString fname, MGInt line)
|
|
: Except( com, fname, line) {mFileInfo = info;};
|
|
virtual ~ExceptFile() {};
|
|
|
|
virtual MGInt GetExType() const { return EX_FILE_CODE;}
|
|
virtual MGString GetExPrefix() const { return EX_FILE_STR;}
|
|
|
|
virtual void WriteInfo( FILE *f);
|
|
|
|
};
|
|
|
|
inline void ExceptFile::WriteInfo( FILE *f)
|
|
{
|
|
fprintf( f, "FILE:%s - LINE:%d;\n", mFileName.c_str(), mLineNo);
|
|
fprintf( f, " %s: %s '%s'\n", (GetExPrefix()).c_str(), mComment.c_str(), mFileInfo.c_str() );
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// class ExceptMath
|
|
// for math. calc. exceptions
|
|
//////////////////////////////////////////////////////////////////////
|
|
class ExceptMath : public Except
|
|
{
|
|
public:
|
|
ExceptMath() {};
|
|
ExceptMath( MGString com, MGString fname, MGInt line)
|
|
: Except( com, fname, line) {};
|
|
|
|
virtual ~ExceptMath() {};
|
|
|
|
virtual MGInt GetExType() const { return EX_MATH_CODE;}
|
|
virtual MGString GetExPrefix() const { return EX_MATH_STR;}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// class ExceptMem
|
|
// for exception caused by memory (problems with alloc., memory corrupt.)
|
|
// C++ bad_alloc is switched off (at least for obj. allocated with GGNEW)
|
|
// because bad_alloc does not return info. where except. occured
|
|
//////////////////////////////////////////////////////////////////////
|
|
class ExceptMem : public Except
|
|
{
|
|
public:
|
|
ExceptMem() {};
|
|
ExceptMem( MGString com, MGString fname, MGInt line)
|
|
: Except( com, fname, line) {};
|
|
|
|
virtual ~ExceptMem() {};
|
|
|
|
virtual MGInt GetExType() const { return EX_MEMORY_CODE;}
|
|
virtual MGString GetExPrefix() const { return EX_MEMORY_STR;}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// class ExceptAssert
|
|
// used in ASSERT macro
|
|
//////////////////////////////////////////////////////////////////////
|
|
class ExceptAssert : public Except
|
|
{
|
|
public:
|
|
ExceptAssert() {};
|
|
ExceptAssert( MGString com, MGString fname, MGInt line)
|
|
: Except( com, fname, line) {};
|
|
|
|
virtual ~ExceptAssert() {};
|
|
|
|
virtual MGInt GetExType() const { return EX_ASSERT_CODE;}
|
|
virtual MGString GetExPrefix() const { return EX_ASSERT_STR;}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// class InternalException
|
|
// for handling abnormal events specific for mesh gen. program
|
|
//////////////////////////////////////////////////////////////////////
|
|
class ExceptInter : public Except
|
|
{
|
|
public:
|
|
ExceptInter() {};
|
|
ExceptInter( MGString com, MGString fname, MGInt line)
|
|
: Except( com, fname, line) {};
|
|
|
|
virtual ~ExceptInter() {};
|
|
|
|
virtual MGInt GetExType() const { return EX_INTERNAL_CODE;}
|
|
virtual MGString GetExPrefix() const { return EX_INTERNAL_STR;}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// class ExceptRExp
|
|
// for handling regular expresion exceptions
|
|
//////////////////////////////////////////////////////////////////////
|
|
class ExceptRExp : public Except
|
|
{
|
|
public:
|
|
ExceptRExp() {};
|
|
ExceptRExp( MGString com, MGString fname, MGInt line)
|
|
: Except( com, fname, line) {};
|
|
|
|
virtual ~ExceptRExp() {};
|
|
|
|
virtual MGInt GetExType() const { return EX_REXP_CODE;}
|
|
virtual MGString GetExPrefix() const { return EX_REXP_STR;}
|
|
};
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// macros for throwing Exceptions
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef assert
|
|
// if compiler provides a assert macro in "assert.h"
|
|
#ifndef ASSERT
|
|
#define ASSERT assert
|
|
#endif
|
|
#else
|
|
// assert macro which does not depend on compiler; uses exception ExceptAssert
|
|
#ifdef _DEBUG
|
|
#define ASSERT(f) \
|
|
{ \
|
|
if (!(f)) \
|
|
throw new ExceptAssert( "assertion failed: '" #f "'", THIS_FILE, __LINE__ ); \
|
|
}
|
|
#else
|
|
#define ASSERT(f) \
|
|
{ \
|
|
}
|
|
#endif // _DEBUG
|
|
#endif // assert
|
|
|
|
|
|
#define THROW_ALLOC(f) \
|
|
{ \
|
|
if (!(f)) \
|
|
throw new ExceptMem( "allocation error: '" #f "'", THIS_FILE, __LINE__ ); \
|
|
}
|
|
|
|
#define THROW_MEMORY(f) \
|
|
{ \
|
|
throw new ExceptMem( f, THIS_FILE, __LINE__ ); \
|
|
}
|
|
|
|
#define THROW_FILE(f1, f2) \
|
|
{ \
|
|
throw new ExceptFile( f1, f2, THIS_FILE, __LINE__ ); \
|
|
}
|
|
|
|
#define THROW_MATH(f) \
|
|
{ \
|
|
throw new ExceptMath( f, THIS_FILE, __LINE__ ); \
|
|
}
|
|
|
|
#define THROW_INTERNAL(f) \
|
|
{ \
|
|
throw new ExceptInter( f, THIS_FILE, __LINE__ ); \
|
|
}
|
|
|
|
#define THROW_REGEXP(f) \
|
|
{ \
|
|
throw new ExceptRExp( f, THIS_FILE, __LINE__ ); \
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif // __MGEXCEPT_H__
|
|
|