core/find.c

Go to the documentation of this file.

#include <ctype.h>
#ifdef WIN32
  #include <io.h>
#else
  #include <unistd.h>
#endif
#include "globals.h"
#include "output.h"
#include "find.h"
#include "aggregate.h"
#include "module.h"

static FINDTYPE invar_types[] = {FT_ID, FT_SIZE, FT_CLASS, FT_PARENT, FT_RANK, FT_NAME, FT_LAT, FT_LONG, FT_INSVC, FT_OUTSVC, FT_MODULE, 0};

static int compare_int(int64 a, FINDOP op, int64 b)
{
    switch (op) {
    case EQ: return a==b;
    case LT: return a<b;
    case GT: return a>b;
    case LE: return a<=b;
    case GE: return a>=b;
    case NE: return a!=b;
    default:
        output_error("compare op %d not supported on integers", op);
        return 0;
    }
}

static int compare_int64(int64 a, FINDOP op, int64 b){
    return compare_int(a, op, b);
}

static int compare_int32(int32 a, FINDOP op, int64 b)
{
    switch (op) {
    case EQ: return a==b;
    case LT: return a<b;
    case GT: return a>b;
    case LE: return a<=b;
    case GE: return a>=b;
    case NE: return a!=b;
    default:
        output_error("compare op %d not supported on integers", op);
        return 0;
    }
}

static int compare_int16(int16 a, FINDOP op, int64 b)
{
    switch (op) {
    case EQ: return a==b;
    case LT: return a<b;
    case GT: return a>b;
    case LE: return a<=b;
    case GE: return a>=b;
    case NE: return a!=b;
    default:
        output_error("compare op %d not supported on integers", op);
        return 0;
    }
}

static int compare_double(double a, FINDOP op, double b)
{
    switch (op) {
    case EQ: return a==b;
    case LT: return a<b;
    case GT: return a>b;
    case LE: return a<=b;
    case GE: return a>=b;
    case NE: return a!=b;
    default:
        output_error("compare op %d not supported on doubles", op);
        return 0;
    }
}

static int compare_string(char *a, FINDOP op, char *b)
{
    switch (op) {
    case SAME: op=EQ; goto CompareInt;
    case BEFORE: op=LT; goto CompareInt;
    case AFTER: op=GT; goto CompareInt;
    case DIFF: op=NE; goto CompareInt;
    case LIKE: return match(a, b);
    case EQ:
    case LT:
    case GT:
    case LE:
    case GE:
    case NE:
        if (!(isdigit(a[0])||a[0]=='+'||a[0]=='-')&&!(isdigit(b[0])||b[0]=='+'||b[0]=='-'))
            output_warning("compare of strings using numeric op usually does not work");
        return compare_double(atof(a),op,atof(b));
    default:
        output_error("compare op %d not supported on strings", op);
        return 0;
    }
CompareInt:
    return compare_int((int64)strcmp(a,b),op,0);

}

static int compare_property(OBJECT *obj, char *propname, FINDOP op, void *value)
{
    char *propval = object_property_to_string(obj,propname);
    if (propval==NULL) return 0;
    return compare_string(propval,op,(char*)value);
}

static int compare_property_alt(OBJECT *obj, char *propname, FINDOP op, void *value){
    complex *complex_target = NULL;
    char *char_target = NULL;
    int16 *int16_target = NULL;
    int32 *int32_target = NULL;
    int64 *int64_target = NULL;
    PROPERTY *prop = object_get_property(obj, propname);
    switch(prop->ptype){
        case PT_void:
            return 0;   /* no comparsion to be made */
        case PT_double:
            break;
        case PT_complex:
            complex_target = object_get_complex(obj, prop);
            if(complex_target == NULL)
                return 0; /* error value */
            break;
        case PT_enumeration:
        case PT_set:
            break;      /* not 100% sure how to make these cooperate yet */
        case PT_int16:
            int16_target = (int16 *)object_get_int16(obj, prop);
            if(int16_target == NULL)
                return 0;
            return compare_int16(*int16_target, op, *(int64 *)value);
        case PT_int32:
            int32_target = (int32 *)object_get_int32(obj, prop);
            return compare_int32(*int32_target, op, *(int64 *)value);
            break;
        case PT_int64:
            int64_target = (int64 *)object_get_int64(obj, prop);
            return compare_int64(*int64_target, op, *(int64 *)value);
            break;
        case PT_char8:
        case PT_char32:
        case PT_char256:
        case PT_char1024:
            char_target = (char *)object_get_string(obj, prop);
            if(char_target == NULL)
                return 0;
            return compare_string(char_target, op, value);
            break;
        case PT_object:

            break;
        case PT_bool:
            break;
        case PT_timestamp:
        case PT_double_array:
        case PT_complex_array:
            break;
#ifdef USE_TRIPLETS
        case PT_triple:
        case PT_triplex:
            break;
#endif
        default:
            output_error("");
            return 0;
    }
}

