core/output.c

Go to the documentation of this file.

#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include "output.h"
#include "globals.h"
#include "exception.h"

static char buffer[65536];
#define CHECK 0xcdcd
int overflow=CHECK;

static struct s_redirection {
    FILE *output;
    FILE *error;
    FILE *warning;
    FILE *debug;
    FILE *verbose;
    FILE *profile;
    FILE *progress;
} redirect;
FILE* output_redirect_stream(char *name, FILE *fp)
{
    struct {
        char *name;
        FILE **file;
        char *defaultfile;
    } map[] = {
        {"output",&redirect.output,"gridlabd.out"},
        {"error",&redirect.error,"gridlabd.err"},
        {"warning",&redirect.warning,"gridlabd.wrn"},
        {"debug",&redirect.debug,"gridlabd.dbg"},
        {"verbose",&redirect.verbose,"gridlabd.inf"},
        {"profile",&redirect.profile,"gridlabd.pro"},
        {"progress",&redirect.progress,"gridlabd.prg"},
    };
    int i;
    for (i=0; i<sizeof(map)/sizeof(map[0]); i++) 
    {
        if (strcmp(name,map[i].name)==0)
        {
            char *mode = "w";
            FILE *oldfp = *(map[i].file);
            *(map[i].file) = fp;
#ifndef WIN32
            if (*(map[i].file))
                setlinebuf(*(map[i].file));
#endif
            return oldfp;
        }
    }
    return NULL;
}

void (*notify_error)(void) = NULL;
int output_notify_error(void (*notify)(void))
{
    notify_error = notify;
    return 0;
}

FILE* output_redirect(char *name, char *path)
{
    struct {
        char *name;
        FILE **file;
        char *defaultfile;
    } map[] = {
        {"output",&redirect.output,"gridlabd.out"},
        {"error",&redirect.error,"gridlabd.err"},
        {"warning",&redirect.warning,"gridlabd.wrn"},
        {"debug",&redirect.debug,"gridlabd.dbg"},
        {"verbose",&redirect.verbose,"gridlabd.inf"},
        {"profile",&redirect.profile,"gridlabd.pro"},
        {"progress",&redirect.progress,"gridlabd.prg"},
    };
    int i;
    for (i=0; i<sizeof(map)/sizeof(map[0]); i++) 
    {
        if (strcmp(name,map[i].name)==0)
        {
            char *mode = "w";
            if (*(map[i].file)!=NULL)
                fclose(*(map[i].file));
            
            /* test for append mode, path led with + */
            if (path != NULL && path[0]=='+')
            {   mode = "a";
                path++;
            }
            *(map[i].file) = fopen(path?path:map[i].defaultfile,"w");
#ifndef WIN32
            if (*(map[i].file))
                setlinebuf(*(map[i].file));
#endif
            return *(map[i].file);
        }
    }
    return NULL;
}

static FILE *curr_stream[3] = {NULL, NULL, NULL};
static int stream_prep = 0;
static void prep_stream(){
    if(stream_prep)
        return;
    stream_prep = 1;
    if(curr_stream[FS_IN] == NULL){
        curr_stream[FS_IN] = stdin;
#ifdef DEBUG
        if (global_verbose_mode) printf("    ... prep_stream() set FS_IN to stdin\n");
#endif
    }
    if(curr_stream[FS_STD] == NULL){
        curr_stream[FS_STD] = stdout;
#ifdef DEBUG
        if (global_verbose_mode) printf("    ... prep_stream() set FS_STD to stdout\n");
#endif
    }
    if(curr_stream[FS_ERR] == NULL){
        curr_stream[FS_ERR] = stderr;
#ifdef DEBUG
        if (global_verbose_mode) printf("    ... prep_stream() set FS_ERR to stderr\n");
#endif
    }
    return;
}

static int default_printstd(char *format,...)
{
    int count;
    va_list ptr;
    prep_stream();
    va_start(ptr,format);
    count = vfprintf(curr_stream[FS_STD],format,ptr);
    va_end(ptr);
    return count;
}

static int default_printerr(char *format,...)
{
    int count;
    va_list ptr;
    prep_stream();
    va_start(ptr,format);
    count = vfprintf(curr_stream[FS_ERR],format,ptr);
    va_end(ptr);
    fflush(curr_stream[FS_ERR]);
    return count;
}

