err.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    err.h
// Purpose:     Handling of error and warning messages
// Last Change: 04.08.2017
// Language:    C++
// EMail:       brass@informatik.uni-halle.de
// WWW:         http://www.informatik.uni-halle.de/~brass/
// Address:     Feldschloesschen 15, D-06120 Halle (Saale), GERMANY
// Copyright:   (c) 2010-2017 by Stefan Brass
// License:     See file "LICENSE" for copying conditions.
// Note:        There is no warranty at all - this code may contain bugs.
// ============================================================================


//=============================================================================
// Include File Frame:
//=============================================================================

#ifndef ERR_INCLUDED
#define ERR_INCLUDED

//=============================================================================
// Used Types and Macros:
//=============================================================================

#ifndef VER_INCLUDED
#include "ver.h"
#endif

#ifndef STR_INCLUDED
#include "str.h"
#endif

#ifndef CHECK_INCLUDED
#include "check.h"
#endif

// Forward declaration, in this way we do not need to include <iostream>:
class ofstream;

//=============================================================================
// Private Constants:
//=============================================================================

//-----------------------------------------------------------------------------
// ERR_BUFSIZE: Size of buffer for a single error message.
//-----------------------------------------------------------------------------

static const int ERR_BUFSIZE = 512;
        // Note: For syntax errors this contains the error message,
        // plus the input line plus the spaces for marking the error position.
        // I.e. this must be large enough to hold three full lines.

//-----------------------------------------------------------------------------
// ERR_MAXERRS: Maximal number of error messages kept in memory.
//-----------------------------------------------------------------------------

static const int ERR_MAXERRS = 10;

//=============================================================================
// Module for Error Message Handling (Class with only static members):
//=============================================================================

class err_c {
        public:


        //=====================================================================
        // Possibility to query last error messages:
        //=====================================================================


        //---------------------------------------------------------------------
        // reset:
        //---------------------------------------------------------------------

        static void reset();

        //---------------------------------------------------------------------
        // ok:
        //---------------------------------------------------------------------

        static bool ok();

        //---------------------------------------------------------------------
        // num_errs:
        //---------------------------------------------------------------------

        static int num_errs();

        //---------------------------------------------------------------------
        // msg:
        //---------------------------------------------------------------------

        static str_t msg(int n = 0);


        //=====================================================================
        // Automatic printing of error messages (Alert-File and/or stderr):
        //=====================================================================


        //---------------------------------------------------------------------
        // open_alert:
        //---------------------------------------------------------------------

        static bool open_alert(str_t filename);

        //---------------------------------------------------------------------
        // close:
        //---------------------------------------------------------------------

        static bool close_alert();

        //---------------------------------------------------------------------
        // use_stderr:
        //---------------------------------------------------------------------

        static void use_stderr(bool b);


        //=====================================================================
        // Errors detected in mem.cpp:
        //=====================================================================


        //---------------------------------------------------------------------
        // malloc_failed:
        //---------------------------------------------------------------------

        static void malloc_failed(unsigned int chunk_size, int num_chunks);


        //=====================================================================
        // Errors detected in stack.h:
        //=====================================================================


        //---------------------------------------------------------------------
        // stack_overflow:
        //---------------------------------------------------------------------

        static void stack_overflow(str_t name, int curr_limit);


        //=====================================================================
        // Errors detected in flexarr.h:
        //=====================================================================


        //---------------------------------------------------------------------
        // flexarr_capacity_limit:
        //---------------------------------------------------------------------

        static void flexarr_capacity_limit(str_t name, int curr_length);


        //=====================================================================
        // Errors detected in list.h:
        //=====================================================================


        //---------------------------------------------------------------------
        // list_capacity_limit:
        //---------------------------------------------------------------------

        static void list_capacity_limit(str_t name, int curr_length);


        //=====================================================================
        // Errors detected in dup_2i.cpp:
        //=====================================================================


        //---------------------------------------------------------------------
        // hashtab_limit:
        //---------------------------------------------------------------------

        static void hashtab_limit(str_t tab_name, int hash_size,
                                        int hash_pages, int max_pages);


