guards.h

Go to the documentation of this file.

#ifndef GUARDS_GROUP
#define GUARDS_GROUP

/*****************************************************************************\
*                                                                             *
*  Name   : guards                                                            *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1989-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "definitions.h"


namespace guards {

// friendlier guards first...

template <class contents>
inline bool in_range(const contents &value, const contents &low,
    const contents &high)
{ return !( (high < low) || (value < low) || (value > high) ); }


#define bounds_return(value, low, high, to_return) \
    { if (((value) < (low)) || ((value) > (high))) return to_return; }

#ifdef __UNIX__
  #define CAUSE_BREAKPOINT
//hmmm: need a unix equivalent for this.  supporting gcc might be enough.
#elif defined(__WIN32__)
  #ifdef __MINGW32__
    extern "C" {
//      #include <ddk/winddi.h>
//for debugbreak.  does this cause other problems?
    }
    #define CAUSE_BREAKPOINT 
//    #define CAUSE_BREAKPOINT __debugbreak()
  #else
    #define CAUSE_BREAKPOINT __debugbreak()
  #endif
#endif


#ifdef ERRORS_ARE_FATAL
  #define REQUIRE(check) if (!check) CAUSE_BREAKPOINT;
#else
  #define REQUIRE(check)
#endif

// then the noisemaking guardians...

void write_to_console(const char *message);


void alert_message(const char *info, const char *title = "Alert Message");
void alert_message(const istring &info);  // uses default title.
void alert_message(const istring &info, const istring &title);  // use "title".

// now more dangerous or potent guards...

#ifndef EMBEDDED_BUILD
  #define BH_ERROR_ADDITION ((istring(" in ") + __argv[0]).s())
#else
  #define BH_ERROR_ADDITION ""
#endif


#ifdef CATCH_ERRORS
  #define bounds_halt(value, low, high, to_return) { \
    if (((value) < (low)) || ((value) > (high))) { \
      guards::implement_bounds_halt(static_class_name(), func, #value, #low, \
          #high, BH_ERROR_ADDITION); \
      return to_return; \
    } \
  }
#else
  #define bounds_halt(a, b, c, d) bounds_return(a, b, c, d)
#endif



#define non_continuable_error(c, f, i) \
  guards::FL_non_continuable_error(__FILE__, __LINE__, c, f, i, \
      "A Non-Continuable Runtime Problem Has Occurred")
#define continuable_error(c, f, i) \
  guards::FL_continuable_error(__FILE__, __LINE__, c, f, i, \
      "Runtime Problem Information")
#define console_error(c, f, i) \
  guards::FL_console_error(__FILE__, __LINE__, c, f, i)
#define deadly_error(c, f, i) \
  guards::FL_deadly_error(__FILE__, __LINE__, c, f, i)
#define out_of_memory_now(c, f) \
  guards::FL_out_of_memory_now(__FILE__, __LINE__, c, f)


// this section is a set of methods that implement the above macros.


void FL_deadly_error(const char *file, int line, const char *classname,
    const char *function_name, const char *info);
void FL_deadly_error(const istring &file, int line,
    const istring &classname, const istring &function_name,
    const istring &info);

void FL_continuable_error(const char *file, int line,
    const char *classname, const char *function_name, const char *info,
    const char *title);

void FL_continuable_error(const istring &file, int line,
    const istring &classname, const istring &function_name,
    const istring &info, const istring &title);


void FL_non_continuable_error(const char *file, int line,
    const char *classname, const char *function_name, const char *info,
    const char *title);

void FL_non_continuable_error(const istring &file, int line,
    const istring &classname, const istring &function_name,
    const istring &info, const istring &title);

void FL_out_of_memory_now(const char *file, int line,
    const char *classname, const char *function_name);

void FL_console_error(const char *file, int line, const char *error_class,
    const char *error_function, const char *info);


void make_error_message(const char *file, int line,
    const char *error_class, const char *error_function,
    const char *info, char *guards_message_space);

void implement_bounds_halt(const char *the_class_name, const char *func,
    const char *value, const char *low, const char *high,
    const char *error_addition);

}  // namespace.

#endif

---