edt_error.c

Go to the documentation of this file.

#include "edt_utils.h"
#include "edt_error.h"

#include <stdlib.h>
#include <string.h>

#include <stdarg.h>

#ifdef WIN32

#include <windows.h>
#include <process.h>

#else

#ifndef VXWORKS
#include <sys/errno.h>
#endif

#endif



#define MAX_MESSAGE 512


#define EDT_DEFAULT_MSG_LEVEL     \
    EDTAPP_MSG_FATAL \
    | EDTAPP_MSG_WARNING \
    | EDTLIB_MSG_FATAL \
    | EDTLIB_MSG_WARNING \
    | PDVLIB_MSG_FATAL \
    | PDVLIB_MSG_WARNING \
    | EDT_MSG_ALWAYS


static char edt_last_error_message[MAX_MESSAGE];

EdtMsgHandler edt_default_msg;
static int edt_default_msg_initialized = 0;

static int 
edt_msg_printf(void *f_p, int level,  const char *message)
{
    FILE *f = (FILE *) f_p;


    if (f)
        return fprintf(f, "%s", message);

    else
        return -1;

}

static void 
edt_msg_close_file(EdtMsgHandler *msg_p)

{
    if (msg_p->own_file && msg_p->file)
        fclose(msg_p->file);

    if (msg_p->target == msg_p->file)
        msg_p->target = NULL;

    msg_p->file = NULL;
    msg_p->own_file = 0;

}


/* copied from libedt.c, so we don't need to link to that just for this function
*/
static unsigned 
edt_err_num(void)
{
#ifdef _NT_
    return GetLastError();
#else 
    extern int errno;
    return errno;
#endif
}

static int
edt_msg_output_vprintf_perror(EdtMsgHandler *msg_p,  int level, const char *format, va_list ap)
{

    char *fullmsg; /* callers message + perror message */
    int success = -1;
    /* copy of last errno so no problem if it changes while executing this func. */
    unsigned error = edt_err_num(); 

#ifdef _NT_
    LPVOID *  lpMsgBuf;
#else
    char *errstr; /* perror message */
    extern int errno;
#endif

    if (msg_p == &edt_default_msg)
    {
        if (!edt_default_msg_initialized)
            edt_msg_init(msg_p);
    }

    if (!(level & msg_p->level))
        return 0;


    /* get caller's string...  */ 

    vsprintf(edt_last_error_message, format, ap);

    /* ... then add system error string to it. */
#ifdef _NT_

    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
        NULL,
        error,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),      /* Default language */
        (LPTSTR) & lpMsgBuf,
        0,
        NULL
        );
    /* add three for \n and ": " chars. */
    fullmsg = (char *)malloc(strlen(edt_last_error_message) + strlen( (char*)lpMsgBuf ) + 3*sizeof(char) +1);
    sprintf(fullmsg, "%s: %s\n", edt_last_error_message, (char*)lpMsgBuf);
    LocalFree(lpMsgBuf);
#else
    errstr = strerror(error);
    /* add three for \n and ": " chars. */
    fullmsg = (char *)malloc(strlen(edt_last_error_message) + strlen(errstr) + 3*sizeof(char));
    sprintf(fullmsg, "%s: %s\n", edt_last_error_message, errstr);
#endif


    if (msg_p->func) {
        success = msg_p->func(msg_p->target, level, fullmsg);
    }

    free(fullmsg);
    return success;
}



void 
edt_msg_init(EdtMsgHandler *msg_p)

{
    if (msg_p)
    {
        msg_p->file = stderr;
        msg_p->own_file = 0;
        msg_p->level = EDT_DEFAULT_MSG_LEVEL;
        msg_p->func = edt_msg_printf;
        msg_p->target = msg_p->file;
    }

    if (msg_p == &edt_default_msg)
        edt_default_msg_initialized = 1;
}


void 
edt_msg_init_names(EdtMsgHandler *msg_p, char *file, int level)

{
    edt_msg_init(msg_p);
    edt_msg_set_name(msg_p, file);
    edt_msg_set_level(msg_p, level);

}

void 
edt_msg_init_files(EdtMsgHandler *msg_p, FILE *file, int level)

{
    edt_msg_init(msg_p);
    edt_msg_set_file(msg_p, file);
    edt_msg_set_level(msg_p, level);
}



void 
edt_msg_close(EdtMsgHandler *msg_p)

{
    edt_msg_close_file(msg_p);
}



int
edt_msg(int level, const char *format, ...)
{
    va_list     stack;

    if (!edt_default_msg_initialized)
        edt_msg_init(&edt_default_msg);

    if (!(level & edt_default_msg.level))
        return 0;

    va_start(stack,     format);

    vsprintf(edt_last_error_message, format, stack);

    if (edt_default_msg.func)
        return edt_default_msg.func(edt_default_msg.target, level, edt_last_error_message);
    return -1;

}



int
edt_msg_output(EdtMsgHandler *msg_p,  int level, const char *format, ...)
{

    va_list     stack;


    if (msg_p == &edt_default_msg)
    {
        if (!edt_default_msg_initialized)
            edt_msg_init(msg_p);
    }

    if (!(level & msg_p->level))
        return 0;

    va_start(stack,     format);

    vsprintf(edt_last_error_message, format, stack);

    if (msg_p->func)
        return msg_p->func(msg_p->target, level, edt_last_error_message);

    return -1;
}




void 
edt_msg_set_level(EdtMsgHandler *msg_p, int newlevel)

{
    if ((msg_p == &edt_default_msg) && !edt_default_msg_initialized)
        edt_msg_init(&edt_default_msg);

    msg_p->level  = newlevel;

}

