dna_genfile.c

Go to the documentation of this file.

/* dna_genfile.c
 *
 * Functions for struct-dna, the genetic file dot c!
 *
 *
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 * DNA handling
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "MEM_guardedalloc.h" // for MEM_freeN MEM_mallocN MEM_callocN

#ifdef WITH_DNA_GHASH
#  include "BLI_ghash.h"
#endif

#include "DNA_genfile.h"
#include "DNA_sdna_types.h" // for SDNA ;-)


/* gcc 4.1 on mingw was complaining that __int64 was already defined
actually is saw the line below as typedef long long long long... 
Anyhow, since its already defined, its safe to do an ifndef here- Campbell */
#ifdef FREE_WINDOWS
#ifndef __int64
typedef long long __int64;
#endif
#endif

/*
 * - please note: no builtin security to detect input of double structs
 * - if you want a struct not to be in DNA file: add two hash marks above it (#<enter>#<enter>)

Structure DNA data is added to each blender file and to each executable, this to detect
in .blend files new veriables in structs, changed array sizes, etc. It's also used for
converting endian and pointer size (32-64 bits)
As an extra, Python uses a call to detect run-time the contents of a blender struct.

Create a structDNA: only needed when one of the input include (.h) files change.
File Syntax:
    SDNA (4 bytes) (magic number)
    NAME (4 bytes)
    <nr> (4 bytes) amount of names (int)
    <string> 
    <string>
    ...
    ...
    TYPE (4 bytes)
    <nr> amount of types (int)
    <string>
    <string>
    ...
    ...
    TLEN (4 bytes)
    <len> (short) the lengths of types
    <len>
    ...
    ...
    STRC (4 bytes)
    <nr> amount of structs (int)
    <typenr><nr_of_elems> <typenr><namenr> <typenr><namenr> ...
    
!!Remember to read/write integer and short aligned!!

 While writing a file, the names of a struct is indicated with a type number,
 to be found with: type= findstruct_nr(SDNA *, char *)
 The value of 'type' corresponds with the the index within the structs array

 For the moment: the complete DNA file is included in a .blend file. For
 the future we can think of smarter methods, like only included the used
 structs. Only needed to keep a file short though...

ALLOWED AND TESTED CHANGES IN STRUCTS:
 - type change (a char to float will be divided by 255)
 - location within a struct (everthing can be randomly mixed up)
 - struct within struct (within struct etc), this is recursive
 - adding new elements, will be default initialized zero
 - remving elements
 - change of array sizes
 - change of a pointer type: when the name doesn't change the contents is copied

NOT YET:
 - array (vec[3]) to float struct (vec3f)

DONE:
 - endian compatibility
 - pointer conversion (32-64 bits)

IMPORTANT:
 - do not use #defines in structs for array lengths, this cannot be read by the dna functions
 - do not use uint, but unsigned int instead, ushort and ulong are allowed
 - only use a long in Blender if you want this to be the size of a pointer. so it is
   32 bits or 64 bits, dependant at the cpu architecture
 - chars are always unsigned
 - aligment of variables has to be done in such a way, that any system does
   not create 'padding' (gaps) in structures. So make sure that:
   - short: 2 aligned
   - int: 4 aligned
   - float: 4 aligned
   - double: 8 aligned
   - long: 8 aligned
   - struct: 8 aligned
 - the sdna functions have several error prints builtin, always check blender running from a console.
 
*/

/* local */
static int le_int(int temp);
static short le_short(short temp);

/* ************************* ENDIAN STUFF ********************** */

static short le_short(short temp)
{
    short new;
    char *rt=(char *)&temp, *rtn=(char *)&new;

    rtn[0]= rt[1];
    rtn[1]= rt[0];

    return new;
}


static int le_int(int temp)
{
    int new;
    char *rt=(char *)&temp, *rtn=(char *)&new;

    rtn[0]= rt[3];
    rtn[1]= rt[2];
    rtn[2]= rt[1];
    rtn[3]= rt[0];

    return new;
}


/* ************************* MAKE DNA ********************** */

/* allowed duplicate code from makesdna.c */
int DNA_elem_array_size(const char *astr, int len)
{
    int a, mul=1;
    char str[100], *cp= NULL;

    memcpy(str, astr, len+1);

    for(a=0; a<len; a++) {
        if( str[a]== '[' ) {
            cp= &(str[a+1]);
        }
        else if( str[a]==']' && cp) {
            str[a]= 0;
            mul*= atoi(cp);
        }
    }

    return mul;
}

