core/convert.c

Go to the documentation of this file.

#include <stdio.h>
#include <math.h>
#include <ctype.h>
#include "globals.h"
#include "convert.h"
#include "object.h"

int convert_from_void(char *buffer, 
                      int size, 
                      void *data, 
                      PROPERTY *prop) 
{
    if(size < 7)
        return 0;
    return sprintf(buffer,"%s","(void)");
}

int convert_to_void(char *buffer, 
                      void *data, 
                      PROPERTY *prop) 
{
    return 1;
}

int convert_from_double(char *buffer, 
                        int size, 
                        void *data, 
                        PROPERTY *prop) 
{
    char temp[1025];
    int count = sprintf(temp, global_double_format, *(double *)data);
    if(count < size+1){
        memcpy(buffer, temp, count);
        buffer[count] = 0;
        return count;
    } else {
        return 0;
    }
}

int convert_to_double(char *buffer, 
                      void *data, 
                      PROPERTY *prop) 
{
    return sscanf(buffer,"%lg",data);
}

int convert_from_complex(char *buffer, 
                        int size, 
                        void *data, 
                        PROPERTY *prop) 
{
    int count = 0;
    char temp[1025];
    complex *v = data;
    if (v->f==A)
    {
        double m = sqrt(v->r*v->r+v->i*v->i);
        double a = (v->r==0) ? (v->i>0 ? PI/2 : (v->i==0 ? 0 : -PI/2)) : ((v->i>0) ? (v->r>0 ? atan(v->i/v->r) : PI-atan(v->i/v->r)) : (v->r>0 ? -atan(v->i/v->r) : PI+atan(v->i/v->r)));
        count = sprintf(temp,global_complex_format,m,a*180/PI,A);
    } else {
        count = sprintf(temp,global_complex_format,v->r,v->i,v->f?v->f:'i');
    }
    if(count < size - 1){
        memcpy(buffer, temp, count);
        buffer[count] = 0;
        return count;
    } else {
        return 0;
    }
}

int convert_to_complex(char *buffer, 
                       void *data, 
                       PROPERTY *prop) 
{
    complex *v = (complex*)data;
    char notation[2]={CNOTATION_DEFAULT,'\0'};
    int n;
    double a=0, b=0; 
    n = sscanf(buffer,"%lg%lg%1[ijd]",&a,&b,notation);
    if (n < 2)
    {
        char signage[2] = {0, 0};
        /* printf("alt complex form?"); */
        n = sscanf(buffer, "%lg %1[+-] %lg%1[ijd]", &a, signage, &b, notation);
        if (n > 0 && signage[0] == '-')
            b *= -1.0;
    }
    if (n>0)
    {
        if (n>1 && notation[0]==A)
        {
            double m = a*a+b*b;
            v->r = m*cos(b*PI/180);
            v->i = m*sin(b*PI/180);
        }
        else
        {
            v->r = a;
            v->i = (n>1?b:0);
        }
        v->f = notation[0];
        return 1;
    }
    else
        return 0;
}

int convert_from_enumeration(char *buffer, 
                             int size, 
                             void *data, 
                             PROPERTY *prop) 
{
    KEYWORD *keys=prop->keywords;
    int count = 0;
    char temp[1025];
    /* get the true value */
    int value = *(unsigned long*)data;

    /* process the keyword list, if any */
    for ( ; keys!=NULL ; keys=keys->next)
    {
        /* if the key value matched */
        if (keys->value==value){
            /* use the keyword */
            count = strncpy(temp,keys->name,1024)?(int)strlen(temp):0;
            break;
        }
    }

    /* no keyword found, return the numeric value instead */
    if (count == 0){
         count = sprintf(temp,"%d",value);
    }
    if(count < size - 1){
        memcpy(buffer, temp, count);
        buffer[count] = 0;
        return count;
    } else {
        return 0;
    }
}

int convert_to_enumeration(char *buffer, 
                           void *data, 
                           PROPERTY *prop) 
{
    KEYWORD *keys=prop->keywords;

    /* process the keyword list */
    for ( ; keys!=NULL ; keys=keys->next)
    {
        if (strcmp(keys->name,buffer)==0)
        {
            *(unsigned long*)data=keys->value;
            return 1;
        }
    }
    return sscanf(buffer,"%d",(unsigned long*)data);
}

