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