patch [#34103] check_for_dupid.patch

from Lawrence D'Oliveiro (ldo)

- more comments
- more uses of bool type
- define symbol for length of in_use array in check_for_dupid

4 files changed, 154 insertions, 112 deletions

diff --git a/source/blender/blenkernel/intern/anim_sys.c b/source/blender/blenkernel/intern/anim_sys.c
index 74e44eab281..d9089a58f03 100644
--- a/source/blender/blenkernel/intern/anim_sys.c
+++ b/source/blender/blenkernel/intern/anim_sys.c
@@ -242,7 +242,7 @@ void BKE_free_animdata(ID *id)
 /* Freeing -------------------------------------------- */
 
 /* Make a copy of the given AnimData - to be used when copying datablocks */
-AnimData *BKE_copy_animdata(AnimData *adt, const short do_action)
+AnimData *BKE_copy_animdata(AnimData *adt, const bool do_action)
 {
 	AnimData *dadt;
 	
@@ -274,7 +274,7 @@ AnimData *BKE_copy_animdata(AnimData *adt, const short do_action)
 	return dadt;
 }
 
-int BKE_copy_animdata_id(ID *id_to, ID *id_from, const short do_action)
+int BKE_copy_animdata_id(ID *id_to, ID *id_from, const bool do_action)
 {
 	AnimData *adt;
 
diff --git a/source/blender/blenkernel/intern/blender.c b/source/blender/blenkernel/intern/blender.c
index 9a21a9648c9..82b3b4f5618 100644
--- a/source/blender/blenkernel/intern/blender.c
+++ b/source/blender/blenkernel/intern/blender.c
@@ -995,7 +995,7 @@ int BKE_copybuffer_paste(bContext *C, char *libname, ReportList *reports)
 	
 	/* append, rather than linking */
 	lib = BLI_findstring(&bmain->library, libname, offsetof(Library, filepath));
-	BKE_library_make_local(bmain, lib, 1);
+	BKE_library_make_local(bmain, lib, true);
 	
 	/* important we unset, otherwise these object wont
 	 * link into other scenes from this blend file */
diff --git a/source/blender/blenkernel/intern/library.c b/source/blender/blenkernel/intern/library.c
index 0c5e2b89cf7..c95576ec8e7 100644
--- a/source/blender/blenkernel/intern/library.c
+++ b/source/blender/blenkernel/intern/library.c
@@ -171,6 +171,7 @@ void id_us_plus(ID *id)
 	}
 }
 
+/* decrements the user count for *id. */
 void id_us_min(ID *id)
 {
 	if (id) {
@@ -186,102 +187,108 @@ void id_us_min(ID *id)
 	}
 }
 