/* ************************* END MAKE DNA ********************** */

/* ************************* DIV ********************** */

void DNA_sdna_free(SDNA *sdna)
{
    MEM_freeN(sdna->data);
    MEM_freeN((void *)sdna->names);
    MEM_freeN(sdna->types);
    MEM_freeN(sdna->structs);

#ifdef WITH_DNA_GHASH
    BLI_ghash_free(sdna->structs_map, NULL, NULL);
#endif

    MEM_freeN(sdna);
}

static int ispointer(const char *name)
{
    /* check if pointer or function pointer */
    return (name[0]=='*' || (name[0]=='(' && name[1]=='*'));
}

static int elementsize(SDNA *sdna, short type, short name)
/* call with numbers from struct-array */
{
    int mul, namelen, len;
    const char *cp;
    
    cp= sdna->names[name];
    len= 0;
    
    namelen= strlen(cp);
    /* is it a pointer or function pointer? */
    if(ispointer(cp)) {
        /* has the naam an extra length? (array) */
        mul= 1;
        if( cp[namelen-1]==']') mul= DNA_elem_array_size(cp, namelen);
        
        len= sdna->pointerlen*mul;
    }
    else if( sdna->typelens[type] ) {
        /* has the naam an extra length? (array) */
        mul= 1;
        if( cp[namelen-1]==']') mul= DNA_elem_array_size(cp, namelen);
        
        len= mul*sdna->typelens[type];
        
    }
    
    return len;
}

#if 0
static void printstruct(SDNA *sdna, short strnr)
{
    /* is for debug */
    int b, nr;
    short *sp;
    
    sp= sdna->structs[strnr];
    
    printf("struct %s\n", sdna->types[ sp[0] ]);
    nr= sp[1];
    sp+= 2;
    
    for(b=0; b< nr; b++, sp+= 2) {
        printf("   %s %s\n", sdna->types[sp[0]], sdna->names[sp[1]]);
    }
}
#endif

static short *findstruct_name(SDNA *sdna, const char *str)
{
    int a;
    short *sp= NULL;


    for(a=0; a<sdna->nr_structs; a++) {

        sp= sdna->structs[a];
        
        if(strcmp( sdna->types[ sp[0] ], str )==0) return sp;
    }
    
    return NULL;
}

int DNA_struct_find_nr(SDNA *sdna, const char *str)
{
    short *sp= NULL;

    if(sdna->lastfind<sdna->nr_structs) {
        sp= sdna->structs[sdna->lastfind];
        if(strcmp( sdna->types[ sp[0] ], str )==0) return sdna->lastfind;
    }

#ifdef WITH_DNA_GHASH
    return (intptr_t)BLI_ghash_lookup(sdna->structs_map, str) - 1;
#else
    {
        int a;

        for(a=0; a<sdna->nr_structs; a++) {

            sp= sdna->structs[a];

            if(strcmp( sdna->types[ sp[0] ], str )==0) {
                sdna->lastfind= a;
                return a;
            }
        }
    }
    return -1;
#endif
}

/* ************************* END DIV ********************** */

/* ************************* READ DNA ********************** */