        //=====================================================================
        // Errors detected in pred.cpp:
        //=====================================================================


        //---------------------------------------------------------------------
        // pred_arity_too_large:
        //---------------------------------------------------------------------

        static void pred_arity_too_large(str_t name, int arity, int limit);

        //---------------------------------------------------------------------
        // pred_too_many_rels:
        //---------------------------------------------------------------------

        static void pred_too_many_rels(str_t name, int limit);


        //=====================================================================
        // Errors detected in in_file.cpp:
        //=====================================================================


        //---------------------------------------------------------------------
        // cgi_security:
        //---------------------------------------------------------------------

        static void cgi_security(str_t filename);

        //---------------------------------------------------------------------
        // open_failed:
        //---------------------------------------------------------------------

        static void open_failed(str_t filename, str_t msg);

        //---------------------------------------------------------------------
        // close_failed:
        //---------------------------------------------------------------------

        static void close_failed(str_t filename, str_t msg);

        //---------------------------------------------------------------------
        // read_failed:
        //---------------------------------------------------------------------

        static void read_failed(str_t filename, str_t msg);


        //=====================================================================
        // Errors detected in in_cgi.cpp:
        //=====================================================================


        //---------------------------------------------------------------------
        // bad_request_method:
        //---------------------------------------------------------------------

        static void bad_request_method();

        //---------------------------------------------------------------------
        // bad_content_type:
        //---------------------------------------------------------------------

        static void bad_content_type();

        //---------------------------------------------------------------------
        // bad_content_length:
        //---------------------------------------------------------------------

        static void bad_content_length();

        //---------------------------------------------------------------------
        // bad_cgi_hex:
        //---------------------------------------------------------------------

        static void bad_cgi_hex();

        //---------------------------------------------------------------------
        // cgi_premature_eof:
        //---------------------------------------------------------------------

        static void cgi_premature_eof();

        //---------------------------------------------------------------------
        // cgi_null_char:
        //---------------------------------------------------------------------

        static void cgi_null_char();

        //---------------------------------------------------------------------
        // cgi_field_not_terminated:
        //---------------------------------------------------------------------

        static void cgi_field_not_terminated();

        //---------------------------------------------------------------------
        // cgi_duplicate_program:
        //---------------------------------------------------------------------

        static void cgi_duplicate_program();

        //---------------------------------------------------------------------
        // cgi_no_program:
        //---------------------------------------------------------------------

        static void cgi_no_program();


        //=====================================================================
        // Errors detected in lex.cpp:
        //=====================================================================


        //---------------------------------------------------------------------
        // null_char:
        //---------------------------------------------------------------------

        static void null_char(str_t filename, int lineno);

        //---------------------------------------------------------------------
        // line_too_long:
        //---------------------------------------------------------------------

        static void line_too_long(str_t filename, int lineno);


        //=====================================================================
        // Functions for Syntax Error Messages (includes input line):
        //=====================================================================


        //---------------------------------------------------------------------
        // syntax_begin:
        //---------------------------------------------------------------------

        static void syntax_begin(str_t filename, int line, str_t msg);

        //---------------------------------------------------------------------
        // syntax_input:
        //---------------------------------------------------------------------

        static void syntax_input(char c);

        //---------------------------------------------------------------------
        // syntax_newline:
        //---------------------------------------------------------------------

        static void syntax_newline();

        //---------------------------------------------------------------------
        // syntax_eof:
        //---------------------------------------------------------------------

        static void syntax_eof();

        //---------------------------------------------------------------------
        // syntax_end:
        //---------------------------------------------------------------------

        static void syntax_end();


        //=====================================================================
        // Errors detected in load.cpp:
        //=====================================================================


        //---------------------------------------------------------------------
        // store_fact_failed:
        //---------------------------------------------------------------------

        static void store_fact_failed(str_t filename, int line_no,
                                        str_t pred_name);


        //=====================================================================
        // Errors detected in test.cpp:
        //=====================================================================


        //---------------------------------------------------------------------
        // test_has_no_arg:
        //---------------------------------------------------------------------

