critical_events.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : critical_events                                                   *
*  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 "critical_events.h"
#include "program_wide_logger.h"
 
#include <application/application_shell.h>
#include <application/callstack_tracker.h>
#include <application/windoze_helper.h>
#include <basis/astring.h>
#include <basis/functions.h>
#include <basis/mutex.h>
#include <configuration/application_configuration.h>
#include <structures/static_memory_gremlin.h>
#include <textual/parser_bits.h>
#include <timely/time_stamp.h>
 
#include <stdio.h>
#include <errno.h>
 
using namespace application;
using namespace basis;
using namespace structures;
using namespace configuration;
using namespace textual;
using namespace timely;
 
const int MESSAGE_SPACE_PROVIDED = 4096;
  // the strings should not be larger than this for diagnostic / error messages.
 
namespace loggers {
 
SAFE_STATIC(astring, critical_events::hidden_critical_events_dir, )
  // define the function that holds the directory string.
 
astring default_critical_location()
{
  // ensure that the critical events function logs to the appropriate place.
  return application_configuration::get_logging_directory();
}
 
SAFE_STATIC(mutex, __critical_event_dir_lock, )
 
basis::un_int critical_events::system_error()
{
#if defined(__UNIX__) || defined(__GNU_WINDOWS__)
  return errno;
//#elif defined(_MSC_VER)
//  return GetLastError();
#else
  #pragma error("hmmm: no code for error number for this operating system")
  return 0;
#endif
}
 
astring critical_events::system_error_text(basis::un_int to_name)
{
#if defined(__UNIX__) || defined(__GNU_WINDOWS__)
  return strerror(to_name);
/*
#elif defined(_MSC_VER)
  char error_text[1000];
  FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL_POINTER, to_name,
      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)error_text,
      sizeof(error_text) - 1, NULL_POINTER);
  astring to_return = error_text;
  // trim off the ridiculous carriage return they add.
  while ( (to_return[to_return.end()] == '\r')
      || (to_return[to_return.end()] == '\n') )
    to_return.zap(to_return.end(), to_return.end());
  return to_return;
*/
#else
  #pragma error("hmmm: no code for error text for this operating system")
  return "";
#endif
}
 
astring critical_events::critical_events_directory()
{
  static bool initted = false;
  if (!initted) {
    auto_synchronizer l(__critical_event_dir_lock());
    if (!initted) {
      set_critical_events_directory(default_critical_location());
      initted = true;
    }
  }
  return hidden_critical_events_dir();
}
 
void critical_events::set_critical_events_directory(const astring &directory)
{ hidden_critical_events_dir() = directory; }
 
void critical_events::write_to_critical_events(const char *to_write)
{
  astring filename = critical_events_directory();
  filename += "/runtime_issues.log";
  FILE *errfile = fopen(filename.s(), "ab");
  if (errfile) {
    astring app_name = application_configuration::application_name();
    int indy = app_name.find('/', app_name.end(), true);
    if (non_negative(indy)) app_name.zap(0, indy);
    indy = app_name.find('\\', app_name.end(), true);
    if (non_negative(indy)) app_name.zap(0, indy);
    fprintf(errfile, "%s [%s]:%s", time_stamp::notarize(true).s(),
        app_name.s(), parser_bits::platform_eol_to_chars());
    fprintf(errfile, "%s%s", to_write, parser_bits::platform_eol_to_chars());
    fclose(errfile);
  }
}
 
void critical_events::write_to_console(const char *guards_message_space)
{ fprintf(stderr, "%s", (char *)guards_message_space); fflush(stderr); }
 
void critical_events::alert_message(const char *info, const char *title)
{
  astring to_print;
  if (strlen(title)) {
    const char border = '=';
    to_print += astring(border, int(strlen(title)) + 4);
    to_print += parser_bits::platform_eol_to_chars();
    to_print += border;
    to_print += ' ';
    to_print += title;
    to_print += ' ';
    to_print += border;
    to_print += parser_bits::platform_eol_to_chars();
    to_print += astring(border, int(strlen(title)) + 4);
    to_print += parser_bits::platform_eol_to_chars();
  }
 
  to_print += info;
  program_wide_logger::get().log(to_print, ALWAYS_PRINT);
  fflush(NULL_POINTER);  // flush all output streams.
}
 
void critical_events::alert_message(const astring &info) { alert_message(info.s()); }
 
void critical_events::alert_message(const astring &info, const astring &title)
{ alert_message(info.s(), title.s()); }
 
void critical_events::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, time_stamp::notarize(false).s());
  strcat(guards_message_space, ")\n");
  strcat(guards_message_space, info);
  strcat(guards_message_space, "\n\n\n");
}
 
void critical_events::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";
    /* why we use an exception here--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.  if not, get a new compiler,
    please. */
}
 
void critical_events::FL_deadly_error(const astring &file, int line,
    const astring &error_class, const astring &error_function,
    const astring &info)
{
  FL_deadly_error(file.s(), line, error_class.s(), error_function.s(),
      info.s()); 
}
 
void critical_events::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);
#ifdef ENABLE_CALLSTACK_TRACKING
  char *stack_trace = thread_wide_stack_trace().full_trace();
  alert_message(stack_trace, "current stack trace");
  // super important to free the space again.
  free(stack_trace);
#endif
}
 
void critical_events::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 critical_events::FL_continuable_error(const astring &file, int line,
    const astring &error_class, const astring &error_function,
    const astring &info, const astring &title)
{
  FL_continuable_error_real(file.s(), line, error_class.s(),
      error_function.s(), info.s(), title.s());
}
 
void critical_events::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 critical_events::FL_non_continuable_error(const astring &file, int line,
    const astring &error_class, const astring &error_function,
    const astring &info, const astring &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 critical_events::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 critical_events::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 critical_events::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.