error.hh

Go to the documentation of this file.

// -*- related-file-name: "../../lib/error.cc" -*-
#ifndef CLICK_ERROR_HH
#define CLICK_ERROR_HH
#include <click/string.hh>
#if defined(CLICK_USERLEVEL) || defined(CLICK_TOOL) || defined(CLICK_MINIOS)
# include <stdio.h>
#endif
#if CLICK_BSDMODULE
# include <machine/stdarg.h>
#else
# include <stdarg.h>
#endif
 
#if HAVE_ADDRESSABLE_VA_LIST
# define VA_LIST_REF_T          va_list *
# define VA_LIST_DEREF(val)     (*(val))
# define VA_LIST_REF(val)       (&(val))
#else
# define VA_LIST_REF_T          va_list
# define VA_LIST_DEREF(val)     (val)
# define VA_LIST_REF(val)       (val)
#endif
#if __GNUC__ <= 3
# define ERRH_SENTINEL
#else
# define ERRH_SENTINEL __attribute__((sentinel))
#endif
CLICK_DECLS
 
class ErrorHandler { public:
 
    enum Level {
        el_abort = -999,        
        el_fatal = -1,          
        el_emergency = 0,       
        el_alert = 1,           
        el_critical = 2,        
        el_error = 3,           
        el_warning = 4,         
        el_notice = 5,          
        el_info = 6,            
        el_debug = 7            
    };
 
    static const char e_abort[],
        e_fatal[],
        e_emergency[],
        e_alert[],
        e_critical[],
        e_error[],
        e_warning[],
        e_warning_annotated[],
        e_notice[],
        e_info[],
        e_debug[];
 
    ErrorHandler()
        : _nerrors(0) {
    }
 
    virtual ~ErrorHandler() {
    }
 
 
    static ErrorHandler *static_initialize(ErrorHandler *errh);
 
    static void static_cleanup();
 
 
    static ErrorHandler *default_handler() {
        return the_default_handler;
    }
 
    static void set_default_handler(ErrorHandler *errh);
 
    static ErrorHandler *silent_handler() {
        return the_silent_handler;
    }
 
 
    static const int ok_result;         
    static const int error_result;      
 
 
    void debug(const char *fmt, ...);
    void message(const char *fmt, ...);
    int warning(const char *fmt, ...);
    int error(const char *fmt, ...);
    int fatal(const char *fmt, ...);
 
    void ldebug(const String &landmark, const char *fmt, ...);
    void lmessage(const String &landmark, const char *fmt, ...);
    int lwarning(const String &landmark, const char *fmt, ...);
    int lerror(const String &landmark, const char *fmt, ...);
    int lfatal(const String &landmark, const char *fmt, ...);
 
 
    int xmessage(const String &str);
    int xmessage(const String &anno, const String &str) {
        return xmessage(combine_anno(str, anno));
    }
    int xmessage(const String &anno, const char *fmt, va_list val) {
        return xmessage(anno, vformat(fmt, val));
    }
    int xmessage(const String &landmark, const String &anno,
                 const String &str) {
        return xmessage(combine_anno(anno, make_landmark_anno(landmark)), str);
    }
    int xmessage(const String &landmark, const String &anno,
                 const char *fmt, va_list val) {
        return xmessage(landmark, anno, vformat(fmt, val));
    }
 
 
    int nerrors() const {
        return _nerrors;
    }
 
 
    static String xformat(int default_flags, const char *fmt, ...);
    static String vxformat(int default_flags, const char *fmt, va_list val);
    static String xformat(const char *fmt, ...);
    static String vxformat(const char *fmt, va_list val) {
        return vxformat(0, fmt, val);
    }
 
 
    virtual String vformat(const char *fmt, va_list val);
 
    String format(const char *fmt, ...);
 
    virtual String decorate(const String &str);
 
    virtual void *emit(const String &str, void *user_data, bool more);
 
    virtual void account(int level) {
        if (level <= el_error)
            ++_nerrors;
    }
 
    virtual void clear() {
        _nerrors = 0;
    }
 
 
    static String make_anno(const char *name, const String &value);
 
    static String combine_anno(const String &str, const String &anno);
 
    static const char *parse_anno(const String &str,
                const char *begin, const char *end, ...) ERRH_SENTINEL;
 