        static void test_has_no_arg(str_t test_id);

        //---------------------------------------------------------------------
        // invalid_test_arg:
        //---------------------------------------------------------------------

        static void invalid_test_arg(str_t test_id, int arg);


        //=====================================================================
        // Errors detected in main.cpp:
        //=====================================================================


        //---------------------------------------------------------------------
        // option_missing:
        //---------------------------------------------------------------------

        static void option_missing();

        //---------------------------------------------------------------------
        // unknown_option:
        //---------------------------------------------------------------------

        static void unknown_option(str_t arg);

        //---------------------------------------------------------------------
        // benchmark_with_debug_code:
        //---------------------------------------------------------------------

        static void benchmark_with_debug_code();

        //---------------------------------------------------------------------
        // debug_output_disabled:
        //---------------------------------------------------------------------

        static void debug_output_disabled();


        //=====================================================================
        // Functions for Dumping Data:
        //=====================================================================


        //---------------------------------------------------------------------
        // dump_begin:
        //---------------------------------------------------------------------

        static void dump_begin(str_t headline);

        //---------------------------------------------------------------------
        // dump_str:
        //---------------------------------------------------------------------

        static void dump_str(str_t str);

        //---------------------------------------------------------------------
        // dump_nl:
        //---------------------------------------------------------------------

        static void dump_nl();

        //---------------------------------------------------------------------
        // dump_char:
        //---------------------------------------------------------------------

        static void dump_char(char c);

        //---------------------------------------------------------------------
        // dump_int:
        //---------------------------------------------------------------------

        static void dump_int(int n);

        //---------------------------------------------------------------------
        // dump_uint:
        //---------------------------------------------------------------------

        static void dump_uint(unsigned int n);

        //---------------------------------------------------------------------
        // dump_bool:
        //---------------------------------------------------------------------

        static void dump_bool(bool b);

        //---------------------------------------------------------------------
        // dump_ptr:
        //---------------------------------------------------------------------

        static void dump_ptr(const void *p);

        //---------------------------------------------------------------------
        // dump_end:
        //---------------------------------------------------------------------

        static void dump_end();


//=============================================================================
// Auxillary Static Methods:
//=============================================================================

        private:

        // msg_begin: Begin construction of message in buffer.
        static void msg_begin();

        // msg_str: Add/Append string to message buffer.
        static void msg_str(str_t str);

        // msg_char: Add/Append character to message buffer.
        static void msg_char(char c);

        // msg_int: Add/Append int to message buffer.
        static void msg_int(int i);

        // msg_uint: Add/Append unsigned int to message buffer.
        static void msg_uint(unsigned int i);

        // msg_output: Output contents of message buffer.
        static void msg_output();

        // dump_output: Output a string as part of a data structure dump.
        static void dump_output(str_t str);

        // dump_flush: Make sure that dump data is really written.
        static void dump_flush();

//-----------------------------------------------------------------------------
// Class Variables:
//-----------------------------------------------------------------------------

        private:

        // UseStderr: Defines whether error messages are printed to stderr.
        static bool UseStderr;

        // Buf: Buffer for current message.
        static char Buf[ERR_BUFSIZE];

        // BufPtr: Next free position in buffer.
        static char *BufPtr;

        // BufFree: Number of free characters in buffer.
        static int BufFree;

        // NumErrs: Number of error messages after last reset().
        static int NumErrs;

        // ErrMsg: Array of last error messages.
        static char ErrMsg[ERR_MAXERRS][ERR_BUFSIZE];

//-----------------------------------------------------------------------------
// There are no objects of this class, therefore no constructor is available:
//-----------------------------------------------------------------------------

        private:

        // Constructor:
        err_c();                                // Not implemented

        // Destructor:
        ~err_c();                               // Not implemented

        // Copy-Constructor:
        err_c(const err_c& obj);                // Not implemented

        // Assignment operator:
        err_c& operator=(const err_c& obj);     // Not implemented


//-----------------------------------------------------------------------------
// End of Class:
//-----------------------------------------------------------------------------

};


//=============================================================================
// End of Include File:
//=============================================================================

#endif