errors.c

Go to the documentation of this file.

/*
 
  $Id: errors.c 1671 2019-06-26 19:14:11Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of Linear/C3 Library.
 
  Linear/C3 Library 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, either version 3 of the License, or
  any later version.
 
  Linear/C3 Library is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.
 
  See the GNU Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public License
  along with Linear/C3 Library.  If not, see <http://www.gnu.org/licenses/>.
 
*/
 
/*
  Exception management. See "arithmetic_errors.h".
*/
 
#ifdef HAVE_CONFIG_H
    #include "config.h"
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include "boolean.h"
#include "arithmetique.h"
 
// forward declaration...
static int timeout_index;
 
// global variable to please the compiler
int linear_assertion_result = -1;
 
/* This can be overrided in the PolyLib. And seems to be according to
   gdb who cannot find the corresponding source code. */
char const *  __attribute__ ((weak))
get_exception_name(const linear_exception_t exception)
{
  if (exception==overflow_error)
    return "overflow_error exception";
  if (exception==simplex_arithmetic_error)
    return "simplex_arithmetic_error exception";
  if (exception==user_exception_error)
    return "user_exception_error exception";
  if (exception==parser_exception_error)
    return "parser_exception_error exception";
  if (exception==timeout_error)
    return "timeout_error exception";
  if (exception==any_exception_error)
    return "all exceptions mask";
 
  return "unknown or mixed exception";
}
 
/********************************************************* EXCEPTION COUNTS */
 
static unsigned int
  overflow_error_count = 0,
  simplex_error_count = 0,
  misc_error_count = 0;
 
/* reset linear counters
 */
void linear_reset_error_counters(void)
{
  overflow_error_count = 0;
  simplex_error_count = 0;
  misc_error_count = 0;
}
 
/* return number of linear errors
 * may be used as a test after a reset to know whether new errors occured.
 */
unsigned int linear_error_count(void)
{
  return overflow_error_count + simplex_error_count + misc_error_count;
}
 
/* return various errors counts through unsigned int pointer
 * overflow, simplex & misc (aka others)
 * NULL pointers are ignored
 */
void linear_get_error_counts(
  unsigned int *poe, unsigned int * pse, unsigned int *pme)
{
  if (poe) *poe = overflow_error_count;
  if (pse) *pse = simplex_error_count;
  if (pme) *pme = misc_error_count;
}
 
static void linear_record_exception(const linear_exception_t exception)
{
  if (exception==overflow_error)
    overflow_error_count ++;
  else if (exception==simplex_arithmetic_error)
    simplex_error_count ++;
  else if (exception==user_exception_error ||
           exception==parser_exception_error ||
           exception==timeout_error)
    misc_error_count ++;
}
 
/* keep track of last thrown exception for RETHROW()
 */
/* This can be overrided in the PolyLib */
linear_exception_t the_last_just_thrown_exception __attribute__ ((weak)) = 0;
 
/* whether to run in debug mode (that is to trace catch/uncatch/throw)
 */
static bool linear_exception_debug_mode = false;
static unsigned int linear_exception_verbose = 1 | 2 | 16 ;
 
/* A structure for the exception stack.
 */
typedef struct
{
  // exception type.
  int what;
 
  // where to jump to.
  jmp_buf where;
 
  // location of the CATCH to be matched against the UNCATCH.
  char const * function;
  char const * file;
  int          line;
 
  // timeout synchronisation
  int timeout;
}
  linear_exception_holder;
 
/* exception stack.
   maximum extension.
-   current index (next available bucket)
 */
#define MAX_STACKED_CONTEXTS 64
static linear_exception_holder exception_stack[MAX_STACKED_CONTEXTS];
static int exception_index = 0;
 
/* callbacks...
 */
static exception_callback_t push_callback = NULL;
static exception_callback_t pop_callback = NULL;
 