static int compare(OBJECT *obj, FINDTYPE ftype, FINDOP op, void *value, char *propname)
{
    switch (ftype) {
    case FT_ID: return compare_int((int64)obj->id,op,(int64)*(OBJECTNUM*)value);
    case FT_SIZE: return compare_int((int64)obj->size,op,(int64)*(int*)value);
    case FT_CLASS: return compare_string((char*)obj->oclass->name,op,(char*)value);
    case FT_MODULE: return compare_string((char*)obj->oclass->module->name,op,(char*)value);
    case FT_RANK: return compare_int((int64)obj->rank,op,(int64)*(int*)value);
    case FT_CLOCK: return compare_int((int64)obj->clock,op,(int64)*(TIMESTAMP*)value);
    case FT_PROPERTY: return compare_property(obj,propname,op,value);
    default:
        output_error("findtype %s not supported", ftype);
        return 0;
    }
}

FINDLIST *new_list(unsigned int n)
{
    unsigned int size = (n>>3)+1;
    FINDLIST *list = malloc(sizeof(FINDLIST)+size-1);
    if (list==NULL)
    {
        errno=ENOMEM;
        return NULL;
    }
    memset(list->result,0,size);
    list->result_size = size;
    list->hit_count = 0;
    return list;
}
#define SIZE(L) ((L).result_size)
#define COUNT(L) ((L).hit_count)
#define FOUND(L,N) (((L).result[(N)>>3]&(1<<((N)&0x7)))!=0)
#define ADDOBJ(L,N) (!FOUND((L),(N))?((L).result[(N)>>3]|=(1<<((N)&0x7)),++((L).hit_count)):(L).hit_count)
#define DELOBJ(L,N) (FOUND((L),(N))?((L).result[(N)>>3]&=~(1<<((N)&0x7)),--((L).hit_count)):(L).hit_count)
#define ADDALL(L) ((L).hit_count=object_get_count(),memset((L).result,0xff,(L).result_size))
#define DELALL(L) ((L).hit_count=object_get_count(),memset((L).result,0x00,(L).result_size))

FINDLIST *find_runpgm(FINDLIST *list, FINDPGM *pgm);
FINDPGM *find_mkpgm(char *expression);

