core/load.c

Go to the documentation of this file.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <float.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <math.h>

#ifdef WIN32
typedef struct _stat STAT;
#define FSTAT _fstat
#define tzset _tzset
#define snprintf _snprintf
#else
#include <unistd.h>
typedef struct stat STAT;
#define FSTAT fstat
#endif

#define QNAN (sqrt(-1)) /* used to force a quiet NAN return value for bad results */

#include "object.h"
#include "load.h"
#include "output.h"
#include "random.h"
#include "convert.h"

static unsigned int linenum=0;
static char filename[1024];

static char *format_object(char *classname, int id)
{
    static char256 buffer;
    strcpy(buffer,"(unidentified)");
    sprintf(buffer,global_object_format,classname,id);
    return buffer;
}

static OBJECT **object_index = NULL;
static unsigned char *object_linked = NULL;
static unsigned int object_index_size = 65536;
/*static*/ STATUS load_set_index(OBJECT *obj, OBJECTNUM id)
{
    if (object_index==NULL)
    {
        object_index = malloc(sizeof(OBJECT*)*object_index_size);
        memset(object_index,0,sizeof(OBJECT*)*object_index_size);
        object_linked = malloc(sizeof(unsigned char)*object_index_size);
        memset(object_linked,0,sizeof(unsigned char)*object_index_size);
    }
    if (id>=object_index_size) /* index needs to grow */
    {   
        int new_size = (id/object_index_size+1)*object_index_size;
        object_index = realloc(object_index,sizeof(OBJECT*)*new_size);
        memset(object_index+object_index_size,0,sizeof(OBJECT*)*object_index_size);
        object_linked = realloc(object_linked,sizeof(unsigned char)*new_size);
        memset(object_linked+object_index_size,0,sizeof(unsigned char)*object_index_size);
        object_index_size = new_size;
    }
    if (object_index==NULL) { errno = ENOMEM; return FAILED;}
    /* collision check here */
    object_index[id] = obj;
    object_linked[id] = 0;
    return SUCCESS;
}
/*static*/ OBJECT *load_get_index(OBJECTNUM id)
{
    if (object_index==NULL || id<0 || id>=object_index_size)
        return NULL;
    object_linked[id]++;
    return object_index[id];
}
static OBJECT *get_next_unlinked(CLASS *oclass)
{
    unsigned int id;
    if (object_index==NULL)
        return NULL;
    for (id=0; id<object_index_size; id++)
    {
        if (object_linked[id]==0 && object_index[id]!=NULL && object_index[id]->oclass==oclass)
        {
            object_linked[id]++;
            return object_index[id];
        }
    }
    return NULL;
}
static void free_index(void)
{
    if (object_index!=NULL)
        free(object_index);
    object_index=NULL;
    object_index_size = 65536;
}

static UNRESOLVED *first_unresolved = NULL;
/*static*/ UNRESOLVED *add_unresolved(OBJECT *by, OBJECT **ref, CLASS *oclass, char *id, unsigned int line, int flags)
{
    UNRESOLVED *item = malloc(sizeof(UNRESOLVED));
    if (item==NULL) { errno = ENOMEM; return NULL; }
    item->by = by;
    item->ref = ref;
    item->oclass = oclass;
    strncpy(item->id,id,sizeof(item->id));
    item->line = line;
    item->next = first_unresolved;
    item->flags = flags;
    first_unresolved = item;
    return item;
}
static int resolve_list(UNRESOLVED *item)
{
    OBJECT *obj;
    char classname[33];
    char propname[33];
    OBJECTNUM id = 0;
    char op[2];
    char star;
    UNRESOLVED *next;
    while (item!=NULL)
    {   
        /* insert raw ID number here. -mh */
        
        if(0 == strcmp(item->id, "root"))
            obj = NULL;
        else if (sscanf(item->id,"%32[^.].%32[^:]:",classname,propname)==2)
        {
            char *value = strchr(item->id,':');
            FINDLIST *match;
            if (value++==NULL)
            {
                output_message("%s(%d): %s reference to %s is missing match value", filename, item->line,
                    format_object(item->by->oclass->name, item->by->id), item->id);
                return FAILED;
            }
            match = find_objects(FL_NEW,FT_CLASS,SAME,classname,AND,FT_PROPERTY,propname,SAME,value,FT_END);
            if (match==NULL || match->hit_count==0)
            {
                output_message("%s(%d): %s reference to %s does not match any existing objects", filename, item->line,
                    format_object(item->by->oclass->name, item->by->id), item->id);
                return FAILED;
            }
            else if (match->hit_count>1)
            {
                output_message("%s(%d): %s reference to %s matches more than one object", filename, item->line,
                    format_object(item->by->oclass->name, item->by->id), item->id);
                return FAILED;
            }
            obj=find_first(match);
        }
        else if (sscanf(item->id,"%[^:]:id%[+-]%d",classname,op,&id)==3)
        {
            CLASS *oclass = class_get_class_from_classname(classname);
            obj = object_find_by_id(item->by->id + (op[0]=='+'?+1:-1)*id);
            if (obj==NULL)
            {
                output_message("%s(%d): unable resolve reference from %s to %s", filename, item->line,
                    format_object(item->by->oclass->name, item->by->id), item->id);
                return FAILED;
            }
        }
        else if (sscanf(item->id,global_object_scan,classname,&id)==2)
        {
            obj = load_get_index(id);
            if (obj==NULL)
            {
                output_message("%s(%d): unable resolve reference from %s to %s", filename, item->line,
                    format_object(item->by->oclass->name, item->by->id), item->id);
                return FAILED;
            }
            if ((strcmp(obj->oclass->name,classname)!=0) && (strcmp("id", classname) != 0))
            { /* "id:###" is our wildcard.  some converters use it for dangerous simplicity. -mh */
                output_message("%s(%d): class of reference from %s to %s mismatched", filename, item->line,
                    format_object(item->by->oclass->name, item->by->id), item->id);
                return FAILED;
            }
        }
        else if (sscanf(item->id,"%[^:]:%c",classname,&star)==2 && star=='*')
        {
            CLASS *oclass = class_get_class_from_classname(classname);
            obj = get_next_unlinked(oclass);
            if (obj==NULL)
            {
                output_message("%s(%d): unable resolve reference from %s to %s", filename, item->line,
                    format_object(item->by->oclass->name, item->by->id), item->id);
                return FAILED;
            }
        }
        else if ((obj=object_find_name(item->id))!=NULL)
        {
            /* found it already*/
        }
        else
        {
            output_message("%s(%d): syntax error in reference from '%s' to '%s'", filename, item->line, object_name(item->by), item->id);
            return FAILED;
        }
        *(item->ref) = obj;
        if ((item->flags&UR_RANKS)==UR_RANKS)
            object_set_rank(obj,item->by->rank);
        next = item->next;
        free(item);
        item=next;
    }
    return SUCCESS;
}
/*static*/ int load_resolve_all()
{
    return resolve_list(first_unresolved);
}

