source: cpp/frams/param/paramobj.cpp @ 211

// This file is a part of the Framsticks GDK.
// Copyright (C) 1999-2014  Maciej Komosinski and Szymon Ulatowski.  See LICENSE.txt for details.
// Refer to http://www.framsticks.com/ for further information.

#include <frams/param/paramobj.h>
#include <frams/util/extvalue.h>
#include <common/nonstd_stl.h>

static const char* maybedup(bool dup,const char* src)
{ return dup ? (src?strdup(src):0) : src; }
static void maybefree(void* mem)
{ if (mem) free(mem); }

ParamEntry* ParamObject::makeParamTab(ParamInterface *pi,bool stripgroups,bool stripproc,
                                      int firstprop, int maxprops, bool dupentries, int flagsexclude)
{
ParamEntry *tab,*t;
int i,n,offs;
static ExtValue ex;
int count=0,gcount=1;
if (!stripgroups) gcount=pi->getGroupCount();
if (stripproc||flagsexclude)
for (int i=firstprop;i < pi->getPropCount();i++)
        {
        const char*t=pi->type(i);
        if ((!stripproc)||(strchr("dfsox",*t)))
                if ((!flagsexclude)||(!(pi->flags(i)&flagsexclude)))
                        if (++count >= maxprops) break;
        }
else count=pi->getPropCount()-firstprop;
t=tab=(ParamEntry*)malloc(sizeof(ParamEntry)*(count+gcount+1));
t->group=(short)gcount;
t->flags=(short)count;
t->name=maybedup(dupentries,pi->getName());
t->type=maybedup(dupentries,pi->getDescription());
for(i=0;i<gcount;i++)
        {
        t->id=maybedup(dupentries,pi->grname(i));
        t->offset=0;
        t++;
        }
n=1; offs=1;
for (i=firstprop;i < pi->getPropCount();i++)
        {
        if ((!stripproc)||(strchr("dfsox",*pi->type(i))))
                {
                if ((!flagsexclude)||(!(pi->flags(i)&flagsexclude)))
                        {
                        t->offset=offs*sizeof(ExtValue);
                        if (*pi->type(i)!='x') t->offset+=(((char*)&ex.data[0])-((char*)&ex));
                        t->group=(short)(stripgroups?0:pi->group(i));
                        t->flags=(short)pi->flags(i);
                        t->fun1=0;
                        t->fun2=0;
                        t->id=maybedup(dupentries,pi->id(i));
                        t->name=maybedup(dupentries,pi->name(i));
                        t->type=maybedup(dupentries,pi->type(i));
                        t->help=maybedup(dupentries,pi->help(i));
                        t++;
                        n++;
                        if (n>count) break;
                        }
                offs++;
                }
        }
t->id=0; t->group=0; t->flags=dupentries?MUTPARAM_ALLOCENTRY:0;
return tab;
}

void ParamObject::freeParamTab(ParamEntry *pe)
{
if (pe[pe->flags+pe->group].flags & MUTPARAM_ALLOCENTRY)
        {
        int i;
        ParamEntry *e;
        maybefree((void*)pe->name);
        maybefree((void*)pe->type);
        for (i=0,e=pe;i<pe->group;i++,e++) 
                maybefree((void*)e->id);
        for (i=pe->group,e=pe+i;i<pe->group+pe->flags;i++,e++) 
                {
                maybefree((void*)e->id);
                maybefree((void*)e->name);
                maybefree((void*)e->type);
                maybefree((void*)e->help);
                }
        }
free(pe);
}

bool ParamObject::paramTabEqual(ParamEntry *pe1,ParamEntry *pe2)
{
if (pe1->flags != pe2->flags) return false;
ParamEntry *e1=pe1+pe1->group, *e2=pe2+pe2->group;
for(int i=0;i<pe1->flags;i++,e1++,e2++)
        {
        if (strcmp(e1->id,e2->id)) return false;
        if (strcmp(e1->name,e2->name)) return false;
        if (strcmp(e1->type,e2->type)) return false;
        if (e1->offset!=e2->offset) return false;
        }
return true;
}

void* ParamObject::makeObject(ParamEntry *tab)
{
if (!tab) return 0;
int n=tab->flags;
if (!n) return 0;
ExtValue *ret=new ExtValue[n+1];
ret->setInt(n);
ExtValue *v=ret+1;
tab+=tab->group;
for (;n>0;n--,v++,tab++)
        switch(*tab->type)
        {
        case 'd': v->setInt(0); break;
        case 'f': v->setDouble(0); break;
        case 's': v->setString(SString::empty()); break;
        case 'o': v->setObject(ExtObject()); break;
        case 'x': break;
        }
return ret;
}

void ParamObject::copyObject(void* dst,void* src)
{
if ((!dst)||(!src)) return;
ExtValue *s=(ExtValue *)src;
ExtValue *d=(ExtValue *)dst;
int n=min(s->getInt(),d->getInt());
s++; d++;
for (int i=0;i<n;i++,d++,s++)
        *d=*s;
}

void* ParamObject::dupObject(void* src)
{
if (!src) return NULL;
ExtValue *s=(ExtValue *)src;
int n=s->getInt();

ExtValue *ret=new ExtValue[n+1];
ExtValue *d=ret;
d->setInt(n);
d++; s++;

for (int i=0;i<n;i++,d++,s++)
        *d=*s;

return ret;
}

void ParamObject::freeObject(void* obj)
{
if (!obj) return;
delete[] (ExtValue *)obj;
}