FINDLIST *find_objects(FINDLIST *start, ...)
{
    OBJECT *obj;
    FINDLIST *result = start;
    if (start==FL_NEW || start==FL_GROUP)
    {
        result=new_list(object_get_count());
        ADDALL(*result);
    }
    /* FL_GROUP is something of an interrupt option that constructs a program by parsing string input. */
    if (start==FL_GROUP)
    {
        FINDPGM *pgm;
        va_list(ptr);
        va_start(ptr,start);
        pgm = find_mkpgm(va_arg(ptr,char*));
        if (pgm!=NULL){
            return find_runpgm(result,pgm);
        } else {
            va_end(ptr);
            DELALL(*result); /* pgm == NULL */
            return result;
        }
    }
    /* if we're not using FL_GROUP, we break apart the va_arg list, taking data inputs in the "correct" type. */
    for (obj=object_get_first(); obj!=NULL; obj=obj->next)
    {
        FINDTYPE ftype;
        va_list(ptr);
        va_start(ptr,start);
        while ((ftype=va_arg(ptr,FINDTYPE)) != FT_END)
        {
            int invert=0;
            int parent=0;
            FINDOP conj=AND;
            FINDOP op;
            char *propname = NULL;
            void *value;
            OBJECT *target=obj;

            /* conjunction */
            if (ftype==AND || ftype==OR)
            {   /* expect another op */
                conj=ftype;
                ftype = va_arg(ptr, FINDTYPE);
            }

            /* follow to parent */
            while (ftype==FT_PARENT)
            {
                ftype=va_arg(ptr,FINDTYPE);
                parent++;
            }

            /* property option require property name */
            if (ftype==FT_PROPERTY)
                propname=va_arg(ptr,char*);

            /* read operation */
            op = va_arg(ptr,FINDOP);

            /* negation */
            if (op==NOT)
            {   /* expect another op */
                invert=1;
                op = va_arg(ptr,FINDOP);
            }

            /* read value */
            switch (ftype) {
                static int ival;
                static char *sval;
                static OBJECTNUM oval;
                static TIMESTAMP tval;
                static double rval;
            case FT_PARENT:
            case FT_ID:
                oval = va_arg(ptr,OBJECTNUM);
                value = &oval;
                break;
            case FT_SIZE:
            case FT_RANK:
                ival = va_arg(ptr,int);
                value = &ival;
                break;
            case FT_INSVC:
            case FT_OUTSVC:
            case FT_CLOCK:
                tval = va_arg(ptr,TIMESTAMP);
                value = &tval;
                break;
            case FT_LAT:
            case FT_LONG:
                rval = va_arg(ptr, double);
                value = &rval;
                break;
            case FT_CLASS:
            case FT_NAME:
            case FT_PROPERTY:
            case FT_MODULE:
                sval = va_arg(ptr,char*);
                value = sval;
                break;
            default:
                output_error("invalid findtype means search is specified incorrectly or FT_END is probably missing");
                if (start == FL_NEW) free(result);
                return NULL;
            }

            /* follow target to parent */
            while (parent-- > 0 && target != NULL)
                target = target->parent;

            /* if target exists */
            if (target != NULL)
            {
                /* match */
                if (compare(target,ftype,op,value,propname)!=invert)
                {
                    if (conj==OR) 
                        ADDOBJ(*result,obj->id);
                }
                else
                {
                    if (conj==AND) 
                        DELOBJ(*result,obj->id);
                }
            }
        }
        va_end(ptr);
    }
    return result;
}

int find_makearray(FINDLIST *list, 
                   OBJECT ***objs) 
{
    OBJECT *obj=find_first(list);
    int n = list->hit_count, i;
    if (n<=0 || obj==NULL)
        return 0;
    (*objs) = (OBJECT**)malloc(sizeof(OBJECT*)*(n+1)); /* one extra for handy NULL to terminate list */
    for ( i=0 ; i<n && obj!=NULL; obj=find_next(list,obj),i++)
        (*objs)[i] = obj;
    objs[n]=NULL;/* NULL to terminate list */
    return n;
}

OBJECT *find_first(FINDLIST *list) 
{
    return find_next(list,NULL);
}

OBJECT *find_next(FINDLIST *list, 
                  OBJECT *obj) 
{
    if (obj==NULL)
        obj = object_get_first();
    else
        obj = obj->next;
    while (obj!=NULL && !FOUND(*list,obj->id))
        obj=obj->next;

    return obj;
}

/**************************************************************
 * FIND EXPRESSIONS AND FIND MACHINES
 **************************************************************/

#define VALUE(X,T,M) ((X).isconstant?(X).value.constant.M:*((X).value.ref.T))

int compare_pointer_eq(void *a, FINDVALUE b) { return *(void**)a==b.pointer;}
int compare_pointer_ne(void *a, FINDVALUE b) { return *(void**)a!=b.pointer;}
int compare_pointer_lt(void *a, FINDVALUE b) { return *(void**)a<b.pointer;}
int compare_pointer_gt(void *a, FINDVALUE b) { return *(void**)a>b.pointer;}
int compare_pointer_le(void *a, FINDVALUE b) { return *(void**)a<=b.pointer;}
int compare_pointer_ge(void *a, FINDVALUE b) { return *(void**)a>=b.pointer;}

int compare_integer16_eq(void *a, FINDVALUE b) { return *(int16*)a==(int16)b.integer;}
int compare_integer16_ne(void *a, FINDVALUE b) { return *(int16*)a!=(int16)b.integer;}
int compare_integer16_lt(void *a, FINDVALUE b) { return *(int16*)a<(int16)b.integer;}
int compare_integer16_gt(void *a, FINDVALUE b) { return *(int16*)a>(int16)b.integer;}
int compare_integer16_le(void *a, FINDVALUE b) { return *(int16*)a<=(int16)b.integer;}
int compare_integer16_ge(void *a, FINDVALUE b) { return *(int16*)a>=(int16)b.integer;}