#define PARSER char *_p
#define START int _mm=0, _m=0, _n=0, _l=linenum;
#define ACCEPT { _n+=_m; _p+=_m; _m=0; }
#define HERE (_p+_m)
#define OR {_m=0;}
#define REJECT { linenum=_l; return 0; }
#define WHITE (_m+=white(HERE))
#define LITERAL(X) (_mm=literal(HERE,(X)),_m+=_mm,_mm>0)
#define TERM(X) (_mm=(X),_m+=_mm,_mm>0)
#define COPY(X) {size--; (X)[_n++]=*_p++;}
#define DONE return _n;
#define BEGIN_REPEAT {char *__p=_p; int __mm=_mm, __m=_m, __n=_n, __l=_l; int __ln=linenum;
#define REPEAT _p=__p;_m=__m; _mm=__mm; _n=__n; _l=__l; linenum=__ln;
#define END_REPEAT }

static void syntax_error(char *p)
{
    char context[16], *nl;
    strncpy(context,p,15);
    nl = strchr(context,'\n');
    if (nl!=NULL) *nl='\0'; else context[15]='\0';
    if (strlen(context)>0)
        output_message("%s(%d): syntax error at '%s...'", filename, linenum, context);
    else
        output_message("%s(%d): syntax error", filename, linenum);
}

static int white(PARSER)
{
    if (*_p=='\0' || !isspace(*_p))
        return 0;
    if (*_p=='\n') linenum++;
    /* tail recursion to keep consuming whitespace until none left*/
    return white(_p+1)+1; 
}

static int comment(PARSER)
{
    int _n = white(_p);
    if (_p[_n]=='#')
    {
        while (_p[_n]!='\n') 
            _n++;
        linenum++;
    }
    return _n;
}

static int literal(PARSER, char *text)
{
    if (strncmp(_p,text,strlen(text))==0)
        return (int)strlen(text);
    return 0;
}

static int name(PARSER, char *result, int size)
{   /* basic name */
    START;
    while (size>1 && isalpha(*_p) || isdigit(*_p) || *_p=='_') COPY(result);
    result[_n]='\0';
    DONE;
}

static int unitspec(PARSER, UNIT **unit)
{
    char result[1024];
    int size=sizeof(result);
    START;
    while (size>1 && isalpha(*_p) || isdigit(*_p) || *_p=='*' || *_p=='/' || *_p=='^') COPY(result);
    result[_n]='\0';
    if ((*unit=unit_find(result))==NULL)
        REJECT;
    DONE;
}

static int unitsuffix(PARSER, UNIT **unit)
{
    START;
    if (LITERAL("["))
    {
        if (!TERM(unitspec(HERE,unit)))
        {
            output_message("%s(%d): missing valid unit after [", filename, linenum);
            REJECT;
        }
        if (!LITERAL("]"))
        {
            output_message("%s(%d): missing ] after unit '%s'", filename, linenum,(*unit)->name);
        }
        ACCEPT;
        DONE;
    }
    REJECT;
    DONE;
}

static int nameunit(PARSER,char *result,int size,UNIT **unit)
{
    START;
    if (TERM(name(HERE,result,size)) && unitsuffix(HERE,unit)) ACCEPT; DONE;
    REJECT;
}

static int dotted_name(PARSER, char *result, int size)
{   /* basic name */
    START;
    while (size>1 && isalpha(*_p) || isdigit(*_p) || *_p=='_' || *_p=='.') COPY(result);
    result[_n]='\0';
    DONE;
}

static int value(PARSER, char *result, int size)
{   
    /* everything to a semicolon */
    char delim=';';
    char *start=_p;
    START;
    if (*_p=='"')
    {
        delim='"';
        *_p++;
        size--;
    }
    while (size>1 && *_p!='\0' && *_p!=delim && *_p!='\n') COPY(result);
    result[_n]='\0';
    if (delim!=';')
        while (*_p!='\0' && *_p!=';' && *_p!='\n') _p++;
    return (int)(_p - start);
}

static int integer(PARSER, int64 *value)
{
    char result[256];
    int size=sizeof(result);
    START;
    while (size>1 && isdigit(*_p)) COPY(result);
    result[_n]='\0';
    *value=atoi64(result);
    return _n;
}

static int integer32(PARSER, int32 *value)
{
    char result[256];
    int size=sizeof(result);
    START;
    while (size>1 && isdigit(*_p)) COPY(result);
    result[_n]='\0';
    *value=atoi(result);
    return _n;
}

static int real(PARSER, double *value)
{
    char result[256];
    int size=sizeof(result);
    START;
    if (*_p=='+' || *_p=='-') COPY(result);
    while (size>1 && isdigit(*_p)) COPY(result);
    if (*_p=='.') COPY(result);
    while (size>1 && isdigit(*_p)) COPY(result);
    if (*_p=='E' || *_p=='e') COPY(result);
    if (*_p=='+' || *_p=='-') COPY(result);
    while (size>1 && isdigit(*_p)) COPY(result);
    result[_n]='\0';
    *value=atof(result);
    return _n;
}

static int functional(PARSER, double *pValue)
{
    char32 fname;
    double a, b;
    START;
    if WHITE ACCEPT;
    if (LITERAL("random.") && TERM(name(HERE,fname,sizeof(fname))) && LITERAL("(") && TERM(real(HERE,&a)) && LITERAL(",") && TERM(real(HERE,&b)) && LITERAL(")"))
    {
        RANDOMTYPE rtype = random_type(fname);
        if (rtype==RT_INVALID)
        {
            output_message("%s(%d): %s is not a valid random distribution", filename,linenum,fname);
            REJECT;
        }
        else
        {
            *pValue = random_value(rtype,a,b);
            ACCEPT;
        }
    } else if TERM(real(HERE,pValue)) ACCEPT
    else 
    {
        output_message("%s(%d): expected property or functional value", filename,linenum);
        REJECT;
    }
    DONE;
}