#define SETDELIM "|"
int convert_from_set(char *buffer, 
                        int size, 
                        void *data, 
                        PROPERTY *prop) 
{
    KEYWORD *keys=prop->keywords;

    /* get the actual value */
    long value = *(unsigned long*)data;

    /* keep track of how characters written */
    int count=0;

    /* clear the buffer */
    buffer[0] = '\0';

    /* process each keyword */
    for ( ; keys!=NULL ; keys=keys->next)
    {
        /* if the keyword matches */
        if ((keys->value&value)==keys->value || (keys->value==0 && value==0))
        {
            /* get the length of the keyword */
            int len = (int)strlen(keys->name);

            /* if there's room for it in the buffer */
            if (size>count+len+1)
            {
                /* if the buffer already has keywords in it */
                if (buffer[0]!='\0')
                {
                    /* add a separator to the buffer */
                    if (!(prop->flags&PF_CHARSET))
                    {
                        count++;
                        strcat(buffer,SETDELIM);
                    }
                }

                /* add the keyword to the buffer */
                count += len;
                strcat(buffer,keys->name);
            }

            /* no room in the buffer */
            else

                /* fail */
                return 0;
        }
    }

    /* succeed */
    return count;
}

int convert_to_set(char *buffer, 
                        void *data, 
                        PROPERTY *prop) 
{
    KEYWORD *keys=prop->keywords;
    char temp[4096], *ptr;
    unsigned long value=0;
    int count=0;

    /* directly convert numeric strings */
    if (strnicmp(buffer,"0x",2)==0)
        return sscanf(buffer,"0x%x",(unsigned long *)data);
    else if (isdigit(buffer[0]))
        return sscanf(buffer,"%d",(unsigned long *)data);

    /* prevent long buffer from being scanned */
    if (strlen(buffer)>sizeof(temp)-1)
        return 0;

    /* make a temporary copy of the buffer */
    strcpy(temp,buffer);

    /* check for CHARSET keys (single character keys) and usage without | */
    if ((prop->flags&PF_CHARSET) && strchr(buffer,'|')==NULL)
    {
        for (ptr=buffer; *ptr!='\0'; ptr++)
        {
            KEYWORD *key;
            for (key=keys; key!=NULL; key=key->next)
            {
                if (*ptr==key->name[0])
                {
                    value |= key->value;
                    count ++;
                    break; /* we found our key */
                }
            }
        }
    }
    else
    {
        /* process each keyword in the temporary buffer*/
        for (ptr=strtok(temp,SETDELIM); ptr!=NULL; ptr=strtok(NULL,SETDELIM))
        {
            KEYWORD *key;

            /* scan each of the keywords in the set */
            for (key=keys; key!=NULL; key=key->next)
            {
                if (strcmp(ptr,key->name)==0)
                {
                    value |= key->value;
                    count ++;
                    break; /* we found our key */
                }
            }
        }
    }
    *(unsigned long *)data = value;
    return count;
}

int convert_from_int16(char *buffer, 
                        int size, 
                        void *data, 
                        PROPERTY *prop) 
{
    char temp[1025];
    int count = sprintf(temp,"%hd",*(short*)data);
    if(count < size - 1){
        memcpy(buffer, temp, count);
        buffer[count] = 0;
        return count;
    } else {
        return 0;
    }
}

int convert_to_int16(char *buffer, 
                        void *data, 
                        PROPERTY *prop) 
{
    return sscanf(buffer,"%hd",data);
}

int convert_from_int32(char *buffer, 
                        int size, 
                        void *data, 
                        PROPERTY *prop) 
{
    char temp[1025];
    int count = sprintf(temp,"%ld",*(int*)data);
    if(count < size - 1){
        memcpy(buffer, temp, count);
        buffer[count] = 0;
        return count;
    } else {
        return 0;
    }
}

int convert_to_int32(char *buffer, 
                        void *data, 
                        PROPERTY *prop) 
{
    return sscanf(buffer,"%ld",data);
}

