Cleanup/Refactor: Simplify/deduplicate bvhutils code
[blender.git] / source / blender / makesdna / intern / dna_genfile.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  * DNA handling
19  */
20
21 /** \file
22  * \ingroup DNA
23  *
24  * Lowest-level functions for decoding the parts of a saved .blend
25  * file, including interpretation of its SDNA block and conversion of
26  * contents of other parts according to the differences between that
27  * SDNA and the SDNA of the current (running) version of Blender.
28  */
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <limits.h>
34
35 #include "MEM_guardedalloc.h"  // for MEM_freeN MEM_mallocN MEM_callocN
36
37 #include "BLI_utildefines.h"
38 #include "BLI_endian_switch.h"
39 #include "BLI_memarena.h"
40 #include "BLI_string.h"
41
42 #include "BLI_ghash.h"
43
44 #include "DNA_genfile.h"
45 #include "DNA_sdna_types.h"  // for SDNA ;-)
46
47 /**
48  * \section dna_genfile Overview
49  *
50  * - please note: no builtin security to detect input of double structs
51  * - if you want a struct not to be in DNA file: add two hash marks above it `(#<enter>#<enter>)`.
52  *
53  * Structure DNA data is added to each blender file and to each executable, this to detect
54  * in .blend files new variables in structs, changed array sizes, etc. It's also used for
55  * converting endian and pointer size (32-64 bits)
56  * As an extra, Python uses a call to detect run-time the contents of a blender struct.
57  *
58  * Create a structDNA: only needed when one of the input include (.h) files change.
59  * File Syntax:
60  * \code{.unparsed}
61  *     SDNA (4 bytes) (magic number)
62  *     NAME (4 bytes)
63  *     <nr> (4 bytes) amount of names (int)
64  *     <string>
65  *     <string>
66  *     ...
67  *     ...
68  *     TYPE (4 bytes)
69  *     <nr> amount of types (int)
70  *     <string>
71  *     <string>
72  *     ...
73  *     ...
74  *     TLEN (4 bytes)
75  *     <len> (short) the lengths of types
76  *     <len>
77  *     ...
78  *     ...
79  *     STRC (4 bytes)
80  *     <nr> amount of structs (int)
81  *     <typenr><nr_of_elems> <typenr><namenr> <typenr><namenr> ...
82  * \endcode
83  *
84  *  **Remember to read/write integer and short aligned!**
85  *
86  *  While writing a file, the names of a struct is indicated with a type number,
87  *  to be found with: ``type = DNA_struct_find_nr(SDNA *, const char *)``
88  *  The value of ``type`` corresponds with the index within the structs array
89  *
90  *  For the moment: the complete DNA file is included in a .blend file. For
91  *  the future we can think of smarter methods, like only included the used
92  *  structs. Only needed to keep a file short though...
93  *
94  * ALLOWED AND TESTED CHANGES IN STRUCTS:
95  *  - Type change (a char to float will be divided by 255).
96  *  - Location within a struct (everything can be randomly mixed up).
97  *  - Struct within struct (within struct etc), this is recursive.
98  *  - Adding new elements, will be default initialized zero.
99  *  - Removing elements.
100  *  - Change of array sizes.
101  *  - Change of a pointer type: when the name doesn't change the contents is copied.
102  *
103  * NOT YET:
104  *  - array (``vec[3]``) to float struct (``vec3f``).
105  *
106  * DONE:
107  *  - Endian compatibility.
108  *  - Pointer conversion (32-64 bits).
109  *
110  * IMPORTANT:
111  *  - Do not use #defines in structs for array lengths, this cannot be read by the dna functions.
112  *  - Do not use uint, but unsigned int instead, ushort and ulong are allowed.
113  *  - Only use a long in Blender if you want this to be the size of a pointer. so it is
114  *    32 bits or 64 bits, dependent at the cpu architecture.
115  *  - Chars are always unsigned
116  *  - Alignment of variables has to be done in such a way, that any system does
117  *    not create 'padding' (gaps) in structures. So make sure that:
118  *    - short: 2 aligned.
119  *    - int: 4 aligned.
120  *    - float: 4 aligned.
121  *    - double: 8 aligned.
122  *    - long: 8 aligned.
123  *    - int64: 8 aligned.
124  *    - struct: 8 aligned.
125  *  - the sdna functions have several error prints builtin,
126  *    always check blender running from a console.
127  */
128
129 #ifdef __BIG_ENDIAN__
130 /* Big Endian */
131 #  define MAKE_ID(a, b, c, d) ((int)(a) << 24 | (int)(b) << 16 | (c) << 8 | (d))
132 #else
133 /* Little Endian */
134 #  define MAKE_ID(a, b, c, d) ((int)(d) << 24 | (int)(c) << 16 | (b) << 8 | (a))
135 #endif
136
137 /* ************************* DIV ********************** */
138
139 void DNA_sdna_free(SDNA *sdna)
140 {
141   if (sdna->data_alloc) {
142     MEM_freeN((void *)sdna->data);
143   }
144
145   MEM_freeN((void *)sdna->names);
146   MEM_freeN((void *)sdna->names_array_len);
147   MEM_freeN((void *)sdna->types);
148   MEM_freeN(sdna->structs);
149
150 #ifdef WITH_DNA_GHASH
151   if (sdna->structs_map) {
152     BLI_ghash_free(sdna->structs_map, NULL, NULL);
153   }
154 #endif
155
156   if (sdna->mem_arena) {
157     BLI_memarena_free(sdna->mem_arena);
158   }
159
160   MEM_SAFE_FREE(sdna->alias.names);
161   MEM_SAFE_FREE(sdna->alias.types);
162 #ifdef WITH_DNA_GHASH
163   if (sdna->alias.structs_map) {
164     BLI_ghash_free(sdna->alias.structs_map, NULL, NULL);
165   }
166 #endif
167
168   MEM_freeN(sdna);
169 }
170
171 /**
172  * Return true if the name indicates a pointer of some kind.
173  */
174 static bool ispointer(const char *name)
175 {
176   /* check if pointer or function pointer */
177   return (name[0] == '*' || (name[0] == '(' && name[1] == '*'));
178 }
179
180 /**
181  * Returns the size of struct fields of the specified type and name.
182  *
183  * \param type: Index into sdna->types/types_size
184  * \param name: Index into sdna->names,
185  * needed to extract possible pointer/array information.
186  */
187 static int elementsize(const SDNA *sdna, short type, short name)
188 {
189   int len;
190   const char *cp = sdna->names[name];
191   len = 0;
192
193   /* is it a pointer or function pointer? */
194   if (ispointer(cp)) {
195     /* has the name an extra length? (array) */
196     len = sdna->pointer_size * sdna->names_array_len[name];
197   }
198   else if (sdna->types_size[type]) {
199     /* has the name an extra length? (array) */
200     len = (int)sdna->types_size[type] * sdna->names_array_len[name];
201   }
202
203   return len;
204 }
205
206 #if 0
207 static void printstruct(SDNA *sdna, short strnr)
208 {
209   /* is for debug */
210   int b, nr;
211   short *sp;
212
213   sp = sdna->structs[strnr];
214
215   printf("struct %s\n", sdna->types[sp[0]]);
216   nr = sp[1];
217   sp += 2;
218
219   for (b = 0; b < nr; b++, sp += 2) {
220     printf("   %s %s\n", sdna->types[sp[0]], sdna->names[sp[1]]);
221   }
222 }
223 #endif
224
225 /**
226  * Returns the index of the struct info for the struct with the specified name.
227  */
228 static int dna_struct_find_nr_ex_impl(
229     /* From SDNA struct. */
230     const char **types,
231     const int UNUSED(types_len),
232     short **const structs,
233     const int structs_len,
234 #ifdef WITH_DNA_GHASH
235     GHash *structs_map,
236 #endif
237     /* Regular args. */
238     const char *str,
239     unsigned int *index_last)
240 {
241   if (*index_last < structs_len) {
242     const short *sp = structs[*index_last];
243     if (STREQ(types[sp[0]], str)) {
244       return *index_last;
245     }
246   }
247
248 #ifdef WITH_DNA_GHASH
249   {
250     void **index_p = BLI_ghash_lookup_p(structs_map, str);
251     if (index_p) {
252       const int index = POINTER_AS_INT(*index_p);
253       *index_last = index;
254       return index;
255     }
256   }
257 #else
258   {
259     for (int index = 0; index < structs_len; index++) {
260       const short *sp = structs[index];
261       if (STREQ(types[sp[0]], str)) {
262         *index_last = index;
263         return index;
264       }
265     }
266   }
267 #endif
268   return -1;
269 }
270
271 /**
272  * Returns the index of the struct info for the struct with the specified name.
273  */
274 int DNA_struct_find_nr_ex(const SDNA *sdna, const char *str, unsigned int *index_last)
275 {
276   return dna_struct_find_nr_ex_impl(
277       /* Expand SDNA. */
278       sdna->types,
279       sdna->types_len,
280       sdna->structs,
281       sdna->structs_len,
282 #ifdef WITH_DNA_GHASH
283       sdna->structs_map,
284 #endif
285       /* Regular args. */
286       str,
287       index_last);
288 }
289
290 /** \note requires #DNA_sdna_alias_data_ensure_structs_map to be called. */
291 int DNA_struct_alias_find_nr_ex(const SDNA *sdna, const char *str, unsigned int *index_last)
292 {
293 #ifdef WITH_DNA_GHASH
294   BLI_assert(sdna->alias.structs_map != NULL);
295 #endif
296   return dna_struct_find_nr_ex_impl(
297       /* Expand SDNA. */
298       sdna->alias.types,
299       sdna->types_len,
300       sdna->structs,
301       sdna->structs_len,
302 #ifdef WITH_DNA_GHASH
303       sdna->alias.structs_map,
304 #endif
305       /* Regular args. */
306       str,
307       index_last);
308 }
309
310 int DNA_struct_find_nr(const SDNA *sdna, const char *str)
311 {
312   unsigned int index_last_dummy = UINT_MAX;
313   return DNA_struct_find_nr_ex(sdna, str, &index_last_dummy);
314 }
315
316 /** \note requires #DNA_sdna_alias_data_ensure_structs_map to be called. */
317 int DNA_struct_alias_find_nr(const SDNA *sdna, const char *str)
318 {
319   unsigned int index_last_dummy = UINT_MAX;
320   return DNA_struct_alias_find_nr_ex(sdna, str, &index_last_dummy);
321 }
322
323 /* ************************* END DIV ********************** */
324
325 /* ************************* READ DNA ********************** */
326
327 BLI_INLINE const char *pad_up_4(const char *ptr)
328 {
329   return (const char *)((((uintptr_t)ptr) + 3) & ~3);
330 }
331
332 /**
333  * In sdna->data the data, now we convert that to something understandable
334  */
335 static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error_message)
336 {
337   int *data, gravity_fix = -1;
338   short *sp;
339
340   data = (int *)sdna->data;
341
342   /* Clear pointers in case of error. */
343   sdna->names = NULL;
344   sdna->types = NULL;
345   sdna->structs = NULL;
346 #ifdef WITH_DNA_GHASH
347   sdna->structs_map = NULL;
348 #endif
349   sdna->mem_arena = NULL;
350
351   /* Lazy initialize. */
352   memset(&sdna->alias, 0, sizeof(sdna->alias));
353
354   /* Struct DNA ('SDNA') */
355   if (*data != MAKE_ID('S', 'D', 'N', 'A')) {
356     *r_error_message = "SDNA error in SDNA file";
357     return false;
358   }
359   else {
360     const char *cp;
361
362     data++;
363     /* Names array ('NAME') */
364     if (*data == MAKE_ID('N', 'A', 'M', 'E')) {
365       data++;
366
367       sdna->names_len = *data;
368       if (do_endian_swap) {
369         BLI_endian_switch_int32(&sdna->names_len);
370       }
371       sdna->names_len_alloc = sdna->names_len;
372
373       data++;
374       sdna->names = MEM_callocN(sizeof(void *) * sdna->names_len, "sdnanames");
375     }
376     else {
377       *r_error_message = "NAME error in SDNA file";
378       return false;
379     }
380
381     cp = (char *)data;
382     for (int nr = 0; nr < sdna->names_len; nr++) {
383       sdna->names[nr] = cp;
384
385       /* "float gravity [3]" was parsed wrong giving both "gravity" and
386        * "[3]"  members. we rename "[3]", and later set the type of
387        * "gravity" to "void" so the offsets work out correct */
388       if (*cp == '[' && strcmp(cp, "[3]") == 0) {
389         if (nr && strcmp(sdna->names[nr - 1], "Cvi") == 0) {
390           sdna->names[nr] = "gravity[3]";
391           gravity_fix = nr;
392         }
393       }
394       while (*cp) {
395         cp++;
396       }
397       cp++;
398     }
399
400     cp = pad_up_4(cp);
401
402     /* Type names array ('TYPE') */
403     data = (int *)cp;
404     if (*data == MAKE_ID('T', 'Y', 'P', 'E')) {
405       data++;
406
407       sdna->types_len = *data;
408       if (do_endian_swap) {
409         BLI_endian_switch_int32(&sdna->types_len);
410       }
411
412       data++;
413       sdna->types = MEM_callocN(sizeof(void *) * sdna->types_len, "sdnatypes");
414     }
415     else {
416       *r_error_message = "TYPE error in SDNA file";
417       return false;
418     }
419
420     cp = (char *)data;
421     for (int nr = 0; nr < sdna->types_len; nr++) {
422       /* WARNING! See: DNA_struct_rename_legacy_hack_static_from_alias docs. */
423       sdna->types[nr] = DNA_struct_rename_legacy_hack_static_from_alias(cp);
424       while (*cp) {
425         cp++;
426       }
427       cp++;
428     }
429
430     cp = pad_up_4(cp);
431
432     /* Type lengths array ('TLEN') */
433     data = (int *)cp;
434     if (*data == MAKE_ID('T', 'L', 'E', 'N')) {
435       data++;
436       sp = (short *)data;
437       sdna->types_size = sp;
438
439       if (do_endian_swap) {
440         BLI_endian_switch_int16_array(sp, sdna->types_len);
441       }
442
443       sp += sdna->types_len;
444     }
445     else {
446       *r_error_message = "TLEN error in SDNA file";
447       return false;
448     }
449     /* prevent BUS error */
450     if (sdna->types_len & 1) {
451       sp++;
452     }
453
454     /* Struct array ('STRC') */
455     data = (int *)sp;
456     if (*data == MAKE_ID('S', 'T', 'R', 'C')) {
457       data++;
458
459       sdna->structs_len = *data;
460       if (do_endian_swap) {
461         BLI_endian_switch_int32(&sdna->structs_len);
462       }
463
464       data++;
465       sdna->structs = MEM_callocN(sizeof(void *) * sdna->structs_len, "sdnastrcs");
466     }
467     else {
468       *r_error_message = "STRC error in SDNA file";
469       return false;
470     }
471
472     sp = (short *)data;
473     for (int nr = 0; nr < sdna->structs_len; nr++) {
474       sdna->structs[nr] = sp;
475
476       if (do_endian_swap) {
477         short a;
478
479         BLI_endian_switch_int16(&sp[0]);
480         BLI_endian_switch_int16(&sp[1]);
481
482         a = sp[1];
483         sp += 2;
484         while (a--) {
485           BLI_endian_switch_int16(&sp[0]);
486           BLI_endian_switch_int16(&sp[1]);
487           sp += 2;
488         }
489       }
490       else {
491         sp += 2 * sp[1] + 2;
492       }
493     }
494   }
495
496   {
497     /* second part of gravity problem, setting "gravity" type to void */
498     if (gravity_fix > -1) {
499       for (int nr = 0; nr < sdna->structs_len; nr++) {
500         sp = sdna->structs[nr];
501         if (strcmp(sdna->types[sp[0]], "ClothSimSettings") == 0) {
502           sp[10] = SDNA_TYPE_VOID;
503         }
504       }
505     }
506   }
507
508 #ifdef WITH_DNA_GHASH
509   {
510     /* create a ghash lookup to speed up */
511     sdna->structs_map = BLI_ghash_str_new_ex("init_structDNA gh", sdna->structs_len);
512
513     for (intptr_t nr = 0; nr < sdna->structs_len; nr++) {
514       sp = sdna->structs[nr];
515       BLI_ghash_insert(sdna->structs_map, (void *)sdna->types[sp[0]], POINTER_FROM_INT(nr));
516     }
517   }
518 #endif
519
520   /* Calculate 'sdna->pointer_size' */
521   {
522     const int nr = DNA_struct_find_nr(sdna, "ListBase");
523
524     /* should never happen, only with corrupt file for example */
525     if (UNLIKELY(nr == -1)) {
526       *r_error_message = "ListBase struct error! Not found.";
527       return false;
528     }
529
530     /* finally pointer_size: use struct ListBase to test it, never change the size of it! */
531     sp = sdna->structs[nr];
532     /* weird; i have no memory of that... I think I used sizeof(void *) before... (ton) */
533
534     sdna->pointer_size = sdna->types_size[sp[0]] / 2;
535
536     if (sp[1] != 2 || (sdna->pointer_size != 4 && sdna->pointer_size != 8)) {
537       *r_error_message = "ListBase struct error! Needs it to calculate pointerize.";
538       /* well, at least sizeof(ListBase) is error proof! (ton) */
539       return false;
540     }
541   }
542
543   /* Cache name size. */
544   {
545     short *names_array_len = MEM_mallocN(sizeof(*names_array_len) * sdna->names_len, __func__);
546     for (int i = 0; i < sdna->names_len; i++) {
547       names_array_len[i] = DNA_elem_array_size(sdna->names[i]);
548     }
549     sdna->names_array_len = names_array_len;
550   }
551
552   return true;
553 }
554
555 /**
556  * Constructs and returns a decoded SDNA structure from the given encoded SDNA data block.
557  */
558 SDNA *DNA_sdna_from_data(const void *data,
559                          const int data_len,
560                          bool do_endian_swap,
561                          bool data_alloc,
562                          const char **r_error_message)
563 {
564   SDNA *sdna = MEM_mallocN(sizeof(*sdna), "sdna");
565   const char *error_message = NULL;
566
567   sdna->data_len = data_len;
568   if (data_alloc) {
569     char *data_copy = MEM_mallocN(data_len, "sdna_data");
570     memcpy(data_copy, data, data_len);
571     sdna->data = data_copy;
572   }
573   else {
574     sdna->data = data;
575   }
576   sdna->data_alloc = data_alloc;
577
578   if (init_structDNA(sdna, do_endian_swap, &error_message)) {
579     return sdna;
580   }
581   else {
582     if (r_error_message == NULL) {
583       fprintf(stderr, "Error decoding blend file SDNA: %s\n", error_message);
584     }
585     else {
586       *r_error_message = error_message;
587     }
588     DNA_sdna_free(sdna);
589     return NULL;
590   }
591 }
592
593 /**
594  * Using globals is acceptable here,
595  * the data is read-only and only changes between Blender versions.
596  *
597  * So it is safe to create once and reuse.
598  */
599 static SDNA *g_sdna = NULL;
600
601 void DNA_sdna_current_init(void)
602 {
603   g_sdna = DNA_sdna_from_data(DNAstr, DNAlen, false, false, NULL);
604 }
605
606 const struct SDNA *DNA_sdna_current_get(void)
607 {
608   BLI_assert(g_sdna != NULL);
609   return g_sdna;
610 }
611
612 void DNA_sdna_current_free(void)
613 {
614   DNA_sdna_free(g_sdna);
615   g_sdna = NULL;
616 }
617
618 /* ******************** END READ DNA ********************** */
619
620 /* ******************* HANDLE DNA ***************** */
621
622 /**
623  * Used by #DNA_struct_get_compareflags (below) to recursively mark all structs
624  * containing a field of type structnr as changed between old and current SDNAs.
625  */
626 static void recurs_test_compflags(const SDNA *sdna, char *compflags, int structnr)
627 {
628   int a, b, typenr, elems;
629   const short *sp;
630   const char *cp;
631
632   /* check all structs, test if it's inside another struct */
633   sp = sdna->structs[structnr];
634   typenr = sp[0];
635
636   for (a = 0; a < sdna->structs_len; a++) {
637     if ((a != structnr) && (compflags[a] == SDNA_CMP_EQUAL)) {
638       sp = sdna->structs[a];
639       elems = sp[1];
640       sp += 2;
641       for (b = 0; b < elems; b++, sp += 2) {
642         if (sp[0] == typenr) {
643           cp = sdna->names[sp[1]];
644           if (!ispointer(cp)) {
645             compflags[a] = SDNA_CMP_NOT_EQUAL;
646             recurs_test_compflags(sdna, compflags, a);
647           }
648         }
649       }
650     }
651   }
652 }
653
654 /**
655  * Constructs and returns an array of byte flags with one element for each struct in oldsdna,
656  * indicating how it compares to newsdna:
657  */
658 const char *DNA_struct_get_compareflags(const SDNA *oldsdna, const SDNA *newsdna)
659 {
660   int a, b;
661   const short *sp_old, *sp_new;
662   const char *str1, *str2;
663   char *compflags;
664
665   if (oldsdna->structs_len == 0) {
666     printf("error: file without SDNA\n");
667     return NULL;
668   }
669
670   compflags = MEM_callocN(oldsdna->structs_len, "compflags");
671
672   /* we check all structs in 'oldsdna' and compare them with
673    * the structs in 'newsdna'
674    */
675   unsigned int newsdna_index_last = 0;
676
677   for (a = 0; a < oldsdna->structs_len; a++) {
678     sp_old = oldsdna->structs[a];
679
680     /* search for type in cur */
681     int sp_new_index = DNA_struct_find_nr_ex(
682         newsdna, oldsdna->types[sp_old[0]], &newsdna_index_last);
683
684     /* The next indices will almost always match */
685     newsdna_index_last++;
686
687     if (sp_new_index != -1) {
688       sp_new = newsdna->structs[sp_new_index];
689       /* initial assumption */
690       compflags[a] = SDNA_CMP_NOT_EQUAL;
691
692       /* compare length and amount of elems */
693       if (sp_new[1] == sp_old[1]) {
694         if (newsdna->types_size[sp_new[0]] == oldsdna->types_size[sp_old[0]]) {
695
696           /* same length, same amount of elems, now per type and name */
697           b = sp_old[1];
698           sp_old += 2;
699           sp_new += 2;
700           while (b > 0) {
701             str1 = newsdna->types[sp_new[0]];
702             str2 = oldsdna->types[sp_old[0]];
703             if (strcmp(str1, str2) != 0) {
704               break;
705             }
706
707             str1 = newsdna->names[sp_new[1]];
708             str2 = oldsdna->names[sp_old[1]];
709             if (strcmp(str1, str2) != 0) {
710               break;
711             }
712
713             /* same type and same name, now pointersize */
714             if (ispointer(str1)) {
715               if (oldsdna->pointer_size != newsdna->pointer_size) {
716                 break;
717               }
718             }
719
720             b--;
721             sp_old += 2;
722             sp_new += 2;
723           }
724           if (b == 0) {
725             /* no differences found */
726             compflags[a] = SDNA_CMP_EQUAL;
727           }
728         }
729       }
730     }
731   }
732
733   /* first struct in util.h is struct Link, this is skipped in compflags (als # 0).
734    * was a bug, and this way dirty patched! Solve this later....
735    */
736   compflags[0] = SDNA_CMP_EQUAL;
737
738   /* Because structs can be inside structs, we recursively
739    * set flags when a struct is altered
740    */
741   for (a = 0; a < oldsdna->structs_len; a++) {
742     if (compflags[a] == SDNA_CMP_NOT_EQUAL) {
743       recurs_test_compflags(oldsdna, compflags, a);
744     }
745   }
746
747 #if 0
748   for (a = 0; a < oldsdna->structs_len; a++) {
749     if (compflags[a] == SDNA_CMP_NOT_EQUAL) {
750       spold = oldsdna->structs[a];
751       printf("changed: %s\n", oldsdna->types[spold[0]]);
752     }
753   }
754 #endif
755
756   return compflags;
757 }
758
759 /**
760  * Converts the name of a primitive type to its enumeration code.
761  */
762 static eSDNA_Type sdna_type_nr(const char *dna_type)
763 {
764   if (STR_ELEM(dna_type, "char", "const char")) {
765     return SDNA_TYPE_CHAR;
766   }
767   else if (STR_ELEM(dna_type, "uchar", "unsigned char")) {
768     return SDNA_TYPE_UCHAR;
769   }
770   else if (STR_ELEM(dna_type, "short")) {
771     return SDNA_TYPE_SHORT;
772   }
773   else if (STR_ELEM(dna_type, "ushort", "unsigned short")) {
774     return SDNA_TYPE_USHORT;
775   }
776   else if (STR_ELEM(dna_type, "int")) {
777     return SDNA_TYPE_INT;
778   }
779   else if (STR_ELEM(dna_type, "float")) {
780     return SDNA_TYPE_FLOAT;
781   }
782   else if (STR_ELEM(dna_type, "double")) {
783     return SDNA_TYPE_DOUBLE;
784   }
785   else if (STR_ELEM(dna_type, "int64_t")) {
786     return SDNA_TYPE_INT64;
787   }
788   else if (STR_ELEM(dna_type, "uint64_t")) {
789     return SDNA_TYPE_UINT64;
790   }
791   /* invalid! */
792   else {
793     return -1;
794   }
795 }
796
797 /**
798  * Converts a value of one primitive type to another.
799  * Note there is no optimization for the case where otype and ctype are the same:
800  * assumption is that caller will handle this case.
801  *
802  * \param ctype: Name of type to convert to
803  * \param otype: Name of type to convert from
804  * \param name_array_len: Result of #DNA_elem_array_size for this element.
805  * \param curdata: Where to put converted data
806  * \param olddata: Data of type otype to convert
807  */
808 static void cast_elem(
809     const char *ctype, const char *otype, int name_array_len, char *curdata, const char *olddata)
810 {
811   double val = 0.0;
812   int curlen = 1, oldlen = 1;
813
814   eSDNA_Type ctypenr, otypenr;
815
816   if ((otypenr = sdna_type_nr(otype)) == -1 || (ctypenr = sdna_type_nr(ctype)) == -1) {
817     return;
818   }
819
820   /* define lengths */
821   oldlen = DNA_elem_type_size(otypenr);
822   curlen = DNA_elem_type_size(ctypenr);
823
824   while (name_array_len > 0) {
825     switch (otypenr) {
826       case SDNA_TYPE_CHAR:
827         val = *olddata;
828         break;
829       case SDNA_TYPE_UCHAR:
830         val = *((unsigned char *)olddata);
831         break;
832       case SDNA_TYPE_SHORT:
833         val = *((short *)olddata);
834         break;
835       case SDNA_TYPE_USHORT:
836         val = *((unsigned short *)olddata);
837         break;
838       case SDNA_TYPE_INT:
839         val = *((int *)olddata);
840         break;
841       case SDNA_TYPE_FLOAT:
842         val = *((float *)olddata);
843         break;
844       case SDNA_TYPE_DOUBLE:
845         val = *((double *)olddata);
846         break;
847       case SDNA_TYPE_INT64:
848         val = *((int64_t *)olddata);
849         break;
850       case SDNA_TYPE_UINT64:
851         val = *((uint64_t *)olddata);
852         break;
853     }
854
855     switch (ctypenr) {
856       case SDNA_TYPE_CHAR:
857         *curdata = val;
858         break;
859       case SDNA_TYPE_UCHAR:
860         *((unsigned char *)curdata) = val;
861         break;
862       case SDNA_TYPE_SHORT:
863         *((short *)curdata) = val;
864         break;
865       case SDNA_TYPE_USHORT:
866         *((unsigned short *)curdata) = val;
867         break;
868       case SDNA_TYPE_INT:
869         *((int *)curdata) = val;
870         break;
871       case SDNA_TYPE_FLOAT:
872         if (otypenr < 2) {
873           val /= 255;
874         }
875         *((float *)curdata) = val;
876         break;
877       case SDNA_TYPE_DOUBLE:
878         if (otypenr < 2) {
879           val /= 255;
880         }
881         *((double *)curdata) = val;
882         break;
883       case SDNA_TYPE_INT64:
884         *((int64_t *)curdata) = val;
885         break;
886       case SDNA_TYPE_UINT64:
887         *((uint64_t *)curdata) = val;
888         break;
889     }
890
891     olddata += oldlen;
892     curdata += curlen;
893     name_array_len--;
894   }
895 }
896
897 /**
898  * Converts pointer values between different sizes. These are only used
899  * as lookup keys to identify data blocks in the saved .blend file, not
900  * as actual in-memory pointers.
901  *
902  * \param curlen: Pointer length to convert to
903  * \param oldlen: Length of pointers in olddata
904  * \param name_array_len: Result of #DNA_elem_array_size for this element.
905  * \param curdata: Where to put converted data
906  * \param olddata: Data to convert
907  */
908 static void cast_pointer(
909     int curlen, int oldlen, int name_array_len, char *curdata, const char *olddata)
910 {
911   int64_t lval;
912
913   while (name_array_len > 0) {
914
915     if (curlen == oldlen) {
916       memcpy(curdata, olddata, curlen);
917     }
918     else if (curlen == 4 && oldlen == 8) {
919       lval = *((int64_t *)olddata);
920
921       /* WARNING: 32-bit Blender trying to load file saved by 64-bit Blender,
922        * pointers may lose uniqueness on truncation! (Hopefully this wont
923        * happen unless/until we ever get to multi-gigabyte .blend files...) */
924       *((int *)curdata) = lval >> 3;
925     }
926     else if (curlen == 8 && oldlen == 4) {
927       *((int64_t *)curdata) = *((int *)olddata);
928     }
929     else {
930       /* for debug */
931       printf("errpr: illegal pointersize!\n");
932     }
933
934     olddata += oldlen;
935     curdata += curlen;
936     name_array_len--;
937   }
938 }
939
940 /**
941  * Equality test on name and oname excluding any array-size suffix.
942  */
943 static int elem_strcmp(const char *name, const char *oname)
944 {
945   int a = 0;
946
947   while (1) {
948     if (name[a] != oname[a]) {
949       return 1;
950     }
951     if (name[a] == '[' || oname[a] == '[') {
952       break;
953     }
954     if (name[a] == 0 || oname[a] == 0) {
955       break;
956     }
957     a++;
958   }
959   return 0;
960 }
961
962 /**
963  * Returns whether the specified field exists according to the struct format
964  * pointed to by old.
965  *
966  * \param sdna: Old SDNA
967  * \param type: Current field type name
968  * \param name: Current field name
969  * \param old: Pointer to struct information in sdna
970  * \return true when existing, false otherwise.
971  */
972 static bool elem_exists_impl(
973     /* Expand SDNA. */
974     const char **types,
975     const char **names,
976     /* Regular args. */
977     const char *type,
978     const char *name,
979     const short *old)
980 {
981   int a, elemcount;
982   const char *otype, *oname;
983
984   /* in old is the old struct */
985   elemcount = old[1];
986   old += 2;
987   for (a = 0; a < elemcount; a++, old += 2) {
988     otype = types[old[0]];
989     oname = names[old[1]];
990
991     if (elem_strcmp(name, oname) == 0) { /* name equal */
992       return strcmp(type, otype) == 0;   /* type equal */
993     }
994   }
995   return false;
996 }
997
998 static bool elem_exists(const SDNA *sdna, const char *type, const char *name, const short *old)
999 {
1000   return elem_exists_impl(
1001       /* Expand SDNA. */
1002       sdna->types,
1003       sdna->names,
1004       /* Regular args. */
1005       type,
1006       name,
1007       old);
1008 }
1009
1010 static bool elem_exists_alias(const SDNA *sdna,
1011                               const char *type,
1012                               const char *name,
1013                               const short *old)
1014 {
1015   return elem_exists_impl(
1016       /* Expand SDNA. */
1017       sdna->alias.types,
1018       sdna->alias.names,
1019       /* Regular args. */
1020       type,
1021       name,
1022       old);
1023 }
1024
1025 /**
1026  * Returns the address of the data for the specified field within olddata
1027  * according to the struct format pointed to by old, or NULL if no such
1028  * field can be found.
1029  *
1030  * Passing olddata=NULL doesn't work reliably for existence checks; it will
1031  * return NULL both when the field is found at offset 0 and when it is not
1032  * found at all. For field existence checks, use #elem_exists() instead.
1033  *
1034  * \param sdna: Old SDNA
1035  * \param type: Current field type name
1036  * \param name: Current field name
1037  * \param old: Pointer to struct information in sdna
1038  * \param olddata: Struct data
1039  * \param sppo: Optional place to return pointer to field info in sdna
1040  * \return Data address.
1041  */
1042 static const char *find_elem(const SDNA *sdna,
1043                              const char *type,
1044                              const char *name,
1045                              const short *old,
1046                              const char *olddata,
1047                              const short **sppo)
1048 {
1049   int a, elemcount, len;
1050   const char *otype, *oname;
1051
1052   /* without arraypart, so names can differ: return old namenr and type */
1053
1054   /* in old is the old struct */
1055   elemcount = old[1];
1056   old += 2;
1057   for (a = 0; a < elemcount; a++, old += 2) {
1058
1059     otype = sdna->types[old[0]];
1060     oname = sdna->names[old[1]];
1061
1062     len = elementsize(sdna, old[0], old[1]);
1063
1064     if (elem_strcmp(name, oname) == 0) { /* name equal */
1065       if (strcmp(type, otype) == 0) {    /* type equal */
1066         if (sppo) {
1067           *sppo = old;
1068         }
1069         return olddata;
1070       }
1071
1072       return NULL;
1073     }
1074
1075     olddata += len;
1076   }
1077   return NULL;
1078 }
1079
1080 /**
1081  * Converts the contents of a single field of a struct, of a non-struct type,
1082  * from oldsdna to newsdna format.
1083  *
1084  * \param newsdna: SDNA of current Blender
1085  * \param oldsdna: SDNA of Blender that saved file
1086  * \param type: current field type name
1087  * \param new_name_nr: current field name number.
1088  * \param curdata: put field data converted to newsdna here
1089  * \param old: pointer to struct info in oldsdna
1090  * \param olddata: struct contents laid out according to oldsdna
1091  */
1092 static void reconstruct_elem(const SDNA *newsdna,
1093                              const SDNA *oldsdna,
1094                              const char *type,
1095                              const int new_name_nr,
1096                              char *curdata,
1097                              const short *old,
1098                              const char *olddata)
1099 {
1100   /* rules: test for NAME:
1101    *      - name equal:
1102    *          - cast type
1103    *      - name partially equal (array differs)
1104    *          - type equal: memcpy
1105    *          - types casten
1106    * (nzc 2-4-2001 I want the 'unsigned' bit to be parsed as well. Where
1107    * can I force this?)
1108    */
1109   int a, elemcount, len, countpos, mul;
1110   const char *otype, *oname, *cp;
1111
1112   /* is 'name' an array? */
1113   const char *name = newsdna->names[new_name_nr];
1114   cp = name;
1115   countpos = 0;
1116   while (*cp && *cp != '[') {
1117     cp++;
1118     countpos++;
1119   }
1120   if (*cp != '[') {
1121     countpos = 0;
1122   }
1123
1124   /* in old is the old struct */
1125   elemcount = old[1];
1126   old += 2;
1127   for (a = 0; a < elemcount; a++, old += 2) {
1128     const int old_name_nr = old[1];
1129     otype = oldsdna->types[old[0]];
1130     oname = oldsdna->names[old[1]];
1131     len = elementsize(oldsdna, old[0], old[1]);
1132
1133     if (strcmp(name, oname) == 0) { /* name equal */
1134
1135       if (ispointer(name)) { /* pointer of functionpointer afhandelen */
1136         cast_pointer(newsdna->pointer_size,
1137                      oldsdna->pointer_size,
1138                      newsdna->names_array_len[new_name_nr],
1139                      curdata,
1140                      olddata);
1141       }
1142       else if (strcmp(type, otype) == 0) { /* type equal */
1143         memcpy(curdata, olddata, len);
1144       }
1145       else {
1146         cast_elem(type, otype, newsdna->names_array_len[new_name_nr], curdata, olddata);
1147       }
1148
1149       return;
1150     }
1151     else if (countpos != 0) { /* name is an array */
1152
1153       if (oname[countpos] == '[' && strncmp(name, oname, countpos) == 0) { /* basis equal */
1154         const int new_name_array_len = newsdna->names_array_len[new_name_nr];
1155         const int old_name_array_len = oldsdna->names_array_len[old_name_nr];
1156         const int min_name_array_len = MIN2(new_name_array_len, old_name_array_len);
1157
1158         if (ispointer(name)) { /* handle pointer or functionpointer */
1159           cast_pointer(
1160               newsdna->pointer_size, oldsdna->pointer_size, min_name_array_len, curdata, olddata);
1161         }
1162         else if (strcmp(type, otype) == 0) { /* type equal */
1163           /* size of single old array element */
1164           mul = len / old_name_array_len;
1165           /* smaller of sizes of old and new arrays */
1166           mul *= min_name_array_len;
1167
1168           memcpy(curdata, olddata, mul);
1169
1170           if (old_name_array_len > new_name_array_len && strcmp(type, "char") == 0) {
1171             /* string had to be truncated, ensure it's still null-terminated */
1172             curdata[mul - 1] = '\0';
1173           }
1174         }
1175         else {
1176           cast_elem(type, otype, min_name_array_len, curdata, olddata);
1177         }
1178         return;
1179       }
1180     }
1181     olddata += len;
1182   }
1183 }
1184
1185 /**
1186  * Converts the contents of an entire struct from oldsdna to newsdna format.
1187  *
1188  * \param newsdna: SDNA of current Blender
1189  * \param oldsdna: SDNA of Blender that saved file
1190  * \param compflags:
1191  *
1192  * Result from DNA_struct_get_compareflags to avoid needless conversions.
1193  * \param oldSDNAnr: Index of old struct definition in oldsdna
1194  * \param data: Struct contents laid out according to oldsdna
1195  * \param curSDNAnr: Index of current struct definition in newsdna
1196  * \param cur: Where to put converted struct contents
1197  */
1198 static void reconstruct_struct(const SDNA *newsdna,
1199                                const SDNA *oldsdna,
1200                                const char *compflags,
1201
1202                                int oldSDNAnr,
1203                                const char *data,
1204                                int curSDNAnr,
1205                                char *cur)
1206 {
1207   /* Recursive!
1208    * Per element from cur_struct, read data from old_struct.
1209    * If element is a struct, call recursive.
1210    */
1211   int a, elemcount, elen, eleno, mul, mulo, firststructtypenr;
1212   const short *spo, *spc, *sppo;
1213   const char *type;
1214   const char *cpo;
1215   char *cpc;
1216   const char *name;
1217
1218   unsigned int oldsdna_index_last = UINT_MAX;
1219   unsigned int cursdna_index_last = UINT_MAX;
1220
1221   if (oldSDNAnr == -1) {
1222     return;
1223   }
1224   if (curSDNAnr == -1) {
1225     return;
1226   }
1227
1228   if (compflags[oldSDNAnr] == SDNA_CMP_EQUAL) {
1229     /* if recursive: test for equal */
1230     spo = oldsdna->structs[oldSDNAnr];
1231     elen = oldsdna->types_size[spo[0]];
1232     memcpy(cur, data, elen);
1233
1234     return;
1235   }
1236
1237   firststructtypenr = *(newsdna->structs[0]);
1238
1239   spo = oldsdna->structs[oldSDNAnr];
1240   spc = newsdna->structs[curSDNAnr];
1241
1242   elemcount = spc[1];
1243
1244   spc += 2;
1245   cpc = cur;
1246   for (a = 0; a < elemcount; a++, spc += 2) { /* convert each field */
1247     type = newsdna->types[spc[0]];
1248     name = newsdna->names[spc[1]];
1249
1250     elen = elementsize(newsdna, spc[0], spc[1]);
1251
1252     /* Skip pad bytes which must start with '_pad', see makesdna.c 'is_name_legal'.
1253      * for exact rules. Note that if we fail to skip a pad byte it's harmless,
1254      * this just avoids unnecessary reconstruction. */
1255     if (name[0] == '_' || (name[0] == '*' && name[1] == '_')) {
1256       cpc += elen;
1257     }
1258     else if (spc[0] >= firststructtypenr && !ispointer(name)) {
1259       /* struct field type */
1260
1261       /* where does the old struct data start (and is there an old one?) */
1262       cpo = (char *)find_elem(oldsdna, type, name, spo, data, &sppo);
1263
1264       if (cpo) {
1265         oldSDNAnr = DNA_struct_find_nr_ex(oldsdna, type, &oldsdna_index_last);
1266         curSDNAnr = DNA_struct_find_nr_ex(newsdna, type, &cursdna_index_last);
1267
1268         /* array! */
1269         mul = newsdna->names_array_len[spc[1]];
1270         mulo = oldsdna->names_array_len[sppo[1]];
1271
1272         eleno = elementsize(oldsdna, sppo[0], sppo[1]);
1273
1274         elen /= mul;
1275         eleno /= mulo;
1276
1277         while (mul--) {
1278           reconstruct_struct(newsdna, oldsdna, compflags, oldSDNAnr, cpo, curSDNAnr, cpc);
1279           cpo += eleno;
1280           cpc += elen;
1281
1282           /* new struct array larger than old */
1283           mulo--;
1284           if (mulo <= 0) {
1285             break;
1286           }
1287         }
1288       }
1289       else {
1290         cpc += elen; /* skip field no longer present */
1291       }
1292     }
1293     else {
1294       /* non-struct field type */
1295       reconstruct_elem(newsdna, oldsdna, type, spc[1], cpc, spo, data);
1296       cpc += elen;
1297     }
1298   }
1299 }
1300
1301 /**
1302  * Does endian swapping on the fields of a struct value.
1303  *
1304  * \param oldsdna: SDNA of Blender that saved file
1305  * \param oldSDNAnr: Index of struct info within oldsdna
1306  * \param data: Struct data
1307  */
1308 void DNA_struct_switch_endian(const SDNA *oldsdna, int oldSDNAnr, char *data)
1309 {
1310   /* Recursive!
1311    * If element is a struct, call recursive.
1312    */
1313   int a, mul, elemcount, elen, elena, firststructtypenr;
1314   const short *spo, *spc;
1315   char *cur;
1316   const char *type, *name;
1317   unsigned int oldsdna_index_last = UINT_MAX;
1318
1319   if (oldSDNAnr == -1) {
1320     return;
1321   }
1322   firststructtypenr = *(oldsdna->structs[0]);
1323
1324   spo = spc = oldsdna->structs[oldSDNAnr];
1325
1326   elemcount = spo[1];
1327
1328   spc += 2;
1329   cur = data;
1330
1331   for (a = 0; a < elemcount; a++, spc += 2) {
1332     type = oldsdna->types[spc[0]];
1333     name = oldsdna->names[spc[1]];
1334     const int old_name_array_len = oldsdna->names_array_len[spc[1]];
1335
1336     /* elementsize = including arraysize */
1337     elen = elementsize(oldsdna, spc[0], spc[1]);
1338
1339     /* test: is type a struct? */
1340     if (spc[0] >= firststructtypenr && !ispointer(name)) {
1341       /* struct field type */
1342       /* where does the old data start (is there one?) */
1343       char *cpo = (char *)find_elem(oldsdna, type, name, spo, data, NULL);
1344       if (cpo) {
1345         oldSDNAnr = DNA_struct_find_nr_ex(oldsdna, type, &oldsdna_index_last);
1346
1347         mul = old_name_array_len;
1348         elena = elen / mul;
1349
1350         while (mul--) {
1351           DNA_struct_switch_endian(oldsdna, oldSDNAnr, cpo);
1352           cpo += elena;
1353         }
1354       }
1355     }
1356     else {
1357       /* non-struct field type */
1358       if (ispointer(name)) {
1359         if (oldsdna->pointer_size == 8) {
1360           BLI_endian_switch_int64_array((int64_t *)cur, old_name_array_len);
1361         }
1362       }
1363       else {
1364         if (ELEM(spc[0], SDNA_TYPE_SHORT, SDNA_TYPE_USHORT)) {
1365
1366           /* exception: variable called blocktype: derived from ID_  */
1367           bool skip = false;
1368           if (name[0] == 'b' && name[1] == 'l') {
1369             if (strcmp(name, "blocktype") == 0) {
1370               skip = true;
1371             }
1372           }
1373
1374           if (skip == false) {
1375             BLI_endian_switch_int16_array((int16_t *)cur, old_name_array_len);
1376           }
1377         }
1378         else if (ELEM(spc[0], SDNA_TYPE_INT, SDNA_TYPE_FLOAT)) {
1379           /* note, intentionally ignore long/ulong here these could be 4 or 8 bits,
1380            * but turns out we only used for runtime vars and
1381            * only once for a struct type that's no longer used. */
1382
1383           BLI_endian_switch_int32_array((int32_t *)cur, old_name_array_len);
1384         }
1385         else if (ELEM(spc[0], SDNA_TYPE_INT64, SDNA_TYPE_UINT64, SDNA_TYPE_DOUBLE)) {
1386           BLI_endian_switch_int64_array((int64_t *)cur, old_name_array_len);
1387         }
1388       }
1389     }
1390     cur += elen;
1391   }
1392 }
1393
1394 /**
1395  * \param newsdna: SDNA of current Blender
1396  * \param oldsdna: SDNA of Blender that saved file
1397  * \param compflags:
1398  *
1399  * Result from DNA_struct_get_compareflags to avoid needless conversions
1400  * \param oldSDNAnr: Index of struct info within oldsdna
1401  * \param blocks: The number of array elements
1402  * \param data: Array of struct data
1403  * \return An allocated reconstructed struct
1404  */
1405 void *DNA_struct_reconstruct(const SDNA *newsdna,
1406                              const SDNA *oldsdna,
1407                              const char *compflags,
1408                              int oldSDNAnr,
1409                              int blocks,
1410                              const void *data)
1411 {
1412   int a, curSDNAnr, curlen = 0, oldlen;
1413   const short *spo, *spc;
1414   char *cur, *cpc;
1415   const char *cpo;
1416   const char *type;
1417
1418   /* oldSDNAnr == structnr, we're looking for the corresponding 'cur' number */
1419   spo = oldsdna->structs[oldSDNAnr];
1420   type = oldsdna->types[spo[0]];
1421   oldlen = oldsdna->types_size[spo[0]];
1422   curSDNAnr = DNA_struct_find_nr(newsdna, type);
1423
1424   /* init data and alloc */
1425   if (curSDNAnr != -1) {
1426     spc = newsdna->structs[curSDNAnr];
1427     curlen = newsdna->types_size[spc[0]];
1428   }
1429   if (curlen == 0) {
1430     return NULL;
1431   }
1432
1433   cur = MEM_callocN(blocks * curlen, "reconstruct");
1434   cpc = cur;
1435   cpo = data;
1436   for (a = 0; a < blocks; a++) {
1437     reconstruct_struct(newsdna, oldsdna, compflags, oldSDNAnr, cpo, curSDNAnr, cpc);
1438     cpc += curlen;
1439     cpo += oldlen;
1440   }
1441
1442   return cur;
1443 }
1444
1445 /**
1446  * Returns the offset of the field with the specified name and type within the specified
1447  * struct type in sdna.
1448  */
1449 int DNA_elem_offset(SDNA *sdna, const char *stype, const char *vartype, const char *name)
1450 {
1451   const int SDNAnr = DNA_struct_find_nr(sdna, stype);
1452   const short *const spo = sdna->structs[SDNAnr];
1453   const char *const cp = find_elem(sdna, vartype, name, spo, NULL, NULL);
1454   BLI_assert(SDNAnr != -1);
1455   return (int)((intptr_t)cp);
1456 }
1457
1458 bool DNA_struct_find(const SDNA *sdna, const char *stype)
1459 {
1460   return DNA_struct_find_nr(sdna, stype) != -1;
1461 }
1462
1463 bool DNA_struct_elem_find(const SDNA *sdna,
1464                           const char *stype,
1465                           const char *vartype,
1466                           const char *name)
1467 {
1468   const int SDNAnr = DNA_struct_find_nr(sdna, stype);
1469
1470   if (SDNAnr != -1) {
1471     const short *const spo = sdna->structs[SDNAnr];
1472     const bool found = elem_exists(sdna, vartype, name, spo);
1473
1474     if (found) {
1475       return true;
1476     }
1477   }
1478   return false;
1479 }
1480
1481 /** \note requires #DNA_sdna_alias_data_ensure_structs_map to be called. */
1482 bool DNA_struct_alias_elem_find(const SDNA *sdna,
1483                                 const char *stype,
1484                                 const char *vartype,
1485                                 const char *name)
1486 {
1487   const int SDNAnr = DNA_struct_alias_find_nr(sdna, stype);
1488
1489   if (SDNAnr != -1) {
1490     const short *const spo = sdna->structs[SDNAnr];
1491     const bool found = elem_exists_alias(sdna, vartype, name, spo);
1492
1493     if (found) {
1494       return true;
1495     }
1496   }
1497   return false;
1498 }
1499
1500 /**
1501  * Returns the size in bytes of a primitive type.
1502  */
1503 int DNA_elem_type_size(const eSDNA_Type elem_nr)
1504 {
1505   /* should contain all enum types */
1506   switch (elem_nr) {
1507     case SDNA_TYPE_CHAR:
1508     case SDNA_TYPE_UCHAR:
1509       return 1;
1510     case SDNA_TYPE_SHORT:
1511     case SDNA_TYPE_USHORT:
1512       return 2;
1513     case SDNA_TYPE_INT:
1514     case SDNA_TYPE_FLOAT:
1515       return 4;
1516     case SDNA_TYPE_DOUBLE:
1517     case SDNA_TYPE_INT64:
1518     case SDNA_TYPE_UINT64:
1519       return 8;
1520   }
1521
1522   /* weak */
1523   return 8;
1524 }
1525
1526 /* -------------------------------------------------------------------- */
1527 /** \name Version Patch DNA
1528  * \{ */
1529
1530 static bool DNA_sdna_patch_struct_nr(SDNA *sdna,
1531                                      const int struct_name_old_nr,
1532                                      const char *struct_name_new)
1533 {
1534   BLI_assert(DNA_struct_find_nr(DNA_sdna_current_get(), struct_name_new) != -1);
1535   const short *sp = sdna->structs[struct_name_old_nr];
1536 #ifdef WITH_DNA_GHASH
1537   BLI_ghash_remove(sdna->structs_map, (void *)sdna->types[sp[0]], NULL, NULL);
1538   BLI_ghash_insert(
1539       sdna->structs_map, (void *)struct_name_new, POINTER_FROM_INT(struct_name_old_nr));
1540 #endif
1541   sdna->types[sp[0]] = struct_name_new;
1542   return true;
1543 }
1544 /**
1545  * Rename a struct
1546  */
1547 bool DNA_sdna_patch_struct(SDNA *sdna, const char *struct_name_old, const char *struct_name_new)
1548 {
1549   const int struct_name_old_nr = DNA_struct_find_nr(sdna, struct_name_old);
1550   if (struct_name_old_nr != -1) {
1551     return DNA_sdna_patch_struct_nr(sdna, struct_name_old_nr, struct_name_new);
1552   }
1553   return false;
1554 }
1555
1556 /* Make public if called often with same struct (avoid duplicate look-ups). */
1557 static bool DNA_sdna_patch_struct_member_nr(SDNA *sdna,
1558                                             const int struct_name_nr,
1559                                             const char *elem_old,
1560                                             const char *elem_new)
1561 {
1562   /* These names aren't handled here (it's not used).
1563    * Ensure they are never used or we get out of sync arrays. */
1564   BLI_assert(sdna->alias.names == NULL);
1565   const int elem_old_len = strlen(elem_old);
1566   const int elem_new_len = strlen(elem_new);
1567   BLI_assert(elem_new != NULL);
1568   short *sp = sdna->structs[struct_name_nr];
1569   for (int elem_index = sp[1]; elem_index > 0; elem_index--, sp += 2) {
1570     const char *elem_old_full = sdna->names[sp[1]];
1571     /* Start & end offsets in 'elem_old_full'. */
1572     uint elem_old_full_offset_start;
1573     if (DNA_elem_id_match(elem_old, elem_old_len, elem_old_full, &elem_old_full_offset_start)) {
1574       if (sdna->mem_arena == NULL) {
1575         sdna->mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
1576       }
1577       const char *elem_new_full = DNA_elem_id_rename(sdna->mem_arena,
1578                                                      elem_old,
1579                                                      elem_old_len,
1580                                                      elem_new,
1581                                                      elem_new_len,
1582                                                      elem_old_full,
1583                                                      strlen(elem_old_full),
1584                                                      elem_old_full_offset_start);
1585
1586       if (sdna->names_len == sdna->names_len_alloc) {
1587         sdna->names_len_alloc += 64;
1588         sdna->names = MEM_recallocN((void *)sdna->names,
1589                                     sizeof(*sdna->names) * sdna->names_len_alloc);
1590         sdna->names_array_len = MEM_recallocN(
1591             (void *)sdna->names_array_len, sizeof(*sdna->names_array_len) * sdna->names_len_alloc);
1592       }
1593       const short name_nr_prev = sp[1];
1594       sp[1] = sdna->names_len++;
1595       sdna->names[sp[1]] = elem_new_full;
1596       sdna->names_array_len[sp[1]] = sdna->names_array_len[name_nr_prev];
1597
1598       return true;
1599     }
1600   }
1601   return false;
1602 }
1603 /**
1604  * Replace \a elem_old with \a elem_new for struct \a struct_name
1605  * handles search & replace, maintaining surrounding non-identifier characters
1606  * such as pointer & array size.
1607  */
1608 bool DNA_sdna_patch_struct_member(SDNA *sdna,
1609                                   const char *struct_name,
1610                                   const char *elem_old,
1611                                   const char *elem_new)
1612 {
1613   const int struct_name_nr = DNA_struct_find_nr(sdna, struct_name);
1614   if (struct_name_nr != -1) {
1615     return DNA_sdna_patch_struct_member_nr(sdna, struct_name_nr, elem_old, elem_new);
1616   }
1617   return false;
1618 }
1619
1620 /** \} */
1621
1622 /* -------------------------------------------------------------------- */
1623 /** \name Versioning (Forward Compatible)
1624  *
1625  * Versioning that allows new names.
1626  * \{ */
1627
1628 /**
1629  * Names are shared between structs which causes problems renaming.
1630  * Make sure every struct member gets it's own name so renaming only ever impacts a single struct.
1631  *
1632  * The resulting SDNA is never written to disk.
1633  */
1634 static void sdna_expand_names(SDNA *sdna)
1635 {
1636   int names_expand_len = 0;
1637   for (int struct_nr = 0; struct_nr < sdna->structs_len; struct_nr++) {
1638     const short *sp = sdna->structs[struct_nr];
1639     names_expand_len += sp[1];
1640   }
1641   const char **names_expand = MEM_mallocN(sizeof(*names_expand) * names_expand_len, __func__);
1642
1643   int names_expand_index = 0;
1644   for (int struct_nr = 0; struct_nr < sdna->structs_len; struct_nr++) {
1645     /* We can't edit this memory 'sdna->structs' points to (readonly datatoc file). */
1646     const short *sp = sdna->structs[struct_nr];
1647     short *sp_expand = BLI_memarena_alloc(sdna->mem_arena, sizeof(short[2]) * (1 + sp[1]));
1648     memcpy(sp_expand, sp, sizeof(short[2]) * (1 + sp[1]));
1649     sdna->structs[struct_nr] = sp_expand;
1650     const int names_len = sp[1];
1651     sp += 2;
1652     sp_expand += 2;
1653     for (int i = 0; i < names_len; i++, sp += 2, sp_expand += 2) {
1654       names_expand[names_expand_index] = sdna->names[sp[1]];
1655       BLI_assert(names_expand_index < SHRT_MAX);
1656       sp_expand[1] = names_expand_index;
1657       names_expand_index++;
1658     }
1659   }
1660   MEM_freeN((void *)sdna->names);
1661   sdna->names = names_expand;
1662   sdna->names_len = names_expand_len;
1663 }
1664
1665 static const char *dna_sdna_alias_from_static_elem_full(SDNA *sdna,
1666                                                         GHash *elem_map_alias_from_static,
1667                                                         const char *struct_name_static,
1668                                                         const char *elem_static_full)
1669 {
1670   const int elem_static_full_len = strlen(elem_static_full);
1671   char *elem_static = alloca(elem_static_full_len + 1);
1672   const int elem_static_len = DNA_elem_id_strip_copy(elem_static, elem_static_full);
1673   const char *str_pair[2] = {struct_name_static, elem_static};
1674   const char *elem_alias = BLI_ghash_lookup(elem_map_alias_from_static, str_pair);
1675   if (elem_alias) {
1676     return DNA_elem_id_rename(sdna->mem_arena,
1677                               elem_static,
1678                               elem_static_len,
1679                               elem_alias,
1680                               strlen(elem_alias),
1681                               elem_static_full,
1682                               elem_static_full_len,
1683                               DNA_elem_id_offset_start(elem_static_full));
1684   }
1685   return NULL;
1686 }
1687
1688 void DNA_sdna_alias_data_ensure(SDNA *sdna)
1689 {
1690   /* We may want this to be optional later. */
1691   const bool use_legacy_hack = true;
1692
1693   if (sdna->mem_arena == NULL) {
1694     sdna->mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
1695   }
1696
1697   GHash *struct_map_alias_from_static;
1698   GHash *elem_map_alias_from_static;
1699
1700   DNA_alias_maps(
1701       DNA_RENAME_ALIAS_FROM_STATIC, &struct_map_alias_from_static, &elem_map_alias_from_static);
1702
1703   if (sdna->alias.types == NULL) {
1704     sdna->alias.types = MEM_mallocN(sizeof(*sdna->alias.types) * sdna->types_len, __func__);
1705     for (int type_nr = 0; type_nr < sdna->types_len; type_nr++) {
1706       const char *struct_name_static = sdna->types[type_nr];
1707
1708       if (use_legacy_hack) {
1709         struct_name_static = DNA_struct_rename_legacy_hack_alias_from_static(struct_name_static);
1710       }
1711
1712       sdna->alias.types[type_nr] = BLI_ghash_lookup_default(
1713           struct_map_alias_from_static, struct_name_static, (void *)struct_name_static);
1714     }
1715   }
1716
1717   if (sdna->alias.names == NULL) {
1718     sdna_expand_names(sdna);
1719     sdna->alias.names = MEM_mallocN(sizeof(*sdna->alias.names) * sdna->names_len, __func__);
1720     for (int struct_nr = 0; struct_nr < sdna->structs_len; struct_nr++) {
1721       const short *sp = sdna->structs[struct_nr];
1722       const char *struct_name_static = sdna->types[sp[0]];
1723
1724       if (use_legacy_hack) {
1725         struct_name_static = DNA_struct_rename_legacy_hack_alias_from_static(struct_name_static);
1726       }
1727
1728       const int dna_struct_names_len = sp[1];
1729       sp += 2;
1730       for (int a = 0; a < dna_struct_names_len; a++, sp += 2) {
1731         const char *elem_alias_full = dna_sdna_alias_from_static_elem_full(
1732             sdna, elem_map_alias_from_static, struct_name_static, sdna->names[sp[1]]);
1733         if (elem_alias_full != NULL) {
1734           sdna->alias.names[sp[1]] = elem_alias_full;
1735         }
1736         else {
1737           sdna->alias.names[sp[1]] = sdna->names[sp[1]];
1738         }
1739       }
1740     }
1741   }
1742   BLI_ghash_free(struct_map_alias_from_static, NULL, NULL);
1743   BLI_ghash_free(elem_map_alias_from_static, MEM_freeN, NULL);
1744 }
1745
1746 /**
1747  * Separated from #DNA_sdna_alias_data_ensure because it's not needed
1748  * unless we want to lookup aliased struct names (#DNA_struct_alias_find_nr and friends).
1749  */
1750 void DNA_sdna_alias_data_ensure_structs_map(SDNA *sdna)
1751 {
1752   DNA_sdna_alias_data_ensure(sdna);
1753 #ifdef WITH_DNA_GHASH
1754   /* create a ghash lookup to speed up */
1755   struct GHash *structs_map = BLI_ghash_str_new_ex(__func__, sdna->structs_len);
1756   for (intptr_t nr = 0; nr < sdna->structs_len; nr++) {
1757     const short *sp = sdna->structs[nr];
1758     BLI_ghash_insert(structs_map, (void *)sdna->alias.types[sp[0]], POINTER_FROM_INT(nr));
1759   }
1760   sdna->alias.structs_map = structs_map;
1761 #else
1762   UNUSED_VARS(sdna);
1763 #endif
1764 }
1765
1766 /** \} */