static int functional_unit(PARSER,double *pValue,UNIT **unit)
{
    START;
    if TERM(functional(HERE,pValue))
    {
        *unit = NULL;
        if WHITE ACCEPT;
        if TERM(unitspec(HERE,unit)) ACCEPT;
        ACCEPT;
        DONE;
    }
    REJECT;
}

static int time_value_seconds(PARSER, TIMESTAMP *t)
{
    START;
    if WHITE ACCEPT;
    if (TERM(integer(HERE,t)) && LITERAL("s")) { *t *= TS_SECOND; ACCEPT; DONE;}
    OR 
    if (TERM(integer(HERE,t)) && LITERAL("S")) { *t *= TS_SECOND; ACCEPT; DONE;}
    REJECT;
}

static int time_value_minutes(PARSER, TIMESTAMP *t)
{
    START;
    if WHITE ACCEPT;
    if (TERM(integer(HERE,t)) && LITERAL("m")) { *t *= 60*TS_SECOND; ACCEPT; DONE;}
    OR 
    if (TERM(integer(HERE,t)) && LITERAL("M")) { *t *= 60*TS_SECOND; ACCEPT; DONE;}
    REJECT;
}

static int time_value_hours(PARSER, TIMESTAMP *t)
{
    START;
    if WHITE ACCEPT;
    if (TERM(integer(HERE,t)) && LITERAL("h")) { *t *= 3600*TS_SECOND; ACCEPT; DONE;}
    OR 
    if (TERM(integer(HERE,t)) && LITERAL("H")) { *t *= 3600*TS_SECOND; ACCEPT; DONE;}
    REJECT;
}

static int time_value_days(PARSER, TIMESTAMP *t)
{
    START;
    if WHITE ACCEPT;
    if (TERM(integer(HERE,t)) && LITERAL("d")) { *t *= 86400*TS_SECOND; ACCEPT; DONE;}
    OR 
    if (TERM(integer(HERE,t)) && LITERAL("D")) { *t *= 86400*TS_SECOND; ACCEPT; DONE;}
    REJECT;
}

/*static*/ int time_value_datetime(PARSER, TIMESTAMP *t)
{
    int64 Y,m,d,H,M,S;
    START;
    if WHITE ACCEPT;
    if LITERAL("'") ACCEPT;
    if (TERM(integer(HERE,&Y)) && LITERAL("-")
        && TERM(integer(HERE,&m)) && LITERAL("-")
        && TERM(integer(HERE,&d)) && LITERAL(" ")
        && TERM(integer(HERE,&H)) && LITERAL(":")
        && TERM(integer(HERE,&M)) && LITERAL(":")
        && TERM(integer(HERE,&S)))
    { 
        struct tm dt = {(int)S,(int)M,(int)H,(int)d,(int)m-1,(int)Y-1900,0,0,0};
        int64 tt = mktime(&dt);
        if (tt!=-1) {*t=(int64)tt*TS_SECOND;
        ACCEPT;
        if LITERAL("'") ACCEPT;
        DONE;}
    }
    REJECT;
}

/*static*/ int time_value(PARSER, TIMESTAMP *t)
{
    START;
    if WHITE ACCEPT;
    if (TERM(time_value_seconds(HERE,t)) && WHITE,LITERAL(";")) {ACCEPT; DONE; }
    OR
    if (TERM(time_value_minutes(HERE,t)) && WHITE,LITERAL(";")) {ACCEPT; DONE; }
    OR
    if (TERM(time_value_hours(HERE,t)) && WHITE,LITERAL(";")) {ACCEPT; DONE; }
    OR
    if (TERM(time_value_days(HERE,t)) && WHITE,LITERAL(";")) {ACCEPT; DONE; }
    OR
    if (TERM(time_value_datetime(HERE,t)) && WHITE,LITERAL(";")) {ACCEPT; DONE; }
    OR
    if (TERM(integer(HERE,t)) && WHITE,LITERAL(";")) {ACCEPT; DONE; } 
    else REJECT;
    DONE;
}

/*static*/ double load_latitude(char *buffer)
{
    int32 d, m=0;
    double s=0;
    char ns;
    if((strcmp(buffer, "none") == 0) || (strcmp(buffer, "NONE") == 0)){
        return QNAN;
    }
    if (sscanf(buffer,"%d%c%d'%lf\"",&d,&ns,&m,&s)>1)
    {   
        double v = (double)d+(double)m/60+s/3600;
        if (v>=0 && v<=90)
        {
            if (ns=='S')
                return -v;
            else if (ns=='N')
                return v;
        }
    }
    output_message("%s(%d): '%s' is not a valid latitude", filename,linenum,buffer);
    return QNAN;
}

/*static*/ double load_longitude(char *buffer)
{
    int32 d, m=0;
    double s=0;
    char ns;
    if((strcmp(buffer, "none") == 0) || (strcmp(buffer, "NONE") == 0)){
        return QNAN;
    }
    if (sscanf(buffer,"%d%c%d'%lf\"",&d,&ns,&m,&s)>1)
    {   
        double v = (double)d+(double)m/60+s/3600;
        if (v>=0 && v<=180)
        {
            if (ns=='W')
                return -v;
            else if (ns=='E')
                return v;
        }
    }
    output_message("%s(%d): '%s' is not a valid longitude", filename,linenum,buffer);
    return QNAN;
}

