/*  Last edited: Nov  8 13:51 1996 (birney) */

%{

#include "wisebase.h"



typedef int Flag;

#define MAXERROR 256
#define MAXERRORCALL 32
#define MAXMSGSTACKERROR 64

/* flags on errors */
#define ERRORUSE      1
#define ERRORTOSTDERR 2
#define ERRORTOLOG    4
#define ERRORTOCALL   8
#define LONGERROR     16 /* not used */


/* types of error */
#define FATAL    1
#define WARNING  2
#define PEDANTIC 4 /* deprecated */
#define INFO     8
#define REPORT   16

#define erroroff(type)       error_flag_off(type,ERRORUSE)
#define erroron(type)        error_flag_on (type,ERRORUSE)
#define errorcallon(type)    error_flag_on (type,ERRORTOCALL)
#define errorcalloff(type)   error_flag_off(type,ERRORTOCALL)
#define errorstderron(type)  error_flag_on (type,ERRORTOSTDERR)
#define errorstderroff(type) error_flag_off(type,ERRORTOSTDERR)
#define errorlogon(type)     error_flag_on (type,ERRORTOLOG)
#define errorlogoff(type)    error_flag_off(type,ERRORTOLOG)

%}


api
func catch_errors
func stop_catching_errors
func warn
func info
func fatal
endapi