static void init_structDNA(SDNA *sdna, int do_endian_swap)
/* in sdna->data the data, now we convert that to something understandable */
{
    int *data, *verg, gravity_fix= -1;
    intptr_t nr;
    short *sp;
    char str[8], *cp;
    
    verg= (int *)str;
    data= (int *)sdna->data;

    strcpy(str, "SDNA");
    if( *data == *verg ) {
    
        data++;
        
        /* load names array */
        strcpy(str, "NAME");
        if( *data == *verg ) {
            data++;
            
            if(do_endian_swap) sdna->nr_names= le_int(*data);
            else sdna->nr_names= *data;
            
            data++;
            sdna->names= MEM_callocN( sizeof(void *)*sdna->nr_names, "sdnanames");
        }
        else {
            printf("NAME error in SDNA file\n");
            return;
        }
        
        nr= 0;
        cp= (char *)data;
        while(nr<sdna->nr_names) {
            sdna->names[nr]= cp;

            /* "float gravity [3]" was parsed wrong giving both "gravity" and
               "[3]"  members. we rename "[3]", and later set the type of
               "gravity" to "void" so the offsets work out correct */
            if(*cp == '[' && strcmp(cp, "[3]")==0) {
                if(nr && strcmp(sdna->names[nr-1], "Cvi") == 0) {
                    sdna->names[nr]= "gravity[3]";
                    gravity_fix= nr;
                }
            }

            while( *cp) cp++;
            cp++;
            nr++;
        }
        nr= (intptr_t)cp;       /* prevent BUS error */
        nr= (nr+3) & ~3;
        cp= (char *)nr;
        
        /* load type names array */
        data= (int *)cp;
        strcpy(str, "TYPE");
        if( *data == *verg ) {
            data++;
            
            if(do_endian_swap) sdna->nr_types= le_int(*data);
            else sdna->nr_types= *data;
            
            data++;
            sdna->types= MEM_callocN( sizeof(void *)*sdna->nr_types, "sdnatypes");
        }
        else {
            printf("TYPE error in SDNA file\n");
            return;
        }
        
        nr= 0;
        cp= (char *)data;
        while(nr<sdna->nr_types) {
            sdna->types[nr]= cp;
            
            /* this is a patch, to change struct names without a confict with SDNA */
            /* be careful to use it, in this case for a system-struct (opengl/X) */
            
            if( *cp == 'b') {
                /* struct Screen was already used by X, 'bScreen' replaces the old IrisGL 'Screen' struct */
                if( strcmp("bScreen", cp)==0 ) sdna->types[nr]= cp+1;
            }
            
            while( *cp) cp++;
            cp++;
            nr++;
        }
        nr= (intptr_t)cp;       /* prevent BUS error */
        nr= (nr+3) & ~3;
        cp= (char *)nr;
        
        /* load typelen array */
        data= (int *)cp;
        strcpy(str, "TLEN");
        if( *data == *verg ) {
            data++;
            sp= (short *)data;
            sdna->typelens= sp;
            
            if(do_endian_swap) {
                short a, *spo= sp;
                
                a= sdna->nr_types;
                while(a--) {
                    spo[0]= le_short(spo[0]);
                    spo++;
                }
            }
            
            sp+= sdna->nr_types;
        }
        else {
            printf("TLEN error in SDNA file\n");
            return;
        }
        if(sdna->nr_types & 1) sp++;    /* prevent BUS error */

        /* load struct array */
        data= (int *)sp;
        strcpy(str, "STRC");
        if( *data == *verg ) {
            data++;
            
            if(do_endian_swap) sdna->nr_structs= le_int(*data);
            else sdna->nr_structs= *data;
            
            data++;
            sdna->structs= MEM_callocN( sizeof(void *)*sdna->nr_structs, "sdnastrcs");
        }
        else {
            printf("STRC error in SDNA file\n");
            return;
        }
        
        nr= 0;
        sp= (short *)data;
        while(nr<sdna->nr_structs) {
            sdna->structs[nr]= sp;
            
            if(do_endian_swap) {
                short a;
                
                sp[0]= le_short(sp[0]);
                sp[1]= le_short(sp[1]);
                
                a= sp[1];
                sp+= 2;
                while(a--) {
                    sp[0]= le_short(sp[0]);
                    sp[1]= le_short(sp[1]);
                    sp+= 2;
                }
            }
            else {
                sp+= 2*sp[1]+2;
            }
            
            nr++;
        }

        /* finally pointerlen: use struct ListBase to test it, never change the size of it! */
        sp= findstruct_name(sdna, "ListBase");
        /* weird; i have no memory of that... I think I used sizeof(void *) before... (ton) */
        
        sdna->pointerlen= sdna->typelens[ sp[0] ]/2;

        if(sp[1]!=2 || (sdna->pointerlen!=4 && sdna->pointerlen!=8)) {
            printf("ListBase struct error! Needs it to calculate pointerize.\n");
            exit(0);
            /* well, at least sizeof(ListBase) is error proof! (ton) */
        }
        
        /* second part of gravity problem, setting "gravity" type to void */
        if(gravity_fix > -1) {
            for(nr=0; nr<sdna->nr_structs; nr++) {
                sp= sdna->structs[nr];
                if(strcmp(sdna->types[sp[0]], "ClothSimSettings") == 0)
                    sp[10]= SDNA_TYPE_VOID;
            }
        }

#ifdef WITH_DNA_GHASH
        /* create a ghash lookup to speed up */
        sdna->structs_map= BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "init_structDNA gh");

        for(nr = 0; nr < sdna->nr_structs; nr++) {
            sp= sdna->structs[nr];
            BLI_ghash_insert(sdna->structs_map, (void *)sdna->types[sp[0]], (void *)(nr + 1));
        }
#endif
    }
}