int compare_integer32_eq(void *a, FINDVALUE b) { return *(int32*)a==(int32)b.integer;}
int compare_integer32_ne(void *a, FINDVALUE b) { return *(int32*)a!=(int32)b.integer;}
int compare_integer32_lt(void *a, FINDVALUE b) { return *(int32*)a<(int32)b.integer;}
int compare_integer32_gt(void *a, FINDVALUE b) { return *(int32*)a>(int32)b.integer;}
int compare_integer32_le(void *a, FINDVALUE b) { return *(int32*)a<=(int32)b.integer;}
int compare_integer32_ge(void *a, FINDVALUE b) { return *(int32*)a>=(int32)b.integer;}

int compare_integer64_eq(void *a, FINDVALUE b) { return *(int64*)a==(int64)b.integer;}
int compare_integer64_ne(void *a, FINDVALUE b) { return *(int64*)a!=(int64)b.integer;}
int compare_integer64_lt(void *a, FINDVALUE b) { return *(int64*)a<(int64)b.integer;}
int compare_integer64_gt(void *a, FINDVALUE b) { return *(int64*)a>(int64)b.integer;}
int compare_integer64_le(void *a, FINDVALUE b) { return *(int64*)a<=(int64)b.integer;}
int compare_integer64_ge(void *a, FINDVALUE b) { return *(int64*)a>=(int64)b.integer;}

int compare_integer_eq(void *a, FINDVALUE b) { return *(long*)a==(long)b.integer;}
int compare_integer_ne(void *a, FINDVALUE b) { return *(long*)a!=(long)b.integer;}
int compare_integer_lt(void *a, FINDVALUE b) { return *(long*)a<(long)b.integer;}
int compare_integer_gt(void *a, FINDVALUE b) { return *(long*)a>(long)b.integer;}
int compare_integer_le(void *a, FINDVALUE b) { return *(long*)a<=(long)b.integer;}
int compare_integer_ge(void *a, FINDVALUE b) { return *(long*)a>=(long)b.integer;}

int compare_real_eq(void *a, FINDVALUE b) { return *(double*)a==b.real;}
int compare_real_ne(void *a, FINDVALUE b) { return *(double*)a!=b.real;}
int compare_real_lt(void *a, FINDVALUE b) { return *(double*)a<b.real;}
int compare_real_gt(void *a, FINDVALUE b) { return *(double*)a>b.real;}
int compare_real_le(void *a, FINDVALUE b) { return *(double*)a<=b.real;}
int compare_real_ge(void *a, FINDVALUE b) { return *(double*)a>=b.real;}

/* NOTE: this only works with short-circuiting logic! */
int compare_string_eq(void *a, FINDVALUE b) { return *(char **)a != NULL && strcmp(*(char**)a,b.string)==0;}
int compare_string_ne(void *a, FINDVALUE b) { return *(char **)a != NULL && strcmp(*(char**)a,b.string)!=0;}
int compare_string_lt(void *a, FINDVALUE b) { return *(char **)a != NULL && strcmp(*(char**)a,b.string)<0;}
int compare_string_gt(void *a, FINDVALUE b) { return *(char **)a != NULL && strcmp(*(char**)a,b.string)>0;}
int compare_string_le(void *a, FINDVALUE b) { return *(char **)a != NULL && strcmp(*(char**)a,b.string)<=0;}
int compare_string_ge(void *a, FINDVALUE b) { return *(char **)a != NULL && strcmp(*(char**)a,b.string)>=0;}

int compare_pointer_li(void *a, FINDVALUE b) {return 0;}

int compare_integer_li(void *a, FINDVALUE b) {
    char temp[256];
    if(convert_from_int64(temp, 256, &(b.integer), NULL))
        return match(*(char **)a, temp);
    return 0;
}

int compare_real_li(void *a, FINDVALUE b) {
    char temp[256];
    if(convert_from_double(temp, 256, &(b.real), NULL))
        return match(*(char **)a, temp);
    return 0;
}

int compare_string_li(void *a, FINDVALUE b) {return match(*(char **)a, b.string);}

int compare_integer16_li(void *a, FINDVALUE b) {
    char temp[256];
    if(convert_from_int16(temp, 256, &(b.integer), NULL))
        return match(*(char **)a, temp);
    return 0;
}

int compare_integer32_li(void *a, FINDVALUE b) {
    char temp[256];
    if(convert_from_int32(temp, 256, &(b.integer), NULL))
        return match(*(char **)a, temp);
    return 0;
}