/* This can be overrided in the PolyLib */
void __attribute__ ((weak))
set_exception_callbacks(
  exception_callback_t push,
  exception_callback_t pop)
{
  if (push_callback!=NULL || pop_callback!=NULL)
  {
    fprintf(stderr, "exception callbacks already defined! (%p, %p)\n",
            push_callback, pop_callback);
    abort();
  }
 
  push_callback = push;
  pop_callback = pop;
}
 
/* total number of exceptions thrown, for statistics.
 */
/* This can be overrided in the PolyLib */
int linear_number_of_exception_thrown __attribute__ ((weak)) = 0;
 
/* dump stack
 */
/* This can be overrided in the PolyLib */
void __attribute__ ((weak))
dump_exception_stack_to_file(FILE * f)
{
  int i;
  fprintf(f, "[dump_exception_stack_to_file] size=%d\n", exception_index);
  for (i=0; i<exception_index; i++)
  {
    fprintf(f,
            "%d: [%s:%d in %s (%d)]\n",
            i,
            exception_stack[i].file,
            exception_stack[i].line,
            exception_stack[i].function,
            exception_stack[i].what);
  }
  fprintf(f, "\n");
}
 
/* This can be overrided in the PolyLib */
void __attribute__ ((weak))
dump_exception_stack(void)
{
  dump_exception_stack_to_file(stderr);
}
 
#define exception_debug_message(type)                     \
  fprintf(stderr, "%s[%s:%d %s (%d)/%d]\n",               \
            type, file, line, function, what, exception_index)
 
#define exception_debug_trace(type)   \
  if (linear_exception_debug_mode)    \
    exception_debug_message(type);
 
#ifdef push_exception_on_stack
#undef push_exception_on_stack
#endif // push_exception_on_stack
 
/* push a what exception on stack.
 */
/* This can be overrided in the PolyLib */
jmp_buf * __attribute__ ((weak))
linear_push_exception_on_stack(
    const int what,
    const char * function,
    const char * file,
    const int line)
{
  exception_debug_trace("PUSH ");
 
  if (exception_index==MAX_STACKED_CONTEXTS)
  {
    exception_debug_message("push");
    fprintf(stderr, "exception stack overflow\n");
    dump_exception_stack();
    abort();
  }
 
  if (push_callback != NULL)
    push_callback(file, function, line);
 
  the_last_just_thrown_exception = 0;
 
  exception_stack[exception_index].what = what;
  exception_stack[exception_index].function = function;
  exception_stack[exception_index].file = file;
  exception_stack[exception_index].line = line;
  exception_stack[exception_index].timeout = timeout_index;
 
  return & exception_stack[exception_index++].where;
}
 
jmp_buf * __attribute__ ((weak))
push_exception_on_stack(
    const int what,
    const char * function,
    const char * file,
    const int line)
{
  return linear_push_exception_on_stack(what, function, file, line);
}
 
 
#if !defined(same_string_p)
#define same_string_p(s1, s2) (strcmp((s1),(s2))==0)
#endif
 
#ifdef pop_exception_from_stack
#undef pop_exception_from_stack
#endif // pop_exception_from_stack
 
/* pop a what exception.
   check for any mismatch!
 */
/* This can be overrided in the PolyLib */
void __attribute__ ((weak))
linear_pop_exception_from_stack(
    const int what,
    const char * function,
    const char * file,
    const int line)
{
  exception_debug_trace("POP  ");
 
  if (exception_index==0)
  {
    exception_debug_message("pop");
    fprintf(stderr, "exception stack underflow\n");
    dump_exception_stack();
    abort();
  }
 
  if (pop_callback) pop_callback(file, function, line);
 
  exception_index--;
  the_last_just_thrown_exception = 0;
 
  if ((exception_stack[exception_index].what != what) ||
      !same_string_p(exception_stack[exception_index].file, file) ||
      !same_string_p(exception_stack[exception_index].function, function))
  {
    // internal error, UNCATCH without CATCH
    exception_debug_message("pop");
    fprintf(stderr,
            "exception stack mismatch at depth=%d:\n"
            "   CATCH: %s:%d in %s (%d)\n"
            " UNCATCH: %s:%d in %s (%d)\n",
            exception_index,
            exception_stack[exception_index].file,
            exception_stack[exception_index].line,
            exception_stack[exception_index].function,
            exception_stack[exception_index].what,
            file, line, function, what);
    dump_exception_stack();
    abort();
  }
}
 
