core/globals.c

#include <stdarg.h>
#include "output.h"
#include "globals.h"
#include "module.h"

static GLOBALVAR *global_varlist = NULL, *lastvar = NULL;

static struct s_varmap {
    char *name;
    PROPERTYTYPE type;
    void *addr;
    PROPERTYACCESS access;
    char *init; /* this is not used yet */
} map[] = {
    {"version.major", PT_int32, &global_version_major, PA_REFERENCE},
    {"version.minor", PT_int32, &global_version_minor, PA_REFERENCE},
    {"command_line", PT_char1024, &global_command_line, PA_REFERENCE},
    {"environment", PT_char1024, &global_environment, PA_REFERENCE},
    {"quiet", PT_int32, &global_quiet_mode, PA_REFERENCE},
    {"warn", PT_int32, &global_warn_mode, PA_REFERENCE},
    {"debugger", PT_int32, &global_debug_mode, PA_REFERENCE},
    {"debug", PT_int32, &global_debug_output, PA_REFERENCE},
    {"test", PT_int32, &global_debug_mode, PA_REFERENCE},
    {"verbose", PT_int32, &global_verbose_mode, PA_REFERENCE},
    {"iteration_limit", PT_int32, &global_iteration_limit, PA_REFERENCE},
    {"workdir", PT_char1024, &global_workdir, PA_REFERENCE},
    {"dumpfile", PT_char1024, &global_dumpfile, PA_REFERENCE},
    {"savefile", PT_char1024, &global_savefile, PA_REFERENCE},
    {"dumpall", PT_int32, &global_dumpall, PA_REFERENCE},
    {"runchecks", PT_int32, &global_runchecks, PA_REFERENCE},
    {"threadcount", PT_int32, &global_threadcount, PA_REFERENCE},
    {"profiler", PT_int32, &global_profiler, PA_REFERENCE},
    {"pauseatexit", PT_int32, &global_pauseatexit, PA_REFERENCE},
    {"testoutputfile", PT_char1024, &global_testoutputfile, PA_REFERENCE},
    {"xml_encoding", PT_int32, &global_xml_encoding, PA_REFERENCE},
    {"clock", PT_timestamp, &global_clock, PA_REFERENCE},
    {"starttime", PT_timestamp, &global_starttime, PA_REFERENCE},
    {"stoptime", PT_timestamp, &global_stoptime, PA_REFERENCE},
    {"double_format", PT_char32, &global_double_format, PA_REFERENCE},
    {"complex_format", PT_char256, &global_complex_format, PA_REFERENCE},
    {"object_format", PT_char32, &global_object_format, PA_REFERENCE},
    {"object_scan", PT_char32, &global_object_scan, PA_REFERENCE},
    {"object_tree_balance", PT_bool, &global_no_balance, PA_REFERENCE},
    {"kmlfile", PT_char1024, &global_kmlfile, PA_REFERENCE},
    {"modelname", PT_char1024, &global_modelname, PA_REFERENCE},
    {"execdir",PT_char1024, &global_execdir, PA_REFERENCE},
    /* add new global variables here */
};

STATUS global_init(void)
{
    unsigned int i;
    for (i=0; i<sizeof(map)/sizeof(map[0]); i++)
    {
        struct s_varmap *p = &(map[i]);
        if (global_create(p->name,p->type,p->addr,PT_ACCESS,p->access,NULL)==NULL)
            output_error("global_init(): global variable '%s' registration failed", p->name);
    }
    return SUCCESS;
}

GLOBALVAR *global_find(char *name) 
{
    GLOBALVAR *var;
    for (var=global_getnext(NULL); var!=NULL; var=global_getnext(var))
    {
        if (strcmp(var->name,name)==0)
            return var;
    }
    return NULL;
}

GLOBALVAR *global_getnext(GLOBALVAR *previous) 
{
    return previous==NULL ? global_varlist : previous->next;
}

