---

mexception.h

Go to the documentation of this file.

#ifndef __MAGIC_MEXCEPTION_H__
#define __MAGIC_MEXCEPTION_H__

#include "magic/mobject.h"

namespace MagiC {
    class String;
}

BEGIN_NAMESPACE (MagiC);

//                                                                           //
//                -----                          o                           //
//                |          ___   ___   --   |           _                  //
//                |---  \ / |   \ /   ) |  ) -+- |  __  |/ \                 //
//                |      X  |     |---  |--   |  | /  \ |   |                //
//                |____ / \  \__/  \__  |      \ | \__/ |   |                //
//                                                                           //

// Exception handling macros

class Exception : public Object {
    String* mWhat;
  public:

                    Exception   (const String& what);
                    Exception   (const Exception& orig);
                    ~Exception  ();

    const String&   what        () const {return *mWhat;}
};

#define EXCEPTIONCLASS(eclass) \
class eclass : public Exception {\
public:\
    eclass (const String& what_arg) : Exception (what_arg) { }\
    virtual ~eclass () {;}\
};

//  eclass (const __string& what_arg): logic_error (what_arg) {;}

EXCEPTIONCLASS (generic_exception);
EXCEPTIONCLASS (invalid_format);
EXCEPTIONCLASS (assertion_failed);
EXCEPTIONCLASS (forwarded_failure);
EXCEPTIONCLASS (file_not_found);        
EXCEPTIONCLASS (system_failure);        
EXCEPTIONCLASS (open_failure);          
EXCEPTIONCLASS (invalid_flags);         
EXCEPTIONCLASS (file_not_open);         
EXCEPTIONCLASS (device_not_open);       
EXCEPTIONCLASS (stream_failure);        
EXCEPTIONCLASS (end_of_stream);         
EXCEPTIONCLASS (check_failed);          
EXCEPTIONCLASS (out_of_bounds);         
EXCEPTIONCLASS (out_of_range);
EXCEPTIONCLASS (runtime_error);
EXCEPTIONCLASS (io_error);              
// For abstract classes that can't use =0
EXCEPTIONCLASS (must_overload);
#define MUST_OVERLOAD {assertwith (__FILE__, __LINE__, __FUNCTION__, "MUST_OVERLOAD", format("%%ERR: Method of baseclass must be overloaded by descendant %s", typeid(*this).name()));}

EXCEPTIONCLASS (forbidden_call);
#define FORBIDDEN {throw forbidden_call (format("%%ERR: Forbidden execution at %s[%d]: %s()", __FILE__, __LINE__, __FUNCTION__));}

EXCEPTIONCLASS (not_implemented);
#define NOT_IMPLEMENTED {throw not_implemented (format("%%ERR: Function not implemented at %s[%d]: %s()", __FILE__, __LINE__, __FUNCTION__));}

#define failtrace_begin try {
#define failtrace_end \
    } catch (Exception e) { \
        throw forwarded_failure (format ("%s\n%%ERR: Exception forwaded at %s[%d]:%s()", \
                                         (CONSTR) e.what(), __FILE__, __LINE__, __FUNCTION__)); \
    }

#define FUNCTION_BEGIN failtrace_begin
#define FUNCTION_END   failtrace_end

#define failtrace(expr) failtrace_begin; expr; failtrace_end;

#define FAILTRACE failtrace

#define trywith(expr,err) \
    try { \
        expr; \
    } catch (Exception e) { \
        throw forwarded_failure (format ("%s\n%%ERR: Exception forwaded at %s[%d]:%s()\n%%ERR: %s", \
                                         (CONSTR) e.what(), __FILE__, __LINE__, __FUNCTION__, (CONSTR) err)); \
    }

#define TRYWITH trywith

enum assertmodes {ASSERT_THROW=0, ASSERT_CRASH=1, ASSERT_EXIT=2, ASSERT_DONTCARE=3};
    
extern FILE* dbgout;

extern int assertmode;

extern void assertwith (const char* filename, int lineno, const char* funcname,
                        const char* condition=NULL, const char* message=NULL);

END_NAMESPACE;

#endif

---