int convert_from_int64(char *buffer, 
                        int size, 
                        void *data, 
                        PROPERTY *prop) 
{
    char temp[1025];
    int count = sprintf(temp,"%" FMT_INT64 "d",*(int64*)data);
    if(count < size - 1){
        memcpy(buffer, temp, count);
        buffer[count] = 0;
        return count;
    } else {
        return 0;
    }
}

int convert_to_int64(char *buffer, 
                        void *data, 
                        PROPERTY *prop) 
{
    return sscanf(buffer,"%" FMT_INT64 "d",data);
}

int convert_from_char8(char *buffer, 
                        int size, 
                        void *data, 
                        PROPERTY *prop) 
{
    char temp[1025];
    char *format = "%s";
    int count = 0;
    if (strchr((char*)data,' ')!=NULL || strchr((char*)data,';')!=NULL || ((char*)data)[0]=='\0')
        format = "\"%s\"";
    count = sprintf(temp,format,(char*)data);
    if(count > size - 1){
        return 0;
    } else {
        memcpy(buffer, temp, count);
        buffer[count] = 0;
        return count;
    }
}

int convert_to_char8(char *buffer, 
                        void *data, 
                        PROPERTY *prop) 
{
    char c=((char*)data)[0];
    switch (c) {
    case '"':
        return sscanf(buffer+1,"%8[^\"]",data);
    default:
        return sscanf(buffer,"%8s",data);
    }
}

int convert_from_char32(char *buffer, 
                        int size, 
                        void *data, 
                        PROPERTY *prop) 
{
    char temp[1025];
    char *format = "%s";
    int count = 0;
    if (strchr((char*)data,' ')!=NULL || strchr((char*)data,';')!=NULL || ((char*)data)[0]=='\0')
        format = "\"%s\"";
    count = sprintf(temp,format,(char*)data);
    if(count > size - 1){
        return 0;
    } else {
        memcpy(buffer, temp, count);
        buffer[count] = 0;
        return count;
    }
}

int convert_to_char32(char *buffer, 
                        void *data, 
                        PROPERTY *prop) 
{
    char c=((char*)data)[0];
    switch (c) {
    case '"':
        return sscanf(buffer+1,"%32[^\"]",data);
    default:
        return sscanf(buffer,"%32s",data);
    }
}

int convert_from_char256(char *buffer, 
                        int size, 
                        void *data, 
                        PROPERTY *prop) 
{
    char temp[1025];
    char *format = "%s";
    int count = 0;
    if (strchr((char*)data,' ')!=NULL || strchr((char*)data,';')!=NULL || ((char*)data)[0]=='\0')
        format = "\"%s\"";
    count = sprintf(temp,format,(char*)data);
    if(count > size - 1){
        return 0;
    } else {
        memcpy(buffer, temp, count);
        buffer[count] = 0;
        return count;
    }
}

int convert_to_char256(char *buffer, 
                        void *data, 
                        PROPERTY *prop) 
{
    char c=((char*)data)[0];
    switch (c) {
    case '"':
        return sscanf(buffer+1,"%256[^\"]",data);
    default:
        return sscanf(buffer,"%256s",data);
    }
}

int convert_from_char1024(char *buffer, 
                        int size, 
                        void *data, 
                        PROPERTY *prop) 
{
    char temp[1025];
    char *format = "%s";
    int count = 0;
    if (strchr((char*)data,' ')!=NULL || strchr((char*)data,';')!=NULL || ((char*)data)[0]=='\0')
        format = "\"%s\"";
    count = sprintf(temp,format,(char*)data);
    if(count > size - 1){
        return 0;
    } else {
        memcpy(buffer, temp, count);
        buffer[count] = 0;
        return count;
    }
}

int convert_to_char1024(char *buffer, 
                        void *data, 
                        PROPERTY *prop) 
{
    char c=((char*)buffer)[0];
    switch (c) {
    case '"':
        return sscanf(buffer+1,"%1024[^\"]",data);
    default:
        return sscanf(buffer,"%1024[^\n]",data);
    }
}

