writefile: reuse SDNA between writes
[blender.git] / source / blender / makesdna / intern / dna_genfile.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  * DNA handling
27  */
28
29 /** \file blender/makesdna/intern/dna_genfile.c
30  *  \ingroup DNA
31  *
32  * Lowest-level functions for decoding the parts of a saved .blend
33  * file, including interpretation of its SDNA block and conversion of
34  * contents of other parts according to the differences between that
35  * SDNA and the SDNA of the current (running) version of Blender.
36  */
37
38
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <limits.h>
43
44 #include "MEM_guardedalloc.h" // for MEM_freeN MEM_mallocN MEM_callocN
45
46 #include "BLI_utildefines.h"
47 #include "BLI_endian_switch.h"
48
49 #ifdef WITH_DNA_GHASH
50 #  include "BLI_ghash.h"
51 #endif
52
53 #include "DNA_genfile.h"
54 #include "DNA_sdna_types.h" // for SDNA ;-)
55
56 /**
57  * \section dna_genfile Overview
58  *
59  * - please note: no builtin security to detect input of double structs
60  * - if you want a struct not to be in DNA file: add two hash marks above it (#<enter>#<enter>)
61  *
62  * Structure DNA data is added to each blender file and to each executable, this to detect
63  * in .blend files new variables in structs, changed array sizes, etc. It's also used for
64  * converting endian and pointer size (32-64 bits)
65  * As an extra, Python uses a call to detect run-time the contents of a blender struct.
66  *
67  * Create a structDNA: only needed when one of the input include (.h) files change.
68  * File Syntax:
69  * \code{.unparsed}
70  *     SDNA (4 bytes) (magic number)
71  *     NAME (4 bytes)
72  *     <nr> (4 bytes) amount of names (int)
73  *     <string>
74  *     <string>
75  *     ...
76  *     ...
77  *     TYPE (4 bytes)
78  *     <nr> amount of types (int)
79  *     <string>
80  *     <string>
81  *     ...
82  *     ...
83  *     TLEN (4 bytes)
84  *     <len> (short) the lengths of types
85  *     <len>
86  *     ...
87  *     ...
88  *     STRC (4 bytes)
89  *     <nr> amount of structs (int)
90  *     <typenr><nr_of_elems> <typenr><namenr> <typenr><namenr> ...
91  * \endcode
92  *
93  *  **Remember to read/write integer and short aligned!**
94  *
95  *  While writing a file, the names of a struct is indicated with a type number,
96  *  to be found with: ``type = DNA_struct_find_nr(SDNA *, const char *)``
97  *  The value of ``type`` corresponds with the index within the structs array
98  *
99  *  For the moment: the complete DNA file is included in a .blend file. For
100  *  the future we can think of smarter methods, like only included the used
101  *  structs. Only needed to keep a file short though...
102  *
103  * ALLOWED AND TESTED CHANGES IN STRUCTS:
104  *  - type change (a char to float will be divided by 255)
105  *  - location within a struct (everthing can be randomly mixed up)
106  *  - struct within struct (within struct etc), this is recursive
107  *  - adding new elements, will be default initialized zero
108  *  - removing elements
109  *  - change of array sizes
110  *  - change of a pointer type: when the name doesn't change the contents is copied
111  *
112  * NOT YET:
113  *  - array (``vec[3]``) to float struct (``vec3f``)
114  *
115  * DONE:
116  *  - endian compatibility
117  *  - pointer conversion (32-64 bits)
118  *
119  * IMPORTANT:
120  *  - do not use #defines in structs for array lengths, this cannot be read by the dna functions
121  *  - do not use uint, but unsigned int instead, ushort and ulong are allowed
122  *  - only use a long in Blender if you want this to be the size of a pointer. so it is
123  *    32 bits or 64 bits, dependent at the cpu architecture
124  *  - chars are always unsigned
125  *  - alignment of variables has to be done in such a way, that any system does
126  *    not create 'padding' (gaps) in structures. So make sure that:
127  *    - short: 2 aligned
128  *    - int: 4 aligned
129  *    - float: 4 aligned
130  *    - double: 8 aligned
131  *    - long: 8 aligned
132  *    - struct: 8 aligned
133  *  - the sdna functions have several error prints builtin, always check blender running from a console.
134  *
135  */
136
137 /* ************************* ENDIAN STUFF ********************** */
138
139 /**
140  * converts a short between big/little endian.
141  */
142 static short le_short(short temp)
143 {
144         short new;
145         char *rt = (char *)&temp, *rtn = (char *)&new;
146
147         rtn[0] = rt[1];
148         rtn[1] = rt[0];
149
150         return new;
151 }
152
153 /**
154  * converts an int between big/little endian.
155  */
156 static int le_int(int temp)
157 {
158         int new;
159         char *rt = (char *)&temp, *rtn = (char *)&new;
160
161         rtn[0] = rt[3];
162         rtn[1] = rt[2];
163         rtn[2] = rt[1];
164         rtn[3] = rt[0];
165
166         return new;
167 }
168
169
170 /* ************************* MAKE DNA ********************** */
171
172 /* allowed duplicate code from makesdna.c */
173
174 /**
175  * parses the "[n]" on the end of an array name and returns the number of array elements n.
176  */
177 int DNA_elem_array_size(const char *str)
178 {
179         int a, mul = 1;
180         const char *cp = NULL;
181
182         for (a = 0; str[a]; a++) {
183                 if (str[a] == '[') {
184                         cp = &(str[a + 1]);
185                 }
186                 else if (str[a] == ']' && cp) {
187                         mul *= atoi(cp);
188                 }
189         }
190
191         return mul;
192 }
193
194 /* ************************* END MAKE DNA ********************** */
195
196 /* ************************* DIV ********************** */
197
198 void DNA_sdna_free(SDNA *sdna)
199 {
200         if (sdna->data_alloc) {
201                 MEM_freeN((void *)sdna->data);
202         }
203
204         MEM_freeN((void *)sdna->names);
205         MEM_freeN(sdna->types);
206         MEM_freeN(sdna->structs);
207
208 #ifdef WITH_DNA_GHASH
209         BLI_ghash_free(sdna->structs_map, NULL, NULL);
210 #endif
211
212         MEM_freeN(sdna);
213 }
214
215 /**
216  * Return true if the name indicates a pointer of some kind.
217  */
218 static bool ispointer(const char *name)
219 {
220         /* check if pointer or function pointer */
221         return (name[0] == '*' || (name[0] == '(' && name[1] == '*'));
222 }
223
224 /**
225  * Returns the size of struct fields of the specified type and name.
226  *
227  * \param type  Index into sdna->types/typelens
228  * \param name  Index into sdna->names,
229  * needed to extract possible pointer/array information.
230  */
231 static int elementsize(const SDNA *sdna, short type, short name)
232 {
233         int mul, namelen, len;
234         const char *cp;
235         
236         cp = sdna->names[name];
237         len = 0;
238         
239         namelen = strlen(cp);
240         /* is it a pointer or function pointer? */
241         if (ispointer(cp)) {
242                 /* has the name an extra length? (array) */
243                 mul = 1;
244                 if (cp[namelen - 1] == ']') {
245                         mul = DNA_elem_array_size(cp);
246                 }
247                 
248                 len = sdna->pointerlen * mul;
249         }
250         else if (sdna->typelens[type]) {
251                 /* has the name an extra length? (array) */
252                 mul = 1;
253                 if (cp[namelen - 1] == ']') {
254                         mul = DNA_elem_array_size(cp);
255                 }
256                 
257                 len = mul * sdna->typelens[type];
258                 
259         }
260         
261         return len;
262 }
263
264 #if 0
265 static void printstruct(SDNA *sdna, short strnr)
266 {
267         /* is for debug */
268         int b, nr;
269         short *sp;
270         
271         sp = sdna->structs[strnr];
272         
273         printf("struct %s\n", sdna->types[sp[0]]);
274         nr = sp[1];
275         sp += 2;
276         
277         for (b = 0; b < nr; b++, sp += 2) {
278                 printf("   %s %s\n", sdna->types[sp[0]], sdna->names[sp[1]]);
279         }
280 }
281 #endif
282
283 /**
284  * Returns the index of the struct info for the struct with the specified name.
285  */
286 int DNA_struct_find_nr_ex(const SDNA *sdna, const char *str, unsigned int *index_last)
287 {
288         const short *sp = NULL;
289
290         if (*index_last < sdna->nr_structs) {
291                 sp = sdna->structs[*index_last];
292                 if (strcmp(sdna->types[sp[0]], str) == 0) {
293                         return *index_last;
294                 }
295         }
296
297 #ifdef WITH_DNA_GHASH
298         {
299                 void **index_p;
300                 int a;
301
302                 index_p = BLI_ghash_lookup_p(sdna->structs_map, str);
303
304                 if (index_p) {
305                         a = GET_INT_FROM_POINTER(*index_p);
306                         *index_last = a;
307                 }
308                 else {
309                         a = -1;
310                 }
311                 return a;
312         }
313 #else
314         {
315                 int a;
316
317                 for (a = 0; a < sdna->nr_structs; a++) {
318
319                         sp = sdna->structs[a];
320
321                         if (strcmp(sdna->types[sp[0]], str) == 0) {
322                                 *index_last = a;
323                                 return a;
324                         }
325                 }
326         }
327         return -1;
328 #endif
329 }
330
331 int DNA_struct_find_nr(const SDNA *sdna, const char *str)
332 {
333         unsigned int index_last_dummy = UINT_MAX;
334         return DNA_struct_find_nr_ex(sdna, str, &index_last_dummy);
335 }
336
337 /* ************************* END DIV ********************** */
338
339 /* ************************* READ DNA ********************** */
340
341 /**
342  * In sdna->data the data, now we convert that to something understandable
343  */
344 static bool init_structDNA(
345         SDNA *sdna, bool do_endian_swap,
346         const char **r_error_message)
347 {
348         int *data, *verg, gravity_fix = -1;
349         short *sp;
350         char str[8];
351         
352         verg = (int *)str;
353         data = (int *)sdna->data;
354
355         /* clear pointers incase of error */
356         sdna->names = NULL;
357         sdna->types = NULL;
358         sdna->structs = NULL;
359 #ifdef WITH_DNA_GHASH
360         sdna->structs_map = NULL;
361 #endif
362
363         strcpy(str, "SDNA");
364         if (*data != *verg) {
365                 *r_error_message = "SDNA error in SDNA file";
366                 return false;
367         }
368         else {
369                 intptr_t nr;
370                 char *cp;
371
372                 data++;
373                 
374                 /* load names array */
375                 strcpy(str, "NAME");
376                 if (*data == *verg) {
377                         data++;
378                         
379                         if (do_endian_swap) sdna->nr_names = le_int(*data);
380                         else sdna->nr_names = *data;
381                         
382                         data++;
383                         sdna->names = MEM_callocN(sizeof(void *) * sdna->nr_names, "sdnanames");
384                 }
385                 else {
386                         *r_error_message = "NAME error in SDNA file";
387                         return false;
388                 }
389                 
390                 nr = 0;
391                 cp = (char *)data;
392                 while (nr < sdna->nr_names) {
393                         sdna->names[nr] = cp;
394
395                         /* "float gravity [3]" was parsed wrong giving both "gravity" and
396                          * "[3]"  members. we rename "[3]", and later set the type of
397                          * "gravity" to "void" so the offsets work out correct */
398                         if (*cp == '[' && strcmp(cp, "[3]") == 0) {
399                                 if (nr && strcmp(sdna->names[nr - 1], "Cvi") == 0) {
400                                         sdna->names[nr] = "gravity[3]";
401                                         gravity_fix = nr;
402                                 }
403                         }
404
405                         while (*cp) cp++;
406                         cp++;
407                         nr++;
408                 }
409                 nr = (intptr_t)cp;       /* prevent BUS error */
410                 nr = (nr + 3) & ~3;
411                 cp = (char *)nr;
412                 
413                 /* load type names array */
414                 data = (int *)cp;
415                 strcpy(str, "TYPE");
416                 if (*data == *verg) {
417                         data++;
418                         
419                         if (do_endian_swap) sdna->nr_types = le_int(*data);
420                         else sdna->nr_types = *data;
421                         
422                         data++;
423                         sdna->types = MEM_callocN(sizeof(void *) * sdna->nr_types, "sdnatypes");
424                 }
425                 else {
426                         *r_error_message = "TYPE error in SDNA file";
427                         return false;
428                 }
429                 
430                 nr = 0;
431                 cp = (char *)data;
432                 while (nr < sdna->nr_types) {
433                         sdna->types[nr] = cp;
434                         
435                         /* this is a patch, to change struct names without a conflict with SDNA */
436                         /* be careful to use it, in this case for a system-struct (opengl/X) */
437                         
438                         if (*cp == 'b') {
439                                 /* struct Screen was already used by X, 'bScreen' replaces the old IrisGL 'Screen' struct */
440                                 if (strcmp("bScreen", cp) == 0) sdna->types[nr] = cp + 1;
441                         }
442                         
443                         while (*cp) cp++;
444                         cp++;
445                         nr++;
446                 }
447                 nr = (intptr_t)cp;       /* prevent BUS error */
448                 nr = (nr + 3) & ~3;
449                 cp = (char *)nr;
450                 
451                 /* load typelen array */
452                 data = (int *)cp;
453                 strcpy(str, "TLEN");
454                 if (*data == *verg) {
455                         data++;
456                         sp = (short *)data;
457                         sdna->typelens = sp;
458                         
459                         if (do_endian_swap) {
460                                 short a, *spo = sp;
461                                 
462                                 a = sdna->nr_types;
463                                 while (a--) {
464                                         spo[0] = le_short(spo[0]);
465                                         spo++;
466                                 }
467                         }
468                         
469                         sp += sdna->nr_types;
470                 }
471                 else {
472                         *r_error_message = "TLEN error in SDNA file";
473                         return false;
474                 }
475                 if (sdna->nr_types & 1) sp++;   /* prevent BUS error */
476
477                 /* load struct array */
478                 data = (int *)sp;
479                 strcpy(str, "STRC");
480                 if (*data == *verg) {
481                         data++;
482                         
483                         if (do_endian_swap) sdna->nr_structs = le_int(*data);
484                         else sdna->nr_structs = *data;
485                         
486                         data++;
487                         sdna->structs = MEM_callocN(sizeof(void *) * sdna->nr_structs, "sdnastrcs");
488                 }
489                 else {
490                         *r_error_message = "STRC error in SDNA file";
491                         return false;
492                 }
493                 
494                 nr = 0;
495                 sp = (short *)data;
496                 while (nr < sdna->nr_structs) {
497                         sdna->structs[nr] = sp;
498                         
499                         if (do_endian_swap) {
500                                 short a;
501                                 
502                                 sp[0] = le_short(sp[0]);
503                                 sp[1] = le_short(sp[1]);
504                                 
505                                 a = sp[1];
506                                 sp += 2;
507                                 while (a--) {
508                                         sp[0] = le_short(sp[0]);
509                                         sp[1] = le_short(sp[1]);
510                                         sp += 2;
511                                 }
512                         }
513                         else {
514                                 sp += 2 * sp[1] + 2;
515                         }
516                         
517                         nr++;
518                 }
519         }
520
521         {
522                 /* second part of gravity problem, setting "gravity" type to void */
523                 if (gravity_fix > -1) {
524                         for (intptr_t nr = 0; nr < sdna->nr_structs; nr++) {
525                                 sp = sdna->structs[nr];
526                                 if (strcmp(sdna->types[sp[0]], "ClothSimSettings") == 0)
527                                         sp[10] = SDNA_TYPE_VOID;
528                         }
529                 }
530         }
531
532 #ifdef WITH_DNA_GHASH
533         {
534                 /* create a ghash lookup to speed up */
535                 sdna->structs_map = BLI_ghash_str_new_ex("init_structDNA gh", sdna->nr_structs);
536
537                 for (intptr_t nr = 0; nr < sdna->nr_structs; nr++) {
538                         sp = sdna->structs[nr];
539                         BLI_ghash_insert(sdna->structs_map, sdna->types[sp[0]], SET_INT_IN_POINTER(nr));
540                 }
541         }
542 #endif
543
544         /* Calculate 'sdna->pointerlen' */
545         {
546                 intptr_t nr = DNA_struct_find_nr(sdna, "ListBase");
547
548                 /* should never happen, only with corrupt file for example */
549                 if (UNLIKELY(nr == -1)) {
550                         *r_error_message = "ListBase struct error! Not found.";
551                         return false;
552                 }
553
554                 /* finally pointerlen: use struct ListBase to test it, never change the size of it! */
555                 sp = sdna->structs[nr];
556                 /* weird; i have no memory of that... I think I used sizeof(void *) before... (ton) */
557
558                 sdna->pointerlen = sdna->typelens[sp[0]] / 2;
559
560                 if (sp[1] != 2 || (sdna->pointerlen != 4 && sdna->pointerlen != 8)) {
561                         *r_error_message = "ListBase struct error! Needs it to calculate pointerize.";
562                         /* well, at least sizeof(ListBase) is error proof! (ton) */
563                         return false;
564                 }
565         }
566
567         return true;
568 }
569
570 /**
571  * Constructs and returns a decoded SDNA structure from the given encoded SDNA data block.
572  */
573 SDNA *DNA_sdna_from_data(
574         const void *data, const int datalen,
575         bool do_endian_swap, bool data_alloc,
576         const char **r_error_message)
577 {
578         SDNA *sdna = MEM_mallocN(sizeof(*sdna), "sdna");
579         const char *error_message = NULL;
580
581         sdna->datalen = datalen;
582         if (data_alloc) {
583                 char *data_copy = MEM_mallocN(datalen, "sdna_data");
584                 memcpy(data_copy, data, datalen);
585                 sdna->data = data_copy;
586         }
587         else {
588                 sdna->data = data;
589         }
590         sdna->data_alloc = data_alloc;
591         
592
593         if (init_structDNA(sdna, do_endian_swap, &error_message)) {
594                 return sdna;
595         }
596         else {
597                 if (r_error_message == NULL) {
598                         fprintf(stderr, "Error decoding blend file SDNA: %s\n", error_message);
599                 }
600                 else {
601                         *r_error_message = error_message;
602                 }
603                 DNA_sdna_free(sdna);
604                 return NULL;
605         }
606 }
607
608 /**
609  * Using globals is acceptable here, the data is read-only and only changes between Blender versions.
610  *
611  * So it is safe to create once and reuse.
612  */
613 static SDNA *g_sdna = NULL;
614
615 void DNA_sdna_current_init(void)
616 {
617         g_sdna = DNA_sdna_from_data(DNAstr, DNAlen, false, false, NULL);
618 }
619
620 const struct SDNA *DNA_sdna_current_get(void)
621 {
622         BLI_assert(g_sdna != NULL);
623         return g_sdna;
624 }
625
626 void DNA_sdna_current_free(void)
627 {
628         DNA_sdna_free(g_sdna);
629         g_sdna = NULL;
630 }
631
632 /* ******************** END READ DNA ********************** */
633
634 /* ******************* HANDLE DNA ***************** */
635
636 /**
637  * Used by #DNA_struct_get_compareflags (below) to recursively mark all structs
638  * containing a field of type structnr as changed between old and current SDNAs.
639  */
640 static void recurs_test_compflags(const SDNA *sdna, char *compflags, int structnr)
641 {
642         int a, b, typenr, elems;
643         const short *sp;
644         const char *cp;
645         
646         /* check all structs, test if it's inside another struct */
647         sp = sdna->structs[structnr];
648         typenr = sp[0];
649         
650         for (a = 0; a < sdna->nr_structs; a++) {
651                 if ((a != structnr) && (compflags[a] == SDNA_CMP_EQUAL)) {
652                         sp = sdna->structs[a];
653                         elems = sp[1];
654                         sp += 2;
655                         for (b = 0; b < elems; b++, sp += 2) {
656                                 if (sp[0] == typenr) {
657                                         cp = sdna->names[sp[1]];
658                                         if (!ispointer(cp)) {
659                                                 compflags[a] = SDNA_CMP_NOT_EQUAL;
660                                                 recurs_test_compflags(sdna, compflags, a);
661                                         }
662                                 }
663                         }
664                 }
665         }
666         
667 }
668
669
670 /**
671  * Constructs and returns an array of byte flags with one element for each struct in oldsdna,
672  * indicating how it compares to newsdna:
673  *
674  * flag value:
675  * - 0  Struct has disappeared (values of this struct type will not be loaded by the current Blender)
676  * - 1  Struct is the same (can be loaded with straight memory copy after any necessary endian conversion)
677  * - 2  Struct is different in some way (needs to be copied/converted field by field)
678  */
679 char *DNA_struct_get_compareflags(const SDNA *oldsdna, const SDNA *newsdna)
680 {
681         int a, b;
682         const short *sp_old, *sp_new;
683         const char *str1, *str2;
684         char *compflags;
685         
686         if (oldsdna->nr_structs == 0) {
687                 printf("error: file without SDNA\n");
688                 return NULL;
689         }
690
691         compflags = MEM_callocN(oldsdna->nr_structs, "compflags");
692
693         /* we check all structs in 'oldsdna' and compare them with 
694          * the structs in 'newsdna'
695          */
696         unsigned int newsdna_index_last = 0;
697         
698         for (a = 0; a < oldsdna->nr_structs; a++) {
699                 sp_old = oldsdna->structs[a];
700                 
701                 /* search for type in cur */
702                 int sp_new_index = DNA_struct_find_nr_ex(newsdna, oldsdna->types[sp_old[0]], &newsdna_index_last);
703
704                 /* The next indices will almost always match */
705                 newsdna_index_last++;
706
707                 if (sp_new_index != -1) {
708                         sp_new = newsdna->structs[sp_new_index];
709                         /* initial assumption */
710                         compflags[a] = SDNA_CMP_NOT_EQUAL;
711                         
712                         /* compare length and amount of elems */
713                         if (sp_new[1] == sp_old[1]) {
714                                 if (newsdna->typelens[sp_new[0]] == oldsdna->typelens[sp_old[0]]) {
715
716                                         /* same length, same amount of elems, now per type and name */
717                                         b = sp_old[1];
718                                         sp_old += 2;
719                                         sp_new += 2;
720                                         while (b > 0) {
721                                                 str1 = newsdna->types[sp_new[0]];
722                                                 str2 = oldsdna->types[sp_old[0]];
723                                                 if (strcmp(str1, str2) != 0) break;
724
725                                                 str1 = newsdna->names[sp_new[1]];
726                                                 str2 = oldsdna->names[sp_old[1]];
727                                                 if (strcmp(str1, str2) != 0) break;
728
729                                                 /* same type and same name, now pointersize */
730                                                 if (ispointer(str1)) {
731                                                         if (oldsdna->pointerlen != newsdna->pointerlen) break;
732                                                 }
733
734                                                 b--;
735                                                 sp_old += 2;
736                                                 sp_new += 2;
737                                         }
738                                         if (b == 0) {
739                                                 /* no differences found */
740                                                 compflags[a] = SDNA_CMP_EQUAL;
741                                         }
742
743                                 }
744                         }
745                         
746                 }
747         }
748
749         /* first struct in util.h is struct Link, this is skipped in compflags (als # 0).
750          * was a bug, and this way dirty patched! Solve this later....
751          */
752         compflags[0] = SDNA_CMP_EQUAL;
753
754         /* Because structs can be inside structs, we recursively
755          * set flags when a struct is altered
756          */
757         for (a = 0; a < oldsdna->nr_structs; a++) {
758                 if (compflags[a] == SDNA_CMP_NOT_EQUAL) {
759                         recurs_test_compflags(oldsdna, compflags, a);
760                 }
761         }
762         
763 #if 0
764         for (a = 0; a < oldsdna->nr_structs; a++) {
765                 if (compflags[a] == SDNA_CMP_NOT_EQUAL) {
766                         spold = oldsdna->structs[a];
767                         printf("changed: %s\n", oldsdna->types[spold[0]]);
768                 }
769         }
770 #endif
771
772         return compflags;
773 }
774
775 /**
776  * Converts the name of a primitive type to its enumeration code.
777  */
778 static eSDNA_Type sdna_type_nr(const char *dna_type)
779 {
780         if     ((strcmp(dna_type, "char") == 0) || (strcmp(dna_type, "const char") == 0))          return SDNA_TYPE_CHAR;
781         else if ((strcmp(dna_type, "uchar") == 0) || (strcmp(dna_type, "unsigned char") == 0))     return SDNA_TYPE_UCHAR;
782         else if ( strcmp(dna_type, "short") == 0)                                                  return SDNA_TYPE_SHORT;
783         else if ((strcmp(dna_type, "ushort") == 0) || (strcmp(dna_type, "unsigned short") == 0))   return SDNA_TYPE_USHORT;
784         else if ( strcmp(dna_type, "int") == 0)                                                    return SDNA_TYPE_INT;
785         else if ( strcmp(dna_type, "float") == 0)                                                  return SDNA_TYPE_FLOAT;
786         else if ( strcmp(dna_type, "double") == 0)                                                 return SDNA_TYPE_DOUBLE;
787         else if ( strcmp(dna_type, "int64_t") == 0)                                                return SDNA_TYPE_INT64;
788         else if ( strcmp(dna_type, "uint64_t") == 0)                                               return SDNA_TYPE_UINT64;
789         else                                                                                       return -1; /* invalid! */
790 }
791
792 /**
793  * Converts a value of one primitive type to another.
794  * Note there is no optimization for the case where otype and ctype are the same:
795  * assumption is that caller will handle this case.
796  *
797  * \param ctype  Name of type to convert to
798  * \param otype  Name of type to convert from
799  * \param name  Field name to extract array-size information
800  * \param curdata  Where to put converted data
801  * \param olddata  Data of type otype to convert
802  */
803 static void cast_elem(
804         const char *ctype, const char *otype, const char *name,
805         char *curdata, const char *olddata)
806 {
807         double val = 0.0;
808         int arrlen, curlen = 1, oldlen = 1;
809
810         eSDNA_Type ctypenr, otypenr;
811
812         arrlen = DNA_elem_array_size(name);
813
814         if ( (otypenr = sdna_type_nr(otype)) == -1 ||
815              (ctypenr = sdna_type_nr(ctype)) == -1)
816         {
817                 return;
818         }
819
820         /* define lengths */
821         oldlen = DNA_elem_type_size(otypenr);
822         curlen = DNA_elem_type_size(ctypenr);
823
824         while (arrlen > 0) {
825                 switch (otypenr) {
826                         case SDNA_TYPE_CHAR:
827                                 val = *olddata; break;
828                         case SDNA_TYPE_UCHAR:
829                                 val = *( (unsigned char *)olddata); break;
830                         case SDNA_TYPE_SHORT:
831                                 val = *( (short *)olddata); break;
832                         case SDNA_TYPE_USHORT:
833                                 val = *( (unsigned short *)olddata); break;
834                         case SDNA_TYPE_INT:
835                                 val = *( (int *)olddata); break;
836                         case SDNA_TYPE_FLOAT:
837                                 val = *( (float *)olddata); break;
838                         case SDNA_TYPE_DOUBLE:
839                                 val = *( (double *)olddata); break;
840                         case SDNA_TYPE_INT64:
841                                 val = *( (int64_t *)olddata); break;
842                         case SDNA_TYPE_UINT64:
843                                 val = *( (uint64_t *)olddata); break;
844                 }
845                 
846                 switch (ctypenr) {
847                         case SDNA_TYPE_CHAR:
848                                 *curdata = val; break;
849                         case SDNA_TYPE_UCHAR:
850                                 *( (unsigned char *)curdata) = val; break;
851                         case SDNA_TYPE_SHORT:
852                                 *( (short *)curdata) = val; break;
853                         case SDNA_TYPE_USHORT:
854                                 *( (unsigned short *)curdata) = val; break;
855                         case SDNA_TYPE_INT:
856                                 *( (int *)curdata) = val; break;
857                         case SDNA_TYPE_FLOAT:
858                                 if (otypenr < 2) val /= 255;
859                                 *( (float *)curdata) = val; break;
860                         case SDNA_TYPE_DOUBLE:
861                                 if (otypenr < 2) val /= 255;
862                                 *( (double *)curdata) = val; break;
863                         case SDNA_TYPE_INT64:
864                                 *( (int64_t *)curdata) = val; break;
865                         case SDNA_TYPE_UINT64:
866                                 *( (uint64_t *)curdata) = val; break;
867                 }
868
869                 olddata += oldlen;
870                 curdata += curlen;
871                 arrlen--;
872         }
873 }
874
875 /**
876  * Converts pointer values between different sizes. These are only used
877  * as lookup keys to identify data blocks in the saved .blend file, not
878  * as actual in-memory pointers.
879  *
880  * \param curlen  Pointer length to conver to
881  * \param oldlen  Length of pointers in olddata
882  * \param name  Field name to extract array-size information
883  * \param curdata  Where to put converted data
884  * \param olddata  Data to convert
885  */
886 static void cast_pointer(int curlen, int oldlen, const char *name, char *curdata, const char *olddata)
887 {
888         int64_t lval;
889         int arrlen;
890         
891         arrlen = DNA_elem_array_size(name);
892         
893         while (arrlen > 0) {
894         
895                 if (curlen == oldlen) {
896                         memcpy(curdata, olddata, curlen);
897                 }
898                 else if (curlen == 4 && oldlen == 8) {
899                         lval = *((int64_t *)olddata);
900
901                         /* WARNING: 32-bit Blender trying to load file saved by 64-bit Blender,
902                          * pointers may lose uniqueness on truncation! (Hopefully this wont
903                          * happen unless/until we ever get to multi-gigabyte .blend files...) */
904                         *((int *)curdata) = lval >> 3;
905                 }
906                 else if (curlen == 8 && oldlen == 4) {
907                         *((int64_t *)curdata) = *((int *)olddata);
908                 }
909                 else {
910                         /* for debug */
911                         printf("errpr: illegal pointersize!\n");
912                 }
913                 
914                 olddata += oldlen;
915                 curdata += curlen;
916                 arrlen--;
917
918         }
919 }
920
921 /**
922  * Equality test on name and oname excluding any array-size suffix.
923  */
924 static int elem_strcmp(const char *name, const char *oname)
925 {
926         int a = 0;
927         
928         while (1) {
929                 if (name[a] != oname[a]) return 1;
930                 if (name[a] == '[' || oname[a] == '[') break;
931                 if (name[a] == 0 || oname[a] == 0) break;
932                 a++;
933         }
934         return 0;
935 }
936
937 /**
938  * Returns the address of the data for the specified field within olddata
939  * according to the struct format pointed to by old, or NULL if no such
940  * field can be found.
941  *
942  * \param sdna  Old SDNA
943  * \param type  Current field type name
944  * \param name  Current field name
945  * \param old  Pointer to struct information in sdna
946  * \param olddata  Struct data
947  * \param sppo  Optional place to return pointer to field info in sdna
948  * \return Data address.
949  */
950 static char *find_elem(
951         const SDNA *sdna,
952         const char *type,
953         const char *name,
954         const short *old,
955         char *olddata,
956         const short **sppo)
957 {
958         int a, elemcount, len;
959         const char *otype, *oname;
960         
961         /* without arraypart, so names can differ: return old namenr and type */
962         
963         /* in old is the old struct */
964         elemcount = old[1];
965         old += 2;
966         for (a = 0; a < elemcount; a++, old += 2) {
967
968                 otype = sdna->types[old[0]];
969                 oname = sdna->names[old[1]];
970
971                 len = elementsize(sdna, old[0], old[1]);
972
973                 if (elem_strcmp(name, oname) == 0) {  /* name equal */
974                         if (strcmp(type, otype) == 0) {   /* type equal */
975                                 if (sppo) *sppo = old;
976                                 return olddata;
977                         }
978                         
979                         return NULL;
980                 }
981                 
982                 olddata += len;
983         }
984         return NULL;
985 }
986
987 /**
988  * Converts the contents of a single field of a struct, of a non-struct type,
989  * from oldsdna to newsdna format.
990  *
991  * \param newsdna  SDNA of current Blender
992  * \param oldsdna  SDNA of Blender that saved file
993  * \param type  current field type name
994  * \param name  current field name
995  * \param curdata  put field data converted to newsdna here
996  * \param old  pointer to struct info in oldsdna
997  * \param olddata  struct contents laid out according to oldsdna
998  */
999 static void reconstruct_elem(
1000         const SDNA *newsdna,
1001         const SDNA *oldsdna,
1002         const char *type,
1003         const char *name,
1004         char *curdata,
1005         const short *old,
1006         const char *olddata)
1007 {
1008         /* rules: test for NAME:
1009          *      - name equal:
1010          *          - cast type
1011          *      - name partially equal (array differs)
1012          *          - type equal: memcpy
1013          *          - types casten
1014          * (nzc 2-4-2001 I want the 'unsigned' bit to be parsed as well. Where
1015          * can I force this?)
1016          */
1017         int a, elemcount, len, countpos, oldsize, cursize, mul;
1018         const char *otype, *oname, *cp;
1019         
1020         /* is 'name' an array? */
1021         cp = name;
1022         countpos = 0;
1023         while (*cp && *cp != '[') {
1024                 cp++; countpos++;
1025         }
1026         if (*cp != '[') countpos = 0;
1027         
1028         /* in old is the old struct */
1029         elemcount = old[1];
1030         old += 2;
1031         for (a = 0; a < elemcount; a++, old += 2) {
1032                 otype = oldsdna->types[old[0]];
1033                 oname = oldsdna->names[old[1]];
1034                 len = elementsize(oldsdna, old[0], old[1]);
1035                 
1036                 if (strcmp(name, oname) == 0) { /* name equal */
1037                         
1038                         if (ispointer(name)) {  /* pointer of functionpointer afhandelen */
1039                                 cast_pointer(newsdna->pointerlen, oldsdna->pointerlen, name, curdata, olddata);
1040                         }
1041                         else if (strcmp(type, otype) == 0) {    /* type equal */
1042                                 memcpy(curdata, olddata, len);
1043                         }
1044                         else {
1045                                 cast_elem(type, otype, name, curdata, olddata);
1046                         }
1047
1048                         return;
1049                 }
1050                 else if (countpos != 0) {  /* name is an array */
1051
1052                         if (oname[countpos] == '[' && strncmp(name, oname, countpos) == 0) {  /* basis equal */
1053                                 
1054                                 cursize = DNA_elem_array_size(name);
1055                                 oldsize = DNA_elem_array_size(oname);
1056
1057                                 if (ispointer(name)) {  /* handle pointer or functionpointer */
1058                                         cast_pointer(newsdna->pointerlen, oldsdna->pointerlen,
1059                                                      cursize > oldsize ? oname : name,
1060                                                      curdata, olddata);
1061                                 }
1062                                 else if (strcmp(type, otype) == 0) {  /* type equal */
1063                                         mul = len / oldsize; /* size of single old array element */
1064                                         mul *= (cursize < oldsize) ? cursize : oldsize; /* smaller of sizes of old and new arrays */
1065                                         memcpy(curdata, olddata, mul);
1066                                         
1067                                         if (oldsize > cursize && strcmp(type, "char") == 0) {
1068                                                 /* string had to be truncated, ensure it's still null-terminated */
1069                                                 curdata[mul - 1] = '\0';
1070                                         }
1071                                 }
1072                                 else {
1073                                         cast_elem(type, otype,
1074                                                   cursize > oldsize ? oname : name,
1075                                                   curdata, olddata);
1076                                 }
1077                                 return;
1078                         }
1079                 }
1080                 olddata += len;
1081         }
1082 }
1083
1084 /**
1085  * Converts the contents of an entire struct from oldsdna to newsdna format.
1086  *
1087  * \param newsdna  SDNA of current Blender
1088  * \param oldsdna  SDNA of Blender that saved file
1089  * \param compflags
1090  *
1091  * Result from DNA_struct_get_compareflags to avoid needless conversions.
1092  * \param oldSDNAnr  Index of old struct definition in oldsdna
1093  * \param data  Struct contents laid out according to oldsdna
1094  * \param curSDNAnr  Index of current struct definition in newsdna
1095  * \param cur  Where to put converted struct contents
1096  */
1097 static void reconstruct_struct(
1098         const SDNA *newsdna,
1099         const SDNA *oldsdna,
1100         const char *compflags,
1101
1102         int oldSDNAnr,
1103         char *data,
1104         int curSDNAnr,
1105         char *cur)
1106 {
1107         /* Recursive!
1108          * Per element from cur_struct, read data from old_struct.
1109          * If element is a struct, call recursive.
1110          */
1111         int a, elemcount, elen, eleno, mul, mulo, firststructtypenr;
1112         const short *spo, *spc, *sppo;
1113         const char *type;
1114         char *cpo, *cpc;
1115         const char *name, *nameo;
1116
1117         unsigned int oldsdna_index_last = UINT_MAX;
1118         unsigned int cursdna_index_last = UINT_MAX;
1119
1120
1121         if (oldSDNAnr == -1) return;
1122         if (curSDNAnr == -1) return;
1123
1124         if (compflags[oldSDNAnr] == SDNA_CMP_EQUAL) {
1125                 /* if recursive: test for equal */
1126                 spo = oldsdna->structs[oldSDNAnr];
1127                 elen = oldsdna->typelens[spo[0]];
1128                 memcpy(cur, data, elen);
1129                 
1130                 return;
1131         }
1132
1133         firststructtypenr = *(newsdna->structs[0]);
1134
1135         spo = oldsdna->structs[oldSDNAnr];
1136         spc = newsdna->structs[curSDNAnr];
1137
1138         elemcount = spc[1];
1139
1140         spc += 2;
1141         cpc = cur;
1142         for (a = 0; a < elemcount; a++, spc += 2) {  /* convert each field */
1143                 type = newsdna->types[spc[0]];
1144                 name = newsdna->names[spc[1]];
1145                 
1146                 elen = elementsize(newsdna, spc[0], spc[1]);
1147
1148                 /* test: is type a struct? */
1149                 if (spc[0] >= firststructtypenr && !ispointer(name)) {
1150                         /* struct field type */
1151                         /* where does the old struct data start (and is there an old one?) */
1152                         cpo = find_elem(oldsdna, type, name, spo, data, &sppo);
1153                         
1154                         if (cpo) {
1155                                 oldSDNAnr = DNA_struct_find_nr_ex(oldsdna, type, &oldsdna_index_last);
1156                                 curSDNAnr = DNA_struct_find_nr_ex(newsdna, type, &cursdna_index_last);
1157                                 
1158                                 /* array! */
1159                                 mul = DNA_elem_array_size(name);
1160                                 nameo = oldsdna->names[sppo[1]];
1161                                 mulo = DNA_elem_array_size(nameo);
1162                                 
1163                                 eleno = elementsize(oldsdna, sppo[0], sppo[1]);
1164                                 
1165                                 elen /= mul;
1166                                 eleno /= mulo;
1167                                 
1168                                 while (mul--) {
1169                                         reconstruct_struct(newsdna, oldsdna, compflags, oldSDNAnr, cpo, curSDNAnr, cpc);
1170                                         cpo += eleno;
1171                                         cpc += elen;
1172                                         
1173                                         /* new struct array larger than old */
1174                                         mulo--;
1175                                         if (mulo <= 0) break;
1176                                 }
1177                         }
1178                         else {
1179                                 cpc += elen;  /* skip field no longer present */
1180                         }
1181                 }
1182                 else {
1183                         /* non-struct field type */
1184                         reconstruct_elem(newsdna, oldsdna, type, name, cpc, spo, data);
1185                         cpc += elen;
1186                 }
1187         }
1188 }
1189
1190 /**
1191  * Does endian swapping on the fields of a struct value.
1192  *
1193  * \param oldsdna  SDNA of Blender that saved file
1194  * \param oldSDNAnr  Index of struct info within oldsdna
1195  * \param data  Struct data
1196  */
1197 void DNA_struct_switch_endian(const SDNA *oldsdna, int oldSDNAnr, char *data)
1198 {
1199         /* Recursive!
1200          * If element is a struct, call recursive.
1201          */
1202         int a, mul, elemcount, elen, elena, firststructtypenr;
1203         const short *spo, *spc;
1204         char *cur;
1205         const char *type, *name;
1206         unsigned int oldsdna_index_last = UINT_MAX;
1207
1208         if (oldSDNAnr == -1) return;
1209         firststructtypenr = *(oldsdna->structs[0]);
1210         
1211         spo = spc = oldsdna->structs[oldSDNAnr];
1212
1213         elemcount = spo[1];
1214
1215         spc += 2;
1216         cur = data;
1217         
1218         for (a = 0; a < elemcount; a++, spc += 2) {
1219                 type = oldsdna->types[spc[0]];
1220                 name = oldsdna->names[spc[1]];
1221                 
1222                 /* elementsize = including arraysize */
1223                 elen = elementsize(oldsdna, spc[0], spc[1]);
1224
1225                 /* test: is type a struct? */
1226                 if (spc[0] >= firststructtypenr && !ispointer(name)) {
1227                         /* struct field type */
1228                         /* where does the old data start (is there one?) */
1229                         char *cpo = find_elem(oldsdna, type, name, spo, data, NULL);
1230                         if (cpo) {
1231                                 oldSDNAnr = DNA_struct_find_nr_ex(oldsdna, type, &oldsdna_index_last);
1232                                 
1233                                 mul = DNA_elem_array_size(name);
1234                                 elena = elen / mul;
1235
1236                                 while (mul--) {
1237                                         DNA_struct_switch_endian(oldsdna, oldSDNAnr, cpo);
1238                                         cpo += elena;
1239                                 }
1240                         }
1241                 }
1242                 else {
1243                         /* non-struct field type */
1244                         if (ispointer(name)) {
1245                                 if (oldsdna->pointerlen == 8) {
1246                                         BLI_endian_switch_int64_array((int64_t *)cur, DNA_elem_array_size(name));
1247                                 }
1248                         }
1249                         else {
1250                                 if (ELEM(spc[0], SDNA_TYPE_SHORT, SDNA_TYPE_USHORT)) {
1251
1252                                         /* exception: variable called blocktype: derived from ID_  */
1253                                         bool skip = false;
1254                                         if (name[0] == 'b' && name[1] == 'l') {
1255                                                 if (strcmp(name, "blocktype") == 0) skip = true;
1256                                         }
1257
1258                                         if (skip == false) {
1259                                                 BLI_endian_switch_int16_array((int16_t *)cur, DNA_elem_array_size(name));
1260                                         }
1261                                 }
1262                                 else if (ELEM(spc[0], SDNA_TYPE_INT, SDNA_TYPE_FLOAT)) {
1263                                         /* note, intentionally ignore long/ulong here these could be 4 or 8 bits,
1264                                          * but turns out we only used for runtime vars and
1265                                          * only once for a struct type thats no longer used. */
1266
1267                                         BLI_endian_switch_int32_array((int32_t *)cur, DNA_elem_array_size(name));
1268                                 }
1269                                 else if (ELEM(spc[0], SDNA_TYPE_INT64, SDNA_TYPE_UINT64, SDNA_TYPE_DOUBLE)) {
1270                                         BLI_endian_switch_int64_array((int64_t *)cur, DNA_elem_array_size(name));
1271                                 }
1272                         }
1273                 }
1274                 cur += elen;
1275         }
1276 }
1277
1278 /**
1279  * \param newsdna  SDNA of current Blender
1280  * \param oldsdna  SDNA of Blender that saved file
1281  * \param compflags
1282  *
1283  * Result from DNA_struct_get_compareflags to avoid needless conversions
1284  * \param oldSDNAnr  Index of struct info within oldsdna
1285  * \param blocks  The number of array elements
1286  * \param data  Array of struct data
1287  * \return An allocated reconstructed struct
1288  */
1289 void *DNA_struct_reconstruct(
1290         const SDNA *newsdna, const SDNA *oldsdna,
1291         char *compflags, int oldSDNAnr, int blocks, void *data)
1292 {
1293         int a, curSDNAnr, curlen = 0, oldlen;
1294         const short *spo, *spc;
1295         char *cur, *cpc, *cpo;
1296         const char *type;
1297         
1298         /* oldSDNAnr == structnr, we're looking for the corresponding 'cur' number */
1299         spo = oldsdna->structs[oldSDNAnr];
1300         type = oldsdna->types[spo[0]];
1301         oldlen = oldsdna->typelens[spo[0]];
1302         curSDNAnr = DNA_struct_find_nr(newsdna, type);
1303
1304         /* init data and alloc */
1305         if (curSDNAnr != -1) {
1306                 spc = newsdna->structs[curSDNAnr];
1307                 curlen = newsdna->typelens[spc[0]];
1308         }
1309         if (curlen == 0) {
1310                 return NULL;
1311         }
1312
1313         cur = MEM_callocN(blocks * curlen, "reconstruct");
1314         cpc = cur;
1315         cpo = data;
1316         for (a = 0; a < blocks; a++) {
1317                 reconstruct_struct(newsdna, oldsdna, compflags, oldSDNAnr, cpo, curSDNAnr, cpc);
1318                 cpc += curlen;
1319                 cpo += oldlen;
1320         }
1321
1322         return cur;
1323 }
1324
1325 /**
1326  * Returns the offset of the field with the specified name and type within the specified
1327  * struct type in sdna.
1328  */
1329 int DNA_elem_offset(SDNA *sdna, const char *stype, const char *vartype, const char *name)
1330 {
1331         const int SDNAnr = DNA_struct_find_nr(sdna, stype);
1332         const short * const spo = sdna->structs[SDNAnr];
1333         const char * const cp = find_elem(sdna, vartype, name, spo, NULL, NULL);
1334         BLI_assert(SDNAnr != -1);
1335         return (int)((intptr_t)cp);
1336 }
1337
1338 bool DNA_struct_elem_find(SDNA *sdna, const char *stype, const char *vartype, const char *name)
1339 {
1340         const int SDNAnr = DNA_struct_find_nr(sdna, stype);
1341         
1342         if (SDNAnr != -1) {
1343                 const short * const spo = sdna->structs[SDNAnr];
1344                 const char * const cp = find_elem(sdna, vartype, name, spo, NULL, NULL);
1345                 
1346                 if (cp) {
1347                         return true;
1348                 }
1349         }
1350         return false;
1351 }
1352
1353
1354 /**
1355  * Returns the size in bytes of a primitive type.
1356  */
1357 int DNA_elem_type_size(const eSDNA_Type elem_nr)
1358 {
1359         /* should contain all enum types */
1360         switch (elem_nr) {
1361                 case SDNA_TYPE_CHAR:
1362                 case SDNA_TYPE_UCHAR:
1363                         return 1;
1364                 case SDNA_TYPE_SHORT:
1365                 case SDNA_TYPE_USHORT:
1366                         return 2;
1367                 case SDNA_TYPE_INT:
1368                 case SDNA_TYPE_FLOAT:
1369                         return 4;
1370                 case SDNA_TYPE_DOUBLE:
1371                 case SDNA_TYPE_INT64:
1372                 case SDNA_TYPE_UINT64:
1373                         return 8;
1374         }
1375
1376         /* weak */
1377         return 8;
1378 }