FILE *output_set_stream(FILESTREAM fs, FILE *newfp){
    FILE *oldfp = curr_stream[fs];
    if(fs > FS_ERR) /* input check */
        return NULL;
    if(newfp == NULL)
        return NULL;
    curr_stream[fs] = newfp;
    return oldfp;
}

static PRINTFUNCTION printstd=default_printstd, printerr=default_printerr;

PRINTFUNCTION output_set_stdout(PRINTFUNCTION call) 
{
    PRINTFUNCTION old = printstd;
    printstd = call;
    return old;
}

PRINTFUNCTION output_set_stderr(PRINTFUNCTION call) 
{
    PRINTFUNCTION old = printerr;
    printerr = call;
    return old;
}

int output_fatal(char *format,...) 
{
    va_list ptr;

    va_start(ptr,format);
    vsprintf(buffer,format,ptr); /* note the lack of check on buffer overrun */
    va_end(ptr);

    if (redirect.error)
        return fprintf(redirect.error,"FATAL: %s\n",buffer);
    else
        return (*printerr)("FATAL: %s\n",buffer);
}

int output_error(char *format,...) 
{
    va_list ptr;

    va_start(ptr,format);
    vsprintf(buffer,format,ptr); /* note the lack of check on buffer overrun */
    va_end(ptr);

    if (notify_error!=NULL)
        (*notify_error)();

    if (redirect.error)
        return fprintf(redirect.error,"ERROR: %s\n",buffer);
    else
        return (*printerr)("ERROR: %s\n",buffer);
}

int output_test(char *format,...) 
{
    static FILE *fp = NULL;
    char minor_b[32], major_b[32];
    va_list ptr;

    va_start(ptr,format);
    vsprintf(buffer,format,ptr); /* note the lack of check on buffer overrun */
    va_end(ptr);

    if (fp==NULL)
    {
        time_t now = time(NULL);
        fp = fopen(global_getvar("testoutputfile", NULL, 0), "w"); /* new style - mh*/
        /* fp = fopen(global_testoutputfile,"w"); */ /* old style -mh */
        if (fp==NULL)
        {
            /* can't write to output file, write to stderr instead */
            return (*printerr)("TEST: %s\n",buffer);
        }
        /* fprintf(fp,"GridLAB-D Version %d.%d\n", global_version_major, global_version_minor); */
        fprintf(fp,"GridLAB-D Version %s.%s\n", global_getvar("version.major", major_b, 32), global_getvar("version.minor", minor_b, 32));
        fprintf(fp,"Test results from run started %s", asctime(localtime(&now)));
        fprintf(fp,"Command line: %s\n", global_getvar("command_line", NULL, 0));
    }

    return fprintf(fp,"%s\n", buffer);
}

int output_warning(char *format,...) 
{
    if (global_warn_mode)
    {
        va_list ptr;

        va_start(ptr,format);
        vsprintf(buffer,format,ptr); /* note the lack of check on buffer overrun */
        va_end(ptr);

        if (redirect.warning)
            return fprintf(redirect.warning,"WARNING: %s\n",buffer);
        else
            return (*printerr)("WARNING: %s\n",buffer);
    }
    return 0;
}

int output_debug(char *format,...) 
{
    if (global_debug_output)
    {
        va_list ptr;

        va_start(ptr,format);
        vsprintf(buffer,format,ptr); /* note the lack of check on buffer overrun */
        va_end(ptr);

        if (redirect.debug)
            return fprintf(redirect.debug,"DEBUG: %s\n",buffer);
        else
            return (*printerr)("DEBUG: %s\n",buffer);
    }
    return 0;
}

int output_verbose(char *format,...) 
{
    if (global_verbose_mode)
    {
        va_list ptr;

        va_start(ptr,format);
        vsprintf(buffer,format,ptr); /* note the lack of check on buffer overrun */
        va_end(ptr);

        if (redirect.verbose)
            return fprintf(redirect.verbose,"   ... %s\n",buffer);
        else
            return (*printerr)("    ... %s\n",buffer);
    }
    return 0;
}
int output_message(char *format,...) 
{
    if (!global_quiet_mode)
    {
        va_list ptr;

        va_start(ptr,format);
        vsprintf(buffer,format,ptr); /* note the lack of check on buffer overrun */
        va_end(ptr);

            if (redirect.output)
                return fprintf(redirect.output,"%s\n",buffer);
            else
                return (*printstd)("%s\n",buffer);
    }
    return 0;
}