int 
edt_msg_get_level(EdtMsgHandler *msg_p) 
{
    return msg_p->level;
}


void 
edt_msg_add_level(EdtMsgHandler *msg_p, int level) 
{
    edt_msg_set_level(msg_p, edt_msg_get_level(msg_p) | level);
}


void 
edt_msg_set_function(EdtMsgHandler *msg_p, EdtMsgFunction f)

{
    if ((msg_p == &edt_default_msg) && !edt_default_msg_initialized)
        edt_msg_init(&edt_default_msg);

    msg_p->func = f;
}

void 
edt_msg_set_file(EdtMsgHandler *msg_p, FILE *fp)

{
    if ((msg_p == &edt_default_msg) && !edt_default_msg_initialized)
        edt_msg_init(&edt_default_msg);

    edt_msg_close_file(msg_p);

    msg_p->file = fp; 

    msg_p->own_file = 0;
}


void 
edt_msg_set_name(EdtMsgHandler *msg_p, const char *name)

{
    if ((msg_p == &edt_default_msg) && !edt_default_msg_initialized)
        edt_msg_init(&edt_default_msg);

    edt_msg_close_file(msg_p);

    msg_p->file = fopen(name, "wb");

    msg_p->own_file = (msg_p->file != NULL);
    edt_msg_set_target(msg_p, msg_p->file);

}

void 
edt_msg_set_target(EdtMsgHandler *msg_p, void *target)

{
    if ((msg_p == &edt_default_msg) && !edt_default_msg_initialized)
        edt_msg_init(&edt_default_msg);

    msg_p->target = target;
}


int
edt_msg_perror(int level, const char *msg)

{
    char message[MAX_MESSAGE];

#ifdef _NT_
    LPVOID *  lpMsgBuf;
#else
    extern int errno;
#endif

    if (!edt_default_msg_initialized)
        edt_msg_init(&edt_default_msg);

    if (!(level & edt_default_msg.level))
        return 0;

#ifdef _NT_

    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
        NULL,
        GetLastError(),
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),      /* Default language */
        (LPTSTR) & lpMsgBuf,
        0,
        NULL
        );

    sprintf(message, "%s: %s\n", msg, lpMsgBuf);
    LocalFree(lpMsgBuf);
#else
    sprintf(message, "%s: %s\n", msg, strerror(errno));
#endif
    return edt_msg(level, message);
}


int
edt_msg_output_perror(EdtMsgHandler *msg_p, int level, const char *msg)

{
    char message[MAX_MESSAGE];

#ifdef _NT_
    LPVOID *  lpMsgBuf;
#else
    extern int errno;
#endif

    if ((msg_p == &edt_default_msg) && !edt_default_msg_initialized)
        edt_msg_init(&edt_default_msg);

#ifdef _NT_

    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
        NULL,
        GetLastError(),
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),      /* Default language */
        (LPTSTR) & lpMsgBuf,
        0,
        NULL
        );

    sprintf(message, "%s: %s\n", msg, lpMsgBuf);
    LocalFree(lpMsgBuf);
#else
    sprintf(message, "%s: %s\n", msg, strerror(errno));
#endif

    return edt_msg_printf(msg_p->target, level, message);
}

int 
edt_msg_printf_perror(int level, const char *format, ...)
{
    va_list stack;
    va_start(stack, format);

    return edt_msg_output_vprintf_perror(&edt_default_msg, level, format, stack);
}


int
edt_msg_output_printf_perror(EdtMsgHandler *msg_p,  int level, const char *format, ...)
{
    va_list stack;
    va_start(stack, format);

    return edt_msg_output_vprintf_perror(msg_p, level, format, stack);
}


EdtMsgHandler *
edt_msg_default_handle()
{
    if (!edt_default_msg_initialized)
        edt_msg_init(&edt_default_msg);

    return &edt_default_msg;
}

int
edt_msg_default_level()
{
    if (!edt_default_msg_initialized)
        edt_msg_init(&edt_default_msg);

    return edt_default_msg.level;
}


char *edt_msg_last_error()
{
    return edt_last_error_message;
}

static int lvl_indent = 0;

int
lvl_printf(int delta, char *format, ...)
{
    va_list     stack;
    int i;
    char message[512];
    va_start(stack,     format);

    if (delta < 0)
        lvl_indent += delta;

    for (i=0;i<lvl_indent;i++)
        printf("    ");

    vsprintf(message, format, stack);

    printf("%s",message);
    if (delta > 0)
        lvl_indent += delta;

    return lvl_indent;
}

/*
* output message simplified - levels 0 - 3
* level 0 - fatal only
* level 1 - warnings
* level 2 - info level 1
* level 3 - info level 2
*/

void
edt_set_verbosity(int verbose)

{
    int level = edt_msg_default_level();
    if (verbose < 1)
        level = 0;
    else if (verbose > 1) /* default is slightly verbose */
    {
        level |= EDTAPP_MSG_INFO_1;
        level |= EDTLIB_MSG_INFO_1;
    }
    if (verbose > 2)
    {
        level |= EDTAPP_MSG_INFO_1
            | EDTAPP_MSG_INFO_2
            | EDTLIB_MSG_INFO_1
            | EDTLIB_MSG_INFO_2;
    }
    edt_msg_set_level(edt_msg_default_handle(), level);
}

int
edt_get_verbosity()

{
    if (edt_default_msg.level & (EDTAPP_MSG_INFO_2 | EDTLIB_MSG_INFO_2))
        return 3;
    if (edt_default_msg.level & (EDTAPP_MSG_INFO_1 | EDTLIB_MSG_INFO_1))
        return 2;
    if (edt_default_msg.level & (EDT_DEFAULT_MSG_LEVEL))
        return 1;

    return 0;

}

---