%{
#include "wiseerror.h"

static Flag fatal_flag    = 3;
static Flag warning_flag  = 3;
static Flag info_flag     = 3;
static Flag report_flag   = 3;

#define flag_of_type(c) (c == FATAL ? fatal_flag : c == WARNING ? warning_flag :c == INFO ? info_flag : report_flag )


static int eventc=0;
static FILE * errlog=NULL;

static void (*error_call)(char *,int)= NULL;

static char * error_msg_stack[MAXMSGSTACKERROR];

static char * (*((error_msg_call)[MAXMSGSTACKERROR]))(void);
static int  msg_stack_no=0;

%func
This adds a function onto the error message
stack for stacking errors. this is for
decent parsers etc for allowing 'error scope'
to be propagated down.

It is very very bad form to push an errormsg
stack and not pop it at the end. 
%type internal
%%
boolean push_errormsg_stack(char * msg, ...)
{
  char buffer[1024];
  va_list ap;
  
  
  
  va_start(ap,msg);
  vsprintf(buffer,msg,ap);	
  
  if( msg_stack_no >= MAXMSGSTACKERROR ) {
    warn("Too many messages held on stack, [%s] discarded\n",buffer);
    /*** still should up the number ***/
    msg_stack_no++;
    return FALSE;
  }
  error_msg_call[msg_stack_no] = NULL;
  error_msg_stack[msg_stack_no++] = stringalloc(buffer);
  return TRUE;
}	

  

%func
This adds a function call for people who want
to register error handling functions

Probably best wrapped by a separate function
%%
boolean push_errormsg_stack_call( char * (*ecall)(void))
{

  if( msg_stack_no >= MAXMSGSTACKERROR ) {
    warn("Too many messages held on stack, Error message call discarded\n");
    /*** still should up the number ***/
    msg_stack_no++;
    return FALSE;
  }
  error_msg_call[msg_stack_no] = ecall;
  error_msg_stack[msg_stack_no++] = NULL;
  return TRUE;
}

%func
This removes a error message from the stack
%%
void pop_errormsg_stack(void)
{
  if( msg_stack_no < MAXMSGSTACKERROR && msg_stack_no > 0 && error_msg_stack[msg_stack_no-1] != NULL)
    ckfree(error_msg_stack[msg_stack_no-1]);
  if( msg_stack_no > 0)
    msg_stack_no--;
}

%func
This shows the error message set to
everyone 
%type internal
%%
void show_message_stack(FILE * ofp)
{
  register int i;
  register int j;
  register int count;
  
  for(i=0;i<msg_stack_no;i++) {
    if( error_msg_call[i] != NULL ) {
      show_text( (*(error_msg_call[i]))(),65,ofp);
    } else {
      show_text(error_msg_stack[i],65,ofp);
    }
  }
}


%func
Makes ofp the log file for the errors. Discards
any previous one
%type internal
%%
void add_log_file(FILE * ofp)
{
  /* you must also switch on logging errors as well! */

  errlog=ofp;
}


%func
Opens filename as the log file. 
%%
boolean add_log_filename(char * filename)
{
  register FILE * ofp;
  if( (ofp=openfile(filename,"w")) == NULL) {
    warn("Could not open %s as a log filename",filename);
    return FALSE;
  }
  
  add_log_file(ofp);
  return TRUE;
}

%func
Really for the API. Wraps some
of the error concepts..
%%
void error_off(int type)
{
  error_flag_off(type,ERRORUSE);
}

%func
Really for the API. Wraps some
of the error concepts..
%%
void error_on(int type)
{
  error_flag_on(type,ERRORUSE);
}


%func
Turns on the particular type of error flag
(eg, STDERR etc). 
%%
void error_flag_on(int type,Flag f)
{
  switch (type) {
    case FATAL    : fatal_flag     = fatal_flag | f; return;
    case WARNING  : warning_flag   = warning_flag | f; return;
    case INFO     : info_flag      = info_flag | f; return;
    case REPORT   : report_flag    = report_flag | f ; return;
    default : log_full_error(WARNING,0,"In error system, tried to change flag %d which doesn't exist!",type); return;
      
    }
}

%func
Turns off the particular type of error flag
(eg, STDERR etc). 
%%
void error_flag_off(int type,Flag f)
{
  switch (type) {
    case FATAL    : fatal_flag     = fatal_flag & ~f; return;
    case WARNING  : warning_flag   = warning_flag & ~f; return;
    case INFO     : info_flag      = info_flag & ~f; return;
    case REPORT   : report_flag    = report_flag & ~f ; return;
    default : log_full_error(WARNING,0,"In error system, tried to change flag %d which doesn't exist!",type); return;
    }
}

%func
This is a wrapper for the error handling
system. It does the following things

Sets function as the function to process errors

Switches the INFO,ERROR and FATAL flags off on STDERR
and on to ERROR CALL.
%arg
catch fN
%%
boolean catch_errors(void (*catch)(char *,int))
{
  erroron(INFO);
  erroron(WARNING);
  erroron(FATAL);

  errorstderroff(INFO);
  errorstderroff(WARNING);
  errorstderroff(FATAL);

  errorcallon(INFO);
  errorcallon(WARNING);
  errorcallon(FATAL);

  push_error_call(catch);

  return TRUE;
}

%func
Switches off error catching,
putting flags back on to STDERR
%%
boolean stop_catching_errors(void)
{
  errorstderron(INFO);
  errorstderron(WARNING);
  errorstderron(FATAL);

  errorcalloff(INFO);
  errorcalloff(WARNING);
  errorcalloff(FATAL);

  pop_error_call();

  return TRUE;
}

%func
Registers this function for dealing with errors

Try to use catch_errors instead

%%
void push_error_call(void (* func)(char *,int))
{	
  error_call=func;
}

%func
Discards current function for dealing with errors
%%
void pop_error_call(void)
{
  error_call=NULL;
}

%func
Turns int error types to Names
for display purposes.
%%
char * type_to_error(int type)
{
  switch (type) {
  case FATAL :  return "Fatal Error";
  case WARNING : return "Warning Error";
  case INFO   :  return "Information";
  default	: return "Strange error type???";
  }
}

%func
Produces a 'info' error message.
%%
void info(char * msg, ...)
{
  char buffer[1024];
  va_list ap;
  int type = INFO;
  
  va_start(ap,msg);
  vsprintf(buffer,msg,ap);
  
  eventc++;	
  
  show_error(flag_of_type(type),buffer,type);
  
  return;
}		

%func
Produces a 'warn' error message.
%%
void warn(char * msg, ...)
{
  char buffer[1024];
  va_list ap;
  int type = WARNING;
  
  va_start(ap,msg);
  vsprintf(buffer,msg,ap);
  
  eventc++;	
  
  show_error(flag_of_type(type),buffer,type);
  
  return;
}		

%func
Produces a 'fatal' error message.
%%
void fatal(char * msg, ...)
{
  char buffer[1024];
  va_list ap;
  int type = FATAL;
  
  va_start(ap,msg);
  vsprintf(buffer,msg,ap);
  
  eventc++;	
  
  show_error(flag_of_type(type),buffer,type);
  fputc('\n',stderr);
  exit(2);
  
  return;
}		

%func
Deprecated

produces any of the error types
%%
void log_full_error(int type,int location,char * msg, ...)
{
  char buffer[1024];
  va_list ap;
  
  va_start(ap,msg);
  vsprintf(buffer,msg,ap);
  
  eventc++;
  
  if(type == FATAL) {
    show_error(fatal_flag,buffer,FATAL);
    fputc('\n',stderr);
    exit(2);
  }
  
  show_error(flag_of_type(type),buffer,type);
  
  return;
}		

%func
Starts a % reporting run. This is the header message
%%
void start_reporting(char * msg,...)
{
  char buffer[1024];
  va_list ap;
  
  if( !(report_flag & ERRORUSE) )
    return;
  
  va_start(ap,msg);
  vsprintf(buffer,msg,ap);
  
  fputs(buffer,stderr);
  start_overlay(stderr);
}

%func
Stops a % reporting run. 
%%
void stop_reporting(void)
{
  
  if( !(report_flag & ERRORUSE) )
    return;
  stop_overlay();
}

%func
Actually shows the error
%type internal
%%
void show_error(Flag flag,char * othermsg,int type)
{
  if( !(flag & ERRORUSE) )
    return;

  
  if( type == REPORT ) {
    print_overlay(othermsg);
    return;
  }
  
  if(flag&ERRORTOSTDERR) {
      fputs(type_to_error(type),stderr);
      fputc('\n',stderr);
      if( msg_stack_no > 0 )
	show_message_stack(stderr);
      fputs("\t",stderr);
      if( type == FATAL )
	fputs(othermsg,stderr);
      else	show_text(othermsg,70,stderr);
  }
  
  if( flag&ERRORTOLOG && errlog != NULL) {
    fputs(type_to_error(type),errlog);
    fputc('\n',stderr);
    if( msg_stack_no > 0 )
      show_message_stack(errlog);
    fputs("\n\t",errlog);
    show_text(othermsg,70,errlog);
  }
	
  if( flag&ERRORTOCALL && error_call != NULL)
    {
      (*(error_call))(othermsg,type);
    }
  
  
  
  return;
}


%}