void __attribute__ ((weak))
pop_exception_from_stack(
    const int what,
    const char * function,
    const char * file,
    const int line)
{
  linear_pop_exception_from_stack(what, function, file, line);
}
 
#ifdef throw_exception
#undef throw_exception
#endif
 
/* throws an exception of a given type by searching for
   the specified 'what' in the current exception stack.
*/
/* This can be overridden in the PolyLib */
void __attribute__ ((weak, noreturn))
linear_throw_exception(
  const int what,
  // exception location:
  const char * function,
  const char * file,
  const int line)
{
  int i;
 
  exception_debug_trace("THROW");
 
  the_last_just_thrown_exception = what; // for rethrow
  linear_record_exception(what);
 
  for (i=exception_index-1; i>=0; i--)
  {
    if (pop_callback)
      // call pop callback with push parameters
      pop_callback(exception_stack[i].file,
                   exception_stack[i].function,
                   exception_stack[i].line);
 
    if (exception_stack[i].what & what)
    {
      exception_index = i;
      linear_number_of_exception_thrown++;
 
      if (linear_exception_debug_mode)
        fprintf(stderr, "---->[%s:%d %s (%d)/%d]\n",
                exception_stack[i].file,
                exception_stack[i].line,
                exception_stack[i].function,
                exception_stack[i].what,
                i);
 
      // trace some exceptions...
      if (linear_exception_verbose & what)
        fprintf(stderr, "exception %d/%d: %s(%s:%d) -> %s(%s:%d)\n",
                what, exception_stack[i].what,
                function, file, line,
                exception_stack[i].function,
                exception_stack[i].file,
                exception_stack[i].line);
 
      // pop timeouts
      while (timeout_index > exception_stack[i].timeout)
        POP_TIMEOUT();
 
      longjmp(exception_stack[i].where, 0);
    }
  }
 
  // internal error, THROW without matching CATCH
  exception_debug_message("throw");
  fprintf(stderr,
          "exception not found in stack:\n"
          "an exception was THROWN without a matching CATCH\n");
  dump_exception_stack();
 
  // timeout triggers an exception which may be intentionnaly not caught
  if (what == timeout_error)
    exit(203);
  else
    abort();
}
 
void __attribute__ ((weak, noreturn))
throw_exception(
  const int what,
  const char * function,
  const char * file,
  const int line)
{
  linear_throw_exception(what, function, file, line);
}
 
// restart substitution
#define throw_exception linear_throw_exception
 
/* This can be overridden in the PolyLib */
void __attribute__ ((weak))
linear_initialize_exception_stack(
  unsigned int verbose_exceptions,
  exception_callback_t push,
  exception_callback_t pop)
{
  linear_exception_verbose = verbose_exceptions;
  set_exception_callbacks(push, pop);
}
 
 
/*********************************************************************** GMP */
 
static bool warned_if_inconsistent_gmp = false;
 
/* whether linear can use gmp (i.e. compiled in)
 */
bool linear_with_gmp(void)
{
#ifdef HAVE_GMP_H
  return true;
#else
  return false;
#endif // HAVE_GMP_H
}
 
/* whether linear is asked to use gmp if possible (env variable)
 */
bool linear_require_gmp(void)
{
        char* env = getenv("LINEAR_USE_GMP");
        return env && atoi(env) != 0;
}
 
/* whether linear is to use gmp
 */
bool linear_use_gmp(void)
{
  bool
    with_gmp = linear_with_gmp(),
    req_gmp = linear_require_gmp();
 
  if (req_gmp && !with_gmp && !warned_if_inconsistent_gmp)
  {
    fprintf(stderr, "linear was compiled without GMP support\n");
    warned_if_inconsistent_gmp = true;
  }
 
  return with_gmp && req_gmp;
}
 