int convert_from_object(char *buffer, 
                        int size, 
                        void *data, 
                        PROPERTY *prop) 
{
    OBJECT *obj = (data ? *(OBJECT**)data : NULL);
    char temp[256];
    if (obj==NULL)
        return 0;
    if (obj->name != NULL){
        if ((strlen(obj->name) != 0) && (strlen(obj->name) < (size_t)(size - 1))){
            strcpy(buffer, obj->name);
            return 1;
        }
    }
    if (sprintf(temp,global_object_format,obj->oclass->name,obj->id)<size)
        strcpy(buffer,temp);
    else
        return 0;
    return 1;
}

int convert_to_object(char *buffer, 
                        void *data, 
                        PROPERTY *prop) 
{
    CLASSNAME cname;
    OBJECTNUM id;
    OBJECT **target = (OBJECT**)data;
    char oname[256];
    if (sscanf(buffer,"\"%[^\"]\"",oname)==1 || (strchr(buffer,':')==NULL && strncpy(oname,buffer,sizeof(oname))))
    {
        oname[sizeof(oname)-1]='\0'; /* terminate unterminated string */
        *target = object_find_name(oname);
        return (*target)!=NULL;
    }
    else if (sscanf(buffer,global_object_scan,cname,&id)==2)
    {
        OBJECT *obj = object_find_by_id(id);
        if(obj == NULL){ /* failure case, make noisy if desired. */
            *target = NULL;
            return 0;
        }
        if (obj!=NULL && strcmp(obj->oclass->name,cname)==0)
        {
            *target=obj;
            return 1;
        }
    }
    else
        *target = NULL;
    return 0;
}

int convert_from_delegated(char *buffer, 
                        int size, 
                        void *data, 
                        PROPERTY *prop) 
{
    DELEGATEDVALUE *value = (DELEGATEDVALUE*)data;
    if (value==NULL || value->type==NULL || value->type->to_string==NULL) 
        return 0;
    else
        return (*(value->type->to_string))(value->data,buffer,size);
}

int convert_to_delegated(char *buffer, 
                        void *data, 
                        PROPERTY *prop) 
{
    DELEGATEDVALUE *value = (DELEGATEDVALUE*)data;
    if (value==NULL || value->type==NULL || value->type->from_string==NULL) 
        return 0;
    else
        return (*(value->type->from_string))(value->data,buffer);
}

int convert_from_boolean(char *buffer, int size, void *data, PROPERTY *prop){
    unsigned int b = 0;
    if(buffer == NULL || data == NULL || prop == NULL)
        return 0;
    b = *(unsigned int *)data;
    if(b == 1 && (size > 4)){
        return sprintf(buffer, "TRUE");
    }
    if(b == 0 && (size > 5)){
        return sprintf(buffer, "FALSE");
    }
    return 0;
}

int convert_to_boolean(char *buffer, void *data, PROPERTY *prop){
    char str[32];
    int i = 0;
    if(buffer == NULL || data == NULL || prop == NULL)
        return 0;
    memcpy(str, buffer, 31);
    for(i = 0; i < 31; ++i){
        if(str[i] == 0)
            break;
        str[i] = toupper(str[i]);
    }
    if(0 == strcmp(str, "TRUE")){
        *(unsigned int *)data = 1;
        return 1;
    }
    if(0 == strcmp(str, "FALSE")){
        *(unsigned int *)data = 0;
        return 1;
    }
    return 0;
}

int convert_from_timestamp_stub(char *buffer, int size, void *data, PROPERTY *prop){
    TIMESTAMP ts = *(int64 *)data;
    return convert_from_timestamp(ts, buffer, size);
    //return 0;
}

int convert_to_timestamp_stub(char *buffer, void *data, PROPERTY *prop){
    TIMESTAMP ts = convert_to_timestamp(buffer);
    *(int64 *)data = ts;
    return 1;
}

int convert_from_double_array(char *buffer, int size, void *data, PROPERTY *prop){
    int i = 0;
    return 0;
}

int convert_to_double_array(char *buffer, void *data, PROPERTY *prop){
    return 0;
}

int convert_from_complex_array(char *buffer, int size, void *data, PROPERTY *prop){
    return 0;
}

int convert_to_complex_array(char *buffer, void *data, PROPERTY *prop){
    return 0;
}

---

GridLAB-D^TM Version 1.0

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