Cleanup: rename nr_* to *_len for DNA code
authorCampbell Barton <ideasman42@gmail.com>
Tue, 21 May 2019 07:53:22 +0000 (17:53 +1000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 21 May 2019 08:01:33 +0000 (18:01 +1000)
source/blender/makesdna/DNA_sdna_types.h
source/blender/makesdna/intern/dna_genfile.c
source/blender/makesdna/intern/makesdna.c

index 01e74da..efd3dbe 100644 (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;
index fa5a55e..2e89629 100644 (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]];
 
index c09ada4..7e53231 100644 (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];