guards.cpp

Go to the documentation of this file.

#ifndef GUARDS_IMPLEMENTATION_FILE
#define GUARDS_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  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 "function.h"
#include "guards.h"
#include "istring.h"
#include "log_base.h"
#include "portable.h"
#include "utility.h"

#include <errno.h>
#include <stdlib.h>
#include <string.h>

#include <stdio.h>

namespace guards {

const int MESSAGE_SPACE_PROVIDED = 4096;
  // the strings should not be larger than this for diagnostic / error messages.
//hmmm: how about we enforce that...???

void write_to_console(const char *guards_message_space)
{ fprintf(stderr, guards_message_space); fflush(stderr); }

void alert_message(const char *info, const char *title)
{
  istring to_print;
  if (strlen(title)) {
    const char border = '=';
    to_print += istring(border, int(strlen(title)) + 4);
    to_print += log_base::platform_ending();
    to_print += border;
    to_print += ' ';
    to_print += title;
    to_print += ' ';
    to_print += border;
    to_print += log_base::platform_ending();
    to_print += istring(border, int(strlen(title)) + 4);
    to_print += log_base::platform_ending();
  }

  to_print += info;
  program_wide_logger().log(to_print);
  fflush(NIL);  // flush all output streams.
}

void alert_message(const istring &info) { alert_message(info.s()); }

void alert_message(const istring &info, const istring &title)
{ alert_message(info.s(), title.s()); }

void make_error_message(const char *file, int line,
    const char *error_class, const char *error_function,
    const char *info, char *guards_message_space)
{
  strcpy(guards_message_space, "\nProblem reported for \"");
//hmmm: only copy N chars of each into the space.
//      say 40 for class/function each, then the space - consumed for the
//      info.  get strlen for real on the class and function name to know
//      actual size for that computation.
  strcat(guards_message_space, error_class);
  strcat(guards_message_space, "::");
  strcat(guards_message_space, error_function);
  strcat(guards_message_space, "\"\n(invoked at line ");
  char line_num[20];
  sprintf(line_num, "%d", line);
  strcat(guards_message_space, line_num);
  strcat(guards_message_space, " in ");
  strcat(guards_message_space, file);
  strcat(guards_message_space, " at ");
  strcat(guards_message_space, utility::timestamp(false, true).s());
  strcat(guards_message_space, ")\n");
  strcat(guards_message_space, info);
  strcat(guards_message_space, "\n\n\n");
}

void FL_deadly_error(const char *file, int line, const char *error_class,
    const char *error_function, const char *info)
{
  FL_continuable_error(file, line, error_class, error_function, info,
      "Deadly Error Information");
  CAUSE_BREAKPOINT;
  throw "deadly_error";
    // abort() is not as good an approach as throwing an exception.  aborts are
    // harder to track with some compilers, but all should be able to trap an
    // exception.
}

void FL_deadly_error(const istring &file, int line,
    const istring &error_class, const istring &error_function,
    const istring &info)
{
  FL_deadly_error(file.s(), line, error_class.s(), error_function.s(),
      info.s()); 
}

void FL_continuable_error_real(const char *file, int line,
    const char *error_class, const char *error_function, const char *info,
    const char *title)
{
  char guards_message_space[MESSAGE_SPACE_PROVIDED];
    // this routine could still fail, if the call stack is already jammed
    // against its barrier.  but if that's the case, even the simple function
    // call might fail.  in any case, we cannot deal with a stack overflow
    // type error using this function.  but we would rather deal with that
    // than make the space static since that would cause corruption when
    // two threads wrote errors at the same time.
  make_error_message(file, line, error_class, error_function, info,
      guards_message_space);
  alert_message(guards_message_space, title);
}

void FL_continuable_error(const char *file, int line,
    const char *error_class, const char *error_function, const char *info,
    const char *title)
{
  FL_continuable_error_real(file, line, error_class, error_function, info,
      title);
}

void FL_continuable_error(const istring &file, int line,
    const istring &error_class, const istring &error_function,
    const istring &info, const istring &title)
{
  FL_continuable_error_real(file.s(), line, error_class.s(),
      error_function.s(), info.s(), title.s());
}

void FL_non_continuable_error(const char *file, int line,
    const char *error_class, const char *error_function, const char *info,
    const char *title)
{
  FL_continuable_error_real(file, line, error_class, error_function, info,
      title);
  exit(EXIT_FAILURE);  // let the outside world know that there was a problem.
}

void FL_non_continuable_error(const istring &file, int line,
    const istring &error_class, const istring &error_function,
    const istring &info, const istring &title)
{
  FL_continuable_error_real(file.s(), line, error_class.s(),
      error_function.s(), info.s(), title.s());
  exit(EXIT_FAILURE);  // let the outside world know that there was a problem.
}

void FL_console_error(const char *file, int line, const char *error_class,
    const char *error_function, const char *info)
{
  char guards_message_space[MESSAGE_SPACE_PROVIDED];
  make_error_message(file, line, error_class, error_function, info,
      guards_message_space);
  write_to_console(guards_message_space);
}

void FL_out_of_memory_now(const char *file, int line,
    const char *the_class_name, const char *the_func)
{
  FL_non_continuable_error(file, line, the_class_name, the_func, 
      "Program stopped due to memory allocation failure.",
      "Out of Memory Now");
}

void implement_bounds_halt(const char *the_class_name, const char *the_func,
    const char *value, const char *low, const char *high,
    const char *error_addition)
{
  char message[400];
  strcpy(message, "bounds error caught");
  strcat(message, error_addition);
  strcat(message, ":\r\n");
  strcat(message, value);
  strcat(message, " is not between ");
  strcat(message, low);
  strcat(message, " and ");
  strcat(message, high);
#ifdef ERRORS_ARE_FATAL
  deadly_error(the_class_name, the_func, message);
#else
  continuable_error(the_class_name, the_func, message);
#endif
}

} // namespace


#endif //GUARDS_IMPLEMENTATION_FILE

---