GLOBALVAR *global_create(char *name, ...)
{
    va_list arg;
    PROPERTY *property = NULL, *lastprop = NULL;
    PROPERTYTYPE proptype;

    /* allocate the global var definition */
    GLOBALVAR *var = (GLOBALVAR*)malloc(sizeof(GLOBALVAR));
    if (var==NULL)
    {
        errno = ENOMEM;
        throw_exception("global_create(char *name='%s',...): unable to allocate memory for global variable", name);
        return NULL;
    }
    strncpy(var->name,name,sizeof(var->name));
    var->prop = NULL;
    var->next = NULL;

    /* read the property args */
    va_start(arg,name);
    while ((proptype=va_arg(arg,PROPERTYTYPE))!=0)
    {
        if (proptype>_PT_LAST)
        {
            if (property==NULL)
                throw_exception("global_create(char *name='%s',...): property keyword not specified after an enumeration property definition", name);
            else if (proptype==PT_KEYWORD && property->ptype==PT_enumeration)
            {
                char *keyword = va_arg(arg,char*);
                long keyvalue = va_arg(arg,long);
                KEYWORD *key = (KEYWORD*)malloc(sizeof(KEYWORD));
                if (key==NULL) 
                    throw_exception("global_create(char *name='%s',...): property keyword could not be stored", name);
                key->next = property->keywords;
                strncpy(key->name,keyword,sizeof(key->name));
                key->value = keyvalue;
                property->keywords = key;
            }
            else if (proptype==PT_KEYWORD && property->ptype==PT_set)
            {
                char *keyword = va_arg(arg,char*);
                unsigned char keyvalue = va_arg(arg, int); /* uchars are promoted to int by GCC */
                KEYWORD *key = (KEYWORD*)malloc(sizeof(KEYWORD));
                if (keyvalue>63) 
                    throw_exception("global_create(char *name='%s',...): set '%s' keyword value '%d' may not exceed 64",name,keyword,keyvalue);
                if (key==NULL) 
                    throw_exception("global_create(char *name='%s',...): property keyword could not be stored", name);
                key->next = property->keywords;
                strncpy(key->name,keyword,sizeof(key->name));
                key->value = keyvalue;
                property->keywords = key;
            }
            else if (proptype==PT_ACCESS)
            {
                PROPERTYACCESS pa = va_arg(arg,PROPERTYACCESS); 
                switch (pa) {
                case PA_PUBLIC:
                case PA_REFERENCE:
                case PA_PROTECTED:
                case PA_PRIVATE:
                    property->access = pa;
                    break;
                default:
                    errno = EINVAL;
                    throw_exception("global_create(char *name='%s',...): unrecognized property access code (PROPERTYACCESS=%d)", name, pa);
                    break;
                }
            }
            else if (proptype==PT_SIZE)
            {
                property->size = va_arg(arg,unsigned long);
                if (property->addr==0)
                {
                    if (property->size>0)
                        property->addr = (PROPERTYADDR)malloc(property->size * property_size(property));
                    else
                        throw_exception("global_create(char *name='%s',...): property size must be greater than 0 to allocate memory", name);
                }
            }
            else
                throw_exception("global_create(char *name='%s',...): property extension code not recognized (PROPERTYTYPE=%d)", name, proptype);
        }
        else
        {
            DELEGATEDTYPE *delegation=(proptype==PT_delegated?va_arg(arg,DELEGATEDTYPE*):NULL);
            char unitspec[1024];
            if (strlen(name)>=sizeof(property->name))
                throw_exception("global_create(char *name='%s',...): property name '%s' is too big to store", name, name);
            property = (PROPERTY*)malloc(sizeof(PROPERTY));
            if (property==NULL)
                throw_exception("global_create(char *name='%s',...): property '%s' could not be stored", name, name);
            property->otype = 0;
            property->ptype = proptype;
            property->addr = va_arg(arg,PROPERTYADDR);
            property->size = 1;
            property->keywords = NULL;
            if (sscanf(name,"%[^[][%[A-Za-z0-9*/^]]",property->name,unitspec)==2)
            {
                property->unit = unit_find(unitspec);
                if (property->unit==NULL)
                    throw_exception("global_create(char *name='%s',...): property %s unit '%s' is not recognized",name, property->name,unitspec);
            }
            else
                property->unit = NULL;
            property->delegation = delegation;
            property->next = NULL;
            if (var->prop==NULL)
                var->prop = property;

            
            /* link map to oclass if not yet done */
            if (lastprop!=NULL)
                lastprop->next = property;
            else
                lastprop = property;

            /* save enum property in case keywords come up */
            if (property->ptype>_PT_LAST)
                property = NULL;
        }
    }
    va_end(arg);
    
    if (lastvar==NULL) 
        /* first variable */
        global_varlist = lastvar = var;
    else
    {   /* not first */
        lastvar->next = var;
        lastvar = var;
    }

    return var;
}

STATUS global_setvar(char *def, ...) 
{
    char name[32]="", value[1024]="";
    if (sscanf(def,"%[^=]=%[^\n]",name,value)<2)
    {
        va_list ptr;
        char *v;
        va_start(ptr,def);
        v = va_arg(ptr,char*);
        va_end(ptr);
        strncpy(value,v,sizeof(value));
        if (strcmp(value,v)!=0)
            output_error("global_setvar(char *name='%s',...): value is too long to store");
    }
    if (strcmp(name,"")!=0) /* something was defined */
    {
        GLOBALVAR *var = global_find(name);
        if (var==NULL)
            var = global_create(name,PT_char1024,NULL,PT_SIZE,1,PT_ACCESS,PA_PUBLIC,NULL);
        class_string_to_property(var->prop,(void*)var->prop->addr,value);
        return SUCCESS;
    }
    else
    {
        output_error("global variable definition '%s' not formatted correctedly", def);
        return FAILED;
    }
}

#if 0

char *global_getvar(char *name) 
{
    static char result[1024];
    GLOBALVAR *var = global_find(name);
    if (var==NULL)
        return NULL;
    if (class_property_to_string(var->prop,(void*)var->prop->addr,result,sizeof(result))>0)
        return result;
    else
        return NULL;
}
#endif

char *global_getvar(char *name, char *buffer, int size){
    static char local_buff[1024];
    char temp[1024];
    int len = 0;
    GLOBALVAR *var = NULL;
    if(buffer == NULL){
        buffer = local_buff; /* might as well hook into the old func. -mh */
        size = 1024;
    }
    if(size < 1){
        return NULL; /* user error ... could force it, but that's asking for trouble. */
    }
    var = global_find(name);
    if(var == NULL)
        return NULL;
    len = class_property_to_string(var->prop, (void *)var->prop->addr, temp, sizeof(temp));
    if(len < size){ /* if we have enough space, copy to the supplied buffer */
        strncpy(buffer, temp, len+1);
        return buffer; /* wrote buffer, return ptr for printf funcs */
    }
    return NULL; /* NULL if insufficient buffer space */
}

void global_dump(void)
{
    GLOBALVAR *var=NULL;
    while ((var=global_getnext(var))!=NULL)
    {
        char buffer[1024];
        if (class_property_to_string(var->prop, (void*)var->prop->addr,buffer,sizeof(buffer)))
            output_message("%s=%s;", var->name, buffer);
    }
}

---

GridLAB-D^TM Version 1.0

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