1 files changed, 56 insertions, 37 deletions

diff --git a/src/tag/TagPool.cxx b/src/tag/TagPool.cxx
index cc28ea9a6..29f605337 100644
--- a/src/tag/TagPool.cxx
+++ b/src/tag/TagPool.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -20,23 +20,46 @@
 #include "config.h"
 #include "TagPool.hxx"
 #include "TagItem.hxx"
-
-#include <glib.h>
+#include "util/Cast.hxx"
+#include "util/VarSize.hxx"
 
 #include <assert.h>
 #include <string.h>
+#include <stdlib.h>
 
 Mutex tag_pool_lock;
 
-#define NUM_SLOTS 4096
+static constexpr size_t NUM_SLOTS = 4096;
 
-struct slot {
-	struct slot *next;
+struct TagPoolSlot {
+	TagPoolSlot *next;
 	unsigned char ref;
 	TagItem item;
-} mpd_packed;
 
-static struct slot *slots[NUM_SLOTS];
+	TagPoolSlot(TagPoolSlot *_next, TagType type,
+		    const char *value, size_t length)
+		:next(_next), ref(1) {
+		item.type = type;
+		memcpy(item.value, value, length);
+		item.value[length] = 0;
+	}
+
+	static TagPoolSlot *Create(TagPoolSlot *_next, TagType type,
+				   const char *value, size_t length);
+} gcc_packed;
+
+TagPoolSlot *
+TagPoolSlot::Create(TagPoolSlot *_next, TagType type,
+		    const char *value, size_t length)
+{
+	TagPoolSlot *dummy;
+	return NewVarSize<TagPoolSlot>(sizeof(dummy->item.value),
+				       length + 1,
+				       _next, type,
+				       value, length);
+}
+
+static TagPoolSlot *slots[NUM_SLOTS];
 
 static inline unsigned
 calc_hash_n(TagType type, const char *p, size_t length)
@@ -64,35 +87,32 @@ calc_hash(TagType type, const char *p)
 	return hash ^ type;
 }
 
-static inline struct slot *
+#if defined(__clang__) || GCC_CHECK_VERSION(4,7)
+	constexpr
+#endif
+static inline TagPoolSlot *
 tag_item_to_slot(TagItem *item)
 {
-	return (struct slot*)(((char*)item) - offsetof(struct slot, item));
+	return &ContainerCast(*item, &TagPoolSlot::item);
 }
 
-static struct slot *slot_alloc(struct slot *next,
-			       TagType type,
-			       const char *value, int length)
+static inline TagPoolSlot **
+tag_value_slot_p(TagType type, const char *value, size_t length)
 {
-	struct slot *slot;
-
-	slot = (struct slot *)
-		g_malloc(sizeof(*slot) - sizeof(slot->item.value) + length + 1);
-	slot->next = next;
-	slot->ref = 1;
-	slot->item.type = type;
-	memcpy(slot->item.value, value, length);
-	slot->item.value[length] = 0;
-	return slot;
+	return &slots[calc_hash_n(type, value, length) % NUM_SLOTS];
+}
+
+static inline TagPoolSlot **
+tag_value_slot_p(TagType type, const char *value)
+{
+	return &slots[calc_hash(type, value) % NUM_SLOTS];
 }
 
 TagItem *
 tag_pool_get_item(TagType type, const char *value, size_t length)
 {
-	struct slot **slot_p, *slot;
-
-	slot_p = &slots[calc_hash_n(type, value, length) % NUM_SLOTS];
-	for (slot = *slot_p; slot != nullptr; slot = slot->next) {
+	auto slot_p = tag_value_slot_p(type, value, length);
+	for (auto slot = *slot_p; slot != nullptr; slot = slot->next) {
 		if (slot->item.type == type &&
 		    length == strlen(slot->item.value) &&
 		    memcmp(value, slot->item.value, length) == 0 &&
@@ -103,7 +123,7 @@ tag_pool_get_item(TagType type, const char *value, size_t length)
 		}
 	}
 
-	slot = slot_alloc(*slot_p, type, value, length);
+	auto slot = TagPoolSlot::Create(*slot_p, type, value, length);
 	*slot_p = slot;
 	return &slot->item;
 }
@@ -111,7 +131,7 @@ tag_pool_get_item(TagType type, const char *value, size_t length)
 TagItem *
 tag_pool_dup_item(TagItem *item)
 {
-	struct slot *slot = tag_item_to_slot(item);
+	TagPoolSlot *slot = tag_item_to_slot(item);
 
 	assert(slot->ref > 0);
 
@@ -122,11 +142,10 @@ tag_pool_dup_item(TagItem *item)
 		/* the reference counter overflows above 0xff;
 		   duplicate the item, and start with 1 */
 		size_t length = strlen(item->value);
-		struct slot **slot_p =
-			&slots[calc_hash_n(item->type, item->value,
-					   length) % NUM_SLOTS];
-		slot = slot_alloc(*slot_p, item->type,
-				  item->value, strlen(item->value));
+		auto slot_p = tag_value_slot_p(item->type,
+					       item->value, length);
+		slot = TagPoolSlot::Create(*slot_p, item->type,
+					   item->value, strlen(item->value));
 		*slot_p = slot;
 		return &slot->item;
 	}
@@ -135,7 +154,7 @@ tag_pool_dup_item(TagItem *item)
 void
 tag_pool_put_item(TagItem *item)
 {
-	struct slot **slot_p, *slot;
+	TagPoolSlot **slot_p, *slot;
 
 	slot = tag_item_to_slot(item);
 	assert(slot->ref > 0);
@@ -144,12 +163,12 @@ tag_pool_put_item(TagItem *item)
 	if (slot->ref > 0)
 		return;
 
-	for (slot_p = &slots[calc_hash(item->type, item->value) % NUM_SLOTS];
+	for (slot_p = tag_value_slot_p(item->type, item->value);
 	     *slot_p != slot;
 	     slot_p = &(*slot_p)->next) {
 		assert(*slot_p != nullptr);
 	}
 
 	*slot_p = slot->next;
-	g_free(slot);
+	DeleteVarSize(slot);
 }