static int clock_properties(PARSER)
{
    TIMESTAMP tsval;
    char32 timezone;
    double realval;
    START;
    if WHITE ACCEPT;
    if (LITERAL("tick") && WHITE)
    {
        if (TERM(real(HERE,&realval)) && WHITE,LITERAL(";"))
        {
            if (realval!=TS_RESOLUTION)
            {
                output_message("%s(%d): timestamp resolution %g does not match system resolution %g, this version does not support variable tick", filename, linenum, realval, TS_RESOLUTION);
                REJECT;
            }
            ACCEPT;
            goto Next;
        }
        output_message("%s(%d): expected tick value", filename, linenum);
        REJECT;
    }
    OR if (LITERAL("timestamp") && WHITE)
    {
        if (TERM(time_value(HERE,&tsval)))
        {
            global_clock = tsval;
            ACCEPT;
            goto Next;
        }
        output_message("%s(%d): expected time value", filename, linenum);
        REJECT;
    }
    OR if (LITERAL("timezone") && WHITE)
    {
        if (TERM(value(HERE,timezone,sizeof(timezone))) && WHITE,LITERAL(";") && strlen(timezone)>0)
        {
            if (timestamp_set_tz(timezone)==NULL)
                output_warning("%s(%d): timezone %s is not defined",filename,linenum,timezone);
            ACCEPT;
            goto Next;
        }
        output_message("%s(%d): expected time zone specification", filename, linenum);
        REJECT;
    }
    OR if (WHITE,LITERAL("}")) {/* don't accept yet */ DONE;}
    OR { syntax_error(HERE); REJECT; }
    /* may be repeated */
Next:
    if TERM(clock_properties(HERE)) ACCEPT;
    DONE;
}

static int clock_block(PARSER)
{
    START;
    if WHITE ACCEPT;
    if LITERAL("clock") ACCEPT else REJECT;
    if WHITE ACCEPT;
    if LITERAL("{") ACCEPT 
    else 
    {
        output_message("%s(%d): expected clock block opening {",filename,linenum);
        REJECT;
    }
    if WHITE ACCEPT;
    if TERM(clock_properties(HERE)) ACCEPT;
    if WHITE ACCEPT;
    if LITERAL("}") ACCEPT else 
    {
        output_message("%s(%d): expected clock block closing }",filename,linenum);
        REJECT;
    }
    DONE;
}

static int module_properties(PARSER, MODULE *mod)
{
    int64 val;
    CLASSNAME classname;
    char256 propname;
    char256 propvalue;
    START;
    if WHITE ACCEPT;
    if (LITERAL("major"))
    {
        if WHITE ACCEPT;
        if (TERM(integer(HERE,&val)))
        {
            if WHITE ACCEPT;
            if LITERAL(";")
            {
                if (val!=mod->major)
                {
                    output_message("%s(%d): %s has an incompatible module major version", filename,linenum,mod->name);
                    REJECT; 
                }
                ACCEPT;
                goto Next;
            }
            else
            {
                output_message("%s(%d): expected ; after %s module major number", filename,linenum, mod->name);
                REJECT; 
            }
        }
        else
        {
            output_message("%s(%d): expected %s module major number", filename,linenum, mod->name);
            REJECT; 
        }
    } 
    OR if (LITERAL("minor"))
    {
        if WHITE ACCEPT;
        if (TERM(integer(HERE,&val)))
        {
            if WHITE ACCEPT;
            if LITERAL(";")
            {
                if (val!=mod->minor)
                {
                    output_message("%s(%d): %s has an incompatible module minor version", filename,linenum,mod->name);
                    REJECT; 
                }
                ACCEPT;
                goto Next;
            }
            else
            {
                output_message("%s(%d): expected ; after %s module minor number", filename,linenum, mod->name);
                REJECT; 
            }
        }
        else
        {
            output_message("%s(%d): expected %s module minor number", filename,linenum, mod->name);
            REJECT; 
        }
    } 
    OR if (LITERAL("class"))
    {
        if WHITE ACCEPT;
        if TERM(name(HERE,classname,sizeof(classname)))
        {
            if WHITE ACCEPT;
            if LITERAL(";")
            {
                CLASS *oclass = class_get_class_from_classname(classname);
                if (oclass==NULL || oclass->module!=mod) 
                {
                    output_message("%s(%d): module '%s' does not implement class '%s'", filename, linenum, mod->name, classname);
                    REJECT; 
                }
                ACCEPT;
                goto Next;
            }
            else
            {
                output_message("%s(%d): expected ; after module %s class %s declaration", filename,linenum, mod->name, classname);
                REJECT; 
            }
        }
        else
        {
            output_message("%s(%d): missing class name in module %s class declaration", filename,linenum, mod->name);
            REJECT; 
        }
    }
    OR if (TERM(name(HERE,propname,sizeof(propname))))
    {
        if WHITE ACCEPT;
        if TERM(value(HERE,propvalue,sizeof(propvalue)))
        {
            if WHITE ACCEPT;
            if LITERAL(";")
            {
                if (module_setvar(mod,propname,propvalue)>0)
                {
                    ACCEPT;
                    goto Next;
                }
                else
                {
                    output_message("%s(%d): invalid module %s property '%s'", filename, linenum, mod->name, propname);
                    REJECT;
                }
            }
            else
            {
                output_message("%s(%d): expected ; after module %s property specification", filename, linenum, mod->name);
                REJECT;
            }
        }
        else
        {
            output_message("%s(%d): missing module %s property %s value", filename, linenum, mod->name, propname);
            REJECT;
        }
    }
    OR if LITERAL("}") {/* don't accept yet */ DONE;}
    OR { syntax_error(HERE); REJECT; }
    /* may be repeated */
Next:
    if TERM(module_properties(HERE,mod)) ACCEPT;
    DONE;
}

static int module_block(PARSER)
{
    char module_name[64];
    char fmod[8],mod[54];
    MODULE *module;
    START;
    if WHITE ACCEPT;
    if LITERAL("module") ACCEPT else REJECT;
    if WHITE ACCEPT;
    /* load options should go here and get converted to argc/argv */

    /* foreign module */
    if (TERM(name(HERE,fmod,sizeof(fmod))) && LITERAL("::") && TERM(name(HERE,mod,sizeof(mod))))
    {
        sprintf(module_name,"%s::%s",fmod,mod);
        if ((module=module_load(module_name,0,NULL))!=NULL)
        {
            ACCEPT;
        }
        else
        {
            output_message("%s(%d): %s module '%s' load failed, %s", filename, linenum, fmod, mod,strerror(errno));
            REJECT;
        }
    }

    OR 
    /* native C/C++ module */
    if (TERM(name(HERE,module_name,sizeof(module_name))))
    {
        if ((module=module_load(module_name,0,NULL))!=NULL) 
        {   
            ACCEPT;
        }
        else
        {
            output_message("%s(%d): module '%s' load failed, %s", filename, linenum, module_name,strerror(errno));
            REJECT;
        }
    }
    if WHITE ACCEPT;
    if LITERAL(";") {ACCEPT;DONE;}
    OR
    if LITERAL("{") ACCEPT 
    else 
    {
        output_message("%s(%d): expected module %s block opening {", filename, linenum, module_name);
        REJECT;
    }
    if TERM(module_properties(HERE,module)) ACCEPT else REJECT;
    if WHITE ACCEPT;
    if LITERAL("}") ACCEPT 
    else 
    {
        output_message("%s(%d): expected module %s block closing }", filename, linenum, module_name);
        REJECT;
    }
    DONE;
}