/******************************************************** TIMEOUT MANAGEMENT */
 
/* a stack of timeouts is kept.
 * this may make sense to deal with local timeouts within linear
 * but still keeping a global outside timeout for pips.
 * on timeouts, the corresponding exception is raised... what to do
 * about it is unclear... probably the idea is to stop more or less cleanly.
 */
 
#include <time.h>
#include <signal.h>
#include <unistd.h>
#include "linear_assert.h"
 
static timeout_callback_f timeout_callback = NULL;
 
void set_timeout_callback(timeout_callback_f callback)
{
  timeout_callback = callback;
}
 
/* hold a timeout prescription
 */
typedef struct
{
  // when
  time_t start;
  time_t end;
  unsigned int delay;
  const char * env;
 
  // where it was set
  const char * funcname;
  const char * filename;
  int lineno;
 
} timeout_t;
 
#define TIMEOUT_MAX_STACK_SIZE 10
 
static timeout_t timeouts[TIMEOUT_MAX_STACK_SIZE];
static int timeout_index = 0;
 
static void __attribute__((noreturn)) timeout_handler(int sig)
{
  int toidx = timeout_index - 1;
 
  assert(sig == SIGALRM);
  assert(toidx >= 0);
 
  // always say something... even if redundant with callback
  fprintf(stderr, "timeout[%d] after %ds from %s (\"%s\":%d)\n", toidx,
          timeouts[toidx].delay,
          timeouts[toidx].funcname,
          timeouts[toidx].filename,
          timeouts[toidx].lineno);
  fflush(stderr);
 
  // note: the timeout may not return
  if (timeout_callback != NULL)
    (*timeout_callback)(timeouts[toidx].delay,
                        timeouts[toidx].funcname,
                        timeouts[toidx].filename,
                        timeouts[toidx].lineno);
 
  // may try to go on, although it is probably not a good idea
  POP_TIMEOUT();
  THROW(timeout_error);
}
 
void push_timeout(
  const unsigned int delay,
  const char * funcname,
  const char * filename,
  const int lineno)
{
  time_t now = time(NULL);
 
  assert(timeout_index < TIMEOUT_MAX_STACK_SIZE);
 
  timeouts[timeout_index].start = now;
  timeouts[timeout_index].delay = delay;
  timeouts[timeout_index].env = NULL;
  timeouts[timeout_index].end = timeouts[timeout_index].start + delay;
  timeouts[timeout_index].funcname = funcname;
  timeouts[timeout_index].filename = filename;
  timeouts[timeout_index].lineno = lineno;
 
  timeout_index++;
 
  signal(SIGALRM, timeout_handler);
  alarm(delay);
}
 
static int env2int(const char * env)
{
  char * val = getenv(env);
  if (val != NULL)
  {
    int i = atoi(val);
    if (i >= 0)
      return i;
  }
  return -1;
}
 
bool push_timeout_env(
  const char * env,
  const char * funcname,
  const char * filename,
  const int lineno)
{
  int delay = env2int(env);
  if (delay > 0)
  {
    push_timeout(delay, funcname, filename, lineno);
    timeouts[timeout_index-1].env = env;
    return true;
  }
  return false;
}
 
void pop_timeout(
  __attribute__((unused)) const char * funcname,
  __attribute__((unused)) const char * filename,
  __attribute__((unused)) const int lineno)
{
  time_t now = time(NULL);
 
  assert(timeout_index > 0);
 
  // cleanup
  alarm(0);
  signal(SIGALRM, SIG_DFL);
 
  timeout_index--;
 
  // reset to previous delay
  if (timeout_index > 0)
  {
    int delay = timeouts[timeout_index - 1].end - now;
 
    if (delay <= 0)
      timeout_handler(SIGALRM);
 
    signal(SIGALRM, timeout_handler);
    alarm(delay);
  }
}
 
void pop_timeout_env(
  const char * env,
  const char * funcname,
  const char * filename,
  const int lineno)
{
  int delay = env2int(env);
  if (delay > 0)
    pop_timeout(funcname, filename, lineno);
}