source/blender/makesdna/intern/makesdna.c

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