static int property_type(PARSER, PROPERTYTYPE *ptype)
{
    char32 type;
    START;
    if WHITE ACCEPT;
    if TERM(name(HERE,type,sizeof(type)))
    {
        *ptype = class_get_propertytype_from_typename(type);
        if (*ptype==PT_void) 
        {   
            output_message("%s(%d): property type %s is not recognized", filename, linenum, type);
            REJECT;
        }
        ACCEPT;
    }
    else REJECT;
    DONE;
}

static int class_properties(PARSER, CLASS *oclass)
{
    PROPERTYTYPE type;
    PROPERTYNAME propname;
    START;
    if WHITE ACCEPT;
    if (TERM(property_type(HERE,&type)) && WHITE && TERM(name(HERE,propname,sizeof(propname))) && WHITE && LITERAL(";")) 
    {
        PROPERTY *prop = class_find_property(oclass,propname);
        if (prop==NULL)
        {
            output_message("%s(%d): property %s is not defined in class %s", filename, linenum, propname, oclass->name);
            REJECT; 
        }
        else if (prop->ptype!=type) 
        {
            output_message("%s(%d): property %s is defined in class %s as type %s", filename, linenum, propname, oclass->name, class_get_property_typename(prop->ptype));
            REJECT;
        }
        ACCEPT;
    }
    else if LITERAL("}") {/* don't accept yet */ DONE;}
    else { syntax_error(HERE); REJECT; }
    /* may be repeated */
    if TERM(class_properties(HERE,oclass)) ACCEPT;
    DONE;
}

static int class_block(PARSER)
{
    CLASSNAME classname;
    CLASS *oclass;
    START;
    if WHITE ACCEPT;
    if LITERAL("class") 
    {
        if WHITE ACCEPT;
        if TERM(name(HERE,classname,sizeof(classname)))
        {
            if WHITE ACCEPT;
            if LITERAL("{")
            {
                oclass = class_get_class_from_classname(classname);
                if (oclass==NULL) REJECT;
                ACCEPT;
            } 
            else 
            {
                output_message("%s(%d): expected class %s block opening {",filename,linenum,classname);
                REJECT;
            }
        }
        else
        {
            output_message("%s(%d): expected class name",filename,linenum);
            REJECT;
        }
        if TERM(class_properties(HERE,oclass)) ACCEPT;
        if WHITE ACCEPT;
        if LITERAL("}") ACCEPT 
        else 
        {
            output_message("%s(%d): expected closing } after class block", filename, linenum);
            REJECT;
        }
    }
    else REJECT;
    DONE;
}

int set_flags(OBJECT *obj, char1024 propval)
{
    extern KEYWORD oflags[];
    if (convert_to_set(propval,&(obj->flags),object_flag_property())<=0)
    {
        output_message("%s(%d): flags of %s:%d could not be set to %s", filename, linenum, obj->oclass->name, obj->id, propval);
        return 0;
    };
    return 1;
}

static int object_properties(PARSER, CLASS *oclass, OBJECT *obj)
{
    PROPERTYNAME propname;
    char1024 propval;
    double dval;
    UNIT *unit=NULL;
    START;
    if WHITE ACCEPT;
    if TERM(dotted_name(HERE,propname,sizeof(propname)))
    {
        PROPERTY *prop = class_find_property(oclass,propname);
        if WHITE ACCEPT;
        if (prop!=NULL && prop->ptype==PT_double && TERM(functional_unit(HERE,&dval,&unit)))
        {
            if (prop==NULL)
            {
                output_message("%s(%d): property '%s' not found", filename, linenum,propname);
                REJECT;
            } else if (unit!=NULL && prop->unit!=NULL && strcmp((char *)unit, "") != 0 && unit_convert_ex(unit,prop->unit,&dval)==0)
            {
                output_message("%s(%d): units of value are incompatible with units of property, cannot convert from %s to %s", filename, linenum, unit->name,prop->unit->name);
                REJECT;
            }
            else if (object_set_double_by_name(obj,propname,dval)==0)
            {
                output_message("%s(%d): property %s of %s could not be set to '%g'", filename, linenum, propname, format_object(obj->oclass->name, obj->id), dval);
                REJECT;
            }
            else
                ACCEPT;
        }
        else if TERM(value(HERE,propval,sizeof(propval)))
        {
            if (prop==NULL)
            {
                /* check for special properties */
                if (strcmp(propname,"root")==0)
                    obj->parent = NULL;
                else if (strcmp(propname,"parent")==0)
                    add_unresolved(obj,(void*)&obj->parent,oclass,propval,linenum,UR_RANKS);
                else if (strcmp(propname,"rank")==0)
                    obj->rank = atoi(propval);
                else if (strcmp(propname,"clock")==0)
                    obj->clock = atoi64(propval);
                else if (strcmp(propname,"latitude")==0)
                    obj->latitude = load_latitude(propval);
                else if (strcmp(propname,"longitude")==0)
                    obj->longitude = load_longitude(propval);
                else if (strcmp(propname,"in")==0)
                    obj->in_svc = convert_to_timestamp(propval);
                else if (strcmp(propname,"out")==0)
                    obj->out_svc = convert_to_timestamp(propval);
                else if (strcmp(propname,"name")==0)
                    object_set_name(obj,propval);
                else if (strcmp(propname,"flags")==0)
                {
                    if(set_flags == 0)
                        REJECT;
                }
                else if (strcmp(propname,"library")==0)
                {
                    output_warning("%s(%d): libraries not yet supported", filename, linenum);
                    ACCEPT;
                    DONE;
                }
                else
                {
                    output_message("%s(%d): property %s is not defined in class %s", filename, linenum, propname, oclass->name);
                    REJECT; 
                }
            }
            else if (prop->ptype==PT_object)
            {   void *addr = object_get_addr(obj,propname);
                if (addr==NULL)
                {
                    output_message("%s(%d): unable to set parent of %s", filename, linenum, format_object(oclass->name, obj->id));
                    REJECT;
                }
                add_unresolved(obj,addr,oclass,propval,linenum,UR_NONE);
            }
            else if (object_set_value_by_name(obj,propname,propval)==0)
            {
                output_message("%s(%d): property %s of %s could not be set to '%s'", filename, linenum, propname, format_object(obj->oclass->name, obj->id), propval);
                REJECT;
            }
            ACCEPT;
        }
        if WHITE ACCEPT;
        if LITERAL(";") {ACCEPT;}
        else
        {
            output_message("%s(%d): expected ';' at end of property specification", filename,linenum);
            REJECT;
        }
    }
    else if LITERAL("}") {/* don't accept yet */ DONE;}
    else { syntax_error(HERE); REJECT; }
    /* may be repeated */
    if TERM(object_properties(HERE,oclass,obj)) ACCEPT;
    DONE;
}

