CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.git] / source / blender / makesdna / intern / makesdna.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  */
19
20 /** \file
21  * \ingroup DNA
22  *
23  * \brief Struct muncher for making SDNA.
24  *
25  * \section aboutmakesdnac About makesdna tool
26  * Originally by Ton, some mods by Frank, and some cleaning and
27  * extension by Nzc.
28  *
29  * Makesdna creates a .c file with a long string of numbers that
30  * encode the Blender file format. It is fast, because it is basically
31  * a binary dump. There are some details to mind when reconstructing
32  * the file (endianness and byte-alignment).
33  *
34  * This little program scans all structs that need to be serialized,
35  * and determined the names and types of all members. It calculates
36  * how much memory (on disk or in ram) is needed to store that struct,
37  * and the offsets for reaching a particular one.
38  *
39  * There is a facility to get verbose output from sdna. Search for
40  * \ref debugSDNA. This int can be set to 0 (no output) to some int. Higher
41  * numbers give more output.
42  */
43
44 #define DNA_DEPRECATED_ALLOW
45
46 #include <assert.h>
47 #include <stdio.h>
48 #include <stdlib.h>
49 #include <string.h>
50
51 #include "MEM_guardedalloc.h"
52
53 #include "BLI_alloca.h"
54 #include "BLI_ghash.h"
55 #include "BLI_memarena.h"
56 #include "BLI_sys_types.h" /* for intptr_t support */
57 #include "BLI_utildefines.h"
58
59 #include "dna_utils.h"
60
61 #define SDNA_MAX_FILENAME_LENGTH 255
62
63 /* Included the path relative from /source/blender/ here, so we can move     */
64 /* headers around with more freedom.                                         */
65 static const char *includefiles[] = {
66     /* if you add files here, please add them at the end
67      * of makesdna.c (this file) as well */
68     "DNA_listBase.h",
69     "DNA_vec_types.h",
70     "DNA_ID.h",
71     "DNA_ipo_types.h",
72     "DNA_key_types.h",
73     "DNA_text_types.h",
74     "DNA_packedFile_types.h",
75     "DNA_gpu_types.h",
76     "DNA_camera_types.h",
77     "DNA_image_types.h",
78     "DNA_texture_types.h",
79     "DNA_light_types.h",
80     "DNA_material_types.h",
81     "DNA_vfont_types.h",
82     "DNA_meta_types.h",
83     "DNA_curve_types.h",
84     "DNA_mesh_types.h",
85     "DNA_meshdata_types.h",
86     "DNA_modifier_types.h",
87     "DNA_lattice_types.h",
88     "DNA_object_types.h",
89     "DNA_object_force_types.h",
90     "DNA_object_fluidsim_types.h",
91     "DNA_world_types.h",
92     "DNA_scene_types.h",
93     "DNA_view3d_types.h",
94     "DNA_view2d_types.h",
95     "DNA_space_types.h",
96     "DNA_userdef_types.h",
97     "DNA_screen_types.h",
98     "DNA_sdna_types.h",
99     "DNA_fileglobal_types.h",
100     "DNA_sequence_types.h",
101     "DNA_effect_types.h",
102     "DNA_outliner_types.h",
103     "DNA_sound_types.h",
104     "DNA_collection_types.h",
105     "DNA_armature_types.h",
106     "DNA_action_types.h",
107     "DNA_constraint_types.h",
108     "DNA_nla_types.h",
109     "DNA_node_types.h",
110     "DNA_color_types.h",
111     "DNA_brush_types.h",
112     "DNA_customdata_types.h",
113     "DNA_particle_types.h",
114     "DNA_cloth_types.h",
115     "DNA_gpencil_types.h",
116     "DNA_gpencil_modifier_types.h",
117     "DNA_shader_fx_types.h",
118     "DNA_windowmanager_types.h",
119     "DNA_anim_types.h",
120     "DNA_boid_types.h",
121     "DNA_fluid_types.h",
122     "DNA_speaker_types.h",
123     "DNA_movieclip_types.h",
124     "DNA_tracking_types.h",
125     "DNA_dynamicpaint_types.h",
126     "DNA_mask_types.h",
127     "DNA_rigidbody_types.h",
128     "DNA_freestyle_types.h",
129     "DNA_linestyle_types.h",
130     "DNA_cachefile_types.h",
131     "DNA_layer_types.h",
132     "DNA_workspace_types.h",
133     "DNA_lightprobe_types.h",
134     "DNA_curveprofile_types.h",
135     "DNA_xr_types.h",
136     "DNA_hair_types.h",
137     "DNA_pointcloud_types.h",
138     "DNA_volume_types.h",
139     "DNA_simulation_types.h",
140
141     /* see comment above before editing! */
142
143     /* empty string to indicate end of includefiles */
144     "",
145 };
146
147 /* -------------------------------------------------------------------- */
148 /** \name Variables
149  * \{ */
150
151 static MemArena *mem_arena = NULL;
152
153 static int max_data_size = 500000, max_array_len = 50000;
154 static int names_len = 0;
155 static int types_len = 0;
156 static int structs_len = 0;
157 /** At address `names[a]` is string `a`. */
158 static char **names;
159 /** At address `types[a]` is string `a`. */
160 static char **types;
161 /** At `types_size[a]` is the size of type `a` on this systems bitness (32 or 64). */
162 static short *types_size_native;
163 /** Contains sizes as they are calculated on 32 bit systems. */
164 static short *types_size_32;
165 /** Contains sizes as they are calculated on 64 bit systems. */
166 static short *types_size_64;
167 /**
168  * At `sp = structs[a]` is the first address of a struct definition:
169  * - `sp[0]` is type number.
170  * - `sp[1]` is the length of the element array (next).
171  * - `sp[2]` sp[3] is [(type_index, name_index), ..] (number of pairs is defined by `sp[1]`),
172  */
173 static short **structs, *structdata;
174
175 /** Versioning data */
176 static struct {
177   GHash *struct_map_alias_from_static;
178   GHash *struct_map_static_from_alias;
179   GHash *elem_map_alias_from_static;
180   GHash *elem_map_static_from_alias;
181 } g_version_data = {NULL};
182
183 /**
184  * Variable to control debug output of makesdna.
185  * debugSDNA:
186  * - 0 = no output, except errors
187  * - 1 = detail actions
188  * - 2 = full trace, tell which names and types were found
189  * - 4 = full trace, plus all gritty details
190  */
191 static int debugSDNA = 0;
192 static int additional_slen_offset;
193
194 #define DEBUG_PRINTF(debug_level, ...) \
195   { \
196     if (debugSDNA > debug_level) { \
197       printf(__VA_ARGS__); \
198     } \
199   } \
200   ((void)0)
201
202 /* stub for BLI_abort() */
203 #ifndef NDEBUG
204 void BLI_system_backtrace(FILE *fp)
205 {
206   (void)fp;
207 }
208 #endif
209
210 /** \} */
211
212 /* -------------------------------------------------------------------- */
213 /** \name Function Declarations
214  * \{ */
215
216 /**
217  * Ensure type \c str to is in the #types array.
218  * \param str: Struct name without any qualifiers.
219  * \param len: The struct size in bytes.
220  * \return Index in the #types array.
221  */
222 static int add_type(const char *str, int size);
223
224 /**
225  * Ensure \c str is int the #names array.
226  * \param str: Struct member name which may include pointer prefix & array size.
227  * \return Index in the #names array.
228  */
229 static int add_name(const char *str);
230
231 /**
232  * Search whether this structure type was already found, and if not,
233  * add it.
234  */
235 static short *add_struct(int namecode);
236
237 /**
238  * Remove comments from this buffer. Assumes that the buffer refers to
239  * ascii-code text.
240  */
241 static int preprocess_include(char *maindata, const int maindata_len);
242
243 /**
244  * Scan this file for serializable types.
245  */
246 static int convert_include(const char *filename);
247
248 /**
249  * Determine how many bytes are needed for each struct.
250  */
251 static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char *base_directory);
252
253 /**
254  * Construct the DNA.c file
255  */
256 static void dna_write(FILE *file, const void *pntr, const int size);
257
258 /**
259  * Report all structures found so far, and print their lengths.
260  */
261 void print_struct_sizes(void);
262
263 /** \} */
264
265 /* -------------------------------------------------------------------- */
266 /** \name Implementation
267  *
268  * Make DNA string (write to file).
269  * \{ */
270
271 static const char *version_struct_static_from_alias(const char *str)
272 {
273   const char *str_test = BLI_ghash_lookup(g_version_data.struct_map_static_from_alias, str);
274   if (str_test != NULL) {
275     return str_test;
276   }
277   return str;
278 }
279
280 static const char *version_struct_alias_from_static(const char *str)
281 {
282   const char *str_test = BLI_ghash_lookup(g_version_data.struct_map_alias_from_static, str);
283   if (str_test != NULL) {
284     return str_test;
285   }
286   return str;
287 }
288
289 static const char *version_elem_static_from_alias(const int strct, const char *elem_alias_full)
290 {
291   const uint elem_alias_full_len = strlen(elem_alias_full);
292   char *elem_alias = alloca(elem_alias_full_len + 1);
293   const int elem_alias_len = DNA_elem_id_strip_copy(elem_alias, elem_alias_full);
294   const char *str_pair[2] = {types[strct], elem_alias};
295   const char *elem_static = BLI_ghash_lookup(g_version_data.elem_map_static_from_alias, str_pair);
296   if (elem_static != NULL) {
297     return DNA_elem_id_rename(mem_arena,
298                               elem_alias,
299                               elem_alias_len,
300                               elem_static,
301                               strlen(elem_static),
302                               elem_alias_full,
303                               elem_alias_full_len,
304                               DNA_elem_id_offset_start(elem_alias_full));
305   }
306   return elem_alias_full;
307 }
308
309 /**
310  * Enforce '_pad123' naming convention, disallow 'pad123' or 'pad_123',
311  * special exception for [a-z] after since there is a 'pad_rot_angle' preference.
312  */
313 static bool is_name_legal(const char *name)
314 {
315   const int name_size = strlen(name) + 1;
316   char *name_strip = alloca(name_size);
317   DNA_elem_id_strip_copy(name_strip, name);
318
319   const char prefix[] = {'p', 'a', 'd'};
320
321   if (name[0] == '_') {
322     if (strncmp(&name_strip[1], prefix, sizeof(prefix)) != 0) {
323       fprintf(
324           stderr, "Error: only '_pad' variables can start with an underscore, found '%s'\n", name);
325       return false;
326     }
327   }
328   else if (strncmp(name_strip, prefix, sizeof(prefix)) == 0) {
329     int i = sizeof(prefix);
330     if (name_strip[i] >= 'a' && name_strip[i] <= 'z') {
331       /* may be part of a word, allow that. */
332       return true;
333     }
334     bool has_only_digit_or_none = true;
335     for (; name_strip[i]; i++) {
336       const char c = name_strip[i];
337       if (!((c >= '0' && c <= '9') || c == '_')) {
338         has_only_digit_or_none = false;
339         break;
340       }
341     }
342     if (has_only_digit_or_none) {
343       /* found 'pad' or 'pad123'. */
344       fprintf(
345           stderr, "Error: padding variables must be formatted '_pad[number]', found '%s'\n", name);
346       return false;
347     }
348   }
349   return true;
350 }
351
352 static int add_type(const char *str, int size)
353 {
354   char *cp;
355
356   /* first do validity check */
357   if (str[0] == 0) {
358     return -1;
359   }
360   else if (strchr(str, '*')) {
361     /* note: this is valid C syntax but we can't parse, complain!
362      * 'struct SomeStruct* somevar;' <-- correct but we cant handle right now. */
363     return -1;
364   }
365
366   str = version_struct_static_from_alias(str);
367
368   /* search through type array */
369   for (int index = 0; index < types_len; index++) {
370     if (strcmp(str, types[index]) == 0) {
371       if (size) {
372         types_size_native[index] = size;
373         types_size_32[index] = size;
374         types_size_64[index] = size;
375       }
376       return index;
377     }
378   }
379
380   /* append new type */
381   const int str_size = strlen(str) + 1;
382   cp = BLI_memarena_alloc(mem_arena, str_size);
383   memcpy(cp, str, str_size);
384   types[types_len] = cp;
385   types_size_native[types_len] = size;
386   types_size_32[types_len] = size;
387   types_size_64[types_len] = size;
388
389   if (types_len >= max_array_len) {
390     printf("too many types\n");
391     return types_len - 1;
392   }
393   types_len++;
394
395   return types_len - 1;
396 }
397
398 /**
399  *
400  * Because of the weird way of tokenizing, we have to 'cast' function
401  * pointers to ... (*f)(), whatever the original signature. In fact,
402  * we add name and type at the same time... There are two special
403  * cases, unfortunately. These are explicitly checked.
404  *
405  * */
406 static int add_name(const char *str)
407 {
408   int nr, i, j, k;
409   char *cp;
410   char buf[255]; /* stupid limit, change it :) */
411   const char *name;
412
413   additional_slen_offset = 0;
414
415   if (str[0] == 0 /*  || (str[1] == 0) */) {
416     return -1;
417   }
418
419   if (str[0] == '(' && str[1] == '*') {
420     /* we handle function pointer and special array cases here, e.g.
421      * void (*function)(...) and float (*array)[..]. the array case
422      * name is still converted to (array *)() though because it is that
423      * way in old dna too, and works correct with elementsize() */
424     int isfuncptr = (strchr(str + 1, '(')) != NULL;
425
426     DEBUG_PRINTF(3, "\t\t\t\t*** Function pointer or multidim array pointer found\n");
427     /* functionpointer: transform the type (sometimes) */
428     i = 0;
429
430     while (str[i] != ')') {
431       buf[i] = str[i];
432       i++;
433     }
434
435     /* Another number we need is the extra slen offset. This extra
436      * offset is the overshoot after a space. If there is no
437      * space, no overshoot should be calculated. */
438     j = i; /* j at first closing brace */
439
440     DEBUG_PRINTF(3, "first brace after offset %d\n", i);
441
442     j++; /* j beyond closing brace ? */
443     while ((str[j] != 0) && (str[j] != ')')) {
444       DEBUG_PRINTF(3, "seen %c (%d)\n", str[j], str[j]);
445       j++;
446     }
447     DEBUG_PRINTF(3,
448                  "seen %c (%d)\n"
449                  "special after offset%d\n",
450                  str[j],
451                  str[j],
452                  j);
453
454     if (!isfuncptr) {
455       /* multidimensional array pointer case */
456       if (str[j] == 0) {
457         DEBUG_PRINTF(3, "offsetting for multidim array pointer\n");
458       }
459       else {
460         printf("Error during tokening multidim array pointer\n");
461       }
462     }
463     else if (str[j] == 0) {
464       DEBUG_PRINTF(3, "offsetting for space\n");
465       /* get additional offset */
466       k = 0;
467       while (str[j] != ')') {
468         j++;
469         k++;
470       }
471       DEBUG_PRINTF(3, "extra offset %d\n", k);
472       additional_slen_offset = k;
473     }
474     else if (str[j] == ')') {
475       DEBUG_PRINTF(3, "offsetting for brace\n");
476       /* don't get extra offset */
477     }
478     else {
479       printf("Error during tokening function pointer argument list\n");
480     }
481
482     /*
483      * Put )(void) at the end? Maybe )(). Should check this with
484      * old sdna. Actually, sometimes )(), sometimes )(void...)
485      * Alas.. such is the nature of brain-damage :(
486      *
487      * Sorted it out: always do )(), except for headdraw and
488      * windraw, part of ScrArea. This is important, because some
489      * linkers will treat different fp's differently when called
490      * !!! This has to do with interference in byte-alignment and
491      * the way args are pushed on the stack.
492      *
493      * */
494     buf[i] = 0;
495     DEBUG_PRINTF(3, "Name before chomping: %s\n", buf);
496     if ((strncmp(buf, "(*headdraw", 10) == 0) || (strncmp(buf, "(*windraw", 9) == 0)) {
497       buf[i] = ')';
498       buf[i + 1] = '(';
499       buf[i + 2] = 'v';
500       buf[i + 3] = 'o';
501       buf[i + 4] = 'i';
502       buf[i + 5] = 'd';
503       buf[i + 6] = ')';
504       buf[i + 7] = 0;
505     }
506     else {
507       buf[i] = ')';
508       buf[i + 1] = '(';
509       buf[i + 2] = ')';
510       buf[i + 3] = 0;
511     }
512     /* now precede with buf*/
513     DEBUG_PRINTF(3, "\t\t\t\t\tProposing fp name %s\n", buf);
514     name = buf;
515   }
516   else {
517     /* normal field: old code */
518     name = str;
519   }
520
521   /* search name array */
522   for (nr = 0; nr < names_len; nr++) {
523     if (strcmp(name, names[nr]) == 0) {
524       return nr;
525     }
526   }
527
528   /* Sanity check the name. */
529   if (!is_name_legal(name)) {
530     return -1;
531   }
532
533   /* Append new name. */
534   const int name_size = strlen(name) + 1;
535   cp = BLI_memarena_alloc(mem_arena, name_size);
536   memcpy(cp, name, name_size);
537   names[names_len] = cp;
538
539   if (names_len >= max_array_len) {
540     printf("too many names\n");
541     return names_len - 1;
542   }
543   names_len++;
544
545   return names_len - 1;
546 }
547
548 static short *add_struct(int namecode)
549 {
550   int len;
551   short *sp;
552
553   if (structs_len == 0) {
554     structs[0] = structdata;
555   }
556   else {
557     sp = structs[structs_len - 1];
558     len = sp[1];
559     structs[structs_len] = sp + 2 * len + 2;
560   }
561
562   sp = structs[structs_len];
563   sp[0] = namecode;
564
565   if (structs_len >= max_array_len) {
566     printf("too many structs\n");
567     return sp;
568   }
569   structs_len++;
570
571   return sp;
572 }
573
574 static int preprocess_include(char *maindata, const int maindata_len)
575 {
576   int a, newlen, comment = 0;
577   char *cp, *temp, *md;
578
579   /* note: len + 1, last character is a dummy to prevent
580    * comparisons using uninitialized memory */
581   temp = MEM_mallocN(maindata_len + 1, "preprocess_include");
582   temp[maindata_len] = ' ';
583
584   memcpy(temp, maindata, maindata_len);
585
586   /* remove all c++ comments */
587   /* replace all enters/tabs/etc with spaces */
588   cp = temp;
589   a = maindata_len;
590   comment = 0;
591   while (a--) {
592     if (cp[0] == '/' && cp[1] == '/') {
593       comment = 1;
594     }
595     else if (*cp == '\n') {
596       comment = 0;
597     }
598     if (comment || *cp < 32 || *cp > 128) {
599       *cp = 32;
600     }
601     cp++;
602   }
603
604   /* data from temp copy to maindata, remove comments and double spaces */
605   cp = temp;
606   md = maindata;
607   newlen = 0;
608   comment = 0;
609   a = maindata_len;
610   while (a--) {
611
612     if (cp[0] == '/' && cp[1] == '*') {
613       comment = 1;
614       cp[0] = cp[1] = 32;
615     }
616     if (cp[0] == '*' && cp[1] == '/') {
617       comment = 0;
618       cp[0] = cp[1] = 32;
619     }
620
621     /* do not copy when: */
622     if (comment) {
623       /* pass */
624     }
625     else if (cp[0] == ' ' && cp[1] == ' ') {
626       /* pass */
627     }
628     else if (cp[-1] == '*' && cp[0] == ' ') {
629       /* pointers with a space */
630     } /* skip special keywords */
631     else if (strncmp("DNA_DEPRECATED", cp, 14) == 0) {
632       /* single values are skipped already, so decrement 1 less */
633       a -= 13;
634       cp += 13;
635     }
636     else {
637       md[0] = cp[0];
638       md++;
639       newlen++;
640     }
641     cp++;
642   }
643
644   MEM_freeN(temp);
645   return newlen;
646 }
647
648 static void *read_file_data(const char *filename, int *r_len)
649 {
650 #ifdef WIN32
651   FILE *fp = fopen(filename, "rb");
652 #else
653   FILE *fp = fopen(filename, "r");
654 #endif
655   void *data;
656
657   if (!fp) {
658     *r_len = -1;
659     return NULL;
660   }
661
662   fseek(fp, 0L, SEEK_END);
663   *r_len = ftell(fp);
664   fseek(fp, 0L, SEEK_SET);
665
666   if (*r_len == -1) {
667     fclose(fp);
668     return NULL;
669   }
670
671   data = MEM_mallocN(*r_len, "read_file_data");
672   if (!data) {
673     *r_len = -1;
674     fclose(fp);
675     return NULL;
676   }
677
678   if (fread(data, *r_len, 1, fp) != 1) {
679     *r_len = -1;
680     MEM_freeN(data);
681     fclose(fp);
682     return NULL;
683   }
684
685   fclose(fp);
686   return data;
687 }
688
689 static int convert_include(const char *filename)
690 {
691   /* read include file, skip structs with a '#' before it.
692    * store all data in temporal arrays.
693    */
694   int maindata_len, count, slen, type, name, strct;
695   short *structpoin, *sp;
696   char *maindata, *mainend, *md, *md1;
697   bool skip_struct;
698
699   md = maindata = read_file_data(filename, &maindata_len);
700   if (maindata_len == -1) {
701     fprintf(stderr, "Can't read file %s\n", filename);
702     return 1;
703   }
704
705   maindata_len = preprocess_include(maindata, maindata_len);
706   mainend = maindata + maindata_len - 1;
707
708   /* we look for '{' and then back to 'struct' */
709   count = 0;
710   skip_struct = false;
711   while (count < maindata_len) {
712
713     /* code for skipping a struct: two hashes on 2 lines. (preprocess added a space) */
714     if (md[0] == '#' && md[1] == ' ' && md[2] == '#') {
715       skip_struct = true;
716     }
717
718     if (md[0] == '{') {
719       md[0] = 0;
720       if (skip_struct) {
721         skip_struct = false;
722       }
723       else {
724         if (md[-1] == ' ') {
725           md[-1] = 0;
726         }
727         md1 = md - 2;
728         while (*md1 != 32) {
729           /* to beginning of word */
730           md1--;
731         }
732         md1++;
733
734         /* we've got a struct name when... */
735         if (strncmp(md1 - 7, "struct", 6) == 0) {
736
737           strct = add_type(md1, 0);
738           if (strct == -1) {
739             fprintf(stderr, "File '%s' contains struct we cant parse \"%s\"\n", filename, md1);
740             return 1;
741           }
742
743           structpoin = add_struct(strct);
744           sp = structpoin + 2;
745
746           DEBUG_PRINTF(1, "\t|\t|-- detected struct %s\n", types[strct]);
747
748           /* first lets make it all nice strings */
749           md1 = md + 1;
750           while (*md1 != '}') {
751             if (md1 > mainend) {
752               break;
753             }
754
755             if (*md1 == ',' || *md1 == ' ') {
756               *md1 = 0;
757             }
758             md1++;
759           }
760
761           /* read types and names until first character that is not '}' */
762           md1 = md + 1;
763           while (*md1 != '}') {
764             if (md1 > mainend) {
765               break;
766             }
767
768             /* skip when it says 'struct' or 'unsigned' or 'const' */
769             if (*md1) {
770               if (strncmp(md1, "struct", 6) == 0) {
771                 md1 += 7;
772               }
773               if (strncmp(md1, "unsigned", 8) == 0) {
774                 md1 += 9;
775               }
776               if (strncmp(md1, "const", 5) == 0) {
777                 md1 += 6;
778               }
779
780               /* we've got a type! */
781               type = add_type(md1, 0);
782               if (type == -1) {
783                 fprintf(
784                     stderr, "File '%s' contains struct we can't parse \"%s\"\n", filename, md1);
785                 return 1;
786               }
787
788               DEBUG_PRINTF(1, "\t|\t|\tfound type %s (", md1);
789
790               md1 += strlen(md1);
791
792               /* read until ';' */
793               while (*md1 != ';') {
794                 if (md1 > mainend) {
795                   break;
796                 }
797
798                 if (*md1) {
799                   /* We've got a name. slen needs
800                    * correction for function
801                    * pointers! */
802                   slen = (int)strlen(md1);
803                   if (md1[slen - 1] == ';') {
804                     md1[slen - 1] = 0;
805
806                     name = add_name(version_elem_static_from_alias(strct, md1));
807                     if (name == -1) {
808                       fprintf(stderr,
809                               "File '%s' contains struct with name that can't be added \"%s\"\n",
810                               filename,
811                               md1);
812                       return 1;
813                     }
814                     slen += additional_slen_offset;
815                     sp[0] = type;
816                     sp[1] = name;
817
818                     if (names[name] != NULL) {
819                       DEBUG_PRINTF(1, "%s |", names[name]);
820                     }
821
822                     structpoin[1]++;
823                     sp += 2;
824
825                     md1 += slen;
826                     break;
827                   }
828
829                   name = add_name(version_elem_static_from_alias(strct, md1));
830                   if (name == -1) {
831                     fprintf(stderr,
832                             "File '%s' contains struct with name that can't be added \"%s\"\n",
833                             filename,
834                             md1);
835                     return 1;
836                   }
837                   slen += additional_slen_offset;
838
839                   sp[0] = type;
840                   sp[1] = name;
841                   if (names[name] != NULL) {
842                     DEBUG_PRINTF(1, "%s ||", names[name]);
843                   }
844
845                   structpoin[1]++;
846                   sp += 2;
847
848                   md1 += slen;
849                 }
850                 md1++;
851               }
852
853               DEBUG_PRINTF(1, ")\n");
854             }
855             md1++;
856           }
857         }
858       }
859     }
860     count++;
861     md++;
862   }
863
864   MEM_freeN(maindata);
865
866   return 0;
867 }
868
869 static bool check_field_alignment(
870     int firststruct, int structtype, int type, int len, const char *name, const char *detail)
871 {
872   bool result = true;
873   if (type < firststruct && types_size_native[type] > 4 && (len % 8)) {
874     fprintf(stderr,
875             "Align 8 error (%s) in struct: %s %s (add %d padding bytes)\n",
876             detail,
877             types[structtype],
878             name,
879             len % 8);
880     result = false;
881   }
882   if (types_size_native[type] > 3 && (len % 4)) {
883     fprintf(stderr,
884             "Align 4 error (%s) in struct: %s %s (add %d padding bytes)\n",
885             detail,
886             types[structtype],
887             name,
888             len % 4);
889     result = false;
890   }
891   if (types_size_native[type] == 2 && (len % 2)) {
892     fprintf(stderr,
893             "Align 2 error (%s) in struct: %s %s (add %d padding bytes)\n",
894             detail,
895             types[structtype],
896             name,
897             len % 2);
898     result = false;
899   }
900   return result;
901 }
902
903 static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char *base_directory)
904 {
905   int unknown = structs_len, lastunknown;
906   bool dna_error = false;
907
908   /* Write test to verify sizes are accurate. */
909   fprintf(file_verify, "/* Verify struct sizes and member offsets are as expected by DNA. */\n");
910   fprintf(file_verify, "#include \"BLI_assert.h\"\n\n");
911   /* Needed so we can find offsets of deprecated structs. */
912   fprintf(file_verify, "#define DNA_DEPRECATED_ALLOW\n");
913   /* Workaround enum naming collision in static asserts
914    * (ideally this included a unique name/id per file). */
915   fprintf(file_verify, "#define assert_line_ assert_line_DNA_\n");
916   for (int i = 0; *(includefiles[i]) != '\0'; i++) {
917     fprintf(file_verify, "#include \"%s%s\"\n", base_directory, includefiles[i]);
918   }
919   fprintf(file_verify, "#undef assert_line_\n");
920   fprintf(file_verify, "\n");
921
922   /* Multiple iterations to handle nested structs. */
923   while (unknown) {
924     lastunknown = unknown;
925     unknown = 0;
926
927     /* check all structs... */
928     for (int a = 0; a < structs_len; a++) {
929       const short *structpoin = structs[a];
930       const int structtype = structpoin[0];
931       const char *structname = version_struct_alias_from_static(types[structtype]);
932
933       /* when length is not known... */
934       if (types_size_native[structtype] == 0) {
935
936         const short *sp = structpoin + 2;
937         int size_native = 0;
938         int size_32 = 0;
939         int size_64 = 0;
940         bool has_pointer = false;
941
942         /* check all elements in struct */
943         for (int b = 0; b < structpoin[1]; b++, sp += 2) {
944           int type = sp[0];
945           const char *cp = names[sp[1]];
946           int namelen = (int)strlen(cp);
947
948           /* Write size verification to file. */
949           {
950             /* Normally 'alloca' would be used here, however we can't in a loop.
951              * Use an over-sized buffer instead. */
952             char name_static[1024];
953             BLI_assert(sizeof(name_static) > namelen);
954
955             DNA_elem_id_strip_copy(name_static, cp);
956             const char *str_pair[2] = {types[structtype], name_static};
957             const char *name_alias = BLI_ghash_lookup(g_version_data.elem_map_alias_from_static,
958                                                       str_pair);
959             fprintf(file_verify,
960                     "BLI_STATIC_ASSERT(offsetof(struct %s, %s) == %d, \"DNA member offset "
961                     "verify\");\n",
962                     structname,
963                     name_alias ? name_alias : name_static,
964                     size_native);
965           }
966
967           /* is it a pointer or function pointer? */
968           if (cp[0] == '*' || cp[1] == '*') {
969             has_pointer = 1;
970             /* has the name an extra length? (array) */
971             int mul = 1;
972             if (cp[namelen - 1] == ']') {
973               mul = DNA_elem_array_size(cp);
974             }
975
976             if (mul == 0) {
977               fprintf(stderr,
978                       "Zero array size found or could not parse %s: '%.*s'\n",
979                       types[structtype],
980                       namelen + 1,
981                       cp);
982               dna_error = 1;
983             }
984
985             /* 4-8 aligned/ */
986             if (sizeof(void *) == 4) {
987               if (size_native % 4) {
988                 fprintf(stderr,
989                         "Align pointer error in struct (size_native 4): %s %s\n",
990                         types[structtype],
991                         cp);
992                 dna_error = 1;
993               }
994             }
995             else {
996               if (size_native % 8) {
997                 fprintf(stderr,
998                         "Align pointer error in struct (size_native 8): %s %s\n",
999                         types[structtype],
1000                         cp);
1001                 dna_error = 1;
1002               }
1003             }
1004
1005             if (size_64 % 8) {
1006               fprintf(stderr,
1007                       "Align pointer error in struct (size_64 8): %s %s\n",
1008                       types[structtype],
1009                       cp);
1010               dna_error = 1;
1011             }
1012
1013             size_native += sizeof(void *) * mul;
1014             size_32 += 4 * mul;
1015             size_64 += 8 * mul;
1016           }
1017           else if (cp[0] == '[') {
1018             /* parsing can cause names "var" and "[3]"
1019              * to be found for "float var [3]" */
1020             fprintf(stderr,
1021                     "Parse error in struct, invalid member name: %s %s\n",
1022                     types[structtype],
1023                     cp);
1024             dna_error = 1;
1025           }
1026           else if (types_size_native[type]) {
1027             /* has the name an extra length? (array) */
1028             int mul = 1;
1029             if (cp[namelen - 1] == ']') {
1030               mul = DNA_elem_array_size(cp);
1031             }
1032
1033             if (mul == 0) {
1034               fprintf(stderr,
1035                       "Zero array size found or could not parse %s: '%.*s'\n",
1036                       types[structtype],
1037                       namelen + 1,
1038                       cp);
1039               dna_error = 1;
1040             }
1041
1042             /* struct alignment */
1043             if (type >= firststruct) {
1044               if (sizeof(void *) == 8 && (size_native % 8)) {
1045                 fprintf(stderr, "Align struct error: %s %s\n", types[structtype], cp);
1046                 dna_error = 1;
1047               }
1048             }
1049
1050             /* Check 2-4-8 aligned. */
1051             if (!check_field_alignment(firststruct, structtype, type, size_32, cp, "32 bit")) {
1052               dna_error = 1;
1053             }
1054             if (!check_field_alignment(firststruct, structtype, type, size_64, cp, "64 bit")) {
1055               dna_error = 1;
1056             }
1057
1058             size_native += mul * types_size_native[type];
1059             size_32 += mul * types_size_32[type];
1060             size_64 += mul * types_size_64[type];
1061           }
1062           else {
1063             size_native = 0;
1064             size_32 = 0;
1065             size_64 = 0;
1066             break;
1067           }
1068         }
1069
1070         if (size_native == 0) {
1071           unknown++;
1072         }
1073         else {
1074           types_size_native[structtype] = size_native;
1075           types_size_32[structtype] = size_32;
1076           types_size_64[structtype] = size_64;
1077           /* two ways to detect if a struct contains a pointer:
1078            * has_pointer is set or size_native  doesn't match any of 32/64bit lengths*/
1079           if (has_pointer || size_64 != size_native || size_32 != size_native) {
1080             if (size_64 % 8) {
1081               fprintf(stderr,
1082                       "Sizeerror 8 in struct: %s (add %d bytes)\n",
1083                       types[structtype],
1084                       size_64 % 8);
1085               dna_error = 1;
1086             }
1087           }
1088
1089           if (size_native % 4) {
1090             fprintf(stderr,
1091                     "Sizeerror 4 in struct: %s (add %d bytes)\n",
1092                     types[structtype],
1093                     size_native % 4);
1094             dna_error = 1;
1095           }
1096
1097           /* Write size verification to file. */
1098           fprintf(file_verify,
1099                   "BLI_STATIC_ASSERT(sizeof(struct %s) == %d, \"DNA struct size verify\");\n\n",
1100                   structname,
1101                   size_native);
1102         }
1103       }
1104     }
1105
1106     if (unknown == lastunknown) {
1107       break;
1108     }
1109   }
1110
1111   if (unknown) {
1112     fprintf(stderr, "ERROR: still %d structs unknown\n", unknown);
1113
1114     if (debugSDNA) {
1115       fprintf(stderr, "*** Known structs :\n");
1116
1117       for (int a = 0; a < structs_len; a++) {
1118         const short *structpoin = structs[a];
1119         const int structtype = structpoin[0];
1120
1121         /* length unknown */
1122         if (types_size_native[structtype] != 0) {
1123           fprintf(stderr, "  %s\n", types[structtype]);
1124         }
1125       }
1126     }
1127
1128     fprintf(stderr, "*** Unknown structs :\n");
1129
1130     for (int a = 0; a < structs_len; a++) {
1131       const short *structpoin = structs[a];
1132       const int structtype = structpoin[0];
1133
1134       /* length unknown yet */
1135       if (types_size_native[structtype] == 0) {
1136         fprintf(stderr, "  %s\n", types[structtype]);
1137       }
1138     }
1139
1140     dna_error = 1;
1141   }
1142
1143   return dna_error;
1144 }
1145
1146 #define MAX_DNA_LINE_LENGTH 20
1147
1148 static void dna_write(FILE *file, const void *pntr, const int size)
1149 {
1150   static int linelength = 0;
1151   int i;
1152   const char *data;
1153
1154   data = (const char *)pntr;
1155
1156   for (i = 0; i < size; i++) {
1157     fprintf(file, "%d, ", data[i]);
1158     linelength++;
1159     if (linelength >= MAX_DNA_LINE_LENGTH) {
1160       fprintf(file, "\n");
1161       linelength = 0;
1162     }
1163   }
1164 }
1165
1166 void print_struct_sizes(void)
1167 {
1168   int a, unknown = structs_len, structtype;
1169   /*int lastunknown;*/ /*UNUSED*/
1170   const short *structpoin;
1171   printf("\n\n*** All detected structs:\n");
1172
1173   while (unknown) {
1174     /*lastunknown = unknown;*/ /*UNUSED*/
1175     unknown = 0;
1176
1177     /* check all structs... */
1178     for (a = 0; a < structs_len; a++) {
1179       structpoin = structs[a];
1180       structtype = structpoin[0];
1181       printf("\t%s\t:%d\n", types[structtype], types_size_native[structtype]);
1182     }
1183   }
1184
1185   printf("*** End of list\n");
1186 }
1187
1188 static int make_structDNA(const char *base_directory,
1189                           FILE *file,
1190                           FILE *file_offsets,
1191                           FILE *file_verify)
1192 {
1193   int i;
1194   const short *sp;
1195   /* str contains filenames. Since we now include paths, I stretched       */
1196   /* it a bit. Hope this is enough :) -nzc-                                */
1197   char str[SDNA_MAX_FILENAME_LENGTH];
1198   int firststruct;
1199
1200   if (debugSDNA > 0) {
1201     fflush(stdout);
1202     printf("Running makesdna at debug level %d\n", debugSDNA);
1203   }
1204
1205   mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
1206
1207   /* the longest known struct is 50k, so we assume 100k is sufficient! */
1208   structdata = MEM_callocN(max_data_size, "structdata");
1209
1210   /* a maximum of 5000 variables, must be sufficient? */
1211   names = MEM_callocN(sizeof(char *) * max_array_len, "names");
1212   types = MEM_callocN(sizeof(char *) * max_array_len, "types");
1213   types_size_native = MEM_callocN(sizeof(short) * max_array_len, "types_size_native");
1214   types_size_32 = MEM_callocN(sizeof(short) * max_array_len, "types_size_32");
1215   types_size_64 = MEM_callocN(sizeof(short) * max_array_len, "types_size_64");
1216   structs = MEM_callocN(sizeof(short *) * max_array_len, "structs");
1217
1218   /* Build versioning data */
1219   DNA_alias_maps(DNA_RENAME_ALIAS_FROM_STATIC,
1220                  &g_version_data.struct_map_alias_from_static,
1221                  &g_version_data.elem_map_alias_from_static);
1222   DNA_alias_maps(DNA_RENAME_STATIC_FROM_ALIAS,
1223                  &g_version_data.struct_map_static_from_alias,
1224                  &g_version_data.elem_map_static_from_alias);
1225
1226   /**
1227    * Insertion of all known types.
1228    *
1229    * \warning Order of function calls here must be aligned with #eSDNA_Type.
1230    * \warning uint is not allowed! use in structs an unsigned int.
1231    * \warning sizes must match #DNA_elem_type_size().
1232    */
1233   add_type("char", 1);   /* SDNA_TYPE_CHAR */
1234   add_type("uchar", 1);  /* SDNA_TYPE_UCHAR */
1235   add_type("short", 2);  /* SDNA_TYPE_SHORT */
1236   add_type("ushort", 2); /* SDNA_TYPE_USHORT */
1237   add_type("int", 4);    /* SDNA_TYPE_INT */
1238
1239   /* note, long isn't supported,
1240    * these are place-holders to maintain alignment with eSDNA_Type*/
1241   add_type("long", 4);  /* SDNA_TYPE_LONG */
1242   add_type("ulong", 4); /* SDNA_TYPE_ULONG */
1243
1244   add_type("float", 4);    /* SDNA_TYPE_FLOAT */
1245   add_type("double", 8);   /* SDNA_TYPE_DOUBLE */
1246   add_type("int64_t", 8);  /* SDNA_TYPE_INT64 */
1247   add_type("uint64_t", 8); /* SDNA_TYPE_UINT64 */
1248   add_type("void", 0);     /* SDNA_TYPE_VOID */
1249
1250   /* the defines above shouldn't be output in the padding file... */
1251   firststruct = types_len;
1252
1253   /* add all include files defined in the global array                     */
1254   /* Since the internal file+path name buffer has limited length, I do a   */
1255   /* little test first...                                                  */
1256   /* Mind the breaking condition here!                                     */
1257   DEBUG_PRINTF(0, "\tStart of header scan:\n");
1258   for (i = 0; *(includefiles[i]) != '\0'; i++) {
1259     sprintf(str, "%s%s", base_directory, includefiles[i]);
1260     DEBUG_PRINTF(0, "\t|-- Converting %s\n", str);
1261     if (convert_include(str)) {
1262       return 1;
1263     }
1264   }
1265   DEBUG_PRINTF(0, "\tFinished scanning %d headers.\n", i);
1266
1267   if (calculate_struct_sizes(firststruct, file_verify, base_directory)) {
1268     /* error */
1269     return 1;
1270   }
1271
1272   /* FOR DEBUG */
1273   if (debugSDNA > 1) {
1274     int a, b;
1275     /* short *elem; */
1276     short num_types;
1277
1278     printf("names_len %d types_len %d structs_len %d\n", names_len, types_len, structs_len);
1279     for (a = 0; a < names_len; a++) {
1280       printf(" %s\n", names[a]);
1281     }
1282     printf("\n");
1283
1284     sp = types_size_native;
1285     for (a = 0; a < types_len; a++, sp++) {
1286       printf(" %s %d\n", types[a], *sp);
1287     }
1288     printf("\n");
1289
1290     for (a = 0; a < structs_len; a++) {
1291       sp = structs[a];
1292       printf(" struct %s elems: %d size: %d\n", types[sp[0]], sp[1], types_size_native[sp[0]]);
1293       num_types = sp[1];
1294       sp += 2;
1295       /* ? num_types was elem? */
1296       for (b = 0; b < num_types; b++, sp += 2) {
1297         printf("   %s %s\n", types[sp[0]], names[sp[1]]);
1298       }
1299     }
1300   }
1301
1302   /* file writing */
1303
1304   DEBUG_PRINTF(0, "Writing file ... ");
1305
1306   if (names_len == 0 || structs_len == 0) {
1307     /* pass */
1308   }
1309   else {
1310     const char nil_bytes[4] = {0};
1311     int len, len_align;
1312
1313     dna_write(file, "SDNA", 4);
1314
1315     /* write names */
1316     dna_write(file, "NAME", 4);
1317     len = names_len;
1318     dna_write(file, &len, 4);
1319     /* write array */
1320     len = 0;
1321     for (int nr = 0; nr < names_len; nr++) {
1322       int name_size = strlen(names[nr]) + 1;
1323       dna_write(file, names[nr], name_size);
1324       len += name_size;
1325     }
1326     len_align = (len + 3) & ~3;
1327     if (len != len_align) {
1328       dna_write(file, nil_bytes, len_align - len);
1329     }
1330
1331     /* write TYPES */
1332     dna_write(file, "TYPE", 4);
1333     len = types_len;
1334     dna_write(file, &len, 4);
1335     /* write array */
1336     len = 0;
1337     for (int nr = 0; nr < types_len; nr++) {
1338       int type_size = strlen(types[nr]) + 1;
1339       dna_write(file, types[nr], type_size);
1340       len += type_size;
1341     }
1342     len_align = (len + 3) & ~3;
1343     if (len != len_align) {
1344       dna_write(file, nil_bytes, len_align - len);
1345     }
1346
1347     /* WRITE TYPELENGTHS */
1348     dna_write(file, "TLEN", 4);
1349
1350     len = 2 * types_len;
1351     if (types_len & 1) {
1352       len += 2;
1353     }
1354     dna_write(file, types_size_native, len);
1355
1356     /* WRITE STRUCTS */
1357     dna_write(file, "STRC", 4);
1358     len = structs_len;
1359     dna_write(file, &len, 4);
1360
1361     /* calc datablock size */
1362     sp = structs[structs_len - 1];
1363     sp += 2 + 2 * (sp[1]);
1364     len = (intptr_t)((char *)sp - (char *)structs[0]);
1365     len = (len + 3) & ~3;
1366
1367     dna_write(file, structs[0], len);
1368   }
1369
1370   /* write a simple enum with all structs offsets,
1371    * should only be accessed via SDNA_TYPE_FROM_STRUCT macro */
1372   {
1373     fprintf(file_offsets, "#define SDNA_TYPE_FROM_STRUCT(id) _SDNA_TYPE_##id\n");
1374     fprintf(file_offsets, "enum {\n");
1375     for (i = 0; i < structs_len; i++) {
1376       const short *structpoin = structs[i];
1377       const int structtype = structpoin[0];
1378       fprintf(file_offsets,
1379               "\t_SDNA_TYPE_%s = %d,\n",
1380               version_struct_alias_from_static(types[structtype]),
1381               i);
1382     }
1383     fprintf(file_offsets, "\tSDNA_TYPE_MAX = %d,\n", structs_len);
1384     fprintf(file_offsets, "};\n\n");
1385   }
1386
1387   /* Check versioning errors which could cause duplicate names,
1388    * do last because names are stripped. */
1389   {
1390     GSet *names_unique = BLI_gset_str_new_ex(__func__, 512);
1391     for (int struct_nr = 0; struct_nr < structs_len; struct_nr++) {
1392       sp = structs[struct_nr];
1393       const char *struct_name = types[sp[0]];
1394       const int len = sp[1];
1395       sp += 2;
1396       for (int a = 0; a < len; a++, sp += 2) {
1397         char *name = names[sp[1]];
1398         DNA_elem_id_strip(name);
1399         if (!BLI_gset_add(names_unique, name)) {
1400           fprintf(stderr,
1401                   "Error: duplicate name found '%s.%s', "
1402                   "likely cause is 'dna_rename_defs.h'\n",
1403                   struct_name,
1404                   name);
1405           return 1;
1406         }
1407       }
1408       BLI_gset_clear(names_unique, NULL);
1409     }
1410     BLI_gset_free(names_unique, NULL);
1411   }
1412
1413   MEM_freeN(structdata);
1414   MEM_freeN(names);
1415   MEM_freeN(types);
1416   MEM_freeN(types_size_native);
1417   MEM_freeN(types_size_32);
1418   MEM_freeN(types_size_64);
1419   MEM_freeN(structs);
1420
1421   BLI_memarena_free(mem_arena);
1422
1423   BLI_ghash_free(g_version_data.struct_map_alias_from_static, NULL, NULL);
1424   BLI_ghash_free(g_version_data.struct_map_static_from_alias, NULL, NULL);
1425   BLI_ghash_free(g_version_data.elem_map_static_from_alias, MEM_freeN, NULL);
1426   BLI_ghash_free(g_version_data.elem_map_alias_from_static, MEM_freeN, NULL);
1427
1428   DEBUG_PRINTF(0, "done.\n");
1429
1430   return 0;
1431 }
1432
1433 /** \} */
1434
1435 /* end make DNA. */
1436
1437 /* -------------------------------------------------------------------- */
1438 /** \name Main Function
1439  * \{ */
1440
1441 static void make_bad_file(const char *file, int line)
1442 {
1443   FILE *fp = fopen(file, "w");
1444   fprintf(fp,
1445           "#error \"Error! can't make correct DNA.c file from %s:%d, check alignment.\"\n",
1446           __FILE__,
1447           line);
1448   fclose(fp);
1449 }
1450
1451 #ifndef BASE_HEADER
1452 #  define BASE_HEADER "../"
1453 #endif
1454
1455 int main(int argc, char **argv)
1456 {
1457   int return_status = 0;
1458
1459   if (argc != 4 && argc != 5) {
1460     printf("Usage: %s dna.c dna_struct_offsets.h [base directory]\n", argv[0]);
1461     return_status = 1;
1462   }
1463   else {
1464     FILE *file_dna = fopen(argv[1], "w");
1465     FILE *file_dna_offsets = fopen(argv[2], "w");
1466     FILE *file_dna_verify = fopen(argv[3], "w");
1467     if (!file_dna) {
1468       printf("Unable to open file: %s\n", argv[1]);
1469       return_status = 1;
1470     }
1471     else if (!file_dna_offsets) {
1472       printf("Unable to open file: %s\n", argv[2]);
1473       return_status = 1;
1474     }
1475     else if (!file_dna_verify) {
1476       printf("Unable to open file: %s\n", argv[3]);
1477       return_status = 1;
1478     }
1479     else {
1480       const char *base_directory;
1481
1482       if (argc == 5) {
1483         base_directory = argv[4];
1484       }
1485       else {
1486         base_directory = BASE_HEADER;
1487       }
1488
1489       fprintf(file_dna, "extern const unsigned char DNAstr[];\n");
1490       fprintf(file_dna, "const unsigned char DNAstr[] = {\n");
1491       if (make_structDNA(base_directory, file_dna, file_dna_offsets, file_dna_verify)) {
1492         /* error */
1493         fclose(file_dna);
1494         file_dna = NULL;
1495         make_bad_file(argv[1], __LINE__);
1496         return_status = 1;
1497       }
1498       else {
1499         fprintf(file_dna, "};\n");
1500         fprintf(file_dna, "extern const int DNAlen;\n");
1501         fprintf(file_dna, "const int DNAlen = sizeof(DNAstr);\n");
1502       }
1503     }
1504
1505     if (file_dna) {
1506       fclose(file_dna);
1507     }
1508     if (file_dna_offsets) {
1509       fclose(file_dna_offsets);
1510     }
1511     if (file_dna_verify) {
1512       fclose(file_dna_verify);
1513     }
1514   }
1515
1516   return return_status;
1517 }
1518
1519 /* handy but fails on struct bounds which makesdna doesn't care about
1520  * with quite the same strictness as GCC does */
1521 #if 0
1522 /* include files for automatic dependencies */
1523
1524 /* extra safety check that we are aligned,
1525  * warnings here are easier to fix the makesdna's */
1526 #  ifdef __GNUC__
1527 #    pragma GCC diagnostic error "-Wpadded"
1528 #  endif
1529
1530 #endif /* if 0 */
1531
1532 /* even though DNA supports, 'long' shouldn't be used since it can be either 32 or 64bit,
1533  * use int or int64_t instead.
1534  * Only valid use would be as a runtime variable if an API expected a long,
1535  * but so far we dont have this happening. */
1536 #ifdef __GNUC__
1537 #  pragma GCC poison long
1538 #endif
1539
1540 #include "DNA_ID.h"
1541 #include "DNA_action_types.h"
1542 #include "DNA_anim_types.h"
1543 #include "DNA_armature_types.h"
1544 #include "DNA_boid_types.h"
1545 #include "DNA_brush_types.h"
1546 #include "DNA_cachefile_types.h"
1547 #include "DNA_camera_types.h"
1548 #include "DNA_cloth_types.h"
1549 #include "DNA_collection_types.h"
1550 #include "DNA_color_types.h"
1551 #include "DNA_constraint_types.h"
1552 #include "DNA_curve_types.h"
1553 #include "DNA_curveprofile_types.h"
1554 #include "DNA_customdata_types.h"
1555 #include "DNA_dynamicpaint_types.h"
1556 #include "DNA_effect_types.h"
1557 #include "DNA_fileglobal_types.h"
1558 #include "DNA_fluid_types.h"
1559 #include "DNA_freestyle_types.h"
1560 #include "DNA_gpencil_modifier_types.h"
1561 #include "DNA_gpencil_types.h"
1562 #include "DNA_hair_types.h"
1563 #include "DNA_image_types.h"
1564 #include "DNA_ipo_types.h"
1565 #include "DNA_key_types.h"
1566 #include "DNA_lattice_types.h"
1567 #include "DNA_layer_types.h"
1568 #include "DNA_light_types.h"
1569 #include "DNA_lightprobe_types.h"
1570 #include "DNA_linestyle_types.h"
1571 #include "DNA_listBase.h"
1572 #include "DNA_mask_types.h"
1573 #include "DNA_material_types.h"
1574 #include "DNA_mesh_types.h"
1575 #include "DNA_meshdata_types.h"
1576 #include "DNA_meta_types.h"
1577 #include "DNA_modifier_types.h"
1578 #include "DNA_movieclip_types.h"
1579 #include "DNA_nla_types.h"
1580 #include "DNA_node_types.h"
1581 #include "DNA_object_fluidsim_types.h"
1582 #include "DNA_object_force_types.h"
1583 #include "DNA_object_types.h"
1584 #include "DNA_outliner_types.h"
1585 #include "DNA_packedFile_types.h"
1586 #include "DNA_particle_types.h"
1587 #include "DNA_pointcloud_types.h"
1588 #include "DNA_rigidbody_types.h"
1589 #include "DNA_scene_types.h"
1590 #include "DNA_screen_types.h"
1591 #include "DNA_sdna_types.h"
1592 #include "DNA_sequence_types.h"
1593 #include "DNA_shader_fx_types.h"
1594 #include "DNA_simulation_types.h"
1595 #include "DNA_sound_types.h"
1596 #include "DNA_space_types.h"
1597 #include "DNA_speaker_types.h"
1598 #include "DNA_text_types.h"
1599 #include "DNA_texture_types.h"
1600 #include "DNA_tracking_types.h"
1601 #include "DNA_userdef_types.h"
1602 #include "DNA_vec_types.h"
1603 #include "DNA_vfont_types.h"
1604 #include "DNA_view2d_types.h"
1605 #include "DNA_view3d_types.h"
1606 #include "DNA_volume_types.h"
1607 #include "DNA_windowmanager_types.h"
1608 #include "DNA_workspace_types.h"
1609 #include "DNA_world_types.h"
1610 #include "DNA_xr_types.h"
1611
1612 /* end of list */
1613
1614 /** \} */
1615
1616 /* -------------------------------------------------------------------- */
1617 /** \name DNA Renaming Sanity Check
1618  *
1619  * Without this it's possible to reference struct members that don't exist,
1620  * breaking backward & forward compatibility.
1621  *
1622  * \{ */
1623
1624 static void UNUSED_FUNCTION(dna_rename_defs_ensure)(void)
1625 {
1626 #define DNA_STRUCT_RENAME(old, new) (void)sizeof(new);
1627 #define DNA_STRUCT_RENAME_ELEM(struct_name, old, new) (void)offsetof(struct_name, new);
1628 #include "dna_rename_defs.h"
1629 #undef DNA_STRUCT_RENAME
1630 #undef DNA_STRUCT_RENAME_ELEM
1631 }
1632
1633 /** \} */