Code cleanup: use r_ prefix for return args
[blender.git] / source / blender / makesdna / intern / makesdna.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /**  \file makesdna.c
29  *   \brief Struct muncher for making SDNA.
30  *   \ingroup DNA
31  *
32  * \section aboutmakesdnac About makesdna tool
33  * Originally by Ton, some mods by Frank, and some cleaning and
34  * extension by Nzc.
35  *
36  * Makesdna creates a .c file with a long string of numbers that
37  * encode the Blender file format. It is fast, because it is basically
38  * a binary dump. There are some details to mind when reconstructing
39  * the file (endianness and byte-alignment).
40  *
41  * This little program scans all structs that need to be serialized,
42  * and determined the names and types of all members. It calculates
43  * how much memory (on disk or in ram) is needed to store that struct,
44  * and the offsets for reaching a particular one.
45  *
46  * There is a facility to get verbose output from sdna. Search for
47  * \ref debugSDNA. This int can be set to 0 (no output) to some int. Higher
48  * numbers give more output.
49  */
50
51 #include <string.h>
52 #include <stdlib.h>
53 #include <stdio.h>
54
55 #include "MEM_guardedalloc.h"
56
57 #include "../blenlib/BLI_sys_types.h" // for intptr_t support
58
59 #define SDNA_MAX_FILENAME_LENGTH 255
60
61
62 /* Included the path relative from /source/blender/ here, so we can move     */
63 /* headers around with more freedom.                                         */
64 static const char *includefiles[] = {
65
66         /* if you add files here, please add them at the end
67          * of makesdna.c (this file) as well */
68
69         "DNA_listBase.h",
70         "DNA_vec_types.h",
71         "DNA_ID.h",
72         "DNA_ipo_types.h",
73         "DNA_key_types.h",
74         "DNA_text_types.h",
75         "DNA_packedFile_types.h",
76         "DNA_camera_types.h",
77         "DNA_image_types.h",
78         "DNA_texture_types.h",
79         "DNA_lamp_types.h",
80         "DNA_material_types.h",
81         "DNA_vfont_types.h",
82         /* if you add files here, please add them at the end
83          * of makesdna.c (this file) as well */
84         "DNA_meta_types.h",
85         "DNA_curve_types.h",
86         "DNA_mesh_types.h",
87         "DNA_meshdata_types.h",
88         "DNA_modifier_types.h",
89         "DNA_lattice_types.h",
90         "DNA_object_types.h",
91         "DNA_object_force.h",
92         "DNA_object_fluidsim.h",
93         "DNA_world_types.h",
94         "DNA_scene_types.h",
95         "DNA_view3d_types.h",
96         "DNA_view2d_types.h",
97         "DNA_space_types.h",
98         "DNA_userdef_types.h",
99         "DNA_screen_types.h",
100         "DNA_sdna_types.h",
101         // if you add files here, please add them at the end
102         // of makesdna.c (this file) as well
103         "DNA_fileglobal_types.h",
104         "DNA_sequence_types.h",
105         "DNA_effect_types.h",
106         "DNA_outliner_types.h",
107         "DNA_property_types.h",
108         "DNA_sensor_types.h",
109         "DNA_controller_types.h",
110         "DNA_actuator_types.h",
111         "DNA_sound_types.h",
112         "DNA_group_types.h",
113         "DNA_armature_types.h",
114         "DNA_action_types.h",
115         "DNA_constraint_types.h",
116         "DNA_nla_types.h",
117         "DNA_node_types.h",
118         "DNA_color_types.h",
119         "DNA_brush_types.h",
120         "DNA_customdata_types.h",
121         "DNA_particle_types.h",
122         "DNA_cloth_types.h",
123         "DNA_gpencil_types.h",
124         /* if you add files here, please add them at the end
125          * of makesdna.c (this file) as well */
126         "DNA_windowmanager_types.h",
127         "DNA_anim_types.h",
128         "DNA_boid_types.h",
129         "DNA_smoke_types.h",
130         "DNA_speaker_types.h",
131         "DNA_movieclip_types.h",
132         "DNA_tracking_types.h",
133         "DNA_dynamicpaint_types.h",
134         "DNA_mask_types.h",
135         "DNA_rigidbody_types.h",
136         "DNA_freestyle_types.h",
137         "DNA_linestyle_types.h",
138
139         /* empty string to indicate end of includefiles */
140         ""
141 };
142
143 static int maxdata = 500000, maxnr = 50000;
144 static int nr_names = 0;
145 static int nr_types = 0;
146 static int nr_structs = 0;
147 static char **names, *namedata;      /* at address names[a] is string a */
148 static char **types, *typedata;      /* at address types[a] is string a */
149 static short *typelens_native;       /* at typelens[a] is the length of type 'a' on this systems bitness (32 or 64) */
150 static short *typelens_32;           /* contains sizes as they are calculated on 32 bit systems */
151 static short *typelens_64;           /* contains sizes as they are calculated on 64 bit systems */
152 static short **structs, *structdata; /* at sp = structs[a] is the first address of a struct definition
153                                       * sp[0] is type number
154                                       * sp[1] is amount of elements
155                                       * sp[2] sp[3] is typenr,  namenr (etc) */
156 /**
157  * Variable to control debug output of makesdna.
158  * debugSDNA:
159  *  - 0 = no output, except errors
160  *  - 1 = detail actions
161  *  - 2 = full trace, tell which names and types were found
162  *  - 4 = full trace, plus all gritty details
163  */
164 static int debugSDNA = 0;
165 static int additional_slen_offset;
166
167 /* ************************************************************************** */
168 /* Functions                                                                  */
169 /* ************************************************************************** */
170
171 /**
172  * Add type \c str to struct indexed by \c len, if it was not yet found.
173  * \param str char
174  * \param len int
175  */
176 static int add_type(const char *str, int len);
177
178 /**
179  * Add variable \c str to 
180  * \param str
181  */
182 static int add_name(const char *str);
183
184 /**
185  * Search whether this structure type was already found, and if not,
186  * add it.
187  */
188 static short *add_struct(int namecode);
189
190 /**
191  * Remove comments from this buffer. Assumes that the buffer refers to
192  * ascii-code text.
193  */
194 static int preprocess_include(char *maindata, int len);
195
196 /**
197  * Scan this file for serializable types.
198  */ 
199 static int convert_include(char *filename);
200
201 /**
202  * Determine how many bytes are needed for an array.
203  */ 
204 static int arraysize(const char *str);
205
206 /**
207  * Determine how many bytes are needed for each struct.
208  */ 
209 static int calculate_structlens(int);
210
211 /**
212  * Construct the DNA.c file
213  */ 
214 static void dna_write(FILE *file, const void *pntr, const int size);
215
216 /**
217  * Report all structures found so far, and print their lengths.
218  */
219 void printStructLengths(void);
220
221
222
223 /* ************************************************************************** */
224 /* Implementation                                                             */
225 /* ************************************************************************** */
226
227 /* ************************* MAKEN DNA ********************** */
228
229 static int add_type(const char *str, int len)
230 {
231         int nr;
232         char *cp;
233         
234         /* first do validity check */
235         if (str[0] == 0) {
236                 return -1;
237         }
238         else if (strchr(str, '*')) {
239                 /* note: this is valid C syntax but we can't parse, complain!
240                  * 'struct SomeStruct* somevar;' <-- correct but we cant handle right now. */
241                 return -1;
242         }
243         
244         /* search through type array */
245         for (nr = 0; nr < nr_types; nr++) {
246                 if (strcmp(str, types[nr]) == 0) {
247                         if (len) {
248                                 typelens_native[nr] = len;
249                                 typelens_32[nr] = len;
250                                 typelens_64[nr] = len;
251                         }
252                         return nr;
253                 }
254         }
255         
256         /* append new type */
257         if (nr_types == 0) {
258                 cp = typedata;
259         }
260         else {
261                 cp = types[nr_types - 1] + strlen(types[nr_types - 1]) + 1;
262         }
263         strcpy(cp, str);
264         types[nr_types] = cp;
265         typelens_native[nr_types] = len;
266         typelens_32[nr_types] = len;
267         typelens_64[nr_types] = len;
268         
269         if (nr_types >= maxnr) {
270                 printf("too many types\n");
271                 return nr_types - 1;
272         }
273         nr_types++;
274         
275         return nr_types - 1;
276 }
277
278
279 /**
280  *
281  * Because of the weird way of tokenizing, we have to 'cast' function
282  * pointers to ... (*f)(), whatever the original signature. In fact,
283  * we add name and type at the same time... There are two special
284  * cases, unfortunately. These are explicitly checked.
285  *
286  * */
287 static int add_name(const char *str)
288 {
289         int nr, i, j, k;
290         char *cp;
291         char buf[255]; /* stupid limit, change it :) */
292         const char *name;
293
294         additional_slen_offset = 0;
295         
296         if (str[0] == 0 /*  || (str[1] == 0) */) return -1;
297
298         if (str[0] == '(' && str[1] == '*') {
299                 /* we handle function pointer and special array cases here, e.g.
300                  * void (*function)(...) and float (*array)[..]. the array case
301                  * name is still converted to (array *)() though because it is that
302                  * way in old dna too, and works correct with elementsize() */
303                 int isfuncptr = (strchr(str + 1, '(')) != NULL;
304
305                 if (debugSDNA > 3) printf("\t\t\t\t*** Function pointer or multidim array pointer found\n");
306                 /* functionpointer: transform the type (sometimes) */
307                 i = 0;
308
309                 while (str[i] != ')') {
310                         buf[i] = str[i];
311                         i++;
312                 }
313                 
314                 /* Another number we need is the extra slen offset. This extra
315                  * offset is the overshoot after a space. If there is no
316                  * space, no overshoot should be calculated. */
317                 j = i; /* j at first closing brace */
318
319                 if (debugSDNA > 3) printf("first brace after offset %d\n", i);
320
321                 j++; /* j beyond closing brace ? */
322                 while ((str[j] != 0) && (str[j] != ')')) {
323                         if (debugSDNA > 3) printf("seen %c ( %d)\n", str[j], str[j]);
324                         j++;
325                 }
326                 if (debugSDNA > 3) printf("seen %c ( %d)\n"
327                                               "special after offset%d\n",
328                                               str[j], str[j], j);
329                                 
330                 if (!isfuncptr) {
331                         /* multidimensional array pointer case */
332                         if (str[j] == 0) {
333                                 if (debugSDNA > 3) printf("offsetting for multidim array pointer\n");
334                         }
335                         else
336                                 printf("Error during tokening multidim array pointer\n");
337                 }
338                 else if (str[j] == 0) {
339                         if (debugSDNA > 3) printf("offsetting for space\n"); 
340                         /* get additional offset */
341                         k = 0;
342                         while (str[j] != ')') {
343                                 j++;
344                                 k++;
345                         }
346                         if (debugSDNA > 3) printf("extra offset %d\n", k);
347                         additional_slen_offset = k;
348                 }
349                 else if (str[j] == ')') {
350                         if (debugSDNA > 3) printf("offsetting for brace\n");
351                         ; /* don't get extra offset */
352                 }
353                 else {
354                         printf("Error during tokening function pointer argument list\n");
355                 }
356                                 
357                 /*
358                  * Put )(void) at the end? Maybe )(). Should check this with
359                  * old sdna. Actually, sometimes )(), sometimes )(void...)
360                  * Alas.. such is the nature of braindamage :(
361                  *
362                  * Sorted it out: always do )(), except for headdraw and
363                  * windraw, part of ScrArea. This is important, because some
364                  * linkers will treat different fp's differently when called
365                  * !!! This has to do with interference in byte-alignment and
366                  * the way args are pushed on the stack.
367                  *
368                  * */
369                 buf[i] = 0;
370                 if (debugSDNA > 3) printf("Name before chomping: %s\n", buf); 
371                 if ((strncmp(buf, "(*headdraw", 10) == 0) ||
372                     (strncmp(buf, "(*windraw", 9) == 0) )
373                 {
374                         buf[i] = ')';
375                         buf[i + 1] = '(';
376                         buf[i + 2] = 'v';
377                         buf[i + 3] = 'o';
378                         buf[i + 4] = 'i';
379                         buf[i + 5] = 'd';
380                         buf[i + 6] = ')';
381                         buf[i + 7] = 0;
382                 }
383                 else {
384                         buf[i] = ')';
385                         buf[i + 1] = '(';
386                         buf[i + 2] = ')';
387                         buf[i + 3] = 0;
388                 }
389                 /* now precede with buf*/
390                 if (debugSDNA > 3) printf("\t\t\t\t\tProposing fp name %s\n", buf);
391                 name = buf;
392         }
393         else {
394                 /* normal field: old code */
395                 name = str;
396         }
397         
398         /* search name array */
399         for (nr = 0; nr < nr_names; nr++) {
400                 if (strcmp(name, names[nr]) == 0) {
401                         return nr;
402                 }
403         }
404         
405         /* append new type */
406         if (nr_names == 0) {
407                 cp = namedata;
408         }
409         else {
410                 cp = names[nr_names - 1] + strlen(names[nr_names - 1]) + 1;
411         }
412         strcpy(cp, name);
413         names[nr_names] = cp;
414         
415         if (nr_names >= maxnr) {
416                 printf("too many names\n");
417                 return nr_names - 1;
418         }
419         nr_names++;
420         
421         return nr_names - 1;
422 }
423
424 static short *add_struct(int namecode)
425 {
426         int len;
427         short *sp;
428
429         if (nr_structs == 0) {
430                 structs[0] = structdata;
431         }
432         else {
433                 sp = structs[nr_structs - 1];
434                 len = sp[1];
435                 structs[nr_structs] = sp + 2 * len + 2;
436         }
437         
438         sp = structs[nr_structs];
439         sp[0] = namecode;
440         
441         if (nr_structs >= maxnr) {
442                 printf("too many structs\n");
443                 return sp;
444         }
445         nr_structs++;
446         
447         return sp;
448 }
449
450 static int preprocess_include(char *maindata, int len)
451 {
452         int a, newlen, comment = 0;
453         char *cp, *temp, *md;
454         
455         /* note: len + 1, last character is a dummy to prevent
456          * comparisons using uninitialized memory */
457         temp = MEM_mallocN(len + 1, "preprocess_include");
458         temp[len] = ' ';
459
460         memcpy(temp, maindata, len);
461         
462         /* remove all c++ comments */
463         /* replace all enters/tabs/etc with spaces */
464         cp = temp;
465         a = len;
466         comment = 0;
467         while (a--) {
468                 if (cp[0] == '/' && cp[1] == '/') {
469                         comment = 1;
470                 }
471                 else if (*cp < 32) {
472                         comment = 0;
473                 }
474                 if (comment || *cp < 32 || *cp > 128) *cp = 32;
475                 cp++;
476         }
477         
478
479         /* data from temp copy to maindata, remove comments and double spaces */
480         cp = temp;
481         md = maindata;
482         newlen = 0;
483         comment = 0;
484         a = len;
485         while (a--) {
486                 
487                 if (cp[0] == '/' && cp[1] == '*') {
488                         comment = 1;
489                         cp[0] = cp[1] = 32;
490                 }
491                 if (cp[0] == '*' && cp[1] == '/') {
492                         comment = 0;
493                         cp[0] = cp[1] = 32;
494                 }
495
496                 /* do not copy when: */
497                 if (comment) {
498                         /* pass */
499                 }
500                 else if (cp[0] == ' ' && cp[1] == ' ') {
501                         /* pass */
502                 }
503                 else if (cp[-1] == '*' && cp[0] == ' ') {
504                         /* pointers with a space */
505                 }       /* skip special keywords */
506                 else if (strncmp("DNA_DEPRECATED", cp, 14) == 0) {
507                         /* single values are skipped already, so decrement 1 less */
508                         a -= 13;
509                         cp += 13;
510                 }
511                 else {
512                         md[0] = cp[0];
513                         md++;
514                         newlen++;
515                 }
516                 cp++;
517         }
518         
519         MEM_freeN(temp);
520         return newlen;
521 }
522
523 static void *read_file_data(char *filename, int *r_len)
524 {
525 #ifdef WIN32
526         FILE *fp = fopen(filename, "rb");
527 #else
528         FILE *fp = fopen(filename, "r");
529 #endif
530         void *data;
531
532         if (!fp) {
533                 *r_len = -1;
534                 return NULL;
535         }
536
537         fseek(fp, 0L, SEEK_END);
538         *r_len = ftell(fp);
539         fseek(fp, 0L, SEEK_SET);
540
541         data = MEM_mallocN(*r_len, "read_file_data");
542         if (!data) {
543                 *r_len = -1;
544                 fclose(fp);
545                 return NULL;
546         }
547
548         if (fread(data, *r_len, 1, fp) != 1) {
549                 *r_len = -1;
550                 MEM_freeN(data);
551                 fclose(fp);
552                 return NULL;
553         }
554         
555         fclose(fp);
556         return data;
557 }
558
559 static int convert_include(char *filename)
560 {
561         /* read include file, skip structs with a '#' before it.
562          * store all data in temporal arrays.
563          */
564         int filelen, count, overslaan, slen, type, name, strct;
565         short *structpoin, *sp;
566         char *maindata, *mainend, *md, *md1;
567         
568         md = maindata = read_file_data(filename, &filelen);
569         if (filelen == -1) {
570                 printf("Can't read file %s\n", filename);
571                 return 1;
572         }
573
574         filelen = preprocess_include(maindata, filelen);
575         mainend = maindata + filelen - 1;
576
577         /* we look for '{' and then back to 'struct' */
578         count = 0;
579         overslaan = 0;
580         while (count < filelen) {
581                 
582                 /* code for skipping a struct: two hashes on 2 lines. (preprocess added a space) */
583                 if (md[0] == '#' && md[1] == ' ' && md[2] == '#') {
584                         overslaan = 1;
585                 }
586                 
587                 if (md[0] == '{') {
588                         md[0] = 0;
589                         if (overslaan) {
590                                 overslaan = 0;
591                         }
592                         else {
593                                 if (md[-1] == ' ') md[-1] = 0;
594                                 md1 = md - 2;
595                                 while (*md1 != 32) md1--;       /* to beginning of word */
596                                 md1++;
597                                 
598                                 /* we've got a struct name when... */
599                                 if (strncmp(md1 - 7, "struct", 6) == 0) {
600
601                                         strct = add_type(md1, 0);
602                                         if (strct == -1) {
603                                                 printf("File '%s' contains struct we cant parse \"%s\"\n", filename, md1);
604                                                 return 1;
605                                         }
606
607                                         structpoin = add_struct(strct);
608                                         sp = structpoin + 2;
609
610                                         if (debugSDNA > 1) printf("\t|\t|-- detected struct %s\n", types[strct]);
611
612                                         /* first lets make it all nice strings */
613                                         md1 = md + 1;
614                                         while (*md1 != '}') {
615                                                 if (md1 > mainend) break;
616                                                 
617                                                 if (*md1 == ',' || *md1 == ' ') *md1 = 0;
618                                                 md1++;
619                                         }
620                                         
621                                         /* read types and names until first character that is not '}' */
622                                         md1 = md + 1;
623                                         while (*md1 != '}') {
624                                                 if (md1 > mainend) break;
625                                                 
626                                                 /* skip when it says 'struct' or 'unsigned' or 'const' */
627                                                 if (*md1) {
628                                                         if (strncmp(md1, "struct", 6) == 0) md1 += 7;
629                                                         if (strncmp(md1, "unsigned", 8) == 0) md1 += 9;
630                                                         if (strncmp(md1, "const", 5) == 0) md1 += 6;
631                                                         
632                                                         /* we've got a type! */
633                                                         type = add_type(md1, 0);
634                                                         if (type == -1) {
635                                                                 printf("File '%s' contains struct we can't parse \"%s\"\n", filename, md1);
636                                                                 return 1;
637                                                         }
638
639                                                         if (debugSDNA > 1) printf("\t|\t|\tfound type %s (", md1);
640
641                                                         md1 += strlen(md1);
642
643                                                         
644                                                         /* read until ';' */
645                                                         while (*md1 != ';') {
646                                                                 if (md1 > mainend) break;
647                                                                 
648                                                                 if (*md1) {
649                                                                         /* We've got a name. slen needs
650                                                                          * correction for function
651                                                                          * pointers! */
652                                                                         slen = (int) strlen(md1);
653                                                                         if (md1[slen - 1] == ';') {
654                                                                                 md1[slen - 1] = 0;
655
656
657                                                                                 name = add_name(md1);
658                                                                                 slen += additional_slen_offset;
659                                                                                 sp[0] = type;
660                                                                                 sp[1] = name;
661
662                                                                                 if ((debugSDNA > 1) && (names[name] != NULL)) printf("%s |", names[name]);
663
664                                                                                 structpoin[1]++;
665                                                                                 sp += 2;
666                                                                                                                                                                         
667                                                                                 md1 += slen;
668                                                                                 break;
669                                                                         }
670                                                                         
671
672                                                                         name = add_name(md1);
673                                                                         slen += additional_slen_offset;
674
675                                                                         sp[0] = type;
676                                                                         sp[1] = name;
677                                                                         if ((debugSDNA > 1) && (names[name] != NULL)) printf("%s ||", names[name]);
678
679                                                                         structpoin[1]++;
680                                                                         sp += 2;
681                                                                         
682                                                                         md1 += slen;
683                                                                 }
684                                                                 md1++;
685                                                         }
686
687                                                         if (debugSDNA > 1) printf(")\n");
688
689                                                 }
690                                                 md1++;
691                                         }
692                                 }
693                         }
694                 }
695                 count++;
696                 md++;
697         }
698         
699         MEM_freeN(maindata);
700
701         return 0;
702 }
703
704 static int arraysize(const char *str)
705 {
706         int a, mul = 1;
707         const char *cp = NULL;
708         
709         for (a = 0; str[a]; a++) {
710                 if (str[a] == '[') {
711                         cp = &(str[a + 1]);
712                 }
713                 else if (str[a] == ']' && cp) {
714                         /* if 'cp' is a preprocessor definition, it will evaluate to 0,
715                          * the caller needs to check for this case and throw an error */
716                         mul *= atoi(cp);
717                 }
718         }
719         
720         return mul;
721 }
722
723 static int calculate_structlens(int firststruct)
724 {
725         int a, b, len_native, len_32, len_64, unknown = nr_structs, lastunknown, structtype, type, mul, namelen;
726         short *sp, *structpoin;
727         const char *cp;
728         int has_pointer, dna_error = 0;
729                 
730         while (unknown) {
731                 lastunknown = unknown;
732                 unknown = 0;
733                 
734                 /* check all structs... */
735                 for (a = 0; a < nr_structs; a++) {
736                         structpoin = structs[a];
737                         structtype = structpoin[0];
738
739                         /* when length is not known... */
740                         if (typelens_native[structtype] == 0) {
741                                 
742                                 sp = structpoin + 2;
743                                 len_native = 0;
744                                 len_32 = 0;
745                                 len_64 = 0;
746                                 has_pointer = 0;
747                                 
748                                 /* check all elements in struct */
749                                 for (b = 0; b < structpoin[1]; b++, sp += 2) {
750                                         type = sp[0];
751                                         cp = names[sp[1]];
752
753                                         namelen = (int) strlen(cp);
754                                         /* is it a pointer or function pointer? */
755                                         if (cp[0] == '*' || cp[1] == '*') {
756                                                 has_pointer = 1;
757                                                 /* has the name an extra length? (array) */
758                                                 mul = 1;
759                                                 if (cp[namelen - 1] == ']') mul = arraysize(cp);
760
761                                                 if (mul == 0) {
762                                                         printf("Zero array size found or could not parse %s: '%.*s'\n", types[structtype], namelen + 1, cp);
763                                                         dna_error = 1;
764                                                 }
765
766                                                 /* 4-8 aligned/ */
767                                                 if (sizeof(void *) == 4) {
768                                                         if (len_native % 4) {
769                                                                 printf("Align pointer error in struct (len_native 4): %s %s\n", types[structtype], cp);
770                                                                 dna_error = 1;
771                                                         }
772                                                 }
773                                                 else {
774                                                         if (len_native % 8) {
775                                                                 printf("Align pointer error in struct (len_native 8): %s %s\n", types[structtype], cp);
776                                                                 dna_error = 1;
777                                                         }
778                                                 }
779
780                                                 if (len_64 % 8) {
781                                                         printf("Align pointer error in struct (len_64 8): %s %s\n", types[structtype], cp);
782                                                         dna_error = 1;
783                                                 }
784
785                                                 len_native += sizeof(void *) * mul;
786                                                 len_32 += 4 * mul;
787                                                 len_64 += 8 * mul;
788
789                                         }
790                                         else if (cp[0] == '[') {
791                                                 /* parsing can cause names "var" and "[3]" to be found for "float var [3]" ... */
792                                                 printf("Parse error in struct, invalid member name: %s %s\n", types[structtype], cp);
793                                                 dna_error = 1;
794                                         }
795                                         else if (typelens_native[type]) {
796                                                 /* has the name an extra length? (array) */
797                                                 mul = 1;
798                                                 if (cp[namelen - 1] == ']') mul = arraysize(cp);
799
800                                                 if (mul == 0) {
801                                                         printf("Zero array size found or could not parse %s: '%.*s'\n", types[structtype], namelen + 1, cp);
802                                                         dna_error = 1;
803                                                 }
804
805                                                 /* struct alignment */
806                                                 if (type >= firststruct) {
807                                                         if (sizeof(void *) == 8 && (len_native % 8) ) {
808                                                                 printf("Align struct error: %s %s\n", types[structtype], cp);
809                                                                 dna_error = 1;
810                                                         }
811                                                 }
812                                                 
813                                                 /* 2-4-8 aligned/ */
814                                                 if (type < firststruct && typelens_native[type] > 4 && (len_native % 8)) {
815                                                         printf("Align 8 error in struct: %s %s (add %d padding bytes)\n", types[structtype], cp, len_native % 8);
816                                                         dna_error = 1;
817                                                 }
818                                                 if (typelens_native[type] > 3 && (len_native % 4) ) {
819                                                         printf("Align 4 error in struct: %s %s (add %d padding bytes)\n", types[structtype], cp, len_native % 4);
820                                                         dna_error = 1;
821                                                 }
822                                                 else if (typelens_native[type] == 2 && (len_native % 2) ) {
823                                                         printf("Align 2 error in struct: %s %s (add %d padding bytes)\n", types[structtype], cp, len_native % 2);
824                                                         dna_error = 1;
825                                                 }
826
827                                                 len_native += mul * typelens_native[type];
828                                                 len_32 += mul * typelens_32[type];
829                                                 len_64 += mul * typelens_64[type];
830                                                 
831                                         }
832                                         else {
833                                                 len_native = 0;
834                                                 len_32 = 0;
835                                                 len_64 = 0;
836                                                 break;
837                                         }
838                                 }
839                                 
840                                 if (len_native == 0) {
841                                         unknown++;
842                                 }
843                                 else {
844                                         typelens_native[structtype] = len_native;
845                                         typelens_32[structtype] = len_32;
846                                         typelens_64[structtype] = len_64;
847                                         /* two ways to detect if a struct contains a pointer:
848                                          * has_pointer is set or len_native  doesn't match any of 32/64bit lengths*/
849                                         if (has_pointer || len_64 != len_native || len_32 != len_native) {
850                                                 if (len_64 % 8) {
851                                                         printf("Sizeerror 8 in struct: %s (add %d bytes)\n", types[structtype], len_64 % 8);
852                                                         dna_error = 1;
853                                                 }
854                                         }
855                                         
856                                         if (len_native % 4) {
857                                                 printf("Sizeerror 4 in struct: %s (add %d bytes)\n", types[structtype], len_native % 4);
858                                                 dna_error = 1;
859                                         }
860                                         
861                                 }
862                         }
863                 }
864                 
865                 if (unknown == lastunknown) break;
866         }
867         
868         if (unknown) {
869                 printf("ERROR: still %d structs unknown\n", unknown);
870
871                 if (debugSDNA) {
872                         printf("*** Known structs :\n");
873                         
874                         for (a = 0; a < nr_structs; a++) {
875                                 structpoin = structs[a];
876                                 structtype = structpoin[0];
877                                 
878                                 /* length unknown */
879                                 if (typelens_native[structtype] != 0) {
880                                         printf("  %s\n", types[structtype]);
881                                 }
882                         }
883                 }
884
885                         
886                 printf("*** Unknown structs :\n");
887                         
888                 for (a = 0; a < nr_structs; a++) {
889                         structpoin = structs[a];
890                         structtype = structpoin[0];
891
892                         /* length unknown yet */
893                         if (typelens_native[structtype] == 0) {
894                                 printf("  %s\n", types[structtype]);
895                         }
896                 }
897
898                 dna_error = 1;
899         }
900
901         return(dna_error);
902 }
903
904 #define MAX_DNA_LINE_LENGTH 20
905
906 static void dna_write(FILE *file, const void *pntr, const int size)
907 {
908         static int linelength = 0;
909         int i;
910         char *data;
911
912         data = (char *) pntr;
913         
914         for (i = 0; i < size; i++) {
915                 fprintf(file, "%d, ", data[i]);
916                 linelength++;
917                 if (linelength >= MAX_DNA_LINE_LENGTH) {
918                         fprintf(file, "\n");
919                         linelength = 0;
920                 }
921         }
922 }
923
924 void printStructLengths(void)
925 {
926         int a, unknown = nr_structs, structtype;
927         /*int lastunknown;*/ /*UNUSED*/
928         short *structpoin;
929         printf("\n\n*** All detected structs:\n");
930
931         while (unknown) {
932                 /*lastunknown = unknown;*/ /*UNUSED*/
933                 unknown = 0;
934                 
935                 /* check all structs... */
936                 for (a = 0; a < nr_structs; a++) {
937                         structpoin = structs[a];
938                         structtype = structpoin[0];
939                         printf("\t%s\t:%d\n", types[structtype], typelens_native[structtype]);
940                 }
941         }
942
943         printf("*** End of list\n");
944
945 }
946
947
948 static int make_structDNA(const char *baseDirectory, FILE *file)
949 {
950         int len, i;
951         short *sp;
952         /* str contains filenames. Since we now include paths, I stretched       */
953         /* it a bit. Hope this is enough :) -nzc-                                */
954         char str[SDNA_MAX_FILENAME_LENGTH], *cp;
955         int firststruct;
956         
957         if (debugSDNA > -1) {
958                 fflush(stdout);
959                 printf("Running makesdna at debug level %d\n", debugSDNA);
960         }
961                 
962         /* the longest known struct is 50k, so we assume 100k is sufficent! */
963         namedata = MEM_callocN(maxdata, "namedata");
964         typedata = MEM_callocN(maxdata, "typedata");
965         structdata = MEM_callocN(maxdata, "structdata");
966         
967         /* a maximum of 5000 variables, must be sufficient? */
968         names = MEM_callocN(sizeof(char *) * maxnr, "names");
969         types = MEM_callocN(sizeof(char *) * maxnr, "types");
970         typelens_native = MEM_callocN(sizeof(short) * maxnr, "typelens_native");
971         typelens_32 = MEM_callocN(sizeof(short) * maxnr, "typelens_32");
972         typelens_64 = MEM_callocN(sizeof(short) * maxnr, "typelens_64");
973         structs = MEM_callocN(sizeof(short *) * maxnr, "structs");
974
975         /* insertion of all known types */
976         /* watch it: uint is not allowed! use in structs an unsigned int */
977         /* watch it: sizes must match DNA_elem_type_size() */
978         add_type("char", 1);     /* SDNA_TYPE_CHAR */
979         add_type("uchar", 1);    /* SDNA_TYPE_UCHAR */
980         add_type("short", 2);    /* SDNA_TYPE_SHORT */
981         add_type("ushort", 2);   /* SDNA_TYPE_USHORT */
982         add_type("int", 4);      /* SDNA_TYPE_INT */
983         add_type("long", 4);     /* SDNA_TYPE_LONG */  /* maybe 4 or 8 bytes depending on platform, disallowed for now */
984         add_type("ulong", 4);    /* SDNA_TYPE_ULONG */
985         add_type("float", 4);    /* SDNA_TYPE_FLOAT */
986         add_type("double", 8);   /* SDNA_TYPE_DOUBLE */
987         add_type("int64_t", 8);  /* SDNA_TYPE_INT64 */
988         add_type("uint64_t", 8); /* SDNA_TYPE_UINT64 */
989         add_type("void", 0);     /* SDNA_TYPE_VOID */
990
991         /* the defines above shouldn't be output in the padding file... */
992         firststruct = nr_types;
993         
994         /* add all include files defined in the global array                     */
995         /* Since the internal file+path name buffer has limited length, I do a   */
996         /* little test first...                                                  */
997         /* Mind the breaking condition here!                                     */
998         if (debugSDNA) printf("\tStart of header scan:\n"); 
999         for (i = 0; *(includefiles[i]) != '\0'; i++) {
1000                 sprintf(str, "%s%s", baseDirectory, includefiles[i]);
1001                 if (debugSDNA) printf("\t|-- Converting %s\n", str);
1002                 if (convert_include(str)) {
1003                         return (1);
1004                 }
1005         }
1006         if (debugSDNA) printf("\tFinished scanning %d headers.\n", i); 
1007
1008         if (calculate_structlens(firststruct)) {
1009                 /* error */
1010                 return(1);
1011         }
1012
1013         /* FOR DEBUG */
1014         if (debugSDNA > 1) {
1015                 int a, b;
1016                 /* short *elem; */
1017                 short num_types;
1018
1019                 printf("nr_names %d nr_types %d nr_structs %d\n", nr_names, nr_types, nr_structs);
1020                 for (a = 0; a < nr_names; a++) {
1021                         printf(" %s\n", names[a]);
1022                 }
1023                 printf("\n");
1024                 
1025                 sp = typelens_native;
1026                 for (a = 0; a < nr_types; a++, sp++) {
1027                         printf(" %s %d\n", types[a], *sp);
1028                 }
1029                 printf("\n");
1030                 
1031                 for (a = 0; a < nr_structs; a++) {
1032                         sp = structs[a];
1033                         printf(" struct %s elems: %d size: %d\n", types[sp[0]], sp[1], typelens_native[sp[0]]);
1034                         num_types  = sp[1];
1035                         sp += 2;
1036                         /* ? num_types was elem? */
1037                         for (b = 0; b < num_types; b++, sp += 2) {
1038                                 printf("   %s %s\n", types[sp[0]], names[sp[1]]);
1039                         }
1040                 }
1041         }
1042
1043         /* file writing */
1044
1045         if (debugSDNA > -1) printf("Writing file ... ");
1046                 
1047         if (nr_names == 0 || nr_structs == 0) {
1048                 /* pass */
1049         }
1050         else {
1051                 dna_write(file, "SDNA", 4);
1052                 
1053                 /* write names */
1054                 dna_write(file, "NAME", 4);
1055                 len = nr_names;
1056                 dna_write(file, &len, 4);
1057                 
1058                 /* calculate size of datablock with strings */
1059                 cp = names[nr_names - 1];
1060                 cp += strlen(names[nr_names - 1]) + 1;         /* +1: null-terminator */
1061                 len = (intptr_t) (cp - (char *) names[0]);
1062                 len = (len + 3) & ~3;
1063                 dna_write(file, names[0], len);
1064                 
1065                 /* write TYPES */
1066                 dna_write(file, "TYPE", 4);
1067                 len = nr_types;
1068                 dna_write(file, &len, 4);
1069         
1070                 /* calculate datablock size */
1071                 cp = types[nr_types - 1];
1072                 cp += strlen(types[nr_types - 1]) + 1;     /* +1: null-terminator */
1073                 len = (intptr_t) (cp - (char *) types[0]);
1074                 len = (len + 3) & ~3;
1075                 
1076                 dna_write(file, types[0], len);
1077                 
1078                 /* WRITE TYPELENGTHS */
1079                 dna_write(file, "TLEN", 4);
1080                 
1081                 len = 2 * nr_types;
1082                 if (nr_types & 1) len += 2;
1083                 dna_write(file, typelens_native, len);
1084                 
1085                 /* WRITE STRUCTS */
1086                 dna_write(file, "STRC", 4);
1087                 len = nr_structs;
1088                 dna_write(file, &len, 4);
1089         
1090                 /* calc datablock size */
1091                 sp = structs[nr_structs - 1];
1092                 sp += 2 + 2 * (sp[1]);
1093                 len = (intptr_t) ((char *) sp - (char *) structs[0]);
1094                 len = (len + 3) & ~3;
1095                 
1096                 dna_write(file, structs[0], len);
1097         
1098                 /* a simple dna padding test */
1099                 if (0) {
1100                         FILE *fp;
1101                         int a;
1102                         
1103                         fp = fopen("padding.c", "w");
1104                         if (fp == NULL) {
1105                                 /* pass */
1106                         }
1107                         else {
1108
1109                                 /* add all include files defined in the global array */
1110                                 for (i = 0; *(includefiles[i]) != '\0'; i++) {
1111                                         fprintf(fp, "#include \"%s%s\"\n", baseDirectory, includefiles[i]);
1112                                 }
1113
1114                                 fprintf(fp, "main() {\n");
1115                                 sp = typelens_native;
1116                                 sp += firststruct;
1117                                 for (a = firststruct; a < nr_types; a++, sp++) {
1118                                         if (*sp) {
1119                                                 fprintf(fp, "\tif (sizeof(struct %s) - %d) printf(\"ALIGN ERROR:", types[a], *sp);
1120                                                 fprintf(fp, "%%d %s %d ", types[a], *sp);
1121                                                 fprintf(fp, "\\n\",  sizeof(struct %s) - %d);\n", types[a], *sp);
1122                                         }
1123                                 }
1124                                 fprintf(fp, "}\n");
1125                                 fclose(fp);
1126                         }
1127                 }
1128                 /*      end end padding test */
1129         }
1130         
1131         
1132         MEM_freeN(namedata);
1133         MEM_freeN(typedata);
1134         MEM_freeN(structdata);
1135         MEM_freeN(names);
1136         MEM_freeN(types);
1137         MEM_freeN(typelens_native);
1138         MEM_freeN(typelens_32);
1139         MEM_freeN(typelens_64);
1140         MEM_freeN(structs);
1141
1142         if (debugSDNA > -1) printf("done.\n");
1143         
1144         return(0);
1145 }
1146
1147 /* ************************* END MAKE DNA ********************** */
1148
1149 static void make_bad_file(const char *file, int line)
1150 {
1151         FILE *fp = fopen(file, "w");
1152         fprintf(fp, "#error \"Error! can't make correct DNA.c file from %s:%d, STUPID!\"\n", __FILE__, line);
1153         fclose(fp);
1154 }
1155
1156 #ifndef BASE_HEADER
1157 #define BASE_HEADER "../"
1158 #endif
1159
1160 int main(int argc, char **argv)
1161 {
1162         FILE *file;
1163         int return_status = 0;
1164
1165         if (argc != 2 && argc != 3) {
1166                 printf("Usage: %s outfile.c [base directory]\n", argv[0]);
1167                 return_status = 1;
1168         }
1169         else {
1170                 file = fopen(argv[1], "w");
1171                 if (!file) {
1172                         printf("Unable to open file: %s\n", argv[1]);
1173                         return_status = 1;
1174                 }
1175                 else {
1176                         const char *baseDirectory;
1177
1178                         if (argc == 3) {
1179                                 baseDirectory = argv[2];
1180                         }
1181                         else {
1182                                 baseDirectory = BASE_HEADER;
1183                         }
1184
1185                         fprintf(file, "const unsigned char DNAstr[] = {\n");
1186                         if (make_structDNA(baseDirectory, file)) {
1187                                 /* error */
1188                                 fclose(file);
1189                                 make_bad_file(argv[1], __LINE__);
1190                                 return_status = 1;
1191                         }
1192                         else {
1193                                 fprintf(file, "};\n");
1194                                 fprintf(file, "const int DNAlen = sizeof(DNAstr);\n");
1195         
1196                                 fclose(file);
1197                         }
1198                 }
1199         }
1200
1201                 
1202         return(return_status);
1203 }
1204
1205 /* handy but fails on struct bounds which makesdna doesnt care about
1206  * with quite the same strictness as GCC does */
1207 #if 0
1208 /* include files for automatic dependencies */
1209
1210 /* extra safety check that we are aligned,
1211  * warnings here are easier to fix the makesdna's */
1212 #ifdef __GNUC__
1213 #  pragma GCC diagnostic error "-Wpadded"
1214 #endif
1215
1216 #endif /* if 0 */
1217
1218 /* even though DNA supports, 'long' shouldn't be used since it can be either 32 or 64bit,
1219  * use int or int64_t instead.
1220  * Only valid use would be as a runtime variable if an API expected a long,
1221  * but so far we dont have this happening. */
1222 #ifdef __GNUC__
1223 #  pragma GCC poison long
1224 #endif
1225
1226 #include "DNA_listBase.h"
1227 #include "DNA_vec_types.h"
1228 #include "DNA_ID.h"
1229 #include "DNA_ipo_types.h"
1230 #include "DNA_key_types.h"
1231 #include "DNA_text_types.h"
1232 #include "DNA_packedFile_types.h"
1233 #include "DNA_camera_types.h"
1234 #include "DNA_image_types.h"
1235 #include "DNA_texture_types.h"
1236 #include "DNA_lamp_types.h"
1237 #include "DNA_material_types.h"
1238 #include "DNA_vfont_types.h"
1239 #include "DNA_meta_types.h"
1240 #include "DNA_curve_types.h"
1241 #include "DNA_mesh_types.h"
1242 #include "DNA_meshdata_types.h"
1243 #include "DNA_modifier_types.h"
1244 #include "DNA_lattice_types.h"  
1245 #include "DNA_object_types.h"
1246 #include "DNA_object_force.h"
1247 #include "DNA_object_fluidsim.h"
1248 #include "DNA_world_types.h"
1249 #include "DNA_scene_types.h"
1250 #include "DNA_view3d_types.h"
1251 #include "DNA_view2d_types.h"   
1252 #include "DNA_space_types.h"
1253 #include "DNA_userdef_types.h"
1254 #include "DNA_screen_types.h"
1255 #include "DNA_sdna_types.h"
1256 #include "DNA_fileglobal_types.h"
1257 #include "DNA_sequence_types.h"
1258 #include "DNA_effect_types.h"
1259 #include "DNA_outliner_types.h"
1260 #include "DNA_property_types.h"
1261 #include "DNA_sensor_types.h"
1262 #include "DNA_controller_types.h"
1263 #include "DNA_actuator_types.h"
1264 #include "DNA_sound_types.h"
1265 #include "DNA_group_types.h"
1266 #include "DNA_armature_types.h"
1267 #include "DNA_action_types.h"
1268 #include "DNA_constraint_types.h"
1269 #include "DNA_nla_types.h"
1270 #include "DNA_node_types.h"
1271 #include "DNA_color_types.h"
1272 #include "DNA_brush_types.h"
1273 #include "DNA_customdata_types.h"
1274 #include "DNA_particle_types.h"
1275 #include "DNA_cloth_types.h"
1276 #include "DNA_gpencil_types.h"
1277 #include "DNA_windowmanager_types.h"
1278 #include "DNA_anim_types.h"
1279 #include "DNA_boid_types.h"
1280 #include "DNA_smoke_types.h"
1281 #include "DNA_speaker_types.h"
1282 #include "DNA_movieclip_types.h"
1283 #include "DNA_tracking_types.h"
1284 #include "DNA_dynamicpaint_types.h"
1285 #include "DNA_mask_types.h"
1286 #include "DNA_rigidbody_types.h"
1287 #include "DNA_freestyle_types.h"
1288 #include "DNA_linestyle_types.h"
1289 /* end of list */