static int object_name_id(PARSER,char *classname, int64 *id)
{
    START;
    if WHITE ACCEPT;
    if TERM(dotted_name(HERE,classname,sizeof(CLASSNAME)))
    {
        *id = -1; /* anonymous object */
        if LITERAL(":")
        {
            TERM(integer(HERE,id));
        }
        ACCEPT;
        DONE;
    }
    else if TERM(name(HERE,classname,sizeof(CLASSNAME)))
    {
        *id = -1; /* anonymous object */
        if LITERAL(":")
        {
            TERM(integer(HERE,id));
        }
        ACCEPT;
        DONE;
    }
    else
        REJECT;
}

static int object_name_id_range(PARSER,char *classname, int64 *from, int64 *to)
{
    START;
    if WHITE ACCEPT;
    if (TERM(dotted_name(HERE,classname,sizeof(CLASSNAME))) && LITERAL(":") && TERM(integer(HERE,from)) && LITERAL("..")) ACCEPT
    else if (TERM(name(HERE,classname,sizeof(CLASSNAME))) && LITERAL(":") && TERM(integer(HERE,from)) && LITERAL("..")) ACCEPT
    else REJECT;
    if (TERM(integer(HERE,to))) ACCEPT else 
    {
        output_message("%s(%d): expected id range end value", filename, linenum);
        REJECT;
    }
    DONE;
}

static int object_name_id_count(PARSER,char *classname, int64 *count)
{
    START;
    if WHITE ACCEPT;
    if (TERM(dotted_name(HERE,classname,sizeof(CLASSNAME))) && LITERAL(":") && LITERAL("..")) ACCEPT
    else if (TERM(name(HERE,classname,sizeof(CLASSNAME))) && LITERAL(":") && LITERAL("..")) ACCEPT
    else REJECT;
    if (TERM(integer(HERE,count))) ACCEPT else 
    {
        output_message("%s(%d): expected id count", filename, linenum);
        REJECT;
    }
    DONE;
}

static int object_block(PARSER)
{
    static OBJECT nameobj;
    CLASSNAME classname;
    CLASS *oclass;
    OBJECT *obj;
    int64 id=-1, id2=-1;
    START;
    if WHITE ACCEPT;
    if LITERAL("object") ACCEPT else REJECT
    if WHITE ACCEPT;
    if TERM(object_name_id_range(HERE,classname,&id,&id2))
    {
        oclass = class_get_class_from_classname(classname);
        if (oclass==NULL) REJECT;
        id2++;
        ACCEPT;
    }
    else if TERM(object_name_id_count(HERE,classname,&id2))
    {
        id=-1; id2--;  /* count down to zero inclusive */
        oclass = class_get_class_from_classname(classname);
        if (oclass==NULL) REJECT;
        ACCEPT;
    }
    else if TERM(object_name_id(HERE,classname,&id))
    {
        oclass = class_get_class_from_classname(classname);
        if (oclass==NULL) 
        {
            output_message("%s(%d): class '%s' is not known", filename, linenum, classname);
            REJECT;
        }
        ACCEPT;
    }
    else 
    {
        output_message("%s(%d): expected object id or range", filename, linenum);
        REJECT;
    }
    if WHITE ACCEPT;
    if (LITERAL("{")) ACCEPT else 
    {
        output_message("%s(%d): expected object block starting {", filename, linenum);
        REJECT;
    }

    /* id(s) is/are valid */
    nameobj.name = classname;
    if (id2==-1) id2=id+1; /* create singleton */
    BEGIN_REPEAT;
    while (id<id2)
    {
        REPEAT;
        obj = &nameobj;
        if ((*oclass->create)(&obj,NULL)==FAILED) REJECT;
        if (obj==NULL || obj==&nameobj) REJECT;
        if (id!=-1 && load_set_index(obj,(OBJECTNUM)id)==FAILED)
        {
            output_message("%s(%d): unable to index object id number for %s", filename, linenum, format_object(classname, (int)id));
            REJECT;
        }
        if TERM(object_properties(HERE,oclass,obj))
        {
            ACCEPT; 
        } else REJECT;
        if (id==-1) id2--; else id++;
    }
    END_REPEAT;
    if WHITE ACCEPT;
    if LITERAL("}") ACCEPT else 
    {
        output_message("%s(%d): expected object block closing }", filename, linenum);
        REJECT;
    }
    DONE;
}