SDNA *DNA_sdna_from_data(void *data, int datalen, int do_endian_swap)
{
    SDNA *sdna= MEM_mallocN(sizeof(*sdna), "sdna");
    
    sdna->lastfind= 0;

    sdna->datalen= datalen;
    sdna->data= MEM_mallocN(datalen, "sdna_data");
    memcpy(sdna->data, data, datalen);
    
    init_structDNA(sdna, do_endian_swap);
    
    return sdna;
}

/* ******************** END READ DNA ********************** */

/* ******************* HANDLE DNA ***************** */

static void recurs_test_compflags(SDNA *sdna, char *compflags, int structnr)
{
    int a, b, typenr, elems;
    short *sp;
    const char *cp;
    
    /* check all structs, test if it's inside another struct */
    sp= sdna->structs[structnr];
    typenr= sp[0];
    
    for(a=0; a<sdna->nr_structs; a++) {
        if(a!=structnr && compflags[a]==1) {
            sp= sdna->structs[a];
            elems= sp[1];
            sp+= 2;
            for(b=0; b<elems; b++, sp+=2) {
                if(sp[0]==typenr) {
                    cp= sdna->names[ sp[1] ];
                    if(!ispointer(cp)) {
                        compflags[a]= 2;
                        recurs_test_compflags(sdna, compflags, a);
                    }
                }
            }
        }
    }
    
}

    /* Unsure of exact function - compares the sdna argument to
     * newsdna and sets up the information necessary to convert
     * data written with a dna of oldsdna to inmemory data with a
     * structure defined by the newsdna sdna (I think). -zr
     */

/* well, the function below is just a lookup table to speed
 * up reading files. doh! -ton
 */


char *DNA_struct_get_compareflags(SDNA *sdna, SDNA *newsdna)
{
    /* flag: 0: doesn't exist anymore (or not yet)
     *       1: is equal
     *       2: is different
     */
    int a, b;
    short *spold, *spcur;
    const char *str1, *str2;
    char *compflags;
    
    if(sdna->nr_structs==0) {
        printf("error: file without SDNA\n");
        return NULL;
    }
        
    compflags= MEM_callocN(sdna->nr_structs, "compflags");

    /* we check all structs in 'sdna' and compare them with 
     * the structs in 'newsdna'
     */
    
    for(a=0; a<sdna->nr_structs; a++) {
        spold= sdna->structs[a];
        
        /* search for type in cur */
        spcur= findstruct_name(newsdna, sdna->types[spold[0]]);
        
        if(spcur) {
            compflags[a]= 2;
            
            /* compare length and amount of elems */
            if( spcur[1] == spold[1]) {
                if( newsdna->typelens[spcur[0]] == sdna->typelens[spold[0]] ) {

                    /* same length, same amount of elems, now per type and name */
                    b= spold[1];
                    spold+= 2;
                    spcur+= 2;
                    while(b > 0) {
                        str1= newsdna->types[spcur[0]];
                        str2= sdna->types[spold[0]];
                        if(strcmp(str1, str2)!=0) break;

                        str1= newsdna->names[spcur[1]];
                        str2= sdna->names[spold[1]];
                        if(strcmp(str1, str2)!=0) break;

                        /* same type and same name, now pointersize */
                        if(ispointer(str1)) {
                            if(sdna->pointerlen!=newsdna->pointerlen) break;
                        }

                        b--;
                        spold+= 2;
                        spcur+= 2;
                    }
                    if(b==0) compflags[a]= 1;

                }
            }
            
        }
    }

    /* first struct in util.h is struct Link, this is skipped in compflags (als # 0).
     * was a bug, and this way dirty patched! Solve this later....
     */
    compflags[0]= 1;

    /* Because structs can be inside structs, we recursively
     * set flags when a struct is altered
     */
    for(a=0; a<sdna->nr_structs; a++) {
        if(compflags[a]==2) recurs_test_compflags(sdna, compflags, a);
    }
    
/*
    for(a=0; a<sdna->nr_structs; a++) {
        if(compflags[a]==2) {
            spold= sdna->structs[a];
            printf("changed: %s\n", sdna->types[ spold[0] ]);
        }
    }
*/

    return compflags;
}