int compare_integer64_li(void *a, FINDVALUE b) {
    char temp[256];
    if(convert_from_int64(temp, 256, &(b.integer), NULL))
        return match(*(char **)a, temp);
    return 0;
}

int compare_pointer_nl(void *a, FINDVALUE b) {return 1;}

int compare_integer_nl(void *a, FINDVALUE b) {
    char temp[256];
    if(convert_from_int64(temp, 256, &(b.integer), NULL))
        return 1 != match(*(char **)a, temp);
    return 0;
}

int compare_real_nl(void *a, FINDVALUE b) {
    char temp[256];
    if(convert_from_double(temp, 256, &(b.real), NULL))
        return 1 != match(*(char **)a, temp);
    return 0;
}

int compare_string_nl(void *a, FINDVALUE b) {
    return 1 != match(*(char **)a, b.string);
}

int compare_integer16_nl(void *a, FINDVALUE b) {
    char temp[256];
    if(convert_from_int16(temp, 256, &(b.integer), NULL))
        return 1 != match(*(char **)a, temp);
    return 0;
}

int compare_integer32_nl(void *a, FINDVALUE b) {
    char temp[256];
    if(convert_from_int32(temp, 256, &(b.integer), NULL))
        return 1 != match(*(char **)a, temp);
    return 0;
}

int compare_integer64_nl(void *a, FINDVALUE b) {
    char temp[256];
    if(convert_from_int64(temp, 256, &(b.integer), NULL))
        return 1 != match(*(char **)a, temp);
    return 0;
}

static void findlist_add(FINDLIST *list, OBJECT *obj)
{
    ADDOBJ(*list,obj->id);
}
static void findlist_del(FINDLIST *list, OBJECT *obj)
{
    DELOBJ(*list,obj->id);
}
static void findlist_nop(FINDLIST *list, OBJECT *obj)
{
}

PGMCONSTFLAGS find_pgmconstants(FINDPGM *pgm)
{
    if (pgm==NULL)
        return 0;

    /* find the end of the program */
    while (pgm->next!=NULL) pgm=pgm->next;
    return pgm->constflags;

}

static FINDPGM *add_pgm(FINDPGM **pgm, COMPAREFUNC op, unsigned short target, FINDVALUE value, FOUNDACTION pos, FOUNDACTION neg)
{
    /* create program entry */
    FINDPGM *item = (FINDPGM*)malloc(sizeof(FINDPGM));
    if (item!=NULL)
    {
        item->constflags = CF_CONSTANT; /* initially the result is invariant */
        item->op = op;
        item->target = target;
        item->value = value;
        item->pos = pos;
        item->neg = neg;
        item->next = NULL;

        /* attach to existing program */
        if (*pgm!=NULL)
        {
            FINDPGM *tail = *pgm;

            item->constflags = tail->constflags; /* inherit flags from previous result set */

            /* find tail of existing program */
            while (tail->next!=NULL) tail=tail->next;
            tail->next = item;
        }
        else
            *pgm = item;
    }
    else
        errno = ENOMEM;

    return item;
}
FINDLIST *find_runpgm(FINDLIST *list, FINDPGM *pgm)
{
    if (list==NULL)
    {
        list=new_list(object_get_count());
        ADDALL(*list);
    }
    if (pgm!=NULL)
    {
        OBJECT *obj;
        for (obj=find_first(list); obj!=NULL; obj=find_next(list,obj))
        {
            if ((*pgm->op)((void*)(((char*)obj)+pgm->target),pgm->value))
            {   if (pgm->pos) (*pgm->pos)(list,obj); }
            else
            {   if (pgm->neg) (*pgm->neg)(list,obj); }
        }
        find_runpgm(list,pgm->next);
    }
    return list;
}

#define PARSER char *_p
#define START int _m=0, _n=0;
#define ACCEPT { _n+=_m; _p+=_m; _m=0; }
#define HERE (_p+_m)
#define OR {_m=0;}
#define REJECT { return 0; }
#define WHITE (_m+=white(HERE))
#define LITERAL(X) ((_m+=literal(HERE,(X)))>0)
#define TERM(X) ((_m+=(X))>0)
#define COPY(X) {size--; (X)[_n++]=*_p++;}
#define DONE return _n;

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("find expression syntax error at '%s...'", context);
    else
        output_message("find expression syntax error");
}