-int id_make_local(ID *id, int test)
+/* calls the appropriate make_local method for the block, unless test. Returns true
+ * if the block can be made local. */
+bool id_make_local(ID *id, bool test)
 {
 	if (id->flag & LIB_INDIRECT)
-		return 0;
+		return false;
 
 	switch (GS(id->name)) {
 		case ID_SCE:
-			return 0; /* not implemented */
+			return false; /* not implemented */
 		case ID_LI:
-			return 0; /* can't be linked */
+			return false; /* can't be linked */
 		case ID_OB:
 			if (!test) BKE_object_make_local((Object *)id);
-			return 1;
+			return true;
 		case ID_ME:
 			if (!test) {
 				BKE_mesh_make_local((Mesh *)id);
 				BKE_key_make_local(((Mesh *)id)->key);
 			}
-			return 1;
+			return true;
 		case ID_CU:
 			if (!test) {
 				BKE_curve_make_local((Curve *)id);
 				BKE_key_make_local(((Curve *)id)->key);
 			}
-			return 1;
+			return true;
 		case ID_MB:
 			if (!test) BKE_mball_make_local((MetaBall *)id);
-			return 1;
+			return true;
 		case ID_MA:
 			if (!test) BKE_material_make_local((Material *)id);
-			return 1;
+			return true;
 		case ID_TE:
 			if (!test) BKE_texture_make_local((Tex *)id);
-			return 1;
+			return true;
 		case ID_IM:
 			if (!test) BKE_image_make_local((Image *)id);
-			return 1;
+			return true;
 		case ID_LT:
 			if (!test) {
 				BKE_lattice_make_local((Lattice *)id);
 				BKE_key_make_local(((Lattice *)id)->key);
 			}
-			return 1;
+			return true;
 		case ID_LA:
 			if (!test) BKE_lamp_make_local((Lamp *)id);
-			return 1;
+			return true;
 		case ID_CA:
 			if (!test) BKE_camera_make_local((Camera *)id);
-			return 1;
+			return true;
 		case ID_SPK:
 			if (!test) BKE_speaker_make_local((Speaker *)id);
-			return 1;
+			return true;
 		case ID_IP:
-			return 0; /* deprecated */
+			return false; /* deprecated */
 		case ID_KE:
 			if (!test) BKE_key_make_local((Key *)id);
-			return 1;
+			return true;
 		case ID_WO:
 			if (!test) BKE_world_make_local((World *)id);
-			return 1;
+			return true;
 		case ID_SCR:
-			return 0; /* can't be linked */
+			return false; /* can't be linked */
 		case ID_VF:
-			return 0; /* not implemented */
+			return false; /* not implemented */
 		case ID_TXT:
-			return 0; /* not implemented */
+			return false; /* not implemented */
 		case ID_SCRIPT:
-			return 0; /* deprecated */
+			return false; /* deprecated */
 		case ID_SO:
-			return 0; /* not implemented */
+			return false; /* not implemented */
 		case ID_GR:
-			return 0; /* not implemented */
+			return false; /* not implemented */
 		case ID_AR:
 			if (!test) BKE_armature_make_local((bArmature *)id);
-			return 1;
+			return true;
 		case ID_AC:
 			if (!test) BKE_action_make_local((bAction *)id);
-			return 1;
+			return true;
 		case ID_NT:
-			return 0; /* not implemented */
+			return false; /* not implemented */
 		case ID_BR:
 			if (!test) BKE_brush_make_local((Brush *)id);
-			return 1;
+			return true;
 		case ID_PA:
 			if (!test) BKE_particlesettings_make_local((ParticleSettings *)id);
-			return 1;
+			return true;
 		case ID_WM:
-			return 0; /* can't be linked */
+			return false; /* can't be linked */
 		case ID_GD:
-			return 0; /* not implemented */
+			return false; /* not implemented */
 	}
 
-	return 0;
+	return false;
 }
 
-int id_copy(ID *id, ID **newid, int test)
+/**
+ * Invokes the appropriate copy method for the block and returns the result in
+ * newid, unless test. Returns true iff the block can be copied.
+ */
+bool id_copy(ID *id, ID **newid, bool test)
 {
 	if (!test) *newid = NULL;
 
@@ -290,124 +297,124 @@ int id_copy(ID *id, ID **newid, int test)
 	 * - id.us of the new ID is set to 1 */
 	switch (GS(id->name)) {
 		case ID_SCE:
-			return 0; /* can't be copied from here */
+			return false;  /* can't be copied from here */
 		case ID_LI:
-			return 0; /* can't be copied from here */
+			return false;  /* can't be copied from here */
 		case ID_OB:
 			if (!test) *newid = (ID *)BKE_object_copy((Object *)id);
-			return 1;
+			return true;
 		case ID_ME:
 			if (!test) *newid = (ID *)BKE_mesh_copy((Mesh *)id);
-			return 1;
+			return true;
 		case ID_CU:
 			if (!test) *newid = (ID *)BKE_curve_copy((Curve *)id);
-			return 1;
+			return true;
 		case ID_MB:
 			if (!test) *newid = (ID *)BKE_mball_copy((MetaBall *)id);
-			return 1;
+			return true;
 		case ID_MA:
 			if (!test) *newid = (ID *)BKE_material_copy((Material *)id);
-			return 1;
+			return true;
 		case ID_TE:
 			if (!test) *newid = (ID *)BKE_texture_copy((Tex *)id);
-			return 1;
+			return true;
 		case ID_IM:
 			if (!test) *newid = (ID *)BKE_image_copy(G.main, (Image *)id);
-			return 1;
+			return true;
 		case ID_LT:
 			if (!test) *newid = (ID *)BKE_lattice_copy((Lattice *)id);
-			return 1;
+			return true;
 		case ID_LA:
 			if (!test) *newid = (ID *)BKE_lamp_copy((Lamp *)id);
-			return 1;
+			return true;
 		case ID_SPK:
 			if (!test) *newid = (ID *)BKE_speaker_copy((Speaker *)id);
-			return 1;
+			return true;
 		case ID_CA:
 			if (!test) *newid = (ID *)BKE_camera_copy((Camera *)id);
-			return 1;
+			return true;
 		case ID_IP:
-			return 0; /* deprecated */
+			return false;  /* deprecated */
 		case ID_KE:
 			if (!test) *newid = (ID *)BKE_key_copy((Key *)id);
-			return 1;
+			return true;
 		case ID_WO:
 			if (!test) *newid = (ID *)BKE_world_copy((World *)id);
-			return 1;
+			return true;
 		case ID_SCR:
-			return 0; /* can't be copied from here */
+			return false;  /* can't be copied from here */
 		case ID_VF:
-			return 0; /* not implemented */
+			return false;  /* not implemented */
 		case ID_TXT:
 			if (!test) *newid = (ID *)BKE_text_copy((Text *)id);
-			return 1;
+			return true;
 		case ID_SCRIPT:
-			return 0; /* deprecated */
+			return false;  /* deprecated */
 		case ID_SO:
-			return 0; /* not implemented */
+			return false;  /* not implemented */
 		case ID_GR:
 			if (!test) *newid = (ID *)BKE_group_copy((Group *)id);
-			return 1;
+			return true;
 		case ID_AR:
 			if (!test) *newid = (ID *)BKE_armature_copy((bArmature *)id);
-			return 1;
+			return true;
 		case ID_AC:
 			if (!test) *newid = (ID *)BKE_action_copy((bAction *)id);
-			return 1;
+			return true;
 		case ID_NT:
 			if (!test) *newid = (ID *)ntreeCopyTree((bNodeTree *)id);
-			return 1;
+			return true;
 		case ID_BR:
 			if (!test) *newid = (ID *)BKE_brush_copy((Brush *)id);
-			return 1;
+			return true;
 		case ID_PA:
 			if (!test) *newid = (ID *)BKE_particlesettings_copy((ParticleSettings *)id);
-			return 1;
+			return true;
 		case ID_WM:
-			return 0; /* can't be copied from here */
+			return false;  /* can't be copied from here */
 		case ID_GD:
-			return 0; /* not implemented */
+			return false;  /* not implemented */
 		case ID_MSK:
 			if (!test) *newid = (ID *)BKE_mask_copy((Mask *)id);
-			return 1;
+			return true;
 	}
 	
-	return 0;
+	return false;
 }
 