static eSDNA_Type sdna_type_nr(const char *dna_type)
{
    if     ((strcmp(dna_type, "char")==0) || (strcmp(dna_type, "const char")==0))         return SDNA_TYPE_CHAR;
    else if((strcmp(dna_type, "uchar")==0) || (strcmp(dna_type, "unsigned char")==0))     return SDNA_TYPE_UCHAR;
    else if( strcmp(dna_type, "short")==0)                                                return SDNA_TYPE_SHORT;
    else if((strcmp(dna_type, "ushort")==0)||(strcmp(dna_type, "unsigned short")==0))     return SDNA_TYPE_USHORT;
    else if( strcmp(dna_type, "int")==0)                                                  return SDNA_TYPE_INT;
    else if( strcmp(dna_type, "long")==0)                                                 return SDNA_TYPE_LONG;
    else if((strcmp(dna_type, "ulong")==0)||(strcmp(dna_type, "unsigned long")==0))       return SDNA_TYPE_ULONG;
    else if( strcmp(dna_type, "float")==0)                                                return SDNA_TYPE_FLOAT;
    else if( strcmp(dna_type, "double")==0)                                               return SDNA_TYPE_DOUBLE;
    else if( strcmp(dna_type, "int64_t")==0)                                              return SDNA_TYPE_INT64;
    else if( strcmp(dna_type, "uint64_t")==0)                                             return SDNA_TYPE_UINT64;
    else                                                                                  return -1; /* invalid! */
}

static void cast_elem(const char *ctype, const char *otype, const char *name, char *curdata, char *olddata)
{
    double val = 0.0;
    int arrlen, curlen=1, oldlen=1;

    eSDNA_Type ctypenr, otypenr;

    arrlen= DNA_elem_array_size(name, strlen(name));

    if ( (otypenr= sdna_type_nr(otype)) == -1 ||
         (ctypenr= sdna_type_nr(ctype)) == -1 )
    {
        return;
    }

    /* define lengths */
    oldlen= DNA_elem_type_size(otypenr);
    curlen= DNA_elem_type_size(ctypenr);

    while(arrlen>0) {
        switch(otypenr) {
        case SDNA_TYPE_CHAR:
            val= *olddata; break;
        case SDNA_TYPE_UCHAR:
            val= *( (unsigned char *)olddata); break;
        case SDNA_TYPE_SHORT:
            val= *( (short *)olddata); break;
        case SDNA_TYPE_USHORT:
            val= *( (unsigned short *)olddata); break;
        case SDNA_TYPE_INT:
            val= *( (int *)olddata); break;
        case SDNA_TYPE_LONG:
            val= *( (int *)olddata); break;
        case SDNA_TYPE_ULONG:
            val= *( (unsigned int *)olddata); break;
        case SDNA_TYPE_FLOAT:
            val= *( (float *)olddata); break;
        case SDNA_TYPE_DOUBLE:
            val= *( (double *)olddata); break;
        case SDNA_TYPE_INT64:
            val= *( (int64_t *)olddata); break;
        case SDNA_TYPE_UINT64:
            val= *( (uint64_t *)olddata); break;
        }
        
        switch(ctypenr) {
        case SDNA_TYPE_CHAR:
            *curdata= val; break;
        case SDNA_TYPE_UCHAR:
            *( (unsigned char *)curdata)= val; break;
        case SDNA_TYPE_SHORT:
            *( (short *)curdata)= val; break;
        case SDNA_TYPE_USHORT:
            *( (unsigned short *)curdata)= val; break;
        case SDNA_TYPE_INT:
            *( (int *)curdata)= val; break;
        case SDNA_TYPE_LONG:
            *( (int *)curdata)= val; break;
        case SDNA_TYPE_ULONG:
            *( (unsigned int *)curdata)= val; break;
        case SDNA_TYPE_FLOAT:
            if(otypenr<2) val/= 255;
            *( (float *)curdata)= val; break;
        case SDNA_TYPE_DOUBLE:
            if(otypenr<2) val/= 255;
            *( (double *)curdata)= val; break;
        case SDNA_TYPE_INT64:
            *( (int64_t *)curdata)= val; break;
        case SDNA_TYPE_UINT64:
            *( (uint64_t *)curdata)= val; break;
        }

        olddata+= oldlen;
        curdata+= curlen;
        arrlen--;
    }
}

static void cast_pointer(int curlen, int oldlen, const char *name, char *curdata, char *olddata)
{
#ifdef WIN32
    __int64 lval;
#else
    long long lval;
#endif
    int arrlen;
    
    arrlen= DNA_elem_array_size(name, strlen(name));
    
    while(arrlen>0) {
    
        if(curlen==oldlen) {
            memcpy(curdata, olddata, curlen);
        }
        else if(curlen==4 && oldlen==8) {
#ifdef WIN32            
            lval= *( (__int64 *)olddata );
#else
            lval= *( (long long *)olddata );
#endif
            *((int *)curdata) = lval>>3;        /* is of course gambling! */
        }
        else if(curlen==8 && oldlen==4) {
#ifdef WIN32
             *( (__int64 *)curdata ) = *((int *)olddata);
#else
             *( (long long *)curdata ) = *((int *)olddata);
#endif
        }
        else {
            /* for debug */
            printf("errpr: illegal pointersize! \n");
        }
        
        olddata+= oldlen;
        curdata+= curlen;
        arrlen--;

    }
}