static int import(PARSER)
{
    char32 modname;
    char1024 fname;
    START;
    if WHITE ACCEPT;
    if LITERAL("import") 
    {
        if WHITE ACCEPT;
        if TERM(name(HERE,modname,sizeof(modname)))
        {
            if WHITE ACCEPT;
            if TERM(value(HERE,fname,sizeof(fname)))
            {
                if LITERAL(";")
                {
                    int result;
                    MODULE *module = module_find(modname);
                    if (module==NULL)
                    {
                        output_message("%s(%d): module %s not loaded", filename, linenum, modname);
                        REJECT;
                    }
                    result = module_import(module,fname);
                    if (result < 0)
                    {
                        output_message("%s(%d): %d errors loading importing %s into %s module", filename, linenum, -result, fname, modname);
                        REJECT;
                    }
                    else if (result==0)
                    {
                        output_message("%s(%d): module %s load of %s failed; %s", filename, linenum, modname, fname, strerror(errno));
                        REJECT;
                    }
                    else
                    {
                        output_verbose("%d objects loaded to %s from %s", result, modname, fname);
                        ACCEPT;
                    }
                }
                else
                {
                    output_message("%s(%d): expected ; after module %s import from %s statement", filename, linenum, modname, fname);
                    REJECT;
                }
            }
            else
            {
                output_message("%s(%d): expected filename after module %s import statement", filename, linenum, modname);
                REJECT;
            }
        }
        else
        {
            output_message("%s(%d): expected module name after import statement", filename, linenum);
            REJECT;
        }
    }
    DONE
}

static int library(PARSER)
{
    START;
    if WHITE ACCEPT;
    if LITERAL("library")
    {
        char libname[1024];
        if WHITE ACCEPT;
        if ( TERM(dotted_name(HERE,libname,sizeof(libname))) && WHITE,LITERAL(";"))
        {
            output_warning("%s(%d): libraries not yet supported", filename, linenum);
            ACCEPT;
            DONE;
        }
        else
        {
            output_message("%s(%d): library syntax error", filename, linenum);
            REJECT;
        }
    }
    REJECT;
}

static int gridlabd_file(PARSER)
{
    START;
    if WHITE ACCEPT;
    OR if TERM(object_block(HERE)) {ACCEPT; DONE;}
    OR if TERM(class_block(HERE)) {ACCEPT; DONE;}
    OR if TERM(module_block(HERE)) {ACCEPT; DONE;}
    OR if TERM(clock_block(HERE)) {ACCEPT; DONE;}
    OR if TERM(import(HERE)) {ACCEPT; DONE; }
    OR if TERM(library(HERE)) {ACCEPT; DONE; }
    OR if (*(HERE)=='\0') {ACCEPT; DONE;}
    else REJECT;
    DONE;
}

static int suppress = 0;
static int nesting = 0;
static int macro_line[64];
static int process_macro(char *buffer, int size, char *line, char *filename, int linenum);
static int buffer_read(FILE *fp, char *buffer, char *filename, int size)
{
    char line[1024];
    int n=0;
    int linenum=0;
    while (fgets(line,sizeof(line),fp)!=NULL)
    {
        int len;
        char *c = strchr(line,'#');
        linenum++;
        if (c!=NULL) /* truncate at comment */
            strcpy(c,"\n");
        len = (int)strlen(line);
        if (len>=size-1)
            return 0;

        /* check for macros that affect reading */
        if (line[0]=='%')
        {
            /* macro disables reading */
            if (process_macro(buffer,size,line,filename,linenum)==FALSE)
                return 0;
        }

        /* if reading is enabled */
        else if (suppress==0)
        {
            strcpy(buffer,line);
            buffer+=len;
            size -= len;
            n+=len;
        }
    }
    if (nesting>0)
    {
        output_message("%s(%d): missing %%endif for %%if at %s(%d)", filename,linenum,filename,macro_line[nesting-1]);
        return -1;
    }
    return n;
}

static int include_file(char *filename, char *buffer, int size, char *offset)
{
    STAT stat;
    char *ff = find_file(filename,NULL,R_OK);
    FILE *fp;
    fp = ff?fopen(ff,"r"):NULL;
    if (fp==NULL)
    {
        output_error("include file '%s' open failed: %s", filename, strerror(errno));
        errno = 0;
        return 0;
    }
    if (FSTAT(fileno(fp),&stat)==0 && stat.st_size<size)
    {
        /* buffer = realloc(buffer,size+stat.st_size); */
        output_error("unable to grow size of read buffer for include file '%s'", filename);
        errno = 0;
        return 0;
    }
    else
    {
        output_error("unable to get size of included file '%s'", filename);
        errno = 0;
        return 0;
    }
    output_verbose("included file '%s' is %d bytes long", filename,stat.st_size);
    if (buffer==NULL)
    {
        output_error("unable to expand buffer size for file '%s': %s", filename, strerror(errno));
        errno = 0;
        return 0;
    }
    output_error("%s: include files not supported", filename);
    return 0;
}