int output_profile(char *format, ...) 
{
    char tmp[1024];
    va_list ptr;

    va_start(ptr,format);
    vsprintf(tmp,format,ptr);
    va_end(ptr);

    if (redirect.profile!=NULL)
        return fprintf(redirect.profile,"%s\n",tmp);
    else
        return output_message("%s",tmp);
}

int output_progress()
{
    char buffer[64];
    int res = 0;
    char *ts = convert_from_timestamp(global_clock,buffer,sizeof(buffer))>0?buffer:"(invalid)";
    if (redirect.progress)
    {
        res = fprintf(redirect.progress,"%s\n",ts);
        fflush(redirect.progress);
    }
    else if (global_keep_progress)
        res = output_message("Processing %s...", ts);
    else
    {
        static int len=0;
        int i=len, slen = (int)strlen(ts)+15;
        while (i--) putchar(' ');
        putchar('\r');
        if (slen>len) len=slen;
        res = output_raw("Processing %s...\r", ts);
    }
    return res;
}

int output_raw(char *format,...) 
{
    if (!global_quiet_mode)
    {
        va_list ptr;

        va_start(ptr,format);
        vsprintf(buffer,format,ptr); /* note the lack of check on buffer overrun */
        va_end(ptr);

            if (redirect.output)
            {   int len = fprintf(redirect.output,"%s",buffer);
                fflush(redirect.output);
                return len;
            }
            else
                return (*printerr)("%s",buffer);
    }
    return 0;
}

#include "module.h"

int output_xsd(char *spec)
{
    MODULE *mod = NULL;
    CLASS *oclass = NULL;
    char modulename[1024], classname[1024];
    char buffer[65536];
    /*if(sscanf(spec, "%[A-Za-z_0-9]::%[A-Za-z_0-9]:%s",modulename, submodulename, classname) == 3)
    {
        sprintf(jointname, "%s::%s", modulename, submodulename);
        mod = module_load(jointname, 0, NULL);
        if(mod == NULL){
            output_error("unable to load parent module %s", modulename);
            return 0;
        }
        
    }
    else if(sscanf(spec, "%[A-Za-z_0-9]::%[A-Za-z_0-9]",modulename, submodulename) == 2)
    {
        sprintf(jointname, "%s::%s", modulename, submodulename);
        mod = module_load(jointname, 0, NULL);
        if(mod == NULL){
            output_error("unable to load parent module %s", modulename);
            return 0;
        }
    }
    else */if (sscanf(spec,"%[A-Za-z_0-9]:%s",modulename,classname)<1)
    {
        output_error("improperly formatted XSD dump specification");
        return 0;
    }
    if (mod == NULL)
        mod = module_load(modulename,0,NULL);
    if (mod==NULL)
    {
        output_error("unable to find module '%s'", spec);
        return 0;
    }
    if (classname[0]!='\0' && (oclass=class_get_class_from_classname(classname))==NULL)
    {
        output_error("unable to find class '%s' in module '%s'", classname, modulename);
        return 0;
    }
    //if ((strlen(submodulename) > 1))
    //  strcpy(modulename, submodulename);
    output_message("<?xml version=\"1.0\" encoding=\"utf-%d\"?>",global_xml_encoding);
    output_message("<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" targetNamespace=\"http://www.w3.org/\" xmlns=\"http://www.w3.org/\" elementFormDefalt=\"qualified\">\n");
    for (oclass=(classname[0]!='\0'?oclass:class_get_first_class()); oclass!=NULL; oclass=oclass->next) 
    {
        if (class_get_xsd(oclass,buffer,sizeof(buffer))<=0)
        {
            output_error("unable to convert class '%s' to XSD", oclass->name);
            return 0;
        }
        output_message(buffer);
        if (classname[0]!='\0') 
            break;
    }
    output_message("</xs:schema>\n");
    return 0;
}

---

GridLAB-D^TM Version 1.0

An open-source project initiated by the US Department of Energy