static int elem_strcmp(const char *name, const char *oname)
{
    int a=0;
    
    /* strcmp without array part */
    
    while(1) {
        if(name[a] != oname[a]) return 1;
        if(name[a]=='[') break;
        if(name[a]==0) break;
        a++;
    }
    return 0;
}

static char *find_elem(SDNA *sdna, const char *type, const char *name, short *old, char *olddata, short **sppo)
{
    int a, elemcount, len;
    const char *otype, *oname;
    
    /* without arraypart, so names can differ: return old namenr and type */
    
    /* in old is the old struct */
    elemcount= old[1];
    old+= 2;
    for(a=0; a<elemcount; a++, old+=2) {
    
        otype= sdna->types[old[0]];
        oname= sdna->names[old[1]];
        
        len= elementsize(sdna, old[0], old[1]);
        
        if( elem_strcmp(name, oname)==0 ) { /* naam equal */
            if( strcmp(type, otype)==0 ) {  /* type equal */
                if(sppo) *sppo= old;
                return olddata;
            }
            
            return NULL;
        }
        
        olddata+= len;
    }
    return NULL;
}

static void reconstruct_elem(SDNA *newsdna, SDNA *oldsdna,
                             char *type, const char *name, char *curdata, short *old, char *olddata)
{
    /* rules: test for NAME:
            - name equal:
                - cast type
            - name partially equal (array differs)
                - type equal: memcpy
                - types casten
       (nzc 2-4-2001 I want the 'unsigned' bit to be parsed as well. Where
       can I force this?)
    */  
    int a, elemcount, len, array, oldsize, cursize, mul;
    char *otype;
    const char *oname, *cp;
    
    /* is 'name' an array? */
    cp= name;
    array= 0;
    while( *cp && *cp!='[') {
        cp++; array++;
    }
    if( *cp!= '[' ) array= 0;
    
    /* in old is the old struct */
    elemcount= old[1];
    old+= 2;
    for(a=0; a<elemcount; a++, old+=2) {
        otype= oldsdna->types[old[0]];
        oname= oldsdna->names[old[1]];
        len= elementsize(oldsdna, old[0], old[1]);
        
        if( strcmp(name, oname)==0 ) {  /* name equal */
            
            if(ispointer(name)) {   /* pointer of functionpointer afhandelen */
                cast_pointer(newsdna->pointerlen, oldsdna->pointerlen, name, curdata, olddata);
            }
            else if( strcmp(type, otype)==0 ) { /* type equal */
                memcpy(curdata, olddata, len);
            }
            else cast_elem(type, otype, name, curdata, olddata);

            return;
        }
        else if(array) {        /* name is an array */

            if(oname[array]=='[' && strncmp(name, oname, array)==0 ) {          /* basis equal */
                
                cursize= DNA_elem_array_size(name, strlen(name));
                oldsize= DNA_elem_array_size(oname, strlen(oname));

                if(ispointer(name)) {       /* handle pointer or functionpointer */
                    if(cursize>oldsize) cast_pointer(newsdna->pointerlen, oldsdna->pointerlen, oname, curdata, olddata);
                    else cast_pointer(newsdna->pointerlen, oldsdna->pointerlen, name, curdata, olddata);
                }
                else if(name[0]=='*' || strcmp(type, otype)==0 ) {  /* type equal */
                    mul= len/oldsize;
                    mul*= (cursize < oldsize)? cursize: oldsize;
                    memcpy(curdata, olddata, mul);
                    
                    /* terminate strings */
                    if(oldsize > cursize && strcmp(type, "char")==0)
                        curdata[mul-1]= 0;
                }
                else {
                    if(cursize>oldsize) cast_elem(type, otype, oname, curdata, olddata);
                    else cast_elem(type, otype, name, curdata, olddata);
                }
                return;
            }
        }
        olddata+= len;
    }
}