static int white(PARSER)
{
    if (*_p=='\0' || !isspace(*_p))
        return 0;
    /* 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++;
    }
    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 value(PARSER, char *result, int size)
{   /* everything to a semicolon */
    START;
    while (size>1 && *_p!='\0' && *_p!=';' && *_p!='\n') COPY(result);
    result[_n]='\0';
    return _n;
}

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 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 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("'")
        && 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)) && LITERAL("'"))
    {
        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; DONE;}
    }
    REJECT;
}

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

static int compare_op(PARSER, FINDOP *op)
{
    /* these first! */
    if (strncmp(_p,"!=", 2)==0) {*op=NE; return 2;}
    if (strncmp(_p,"<=", 2)==0) {*op=LE; return 2;}
    if (strncmp(_p,">=", 2)==0) {*op=GE; return 2;}
    if (strncmp(_p,"!~", 2)==0) {*op=UNLIKE; return 2;}

    if (strncmp(_p,"=", 1)==0) {*op=EQ; return 1;}
    if (strncmp(_p,"<", 1)==0) {*op=LT; return 1;}
    if (strncmp(_p,">", 1)==0) {*op=GT; return 1;}
    if (strncmp(_p,"~", 1)==0) {*op=LIKE; return 1;}
    return 0;
}

struct {
    COMPAREFUNC pointer, integer, real, string;
} comparemap[] = 
{   {compare_pointer_eq, compare_integer_eq, compare_real_eq, compare_string_eq},
    {compare_pointer_lt, compare_integer_lt, compare_real_lt, compare_string_lt},
    {compare_pointer_gt, compare_integer_gt, compare_real_gt, compare_string_gt},
    {compare_pointer_ne, compare_integer_ne, compare_real_ne, compare_string_ne},
    {compare_pointer_le, compare_integer_le, compare_real_le, compare_string_le},
    {compare_pointer_ge, compare_integer_ge, compare_real_ge, compare_string_ge},
    {compare_pointer_li, compare_integer_li, compare_real_li, compare_string_li},
    {compare_pointer_nl, compare_integer_nl, compare_real_nl, compare_string_nl}
};

struct {
    COMPAREFUNC pointer, integer, real, string, int_16, int_32, int_64; /*  int_size to avoid #define int64 (platform.h) */
} comparemap_ext[] =
{   {compare_pointer_eq, compare_integer_eq, compare_real_eq, compare_string_eq, compare_integer16_eq, compare_integer32_eq, compare_integer64_eq},
    {compare_pointer_lt, compare_integer_lt, compare_real_lt, compare_string_lt, compare_integer16_lt, compare_integer32_lt, compare_integer64_lt},
    {compare_pointer_gt, compare_integer_gt, compare_real_gt, compare_string_gt, compare_integer16_gt, compare_integer32_gt, compare_integer64_gt},
    {compare_pointer_ne, compare_integer_ne, compare_real_ne, compare_string_ne, compare_integer16_ne, compare_integer32_ne, compare_integer64_ne},
    {compare_pointer_le, compare_integer_le, compare_real_le, compare_string_le, compare_integer16_le, compare_integer32_le, compare_integer64_le},
    {compare_pointer_ge, compare_integer_ge, compare_real_ge, compare_string_ge, compare_integer16_ge, compare_integer32_ge, compare_integer64_ge},
    {compare_pointer_li, compare_integer_li, compare_real_li, compare_string_li, compare_integer16_li, compare_integer32_li, compare_integer64_li},
    {compare_pointer_nl, compare_integer_nl, compare_real_nl, compare_string_nl, compare_integer16_nl, compare_integer32_nl, compare_integer64_nl},
};

/* int compare_integer32_eq(void *a, FINDVALUE b) { return *(int32*)a==(int32)b.integer;} */