-int id_unlink(ID *id, int test)
+bool id_unlink(ID *id, int test)
 {
 	Main *mainlib = G.main;
 	ListBase *lb;
 
 	switch (GS(id->name)) {
 		case ID_TXT:
-			if (test) return 1;
+			if (test) return true;
 			BKE_text_unlink(mainlib, (Text *)id);
 			break;
 		case ID_GR:
-			if (test) return 1;
+			if (test) return true;
 			BKE_group_unlink((Group *)id);
 			break;
 		case ID_OB:
-			if (test) return 1;
+			if (test) return true;
 			BKE_object_unlink((Object *)id);
 			break;
 	}
 
 	if (id->us == 0) {
-		if (test) return 1;
+		if (test) return true;
 
 		lb = which_libbase(mainlib, GS(id->name));
 		BKE_libblock_free(lb, id);
 
-		return 1;
+		return true;
 	}
 
-	return 0;
+	return false;
 }
 
-int id_single_user(bContext *C, ID *id, PointerRNA *ptr, PropertyRNA *prop)
+bool id_single_user(bContext *C, ID *id, PointerRNA *ptr, PropertyRNA *prop)
 {
 	ID *newid = NULL;
 	PointerRNA idptr;
@@ -415,7 +422,7 @@ int id_single_user(bContext *C, ID *id, PointerRNA *ptr, PropertyRNA *prop)
 	if (id) {
 		/* if property isn't editable, we're going to have an extra block hanging around until we save */
 		if (RNA_property_editable(ptr, prop)) {
-			if (id_copy(id, &newid, 0) && newid) {
+			if (id_copy(id, &newid, false) && newid) {
 				/* copy animation actions too */
 				BKE_copy_animdata_id_action(id);
 				/* us is 1 by convention, but RNA_property_pointer_set
@@ -427,12 +434,12 @@ int id_single_user(bContext *C, ID *id, PointerRNA *ptr, PropertyRNA *prop)
 				RNA_property_pointer_set(ptr, prop, idptr);
 				RNA_property_update(C, ptr, prop);
 				
-				return 1;
+				return true;
 			}
 		}
 	}
 	
-	return 0;
+	return false;
 }
 
 ListBase *which_libbase(Main *mainlib, short type)
@@ -536,7 +543,13 @@ void recalc_all_library_objects(Main *main)
 			ob->recalc |= OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME;
 }
 
-/* note: MAX_LIBARRAY define should match this code */
+/**
+ * puts into array *lb pointers to all the ListBase structs in main,
+ * and returns the number of them as the function result. This is useful for
+ * generic traversal of all the blocks in a Main (by traversing all the
+ * lists in turn), without worrying about block types.
+ *
+ * \note MAX_LIBARRAY define should match this code */
 int set_listbasepointers(Main *main, ListBase **lb)
 {
 	int a = 0;
@@ -600,6 +613,10 @@ int set_listbasepointers(Main *main, ListBase **lb)
  *
  * **************************** */
 
+/**
+ * Allocates and returns memory of the right size for the specified block type,
+ * initialized to zero.
+ */
 static ID *alloc_libblock_notest(short type)
 {
 	ID *id = NULL;
@@ -702,7 +719,12 @@ static ID *alloc_libblock_notest(short type)
 	return id;
 }
 
-/* used everywhere in blenkernel and text.c */
+/**
+ * Allocates and returns a block of the specified type, with the specified name
+ * (adjusted as necessary to ensure uniqueness), and appended to the specified list.
+ * The user count is set to 1, all other content (apart from name and links) being
+ * initialized to zero.
+ */
 void *BKE_libblock_alloc(ListBase *lb, short type, const char *name)
 {
 	ID *id = NULL;
@@ -714,25 +736,25 @@ void *BKE_libblock_alloc(ListBase *lb, short type, const char *name)
 		id->icon_id = 0;
 		*( (short *)id->name) = type;
 		new_id(lb, id, name);
-		/* alphabetic insterion: is in new_id */
+		/* alphabetic insertion: is in new_id */
 	}
 	return id;
 }
 
 /* by spec, animdata is first item after ID */
 /* and, trust that BKE_animdata_from_id() will only find AnimData for valid ID-types */
-static void id_copy_animdata(ID *id, const short do_action)
+static void id_copy_animdata(ID *id, const bool do_action)
 {
 	AnimData *adt = BKE_animdata_from_id(id);
 	
 	if (adt) {
 		IdAdtTemplate *iat = (IdAdtTemplate *)id;
-		iat->adt = BKE_copy_animdata(iat->adt, do_action); /* could be set to FALSE, need to investigate */
+		iat->adt = BKE_copy_animdata(iat->adt, do_action); /* could be set to false, need to investigate */
 	}
 }
 
 /* material nodes use this since they are not treated as libdata */
-void BKE_libblock_copy_data(ID *id, const ID *id_from, const short do_action)
+void BKE_libblock_copy_data(ID *id, const ID *id_from, const bool do_action)
 {
 	if (id_from->properties)
 		id->properties = IDP_CopyProperty(id_from->properties);
@@ -764,7 +786,7 @@ void *BKE_libblock_copy_ex(Main *bmain, ID *id)
 	id->newid = idn;
 	idn->flag |= LIB_NEW;
 
-	BKE_libblock_copy_data(idn, id, FALSE);
+	BKE_libblock_copy_data(idn, id, false);
 	
 	return idn;
 }
@@ -1202,7 +1224,7 @@ static ID *is_dupid(ListBase *lb, ID *id, const char *name)
 
 /* 
  * Check to see if an ID name is already used, and find a new one if so.
- * Return 1 if created a new name (returned in name).
+ * Return true if created a new name (returned in name).
  *
  * Normally the ID that's being check is already in the ListBase, so ID *id
  * points at the new entry.  The Python Library module needs to know what
@@ -1210,11 +1232,13 @@ static ID *is_dupid(ListBase *lb, ID *id, const char *name)
  * id is NULL
  */
 
-static int check_for_dupid(ListBase *lb, ID *id, char *name)
+static bool check_for_dupid(ListBase *lb, ID *id, char *name)
 {
 	ID *idtest;
 	int nr = 0, nrtest, a, left_len;
-	char in_use[64]; /* use as a boolean array, unrelated to name length */
+#define MAX_IN_USE 64
+	bool in_use[MAX_IN_USE];
+	  /* to speed up finding unused numbers within [1 .. MAX_IN_USE - 1] (in_use[0] not used) */
 
 	char left[MAX_ID_NAME + 8], leftest[MAX_ID_NAME + 8];
 
@@ -1222,23 +1246,23 @@ static int check_for_dupid(ListBase *lb, ID *id, char *name)
 	/* if ( strlen(name) > MAX_ID_NAME-3 ) name[MAX_ID_NAME-3] = 0; */
 	/* removed since this is only ever called from one place - campbell */
 
-	while (1) {
+	while (true) {
 
 		/* phase 1: id already exists? */
 		idtest = is_dupid(lb, id, name);
 
 		/* if there is no double, done */
-		if (idtest == NULL) return 0;
+		if (idtest == NULL) return false;
 
 		/* we have a dup; need to make a new name */
-		/* quick check so we can reuse one of first 64 ids if vacant */
-		memset(in_use, 0, sizeof(in_use));
+		/* quick check so we can reuse one of first MAX_IN_USE - 1 ids if vacant */
+		memset(in_use, false, sizeof(in_use));
 
 		/* get name portion, number portion ("name.number") */
 		left_len = BLI_split_name_num(left, &nr, name, '.');
 
 		/* if new name will be too long, truncate it */
-		if (nr > 999 && left_len > (MAX_ID_NAME - 8)) {
+		if (nr > 999 && left_len > (MAX_ID_NAME - 8)) {  /* assumption: won't go beyond 9999 */
 			left[MAX_ID_NAME - 8] = 0;
 			left_len = MAX_ID_NAME - 8;
 		}
@@ -1255,21 +1279,24 @@ static int check_for_dupid(ListBase *lb, ID *id, char *name)
 			     (BLI_split_name_num(leftest, &nrtest, idtest->name + 2, '.') == left_len)
 			     )
 			{
-				if (nrtest < sizeof(in_use))
-					in_use[nrtest] = 1;  /* mark as used */
+				if (nrtest < MAX_IN_USE)
+					in_use[nrtest] = true;  /* mark as used */
 				if (nr <= nrtest)
 					nr = nrtest + 1;    /* track largest unused */
 			}
 		}
 
 		/* decide which value of nr to use */
-		for (a = 0; a < sizeof(in_use); a++) {
-			if (a >= nr) break;  /* stop when we've check up to biggest */
-			if (in_use[a] == 0) { /* found an unused value */
+		for (a = 0; a < MAX_IN_USE; a++) {
+			if (a >= nr) break;  /* stop when we've checked up to biggest */  /* redundant check */
+			if (!in_use[a]) { /* found an unused value */
 				nr = a;
 				break;
 			}
 		}
+	  /* At this point, nr is either the lowest unused number within [0 .. MAX_IN_USE - 1],
+		or 1 greater than the largest used number if all those low ones are taken.
+		We can't be bothered to look for the lowest unused number beyond (MAX_IN_USE - 1). */
 
 		/* If the original name has no numeric suffix, 
 		 * rather than just chopping and adding numbers, 
@@ -1283,7 +1310,7 @@ static int check_for_dupid(ListBase *lb, ID *id, char *name)
 				name[len--] = '\0';
 				idtest = is_dupid(lb, id, name);
 			}
-			if (idtest == NULL) return 1;
+			if (idtest == NULL) return true;
 			/* otherwise just continue and use a number suffix */
 		}
 		
@@ -1297,24 +1324,26 @@ static int check_for_dupid(ListBase *lb, ID *id, char *name)
 		/* this format specifier is from hell... */
 		BLI_snprintf(name, sizeof(id->name) - 2, "%s.%.3d", left, nr);
 
-		return 1;
+		return true;
 	}
+
+#undef MAX_IN_USE
 }
 
 /*
  * Only for local blocks: external en indirect blocks already have a
  * unique ID.
  *
- * return 1: created a new name
+ * return true: created a new name
  */
 
-int new_id(ListBase *lb, ID *id, const char *tname)
+bool new_id(ListBase *lb, ID *id, const char *tname)
 {
-	int result;
+	bool result;
 	char name[MAX_ID_NAME - 2];
 
 	/* if library, don't rename */
-	if (id->lib) return 0;
+	if (id->lib) return false;
 
 	/* if no libdata given, look up based on ID */
 	if (lb == NULL) lb = which_libbase(G.main, GS(id->name));
@@ -1386,10 +1415,9 @@ void clear_id_newpoins(void)
 	}
 }
 
-#define LIBTAG(a)   if (a && a->id.lib) { a->id.flag &= ~LIB_INDIRECT; a->id.flag |= LIB_EXTERN; } (void)0
-
 static void lib_indirect_test_id(ID *id, Library *lib)
 {
+#define LIBTAG(a)   if (a && a->id.lib) { a->id.flag &= ~LIB_INDIRECT; a->id.flag |= LIB_EXTERN; } (void)0
 	
 	if (id->lib) {
 		/* datablocks that were indirectly related are now direct links
@@ -1429,6 +1457,8 @@ static void lib_indirect_test_id(ID *id, Library *lib)
 		me = ob->data;
 		LIBTAG(me);
 	}
+
+#undef LIBTAG
 }
 
 void tag_main_lb(ListBase *lb, const short tag)
@@ -1466,7 +1496,7 @@ void tag_main(struct Main *mainvar, const short tag)
 
 /* if lib!=NULL, only all from lib local
  * bmain is almost certainly G.main */
-void BKE_library_make_local(Main *bmain, Library *lib, int untagged_only)
+void BKE_library_make_local(Main *bmain, Library *lib, bool untagged_only)
 {
 	ListBase *lbarray[MAX_LIBARRAY], tempbase = {NULL, NULL};
 	ID *id, *idn;
@@ -1486,7 +1516,7 @@ void BKE_library_make_local(Main *bmain, Library *lib, int untagged_only)
 			 * (very nasty to discover all your links are lost after appending)  
 			 * */
 			if (id->flag & (LIB_EXTERN | LIB_INDIRECT | LIB_NEW) &&
-			    (untagged_only == 0 || !(id->flag & LIB_PRE_EXISTING)))
+			    ((untagged_only == false) || !(id->flag & LIB_PRE_EXISTING)))
 			{
 				if (lib == NULL || id->lib == lib) {
 					if (id->lib) {
@@ -1505,6 +1535,7 @@ void BKE_library_make_local(Main *bmain, Library *lib, int untagged_only)
 		}
 		
 		/* patch2: make it aphabetically */
+		/* FIXME: but nothing is ever put into tempbase! */
 		while ( (id = tempbase.first) ) {
 			BLI_remlink(&tempbase, id);
 			BLI_addtail(lbarray[a], id);
@@ -1534,12 +1565,16 @@ void test_idbutton(char *name)
 	/* search for id */
 	idtest = BLI_findstring(lb, name, offsetof(ID, name) + 2);
 
-	if (idtest && (new_id(lb, idtest, name) == 0)) {
+	if (idtest && !new_id(lb, idtest, name)) {
 		id_sort_by_name(lb, idtest);
 	}
 }
 
-void text_idbutton(struct ID *id, char *text)
+/**
+ * Puts into *text a descriptive block type prefix to be displayed before the block name.
+ */
+/* Not actually used anywhere any more. */
+void text_idbutton(const struct ID *id, char *text)
 {
 	if (id) {
 		if (GS(id->name) == ID_SCE)
@@ -1561,6 +1596,9 @@ void text_idbutton(struct ID *id, char *text)
 	}
 }
 
+/**
+ * Sets the name of a block to name, suitably adjusted for uniqueness.
+ */
 void rename_id(ID *id, const char *name)
 {
 	ListBase *lb;
@@ -1571,7 +1609,11 @@ void rename_id(ID *id, const char *name)
 	new_id(lb, id, name);
 }
 
-void name_uiprefix_id(char *name, ID *id)
+/**
+ * Returns in name the name of the block, with a 3-character prefix prepended
+ * indicating whether it comes from a library, has a fake user, or no users.
+ */
+void name_uiprefix_id(char *name, const ID *id)
 {
 	name[0] = id->lib ? 'L' : ' ';
 	name[1] = id->flag & LIB_FAKEUSER ? 'F' : (id->us == 0) ? '0' : ' ';
diff --git a/source/blender/blenkernel/intern/node.c b/source/blender/blenkernel/intern/node.c
index 897e2ff2326..974a564b9da 100644
--- a/source/blender/blenkernel/intern/node.c
+++ b/source/blender/blenkernel/intern/node.c
@@ -716,7 +716,7 @@ static bNodeTree *ntreeCopyTree_internal(bNodeTree *ntree, const short do_id_use
 	}
 	else {
 		newtree = MEM_dupallocN(ntree);
-		BKE_libblock_copy_data(&newtree->id, &ntree->id, TRUE); /* copy animdata and ID props */
+		BKE_libblock_copy_data(&newtree->id, &ntree->id, true); /* copy animdata and ID props */
 	}
 
 	id_us_plus((ID *)newtree->gpd);