static void reconstruct_struct(SDNA *newsdna, SDNA *oldsdna,
                               char *compflags, int oldSDNAnr, char *data, int curSDNAnr, char *cur)
{
    /* Recursive!
     * Per element from cur_struct, read data from old_struct.
     * If element is a struct, call recursive.
     */
    int a, elemcount, elen, eleno, mul, mulo, firststructtypenr;
    short *spo, *spc, *sppo;
    char *type, *cpo, *cpc;
    const char *name, *nameo;

    if(oldSDNAnr== -1) return;
    if(curSDNAnr== -1) return;

    if( compflags[oldSDNAnr]==1 ) {     /* if recursive: test for equal */
    
        spo= oldsdna->structs[oldSDNAnr];
        elen= oldsdna->typelens[ spo[0] ];
        memcpy( cur, data, elen);
        
        return;
    }

    firststructtypenr= *(newsdna->structs[0]);

    spo= oldsdna->structs[oldSDNAnr];
    spc= newsdna->structs[curSDNAnr];

    elemcount= spc[1];

    spc+= 2;
    cpc= cur;
    for(a=0; a<elemcount; a++, spc+=2) {
        type= newsdna->types[spc[0]];
        name= newsdna->names[spc[1]];
        
        elen= elementsize(newsdna, spc[0], spc[1]);

        /* test: is type a struct? */
        if(spc[0]>=firststructtypenr  &&  !ispointer(name)) {
        
            /* where does the old struct data start (and is there an old one?) */
            cpo= find_elem(oldsdna, type, name, spo, data, &sppo);
            
            if(cpo) {
                oldSDNAnr= DNA_struct_find_nr(oldsdna, type);
                curSDNAnr= DNA_struct_find_nr(newsdna, type);
                
                /* array! */
                mul= DNA_elem_array_size(name, strlen(name));
                nameo= oldsdna->names[sppo[1]];
                mulo= DNA_elem_array_size(nameo, strlen(nameo));
                
                eleno= elementsize(oldsdna, sppo[0], sppo[1]);
                
                elen/= mul;
                eleno/= mulo;
                
                while(mul--) {
                    reconstruct_struct(newsdna, oldsdna, compflags, oldSDNAnr, cpo, curSDNAnr, cpc);
                    cpo+= eleno;
                    cpc+= elen;
                    
                    /* new struct array larger than old */
                    mulo--;
                    if(mulo<=0) break;
                }
            }
            else cpc+= elen;
        }
        else {

            reconstruct_elem(newsdna, oldsdna, type, name, cpc, spo, data);
            cpc+= elen;

        }
    }
}

