griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: DNA code: sanitize naming.

Browse Source 
Previous namings in makesdna code was very confusing and inconsistent.

This commit unifies names accross the codebase as such:
- `struct` for the structs definitions data.
- `type` for the types definitions data.
- `member` for the struct members definitions data.

Structs and types definitions are not in synced for two reasons:
- types contains also definitions for basic types (int, float, etc.).
- types can be discovered before their struct definition (as members of
  other structs).

This commit also groups all members of `SDNA` struct more logically (all
'structs' ones together, then all 'types' ones, then all 'struct
members' ones).

This commit should have no behavioral change at all.

Pull Request: https://projects.blender.org/blender/blender/pulls/125605
This commit is contained in:
Bastien Montagne
2024-07-22 18:11:17 +02:00
committed by Gitea
parent 09bae67c86
commit 2372bf1377
10 changed files with 1093 additions and 953 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenloader/intern/writefile.cc
View File

@@ -1492,7 +1492,7 @@ static bool write_file_handle(Main *mainvar,
*
* Note that we *borrow* the pointer to 'DNAstr',
* so writing each time uses the same address and doesn't cause unnecessary undo overhead. */
writedata(wd, BLO_CODE_DNA1, size_t(wd->sdna->data_len), wd->sdna->data);
writedata(wd, BLO_CODE_DNA1, size_t(wd->sdna->data_size), wd->sdna->data);
/* End of file. */
memset(&bhead, 0, sizeof(BHead));

58
source/blender/makesdna/DNA_genfile.h
View File

@@ -96,24 +96,24 @@ struct DNA_ReconstructInfo *DNA_reconstruct_info_create(const struct SDNA *oldsd
void DNA_reconstruct_info_free(struct DNA_ReconstructInfo *reconstruct_info);
/**
* \param index_last: Support faster lookups when there is the possibility
* \param struct_index_last: Support faster lookups when there is the possibility
* of the same name being looked up multiple times. Initialize to `UINT_MAX`.
*
* \return the index of the struct or -1 on failure.
*/
int DNA_struct_find_with_alias_ex(const struct SDNA *sdna,
const char *str,
unsigned int *index_last);
int DNA_struct_find_index_with_alias_ex(const struct SDNA *sdna,
const char *str,
unsigned int *struct_index_last);
/** \note prefer #DNA_struct_find_with_alias_ex unless there is a good reason not to. */
int DNA_struct_find_without_alias_ex(const struct SDNA *sdna,
const char *str,
unsigned int *index_last);
int DNA_struct_find_index_without_alias_ex(const struct SDNA *sdna,
const char *str,
unsigned int *struct_index_last);
/**
* \return the index of the struct or -1 on failure.
*/
int DNA_struct_find_with_alias(const struct SDNA *sdna, const char *str);
/** \note prefer #DNA_struct_find_with_alias unless there is a good reason not to. */
int DNA_struct_find_without_alias(const struct SDNA *sdna, const char *str);
int DNA_struct_find_index_without_alias(const struct SDNA *sdna, const char *str);
/**
* A convenience function, the equivalent of: `DNA_struct_find_with_alias(..) != -1`
@@ -141,7 +141,7 @@ bool DNA_struct_member_exists_without_alias(const struct SDNA *sdna,
* \param struct_nr: Index of struct info within sdna
* \param data: Struct data that is to be converted
*/
void DNA_struct_switch_endian(const struct SDNA *sdna, int struct_nr, char *data);
void DNA_struct_switch_endian(const struct SDNA *sdna, int struct_index, char *data);
/**
* Constructs and returns an array of byte flags with one element for each struct in oldsdna,
* indicating how it compares to newsdna.
@@ -149,14 +149,14 @@ void DNA_struct_switch_endian(const struct SDNA *sdna, int struct_nr, char *data
const char *DNA_struct_get_compareflags(const struct SDNA *sdna, const struct SDNA *newsdna);
/**
* \param reconstruct_info: Information preprocessed by #DNA_reconstruct_info_create.
* \param old_struct_nr: Index of struct info within oldsdna.
* \param old_struct_index: Index of struct info within oldsdna.
* \param blocks: The number of array elements.
* \param old_blocks: Array of struct data.
* \param alloc_name: String to pass to the allocation calls for reconstructed data.
* \return An allocated reconstructed struct.
*/
void *DNA_struct_reconstruct(const struct DNA_ReconstructInfo *reconstruct_info,
int old_struct_nr,
int old_struct_index,
int blocks,
const void *old_blocks,
const char *alloc_name);
@@ -179,13 +179,13 @@ int DNA_struct_member_offset_by_name_with_alias(const struct SDNA *sdna,
const char *name);
/**
* Returns the size of struct fields of the specified type and name.
* Returns the size of struct fields of the specified type and member_index.
*
* \param type: Index into sdna->types/types_size
* \param name: Index into sdna->names,
* needed to extract possible pointer/array information.
* \param member_index: Index into sdna->names, needed to extract possible pointer/array
* information.
*/
int DNA_struct_member_size(const struct SDNA *sdna, short type, short name);
int DNA_struct_member_size(const struct SDNA *sdna, short type, short member_index);
/**
* Returns the size in bytes of a primitive type.
@@ -202,7 +202,7 @@ int DNA_struct_size(const struct SDNA *sdna, int struct_index);
/**
* Get the alignment that should be used when allocating memory for this type.
*/
int DNA_struct_alignment(const struct SDNA *sdna, int struct_nr);
int DNA_struct_alignment(const struct SDNA *sdna, int struct_index);
/**
* Return the current (alias) type name of the given struct index.
@@ -210,20 +210,28 @@ int DNA_struct_alignment(const struct SDNA *sdna, int struct_nr);
const char *DNA_struct_identifier(struct SDNA *sdna, int struct_index);
/**
* Rename a struct
* Find the struct matching the given `old_type_name`, and rename its type (referenced by its
* #SDNA_Struct.type_index) to the given `new_type_name`.
*
* WARNING: Deprecated, do not use in new code. Only used to version some renaming done during
* early 2.80 development.
*/
bool DNA_sdna_patch_struct_by_name(struct SDNA *sdna,
const char *struct_name_old,
const char *struct_name_new);
const char *old_type_name,
const char *new_type_name);
/**
* Replace \a elem_old with \a elem_new for struct \a struct_name
* handles search & replace, maintaining surrounding non-identifier characters
* such as pointer & array size.
* Rename \a old_member_name with \a new_member_name for struct matching \a type_name.
*
* Handles search & replace, maintaining surrounding non-identifier characters such as pointer &
* array size.
*
* WARNING: Deprecated, do not use in new code. Only used to version some renaming done during
* early 2.80 development.
*/
bool DNA_sdna_patch_struct_member_by_name(struct SDNA *sdna,
const char *struct_name,
const char *elem_old,
const char *elem_new);
const char *type_name,
const char *old_member_name,
const char *new_member_name);
void DNA_sdna_alias_data_ensure(struct SDNA *sdna);

7
source/blender/makesdna/DNA_listBase.h
View File

@@ -23,7 +23,12 @@ typedef struct LinkData {
void *data;
} LinkData;
/** Never change the size of this! dna_genfile.cc detects pointer_size with it. */
/**
* The basic double linked-list structure.
*
* \warning Never change the size/definition of this struct! The #init_structDNA
* function (from dna_genfile.cc) uses it to compute the #pointer_size.
*/
typedef struct ListBase {
void *first, *last;
} ListBase;

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

@@ -15,9 +15,9 @@ typedef struct SDNA_StructMember {
/** This struct must not change, it's only a convenience view for raw data stored in SDNA. */
/** An index into SDNA->types. */
short type;
/** An index into SDNA->names. */
short name;
short type_index;
/** An index into SDNA->members. */
short member_index;
} SDNA_StructMember;
#
@@ -26,9 +26,9 @@ typedef struct SDNA_Struct {
/** This struct must not change, it's only a convenience view for raw data stored in SDNA. */
/** An index into SDNA->types. */
short type;
short type_index;
/** The amount of members in this struct. */
short members_len;
short members_num;
/** "Flexible array member" that contains information about all members of this struct. */
SDNA_StructMember members[];
} SDNA_Struct;
@@ -36,57 +36,99 @@ typedef struct SDNA_Struct {
#
#
typedef struct SDNA {
/** Full copy of 'encoded' data (when data_alloc is set, otherwise borrowed). */
/** The 'encoded' data (full copy when #data_alloc is set, otherwise borrowed memory). */
const char *data;
/** Length of data. */
int data_len;
/** Length of #data, in bytes. */
int data_size;
bool data_alloc;
/** Total number of struct members. */
int names_len, names_len_alloc;
/** Struct member names. */
const char **names;
/** Result of #DNA_elem_array_size (aligned with #names). */
short *names_array_len;
/** Size of a pointer in bytes. */
int pointer_size;
/* ***** Start of SDNA types. ***** */
/**
* This covers all known types (basic and structs ones) from SDNA.
*
* NOTE: This data is not in sync with the SDNA #structs info below. Among other things:
* - Basic types (int, float, etc.) have _no_ matching struct definitions currently.
* - Types can be discovered and added before their struct definition, when they are used for
* members of another struct which gets parsed first.
*/
/** Number of types. */
int types_num;
/** Type names. */
const char **types;
/** Number of basic types + struct types. */
int types_len;
/** Type lengths. */
short *types_size;
/** Information about structs and their members. */
SDNA_Struct **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;
/** Temporary memory currently only used for version patching DNA. */
struct MemArena *mem_arena;
/** Runtime versions of data stored in DNA, lazy initialized,
* only different when renaming is done. */
struct {
/** Aligned with #SDNA.names, same pointers when unchanged. */
const char **names;
/** Aligned with #SDNA.types, same pointers when unchanged. */
const char **types;
/** A version of #SDNA.structs_map that uses #SDNA.alias.types for its keys. */
struct GHash *structs_map;
} alias;
/**
* Alignment used when allocating pointers to this type. The actual minimum alignment of the
* type may be lower in some cases. For example, the pointer alignment of a single char is at
* least 8 bytes, but the alignment of the type itself is 1.
*/
int *types_alignment;
/* ***** End of SDNA types. ***** */
/* ***** Start of SDNA structs. ***** */
/**
* This covers all known structs from SDNA (pointers to #SDNA_Struct data).
*
* NOTE: See comment above about SDNA types above for differences between structs and types
* definitions.
*/
/** Number of struct definitions. */
int structs_num;
/** Information about structs and their members. */
SDNA_Struct **structs;
/* ***** End of SDNA structs. ***** */
/* ***** Start of SDNA struct members. ***** */
/** Total number of struct members. */
int members_num;
/**
* Contains the number of allocated items in both #members and #members_array_num arrays below.
*
* Typically same as #members_len, unless after versionning DNA info (these arrays are
* reallocated by chunks, see #DNA_sdna_patch_struct_member).
*/
int members_num_alloc;
/** Struct member names. */
const char **members;
/**
* Aligned with #members. The total number of items in the array defined by the matching member,
* if any, otherwise 1.
*
* Result of #DNA_member_array_num.
*/
short *members_array_num;
/* ***** End of SDNA struct members. ***** */
/**
* Mapping between type names (from #types array above) and struct indices (into #structs array
* above).
*
* Requires WITH_DNA_GHASH to be used for now.
*/
struct GHash *types_to_structs_map;
/**
* Runtime versions of data stored in DNA, lazy initialized, only different when renaming is
* done.
*
* Contains mapping from original (static) types/members names to their current (alias)
* DNA-defined versions (i.e. results from calling #DNA_alias_maps with
* #DNA_RENAME_ALIAS_FROM_STATIC).
*/
struct {
/** Aligned with #SDNA.types, same pointers when unchanged. */
const char **types;
/** Aligned with #SDNA.members, same pointers when unchanged. */
const char **members;
/** A version of #SDNA.types_to_structs_map that uses #SDNA.alias.types for its keys. */
struct GHash *types_to_structs_map;
} alias;
/** Temporary memory currently only used for version patching DNA. */
struct MemArena *mem_arena;
} SDNA;
#

715
source/blender/makesdna/intern/dna_genfile.cc
View File

@@ -129,15 +129,15 @@ void DNA_sdna_free(SDNA *sdna)
MEM_freeN((void *)sdna->data);
}
MEM_freeN((void *)sdna->names);
MEM_freeN((void *)sdna->names_array_len);
MEM_freeN((void *)sdna->members);
MEM_freeN((void *)sdna->members_array_num);
MEM_freeN((void *)sdna->types);
MEM_freeN(sdna->structs);
MEM_freeN(sdna->types_alignment);
#ifdef WITH_DNA_GHASH
if (sdna->structs_map) {
BLI_ghash_free(sdna->structs_map, nullptr, nullptr);
if (sdna->types_to_structs_map) {
BLI_ghash_free(sdna->types_to_structs_map, nullptr, nullptr);
}
#endif
@@ -145,11 +145,11 @@ void DNA_sdna_free(SDNA *sdna)
BLI_memarena_free(sdna->mem_arena);
}
MEM_SAFE_FREE(sdna->alias.names);
MEM_SAFE_FREE(sdna->alias.members);
MEM_SAFE_FREE(sdna->alias.types);
#ifdef WITH_DNA_GHASH
if (sdna->alias.structs_map) {
BLI_ghash_free(sdna->alias.structs_map, nullptr, nullptr);
if (sdna->alias.types_to_structs_map) {
BLI_ghash_free(sdna->alias.types_to_structs_map, nullptr, nullptr);
}
#endif
@@ -158,7 +158,7 @@ void DNA_sdna_free(SDNA *sdna)
int DNA_struct_size(const SDNA *sdna, int struct_index)
{
return sdna->types_size[sdna->structs[struct_index]->type];
return sdna->types_size[sdna->structs[struct_index]->type_index];
}
/**
@@ -170,30 +170,30 @@ static bool ispointer(const char *name)
return (name[0] == '*' || (name[0] == '(' && name[1] == '*'));
}
int DNA_struct_member_size(const SDNA *sdna, short type, short name)
int DNA_struct_member_size(const SDNA *sdna, short type, short member_index)
{
const char *cp = sdna->names[name];
const char *cp = sdna->members[member_index];
int len = 0;
/* is it a pointer or function pointer? */
if (ispointer(cp)) {
/* has the name an extra length? (array) */
len = sdna->pointer_size * sdna->names_array_len[name];
len = sdna->pointer_size * sdna->members_array_num[member_index];
}
else if (sdna->types_size[type]) {
/* has the name an extra length? (array) */
len = int(sdna->types_size[type]) * sdna->names_array_len[name];
len = int(sdna->types_size[type]) * sdna->members_array_num[member_index];
}
return len;
}
#if 0
static void printstruct(SDNA *sdna, short strnr)
static void printstruct(SDNA *sdna, short struct_index)
{
/* is for debug */
SDNA_Struct *struct_info = sdna->structs[strnr];
SDNA_Struct *struct_info = sdna->structs[struct_index];
printf("struct %s\n", sdna->types[struct_info->type]);
for (int b = 0; b < struct_info->members_len; b++) {
@@ -206,42 +206,42 @@ static void printstruct(SDNA *sdna, short strnr)
/**
* Returns the index of the struct info for the struct with the specified name.
*/
static int dna_struct_find_nr_ex_impl(
static int dna_struct_find_index_ex_impl(
/* From SDNA struct. */
const char **types,
const int /*types_len*/,
const int /*types_num*/,
SDNA_Struct **const structs,
const int structs_len,
const int structs_num,
#ifdef WITH_DNA_GHASH
GHash *structs_map,
#endif
/* Regular args. */
const char *str,
uint *index_last)
uint *struct_index_last)
{
if (*index_last < structs_len) {
const SDNA_Struct *struct_info = structs[*index_last];
if (STREQ(types[struct_info->type], str)) {
return *index_last;
if (*struct_index_last < structs_num) {
const SDNA_Struct *struct_info = structs[*struct_index_last];
if (STREQ(types[struct_info->type_index], str)) {
return *struct_index_last;
}
}
#ifdef WITH_DNA_GHASH
{
void **index_p = BLI_ghash_lookup_p(structs_map, str);
if (index_p) {
const int index = POINTER_AS_INT(*index_p);
*index_last = index;
return index;
void **struct_index_p = BLI_ghash_lookup_p(structs_map, str);
if (struct_index_p) {
const int struct_index = POINTER_AS_INT(*struct_index_p);
*struct_index_last = struct_index;
return struct_index;
}
}
#else
{
for (int index = 0; index < structs_len; index++) {
const SDNA_Struct *struct_info = structs[index];
for (int struct_index = 0; struct_index < types_num; struct_index++) {
const SDNA_Struct *struct_info = structs[struct_index];
if (STREQ(types[struct_info->type], str)) {
*index_last = index;
return index;
*struct_index_last = struct_index;
return struct_index;
}
}
}
@@ -249,51 +249,56 @@ static int dna_struct_find_nr_ex_impl(
return -1;
}
int DNA_struct_find_without_alias_ex(const SDNA *sdna, const char *str, uint *index_last)
int DNA_struct_find_index_without_alias_ex(const SDNA *sdna,
const char *str,
uint *struct_index_last)
{
return dna_struct_find_nr_ex_impl(
#ifdef WITH_DNA_GHASH
BLI_assert(sdna->types_to_structs_map != nullptr);
#endif
return dna_struct_find_index_ex_impl(
/* Expand SDNA. */
sdna->types,
sdna->types_len,
sdna->types_num,
sdna->structs,
sdna->structs_len,
sdna->structs_num,
#ifdef WITH_DNA_GHASH
sdna->structs_map,
sdna->types_to_structs_map,
#endif
/* Regular args. */
str,
index_last);
struct_index_last);
}
int DNA_struct_find_with_alias_ex(const SDNA *sdna, const char *str, uint *index_last)
int DNA_struct_find_index_with_alias_ex(const SDNA *sdna, const char *str, uint *struct_index_last)
{
#ifdef WITH_DNA_GHASH
BLI_assert(sdna->alias.structs_map != nullptr);
BLI_assert(sdna->alias.types_to_structs_map != nullptr);
#endif
return dna_struct_find_nr_ex_impl(
return dna_struct_find_index_ex_impl(
/* Expand SDNA. */
sdna->alias.types,
sdna->types_len,
sdna->types_num,
sdna->structs,
sdna->structs_len,
sdna->structs_num,
#ifdef WITH_DNA_GHASH
sdna->alias.structs_map,
sdna->alias.types_to_structs_map,
#endif
/* Regular args. */
str,
index_last);
struct_index_last);
}
int DNA_struct_find_without_alias(const SDNA *sdna, const char *str)
int DNA_struct_find_index_without_alias(const SDNA *sdna, const char *str)
{
uint index_last_dummy = UINT_MAX;
return DNA_struct_find_without_alias_ex(sdna, str, &index_last_dummy);
return DNA_struct_find_index_without_alias_ex(sdna, str, &index_last_dummy);
}
int DNA_struct_find_with_alias(const SDNA *sdna, const char *str)
{
uint index_last_dummy = UINT_MAX;
return DNA_struct_find_with_alias_ex(sdna, str, &index_last_dummy);
return DNA_struct_find_index_with_alias_ex(sdna, str, &index_last_dummy);
}
bool DNA_struct_exists_with_alias(const SDNA *sdna, const char *str)
@@ -315,16 +320,16 @@ BLI_INLINE const char *pad_up_4(const char *ptr)
*/
static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error_message)
{
int gravity_fix = -1;
int member_index_gravity_fix = -1;
int *data = (int *)sdna->data;
/* Clear pointers in case of error. */
sdna->names = nullptr;
sdna->members = nullptr;
sdna->types = nullptr;
sdna->structs = nullptr;
#ifdef WITH_DNA_GHASH
sdna->structs_map = nullptr;
sdna->types_to_structs_map = nullptr;
#endif
sdna->mem_arena = nullptr;
@@ -344,15 +349,15 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
if (*data == MAKE_ID('N', 'A', 'M', 'E')) {
data++;
sdna->names_len = *data;
sdna->members_num = *data;
if (do_endian_swap) {
BLI_endian_switch_int32(&sdna->names_len);
BLI_endian_switch_int32(&sdna->members_num);
}
sdna->names_len_alloc = sdna->names_len;
sdna->members_num_alloc = sdna->members_num;
data++;
sdna->names = static_cast<const char **>(
MEM_callocN(sizeof(void *) * sdna->names_len, "sdnanames"));
sdna->members = static_cast<const char **>(
MEM_callocN(sizeof(void *) * sdna->members_num, "sdnanames"));
}
else {
*r_error_message = "NAME error in SDNA file";
@@ -360,16 +365,16 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
}
cp = (char *)data;
for (int nr = 0; nr < sdna->names_len; nr++) {
sdna->names[nr] = cp;
for (int member_index = 0; member_index < sdna->members_num; member_index++) {
sdna->members[member_index] = cp;
/* "float gravity [3]" was parsed wrong giving both "gravity" and
* "[3]" members. we rename "[3]", and later set the type of
* "gravity" to "void" so the offsets work out correct */
if (*cp == '[' && STREQ(cp, "[3]")) {
if (nr && STREQ(sdna->names[nr - 1], "Cvi")) {
sdna->names[nr] = "gravity[3]";
gravity_fix = nr;
if (member_index && STREQ(sdna->members[member_index - 1], "Cvi")) {
sdna->members[member_index] = "gravity[3]";
member_index_gravity_fix = member_index;
}
}
while (*cp) {
@@ -385,14 +390,14 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
if (*data == MAKE_ID('T', 'Y', 'P', 'E')) {
data++;
sdna->types_len = *data;
sdna->types_num = *data;
if (do_endian_swap) {
BLI_endian_switch_int32(&sdna->types_len);
BLI_endian_switch_int32(&sdna->types_num);
}
data++;
sdna->types = static_cast<const char **>(
MEM_callocN(sizeof(void *) * sdna->types_len, "sdnatypes"));
MEM_callocN(sizeof(void *) * sdna->types_num, "sdnatypes"));
}
else {
*r_error_message = "TYPE error in SDNA file";
@@ -400,9 +405,9 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
}
cp = (char *)data;
for (int nr = 0; nr < sdna->types_len; nr++) {
for (int type_index = 0; type_index < sdna->types_num; type_index++) {
/* WARNING! See: DNA_struct_rename_legacy_hack_static_from_alias docs. */
sdna->types[nr] = DNA_struct_rename_legacy_hack_static_from_alias(cp);
sdna->types[type_index] = DNA_struct_rename_legacy_hack_static_from_alias(cp);
while (*cp) {
cp++;
}
@@ -420,17 +425,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->types_len);
BLI_endian_switch_int16_array(sp, sdna->types_num);
}
sp += sdna->types_len;
sp += sdna->types_num;
}
else {
*r_error_message = "TLEN error in SDNA file";
return false;
}
/* prevent BUS error */
if (sdna->types_len & 1) {
if (sdna->types_num & 1) {
sp++;
}
@@ -439,14 +444,14 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
if (*data == MAKE_ID('S', 'T', 'R', 'C')) {
data++;
sdna->structs_len = *data;
sdna->structs_num = *data;
if (do_endian_swap) {
BLI_endian_switch_int32(&sdna->structs_len);
BLI_endian_switch_int32(&sdna->structs_num);
}
data++;
sdna->structs = static_cast<SDNA_Struct **>(
MEM_callocN(sizeof(SDNA_Struct *) * sdna->structs_len, "sdnastrcs"));
MEM_callocN(sizeof(SDNA_Struct *) * sdna->structs_num, "sdnastrcs"));
}
else {
*r_error_message = "STRC error in SDNA file";
@@ -454,28 +459,28 @@ static bool init_structDNA(SDNA *sdna, bool do_endian_swap, const char **r_error
}
sp = (short *)data;
for (int nr = 0; nr < sdna->structs_len; nr++) {
for (int struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
SDNA_Struct *struct_info = (SDNA_Struct *)sp;
sdna->structs[nr] = struct_info;
sdna->structs[struct_index] = struct_info;
if (do_endian_swap) {
BLI_endian_switch_int16(&struct_info->type);
BLI_endian_switch_int16(&struct_info->members_len);
BLI_endian_switch_int16(&struct_info->type_index);
BLI_endian_switch_int16(&struct_info->members_num);
for (short a = 0; a < struct_info->members_len; a++) {
for (short a = 0; a < struct_info->members_num; a++) {
SDNA_StructMember *member = &struct_info->members[a];
BLI_endian_switch_int16(&member->type);
BLI_endian_switch_int16(&member->name);
BLI_endian_switch_int16(&member->type_index);
BLI_endian_switch_int16(&member->member_index);
}
}
sp += 2 + (sizeof(SDNA_StructMember) / sizeof(short)) * struct_info->members_len;
sp += 2 + (sizeof(SDNA_StructMember) / sizeof(short)) * struct_info->members_num;
}
{
/* second part of gravity problem, setting "gravity" type to void */
if (gravity_fix > -1) {
for (int nr = 0; nr < sdna->structs_len; nr++) {
sp = (short *)sdna->structs[nr];
if (member_index_gravity_fix > -1) {
for (int struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
sp = (short *)sdna->structs[struct_index];
if (STREQ(sdna->types[sp[0]], "ClothSimSettings")) {
sp[10] = SDNA_TYPE_VOID;
}
@@ -486,61 +491,72 @@ 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->structs_len);
sdna->types_to_structs_map = BLI_ghash_str_new_ex("init_structDNA gh", sdna->structs_num);
for (intptr_t nr = 0; nr < sdna->structs_len; nr++) {
SDNA_Struct *struct_info = sdna->structs[nr];
BLI_ghash_insert(
sdna->structs_map, (void *)sdna->types[struct_info->type], POINTER_FROM_INT(nr));
for (intptr_t struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
SDNA_Struct *struct_info = sdna->structs[struct_index];
BLI_ghash_insert(sdna->types_to_structs_map,
(void *)sdna->types[struct_info->type_index],
POINTER_FROM_INT(struct_index));
}
}
#endif
/* Calculate 'sdna->pointer_size' */
/* Calculate 'sdna->pointer_size'.
*
* NOTE: Cannot just do `sizeof(void *)` here, since the current DNA may come from a blendfile
* saved on a different system, using a different pointer size. So instead, use half the size of
* the #ListBase struct (only made of two pointers).
*/
{
const int nr = DNA_struct_find_without_alias(sdna, "ListBase");
const int struct_index = DNA_struct_find_index_without_alias(sdna, "ListBase");
/* should never happen, only with corrupt file for example */
if (UNLIKELY(nr == -1)) {
/* Should never happen, only with corrupt file for example. */
if (UNLIKELY(struct_index == -1)) {
*r_error_message = "ListBase struct error! Not found.";
return false;
}
/* finally pointer_size: use struct #ListBase to test it, never change the size of it! */
const SDNA_Struct *struct_info = sdna->structs[nr];
/* Weird; I have no memory of that... I think I used `sizeof(void *)` before... (ton). */
const SDNA_Struct *struct_info = sdna->structs[struct_index];
sdna->pointer_size = sdna->types_size[struct_info->type_index] / 2;
sdna->pointer_size = sdna->types_size[struct_info->type] / 2;
if (struct_info->members_len != 2 || !ELEM(sdna->pointer_size, 4, 8)) {
*r_error_message = "ListBase struct error! Needs it to calculate pointer-size.";
/* Well, at least `sizeof(ListBase)` is error proof! (ton). */
/* Should never fail, double-check that #ListBase struct is still what is should be (akak a
* couple of pointers and nothing else). */
if (UNLIKELY(struct_info->members_num != 2 || !ELEM(sdna->pointer_size, 4, 8))) {
*r_error_message = "ListBase struct error: invalid computed pointer-size.";
return false;
}
}
/* Cache name size. */
{
short *names_array_len = static_cast<short int *>(
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]);
short *members_array_num = static_cast<short int *>(
MEM_mallocN(sizeof(*members_array_num) * sdna->members_num, __func__));
for (int member_index = 0; member_index < sdna->members_num; member_index++) {
members_array_num[member_index] = DNA_member_array_num(sdna->members[member_index]);
}
sdna->names_array_len = names_array_len;
sdna->members_array_num = members_array_num;
}
sdna->types_alignment = static_cast<int *>(
MEM_malloc_arrayN(sdna->types_len, sizeof(int), __func__));
for (int i = 0; i < sdna->types_len; i++) {
sdna->types_alignment[i] = int(__STDCPP_DEFAULT_NEW_ALIGNMENT__);
MEM_malloc_arrayN(sdna->types_num, sizeof(int), __func__));
for (int type_index = 0; type_index < sdna->types_num; type_index++) {
sdna->types_alignment[type_index] = int(__STDCPP_DEFAULT_NEW_ALIGNMENT__);
}
{
/* TODO: This should be generalized at some point. We should be able to specify `overaligned`
* types directly in the DNA struct definitions. */
uint dummy_index = 0;
const int mat4x4f_nr = DNA_struct_find_without_alias_ex(sdna, "mat4x4f", &dummy_index);
if (mat4x4f_nr >= 0) {
sdna->types_alignment[mat4x4f_nr] = alignof(blender::float4x4);
const int mat4x4f_struct_index = DNA_struct_find_index_without_alias_ex(
sdna, "mat4x4f", &dummy_index);
if (mat4x4f_struct_index >= 0) {
#if 0 /* FIXME: This is using the wrong index. Code should be: */
SDNA_Struct *struct_info = sdna->structs[mat4x4f_struct_index];
const int mat4x4f_type_index = struct_info->type_index;
sdna->types_alignment[mat4x4f_type_index] = alignof(blender::float4x4);
#else
sdna->types_alignment[mat4x4f_struct_index] = alignof(blender::float4x4);
#endif
}
}
@@ -557,7 +573,7 @@ SDNA *DNA_sdna_from_data(const void *data,
SDNA *sdna = static_cast<SDNA *>(MEM_mallocN(sizeof(*sdna), "sdna"));
const char *error_message = nullptr;
sdna->data_len = data_len;
sdna->data_size = data_len;
if (data_alloc) {
char *data_copy = static_cast<char *>(MEM_mallocN(data_len, "sdna_data"));
memcpy(data_copy, data, data_len);
@@ -629,9 +645,9 @@ static void set_compare_flags_for_struct(const SDNA *oldsdna,
}
SDNA_Struct *old_struct = oldsdna->structs[old_struct_index];
const char *struct_name = oldsdna->types[old_struct->type];
const char *struct_name = oldsdna->types[old_struct->type_index];
const int new_struct_index = DNA_struct_find_without_alias(newsdna, struct_name);
const int new_struct_index = DNA_struct_find_index_without_alias(newsdna, struct_name);
if (new_struct_index == -1) {
/* Didn't find a matching new struct, so it has been removed. */
compare_flags[old_struct_index] = SDNA_CMP_REMOVED;
@@ -639,32 +655,32 @@ static void set_compare_flags_for_struct(const SDNA *oldsdna,
}
SDNA_Struct *new_struct = newsdna->structs[new_struct_index];
if (old_struct->members_len != new_struct->members_len) {
if (old_struct->members_num != new_struct->members_num) {
/* Structs with a different amount of members are not equal. */
compare_flags[old_struct_index] = SDNA_CMP_NOT_EQUAL;
return;
}
if (oldsdna->types_size[old_struct->type] != newsdna->types_size[new_struct->type]) {
if (oldsdna->types_size[old_struct->type_index] != newsdna->types_size[new_struct->type_index]) {
/* Structs that don't have the same size are not equal. */
compare_flags[old_struct_index] = SDNA_CMP_NOT_EQUAL;
return;
}
/* Compare each member individually. */
for (int member_index = 0; member_index < old_struct->members_len; member_index++) {
for (int member_index = 0; member_index < old_struct->members_num; member_index++) {
const SDNA_StructMember *old_member = &old_struct->members[member_index];
const SDNA_StructMember *new_member = &new_struct->members[member_index];
const char *old_type_name = oldsdna->types[old_member->type];
const char *new_type_name = newsdna->types[new_member->type];
const char *old_type_name = oldsdna->types[old_member->type_index];
const char *new_type_name = newsdna->types[new_member->type_index];
if (!STREQ(old_type_name, new_type_name)) {
/* If two members have a different type in the same place, the structs are not equal. */
compare_flags[old_struct_index] = SDNA_CMP_NOT_EQUAL;
return;
}
const char *old_member_name = oldsdna->names[old_member->name];
const char *new_member_name = newsdna->names[new_member->name];
const char *old_member_name = oldsdna->members[old_member->member_index];
const char *new_member_name = newsdna->members[new_member->member_index];
if (!STREQ(old_member_name, new_member_name)) {
/* If two members have a different name in the same place, the structs are not equal. */
compare_flags[old_struct_index] = SDNA_CMP_NOT_EQUAL;
@@ -680,7 +696,8 @@ static void set_compare_flags_for_struct(const SDNA *oldsdna,
}
}
else {
const int old_member_struct_index = DNA_struct_find_without_alias(oldsdna, old_type_name);
const int old_member_struct_index = DNA_struct_find_index_without_alias(oldsdna,
old_type_name);
if (old_member_struct_index >= 0) {
set_compare_flags_for_struct(oldsdna, newsdna, compare_flags, old_member_struct_index);
if (compare_flags[old_member_struct_index] != SDNA_CMP_EQUAL) {
@@ -697,18 +714,18 @@ static void set_compare_flags_for_struct(const SDNA *oldsdna,
const char *DNA_struct_get_compareflags(const SDNA *oldsdna, const SDNA *newsdna)
{
if (oldsdna->structs_len == 0) {
if (oldsdna->structs_num == 0) {
printf("error: file without SDNA\n");
return nullptr;
}
char *compare_flags = static_cast<char *>(MEM_mallocN(oldsdna->structs_len, "compare flags"));
memset(compare_flags, SDNA_CMP_UNKNOWN, oldsdna->structs_len);
char *compare_flags = static_cast<char *>(MEM_mallocN(oldsdna->structs_num, "compare flags"));
memset(compare_flags, SDNA_CMP_UNKNOWN, oldsdna->structs_num);
/* Set correct flag for every struct. */
for (int a = 0; a < oldsdna->structs_len; a++) {
set_compare_flags_for_struct(oldsdna, newsdna, compare_flags, a);
BLI_assert(compare_flags[a] != SDNA_CMP_UNKNOWN);
for (int old_struct_index = 0; old_struct_index < oldsdna->structs_num; old_struct_index++) {
set_compare_flags_for_struct(oldsdna, newsdna, compare_flags, old_struct_index);
BLI_assert(compare_flags[old_struct_index] != SDNA_CMP_UNKNOWN);
}
/* First struct is `struct Link`, this is skipped in compare_flags (at index `0`).
@@ -926,10 +943,10 @@ static bool elem_exists_impl(
const SDNA_Struct *old)
{
/* in old is the old struct */
for (int a = 0; a < old->members_len; a++) {
for (int a = 0; a < old->members_num; a++) {
const SDNA_StructMember *member = &old->members[a];
const char *otype = types[member->type];
const char *oname = names[member->name];
const char *otype = types[member->type_index];
const char *oname = names[member->member_index];
if (elem_streq(name, oname)) { /* name equal */
return STREQ(type, otype); /* type equal */
@@ -949,7 +966,7 @@ static bool elem_exists_without_alias(const SDNA *sdna,
return elem_exists_impl(
/* Expand SDNA. */
sdna->types,
sdna->names,
sdna->members,
/* Regular args. */
type,
name,
@@ -964,7 +981,7 @@ static bool elem_exists_with_alias(const SDNA *sdna,
return elem_exists_impl(
/* Expand SDNA. */
sdna->alias.types,
sdna->alias.names,
sdna->alias.members,
/* Regular args. */
type,
name,
@@ -982,17 +999,17 @@ static int elem_offset_impl(const SDNA *sdna,
/* in old is the old struct */
int offset = 0;
for (int a = 0; a < old->members_len; a++) {
for (int a = 0; a < old->members_num; a++) {
const SDNA_StructMember *member = &old->members[a];
const char *otype = types[member->type];
const char *oname = names[member->name];
const char *otype = types[member->type_index];
const char *oname = names[member->member_index];
if (elem_streq(name, oname)) { /* name equal */
if (STREQ(type, otype)) { /* type equal */
return offset;
}
break; /* Fail below. */
}
offset += DNA_struct_member_size(sdna, member->type, member->name);
offset += DNA_struct_member_size(sdna, member->type_index, member->member_index);
}
return -1;
}
@@ -1017,7 +1034,7 @@ static int elem_offset_without_alias(const SDNA *sdna,
const char *name,
const SDNA_Struct *old)
{
return elem_offset_impl(sdna, sdna->types, sdna->names, type, name, old);
return elem_offset_impl(sdna, sdna->types, sdna->members, type, name, old);
}
/**
@@ -1028,7 +1045,7 @@ static int elem_offset_with_alias(const SDNA *sdna,
const char *name,
const SDNA_Struct *old)
{
return elem_offset_impl(sdna, sdna->alias.types, sdna->alias.names, type, name, old);
return elem_offset_impl(sdna, sdna->alias.types, sdna->alias.members, type, name, old);
}
/* Each struct member belongs to one of the categories below. */
@@ -1041,11 +1058,11 @@ enum eStructMemberCategory {
static eStructMemberCategory get_struct_member_category(const SDNA *sdna,
const SDNA_StructMember *member)
{
const char *member_name = sdna->names[member->name];
const char *member_name = sdna->members[member->member_index];
if (ispointer(member_name)) {
return STRUCT_MEMBER_CATEGORY_POINTER;
}
const char *member_type_name = sdna->types[member->type];
const char *member_type_name = sdna->types[member->type_index];
if (DNA_struct_exists_without_alias(sdna, member_type_name)) {
return STRUCT_MEMBER_CATEGORY_STRUCT;
}
@@ -1054,43 +1071,43 @@ static eStructMemberCategory get_struct_member_category(const SDNA *sdna,
static int get_member_size_in_bytes(const SDNA *sdna, const SDNA_StructMember *member)
{
const char *name = sdna->names[member->name];
const int array_length = sdna->names_array_len[member->name];
const char *name = sdna->members[member->member_index];
const int array_length = sdna->members_array_num[member->member_index];
if (ispointer(name)) {
return sdna->pointer_size * array_length;
}
const int type_size = sdna->types_size[member->type];
const int type_size = sdna->types_size[member->type_index];
return type_size * array_length;
}
void DNA_struct_switch_endian(const SDNA *sdna, int struct_nr, char *data)
void DNA_struct_switch_endian(const SDNA *sdna, int struct_index, char *data)
{
if (struct_nr == -1) {
if (struct_index == -1) {
return;
}
const SDNA_Struct *struct_info = sdna->structs[struct_nr];
const SDNA_Struct *struct_info = sdna->structs[struct_index];
int offset_in_bytes = 0;
for (int member_index = 0; member_index < struct_info->members_len; member_index++) {
for (int member_index = 0; member_index < struct_info->members_num; member_index++) {
const SDNA_StructMember *member = &struct_info->members[member_index];
const eStructMemberCategory member_category = get_struct_member_category(sdna, member);
char *member_data = data + offset_in_bytes;
const char *member_type_name = sdna->types[member->type];
const int member_array_length = sdna->names_array_len[member->name];
const char *member_type_name = sdna->types[member->type_index];
const int member_array_length = sdna->members_array_num[member->member_index];
switch (member_category) {
case STRUCT_MEMBER_CATEGORY_STRUCT: {
const int substruct_size = sdna->types_size[member->type];
const int substruct_nr = DNA_struct_find_without_alias(sdna, member_type_name);
BLI_assert(substruct_nr != -1);
const int substruct_size = sdna->types_size[member->type_index];
const int substruct_index = DNA_struct_find_index_without_alias(sdna, member_type_name);
BLI_assert(substruct_index != -1);
for (int a = 0; a < member_array_length; a++) {
DNA_struct_switch_endian(sdna, substruct_nr, member_data + a * substruct_size);
DNA_struct_switch_endian(sdna, substruct_index, member_data + a * substruct_size);
}
break;
}
case STRUCT_MEMBER_CATEGORY_PRIMITIVE: {
switch (member->type) {
switch (member->type_index) {
case SDNA_TYPE_SHORT:
case SDNA_TYPE_USHORT: {
BLI_endian_switch_int16_array((int16_t *)member_data, member_array_length);
@@ -1164,8 +1181,8 @@ struct ReconstructStep {
int old_offset;
int new_offset;
int array_len;
short old_struct_nr;
short new_struct_nr;
short old_struct_index;
short new_struct_index;
} substruct;
} data;
};
@@ -1196,12 +1213,12 @@ static void reconstruct_structs(const DNA_ReconstructInfo *reconstruct_info,
* \param new_block: Where to put converted struct contents.
*/
static void reconstruct_struct(const DNA_ReconstructInfo *reconstruct_info,
const int new_struct_nr,
const int new_struct_index,
const char *old_block,
char *new_block)
{
const ReconstructStep *steps = reconstruct_info->steps[new_struct_nr];
const int step_count = reconstruct_info->step_counts[new_struct_nr];
const ReconstructStep *steps = reconstruct_info->steps[new_struct_index];
const int step_count = reconstruct_info->step_counts[new_struct_index];
/* Execute all preprocessed steps. */
for (int a = 0; a < step_count; a++) {
@@ -1232,8 +1249,8 @@ static void reconstruct_struct(const DNA_ReconstructInfo *reconstruct_info,
case RECONSTRUCT_STEP_SUBSTRUCT:
reconstruct_structs(reconstruct_info,
step->data.substruct.array_len,
step->data.substruct.old_struct_nr,
step->data.substruct.new_struct_nr,
step->data.substruct.old_struct_index,
step->data.substruct.new_struct_index,
old_block + step->data.substruct.old_offset,
new_block + step->data.substruct.new_offset);
break;
@@ -1250,26 +1267,26 @@ static void reconstruct_struct(const DNA_ReconstructInfo *reconstruct_info,
/** Reconstructs an array of structs. */
static void reconstruct_structs(const DNA_ReconstructInfo *reconstruct_info,
const int blocks,
const int old_struct_nr,
const int new_struct_nr,
const int old_struct_index,
const int new_struct_index,
const char *old_blocks,
char *new_blocks)
{
const SDNA_Struct *old_struct = reconstruct_info->oldsdna->structs[old_struct_nr];
const SDNA_Struct *new_struct = reconstruct_info->newsdna->structs[new_struct_nr];
const SDNA_Struct *old_struct = reconstruct_info->oldsdna->structs[old_struct_index];
const SDNA_Struct *new_struct = reconstruct_info->newsdna->structs[new_struct_index];
const int old_block_size = reconstruct_info->oldsdna->types_size[old_struct->type];
const int new_block_size = reconstruct_info->newsdna->types_size[new_struct->type];
const int old_block_size = reconstruct_info->oldsdna->types_size[old_struct->type_index];
const int new_block_size = reconstruct_info->newsdna->types_size[new_struct->type_index];
for (int a = 0; a < blocks; a++) {
const char *old_block = old_blocks + a * old_block_size;
char *new_block = new_blocks + a * new_block_size;
reconstruct_struct(reconstruct_info, new_struct_nr, old_block, new_block);
reconstruct_struct(reconstruct_info, new_struct_index, old_block, new_block);
}
}
void *DNA_struct_reconstruct(const DNA_ReconstructInfo *reconstruct_info,
int old_struct_nr,
int old_struct_index,
int blocks,
const void *old_blocks,
const char *alloc_name)
@@ -1277,24 +1294,24 @@ void *DNA_struct_reconstruct(const DNA_ReconstructInfo *reconstruct_info,
const SDNA *oldsdna = reconstruct_info->oldsdna;
const SDNA *newsdna = reconstruct_info->newsdna;
const SDNA_Struct *old_struct = oldsdna->structs[old_struct_nr];
const char *type_name = oldsdna->types[old_struct->type];
const int new_struct_nr = DNA_struct_find_without_alias(newsdna, type_name);
const SDNA_Struct *old_struct = oldsdna->structs[old_struct_index];
const char *type_name = oldsdna->types[old_struct->type_index];
const int new_struct_index = DNA_struct_find_index_without_alias(newsdna, type_name);
if (new_struct_nr == -1) {
if (new_struct_index == -1) {
return nullptr;
}
const SDNA_Struct *new_struct = newsdna->structs[new_struct_nr];
const int new_block_size = newsdna->types_size[new_struct->type];
const SDNA_Struct *new_struct = newsdna->structs[new_struct_index];
const int new_block_size = newsdna->types_size[new_struct->type_index];
const int alignment = DNA_struct_alignment(newsdna, new_struct_nr);
const int alignment = DNA_struct_alignment(newsdna, new_struct_index);
char *new_blocks = static_cast<char *>(
MEM_calloc_arrayN_aligned(new_block_size, blocks, alignment, alloc_name));
reconstruct_structs(reconstruct_info,
blocks,
old_struct_nr,
new_struct_nr,
old_struct_index,
new_struct_index,
static_cast<const char *>(old_blocks),
new_blocks);
return new_blocks;
@@ -1307,9 +1324,9 @@ static const SDNA_StructMember *find_member_with_matching_name(const SDNA *sdna,
int *r_offset)
{
int offset = 0;
for (int a = 0; a < struct_info->members_len; a++) {
for (int a = 0; a < struct_info->members_num; a++) {
const SDNA_StructMember *member = &struct_info->members[a];
const char *member_name = sdna->names[member->name];
const char *member_name = sdna->members[member->member_index];
if (elem_streq(name, member_name)) {
*r_offset = offset;
return member;
@@ -1331,7 +1348,7 @@ static void init_reconstruct_step_for_member(const SDNA *oldsdna,
/* Find the matching old member. */
int old_member_offset;
const char *new_name = newsdna->names[new_member->name];
const char *new_name = newsdna->members[new_member->member_index];
const SDNA_StructMember *old_member = find_member_with_matching_name(
oldsdna, old_struct, new_name, &old_member_offset);
@@ -1352,30 +1369,32 @@ static void init_reconstruct_step_for_member(const SDNA *oldsdna,
return;
}
const int new_array_length = newsdna->names_array_len[new_member->name];
const int old_array_length = oldsdna->names_array_len[old_member->name];
const int new_array_length = newsdna->members_array_num[new_member->member_index];
const int old_array_length = oldsdna->members_array_num[old_member->member_index];
const int shared_array_length = std::min(new_array_length, old_array_length);
const char *new_type_name = newsdna->types[new_member->type];
const char *old_type_name = oldsdna->types[old_member->type];
const char *new_type_name = newsdna->types[new_member->type_index];
const char *old_type_name = oldsdna->types[old_member->type_index];
switch (new_category) {
case STRUCT_MEMBER_CATEGORY_STRUCT: {
if (STREQ(new_type_name, old_type_name)) {
const int old_struct_nr = DNA_struct_find_without_alias(oldsdna, old_type_name);
BLI_assert(old_struct_nr != -1);
enum eSDNA_StructCompare compare_flag = eSDNA_StructCompare(compare_flags[old_struct_nr]);
const int old_struct_index = DNA_struct_find_index_without_alias(oldsdna, old_type_name);
BLI_assert(old_struct_index != -1);
enum eSDNA_StructCompare compare_flag = eSDNA_StructCompare(
compare_flags[old_struct_index]);
BLI_assert(compare_flag != SDNA_CMP_REMOVED);
if (compare_flag == SDNA_CMP_EQUAL) {
/* The old and new members are identical, just do a #memcpy. */
r_step->type = RECONSTRUCT_STEP_MEMCPY;
r_step->data.memcpy.new_offset = new_member_offset;
r_step->data.memcpy.old_offset = old_member_offset;
r_step->data.memcpy.size = newsdna->types_size[new_member->type] * shared_array_length;
r_step->data.memcpy.size = newsdna->types_size[new_member->type_index] *
shared_array_length;
}
else {
const int new_struct_nr = DNA_struct_find_without_alias(newsdna, new_type_name);
BLI_assert(new_struct_nr != -1);
const int new_struct_index = DNA_struct_find_index_without_alias(newsdna, new_type_name);
BLI_assert(new_struct_index != -1);
/* The old and new members are different, use recursion to reconstruct the
* nested struct. */
@@ -1384,8 +1403,8 @@ static void init_reconstruct_step_for_member(const SDNA *oldsdna,
r_step->data.substruct.new_offset = new_member_offset;
r_step->data.substruct.old_offset = old_member_offset;
r_step->data.substruct.array_len = shared_array_length;
r_step->data.substruct.new_struct_nr = new_struct_nr;
r_step->data.substruct.old_struct_nr = old_struct_nr;
r_step->data.substruct.new_struct_index = new_struct_index;
r_step->data.substruct.old_struct_index = old_struct_index;
}
}
else {
@@ -1400,7 +1419,8 @@ static void init_reconstruct_step_for_member(const SDNA *oldsdna,
r_step->type = RECONSTRUCT_STEP_MEMCPY;
r_step->data.memcpy.new_offset = new_member_offset;
r_step->data.memcpy.old_offset = old_member_offset;
r_step->data.memcpy.size = newsdna->types_size[new_member->type] * shared_array_length;
r_step->data.memcpy.size = newsdna->types_size[new_member->type_index] *
shared_array_length;
}
else {
/* The old and new primitive types are different, cast from the old to new type. */
@@ -1408,8 +1428,8 @@ static void init_reconstruct_step_for_member(const SDNA *oldsdna,
r_step->data.cast_primitive.array_len = shared_array_length;
r_step->data.cast_primitive.new_offset = new_member_offset;
r_step->data.cast_primitive.old_offset = old_member_offset;
r_step->data.cast_primitive.new_type = eSDNA_Type(new_member->type);
r_step->data.cast_primitive.old_type = eSDNA_Type(old_member->type);
r_step->data.cast_primitive.new_type = eSDNA_Type(new_member->type_index);
r_step->data.cast_primitive.old_type = eSDNA_Type(old_member->type_index);
}
break;
}
@@ -1494,9 +1514,9 @@ static void init_reconstruct_step_for_member(const SDNA *oldsdna,
"length: %d",
step->data.substruct.old_offset,
step->data.substruct.new_offset,
step->data.substruct.new_struct_nr,
newsdna->types[newsdna->structs[step->data.substruct.new_struct_nr]->type],
newsdna->types_size[newsdna->structs[step->data.substruct.new_struct_nr]->type],
step->data.substruct.new_struct_index,
newsdna->types[newsdna->structs[step->data.substruct.new_struct_index]->type_index],
newsdna->types_size[newsdna->structs[step->data.substruct.new_struct_index]->type_index],
step->data.substruct.array_len);
break;
}
@@ -1514,10 +1534,10 @@ static ReconstructStep *create_reconstruct_steps_for_struct(const SDNA *oldsdna,
const SDNA_Struct *new_struct)
{
ReconstructStep *steps = static_cast<ReconstructStep *>(
MEM_calloc_arrayN(new_struct->members_len, sizeof(ReconstructStep), __func__));
MEM_calloc_arrayN(new_struct->members_num, sizeof(ReconstructStep), __func__));
int new_member_offset = 0;
for (int new_member_index = 0; new_member_index < new_struct->members_len; new_member_index++) {
for (int new_member_index = 0; new_member_index < new_struct->members_num; new_member_index++) {
const SDNA_StructMember *new_member = &new_struct->members[new_member_index];
init_reconstruct_step_for_member(oldsdna,
newsdna,
@@ -1585,29 +1605,29 @@ DNA_ReconstructInfo *DNA_reconstruct_info_create(const SDNA *oldsdna,
reconstruct_info->newsdna = newsdna;
reconstruct_info->compare_flags = compare_flags;
reconstruct_info->step_counts = static_cast<int *>(
MEM_malloc_arrayN(newsdna->structs_len, sizeof(int), __func__));
MEM_malloc_arrayN(newsdna->structs_num, sizeof(int), __func__));
reconstruct_info->steps = static_cast<ReconstructStep **>(
MEM_malloc_arrayN(newsdna->structs_len, sizeof(ReconstructStep *), __func__));
MEM_malloc_arrayN(newsdna->structs_num, sizeof(ReconstructStep *), __func__));
/* Generate reconstruct steps for all structs. */
for (int new_struct_nr = 0; new_struct_nr < newsdna->structs_len; new_struct_nr++) {
const SDNA_Struct *new_struct = newsdna->structs[new_struct_nr];
const char *new_struct_name = newsdna->types[new_struct->type];
const int old_struct_nr = DNA_struct_find_without_alias(oldsdna, new_struct_name);
if (old_struct_nr < 0) {
reconstruct_info->steps[new_struct_nr] = nullptr;
reconstruct_info->step_counts[new_struct_nr] = 0;
for (int new_struct_index = 0; new_struct_index < newsdna->structs_num; new_struct_index++) {
const SDNA_Struct *new_struct = newsdna->structs[new_struct_index];
const char *new_struct_name = newsdna->types[new_struct->type_index];
const int old_struct_index = DNA_struct_find_index_without_alias(oldsdna, new_struct_name);
if (old_struct_index < 0) {
reconstruct_info->steps[new_struct_index] = nullptr;
reconstruct_info->step_counts[new_struct_index] = 0;
continue;
}
const SDNA_Struct *old_struct = oldsdna->structs[old_struct_nr];
const SDNA_Struct *old_struct = oldsdna->structs[old_struct_index];
ReconstructStep *steps = create_reconstruct_steps_for_struct(
oldsdna, newsdna, compare_flags, old_struct, new_struct);
/* Comment the line below to skip the compression for debugging purposes. */
const int steps_len = compress_reconstruct_steps(steps, new_struct->members_len);
const int steps_len = compress_reconstruct_steps(steps, new_struct->members_num);
reconstruct_info->steps[new_struct_nr] = steps;
reconstruct_info->step_counts[new_struct_nr] = steps_len;
reconstruct_info->steps[new_struct_index] = steps;
reconstruct_info->step_counts[new_struct_index] = steps_len;
/* This is useful when debugging the reconstruct steps. */
#if 0
@@ -1625,9 +1645,11 @@ DNA_ReconstructInfo *DNA_reconstruct_info_create(const SDNA *oldsdna,
void DNA_reconstruct_info_free(DNA_ReconstructInfo *reconstruct_info)
{
for (int a = 0; a < reconstruct_info->newsdna->structs_len; a++) {
if (reconstruct_info->steps[a] != nullptr) {
MEM_freeN(reconstruct_info->steps[a]);
for (int new_struct_index = 0; new_struct_index < reconstruct_info->newsdna->structs_num;
new_struct_index++)
{
if (reconstruct_info->steps[new_struct_index] != nullptr) {
MEM_freeN(reconstruct_info->steps[new_struct_index]);
}
}
MEM_freeN(reconstruct_info->steps);
@@ -1640,10 +1662,10 @@ int DNA_struct_member_offset_by_name_without_alias(const SDNA *sdna,
const char *vartype,
const char *name)
{
const int SDNAnr = DNA_struct_find_without_alias(sdna, stype);
BLI_assert(SDNAnr != -1);
const SDNA_Struct *const spo = sdna->structs[SDNAnr];
return elem_offset_without_alias(sdna, vartype, name, spo);
const int struct_index = DNA_struct_find_index_without_alias(sdna, stype);
BLI_assert(struct_index != -1);
const SDNA_Struct *const struct_info = sdna->structs[struct_index];
return elem_offset_without_alias(sdna, vartype, name, struct_info);
}
int DNA_struct_member_offset_by_name_with_alias(const SDNA *sdna,
@@ -1651,15 +1673,15 @@ int DNA_struct_member_offset_by_name_with_alias(const SDNA *sdna,
const char *vartype,
const char *name)
{
const int SDNAnr = DNA_struct_find_with_alias(sdna, stype);
BLI_assert(SDNAnr != -1);
const SDNA_Struct *const spo = sdna->structs[SDNAnr];
return elem_offset_with_alias(sdna, vartype, name, spo);
const int struct_index = DNA_struct_find_with_alias(sdna, stype);
BLI_assert(struct_index != -1);
const SDNA_Struct *const struct_info = sdna->structs[struct_index];
return elem_offset_with_alias(sdna, vartype, name, struct_info);
}
bool DNA_struct_exists_without_alias(const SDNA *sdna, const char *stype)
{
return DNA_struct_find_without_alias(sdna, stype) != -1;
return DNA_struct_find_index_without_alias(sdna, stype) != -1;
}
bool DNA_struct_member_exists_without_alias(const SDNA *sdna,
@@ -1667,11 +1689,11 @@ bool DNA_struct_member_exists_without_alias(const SDNA *sdna,
const char *vartype,
const char *name)
{
const int SDNAnr = DNA_struct_find_without_alias(sdna, stype);
const int struct_index = DNA_struct_find_index_without_alias(sdna, stype);
if (SDNAnr != -1) {
const SDNA_Struct *const spo = sdna->structs[SDNAnr];
const bool found = elem_exists_without_alias(sdna, vartype, name, spo);
if (struct_index != -1) {
const SDNA_Struct *const struct_info = sdna->structs[struct_index];
const bool found = elem_exists_without_alias(sdna, vartype, name, struct_info);
if (found) {
return true;
@@ -1722,90 +1744,96 @@ int DNA_elem_type_size(const eSDNA_Type elem_nr)
return 8;
}
int DNA_struct_alignment(const SDNA *sdna, const int struct_nr)
int DNA_struct_alignment(const SDNA *sdna, const int struct_index)
{
return sdna->types_alignment[struct_nr];
return sdna->types_alignment[struct_index];
}
const char *DNA_struct_identifier(struct SDNA *sdna, const int struct_index)
{
DNA_sdna_alias_data_ensure(sdna);
const SDNA_Struct *struct_info = sdna->structs[struct_index];
return sdna->alias.types[struct_info->type];
return sdna->alias.types[struct_info->type_index];
}
/* -------------------------------------------------------------------- */
/** \name Version Patch DNA
* \{ */
static bool DNA_sdna_patch_struct(SDNA *sdna,
const int struct_name_old_nr,
const char *struct_name_new)
static bool DNA_sdna_patch_struct(SDNA *sdna, const int struct_index, const char *new_type_name)
{
BLI_assert(DNA_struct_find_without_alias(DNA_sdna_current_get(), struct_name_new) != -1);
const SDNA_Struct *struct_info = sdna->structs[struct_name_old_nr];
BLI_assert(DNA_struct_find_index_without_alias(DNA_sdna_current_get(), new_type_name) != -1);
const SDNA_Struct *struct_info = sdna->structs[struct_index];
#ifdef WITH_DNA_GHASH
BLI_ghash_remove(sdna->structs_map, (void *)sdna->types[struct_info->type], nullptr, nullptr);
BLI_ghash_remove(
sdna->types_to_structs_map, (void *)sdna->types[struct_info->type_index], nullptr, nullptr);
BLI_ghash_insert(
sdna->structs_map, (void *)struct_name_new, POINTER_FROM_INT(struct_name_old_nr));
sdna->types_to_structs_map, (void *)new_type_name, POINTER_FROM_INT(struct_index));
#endif
sdna->types[struct_info->type] = struct_name_new;
sdna->types[struct_info->type_index] = new_type_name;
return true;
}
bool DNA_sdna_patch_struct_by_name(SDNA *sdna,
const char *struct_name_old,
const char *struct_name_new)
const char *old_type_name,
const char *new_type_name)
{
const int struct_name_old_nr = DNA_struct_find_without_alias(sdna, struct_name_old);
if (struct_name_old_nr != -1) {
return DNA_sdna_patch_struct(sdna, struct_name_old_nr, struct_name_new);
const int struct_index = DNA_struct_find_index_without_alias(sdna, old_type_name);
if (struct_index != -1) {
return DNA_sdna_patch_struct(sdna, struct_index, new_type_name);
}
return false;
}
/* Make public if called often with same struct (avoid duplicate lookups). */
static bool DNA_sdna_patch_struct_member(SDNA *sdna,
const int struct_name_nr,
const char *elem_old,
const char *elem_new)
const int struct_index,
const char *old_member_name,
const char *new_member_name)
{
/* These names aren't handled here (it's not used).
* Ensure they are never used or we get out of sync arrays. */
BLI_assert(sdna->alias.names == nullptr);
const int elem_old_len = strlen(elem_old);
const int elem_new_len = strlen(elem_new);
BLI_assert(elem_new != nullptr);
SDNA_Struct *sp = sdna->structs[struct_name_nr];
for (int elem_index = sp->members_len; elem_index > 0; elem_index--) {
SDNA_StructMember *member = &sp->members[elem_index];
const char *elem_old_full = sdna->names[member->name];
/* Start & end offsets in 'elem_old_full'. */
uint elem_old_full_offset_start;
if (DNA_elem_id_match(elem_old, elem_old_len, elem_old_full, &elem_old_full_offset_start)) {
BLI_assert(sdna->alias.members == nullptr);
const int old_member_name_len = strlen(old_member_name);
const int new_member_name_len = strlen(new_member_name);
BLI_assert(new_member_name != nullptr);
SDNA_Struct *struct_info = sdna->structs[struct_index];
for (int struct_member_index = struct_info->members_num; struct_member_index > 0;
struct_member_index--)
{
SDNA_StructMember *member_info = &struct_info->members[struct_member_index];
const char *old_member_name_full = sdna->members[member_info->member_index];
/* Start & end offsets in #old_member_full. */
uint old_member_name_full_offset_start;
if (DNA_member_id_match(old_member_name,
old_member_name_len,
old_member_name_full,
&old_member_name_full_offset_start))
{
if (sdna->mem_arena == nullptr) {
sdna->mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
}
const char *elem_new_full = DNA_elem_id_rename(sdna->mem_arena,
elem_old,
elem_old_len,
elem_new,
elem_new_len,
elem_old_full,
strlen(elem_old_full),
elem_old_full_offset_start);
const char *new_member_name_full = DNA_member_id_rename(sdna->mem_arena,
old_member_name,
old_member_name_len,
new_member_name,
new_member_name_len,
old_member_name_full,
strlen(old_member_name_full),
old_member_name_full_offset_start);
if (sdna->names_len == sdna->names_len_alloc) {
sdna->names_len_alloc += 64;
sdna->names = static_cast<const char **>(
MEM_recallocN((void *)sdna->names, sizeof(*sdna->names) * sdna->names_len_alloc));
sdna->names_array_len = static_cast<short int *>(
MEM_recallocN((void *)sdna->names_array_len,
sizeof(*sdna->names_array_len) * sdna->names_len_alloc));
if (sdna->members_num == sdna->members_num_alloc) {
sdna->members_num_alloc += 64;
sdna->members = static_cast<const char **>(MEM_recallocN(
(void *)sdna->members, sizeof(*sdna->members) * sdna->members_num_alloc));
sdna->members_array_num = static_cast<short int *>(
MEM_recallocN((void *)sdna->members_array_num,
sizeof(*sdna->members_array_num) * sdna->members_num_alloc));
}
const short name_nr_prev = member->name;
member->name = sdna->names_len++;
sdna->names[member->name] = elem_new_full;
sdna->names_array_len[member->name] = sdna->names_array_len[name_nr_prev];
const short old_member_index = member_info->member_index;
member_info->member_index = sdna->members_num++;
sdna->members[member_info->member_index] = new_member_name_full;
sdna->members_array_num[member_info->member_index] =
sdna->members_array_num[old_member_index];
return true;
}
@@ -1813,13 +1841,13 @@ static bool DNA_sdna_patch_struct_member(SDNA *sdna,
return false;
}
bool DNA_sdna_patch_struct_member_by_name(SDNA *sdna,
const char *struct_name,
const char *elem_old,
const char *elem_new)
const char *type_name,
const char *old_member_name,
const char *new_member_name)
{
const int struct_name_nr = DNA_struct_find_without_alias(sdna, struct_name);
if (struct_name_nr != -1) {
return DNA_sdna_patch_struct_member(sdna, struct_name_nr, elem_old, elem_new);
const int struct_index = DNA_struct_find_index_without_alias(sdna, type_name);
if (struct_index != -1) {
return DNA_sdna_patch_struct_member(sdna, struct_index, old_member_name, new_member_name);
}
return false;
}
@@ -1841,9 +1869,9 @@ bool DNA_sdna_patch_struct_member_by_name(SDNA *sdna,
static void sdna_expand_names(SDNA *sdna)
{
int names_expand_len = 0;
for (int struct_nr = 0; struct_nr < sdna->structs_len; struct_nr++) {
const SDNA_Struct *struct_old = sdna->structs[struct_nr];
names_expand_len += struct_old->members_len;
for (int struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
const SDNA_Struct *struct_old = sdna->structs[struct_index];
names_expand_len += struct_old->members_num;
}
const char **names_expand = static_cast<const char **>(
MEM_mallocN(sizeof(*names_expand) * names_expand_len, __func__));
@@ -1851,35 +1879,36 @@ static void sdna_expand_names(SDNA *sdna)
MEM_mallocN(sizeof(*names_array_len_expand) * names_expand_len, __func__));
int names_expand_index = 0;
for (int struct_nr = 0; struct_nr < sdna->structs_len; struct_nr++) {
for (int struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
/* We can't edit this memory 'sdna->structs' points to (read-only `datatoc` file). */
const SDNA_Struct *struct_old = sdna->structs[struct_nr];
const SDNA_Struct *struct_old = sdna->structs[struct_index];
const int array_size = sizeof(short) * 2 + sizeof(SDNA_StructMember) * struct_old->members_len;
const int array_size = sizeof(short) * 2 + sizeof(SDNA_StructMember) * struct_old->members_num;
SDNA_Struct *struct_new = static_cast<SDNA_Struct *>(
BLI_memarena_alloc(sdna->mem_arena, array_size));
memcpy(struct_new, struct_old, array_size);
sdna->structs[struct_nr] = struct_new;
sdna->structs[struct_index] = struct_new;
for (int i = 0; i < struct_old->members_len; i++) {
for (int i = 0; i < struct_old->members_num; i++) {
const SDNA_StructMember *member_old = &struct_old->members[i];
SDNA_StructMember *member_new = &struct_new->members[i];
names_expand[names_expand_index] = sdna->names[member_old->name];
names_array_len_expand[names_expand_index] = sdna->names_array_len[member_old->name];
names_expand[names_expand_index] = sdna->members[member_old->member_index];
names_array_len_expand[names_expand_index] =
sdna->members_array_num[member_old->member_index];
BLI_assert(names_expand_index < SHRT_MAX);
member_new->name = names_expand_index;
member_new->member_index = names_expand_index;
names_expand_index++;
}
}
MEM_freeN((void *)sdna->names);
sdna->names = names_expand;
MEM_freeN((void *)sdna->members);
sdna->members = names_expand;
MEM_freeN((void *)sdna->names_array_len);
sdna->names_array_len = names_array_len_expand;
MEM_freeN((void *)sdna->members_array_num);
sdna->members_array_num = names_array_len_expand;
sdna->names_len = names_expand_len;
sdna->members_num = names_expand_len;
}
static const char *dna_sdna_alias_from_static_elem_full(SDNA *sdna,
@@ -1889,26 +1918,26 @@ static const char *dna_sdna_alias_from_static_elem_full(SDNA *sdna,
{
const int elem_static_full_len = strlen(elem_static_full);
char *elem_static = static_cast<char *>(alloca(elem_static_full_len + 1));
const int elem_static_len = DNA_elem_id_strip_copy(elem_static, elem_static_full);
const int elem_static_len = DNA_member_id_strip_copy(elem_static, elem_static_full);
const char *str_pair[2] = {struct_name_static, elem_static};
const char *elem_alias = static_cast<const char *>(
BLI_ghash_lookup(elem_map_alias_from_static, str_pair));
if (elem_alias) {
return DNA_elem_id_rename(sdna->mem_arena,
elem_static,
elem_static_len,
elem_alias,
strlen(elem_alias),
elem_static_full,
elem_static_full_len,
DNA_elem_id_offset_start(elem_static_full));
return DNA_member_id_rename(sdna->mem_arena,
elem_static,
elem_static_len,
elem_alias,
strlen(elem_alias),
elem_static_full,
elem_static_full_len,
DNA_member_id_offset_start(elem_static_full));
}
return nullptr;
}
void DNA_sdna_alias_data_ensure(SDNA *sdna)
{
if (sdna->alias.names && sdna->alias.types) {
if (sdna->alias.members && sdna->alias.types) {
return;
}
@@ -1919,72 +1948,76 @@ void DNA_sdna_alias_data_ensure(SDNA *sdna)
sdna->mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
}
GHash *struct_map_alias_from_static;
GHash *elem_map_alias_from_static;
GHash *type_map_alias_from_static;
GHash *member_map_alias_from_static;
DNA_alias_maps(
DNA_RENAME_ALIAS_FROM_STATIC, &struct_map_alias_from_static, &elem_map_alias_from_static);
DNA_RENAME_ALIAS_FROM_STATIC, &type_map_alias_from_static, &member_map_alias_from_static);
if (sdna->alias.types == nullptr) {
sdna->alias.types = static_cast<const char **>(
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];
MEM_mallocN(sizeof(*sdna->alias.types) * sdna->types_num, __func__));
for (int type_index = 0; type_index < sdna->types_num; type_index++) {
const char *type_name_static = sdna->types[type_index];
if (use_legacy_hack) {
struct_name_static = DNA_struct_rename_legacy_hack_alias_from_static(struct_name_static);
type_name_static = DNA_struct_rename_legacy_hack_alias_from_static(type_name_static);
}
sdna->alias.types[type_nr] = static_cast<const char *>(BLI_ghash_lookup_default(
struct_map_alias_from_static, struct_name_static, (void *)struct_name_static));
sdna->alias.types[type_index] = static_cast<const char *>(BLI_ghash_lookup_default(
type_map_alias_from_static, type_name_static, (void *)type_name_static));
}
}
if (sdna->alias.names == nullptr) {
if (sdna->alias.members == nullptr) {
sdna_expand_names(sdna);
sdna->alias.names = static_cast<const char **>(
MEM_mallocN(sizeof(*sdna->alias.names) * sdna->names_len, __func__));
for (int struct_nr = 0; struct_nr < sdna->structs_len; struct_nr++) {
const SDNA_Struct *struct_info = sdna->structs[struct_nr];
const char *struct_name_static = sdna->types[struct_info->type];
sdna->alias.members = static_cast<const char **>(
MEM_mallocN(sizeof(*sdna->alias.members) * sdna->members_num, __func__));
for (int struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
const SDNA_Struct *struct_info = sdna->structs[struct_index];
const char *struct_name_static = sdna->types[struct_info->type_index];
if (use_legacy_hack) {
struct_name_static = DNA_struct_rename_legacy_hack_alias_from_static(struct_name_static);
}
for (int a = 0; a < struct_info->members_len; a++) {
for (int a = 0; a < struct_info->members_num; a++) {
const SDNA_StructMember *member = &struct_info->members[a];
const char *elem_alias_full = dna_sdna_alias_from_static_elem_full(
sdna, elem_map_alias_from_static, struct_name_static, sdna->names[member->name]);
if (elem_alias_full != nullptr) {
sdna->alias.names[member->name] = elem_alias_full;
const char *member_alias_full = dna_sdna_alias_from_static_elem_full(
sdna,
member_map_alias_from_static,
struct_name_static,
sdna->members[member->member_index]);
if (member_alias_full != nullptr) {
sdna->alias.members[member->member_index] = member_alias_full;
}
else {
sdna->alias.names[member->name] = sdna->names[member->name];
sdna->alias.members[member->member_index] = sdna->members[member->member_index];
}
}
}
}
BLI_ghash_free(struct_map_alias_from_static, nullptr, nullptr);
BLI_ghash_free(elem_map_alias_from_static, MEM_freeN, nullptr);
BLI_ghash_free(type_map_alias_from_static, nullptr, nullptr);
BLI_ghash_free(member_map_alias_from_static, MEM_freeN, nullptr);
}
void DNA_sdna_alias_data_ensure_structs_map(SDNA *sdna)
{
if (sdna->alias.structs_map) {
if (sdna->alias.types_to_structs_map) {
return;
}
DNA_sdna_alias_data_ensure(sdna);
#ifdef WITH_DNA_GHASH
/* create a ghash lookup to speed up */
GHash *structs_map = BLI_ghash_str_new_ex(__func__, sdna->structs_len);
for (intptr_t nr = 0; nr < sdna->structs_len; nr++) {
const SDNA_Struct *struct_info = sdna->structs[nr];
BLI_ghash_insert(
structs_map, (void *)sdna->alias.types[struct_info->type], POINTER_FROM_INT(nr));
GHash *type_to_struct_index_map = BLI_ghash_str_new_ex(__func__, sdna->structs_num);
for (intptr_t struct_index = 0; struct_index < sdna->structs_num; struct_index++) {
const SDNA_Struct *struct_info = sdna->structs[struct_index];
BLI_ghash_insert(type_to_struct_index_map,
(void *)sdna->alias.types[struct_info->type_index],
POINTER_FROM_INT(struct_index));
}
sdna->alias.structs_map = structs_map;
sdna->alias.types_to_structs_map = type_to_struct_index_map;
#else
UNUSED_VARS(sdna);
#endif

362
source/blender/makesdna/intern/dna_rename_defs.h
View File

@@ -47,190 +47,190 @@ DNA_STRUCT_RENAME(SeqRetimingHandle, SeqRetimingKey)
DNA_STRUCT_RENAME(SpaceButs, SpaceProperties)
DNA_STRUCT_RENAME(SpaceIpo, SpaceGraph)
DNA_STRUCT_RENAME(SpaceOops, SpaceOutliner)
DNA_STRUCT_RENAME_ELEM(BPoint, alfa, tilt)
DNA_STRUCT_RENAME_ELEM(BezTriple, alfa, tilt)
DNA_STRUCT_RENAME_ELEM(Bone, curveInX, curve_in_x)
DNA_STRUCT_RENAME_ELEM(Bone, curveInY, curve_in_z)
DNA_STRUCT_RENAME_ELEM(Bone, curveOutX, curve_out_x)
DNA_STRUCT_RENAME_ELEM(Bone, curveOutY, curve_out_z)
DNA_STRUCT_RENAME_ELEM(Bone, scaleIn, scale_in_x)
DNA_STRUCT_RENAME_ELEM(Bone, scaleOut, scale_out_x)
DNA_STRUCT_RENAME_ELEM(Bone, scale_in_y, scale_in_z)
DNA_STRUCT_RENAME_ELEM(Bone, scale_out_y, scale_out_z)
DNA_STRUCT_RENAME_ELEM(BrushGpencilSettings, gradient_f, hardness)
DNA_STRUCT_RENAME_ELEM(BrushGpencilSettings, gradient_s, aspect_ratio)
DNA_STRUCT_RENAME_ELEM(Camera, YF_dofdist, dof_distance)
DNA_STRUCT_RENAME_ELEM(Camera, clipend, clip_end)
DNA_STRUCT_RENAME_ELEM(Camera, clipsta, clip_start)
DNA_STRUCT_RENAME_ELEM(Collection, dupli_ofs, instance_offset)
DNA_STRUCT_RENAME_ELEM(Curve, ext1, extrude)
DNA_STRUCT_RENAME_ELEM(Curve, ext2, bevel_radius)
DNA_STRUCT_RENAME_ELEM(Curve, len_wchar, len_char32)
DNA_STRUCT_RENAME_ELEM(Curve, loc, texspace_location)
DNA_STRUCT_RENAME_ELEM(Curve, size, texspace_size)
DNA_STRUCT_RENAME_ELEM(Curve, texflag, texspace_flag)
DNA_STRUCT_RENAME_ELEM(Curve, width, offset)
DNA_STRUCT_RENAME_ELEM(Curves, attributes_active_index, attributes_active_index_legacy)
DNA_STRUCT_RENAME_ELEM(CurvesGeometry, curve_size, curve_num)
DNA_STRUCT_RENAME_ELEM(CurvesGeometry, point_size, point_num)
DNA_STRUCT_RENAME_ELEM(CustomDataExternal, filename, filepath)
DNA_STRUCT_RENAME_ELEM(Editing, over_border, overlay_frame_rect)
DNA_STRUCT_RENAME_ELEM(Editing, over_cfra, overlay_frame_abs)
DNA_STRUCT_RENAME_ELEM(Editing, over_flag, overlay_frame_flag)
DNA_STRUCT_RENAME_ELEM(Editing, over_ofs, overlay_frame_ofs)
DNA_STRUCT_RENAME_ELEM(FileAssetSelectParams, import_type, import_method)
DNA_STRUCT_RENAME_ELEM(FileGlobal, filename, filepath)
DNA_STRUCT_RENAME_ELEM(FluidDomainSettings, cache_frame_pause_guiding, cache_frame_pause_guide)
DNA_STRUCT_RENAME_ELEM(FluidDomainSettings, guiding_alpha, guide_alpha)
DNA_STRUCT_RENAME_ELEM(FluidDomainSettings, guiding_beta, guide_beta)
DNA_STRUCT_RENAME_ELEM(FluidDomainSettings, guiding_parent, guide_parent)
DNA_STRUCT_RENAME_ELEM(FluidDomainSettings, guiding_source, guide_source)
DNA_STRUCT_RENAME_ELEM(FluidDomainSettings, guiding_vel_factor, guide_vel_factor)
DNA_STRUCT_RENAME_ELEM(FluidEffectorSettings, guiding_mode, guide_mode)
DNA_STRUCT_RENAME_ELEM(GreasePencil, drawing_array_size, drawing_array_num)
DNA_STRUCT_RENAME_ELEM(GreasePencil, material_array_size, material_array_num)
DNA_STRUCT_RENAME_ELEM(GreasePencilLayerFramesMapStorage, size, num)
DNA_STRUCT_RENAME_ELEM(HookModifierData, totindex, indexar_num)
DNA_STRUCT_RENAME_ELEM(Image, name, filepath)
DNA_STRUCT_RENAME_ELEM(LaplacianDeformModifierData, total_verts, verts_num)
DNA_STRUCT_RENAME_ELEM(Library, name, filepath)
DNA_STRUCT_RENAME_ELEM(Light, energy, energy_deprecated)
DNA_STRUCT_RENAME_ELEM(Light, energy_new, energy)
DNA_STRUCT_RENAME_ELEM(LineartGpencilModifierData, line_types, edge_types)
DNA_STRUCT_RENAME_ELEM(LineartGpencilModifierData, transparency_flags, mask_switches)
DNA_STRUCT_RENAME_ELEM(LineartGpencilModifierData, transparency_mask, material_mask_bits)
DNA_STRUCT_RENAME_ELEM(MDefCell, totinfluence, influences_num)
DNA_STRUCT_RENAME_ELEM(MEdge, bweight, bweight_legacy)
DNA_STRUCT_RENAME_ELEM(MEdge, crease, crease_legacy)
DNA_STRUCT_RENAME_ELEM(MEdge, flag, flag_legacy)
DNA_STRUCT_RENAME_ELEM(MPoly, flag, flag_legacy)
DNA_STRUCT_RENAME_ELEM(MPoly, mat_nr, mat_nr_legacy)
DNA_STRUCT_RENAME_ELEM(MVert, bweight, bweight_legacy)
DNA_STRUCT_RENAME_ELEM(MVert, co, co_legacy)
DNA_STRUCT_RENAME_ELEM(MVert, flag, flag_legacy)
DNA_STRUCT_RENAME_ELEM(MaskLayer, restrictflag, visibility_flag)
DNA_STRUCT_RENAME_ELEM(MaterialLineArt, transparency_mask, material_mask_bits)
DNA_STRUCT_RENAME_ELEM(Mesh, edata, edge_data)
DNA_STRUCT_RENAME_ELEM(Mesh, fdata, fdata_legacy)
DNA_STRUCT_RENAME_ELEM(Mesh, ldata, corner_data)
DNA_STRUCT_RENAME_ELEM(Mesh, loc, texspace_location)
DNA_STRUCT_RENAME_ELEM(Mesh, pdata, face_data)
DNA_STRUCT_RENAME_ELEM(Mesh, poly_offset_indices, face_offset_indices)
DNA_STRUCT_RENAME_ELEM(Mesh, size, texspace_size)
DNA_STRUCT_RENAME_ELEM(Mesh, smoothresh, smoothresh_legacy)
DNA_STRUCT_RENAME_ELEM(Mesh, texflag, texspace_flag)
DNA_STRUCT_RENAME_ELEM(Mesh, totedge, edges_num)
DNA_STRUCT_RENAME_ELEM(Mesh, totface, totface_legacy)
DNA_STRUCT_RENAME_ELEM(Mesh, totloop, corners_num)
DNA_STRUCT_RENAME_ELEM(Mesh, totpoly, faces_num)
DNA_STRUCT_RENAME_ELEM(Mesh, totvert, verts_num)
DNA_STRUCT_RENAME_ELEM(Mesh, vdata, vert_data)
DNA_STRUCT_RENAME_ELEM(MeshDeformModifierData, totcagevert, cage_verts_num)
DNA_STRUCT_RENAME_ELEM(MeshDeformModifierData, totinfluence, influences_num)
DNA_STRUCT_RENAME_ELEM(MeshDeformModifierData, totvert, verts_num)
DNA_STRUCT_RENAME_ELEM(MetaBall, loc, texspace_location)
DNA_STRUCT_RENAME_ELEM(MetaBall, size, texspace_size)
DNA_STRUCT_RENAME_ELEM(MetaBall, texflag, texspace_flag)
DNA_STRUCT_RENAME_ELEM(MovieClip, name, filepath)
DNA_STRUCT_RENAME_ELEM(MovieTracking, act_plane_track, act_plane_track_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTracking, act_track, act_track_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTracking, plane_tracks, plane_tracks_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTracking, reconstruction, reconstruction_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTracking, tracks, tracks_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTrackingCamera, principal, principal_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTrackingSettings, keyframe1, keyframe1_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTrackingSettings, keyframe2, keyframe2_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTrackingStabilization, rot_track, rot_track_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTrackingTrack, pat_max, pat_max_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTrackingTrack, pat_min, pat_min_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTrackingTrack, search_max, search_max_legacy)
DNA_STRUCT_RENAME_ELEM(MovieTrackingTrack, search_min, search_min_legacy)
DNA_STRUCT_RENAME_ELEM(NodeCryptomatte, num_inputs, inputs_num)
DNA_STRUCT_RENAME_ELEM(NodeGeometryAttributeCapture, data_type, data_type_legacy)
DNA_STRUCT_RENAME_ELEM(NodesModifierData, simulation_bake_directory, bake_directory)
DNA_STRUCT_RENAME_ELEM(Object, col, color)
DNA_STRUCT_RENAME_ELEM(Object, dup_group, instance_collection)
DNA_STRUCT_RENAME_ELEM(Object, dupfacesca, instance_faces_scale)
DNA_STRUCT_RENAME_ELEM(Object, restrictflag, visibility_flag)
DNA_STRUCT_RENAME_ELEM(Object, size, scale)
DNA_STRUCT_RENAME_ELEM(OpacityGpencilModifierData, hardeness, hardness)
DNA_STRUCT_RENAME_ELEM(Paint, num_input_samples, num_input_samples_deprecated)
DNA_STRUCT_RENAME_ELEM(ParticleSettings, child_nbr, child_percent)
DNA_STRUCT_RENAME_ELEM(ParticleSettings, dup_group, instance_collection)
DNA_STRUCT_RENAME_ELEM(ParticleSettings, dup_ob, instance_object)
DNA_STRUCT_RENAME_ELEM(ParticleSettings, dupliweights, instance_weights)
DNA_STRUCT_RENAME_ELEM(ParticleSettings, ren_child_nbr, child_render_percent)
DNA_STRUCT_RENAME_ELEM(RenderData, bake_filter, bake_margin)
DNA_STRUCT_RENAME_ELEM(RenderData, blurfac, motion_blur_shutter)
DNA_STRUCT_RENAME_ELEM(RigidBodyWorld, steps_per_second, substeps_per_frame)
DNA_STRUCT_RENAME_ELEM(SceneEEVEE, motion_blur_position, motion_blur_position_deprecated)
DNA_STRUCT_RENAME_ELEM(SceneEEVEE, motion_blur_shutter, motion_blur_shutter_deprecated)
DNA_STRUCT_RENAME_ELEM(SDefBind, numverts, verts_num)
DNA_STRUCT_RENAME_ELEM(SDefVert, numbinds, binds_num)
DNA_STRUCT_RENAME_ELEM(Sequence, retiming_handle_num, retiming_keys_num)
DNA_STRUCT_RENAME_ELEM(Sequence, retiming_handles, retiming_keys)
DNA_STRUCT_RENAME_ELEM(SpaceImage, pixel_snap_mode, pixel_round_mode)
DNA_STRUCT_RENAME_ELEM(SpaceSeq, overlay_type, overlay_frame_type)
DNA_STRUCT_RENAME_ELEM(Strip, dir, dirpath)
DNA_STRUCT_RENAME_ELEM(StripElem, name, filename)
DNA_STRUCT_RENAME_ELEM(StripProxy, dir, dirpath)
DNA_STRUCT_RENAME_ELEM(StripProxy, file, filename)
DNA_STRUCT_RENAME_ELEM(SurfaceDeformModifierData, num_mesh_verts, mesh_verts_num)
DNA_STRUCT_RENAME_ELEM(SurfaceDeformModifierData, numpoly, target_polys_num)
DNA_STRUCT_RENAME_ELEM(SurfaceDeformModifierData, numverts, bind_verts_num)
DNA_STRUCT_RENAME_ELEM(Text, name, filepath)
DNA_STRUCT_RENAME_ELEM(ThemeSpace, scrubbing_background, time_scrub_background)
DNA_STRUCT_RENAME_ELEM(ThemeSpace, show_back_grad, background_type)
DNA_STRUCT_RENAME_ELEM(UVProjectModifierData, num_projectors, projectors_num)
DNA_STRUCT_RENAME_ELEM(UserDef, autokey_flag, keying_flag)
DNA_STRUCT_RENAME_ELEM(UserDef, gp_manhattendist, gp_manhattandist)
DNA_STRUCT_RENAME_ELEM(UserDef, pythondir, pythondir_legacy)
DNA_STRUCT_RENAME_ELEM(VFont, name, filepath)
DNA_STRUCT_RENAME_ELEM(View3D, far, clip_end)
DNA_STRUCT_RENAME_ELEM(View3D, local_collections_uuid, local_collections_uid)
DNA_STRUCT_RENAME_ELEM(View3D, local_view_uuid, local_view_uid)
DNA_STRUCT_RENAME_ELEM(View3D, near, clip_start)
DNA_STRUCT_RENAME_ELEM(View3D, ob_centre, ob_center)
DNA_STRUCT_RENAME_ELEM(View3D, ob_centre_bone, ob_center_bone)
DNA_STRUCT_RENAME_ELEM(View3D, ob_centre_cursor, ob_center_cursor)
DNA_STRUCT_RENAME_ELEM(bArmature, collections, collections_legacy)
DNA_STRUCT_RENAME_ELEM(bGPDstroke, gradient_f, hardness)
DNA_STRUCT_RENAME_ELEM(bGPDstroke, gradient_s, aspect_ratio)
DNA_STRUCT_RENAME_ELEM(bNodeLink, multi_input_socket_index, multi_input_sort_id)
DNA_STRUCT_RENAME_ELEM(bNodeTree, inputs, inputs_legacy)
DNA_STRUCT_RENAME_ELEM(bNodeTree, outputs, outputs_legacy)
DNA_STRUCT_RENAME_ELEM(bPoseChannel, curveInX, curve_in_x)
DNA_STRUCT_RENAME_ELEM(bPoseChannel, curveInY, curve_in_z)
DNA_STRUCT_RENAME_ELEM(bPoseChannel, curveOutX, curve_out_x)
DNA_STRUCT_RENAME_ELEM(bPoseChannel, curveOutY, curve_out_z)
DNA_STRUCT_RENAME_ELEM(bPoseChannel, scaleIn, scale_in_x)
DNA_STRUCT_RENAME_ELEM(bPoseChannel, scaleOut, scale_out_x)
DNA_STRUCT_RENAME_ELEM(bPoseChannel, scale_in_y, scale_in_z)
DNA_STRUCT_RENAME_ELEM(bPoseChannel, scale_out_y, scale_out_z)
DNA_STRUCT_RENAME_ELEM(bSameVolumeConstraint, flag, free_axis)
DNA_STRUCT_RENAME_ELEM(bSound, name, filepath)
DNA_STRUCT_RENAME_ELEM(bTheme, tact, space_action)
DNA_STRUCT_RENAME_ELEM(bTheme, tbuts, space_properties)
DNA_STRUCT_RENAME_ELEM(bTheme, tclip, space_clip)
DNA_STRUCT_RENAME_ELEM(bTheme, tconsole, space_console)
DNA_STRUCT_RENAME_ELEM(bTheme, text, space_text)
DNA_STRUCT_RENAME_ELEM(bTheme, tfile, space_file)
DNA_STRUCT_RENAME_ELEM(bTheme, tima, space_image)
DNA_STRUCT_RENAME_ELEM(bTheme, tinfo, space_info)
DNA_STRUCT_RENAME_ELEM(bTheme, tipo, space_graph)
DNA_STRUCT_RENAME_ELEM(bTheme, tnla, space_nla)
DNA_STRUCT_RENAME_ELEM(bTheme, tnode, space_node)
DNA_STRUCT_RENAME_ELEM(bTheme, toops, space_outliner)
DNA_STRUCT_RENAME_ELEM(bTheme, tseq, space_sequencer)
DNA_STRUCT_RENAME_ELEM(bTheme, tstatusbar, space_statusbar)
DNA_STRUCT_RENAME_ELEM(bTheme, ttopbar, space_topbar)
DNA_STRUCT_RENAME_ELEM(bTheme, tuserpref, space_preferences)
DNA_STRUCT_RENAME_ELEM(bTheme, tv3d, space_view3d)
DNA_STRUCT_RENAME_ELEM(bUserAssetLibrary, path, dirpath)
DNA_STRUCT_RENAME_MEMBER(BPoint, alfa, tilt)
DNA_STRUCT_RENAME_MEMBER(BezTriple, alfa, tilt)
DNA_STRUCT_RENAME_MEMBER(Bone, curveInX, curve_in_x)
DNA_STRUCT_RENAME_MEMBER(Bone, curveInY, curve_in_z)
DNA_STRUCT_RENAME_MEMBER(Bone, curveOutX, curve_out_x)
DNA_STRUCT_RENAME_MEMBER(Bone, curveOutY, curve_out_z)
DNA_STRUCT_RENAME_MEMBER(Bone, scaleIn, scale_in_x)
DNA_STRUCT_RENAME_MEMBER(Bone, scaleOut, scale_out_x)
DNA_STRUCT_RENAME_MEMBER(Bone, scale_in_y, scale_in_z)
DNA_STRUCT_RENAME_MEMBER(Bone, scale_out_y, scale_out_z)
DNA_STRUCT_RENAME_MEMBER(BrushGpencilSettings, gradient_f, hardness)
DNA_STRUCT_RENAME_MEMBER(BrushGpencilSettings, gradient_s, aspect_ratio)
DNA_STRUCT_RENAME_MEMBER(Camera, YF_dofdist, dof_distance)
DNA_STRUCT_RENAME_MEMBER(Camera, clipend, clip_end)
DNA_STRUCT_RENAME_MEMBER(Camera, clipsta, clip_start)
DNA_STRUCT_RENAME_MEMBER(Collection, dupli_ofs, instance_offset)
DNA_STRUCT_RENAME_MEMBER(Curve, ext1, extrude)
DNA_STRUCT_RENAME_MEMBER(Curve, ext2, bevel_radius)
DNA_STRUCT_RENAME_MEMBER(Curve, len_wchar, len_char32)
DNA_STRUCT_RENAME_MEMBER(Curve, loc, texspace_location)
DNA_STRUCT_RENAME_MEMBER(Curve, size, texspace_size)
DNA_STRUCT_RENAME_MEMBER(Curve, texflag, texspace_flag)
DNA_STRUCT_RENAME_MEMBER(Curve, width, offset)
DNA_STRUCT_RENAME_MEMBER(Curves, attributes_active_index, attributes_active_index_legacy)
DNA_STRUCT_RENAME_MEMBER(CurvesGeometry, curve_size, curve_num)
DNA_STRUCT_RENAME_MEMBER(CurvesGeometry, point_size, point_num)
DNA_STRUCT_RENAME_MEMBER(CustomDataExternal, filename, filepath)
DNA_STRUCT_RENAME_MEMBER(Editing, over_border, overlay_frame_rect)
DNA_STRUCT_RENAME_MEMBER(Editing, over_cfra, overlay_frame_abs)
DNA_STRUCT_RENAME_MEMBER(Editing, over_flag, overlay_frame_flag)
DNA_STRUCT_RENAME_MEMBER(Editing, over_ofs, overlay_frame_ofs)
DNA_STRUCT_RENAME_MEMBER(FileAssetSelectParams, import_type, import_method)
DNA_STRUCT_RENAME_MEMBER(FileGlobal, filename, filepath)
DNA_STRUCT_RENAME_MEMBER(FluidDomainSettings, cache_frame_pause_guiding, cache_frame_pause_guide)
DNA_STRUCT_RENAME_MEMBER(FluidDomainSettings, guiding_alpha, guide_alpha)
DNA_STRUCT_RENAME_MEMBER(FluidDomainSettings, guiding_beta, guide_beta)
DNA_STRUCT_RENAME_MEMBER(FluidDomainSettings, guiding_parent, guide_parent)
DNA_STRUCT_RENAME_MEMBER(FluidDomainSettings, guiding_source, guide_source)
DNA_STRUCT_RENAME_MEMBER(FluidDomainSettings, guiding_vel_factor, guide_vel_factor)
DNA_STRUCT_RENAME_MEMBER(FluidEffectorSettings, guiding_mode, guide_mode)
DNA_STRUCT_RENAME_MEMBER(GreasePencil, drawing_array_size, drawing_array_num)
DNA_STRUCT_RENAME_MEMBER(GreasePencil, material_array_size, material_array_num)
DNA_STRUCT_RENAME_MEMBER(GreasePencilLayerFramesMapStorage, size, num)
DNA_STRUCT_RENAME_MEMBER(HookModifierData, totindex, indexar_num)
DNA_STRUCT_RENAME_MEMBER(Image, name, filepath)
DNA_STRUCT_RENAME_MEMBER(LaplacianDeformModifierData, total_verts, verts_num)
DNA_STRUCT_RENAME_MEMBER(Library, name, filepath)
DNA_STRUCT_RENAME_MEMBER(Light, energy, energy_deprecated)
DNA_STRUCT_RENAME_MEMBER(Light, energy_new, energy)
DNA_STRUCT_RENAME_MEMBER(LineartGpencilModifierData, line_types, edge_types)
DNA_STRUCT_RENAME_MEMBER(LineartGpencilModifierData, transparency_flags, mask_switches)
DNA_STRUCT_RENAME_MEMBER(LineartGpencilModifierData, transparency_mask, material_mask_bits)
DNA_STRUCT_RENAME_MEMBER(MDefCell, totinfluence, influences_num)
DNA_STRUCT_RENAME_MEMBER(MEdge, bweight, bweight_legacy)
DNA_STRUCT_RENAME_MEMBER(MEdge, crease, crease_legacy)
DNA_STRUCT_RENAME_MEMBER(MEdge, flag, flag_legacy)
DNA_STRUCT_RENAME_MEMBER(MPoly, flag, flag_legacy)
DNA_STRUCT_RENAME_MEMBER(MPoly, mat_nr, mat_nr_legacy)
DNA_STRUCT_RENAME_MEMBER(MVert, bweight, bweight_legacy)
DNA_STRUCT_RENAME_MEMBER(MVert, co, co_legacy)
DNA_STRUCT_RENAME_MEMBER(MVert, flag, flag_legacy)
DNA_STRUCT_RENAME_MEMBER(MaskLayer, restrictflag, visibility_flag)
DNA_STRUCT_RENAME_MEMBER(MaterialLineArt, transparency_mask, material_mask_bits)
DNA_STRUCT_RENAME_MEMBER(Mesh, edata, edge_data)
DNA_STRUCT_RENAME_MEMBER(Mesh, fdata, fdata_legacy)
DNA_STRUCT_RENAME_MEMBER(Mesh, ldata, corner_data)
DNA_STRUCT_RENAME_MEMBER(Mesh, loc, texspace_location)
DNA_STRUCT_RENAME_MEMBER(Mesh, pdata, face_data)
DNA_STRUCT_RENAME_MEMBER(Mesh, poly_offset_indices, face_offset_indices)
DNA_STRUCT_RENAME_MEMBER(Mesh, size, texspace_size)
DNA_STRUCT_RENAME_MEMBER(Mesh, smoothresh, smoothresh_legacy)
DNA_STRUCT_RENAME_MEMBER(Mesh, texflag, texspace_flag)
DNA_STRUCT_RENAME_MEMBER(Mesh, totedge, edges_num)
DNA_STRUCT_RENAME_MEMBER(Mesh, totface, totface_legacy)
DNA_STRUCT_RENAME_MEMBER(Mesh, totloop, corners_num)
DNA_STRUCT_RENAME_MEMBER(Mesh, totpoly, faces_num)
DNA_STRUCT_RENAME_MEMBER(Mesh, totvert, verts_num)
DNA_STRUCT_RENAME_MEMBER(Mesh, vdata, vert_data)
DNA_STRUCT_RENAME_MEMBER(MeshDeformModifierData, totcagevert, cage_verts_num)
DNA_STRUCT_RENAME_MEMBER(MeshDeformModifierData, totinfluence, influences_num)
DNA_STRUCT_RENAME_MEMBER(MeshDeformModifierData, totvert, verts_num)
DNA_STRUCT_RENAME_MEMBER(MetaBall, loc, texspace_location)
DNA_STRUCT_RENAME_MEMBER(MetaBall, size, texspace_size)
DNA_STRUCT_RENAME_MEMBER(MetaBall, texflag, texspace_flag)
DNA_STRUCT_RENAME_MEMBER(MovieClip, name, filepath)
DNA_STRUCT_RENAME_MEMBER(MovieTracking, act_plane_track, act_plane_track_legacy)
DNA_STRUCT_RENAME_MEMBER(MovieTracking, act_track, act_track_legacy)
DNA_STRUCT_RENAME_MEMBER(MovieTracking, plane_tracks, plane_tracks_legacy)
DNA_STRUCT_RENAME_MEMBER(MovieTracking, reconstruction, reconstruction_legacy)
DNA_STRUCT_RENAME_MEMBER(MovieTracking, tracks, tracks_legacy)
DNA_STRUCT_RENAME_MEMBER(MovieTrackingCamera, principal, principal_legacy)
DNA_STRUCT_RENAME_MEMBER(MovieTrackingSettings, keyframe1, keyframe1_legacy)
DNA_STRUCT_RENAME_MEMBER(MovieTrackingSettings, keyframe2, keyframe2_legacy)
DNA_STRUCT_RENAME_MEMBER(MovieTrackingStabilization, rot_track, rot_track_legacy)
DNA_STRUCT_RENAME_MEMBER(MovieTrackingTrack, pat_max, pat_max_legacy)
DNA_STRUCT_RENAME_MEMBER(MovieTrackingTrack, pat_min, pat_min_legacy)
DNA_STRUCT_RENAME_MEMBER(MovieTrackingTrack, search_max, search_max_legacy)
DNA_STRUCT_RENAME_MEMBER(MovieTrackingTrack, search_min, search_min_legacy)
DNA_STRUCT_RENAME_MEMBER(NodeCryptomatte, num_inputs, inputs_num)
DNA_STRUCT_RENAME_MEMBER(NodeGeometryAttributeCapture, data_type, data_type_legacy)
DNA_STRUCT_RENAME_MEMBER(NodesModifierData, simulation_bake_directory, bake_directory)
DNA_STRUCT_RENAME_MEMBER(Object, col, color)
DNA_STRUCT_RENAME_MEMBER(Object, dup_group, instance_collection)
DNA_STRUCT_RENAME_MEMBER(Object, dupfacesca, instance_faces_scale)
DNA_STRUCT_RENAME_MEMBER(Object, restrictflag, visibility_flag)
DNA_STRUCT_RENAME_MEMBER(Object, size, scale)
DNA_STRUCT_RENAME_MEMBER(OpacityGpencilModifierData, hardeness, hardness)
DNA_STRUCT_RENAME_MEMBER(Paint, num_input_samples, num_input_samples_deprecated)
DNA_STRUCT_RENAME_MEMBER(ParticleSettings, child_nbr, child_percent)
DNA_STRUCT_RENAME_MEMBER(ParticleSettings, dup_group, instance_collection)
DNA_STRUCT_RENAME_MEMBER(ParticleSettings, dup_ob, instance_object)
DNA_STRUCT_RENAME_MEMBER(ParticleSettings, dupliweights, instance_weights)
DNA_STRUCT_RENAME_MEMBER(ParticleSettings, ren_child_nbr, child_render_percent)
DNA_STRUCT_RENAME_MEMBER(RenderData, bake_filter, bake_margin)
DNA_STRUCT_RENAME_MEMBER(RenderData, blurfac, motion_blur_shutter)
DNA_STRUCT_RENAME_MEMBER(RigidBodyWorld, steps_per_second, substeps_per_frame)
DNA_STRUCT_RENAME_MEMBER(SceneEEVEE, motion_blur_position, motion_blur_position_deprecated)
DNA_STRUCT_RENAME_MEMBER(SceneEEVEE, motion_blur_shutter, motion_blur_shutter_deprecated)
DNA_STRUCT_RENAME_MEMBER(SDefBind, numverts, verts_num)
DNA_STRUCT_RENAME_MEMBER(SDefVert, numbinds, binds_num)
DNA_STRUCT_RENAME_MEMBER(Sequence, retiming_handle_num, retiming_keys_num)
DNA_STRUCT_RENAME_MEMBER(Sequence, retiming_handles, retiming_keys)
DNA_STRUCT_RENAME_MEMBER(SpaceImage, pixel_snap_mode, pixel_round_mode)
DNA_STRUCT_RENAME_MEMBER(SpaceSeq, overlay_type, overlay_frame_type)
DNA_STRUCT_RENAME_MEMBER(Strip, dir, dirpath)
DNA_STRUCT_RENAME_MEMBER(StripElem, name, filename)
DNA_STRUCT_RENAME_MEMBER(StripProxy, dir, dirpath)
DNA_STRUCT_RENAME_MEMBER(StripProxy, file, filename)
DNA_STRUCT_RENAME_MEMBER(SurfaceDeformModifierData, num_mesh_verts, mesh_verts_num)
DNA_STRUCT_RENAME_MEMBER(SurfaceDeformModifierData, numpoly, target_polys_num)
DNA_STRUCT_RENAME_MEMBER(SurfaceDeformModifierData, numverts, bind_verts_num)
DNA_STRUCT_RENAME_MEMBER(Text, name, filepath)
DNA_STRUCT_RENAME_MEMBER(ThemeSpace, scrubbing_background, time_scrub_background)
DNA_STRUCT_RENAME_MEMBER(ThemeSpace, show_back_grad, background_type)
DNA_STRUCT_RENAME_MEMBER(UVProjectModifierData, num_projectors, projectors_num)
DNA_STRUCT_RENAME_MEMBER(UserDef, autokey_flag, keying_flag)
DNA_STRUCT_RENAME_MEMBER(UserDef, gp_manhattendist, gp_manhattandist)
DNA_STRUCT_RENAME_MEMBER(UserDef, pythondir, pythondir_legacy)
DNA_STRUCT_RENAME_MEMBER(VFont, name, filepath)
DNA_STRUCT_RENAME_MEMBER(View3D, far, clip_end)
DNA_STRUCT_RENAME_MEMBER(View3D, local_collections_uuid, local_collections_uid)
DNA_STRUCT_RENAME_MEMBER(View3D, local_view_uuid, local_view_uid)
DNA_STRUCT_RENAME_MEMBER(View3D, near, clip_start)
DNA_STRUCT_RENAME_MEMBER(View3D, ob_centre, ob_center)
DNA_STRUCT_RENAME_MEMBER(View3D, ob_centre_bone, ob_center_bone)
DNA_STRUCT_RENAME_MEMBER(View3D, ob_centre_cursor, ob_center_cursor)
DNA_STRUCT_RENAME_MEMBER(bArmature, collections, collections_legacy)
DNA_STRUCT_RENAME_MEMBER(bGPDstroke, gradient_f, hardness)
DNA_STRUCT_RENAME_MEMBER(bGPDstroke, gradient_s, aspect_ratio)
DNA_STRUCT_RENAME_MEMBER(bNodeLink, multi_input_socket_index, multi_input_sort_id)
DNA_STRUCT_RENAME_MEMBER(bNodeTree, inputs, inputs_legacy)
DNA_STRUCT_RENAME_MEMBER(bNodeTree, outputs, outputs_legacy)
DNA_STRUCT_RENAME_MEMBER(bPoseChannel, curveInX, curve_in_x)
DNA_STRUCT_RENAME_MEMBER(bPoseChannel, curveInY, curve_in_z)
DNA_STRUCT_RENAME_MEMBER(bPoseChannel, curveOutX, curve_out_x)
DNA_STRUCT_RENAME_MEMBER(bPoseChannel, curveOutY, curve_out_z)
DNA_STRUCT_RENAME_MEMBER(bPoseChannel, scaleIn, scale_in_x)
DNA_STRUCT_RENAME_MEMBER(bPoseChannel, scaleOut, scale_out_x)
DNA_STRUCT_RENAME_MEMBER(bPoseChannel, scale_in_y, scale_in_z)
DNA_STRUCT_RENAME_MEMBER(bPoseChannel, scale_out_y, scale_out_z)
DNA_STRUCT_RENAME_MEMBER(bSameVolumeConstraint, flag, free_axis)
DNA_STRUCT_RENAME_MEMBER(bSound, name, filepath)
DNA_STRUCT_RENAME_MEMBER(bTheme, tact, space_action)
DNA_STRUCT_RENAME_MEMBER(bTheme, tbuts, space_properties)
DNA_STRUCT_RENAME_MEMBER(bTheme, tclip, space_clip)
DNA_STRUCT_RENAME_MEMBER(bTheme, tconsole, space_console)
DNA_STRUCT_RENAME_MEMBER(bTheme, text, space_text)
DNA_STRUCT_RENAME_MEMBER(bTheme, tfile, space_file)
DNA_STRUCT_RENAME_MEMBER(bTheme, tima, space_image)
DNA_STRUCT_RENAME_MEMBER(bTheme, tinfo, space_info)
DNA_STRUCT_RENAME_MEMBER(bTheme, tipo, space_graph)
DNA_STRUCT_RENAME_MEMBER(bTheme, tnla, space_nla)
DNA_STRUCT_RENAME_MEMBER(bTheme, tnode, space_node)
DNA_STRUCT_RENAME_MEMBER(bTheme, toops, space_outliner)
DNA_STRUCT_RENAME_MEMBER(bTheme, tseq, space_sequencer)
DNA_STRUCT_RENAME_MEMBER(bTheme, tstatusbar, space_statusbar)
DNA_STRUCT_RENAME_MEMBER(bTheme, ttopbar, space_topbar)
DNA_STRUCT_RENAME_MEMBER(bTheme, tuserpref, space_preferences)
DNA_STRUCT_RENAME_MEMBER(bTheme, tv3d, space_view3d)
DNA_STRUCT_RENAME_MEMBER(bUserAssetLibrary, path, dirpath)
/* NOTE: Keep sorted! */
/* Write with a different name, old Blender versions crash loading files with non-NULL
* global_areas. See D9442. */
DNA_STRUCT_RENAME_ELEM(wmWindow, global_area_map, global_areas)
DNA_STRUCT_RENAME_MEMBER(wmWindow, global_area_map, global_areas)
/* NOTE: Keep sorted! */

196
source/blender/makesdna/intern/dna_utils.cc
View File

@@ -26,7 +26,7 @@
/** \name Struct Member Evaluation
* \{ */
int DNA_elem_array_size(const char *str)
int DNA_member_array_num(const char *str)
{
int result = 1;
int current = 0;
@@ -71,95 +71,100 @@ static bool is_identifier(const char c)
(c == '_'));
}
uint DNA_elem_id_offset_start(const char *elem_full)
uint DNA_member_id_offset_start(const char *member_full)
{
uint elem_full_offset = 0;
while (!is_identifier(elem_full[elem_full_offset])) {
while (!is_identifier(member_full[elem_full_offset])) {
elem_full_offset++;
}
return elem_full_offset;
}
uint DNA_elem_id_offset_end(const char *elem_full)
uint DNA_member_id_offset_end(const char *member_full)
{
uint elem_full_offset = 0;
while (is_identifier(elem_full[elem_full_offset])) {
while (is_identifier(member_full[elem_full_offset])) {
elem_full_offset++;
}
return elem_full_offset;
}
uint DNA_elem_id_strip_copy(char *elem_dst, const char *elem_src)
uint DNA_member_id_strip_copy(char *member_id_dst, const char *member_full_src)
{
const uint elem_src_offset = DNA_elem_id_offset_start(elem_src);
const char *elem_src_trim = elem_src + elem_src_offset;
const uint elem_src_trim_len = DNA_elem_id_offset_end(elem_src_trim);
memcpy(elem_dst, elem_src_trim, elem_src_trim_len);
elem_dst[elem_src_trim_len] = '\0';
return elem_src_trim_len;
const uint member_src_offset = DNA_member_id_offset_start(member_full_src);
const char *member_src_trimmed = member_full_src + member_src_offset;
const uint member_src_trimmed_len = DNA_member_id_offset_end(member_src_trimmed);
memcpy(member_id_dst, member_src_trimmed, member_src_trimmed_len);
member_id_dst[member_src_trimmed_len] = '\0';
return member_src_trimmed_len;
}
uint DNA_elem_id_strip(char *elem)
uint DNA_member_id_strip(char *member)
{
const uint elem_offset = DNA_elem_id_offset_start(elem);
const char *elem_trim = elem + elem_offset;
const uint elem_trim_len = DNA_elem_id_offset_end(elem_trim);
memmove(elem, elem_trim, elem_trim_len);
elem[elem_trim_len] = '\0';
return elem_trim_len;
const uint member_offset = DNA_member_id_offset_start(member);
const char *member_trimmed = member + member_offset;
const uint member_trimmed_len = DNA_member_id_offset_end(member_trimmed);
memmove(member, member_trimmed, member_trimmed_len);
member[member_trimmed_len] = '\0';
return member_trimmed_len;
}
bool DNA_elem_id_match(const char *elem_search,
const int elem_search_len,
const char *elem_full,
uint *r_elem_full_offset)
bool DNA_member_id_match(const char *member_id,
const int member_id_len,
const char *member_full,
uint *r_member_full_offset)
{
BLI_assert(strlen(elem_search) == elem_search_len);
const uint elem_full_offset = DNA_elem_id_offset_start(elem_full);
const char *elem_full_trim = elem_full + elem_full_offset;
if (strncmp(elem_search, elem_full_trim, elem_search_len) == 0) {
const char c = elem_full_trim[elem_search_len];
BLI_assert(strlen(member_id) == member_id_len);
const uint elem_full_offset = DNA_member_id_offset_start(member_full);
const char *elem_full_trim = member_full + elem_full_offset;
if (strncmp(member_id, elem_full_trim, member_id_len) == 0) {
const char c = elem_full_trim[member_id_len];
if (c == '\0' || !is_identifier(c)) {
*r_elem_full_offset = elem_full_offset;
*r_member_full_offset = elem_full_offset;
return true;
}
}
return false;
}
char *DNA_elem_id_rename(MemArena *mem_arena,
const char *elem_src,
const int elem_src_len,
const char *elem_dst,
const int elem_dst_len,
const char *elem_src_full,
const int elem_src_full_len,
const uint elem_src_full_offset_len)
char *DNA_member_id_rename(MemArena *mem_arena,
const char *member_id_src,
const int member_id_src_len,
const char *member_id_dst,
const int member_id_dst_len,
const char *member_full_src,
const int member_full_src_len,
const uint member_full_src_offset_len)
{
BLI_assert(strlen(elem_src) == elem_src_len);
BLI_assert(strlen(elem_dst) == elem_dst_len);
BLI_assert(strlen(elem_src_full) == elem_src_full_len);
BLI_assert(DNA_elem_id_offset_start(elem_src_full) == elem_src_full_offset_len);
UNUSED_VARS_NDEBUG(elem_src);
BLI_assert(strlen(member_id_src) == member_id_src_len);
BLI_assert(strlen(member_id_dst) == member_id_dst_len);
BLI_assert(strlen(member_full_src) == member_full_src_len);
BLI_assert(DNA_member_id_offset_start(member_full_src) == member_full_src_offset_len);
UNUSED_VARS_NDEBUG(member_src);
const int elem_final_len = (elem_src_full_len - elem_src_len) + elem_dst_len;
char *elem_dst_full = static_cast<char *>(BLI_memarena_alloc(mem_arena, elem_final_len + 1));
const int member_full_dst_len = (member_full_src_len - member_id_src_len) + member_id_dst_len;
char *member_full_dst = static_cast<char *>(
BLI_memarena_alloc(mem_arena, member_full_dst_len + 1));
uint i = 0;
if (elem_src_full_offset_len != 0) {
memcpy(elem_dst_full, elem_src_full, elem_src_full_offset_len);
i = elem_src_full_offset_len;
if (member_full_src_offset_len != 0) {
memcpy(member_full_dst, member_full_src, member_full_src_offset_len);
i = member_full_src_offset_len;
}
memcpy(&elem_dst_full[i], elem_dst, elem_dst_len + 1);
i += elem_dst_len;
uint elem_src_full_offset_end = elem_src_full_offset_len + elem_src_len;
if (elem_src_full[elem_src_full_offset_end] != '\0') {
const int elem_full_tail_len = (elem_src_full_len - elem_src_full_offset_end);
memcpy(&elem_dst_full[i], &elem_src_full[elem_src_full_offset_end], elem_full_tail_len + 1);
i += elem_full_tail_len;
memcpy(&member_full_dst[i], member_id_dst, member_id_dst_len + 1);
i += member_id_dst_len;
const uint member_full_src_offset_end = member_full_src_offset_len + member_id_src_len;
BLI_assert(DNA_member_id_offset_end(member_full_src + member_full_src_offset_len) ==
(member_full_src_offset_end - member_full_src_offset_len));
if (member_full_src[member_full_src_offset_end] != '\0') {
const int member_full_tail_len = (member_full_src_len - member_full_src_offset_end);
memcpy(&member_full_dst[i],
&member_full_src[member_full_src_offset_end],
member_full_tail_len + 1);
i += member_full_tail_len;
}
BLI_assert((strlen(elem_dst_full) == elem_final_len) && (i == elem_final_len));
BLI_assert((strlen(member_full_dst) == member_full_dst_len) && (i == member_full_dst_len));
UNUSED_VARS_NDEBUG(i);
return elem_dst_full;
return member_full_dst;
}
/** \} */
@@ -181,16 +186,16 @@ static bool strhash_pair_cmp(const void *a, const void *b)
return (STREQ(pair_a[0], pair_b[0]) && STREQ(pair_a[1], pair_b[1])) ? false : true;
}
void DNA_alias_maps(enum eDNA_RenameDir version_dir, GHash **r_struct_map, GHash **r_elem_map)
void DNA_alias_maps(enum eDNA_RenameDir version_dir, GHash **r_type_map, GHash **r_member_map)
{
GHash *struct_map_local = nullptr;
if (r_struct_map) {
const char *data[][2] = {
GHash *type_map_local = nullptr;
if (r_type_map) {
const char *type_data[][2] = {
#define DNA_STRUCT_RENAME(old, new) {#old, #new},
#define DNA_STRUCT_RENAME_ELEM(struct_name, old, new)
#define DNA_STRUCT_RENAME_MEMBER(struct_name, old, new)
#include "dna_rename_defs.h"
#undef DNA_STRUCT_RENAME
#undef DNA_STRUCT_RENAME_ELEM
#undef DNA_STRUCT_RENAME_MEMBER
};
int elem_key, elem_val;
@@ -202,40 +207,41 @@ void DNA_alias_maps(enum eDNA_RenameDir version_dir, GHash **r_struct_map, GHash
elem_key = 1;
elem_val = 0;
}
GHash *struct_map = BLI_ghash_str_new_ex(__func__, ARRAY_SIZE(data));
for (int i = 0; i < ARRAY_SIZE(data); i++) {
BLI_ghash_insert(struct_map, (void *)data[i][elem_key], (void *)data[i][elem_val]);
GHash *type_map = BLI_ghash_str_new_ex(__func__, ARRAY_SIZE(type_data));
for (int i = 0; i < ARRAY_SIZE(type_data); i++) {
BLI_ghash_insert(type_map, (void *)type_data[i][elem_key], (void *)type_data[i][elem_val]);
}
if (version_dir == DNA_RENAME_STATIC_FROM_ALIAS) {
const char *renames[][2] = {
{"uint8_t", "uchar"},
{"int16_t", "short"},
{"uint16_t", "ushort"},
{"int32_t", "int"},
{"uint32_t", "int"},
/* {old, new}, like in #DNA_STRUCT_RENAME */
{"uchar", "uint8_t"},
{"short", "int16_t"},
{"ushort", "uint16_t"},
{"int", "int32_t"},
{"int", "uint32_t"},
};
for (int i = 0; i < ARRAY_SIZE(renames); i++) {
BLI_ghash_insert(struct_map, (void *)renames[i][0], (void *)renames[i][1]);
BLI_ghash_insert(type_map, (void *)renames[i][elem_key], (void *)renames[i][elem_val]);
}
}
*r_struct_map = struct_map;
*r_type_map = type_map;
/* We know the direction of this, for local use. */
struct_map_local = BLI_ghash_str_new_ex(__func__, ARRAY_SIZE(data));
for (int i = 0; i < ARRAY_SIZE(data); i++) {
BLI_ghash_insert(struct_map_local, (void *)data[i][1], (void *)data[i][0]);
type_map_local = BLI_ghash_str_new_ex(__func__, ARRAY_SIZE(type_data));
for (int i = 0; i < ARRAY_SIZE(type_data); i++) {
BLI_ghash_insert(type_map_local, (void *)type_data[i][1], (void *)type_data[i][0]);
}
}
if (r_elem_map != nullptr) {
const char *data[][3] = {
if (r_member_map != nullptr) {
const char *member_data[][3] = {
#define DNA_STRUCT_RENAME(old, new)
#define DNA_STRUCT_RENAME_ELEM(struct_name, old, new) {#struct_name, #old, #new},
#define DNA_STRUCT_RENAME_MEMBER(struct_name, old, new) {#struct_name, #old, #new},
#include "dna_rename_defs.h"
#undef DNA_STRUCT_RENAME
#undef DNA_STRUCT_RENAME_ELEM
#undef DNA_STRUCT_RENAME_MEMBER
};
int elem_key, elem_val;
@@ -247,21 +253,21 @@ void DNA_alias_maps(enum eDNA_RenameDir version_dir, GHash **r_struct_map, GHash
elem_key = 2;
elem_val = 1;
}
GHash *elem_map = BLI_ghash_new_ex(
strhash_pair_p, strhash_pair_cmp, __func__, ARRAY_SIZE(data));
for (int i = 0; i < ARRAY_SIZE(data); i++) {
GHash *member_map = BLI_ghash_new_ex(
strhash_pair_p, strhash_pair_cmp, __func__, ARRAY_SIZE(member_data));
for (int i = 0; i < ARRAY_SIZE(member_data); i++) {
const char **str_pair = static_cast<const char **>(
MEM_mallocN(sizeof(char *) * 2, __func__));
str_pair[0] = static_cast<const char *>(
BLI_ghash_lookup_default(struct_map_local, data[i][0], (void *)data[i][0]));
str_pair[1] = data[i][elem_key];
BLI_ghash_insert(elem_map, (void *)str_pair, (void *)data[i][elem_val]);
BLI_ghash_lookup_default(type_map_local, member_data[i][0], (void *)member_data[i][0]));
str_pair[1] = member_data[i][elem_key];
BLI_ghash_insert(member_map, (void *)str_pair, (void *)member_data[i][elem_val]);
}
*r_elem_map = elem_map;
*r_member_map = member_map;
}
if (struct_map_local) {
BLI_ghash_free(struct_map_local, nullptr, nullptr);
if (type_map_local) {
BLI_ghash_free(type_map_local, nullptr, nullptr);
}
}
@@ -273,15 +279,15 @@ void DNA_alias_maps(enum eDNA_RenameDir version_dir, GHash **r_struct_map, GHash
/** \name Struct Name Legacy Hack
* \{ */
/* WARNING: Only keep this for compatibility: *NEVER ADD NEW STRINGS HERE*.
*
* The renaming here isn't complete, references to the old struct names
* are still included in DNA, now fixing these struct names properly
* breaks forward compatibility. Leave these as-is, but don't add to them!
* See D4342#98780. */
const char *DNA_struct_rename_legacy_hack_static_from_alias(const char *name)
{
/* Only keep this for compatibility: *NEVER ADD NEW STRINGS HERE*.
*
* The renaming here isn't complete, references to the old struct names
* are still included in DNA, now fixing these struct names properly
* breaks forward compatibility. Leave these as-is, but don't add to them!
* See D4342#98780. */
/* 'bScreen' replaces the old IrisGL 'Screen' struct */
if (STREQ("bScreen", name)) {
return "Screen";

85
source/blender/makesdna/intern/dna_utils.h
View File

@@ -16,53 +16,86 @@ struct GHash;
struct MemArena;
/**
* Parses the `[n1][n2]...` on the end of an array name
* and returns the number of array elements `n1 * n2 ...`.
* Naming convention in this header:
* - `member_full` refers to the full definition of a struct member, including its prefixes (like
* the pointer `*` ones) and suffixes (like the `[]` array ones).
* - `member_id` (for member identifier) refers to the bare name of the struct member (e.g. `var`
* is the member identifier of the `*var[n1][n2]` full member).
*/
int DNA_elem_array_size(const char *str);
uint DNA_elem_id_offset_start(const char *elem_full);
uint DNA_elem_id_offset_end(const char *elem_full);
/**
* \a elem_dst must be at least the size of \a elem_src.
* Parse the `[n1][n2]...` at the end of an array struct member.
*
* \return the total number of array elements `n1 * n2 ...`, or `1` if the member is not an array.
*/
uint DNA_elem_id_strip_copy(char *elem_dst, const char *elem_src);
uint DNA_elem_id_strip(char *elem);
int DNA_member_array_num(const char *str);
/** Find the start offset of the member id (the name) within the full member definition. */
uint DNA_member_id_offset_start(const char *member_full);
/**
* Check if 'var' matches '*var[3]' for eg,
* return true if it does, with start/end offsets.
* Find the end offset of the member id (the name) within the trimmed full member definition.
*
* WARNING: Expects an input string which has already been trimmed from its non-identifier
* prefixes. E.g. passing `*var[n1]` to this function will return `0`, while passing `var[n1]` will
* return the expected `3` value.
*/
bool DNA_elem_id_match(const char *elem_search,
int elem_search_len,
const char *elem_full,
uint *r_elem_full_offset);
uint DNA_member_id_offset_end(const char *member_full_trimmed);
/**
* \return a renamed DNA name, allocated from \a mem_arena.
* Copy the member id part (the bare name) of the full source member into \a member_id_dst.
*
* \param member_id_dst destination char buffer, must be at least the size of \a member_src_full.
*/
char *DNA_elem_id_rename(struct MemArena *mem_arena,
const char *elem_src,
int elem_src_len,
const char *elem_dst,
int elem_dst_len,
const char *elem_src_full,
int elem_src_full_len,
uint elem_src_full_offset_len);
uint DNA_member_id_strip_copy(char *member_id_dst, const char *member_full_src);
/**
* Same as #DNA_member_id_strip_copy, but modifies the given \a member string in place.
*/
uint DNA_member_id_strip(char *member);
/**
* Check if the member identifier given in \a member_id matches the full name given in \a
* member_full. E.g. `var` matches full names like `var` or `*var[3]`, but not `variable`.
*
* \return true if it does, with the start offset of the match in \a r_member_full_offset.
*/
bool DNA_member_id_match(const char *member_id,
int member_id_len,
const char *member_full,
uint *r_member_full_offset);
/**
* Rename a struct member to a different name.
*
* Replace the source member identifier (\a member_id_src) by the destination one
* (\a member_id_dst), while preserving the potential prefixes and suffixes.
*
* \return a renamed DNA full member, allocated from \a mem_arena.
*/
char *DNA_member_id_rename(struct MemArena *mem_arena,
const char *member_id_src,
int member_id_src_len,
const char *member_id_dst,
int member_id_dst_len,
const char *member_full_src,
int member_full_src_len,
uint member_full_src_offset_len);
/**
* When requesting version info, support both directions.
*
* - 'Static' is the original name of the data, the one that is still stored in blendfiles DNA
* info (to avoid breaking forward compatibility).
* - 'Alias' is the current name of the data, the one used in current DNA definition code.
*/
enum eDNA_RenameDir {
DNA_RENAME_STATIC_FROM_ALIAS = -1,
DNA_RENAME_ALIAS_FROM_STATIC = 1,
};
void DNA_alias_maps(enum eDNA_RenameDir version_dir,
struct GHash **r_struct_map,
struct GHash **r_elem_map);
struct GHash **r_type_map,
struct GHash **r_member_map);
const char *DNA_struct_rename_legacy_hack_alias_from_static(const char *name);
/**
* DNA Compatibility Hack.
*/
const char *DNA_struct_rename_legacy_hack_alias_from_static(const char *name);
const char *DNA_struct_rename_legacy_hack_static_from_alias(const char *name);
#ifdef __cplusplus

449
source/blender/makesdna/intern/makesdna.cc
View File

@@ -61,11 +61,11 @@ static const char *includefiles[] = {
static MemArena *mem_arena = nullptr;
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;
static int members_num = 0;
static int types_num = 0;
static int structs_num = 0;
/** At address `members[a]` is string `a`. */
static char **members;
/** At address `types[a]` is string `a`. */
static char **types;
/** At `types_size[a]` is the size of type `a` on this systems bitness (32 or 64). */
@@ -80,18 +80,18 @@ static short *types_size_32;
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_index, name_index), ..] (number of pairs is defined by `sp[1]`),
* - `sp[0]` is type index.
* - `sp[1]` is the length of the member array (next).
* - `sp[2]` sp[3] is [(type_index, member_index), ..] (number of pairs is defined by `sp[1]`),
*/
static short **structs, *structdata;
/** Versioning data */
static struct {
GHash *struct_map_alias_from_static;
GHash *struct_map_static_from_alias;
GHash *elem_map_alias_from_static;
GHash *elem_map_static_from_alias;
GHash *type_map_alias_from_static;
GHash *type_map_static_from_alias;
GHash *member_map_alias_from_static;
GHash *member_map_static_from_alias;
} g_version_data = {nullptr};
/**
@@ -128,25 +128,26 @@ void BLI_system_backtrace(FILE *fp)
* \{ */
/**
* Ensure type \c str to is in the #types array.
* \param str: Struct name without any qualifiers.
* Ensure that type \a type_name is in the #types array.
* \param type_name: Struct name without any qualifiers.
* \param size: The struct size in bytes.
* \return Index in the #types array.
*/
static int add_type(const char *str, int size);
static int add_type(const char *type_name, int size);
/**
* Ensure \c str is int the #names array.
* \param str: Struct member name which may include pointer prefix & array size.
* \return Index in the #names array.
* Ensure that \a member_name is in the #members array.
* \param member_name: Full struct member name (may include pointer prefix & array size).
* \return Index in the #members array.
*/
static int add_name(const char *str);
static int add_member(const char *member_name);
/**
* Search whether this structure type was already found, and if not,
* add it.
* Add a new structure definition, of type matching the given \a type_index.
*
* NOTE: there is no lookup performed here, a new struct definition is always added.
*/
static short *add_struct(int namecode);
static short *add_struct(int type_index);
/**
* Remove comments from this buffer. Assumes that the buffer refers to
@@ -214,45 +215,46 @@ static bool match_identifier_and_advance(char **str_ptr, const char *identifier)
return false;
}
static const char *version_struct_static_from_alias(const char *str)
static const char *version_struct_static_from_alias(const char *type_alias)
{
const char *str_test = static_cast<const char *>(
BLI_ghash_lookup(g_version_data.struct_map_static_from_alias, str));
if (str_test != nullptr) {
return str_test;
const char *type_static = static_cast<const char *>(
BLI_ghash_lookup(g_version_data.type_map_static_from_alias, type_alias));
if (type_static != nullptr) {
return type_static;
}
return str;
return type_alias;
}
static const char *version_struct_alias_from_static(const char *str)
static const char *version_struct_alias_from_static(const char *type_static)
{
const char *str_test = static_cast<const char *>(
BLI_ghash_lookup(g_version_data.struct_map_alias_from_static, str));
if (str_test != nullptr) {
return str_test;
const char *type_alias = static_cast<const char *>(
BLI_ghash_lookup(g_version_data.type_map_alias_from_static, type_static));
if (type_alias != nullptr) {
return type_alias;
}
return str;
return type_static;
}
static const char *version_elem_static_from_alias(const int strct, const char *elem_alias_full)
static const char *version_member_static_from_alias(const int type_index,
const char *member_alias_full)
{
const uint elem_alias_full_len = strlen(elem_alias_full);
char *elem_alias = static_cast<char *>(alloca(elem_alias_full_len + 1));
const int elem_alias_len = DNA_elem_id_strip_copy(elem_alias, elem_alias_full);
const char *str_pair[2] = {types[strct], elem_alias};
const char *elem_static = static_cast<const char *>(
BLI_ghash_lookup(g_version_data.elem_map_static_from_alias, str_pair));
if (elem_static != nullptr) {
return DNA_elem_id_rename(mem_arena,
elem_alias,
elem_alias_len,
elem_static,
strlen(elem_static),
elem_alias_full,
elem_alias_full_len,
DNA_elem_id_offset_start(elem_alias_full));
const uint member_alias_full_len = strlen(member_alias_full);
char *member_alias = static_cast<char *>(alloca(member_alias_full_len + 1));
const int member_alias_len = DNA_member_id_strip_copy(member_alias, member_alias_full);
const char *str_pair[2] = {types[type_index], member_alias};
const char *member_static = static_cast<const char *>(
BLI_ghash_lookup(g_version_data.member_map_static_from_alias, str_pair));
if (member_static != nullptr) {
return DNA_member_id_rename(mem_arena,
member_alias,
member_alias_len,
member_static,
strlen(member_static),
member_alias_full,
member_alias_full_len,
DNA_member_id_offset_start(member_alias_full));
}
return elem_alias_full;
return member_alias_full;
}
/**
@@ -263,7 +265,7 @@ static bool is_name_legal(const char *name)
{
const int name_size = strlen(name) + 1;
char *name_strip = static_cast<char *>(alloca(name_size));
DNA_elem_id_strip_copy(name_strip, name);
DNA_member_id_strip_copy(name_strip, name);
const char prefix[] = {'p', 'a', 'd'};
@@ -298,51 +300,51 @@ static bool is_name_legal(const char *name)
return true;
}
static int add_type(const char *str, int size)
static int add_type(const char *type_name, int size)
{
/* first do validity check */
if (str[0] == 0) {
if (type_name[0] == 0) {
return -1;
}
if (strchr(str, '*')) {
if (strchr(type_name, '*')) {
/* NOTE: this is valid C syntax but we can't parse, complain!
* `struct SomeStruct* some_var;` <-- correct but we can't handle right now. */
return -1;
}
str = version_struct_static_from_alias(str);
type_name = version_struct_static_from_alias(type_name);
/* search through type array */
for (int index = 0; index < types_len; index++) {
if (STREQ(str, types[index])) {
for (int type_index = 0; type_index < types_num; type_index++) {
if (STREQ(type_name, types[type_index])) {
if (size) {
types_size_native[index] = size;
types_size_32[index] = size;
types_size_64[index] = size;
types_align_32[index] = size;
types_align_64[index] = size;
types_size_native[type_index] = size;
types_size_32[type_index] = size;
types_size_64[type_index] = size;
types_align_32[type_index] = size;
types_align_64[type_index] = size;
}
return index;
return type_index;
}
}
/* append new type */
const int str_size = strlen(str) + 1;
char *cp = static_cast<char *>(BLI_memarena_alloc(mem_arena, str_size));
memcpy(cp, str, str_size);
types[types_len] = cp;
types_size_native[types_len] = size;
types_size_32[types_len] = size;
types_size_64[types_len] = size;
types_align_32[types_len] = size;
types_align_64[types_len] = size;
if (types_len >= max_array_len) {
const int type_name_len = strlen(type_name) + 1;
char *cp = static_cast<char *>(BLI_memarena_alloc(mem_arena, type_name_len));
memcpy(cp, type_name, type_name_len);
types[types_num] = cp;
types_size_native[types_num] = size;
types_size_32[types_num] = size;
types_size_64[types_num] = size;
types_align_32[types_num] = size;
types_align_64[types_num] = size;
if (types_num >= max_array_len) {
printf("too many types\n");
return types_len - 1;
return types_num - 1;
}
types_len++;
types_num++;
return types_len - 1;
return types_num - 1;
}
/**
@@ -351,30 +353,30 @@ static int add_type(const char *str, int size)
* we add name and type at the same time... There are two special
* cases, unfortunately. These are explicitly checked.
*/
static int add_name(const char *str)
static int add_member(const char *member_name)
{
char buf[255]; /* stupid limit, change it :) */
const char *name;
additional_slen_offset = 0;
if (str[0] == 0 /* || (str[1] == 0) */) {
if (member_name[0] == 0 /* || (member_name[1] == 0) */) {
return -1;
}
if (str[0] == '(' && str[1] == '*') {
if (member_name[0] == '(' && member_name[1] == '*') {
/* We handle function pointer and special array cases here, e.g.
* `void (*function)(...)` and `float (*array)[..]`. the array case
* name is still converted to (array *)() though because it is that
* way in old DNA too, and works correct with #DNA_struct_member_size. */
int isfuncptr = (strchr(str + 1, '(')) != nullptr;
int isfuncptr = (strchr(member_name + 1, '(')) != nullptr;
DEBUG_PRINTF(3, "\t\t\t\t*** Function pointer or multidim array pointer found\n");
/* function-pointer: transform the type (sometimes). */
int i = 0;
while (str[i] != ')') {
buf[i] = str[i];
while (member_name[i] != ')') {
buf[i] = member_name[i];
i++;
}
@@ -386,38 +388,38 @@ static int add_name(const char *str)
DEBUG_PRINTF(3, "first brace after offset %d\n", i);
j++; /* j beyond closing brace ? */
while ((str[j] != 0) && (str[j] != ')')) {
DEBUG_PRINTF(3, "seen %c (%d)\n", str[j], str[j]);
while ((member_name[j] != 0) && (member_name[j] != ')')) {
DEBUG_PRINTF(3, "seen %c (%d)\n", member_name[j], member_name[j]);
j++;
}
DEBUG_PRINTF(3,
"seen %c (%d)\n"
"special after offset%d\n",
str[j],
str[j],
member_name[j],
member_name[j],
j);
if (!isfuncptr) {
/* multidimensional array pointer case */
if (str[j] == 0) {
if (member_name[j] == 0) {
DEBUG_PRINTF(3, "offsetting for multi-dimensional array pointer\n");
}
else {
printf("Error during tokenizing multi-dimensional array pointer\n");
}
}
else if (str[j] == 0) {
else if (member_name[j] == 0) {
DEBUG_PRINTF(3, "offsetting for space\n");
/* get additional offset */
int k = 0;
while (str[j] != ')') {
while (member_name[j] != ')') {
j++;
k++;
}
DEBUG_PRINTF(3, "extra offset %d\n", k);
additional_slen_offset = k;
}
else if (str[j] == ')') {
else if (member_name[j] == ')') {
DEBUG_PRINTF(3, "offsetting for brace\n");
/* don't get extra offset */
}
@@ -460,13 +462,13 @@ static int add_name(const char *str)
}
else {
/* normal field: old code */
name = str;
name = member_name;
}
/* search name array */
for (int nr = 0; nr < names_len; nr++) {
if (STREQ(name, names[nr])) {
return nr;
for (int member_index = 0; member_index < members_num; member_index++) {
if (STREQ(name, members[member_index])) {
return member_index;
}
}
@@ -476,39 +478,39 @@ static int add_name(const char *str)
}
/* Append new name. */
const int name_size = strlen(name) + 1;
char *cp = static_cast<char *>(BLI_memarena_alloc(mem_arena, name_size));
memcpy(cp, name, name_size);
names[names_len] = cp;
const int name_len = strlen(name) + 1;
char *cp = static_cast<char *>(BLI_memarena_alloc(mem_arena, name_len));
memcpy(cp, name, name_len);
members[members_num] = cp;
if (names_len >= max_array_len) {
if (members_num >= max_array_len) {
printf("too many names\n");
return names_len - 1;
return members_num - 1;
}
names_len++;
members_num++;
return names_len - 1;
return members_num - 1;
}
static short *add_struct(int namecode)
static short *add_struct(int type_index)
{
if (structs_len == 0) {
if (structs_num == 0) {
structs[0] = structdata;
}
else {
short *sp = structs[structs_len - 1];
short *sp = structs[structs_num - 1];
const int len = sp[1];
structs[structs_len] = sp + 2 * len + 2;
structs[structs_num] = sp + 2 * len + 2;
}
short *sp = structs[structs_len];
sp[0] = namecode;
short *sp = structs[structs_num];
sp[0] = type_index;
if (structs_len >= max_array_len) {
if (structs_num >= max_array_len) {
printf("too many structs\n");
return sp;
}
structs_len++;
structs_num++;
return sp;
}
@@ -746,16 +748,16 @@ static int convert_include(const char *filepath)
/* we've got a struct name when... */
if (match_identifier(md1 - 7, "struct")) {
const int strct = add_type(md1, 0);
if (strct == -1) {
const int struct_type_index = add_type(md1, 0);
if (struct_type_index == -1) {
fprintf(stderr, "File '%s' contains struct we can't parse \"%s\"\n", filepath, md1);
return 1;
}
short *structpoin = add_struct(strct);
short *structpoin = add_struct(struct_type_index);
short *sp = structpoin + 2;
DEBUG_PRINTF(1, "\t|\t|-- detected struct %s\n", types[strct]);
DEBUG_PRINTF(1, "\t|\t|-- detected struct %s\n", types[struct_type_index]);
/* first lets make it all nice strings */
md1 = md + 1;
@@ -807,8 +809,8 @@ static int convert_include(const char *filepath)
md1);
return -1;
}
const int type = add_type(md1, 0);
if (type == -1) {
const int member_type_index = add_type(md1, 0);
if (member_type_index == -1) {
fprintf(
stderr, "File '%s' contains struct we can't parse \"%s\"\n", filepath, md1);
return 1;
@@ -832,7 +834,8 @@ static int convert_include(const char *filepath)
if (md1[slen - 1] == ';') {
md1[slen - 1] = 0;
const int name = add_name(version_elem_static_from_alias(strct, md1));
const int name = add_member(
version_member_static_from_alias(struct_type_index, md1));
if (name == -1) {
fprintf(stderr,
"File '%s' contains struct with name that can't be added \"%s\"\n",
@@ -841,11 +844,11 @@ static int convert_include(const char *filepath)
return 1;
}
slen += additional_slen_offset;
sp[0] = type;
sp[0] = member_type_index;
sp[1] = name;
if (names[name] != nullptr) {
DEBUG_PRINTF(1, "%s |", names[name]);
if (members[name] != nullptr) {
DEBUG_PRINTF(1, "%s |", members[name]);
}
structpoin[1]++;
@@ -855,7 +858,8 @@ static int convert_include(const char *filepath)
break;
}
const int name = add_name(version_elem_static_from_alias(strct, md1));
const int name = add_member(
version_member_static_from_alias(struct_type_index, md1));
if (name == -1) {
fprintf(stderr,
"File '%s' contains struct with name that can't be added \"%s\"\n",
@@ -865,10 +869,10 @@ static int convert_include(const char *filepath)
}
slen += additional_slen_offset;
sp[0] = type;
sp[0] = member_type_index;
sp[1] = name;
if (names[name] != nullptr) {
DEBUG_PRINTF(1, "%s ||", names[name]);
if (members[name] != nullptr) {
DEBUG_PRINTF(1, "%s ||", members[name]);
}
structpoin[1]++;
@@ -895,15 +899,19 @@ static int convert_include(const char *filepath)
return 0;
}
static bool check_field_alignment(
int firststruct, int structtype, int type, int len, const char *name, const char *detail)
static bool check_field_alignment(int firststruct,
int struct_type_index,
int type,
int len,
const char *name,
const char *detail)
{
bool result = true;
if (type < firststruct && types_size_native[type] > 4 && (len % 8)) {
fprintf(stderr,
"Align 8 error (%s) in struct: %s %s (add %d padding bytes)\n",
detail,
types[structtype],
types[struct_type_index],
name,
len % 8);
result = false;
@@ -912,7 +920,7 @@ static bool check_field_alignment(
fprintf(stderr,
"Align 4 error (%s) in struct: %s %s (add %d padding bytes)\n",
detail,
types[structtype],
types[struct_type_index],
name,
len % 4);
result = false;
@@ -921,7 +929,7 @@ static bool check_field_alignment(
fprintf(stderr,
"Align 2 error (%s) in struct: %s %s (add %d padding bytes)\n",
detail,
types[structtype],
types[struct_type_index],
name,
len % 2);
result = false;
@@ -948,19 +956,19 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
fprintf(file_verify, "\n");
/* Multiple iterations to handle nested structs. */
int unknown = structs_len;
int unknown = structs_num;
while (unknown) {
const int lastunknown = unknown;
unknown = 0;
/* check all structs... */
for (int a = 0; a < structs_len; a++) {
for (int a = 0; a < structs_num; a++) {
const short *structpoin = structs[a];
const int structtype = structpoin[0];
const char *structname = version_struct_alias_from_static(types[structtype]);
const int struct_type_index = structpoin[0];
const char *struct_type_name = version_struct_alias_from_static(types[struct_type_index]);
/* when length is not known... */
if (types_size_native[structtype] == 0) {
if (types_size_native[struct_type_index] == 0) {
const short *sp = structpoin + 2;
int size_native = 0;
@@ -970,10 +978,10 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
int max_align_32 = 0;
int max_align_64 = 0;
/* check all elements in struct */
/* check all members in struct */
for (int b = 0; b < structpoin[1]; b++, sp += 2) {
int type = sp[0];
const char *cp = names[sp[1]];
const char *cp = members[sp[1]];
int namelen = int(strlen(cp));
/* Write size verification to file. */
@@ -983,14 +991,14 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
char name_static[1024];
BLI_assert(sizeof(name_static) > namelen);
DNA_elem_id_strip_copy(name_static, cp);
const char *str_pair[2] = {types[structtype], name_static};
DNA_member_id_strip_copy(name_static, cp);
const char *str_pair[2] = {types[struct_type_index], name_static};
const char *name_alias = static_cast<const char *>(
BLI_ghash_lookup(g_version_data.elem_map_alias_from_static, str_pair));
BLI_ghash_lookup(g_version_data.member_map_alias_from_static, str_pair));
fprintf(file_verify,
"BLI_STATIC_ASSERT(offsetof(struct %s, %s) == %d, \"DNA member offset "
"verify\");\n",
structname,
struct_type_name,
name_alias ? name_alias : name_static,
size_native);
}
@@ -1000,13 +1008,13 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
/* has the name an extra length? (array) */
int mul = 1;
if (cp[namelen - 1] == ']') {
mul = DNA_elem_array_size(cp);
mul = DNA_member_array_num(cp);
}
if (mul == 0) {
fprintf(stderr,
"Zero array size found or could not parse %s: '%.*s'\n",
types[structtype],
types[struct_type_index],
namelen + 1,
cp);
dna_error = true;
@@ -1017,7 +1025,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
if (size_native % 4) {
fprintf(stderr,
"Align pointer error in struct (size_native 4): %s %s\n",
types[structtype],
types[struct_type_index],
cp);
dna_error = true;
}
@@ -1026,7 +1034,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
if (size_native % 8) {
fprintf(stderr,
"Align pointer error in struct (size_native 8): %s %s\n",
types[structtype],
types[struct_type_index],
cp);
dna_error = true;
}
@@ -1035,7 +1043,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
if (size_64 % 8) {
fprintf(stderr,
"Align pointer error in struct (size_64 8): %s %s\n",
types[structtype],
types[struct_type_index],
cp);
dna_error = true;
}
@@ -1051,7 +1059,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
* to be found for "float var [3]" */
fprintf(stderr,
"Parse error in struct, invalid member name: %s %s\n",
types[structtype],
types[struct_type_index],
cp);
dna_error = true;
}
@@ -1059,13 +1067,13 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
/* has the name an extra length? (array) */
int mul = 1;
if (cp[namelen - 1] == ']') {
mul = DNA_elem_array_size(cp);
mul = DNA_member_array_num(cp);
}
if (mul == 0) {
fprintf(stderr,
"Zero array size found or could not parse %s: '%.*s'\n",
types[structtype],
types[struct_type_index],
namelen + 1,
cp);
dna_error = true;
@@ -1077,7 +1085,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
fprintf(stderr,
"Align struct error: %s::%s (starts at %d on the native platform; "
"%d %% %zu = %d bytes)\n",
types[structtype],
types[struct_type_index],
cp,
size_native,
size_native,
@@ -1088,10 +1096,14 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
}
/* Check 2-4-8 aligned. */
if (!check_field_alignment(firststruct, structtype, type, size_32, cp, "32 bit")) {
if (!check_field_alignment(
firststruct, struct_type_index, type, size_32, cp, "32 bit"))
{
dna_error = true;
}
if (!check_field_alignment(firststruct, structtype, type, size_64, cp, "64 bit")) {
if (!check_field_alignment(
firststruct, struct_type_index, type, size_64, cp, "64 bit"))
{
dna_error = true;
}
@@ -1113,11 +1125,11 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
unknown++;
}
else {
types_size_native[structtype] = size_native;
types_size_32[structtype] = size_32;
types_size_64[structtype] = size_64;
types_align_32[structtype] = max_align_32;
types_align_64[structtype] = max_align_64;
types_size_native[struct_type_index] = size_native;
types_size_32[struct_type_index] = size_32;
types_size_64[struct_type_index] = size_64;
types_align_32[struct_type_index] = max_align_32;
types_align_64[struct_type_index] = max_align_64;
/* Sanity check 1: alignment should never be 0. */
BLI_assert(max_align_32);
@@ -1135,12 +1147,12 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
if ((size_64 % max_align_64 == 0) && (size_32 % max_align_32 == 4)) {
fprintf(stderr,
"Sizeerror in 32 bit struct: %s (add padding pointer)\n",
types[structtype]);
types[struct_type_index]);
}
else {
fprintf(stderr,
"Sizeerror in 32 bit struct: %s (add %d bytes)\n",
types[structtype],
types[struct_type_index],
max_align_32 - (size_32 % max_align_32));
}
dna_error = true;
@@ -1149,7 +1161,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
if (size_64 % max_align_64) {
fprintf(stderr,
"Sizeerror in 64 bit struct: %s (add %d bytes)\n",
types[structtype],
types[struct_type_index],
max_align_64 - (size_64 % max_align_64));
dna_error = true;
}
@@ -1157,7 +1169,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
if (size_native % 4 && !ELEM(size_native, 1, 2)) {
fprintf(stderr,
"Sizeerror 4 in struct: %s (add %d bytes)\n",
types[structtype],
types[struct_type_index],
size_native % 4);
dna_error = true;
}
@@ -1165,7 +1177,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
/* Write size verification to file. */
fprintf(file_verify,
"BLI_STATIC_ASSERT(sizeof(struct %s) == %d, \"DNA struct size verify\");\n\n",
structname,
struct_type_name,
size_native);
}
}
@@ -1182,7 +1194,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 < structs_len; a++) {
for (int a = 0; a < structs_num; a++) {
const short *structpoin = structs[a];
const int structtype = structpoin[0];
@@ -1195,7 +1207,7 @@ static int calculate_struct_sizes(int firststruct, FILE *file_verify, const char
fprintf(stderr, "*** Unknown structs :\n");
for (int a = 0; a < structs_len; a++) {
for (int a = 0; a < structs_num; a++) {
const short *structpoin = structs[a];
const int structtype = structpoin[0];
@@ -1230,14 +1242,14 @@ static void dna_write(FILE *file, const void *pntr, const int size)
void print_struct_sizes()
{
int unknown = structs_len;
int unknown = structs_num;
printf("\n\n*** All detected structs:\n");
while (unknown) {
unknown = 0;
/* check all structs... */
for (int a = 0; a < structs_len; a++) {
for (int a = 0; a < structs_num; a++) {
const short *structpoin = structs[a];
const int structtype = structpoin[0];
printf("\t%s\t:%d\n", types[structtype], types_size_native[structtype]);
@@ -1263,7 +1275,7 @@ static int make_structDNA(const char *base_directory,
structdata = static_cast<short *>(MEM_callocN(max_data_size, "structdata"));
/* a maximum of 5000 variables, must be sufficient? */
names = static_cast<char **>(MEM_callocN(sizeof(char *) * max_array_len, "names"));
members = static_cast<char **>(MEM_callocN(sizeof(char *) * max_array_len, "names"));
types = static_cast<char **>(MEM_callocN(sizeof(char *) * max_array_len, "types"));
types_size_native = static_cast<short *>(
MEM_callocN(sizeof(short) * max_array_len, "types_size_native"));
@@ -1280,11 +1292,11 @@ static int make_structDNA(const char *base_directory,
/* Build versioning data */
DNA_alias_maps(DNA_RENAME_ALIAS_FROM_STATIC,
&g_version_data.struct_map_alias_from_static,
&g_version_data.elem_map_alias_from_static);
&g_version_data.type_map_alias_from_static,
&g_version_data.member_map_alias_from_static);
DNA_alias_maps(DNA_RENAME_STATIC_FROM_ALIAS,
&g_version_data.struct_map_static_from_alias,
&g_version_data.elem_map_static_from_alias);
&g_version_data.type_map_static_from_alias,
&g_version_data.member_map_static_from_alias);
/**
* Insertion of all known types.
@@ -1312,7 +1324,7 @@ static int make_structDNA(const char *base_directory,
add_type("int8_t", 1); /* SDNA_TYPE_INT8 */
/* the defines above shouldn't be output in the padding file... */
const int firststruct = types_len;
const int firststruct = types_num;
/* Add all include files defined in the global array.
* Since the internal file+path name buffer has limited length,
@@ -1343,30 +1355,29 @@ static int make_structDNA(const char *base_directory,
if (debugSDNA > 1) {
int a, b;
// short *elem;
short num_types;
short struct_members_num;
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("names_len %d types_len %d structs_len %d\n", members_num, types_num, structs_num);
for (a = 0; a < members_num; a++) {
printf(" %s\n", members[a]);
}
printf("\n");
const short *sp = types_size_native;
for (a = 0; a < types_len; a++, sp++) {
for (a = 0; a < types_num; a++, sp++) {
printf(" %s %d\n", types[a], *sp);
}
printf("\n");
for (a = 0; a < structs_len; a++) {
for (a = 0; a < structs_num; 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];
struct_members_num = sp[1];
sp += 2;
/* ? num_types was elem? */
for (b = 0; b < num_types; b++, sp += 2) {
for (b = 0; b < struct_members_num; b++, sp += 2) {
printf(" %s %s allign32:%d, allign64:%d\n",
types[sp[0]],
names[sp[1]],
members[sp[1]],
types_align_32[sp[0]],
types_align_64[sp[0]]);
}
@@ -1377,7 +1388,7 @@ static int make_structDNA(const char *base_directory,
DEBUG_PRINTF(0, "Writing file ... ");
if (names_len == 0 || structs_len == 0) {
if (members_num == 0 || structs_num == 0) {
/* pass */
}
else {
@@ -1387,14 +1398,14 @@ static int make_structDNA(const char *base_directory,
/* write names */
dna_write(file, "NAME", 4);
int len = names_len;
int len = members_num;
dna_write(file, &len, 4);
/* write array */
len = 0;
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;
for (int member_index = 0; member_index < members_num; member_index++) {
int member_len = strlen(members[member_index]) + 1;
dna_write(file, members[member_index], member_len);
len += member_len;
}
int len_align = (len + 3) & ~3;
if (len != len_align) {
@@ -1403,14 +1414,14 @@ static int make_structDNA(const char *base_directory,
/* write TYPES */
dna_write(file, "TYPE", 4);
len = types_len;
len = types_num;
dna_write(file, &len, 4);
/* write array */
len = 0;
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;
for (int type_index = 0; type_index < types_num; type_index++) {
int type_len = strlen(types[type_index]) + 1;
dna_write(file, types[type_index], type_len);
len += type_len;
}
len_align = (len + 3) & ~3;
if (len != len_align) {
@@ -1420,19 +1431,19 @@ static int make_structDNA(const char *base_directory,
/* WRITE TYPELENGTHS */
dna_write(file, "TLEN", 4);
len = 2 * types_len;
if (types_len & 1) {
len = 2 * types_num;
if (types_num & 1) {
len += 2;
}
dna_write(file, types_size_native, len);
/* WRITE STRUCTS */
dna_write(file, "STRC", 4);
len = structs_len;
len = structs_num;
dna_write(file, &len, 4);
/* calc datablock size */
const short *sp = structs[structs_len - 1];
const short *sp = structs[structs_num - 1];
sp += 2 + 2 * (sp[1]);
len = intptr_t((char *)sp - (char *)structs[0]);
len = (len + 3) & ~3;
@@ -1446,46 +1457,46 @@ static int make_structDNA(const char *base_directory,
fprintf(file_offsets, "#pragma once\n");
fprintf(file_offsets, "#define SDNA_TYPE_FROM_STRUCT(id) _SDNA_TYPE_##id\n");
fprintf(file_offsets, "enum {\n");
for (int i = 0; i < structs_len; i++) {
for (int i = 0; i < structs_num; i++) {
const short *structpoin = structs[i];
const int structtype = structpoin[0];
const int struct_type_index = structpoin[0];
fprintf(file_offsets,
"\t_SDNA_TYPE_%s = %d,\n",
version_struct_alias_from_static(types[structtype]),
version_struct_alias_from_static(types[struct_type_index]),
i);
}
fprintf(file_offsets, "\tSDNA_TYPE_MAX = %d,\n", structs_len);
fprintf(file_offsets, "\tSDNA_TYPE_MAX = %d,\n", structs_num);
fprintf(file_offsets, "};\n\n");
}
/* Check versioning errors which could cause duplicate names,
* do last because names are stripped. */
{
GSet *names_unique = BLI_gset_str_new_ex(__func__, 512);
for (int struct_nr = 0; struct_nr < structs_len; struct_nr++) {
const short *sp = structs[struct_nr];
const char *struct_name = types[sp[0]];
GSet *members_unique = BLI_gset_str_new_ex(__func__, 512);
for (int struct_index = 0; struct_index < structs_num; struct_index++) {
const short *sp = structs[struct_index];
const char *type = types[sp[0]];
const int len = sp[1];
sp += 2;
for (int a = 0; a < len; a++, sp += 2) {
char *name = names[sp[1]];
DNA_elem_id_strip(name);
if (!BLI_gset_add(names_unique, name)) {
char *member = members[sp[1]];
DNA_member_id_strip(member);
if (!BLI_gset_add(members_unique, member)) {
fprintf(stderr,
"Error: duplicate name found '%s.%s', "
"likely cause is 'dna_rename_defs.h'\n",
struct_name,
name);
type,
member);
return 1;
}
}
BLI_gset_clear(names_unique, nullptr);
BLI_gset_clear(members_unique, nullptr);
}
BLI_gset_free(names_unique, nullptr);
BLI_gset_free(members_unique, nullptr);
}
MEM_freeN(structdata);
MEM_freeN(names);
MEM_freeN(members);
MEM_freeN(types);
MEM_freeN(types_size_native);
MEM_freeN(types_size_32);
@@ -1496,10 +1507,10 @@ static int make_structDNA(const char *base_directory,
BLI_memarena_free(mem_arena);
BLI_ghash_free(g_version_data.struct_map_alias_from_static, nullptr, nullptr);
BLI_ghash_free(g_version_data.struct_map_static_from_alias, nullptr, nullptr);
BLI_ghash_free(g_version_data.elem_map_static_from_alias, MEM_freeN, nullptr);
BLI_ghash_free(g_version_data.elem_map_alias_from_static, MEM_freeN, nullptr);
BLI_ghash_free(g_version_data.type_map_alias_from_static, nullptr, nullptr);
BLI_ghash_free(g_version_data.type_map_static_from_alias, nullptr, nullptr);
BLI_ghash_free(g_version_data.member_map_static_from_alias, MEM_freeN, nullptr);
BLI_ghash_free(g_version_data.member_map_alias_from_static, MEM_freeN, nullptr);
DEBUG_PRINTF(0, "done.\n");
@@ -1634,10 +1645,10 @@ int main(int argc, char **argv)
static void UNUSED_FUNCTION(dna_rename_defs_ensure)()
{
#define DNA_STRUCT_RENAME(old, new) (void)sizeof(new);
#define DNA_STRUCT_RENAME_ELEM(struct_name, old, new) (void)offsetof(struct_name, new);
#define DNA_STRUCT_RENAME_MEMBER(struct_name, old, new) (void)offsetof(struct_name, new);
#include "dna_rename_defs.h"
#undef DNA_STRUCT_RENAME
#undef DNA_STRUCT_RENAME_ELEM
#undef DNA_STRUCT_RENAME_MEMBER
}
/** \} */

50
source/blender/makesrna/intern/rna_define.cc
View File

@@ -64,7 +64,7 @@ BlenderDefRNA DefRNA = {
#ifndef RNA_RUNTIME
static struct {
GHash *struct_map_static_from_alias;
GHash *type_map_static_from_alias;
} g_version_data;
#endif
@@ -202,17 +202,17 @@ static void rna_brna_structs_remove_and_free(BlenderRNA *brna, StructRNA *srna)
}
#endif
static int DNA_struct_find_nr_wrapper(const SDNA *sdna, const char *struct_name)
static int DNA_struct_find_index_wrapper(const SDNA *sdna, const char *type_name)
{
struct_name = DNA_struct_rename_legacy_hack_static_from_alias(struct_name);
type_name = DNA_struct_rename_legacy_hack_static_from_alias(type_name);
#ifdef RNA_RUNTIME
/* We may support this at some point but for now we don't. */
BLI_assert_unreachable();
#else
struct_name = static_cast<const char *>(BLI_ghash_lookup_default(
g_version_data.struct_map_static_from_alias, struct_name, (void *)struct_name));
type_name = static_cast<const char *>(BLI_ghash_lookup_default(
g_version_data.type_map_static_from_alias, type_name, (void *)type_name));
#endif
return DNA_struct_find_without_alias(sdna, struct_name);
return DNA_struct_find_index_without_alias(sdna, type_name);
}
StructDefRNA *rna_find_struct_def(StructRNA *srna)
@@ -448,7 +448,7 @@ static int rna_find_sdna_member(SDNA *sdna,
CLOG_ERROR(&LOG, "only during preprocessing.");
return 0;
}
structnr = DNA_struct_find_nr_wrapper(sdna, structname);
structnr = DNA_struct_find_index_wrapper(sdna, structname);
smember->offset = -1;
if (structnr == -1) {
@@ -457,14 +457,14 @@ static int rna_find_sdna_member(SDNA *sdna,
}
const SDNA_Struct *struct_info = sdna->structs[structnr];
for (int a = 0; a < struct_info->members_len; a++) {
for (int a = 0; a < struct_info->members_num; a++) {
const SDNA_StructMember *member = &struct_info->members[a];
const int size = DNA_struct_member_size(sdna, member->type, member->name);
dnaname = sdna->alias.names[member->name];
const int size = DNA_struct_member_size(sdna, member->type_index, member->member_index);
dnaname = sdna->alias.members[member->member_index];
cmp = rna_member_cmp(dnaname, membername);
if (cmp == 1) {
smember->type = sdna->alias.types[member->type];
smember->type = sdna->alias.types[member->type_index];
smember->name = dnaname;
smember->offset = *offset;
smember->size = size;
@@ -473,7 +473,7 @@ static int rna_find_sdna_member(SDNA *sdna,
smember->arraylength = 0;
}
else {
smember->arraylength = DNA_elem_array_size(smember->name);
smember->arraylength = DNA_member_array_num(smember->name);
}
smember->pointerlevel = 0;
@@ -492,7 +492,8 @@ static int rna_find_sdna_member(SDNA *sdna,
smember->arraylength = 0;
membername = strstr(membername, ".") + strlen(".");
rna_find_sdna_member(sdna, sdna->alias.types[member->type], membername, smember, offset);
rna_find_sdna_member(
sdna, sdna->alias.types[member->type_index], membername, smember, offset);
return 1;
}
@@ -506,7 +507,8 @@ static int rna_find_sdna_member(SDNA *sdna,
*offset = -1;
membername = strstr(membername, "->") + strlen("->");
rna_find_sdna_member(sdna, sdna->alias.types[member->type], membername, smember, offset);
rna_find_sdna_member(
sdna, sdna->alias.types[member->type_index], membername, smember, offset);
return 1;
}
@@ -721,7 +723,7 @@ BlenderRNA *RNA_create()
#ifndef RNA_RUNTIME
DNA_alias_maps(
DNA_RENAME_STATIC_FROM_ALIAS, &g_version_data.struct_map_static_from_alias, nullptr);
DNA_RENAME_STATIC_FROM_ALIAS, &g_version_data.type_map_static_from_alias, nullptr);
#endif
return brna;
@@ -887,8 +889,8 @@ void RNA_free(BlenderRNA *brna)
}
#ifndef RNA_RUNTIME
BLI_ghash_free(g_version_data.struct_map_static_from_alias, nullptr, nullptr);
g_version_data.struct_map_static_from_alias = nullptr;
BLI_ghash_free(g_version_data.type_map_static_from_alias, nullptr, nullptr);
g_version_data.type_map_static_from_alias = nullptr;
#endif
}
@@ -1092,7 +1094,7 @@ void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
* names, this can't be checked without adding an option to disable
* (tested this and it means changes all over). */
#if 0
if (DNA_struct_find_nr_wrapper(DefRNA.sdna, structname) == -1) {
if (DNA_struct_find_index_wrapper(DefRNA.sdna, structname) == -1) {
if (!DefRNA.silent) {
CLOG_ERROR(&LOG, "%s not found.", structname);
DefRNA.error = true;
@@ -1120,7 +1122,7 @@ void RNA_def_struct_sdna_from(StructRNA *srna, const char *structname, const cha
return;
}
if (DNA_struct_find_nr_wrapper(DefRNA.sdna, structname) == -1) {
if (DNA_struct_find_index_wrapper(DefRNA.sdna, structname) == -1) {
if (!DefRNA.silent) {
CLOG_ERROR(&LOG, "%s not found.", structname);
DefRNA.error = true;
@@ -2367,7 +2369,7 @@ void RNA_def_property_boolean_sdna(PropertyRNA *prop,
#ifndef RNA_RUNTIME
/* Set the default if possible. */
if (dp->dnaoffset != -1) {
int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
int SDNAnr = DNA_struct_find_index_wrapper(DefRNA.sdna, dp->dnastructname);
if (SDNAnr != -1) {
const void *default_data = DNA_default_table[SDNAnr];
if (default_data) {
@@ -2496,7 +2498,7 @@ void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const
#ifndef RNA_RUNTIME
/* Set the default if possible. */
if (dp->dnaoffset != -1) {
int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
int SDNAnr = DNA_struct_find_index_wrapper(DefRNA.sdna, dp->dnastructname);
if (SDNAnr != -1) {
const void *default_data = DNA_default_table[SDNAnr];
if (default_data) {
@@ -2628,7 +2630,7 @@ void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, cons
#ifndef RNA_RUNTIME
/* Set the default if possible. */
if (dp->dnaoffset != -1) {
int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
int SDNAnr = DNA_struct_find_index_wrapper(DefRNA.sdna, dp->dnastructname);
if (SDNAnr != -1) {
const void *default_data = DNA_default_table[SDNAnr];
if (default_data) {
@@ -2724,7 +2726,7 @@ void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const
#ifndef RNA_RUNTIME
/* Set the default if possible. */
if (dp->dnaoffset != -1) {
int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
int SDNAnr = DNA_struct_find_index_wrapper(DefRNA.sdna, dp->dnastructname);
if (SDNAnr != -1) {
const void *default_data = DNA_default_table[SDNAnr];
if (default_data) {
@@ -2814,7 +2816,7 @@ void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, con
#ifndef RNA_RUNTIME
/* Set the default if possible. */
if ((dp->dnaoffset != -1) && (dp->dnapointerlevel != 0)) {
int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
int SDNAnr = DNA_struct_find_index_wrapper(DefRNA.sdna, dp->dnastructname);
if (SDNAnr != -1) {
const void *default_data = DNA_default_table[SDNAnr];
if (default_data) {