static int expression(PARSER, FINDPGM **pgm)
{
    char32 pname;
    char256 pvalue;
    FINDOP op = EQ;
    START;
    if WHITE ACCEPT;
    if (TERM(name(HERE,pname,sizeof(pname))) && WHITE,TERM(compare_op(HERE,&op)) && WHITE,TERM(value(HERE,pvalue,sizeof(pvalue))))
    {
        /* NOTE: this will seg fault if op's value is an invalid index! */
        OBJECT _t;
#define OFFSET(X) (unsigned short)((char*)&(_t.X) - (char*)&_t)
        if WHITE ACCEPT;
        if(op < 0 || op >= FINDOP_END){
            output_error("expression(): invalid find op!");
            REJECT;
        }
        if (strcmp(pname,"class")==0)
        {
            FINDVALUE v;
            CLASS *oclass = class_get_class_from_classname(pvalue);
            if (oclass==NULL)
                output_error("class '%s' not found", pvalue);
            else
            {
                v.pointer=(void*)oclass;
                add_pgm(pgm,comparemap[op].pointer,OFFSET(oclass),v,NULL,findlist_del);
                (*pgm)->constflags |= CF_CLASS; /* this will always reduce in a set class of fixed class, leaving it invariant if already so */
                ACCEPT; DONE;
            }
        }
        if (strcmp(pname,"module")==0)
        {
            FINDVALUE v;
            MODULE *mod = module_find(pvalue);
            if (mod==NULL)
                output_error("module '%s' not found", pvalue);
            else
            {
                v.pointer=(void*)mod;
                add_pgm(pgm,comparemap[op].pointer,OFFSET(oclass),v,NULL,findlist_del);
                (*pgm)->constflags |= CF_MODULE; 
                ACCEPT; DONE;
            }
        }
        else if (strcmp(pname,"id")==0)
        {
            FINDVALUE v;
            int idnum = atoi(pvalue);
            if(idnum < 0){
                output_error("ID '#%i' not found", idnum);
            } else {
                v.integer = idnum;
                add_pgm(pgm,comparemap[op].integer,OFFSET(id),v,NULL,findlist_del);
                (*pgm)->constflags |= CF_ID;
                ACCEPT;
                DONE;
            }
        }
        else if (strcmp(pname, "name") == 0)
        {
            /* Accept implicitly.  If it's bad, it's bad. -MH */
            FINDVALUE v;
            strcpy(v.string, pvalue);
            printf("find(): v.string=\"%s\", pvalue=\"%s\"\n", v.string, pvalue);
            add_pgm(pgm, comparemap[op].string, OFFSET(name), v, NULL, findlist_del);
            (*pgm)->constflags |= CF_NAME;
            ACCEPT;
            DONE;
        }
        else if (strcmp(pname,"parent")==0)
        {
            FINDVALUE v;
            OBJECT *parent = object_find_name(pvalue);
            if (parent==NULL && strcmp(pvalue, "root") != 0 && strcmp(pvalue, "ROOT") != 0)
                output_error("parent '%s' not found", pvalue);
            else
            {
                v.pointer = (void*)parent;
                add_pgm(pgm,comparemap[op].pointer,OFFSET(parent),v,NULL,findlist_del);
                (*pgm)->constflags |= CF_PARENT;
                ACCEPT; DONE;
            }
        }
        else if (strcmp(pname,"rank")==0)
        {
            FINDVALUE v;
            int rank = atoi(pvalue);
            if (rank<0)
                output_error("rank %s is invalid", pvalue);
            else
            {
                v.integer = rank;
                add_pgm(pgm,comparemap[op].integer,OFFSET(rank),v,NULL,findlist_del);
                (*pgm)->constflags |= CF_RANK;
                ACCEPT; DONE;
            }
        }
        else if (strcmp(pname, "latitude") == 0)
        {
            /* mostly borrowed from load.c */
            FINDVALUE v;
            int32 d = 0, m = 0;
            double s = 0.0, val = 0.0;
            char ns;
            if (sscanf(pvalue, "%d%c%d'%lf\"", &d, &ns, &m, &s) > 0) /* 12N34'56" */
            {
                val = (double)d+(double)m/60+s/3600;
                if (val >= 0 && val <= 90)
                {
                    if (ns=='S')
                        val = -val;
                    else if (ns=='N')
                        ;
                    else
                        REJECT;
                } else {
                    REJECT;
                }
                v.real = val;
                add_pgm(pgm, comparemap[op].real, OFFSET(latitude), v, NULL, findlist_del);
                (*pgm)->constflags |= CF_LAT;
                ACCEPT; DONE;
            }
        }
        else if (strcmp(pname, "longitude") == 0)
        {
            /* mostly borrowed from load.c */
            FINDVALUE v;
            int32 d = 0, m = 0;
            double s = 0.0, val = 0.0;
            char ns;
            if (sscanf(pvalue, "%d%c%d'%lf\"", &d, &ns, &m, &s) > 0) /* 12N34'56" */
            {
                val = (double)d+(double)m/60+s/3600;
                if (val >= 0 && val <= 180)
                {
                    if (ns=='W')
                        val = -val;
                    else if (ns=='E')
                        ;
                    else
                        REJECT;
                } else {
                    REJECT;
                }
                v.real = val;
                add_pgm(pgm, comparemap[op].real, OFFSET(longitude), v, NULL, findlist_del);
                (*pgm)->constflags |= CF_LONG;
                ACCEPT; DONE;
            }
        }
        else if (strcmp(pname, "clock") == 0)
        {
            FINDVALUE v;
            v.integer = convert_to_timestamp(pvalue);
            if(v.integer == TS_NEVER)
                REJECT;
            add_pgm(pgm, comparemap[op].integer, OFFSET(clock), v, NULL, findlist_del);
            (*pgm)->constflags |= CF_CLOCK;
            ACCEPT; DONE;
        }
        else if (strcmp(pname, "insvc") == 0)   /* format? */
        {
            FINDVALUE v;
            v.integer = convert_to_timestamp(pvalue);
            printf("find insvc=%i\n", v.integer);
            if(v.integer == TS_NEVER)
                REJECT;
            add_pgm(pgm, comparemap[op].integer, OFFSET(in_svc), v, NULL, findlist_del);
            (*pgm)->constflags |= CF_INSVC;
            ACCEPT; DONE;
        }
        else if (strcmp(pname, "outsvc") == 0)  /* format? */
        {
            FINDVALUE v;
            v.integer = convert_to_timestamp(pvalue);
            if(v.integer == TS_NEVER)
                REJECT;
            add_pgm(pgm, comparemap[op].integer, OFFSET(out_svc), v, NULL, findlist_del);
            (*pgm)->constflags |= CF_OUTSVC;
            ACCEPT; DONE;
        }
        else if (strcmp(pname, "flags") == 0)
        {
            /* still need to think about how to input flags without hardcoding the flag name. -mh */
            output_error("find expression on %s not supported", pname);
        }
        else
            output_error("find expression refers to unknown or unsupported property '%s'", pname);
    }
    REJECT;
}