    static const char *skip_anno(const char *begin, const char *end) {
        String name, value;
        const char *x = begin;
        do {
            x = skip_anno(String(), x, end, &name, &value, false);
        } while (name);
        return x;
    }
 
 
    static String make_landmark_anno(const String &x) {
        if (x && x[0] == '{')
            return x;
        else if (x)
            return make_anno("l", x);
        else
            return String();
    }
 
    static String clean_landmark(const String &landmark, bool colon = false);
 
 
    // error conversions
    struct Conversion;
    typedef String (*ConversionFunction)(int flags, VA_LIST_REF_T);
    enum ConversionFlags {
        cf_zero_pad = 1,        
        cf_plus_positive = 2,   
        cf_space_positive = 4,  
        cf_left_just = 8,       
        cf_alternate_form = 16, 
        cf_singlequote = 32,    
        cf_uppercase = 64,      
        cf_signed = 128,        
        cf_negative = 256,      
        cf_utf8 = 1024          
    };
    static Conversion *add_conversion(const String &name, ConversionFunction func);
    static int remove_conversion(Conversion *conversion);
 
  private:
 
    int _nerrors;
 
    static ErrorHandler *the_default_handler;
    static ErrorHandler *the_silent_handler;
 
    static const char *skip_anno(const String &str,
                                 const char *begin, const char *end,
                                 String *name_result, String *value_result,
                                 bool raw);
 
};
 
 
class SilentErrorHandler : public ErrorHandler { public:
 
    SilentErrorHandler() {
    }
 
};
 
 
class ErrorVeneer : public ErrorHandler { public:
 
    ErrorVeneer(ErrorHandler *errh)
        : _errh(errh) {
    }
 
    String vformat(const char *fmt, va_list val);
    String decorate(const String &str);
    void *emit(const String &str, void *user_data, bool more);
    void account(int level);
 
  private:
 
    ErrorHandler *_errh;
 
};
 
 
#if defined(CLICK_USERLEVEL) || defined(CLICK_TOOL) || defined(CLICK_MINIOS)
class FileErrorHandler : public ErrorHandler { public:
 
    FileErrorHandler(FILE *f, const String &prefix = String());
 
    void set_default_flags(int default_flags) {
        _default_flags = default_flags;
    }
 
    String vformat(const char *fmt, va_list val);
    void *emit(const String &str, void *user_data, bool more);
    void account(int level);
 
  private:
 
    FILE *_f;
    String _context;
    int _default_flags;
 
};
#endif
 
 
class LocalErrorHandler : public ErrorVeneer { public:
 
    LocalErrorHandler(ErrorHandler *errh)
        : ErrorVeneer(errh) {
    }
 
};
 
 
class ContextErrorHandler : public ErrorVeneer { public:
 
    ContextErrorHandler(ErrorHandler *errh, const char *fmt, ...);
 
    bool context_printed() const {
        return _context_printed;
    }
 
    void set_context_printed(bool x) {
        _context_printed = x;
    }
 
    void set_context(const String &str) {
        _context = str;
    }
 
    void set_indent(const String &str) {
        _indent = str;
    }
 
    void set_context_landmark(const String &str) {
        _context_landmark = make_landmark_anno(str);
    }
 
    String decorate(const String &str);
 
  private:
 
    String _context;
    String _indent;
    String _context_landmark;
    bool _context_printed;
 
};
 
 
class PrefixErrorHandler : public ErrorVeneer { public:
 
    PrefixErrorHandler(ErrorHandler *errh, const String &prefix);
 
    String decorate(const String &str);
 
  private:
 
    String _prefix;
 
};
 
 
class LandmarkErrorHandler : public ErrorVeneer { public:
 
    LandmarkErrorHandler(ErrorHandler *errh, const String &landmark);
 
    void set_landmark(const String &landmark) {
        _landmark = make_landmark_anno(landmark);
    }
 
    String decorate(const String &str);
 
  private:
 
    String _landmark;
 
};
 
 
#if defined(CLICK_USERLEVEL) || defined(CLICK_TOOL) || defined(CLICK_MINIOS)
class BailErrorHandler : public ErrorVeneer { public:
 
    BailErrorHandler(ErrorHandler *errh, int level = el_error);
 
    void account(int level);
 
  private:
 
    int _level;
 
};
#endif
 
#undef ERRH_SENTINEL
CLICK_ENDDECLS
#endif