blender
/
blender
128
396
Fork 568
Code Issues 6.2k Pull Requests 750 Projects 19 Wiki Activity

Cleanup: rename nr_* to *_len for DNA code

This commit is contained in:
Campbell Barton 2019-05-21 17:53:22 +10:00
parent 34d7ff76ee
commit 21d065af5d
Notes: blender-bot 2023-02-14 06:17:14 +01:00 
Referenced by issue #64951, Grease Pencil: Blender crashes immediately after invoking frame interpolation.
3 changed files with 108 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
source/blender/makesdna/DNA_sdna_types.h
View File

@ -35,7 +35,7 @@ typedef struct SDNA {
bool data_alloc;
/** Total number of struct members. */
int nr_names, nr_names_alloc;
int names_len, names_len_alloc;
/** Struct member names. */
const char **names;
/** Result of #DNA_elem_array_size (aligned with #names). */
@ -44,15 +44,14 @@ typedef struct SDNA {
/** Size of a pointer in bytes. */
int pointer_size;
/** Number of basic types + struct types. */
int nr_types;
/** Type names. */
const char **types;
/** Number of basic types + struct types. */
int types_len;
/** Type lengths. */
short *types_size;
/** Number of struct types. */
int nr_structs;
/**
* sp = structs[a] is the address of a struct definition
* sp[0] is struct type number, sp[1] amount of members
@ -61,6 +60,8 @@ typedef struct SDNA {
* type and name numbers respectively.
*/
short **structs;
/** Number of struct types. */
int structs_len;
/** #GHash for faster lookups, requires WITH_DNA_GHASH to be used for now. */
struct GHash *structs_map;

82
source/blender/makesdna/intern/dna_genfile.c
View File

@ -224,7 +224,7 @@ static void printstruct(SDNA *sdna, short strnr)
*/
int DNA_struct_find_nr_ex(const SDNA *sdna, const char *str, unsigned int *index_last)
{
if (*index_last < sdna->nr_structs) {
if (*index_last < sdna->structs_len) {
const short *sp = sdna->structs[*index_last];
if (STREQ(sdna->types[sp[0]], str)) {
return *index_last;
@ -242,7 +242,7 @@ int DNA_struct_find_nr_ex(const SDNA *sdna, const char *str, unsigned int *index
}
#else
{
for (int index = 0; index < sdna->nr_structs; index++) {
for (int index = 0; index < sdna->structs_len; index++) {
const short *sp = sdna->structs[index];
if (STREQ(sdna->types[sp[0]], str)) {
*index_last = index;
@ -304,14 +304,14 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
if (*data == MAKE_ID('N', 'A', 'M', 'E')) {
data++;
sdna->nr_names = *data;
sdna->names_len = *data;
if (do_endian_swap) {
BLI_endian_switch_int32(&sdna->nr_names);
BLI_endian_switch_int32(&sdna->names_len);
}
sdna->nr_names_alloc = sdna->nr_names;
sdna->names_len_alloc = sdna->names_len;
data++;
sdna->names = MEM_callocN(sizeof(void *) * sdna->nr_names, "sdnanames");
sdna->names = MEM_callocN(sizeof(void *) * sdna->names_len, "sdnanames");
}
else {
*r_error_message = "NAME error in SDNA file";
@ -319,7 +319,7 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
}
cp = (char *)data;
for (int nr = 0; nr < sdna->nr_names; nr++) {
for (int nr = 0; nr < sdna->names_len; nr++) {
sdna->names[nr] = cp;
/* "float gravity [3]" was parsed wrong giving both "gravity" and
@ -344,13 +344,13 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
if (*data == MAKE_ID('T', 'Y', 'P', 'E')) {
data++;
sdna->nr_types = *data;
sdna->types_len = *data;
if (do_endian_swap) {
BLI_endian_switch_int32(&sdna->nr_types);
BLI_endian_switch_int32(&sdna->types_len);
}
data++;
sdna->types = MEM_callocN(sizeof(void *) * sdna->nr_types, "sdnatypes");
sdna->types = MEM_callocN(sizeof(void *) * sdna->types_len, "sdnatypes");
}
else {
*r_error_message = "TYPE error in SDNA file";
@ -358,7 +358,7 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
}
cp = (char *)data;
for (int nr = 0; nr < sdna->nr_types; nr++) {
for (int nr = 0; nr < sdna->types_len; nr++) {
/* WARNING! See: DNA_struct_rename_legacy_hack_static_from_alias docs. */
sdna->types[nr] = DNA_struct_rename_legacy_hack_static_from_alias(cp);
while (*cp) {
@ -377,17 +377,17 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
sdna->types_size = sp;
if (do_endian_swap) {
BLI_endian_switch_int16_array(sp, sdna->nr_types);
BLI_endian_switch_int16_array(sp, sdna->types_len);
}
sp += sdna->nr_types;
sp += sdna->types_len;
}
else {
*r_error_message = "TLEN error in SDNA file";
return false;
}
/* prevent BUS error */
if (sdna->nr_types & 1) {
if (sdna->types_len & 1) {
sp++;
}
@ -396,13 +396,13 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
if (*data == MAKE_ID('S', 'T', 'R', 'C')) {
data++;
sdna->nr_structs = *data;
sdna->structs_len = *data;
if (do_endian_swap) {
BLI_endian_switch_int32(&sdna->nr_structs);
BLI_endian_switch_int32(&sdna->structs_len);
}
data++;
sdna->structs = MEM_callocN(sizeof(void *) * sdna->nr_structs, "sdnastrcs");
sdna->structs = MEM_callocN(sizeof(void *) * sdna->structs_len, "sdnastrcs");
}
else {
*r_error_message = "STRC error in SDNA file";
@ -410,7 +410,7 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
}
sp = (short *)data;
for (int nr = 0; nr < sdna->nr_structs; nr++) {
for (int nr = 0; nr < sdna->structs_len; nr++) {
sdna->structs[nr] = sp;
if (do_endian_swap) {
@ -436,7 +436,7 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
{
/* second part of gravity problem, setting "gravity" type to void */
if (gravity_fix > -1) {
for (int nr = 0; nr < sdna->nr_structs; nr++) {
for (int nr = 0; nr < sdna->structs_len; nr++) {
sp = sdna->structs[nr];
if (strcmp(sdna->types[sp[0]], "ClothSimSettings") == 0) {
sp[10] = SDNA_TYPE_VOID;
@ -448,9 +448,9 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
#ifdef WITH_DNA_GHASH
{
/* create a ghash lookup to speed up */
sdna->structs_map = BLI_ghash_str_new_ex("init_structDNA gh", sdna->nr_structs);
sdna->structs_map = BLI_ghash_str_new_ex("init_structDNA gh", sdna->structs_len);
for (intptr_t nr = 0; nr < sdna->nr_structs; nr++) {
for (intptr_t nr = 0; nr < sdna->structs_len; nr++) {
sp = sdna->structs[nr];
BLI_ghash_insert(sdna->structs_map, (void *)sdna->types[sp[0]], POINTER_FROM_INT(nr));
}
@ -482,8 +482,8 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
/* Cache name size. */
{
short *names_array_len = MEM_mallocN(sizeof(*names_array_len) * sdna->nr_names, __func__);
for (int i = 0; i < sdna->nr_names; i++) {
short *names_array_len = MEM_mallocN(sizeof(*names_array_len) * sdna->names_len, __func__);
for (int i = 0; i < sdna->names_len; i++) {
names_array_len[i] = DNA_elem_array_size(sdna->names[i]);
}
sdna->names_array_len = names_array_len;
@ -573,7 +573,7 @@ static void recurs_test_compflags(const SDNA *sdna, char *compflags, int structn
sp = sdna->structs[structnr];
typenr = sp[0];
for (a = 0; a < sdna->nr_structs; a++) {
for (a = 0; a < sdna->structs_len; a++) {
if ((a != structnr) && (compflags[a] == SDNA_CMP_EQUAL)) {
sp = sdna->structs[a];
elems = sp[1];
@ -602,19 +602,19 @@ const char *DNA_struct_get_compareflags(const SDNA *oldsdna, const SDNA *newsdna
const char *str1, *str2;
char *compflags;
if (oldsdna->nr_structs == 0) {
if (oldsdna->structs_len == 0) {
printf("error: file without SDNA\n");
return NULL;
}
compflags = MEM_callocN(oldsdna->nr_structs, "compflags");
compflags = MEM_callocN(oldsdna->structs_len, "compflags");
/* we check all structs in 'oldsdna' and compare them with
* the structs in 'newsdna'
*/
unsigned int newsdna_index_last = 0;
for (a = 0; a < oldsdna->nr_structs; a++) {
for (a = 0; a < oldsdna->structs_len; a++) {
sp_old = oldsdna->structs[a];
/* search for type in cur */
@ -678,14 +678,14 @@ const char *DNA_struct_get_compareflags(const SDNA *oldsdna, const SDNA *newsdna
/* Because structs can be inside structs, we recursively
* set flags when a struct is altered
*/
for (a = 0; a < oldsdna->nr_structs; a++) {
for (a = 0; a < oldsdna->structs_len; a++) {
if (compflags[a] == SDNA_CMP_NOT_EQUAL) {
recurs_test_compflags(oldsdna, compflags, a);
}
}
#if 0
for (a = 0; a < oldsdna->nr_structs; a++) {
for (a = 0; a < oldsdna->structs_len; a++) {
if (compflags[a] == SDNA_CMP_NOT_EQUAL) {
spold = oldsdna->structs[a];
printf("changed: %s\n", oldsdna->types[spold[0]]);
@ -1470,14 +1470,14 @@ static bool DNA_sdna_patch_struct_member_nr(SDNA *sdna,
strlen(elem_old_full),
elem_old_full_offset_start);
if (sdna->nr_names == sdna->nr_names_alloc) {
sdna->nr_names_alloc += 64;
sdna->names = MEM_recallocN(sdna->names, sizeof(*sdna->names) * sdna->nr_names_alloc);
if (sdna->names_len == sdna->names_len_alloc) {
sdna->names_len_alloc += 64;
sdna->names = MEM_recallocN(sdna->names, sizeof(*sdna->names) * sdna->names_len_alloc);
sdna->names_array_len = MEM_recallocN(
(void *)sdna->names_array_len, sizeof(*sdna->names_array_len) * sdna->nr_names_alloc);
(void *)sdna->names_array_len, sizeof(*sdna->names_array_len) * sdna->names_len_alloc);
}
const short name_nr_prev = sp[1];
sp[1] = sdna->nr_names++;
sp[1] = sdna->names_len++;
sdna->names[sp[1]] = elem_new_full;
sdna->names_array_len[sp[1]] = sdna->names_array_len[name_nr_prev];
@ -1520,14 +1520,14 @@ bool DNA_sdna_patch_struct_member(SDNA *sdna,
static void sdna_expand_names(SDNA *sdna)
{
int names_expand_len = 0;
for (int struct_nr = 0; struct_nr < sdna->nr_structs; struct_nr++) {
for (int struct_nr = 0; struct_nr < sdna->structs_len; struct_nr++) {
const short *sp = sdna->structs[struct_nr];
names_expand_len += sp[1];
}
const char **names_expand = MEM_mallocN(sizeof(*names_expand) * names_expand_len, __func__);
int names_expand_index = 0;
for (int struct_nr = 0; struct_nr < sdna->nr_structs; struct_nr++) {
for (int struct_nr = 0; struct_nr < sdna->structs_len; struct_nr++) {
/* We can't edit this memory 'sdna->structs' points to (readonly datatoc file). */
const short *sp = sdna->structs[struct_nr];
short *sp_expand = BLI_memarena_alloc(sdna->mem_arena, sizeof(short[2]) * (1 + sp[1]));
@ -1545,7 +1545,7 @@ static void sdna_expand_names(SDNA *sdna)
}
MEM_freeN((void *)sdna->names);
sdna->names = names_expand;
sdna->nr_names = names_expand_len;
sdna->names_len = names_expand_len;
}
static const char *dna_sdna_alias_alias_from_static_elem_full(SDNA *sdna,
@ -1587,8 +1587,8 @@ void DNA_sdna_alias_data_ensure(SDNA *sdna)
DNA_RENAME_ALIAS_FROM_STATIC, &struct_map_alias_from_static, &elem_map_alias_from_static);
if (sdna->alias.types == NULL) {
sdna->alias.types = MEM_mallocN(sizeof(*sdna->alias.types) * sdna->nr_types, __func__);
for (int type_nr = 0; type_nr < sdna->nr_types; type_nr++) {
sdna->alias.types = MEM_mallocN(sizeof(*sdna->alias.types) * sdna->types_len, __func__);
for (int type_nr = 0; type_nr < sdna->types_len; type_nr++) {
const char *struct_name_static = sdna->types[type_nr];
if (use_legacy_hack) {
@ -1602,8 +1602,8 @@ void DNA_sdna_alias_data_ensure(SDNA *sdna)
if (sdna->alias.names == NULL) {
sdna_expand_names(sdna);
sdna->alias.names = MEM_mallocN(sizeof(*sdna->alias.names) * sdna->nr_names, __func__);
for (int struct_nr = 0; struct_nr < sdna->nr_structs; struct_nr++) {
sdna->alias.names = MEM_mallocN(sizeof(*sdna->alias.names) * sdna->names_len, __func__);
for (int struct_nr = 0; struct_nr < sdna->structs_len; struct_nr++) {
const short *sp = sdna->structs[struct_nr];
const char *struct_name_static = sdna->types[sp[0]];

123
source/blender/makesdna/intern/makesdna.c
View File

@ -144,10 +144,10 @@ static const char *includefiles[] = {
static MemArena *mem_arena = NULL;
static int maxdata = 500000, maxnr = 50000;
static int nr_names = 0;
static int nr_types = 0;
static int nr_structs = 0;
static int max_data_size = 500000, max_array_len = 50000;
static int names_len = 0;
static int types_len = 0;
static int structs_len = 0;
/** At address `names[a]` is string `a`. */
static char **names;
/** At address `types[a]` is string `a`. */
@ -161,7 +161,7 @@ static short *types_size_64;
/** At `sp = structs[a]` is the first address of a struct definition:
* - `sp[0]` is type number.
* - `sp[1]` is the length of the element array (next).
* - `sp[2]` sp[3] is [(type_nr, name_nr), ..] (number of pairs is defined by `sp[1]`),
* - `sp[2]` sp[3] is [(type_index, name_index), ..] (number of pairs is defined by `sp[1]`),
*/
static short **structs, *structdata;
@ -344,7 +344,6 @@ static bool is_name_legal(const char *name)
static int add_type(const char *str, int size)
{
int nr;
char *cp;
/* first do validity check */
@ -360,14 +359,14 @@ static int add_type(const char *str, int size)
str = version_struct_static_from_alias(str);
/* search through type array */
for (nr = 0; nr < nr_types; nr++) {
if (strcmp(str, types[nr]) == 0) {
for (int index = 0; index < types_len; index++) {
if (strcmp(str, types[index]) == 0) {
if (size) {
types_size_native[nr] = size;
types_size_32[nr] = size;
types_size_64[nr] = size;
types_size_native[index] = size;
types_size_32[index] = size;
types_size_64[index] = size;
}
return nr;
return index;
}
}
@ -375,18 +374,18 @@ static int add_type(const char *str, int size)
const int str_size = strlen(str) + 1;
cp = BLI_memarena_alloc(mem_arena, str_size);
memcpy(cp, str, str_size);
types[nr_types] = cp;
types_size_native[nr_types] = size;
types_size_32[nr_types] = size;
types_size_64[nr_types] = size;
types[types_len] = cp;
types_size_native[types_len] = size;
types_size_32[types_len] = size;
types_size_64[types_len] = size;
if (nr_types >= maxnr) {
if (types_len >= max_array_len) {
printf("too many types\n");
return nr_types - 1;
return types_len - 1;
}
nr_types++;
types_len++;
return nr_types - 1;
return types_len - 1;
}
/**
@ -513,7 +512,7 @@ static int add_name(const char *str)
}
/* search name array */
for (nr = 0; nr < nr_names; nr++) {
for (nr = 0; nr < names_len; nr++) {
if (strcmp(name, names[nr]) == 0) {
return nr;
}
@ -528,15 +527,15 @@ static int add_name(const char *str)
const int name_size = strlen(name) + 1;
cp = BLI_memarena_alloc(mem_arena, name_size);
memcpy(cp, name, name_size);
names[nr_names] = cp;
names[names_len] = cp;
if (nr_names >= maxnr) {
if (names_len >= max_array_len) {
printf("too many names\n");
return nr_names - 1;
return names_len - 1;
}
nr_names++;
names_len++;
return nr_names - 1;
return names_len - 1;
}
static short *add_struct(int namecode)
@ -544,23 +543,23 @@ static short *add_struct(int namecode)
int len;
short *sp;
if (nr_structs == 0) {
if (structs_len == 0) {
structs[0] = structdata;
}
else {
sp = structs[nr_structs - 1];
sp = structs[structs_len - 1];
len = sp[1];
structs[nr_structs] = sp + 2 * len + 2;
structs[structs_len] = sp + 2 * len + 2;
}
sp = structs[nr_structs];
sp = structs[structs_len];
sp[0] = namecode;
if (nr_structs >= maxnr) {
if (structs_len >= max_array_len) {
printf("too many structs\n");
return sp;
}
nr_structs++;
structs_len++;
return sp;
}
@ -896,7 +895,7 @@ static bool check_field_alignment(
static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char *base_directory)
{
int unknown = nr_structs, lastunknown;
int unknown = structs_len, lastunknown;
bool dna_error = false;
/* Write test to verify sizes are accurate. */
@ -914,7 +913,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
unknown = 0;
/* check all structs... */
for (int a = 0; a < nr_structs; a++) {
for (int a = 0; a < structs_len; a++) {
const short *structpoin = structs[a];
const int structtype = structpoin[0];
const char *structname = version_struct_alias_from_static(types[structtype]);
@ -1099,7 +1098,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
if (debugSDNA) {
fprintf(stderr, "*** Known structs :\n");
for (int a = 0; a < nr_structs; a++) {
for (int a = 0; a < structs_len; a++) {
const short *structpoin = structs[a];
const int structtype = structpoin[0];
@ -1112,7 +1111,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
fprintf(stderr, "*** Unknown structs :\n");
for (int a = 0; a < nr_structs; a++) {
for (int a = 0; a < structs_len; a++) {
const short *structpoin = structs[a];
const int structtype = structpoin[0];
@ -1150,7 +1149,7 @@ static void dna_write(FILE *file, const void *pntr, const int size)
void print_struct_sizes(void)
{
int a, unknown = nr_structs, structtype;
int a, unknown = structs_len, structtype;
/*int lastunknown;*/ /*UNUSED*/
const short *structpoin;
printf("\n\n*** All detected structs:\n");
@ -1160,7 +1159,7 @@ void print_struct_sizes(void)
unknown = 0;
/* check all structs... */
for (a = 0; a < nr_structs; a++) {
for (a = 0; a < structs_len; a++) {
structpoin = structs[a];
structtype = structpoin[0];
printf("\t%s\t:%d\n", types[structtype], types_size_native[structtype]);
@ -1190,15 +1189,15 @@ static int make_structDNA(const char *base_directory,
mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
/* the longest known struct is 50k, so we assume 100k is sufficient! */
structdata = MEM_callocN(maxdata, "structdata");
structdata = MEM_callocN(max_data_size, "structdata");
/* a maximum of 5000 variables, must be sufficient? */
names = MEM_callocN(sizeof(char *) * maxnr, "names");
types = MEM_callocN(sizeof(char *) * maxnr, "types");
types_size_native = MEM_callocN(sizeof(short) * maxnr, "types_size_native");
types_size_32 = MEM_callocN(sizeof(short) * maxnr, "types_size_32");
types_size_64 = MEM_callocN(sizeof(short) * maxnr, "types_size_64");
structs = MEM_callocN(sizeof(short *) * maxnr, "structs");
names = MEM_callocN(sizeof(char *) * max_array_len, "names");
types = MEM_callocN(sizeof(char *) * max_array_len, "types");
types_size_native = MEM_callocN(sizeof(short) * max_array_len, "types_size_native");
types_size_32 = MEM_callocN(sizeof(short) * max_array_len, "types_size_32");
types_size_64 = MEM_callocN(sizeof(short) * max_array_len, "types_size_64");
structs = MEM_callocN(sizeof(short *) * max_array_len, "structs");
/* Build versioning data */
DNA_alias_maps(DNA_RENAME_ALIAS_FROM_STATIC,
@ -1233,7 +1232,7 @@ static int make_structDNA(const char *base_directory,
add_type("void", 0); /* SDNA_TYPE_VOID */
/* the defines above shouldn't be output in the padding file... */
firststruct = nr_types;
firststruct = types_len;
/* add all include files defined in the global array */
/* Since the internal file+path name buffer has limited length, I do a */
@ -1260,19 +1259,19 @@ static int make_structDNA(const char *base_directory,
/* short *elem; */
short num_types;
printf("nr_names %d nr_types %d nr_structs %d\n", nr_names, nr_types, nr_structs);
for (a = 0; a < nr_names; a++) {
printf("names_len %d types_len %d structs_len %d\n", names_len, types_len, structs_len);
for (a = 0; a < names_len; a++) {
printf(" %s\n", names[a]);
}
printf("\n");
sp = types_size_native;
for (a = 0; a < nr_types; a++, sp++) {
for (a = 0; a < types_len; a++, sp++) {
printf(" %s %d\n", types[a], *sp);
}
printf("\n");
for (a = 0; a < nr_structs; a++) {
for (a = 0; a < structs_len; a++) {
sp = structs[a];
printf(" struct %s elems: %d size: %d\n", types[sp[0]], sp[1], types_size_native[sp[0]]);
num_types = sp[1];
@ -1288,7 +1287,7 @@ static int make_structDNA(const char *base_directory,
DEBUG_PRINTF(0, "Writing file ... ");
if (nr_names == 0 || nr_structs == 0) {
if (names_len == 0 || structs_len == 0) {
/* pass */
}
else {
@ -1299,11 +1298,11 @@ static int make_structDNA(const char *base_directory,
/* write names */
dna_write(file, "NAME", 4);
len = nr_names;
len = names_len;
dna_write(file, &len, 4);
/* write array */
len = 0;
for (int nr = 0; nr < nr_names; nr++) {
for (int nr = 0; nr < names_len; nr++) {
int name_size = strlen(names[nr]) + 1;
dna_write(file, names[nr], name_size);
len += name_size;
@ -1315,11 +1314,11 @@ static int make_structDNA(const char *base_directory,
/* write TYPES */
dna_write(file, "TYPE", 4);
len = nr_types;
len = types_len;
dna_write(file, &len, 4);
/* write array */
len = 0;
for (int nr = 0; nr < nr_types; nr++) {
for (int nr = 0; nr < types_len; nr++) {
int type_size = strlen(types[nr]) + 1;
dna_write(file, types[nr], type_size);
len += type_size;
@ -1332,19 +1331,19 @@ static int make_structDNA(const char *base_directory,
/* WRITE TYPELENGTHS */
dna_write(file, "TLEN", 4);
len = 2 * nr_types;
if (nr_types & 1) {
len = 2 * types_len;
if (types_len & 1) {
len += 2;
}
dna_write(file, types_size_native, len);
/* WRITE STRUCTS */
dna_write(file, "STRC", 4);
len = nr_structs;
len = structs_len;
dna_write(file, &len, 4);
/* calc datablock size */
sp = structs[nr_structs - 1];
sp = structs[structs_len - 1];
sp += 2 + 2 * (sp[1]);
len = (intptr_t)((char *)sp - (char *)structs[0]);
len = (len + 3) & ~3;
@ -1357,7 +1356,7 @@ static int make_structDNA(const char *base_directory,
{
fprintf(file_offsets, "#define SDNA_TYPE_FROM_STRUCT(id) _SDNA_TYPE_##id\n");
fprintf(file_offsets, "enum {\n");
for (i = 0; i < nr_structs; i++) {
for (i = 0; i < structs_len; i++) {
const short *structpoin = structs[i];
const int structtype = structpoin[0];
fprintf(file_offsets,
@ -1365,7 +1364,7 @@ static int make_structDNA(const char *base_directory,
version_struct_alias_from_static(types[structtype]),
i);
}
fprintf(file_offsets, "\tSDNA_TYPE_MAX = %d,\n", nr_structs);
fprintf(file_offsets, "\tSDNA_TYPE_MAX = %d,\n", structs_len);
fprintf(file_offsets, "};\n\n");
}
@ -1373,7 +1372,7 @@ static int make_structDNA(const char *base_directory,
* do last because names are stripped. */
{
GSet *names_unique = BLI_gset_str_new_ex(__func__, 512);
for (int struct_nr = 0; struct_nr < nr_structs; struct_nr++) {
for (int struct_nr = 0; struct_nr < structs_len; struct_nr++) {
sp = structs[struct_nr];
const char *struct_name = types[sp[0]];
const int len = sp[1];