static int process_macro(char *buffer, int size, char *line, char *filename, int linenum)
{
    if (strncmp(line,"%endif",6)==0)
    {
        if (nesting>0)
        {
            nesting--;
            suppress &= ~(1<<nesting);
            return TRUE;
        }
        else
            output_error("%s(%d): %%endif is mismatched", filename, linenum);
        return TRUE;
    }
    else if (strncmp(line,"%else",5)==0)
    {
        if ( (suppress&(1<<nesting)) == (1<<nesting) )
            suppress &= ~(1<<nesting);
        else
            suppress |= (1<<nesting);
        
    }
    else if (strncmp(line,"%ifdef",6)==0)
    {
        char *term = strchr(line+6,' ');
        char value[1024];
        if (term==NULL)
        {
            output_message("%s(%d): %%ifdef macro missing term",filename,linenum);
            return FALSE;
        }
        if (sscanf(term+1,"%[^\n]",value)==1 && global_getvar(value, NULL, 0)==NULL)
            suppress |= (1<<nesting);
        macro_line[nesting] = linenum;
        nesting++;
        return TRUE;
    }
    else if (strncmp(line,"%ifndef",7)==0)
    {
        char *term = strchr(line+7,' ');
        char value[1024];
        if (term==NULL)
        {
            output_message("%s(%d): %%ifndef macro missing term",filename,linenum);
            return FALSE;
        }
        if (sscanf(term+1,"%[^\n]",value)==1 && global_getvar(value, NULL, 0)!=NULL)
            suppress |= (1<<nesting);
        macro_line[nesting] = linenum;
        nesting++;
        return TRUE;
    }
    else if (strncmp(line,"%if",3)==0)
    {
        char var[32], op[4], *value;
        double val;
        /*output_message("%s(%d): %%if macros not supported yet", filename,linenum);
        return FALSE;*/
        if (sscanf(line+4,"%s %[!<>=] %lg",var,op,&val)!=3)
        {
            output_message("%s(%d): %%if macro statement syntax error", filename,linenum);
            return FALSE;
        }
        value = global_getvar(var, NULL, 0);
        if (value==NULL)
        {
            output_message("%s(%d): %s is not defined", filename,linenum,var);
            return FALSE;
        }
        if (strcmp(op,"<")==0) { if (!val<atof(value)) suppress|=(1<<nesting); }
        else if (strcmp(op,">")==0) { if (!val>atof(value)) suppress|=(1<<nesting); }
        else if (strcmp(op,">=")==0) { if (!val>=atof(value)) suppress|=(1<<nesting); }
        else if (strcmp(op,"<=")==0) { if (!val<=atof(value)) suppress|=(1<<nesting); }
        else if (strcmp(op,"==")==0) { if (!val==atof(value)) suppress|=(1<<nesting); }
        else if (strcmp(op,"!=")==0) { if (!val!=atof(value)) suppress|=(1<<nesting); }
        else
        {
            output_message("%s(%d): operator %s is not recognized", filename,linenum,op);
            return FALSE;
        }
        macro_line[nesting] = linenum;
        nesting++;
        return TRUE;
    }

    /* handles suppressed macros */
    if (suppress!=0)
        return TRUE;

    /* these macros can be suppressed */
    if (strncmp(line,"%include",8)==0)
    {
        char *term = strchr(line+8,' ');
        char value[1024];
        if (term==NULL)
        {
            output_message("%s(%d): %%include macro missing term",filename,linenum);
            return FALSE;
        }
        if (sscanf(term+1,"%[^\n]",value)==1 && include_file(value,buffer,size,line)<=0)
        {
            output_message("%s(%d): %%include failed",filename,linenum);
            return FALSE;
        }
        return TRUE;
    }
    else if (strncmp(line,"%define",7)==0)
    {
        char *term = strchr(line+7,' ');
        char value[1024];
        if (term==NULL)
        {
            output_message("%s(%d): %%define macro missing term",filename,linenum);
            return FALSE;
        }
        if (sscanf(term+1,"%[^\n]",value)==1 && global_setvar(value)==SUCCESS)
            return TRUE;
        else
        {
            output_message("%s(%d): %%define term not accepted",filename,linenum);
            return FALSE;
        }
    }
    else if (strncmp(line,"%print",6)==0)
    {
        char *term = strchr(line+6,' ');
        char value[1024];
        char *result;
        if (term==NULL)
        {
            output_message("%s(%d): %%print macro missing term",filename,linenum);
            return FALSE;
        }
        if (sscanf(term+1,"%[^\n]",value)==1 && (result=global_getvar(value, NULL, 0))!=NULL)
        {
            output_message("%s(%d): %s=%s", filename, linenum, value, result);
            return TRUE;
        }
        else
        {
            output_message("%s(%d): %%print term not found",filename,linenum);
            return FALSE;
        }
    }
    else
        return FALSE;
}

STATUS loadall_glm(char *file) /**< a pointer to the first character in the file name string */
{
    OBJECT *obj, *first = object_get_first();
    char *buffer = NULL, *p = NULL;
    int fsize = 0;
    STATUS status=FAILED;
    STAT stat;
    char *ext = strrchr(file,'.');
    FILE *fp;
    int move=0;

    fp = fopen(file,"r");
    if (fp==NULL) 
        goto Failed;
    if (FSTAT(fileno(fp),&stat)==0)
        buffer = malloc(fsize=stat.st_size+2);
    output_verbose("file '%s' is %d bytes long", file,fsize);
    if (buffer==NULL)
    {
        output_error("unable to allocate buffer for file '%s': %s", file, strerror(errno));
        errno = ENOMEM;
        goto Done;
    }
    else
        p=buffer;
    if (buffer_read(fp,buffer,file,fsize)==0)
    {
        fclose(fp);
        goto Failed;
    }
    fclose(fp);

    /* reset line counter for parser */
    linenum = 1;
    while (*p!='\0')
    {
        move = gridlabd_file(p);
        if (move==0)
            break;
        p+=move;
    }
    status = (*p=='\0') ? SUCCESS : FAILED;
    if (status==FAILED)
    {
        output_message("%s(%d): load failed", file, linenum);
        if (p==0)
            output_error("%s doesn't appear to be a GLM file", file);
        goto Failed;
    }
    else if ((status=load_resolve_all())==FAILED)
        goto Failed;

    /* establish ranks */
    for (obj=first?first:object_get_first(); obj!=NULL; obj=obj->next)
        object_set_parent(obj,obj->parent);
    output_verbose("%d object%s loaded", object_get_count(), object_get_count()>1?"s":"");
    goto Done;
Failed:
    if (errno!=0){
        output_error("unable to load '%s': %s", file, strerror(errno));
    }
Done:
    free(buffer);
    free_index();
    linenum=0;
    return status;
}

STATUS loadall(char *file){
    char *buffer = NULL, *p = NULL;
    char *ext = strrchr(file,'.');
    unsigned int old_obj_count = object_get_count();
    unsigned int new_obj_count = 0;
    unsigned int i;
    STATUS load_status = FAILED;

    if(old_obj_count > 1){
        output_error("loadall: only one file load is supported at this time.");
        return FAILED; /* not what they expected--do not proceed */
    }

    /* handle default extension */
    strcpy(filename,file);
    if (ext==NULL || ext<file+strlen(file)-5)
    {
        ext = filename+strlen(filename);
        strcat(filename,".glm");
    }
        
    if(ext==NULL || strcmp(ext, ".glm")==0)
        load_status = loadall_glm(filename);
    else if(strcmp(ext, ".xml")==0)
        load_status = loadall_xml(filename);
    else
        output_error("%s: unable to load unknown file type", filename, ext);
    
    new_obj_count = object_get_count();

    if((load_status == FAILED) && (old_obj_count < new_obj_count)){
        for(i = old_obj_count+1; i <= new_obj_count; ++i){
            object_remove_by_id(i);
        }
    }
    return load_status;
}

---

GridLAB-D^TM Version 1.0

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