void DNA_struct_switch_endian(SDNA *oldsdna, int oldSDNAnr, char *data)
{
    /* Recursive!
     * If element is a struct, call recursive.
     */
    int a, mul, elemcount, elen, elena, firststructtypenr;
    short *spo, *spc, skip;
    char *type, *cpo, *cur, cval;
    const char *name;

    if(oldSDNAnr== -1) return;
    firststructtypenr= *(oldsdna->structs[0]);
    
    spo= spc= oldsdna->structs[oldSDNAnr];

    elemcount= spo[1];

    spc+= 2;
    cur= data;
    
    for(a=0; a<elemcount; a++, spc+=2) {
        type= oldsdna->types[spc[0]];
        name= oldsdna->names[spc[1]];
        
        /* elementsize = including arraysize */
        elen= elementsize(oldsdna, spc[0], spc[1]);

        /* test: is type a struct? */
        if(spc[0]>=firststructtypenr  &&  !ispointer(name)) {
            /* where does the old data start (is there one?) */
            cpo= find_elem(oldsdna, type, name, spo, data, NULL);
            if(cpo) {
                oldSDNAnr= DNA_struct_find_nr(oldsdna, type);
                
                mul= DNA_elem_array_size(name, strlen(name));
                elena= elen/mul;

                while(mul--) {
                    DNA_struct_switch_endian(oldsdna, oldSDNAnr, cpo);
                    cpo += elena;
                }
            }
        }
        else {
            
            if(ispointer(name)) {
                if(oldsdna->pointerlen==8) {
                    
                    mul= DNA_elem_array_size(name, strlen(name));
                    cpo= cur;
                    while(mul--) {
                        cval= cpo[0]; cpo[0]= cpo[7]; cpo[7]= cval;
                        cval= cpo[1]; cpo[1]= cpo[6]; cpo[6]= cval;
                        cval= cpo[2]; cpo[2]= cpo[5]; cpo[5]= cval;
                        cval= cpo[3]; cpo[3]= cpo[4]; cpo[4]= cval;
                        
                        cpo+= 8;
                    }
                    
                }
            }
            else {
                
                if ( spc[0]==SDNA_TYPE_SHORT ||
                     spc[0]==SDNA_TYPE_USHORT )
                {
                    
                    /* exception: variable called blocktype/ipowin: derived from ID_  */
                    skip= 0;
                    if(name[0]=='b' && name[1]=='l') {
                        if(strcmp(name, "blocktype")==0) skip= 1;
                    }
                    else if(name[0]=='i' && name[1]=='p') {
                        if(strcmp(name, "ipowin")==0) skip= 1;
                    }
                    
                    if(skip==0) {
                        mul= DNA_elem_array_size(name, strlen(name));
                        cpo= cur;
                        while(mul--) {
                            cval= cpo[0];
                            cpo[0]= cpo[1];
                            cpo[1]= cval;
                            cpo+= 2;
                        }
                    }
                }
                else if ( (spc[0]==SDNA_TYPE_INT    ||
                           spc[0]==SDNA_TYPE_LONG   ||
                           spc[0]==SDNA_TYPE_ULONG  ||
                           spc[0]==SDNA_TYPE_FLOAT))
                {

                    mul= DNA_elem_array_size(name, strlen(name));
                    cpo= cur;
                    while(mul--) {
                        cval= cpo[0];
                        cpo[0]= cpo[3];
                        cpo[3]= cval;
                        cval= cpo[1];
                        cpo[1]= cpo[2];
                        cpo[2]= cval;
                        cpo+= 4;
                    }
                }
                else if ( (spc[0]==SDNA_TYPE_INT64) ||
                          (spc[0]==SDNA_TYPE_UINT64))
                {
                    mul= DNA_elem_array_size(name, strlen(name));
                    cpo= cur;
                    while(mul--) {
                        cval= cpo[0]; cpo[0]= cpo[7]; cpo[7]= cval;
                        cval= cpo[1]; cpo[1]= cpo[6]; cpo[6]= cval;
                        cval= cpo[2]; cpo[2]= cpo[5]; cpo[5]= cval;
                        cval= cpo[3]; cpo[3]= cpo[4]; cpo[4]= cval;

                        cpo+= 8;
                    }
                }
            }
        }
        cur+= elen;
    }
}

void *DNA_struct_reconstruct(SDNA *newsdna, SDNA *oldsdna, char *compflags, int oldSDNAnr, int blocks, void *data)
{
    int a, curSDNAnr, curlen=0, oldlen;
    short *spo, *spc;
    char *cur, *type, *cpc, *cpo;
    
    /* oldSDNAnr == structnr, we're looking for the corresponding 'cur' number */
    spo= oldsdna->structs[oldSDNAnr];
    type= oldsdna->types[ spo[0] ];
    oldlen= oldsdna->typelens[ spo[0] ];
    curSDNAnr= DNA_struct_find_nr(newsdna, type);

    /* init data and alloc */
    if(curSDNAnr >= 0) {
        spc= newsdna->structs[curSDNAnr];
        curlen= newsdna->typelens[ spc[0] ];
    }
    if(curlen==0) {
        return NULL;
    }

    cur= MEM_callocN( blocks*curlen, "reconstruct");
    cpc= cur;
    cpo= data;
    for(a=0; a<blocks; a++) {
        reconstruct_struct(newsdna, oldsdna, compflags, oldSDNAnr, cpo, curSDNAnr, cpc);
        cpc+= curlen;
        cpo+= oldlen;
    }

    return cur;
}

int DNA_elem_offset(SDNA *sdna, const char *stype, const char *vartype, const char *name)
{
    
    int SDNAnr= DNA_struct_find_nr(sdna, stype);
    short *spo= sdna->structs[SDNAnr];
    char *cp= find_elem(sdna, vartype, name, spo, NULL, NULL);
    return (int)((intptr_t)cp);
}

int DNA_elem_type_size(const eSDNA_Type elem_nr)
{
    /* should containt all enum types */
    switch (elem_nr) {
        case SDNA_TYPE_CHAR:
        case SDNA_TYPE_UCHAR:
            return 1;
        case SDNA_TYPE_SHORT:
        case SDNA_TYPE_USHORT:
            return 2;
        case SDNA_TYPE_INT:
        case SDNA_TYPE_LONG:
        case SDNA_TYPE_ULONG:
        case SDNA_TYPE_FLOAT:
            return 4;
        case SDNA_TYPE_DOUBLE:
        case SDNA_TYPE_INT64:
        case SDNA_TYPE_UINT64:
            return 8;
    }

    /* weak */
    return 8;
}