static int expression_list(PARSER, FINDPGM **pgm)
{
    START;
    if TERM(expression(HERE,pgm)) ACCEPT;
    if (WHITE,LITERAL(";") && TERM(expression_list(HERE,pgm))) { ACCEPT; DONE; }
    DONE;
}

FINDPGM *find_mkpgm(char *search)
{
    STATUS status=FAILED;
    FINDPGM *pgm = NULL;
    char *p = search;
    while (*p!='\0')
    {
        int move = expression_list(p,&pgm);
        if (move==0)
            break;
        p+=move;
    }
    return pgm;
}

char *find_file(char *name, 
                char *path, 
                int mode) 
{
    static char filepath[1024];
    static char tempfp[1024];
    char *glpath = path?path:getenv("GLPATH");
    int found;
    char *dir = NULL;

    /*
    CAVEAT
        Access() is a potential security hole and should never be used.
        -HMUG man page
     */
    if(access(name, mode) == 0){
        strncpy(filepath, name, 1024);
        return filepath;
    }
#ifdef WIN32
    if(module_get_exe_path(filepath, 1024)){
        sprintf(tempfp, "%s%s", filepath, name);
        if(access(tempfp, mode) == 0)
            return tempfp;
        sprintf(tempfp, "%setc\\%s", filepath, name);
        if(access(tempfp, mode) == 0)
            return tempfp;
        sprintf(tempfp, "%slib\\%s", filepath, name);
        if(access(tempfp, mode) == 0)
            return tempfp;
    }
#else
    sprintf(tempfp, "/usr/lib/gridlabd/%s", name);
    if(access(tempfp, mode) == 0){
        return tempfp;
    }
    sprintf(tempfp, "/usr/etc/gridlabd/%s", name);
    if(access(tempfp, mode) == 0){
        return tempfp;
    }
#endif
    strncpy(filepath,name,sizeof(filepath));

    /* locate unit file on GLPATH if not found locally */
    while (!(found=(access(filepath,mode)==0)) && glpath!=NULL)
    {
        char envbuf[1024];
#ifdef WIN32
        char *delim = ";";
#else
        char *delim = ":";
#endif
        strcpy(envbuf,glpath);
        dir = strtok(dir?NULL:envbuf,delim);
        if (dir==NULL)
            break;
        strcpy(filepath,dir);
        strcat(filepath,"/");
        strcat(filepath,name);
    }
    return found?filepath:NULL;
}

---

GridLAB-D^TM Version 1.0

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