Revert "avoid unnecessary keyDel"

This reverts commit f648ce4.

src/bindings/cpp/include/key.hpp

@@ -1640,12 +1640,7 @@ inline int Key::del ()
 	if (key)
 	{
 		operator-- ();
-		ssize_t rc = getReferenceCounter ();
-		if (rc == 0)
-		{
-			return ckdb::keyDel (key);
-		}
-		return static_cast<int> (rc);
+		return ckdb::keyDel (key);
 	}
 	return -1;
 }

src/bindings/glib/gelektra-key.c

@@ -48,10 +48,8 @@ static void gelektra_key_finalize (GObject * object)
 {
 	GElektraKey * self = GELEKTRA_KEY (object);
 
-	if (keyDecRef (self->key) == 0)
-	{
-		keyDel (self->key);
-	}
+	keyDecRef (self->key);
+	keyDel (self->key);
 
 	/* Always chain up to the parent class; as with dispose(), finalize()
 	 * is guaranteed to exist on the parent's class virtual function table

src/libs/elektra/backend.c

@@ -465,11 +465,9 @@ int backendClose (Backend * backend, Key * errorKey)
 
 	if (backend->mountpoint)
 	{
+		keyDecRef (backend->mountpoint);
 		keySetName (errorKey, keyName (backend->mountpoint));
-		if (keyDecRef (backend->mountpoint) == 0)
-		{
-			keyDel (backend->mountpoint);
-		}
+		keyDel (backend->mountpoint);
 	}
 
 	for (int i = 0; i < NR_OF_PLUGINS; ++i)

src/libs/elektra/kdb.c

@@ -164,11 +164,7 @@ KeySet * ksRenameKeys (KeySet * config, const char * name)
 	root = ksNext (config);
 	rootSize = keyGetNameSize (root);
 
-	Key * r = ksLookup (config, root, KDB_O_POP);
-	if (keyGetRef (r) == 0)
-	{
-		keyDel (r);
-	}
+	keyDel (ksLookup (config, root, KDB_O_POP));
 
 	KeySet * newConfig = ksNew (ksGetSize (config), KS_END);
 	if (rootSize == -1) return newConfig;
@@ -179,10 +175,7 @@ KeySet * ksRenameKeys (KeySet * config, const char * name)
 		keySetName (dupKey, name);
 		keyAddName (dupKey, keyName (cur) + rootSize - 1);
 		ksAppendKey (newConfig, dupKey);
-		if (keyGetRef (cur) == 0)
-		{
-			keyDel (cur);
-		}
+		keyDel (cur);
 	}
 
 	return newConfig;
@@ -336,10 +329,8 @@ static int ensureContractMountGlobal (KDB * handle, KeySet * contract, Key * par
 
 			// we ned to delete cur separately, because it was ksCut() from contract
 			// we also need to decrement the ref count, because it was incremented above
-			if (keyDecRef (cur) == 0)
-			{
-				keyDel (cur);
-			}
+			keyDecRef (cur);
+			keyDel (cur);
 
 			if (ret == ELEKTRA_PLUGIN_STATUS_ERROR)
 			{

src/libs/elektra/key.c

@@ -30,7 +30,6 @@
 #include "kdbprivate.h"
 #include <kdbassert.h>
 
-// #include <signal.h>
 
 /**
  * @defgroup key Key
@@ -504,7 +503,6 @@ int keyDel (Key * key)
 
 	if (key->ksReference > 0)
 	{
-		// raise(SIGTRAP);
 		return key->ksReference;
 	}
 

src/libs/elektra/keymeta.c

@@ -540,10 +540,7 @@ ssize_t keySetMeta (Key * key, const char * metaName, const char * newMetaString
 		if (ret)
 		{
 			/*It was already there, so lets drop that one*/
-			if (keyGetRef (ret) == 0)
-			{
-				keyDel (ret);
-			}
+			keyDel (ret);
 			key->flags |= KEY_FLAG_SYNC;
 		}
 	}

src/libs/elektra/keyset.c

@@ -778,10 +778,8 @@ ssize_t ksAppendKey (KeySet * ks, Key * toAppend)
 		}
 
 		/* Pop the key in the result */
-		if (keyDecRef (ks->array[result]) == 0)
-		{
-			keyDel (ks->array[result]);
-		}
+		keyDecRef (ks->array[result]);
+		keyDel (ks->array[result]);
 
 		/* And use the other one instead */
 		keyIncRef (toAppend);
@@ -2634,11 +2632,10 @@ int ksClose (KeySet * ks)
 	ksRewind (ks);
 	while ((k = ksNext (ks)) != 0)
 	{
-		if (keyDecRef (k) == 0)
-		{
-			keyDel (k);
-		}
+		keyDecRef (k);
+		keyDel (k);
 	}
+
 	if (ks->array && !test_bit (ks->flags, KS_FLAG_MMAP_ARRAY))
 	{
 		elektraFree (ks->array);

src/libs/elektra/mount.c

@@ -317,6 +317,7 @@ int elektraMountGlobalsLoadPlugin (Plugin ** plugin, KeySet * referencePlugins,
 		refKey = keyNew ("/", KEY_BINARY, KEY_SIZE, sizeof (Plugin *), KEY_VALUE, &(*plugin), KEY_END);
 		keyAddBaseName (refKey, keyString (cur));
 		ksAppendKey (referencePlugins, refKey);
+		keyDel (refKey);
 	}
 
 	keyCopyAllMeta (errorKey, openKey);

src/libs/elektra/split.c

@@ -883,48 +883,55 @@ void splitCacheStoreState (KDB * handle, Split * split, KeySet * global, Key * p
 		ksAppendKey (global, key);
 		ELEKTRA_LOG_DEBUG (">>>> STORING key: %s, string: %s, strlen: %ld, valSize: %ld", keyName (key), keyString (key),
 				   strlen (keyString (key)), keyGetValueSize (key));
+		keyDel (key);
 
 		key = keyNew (name, KEY_END);
 		keyAddBaseName (key, "splitParentValue");
 		keySetString (key, keyString (split->parents[i]));
 		ksAppendKey (global, key);
 		ELEKTRA_LOG_DEBUG (">>>> STORING key: %s, string: %s, strlen: %ld, valSize: %ld", keyName (key), keyString (key),
 				   strlen (keyString (key)), keyGetValueSize (key));
+		keyDel (key);
 
 		key = keyNew (name, KEY_END);
 		keyAddBaseName (key, "specsize");
 		keySetBinary (key, &(split->handles[i]->specsize), sizeof (ssize_t));
 		ksAppendKey (global, key);
 		ELEKTRA_LOG_DEBUG (">>>> STORING key: %s, string: %s, strlen: %ld, valSize: %ld", keyName (key), keyString (key),
 				   strlen (keyString (key)), keyGetValueSize (key));
+		keyDel (key);
 
 		key = keyNew (name, KEY_END);
 		keyAddBaseName (key, "dirsize");
 		keySetBinary (key, &(split->handles[i]->dirsize), sizeof (ssize_t));
 		ksAppendKey (global, key);
 		ELEKTRA_LOG_DEBUG (">>>> STORING key: %s, string: %s, strlen: %ld, valSize: %ld", keyName (key), keyString (key),
 				   strlen (keyString (key)), keyGetValueSize (key));
+		keyDel (key);
 
 		key = keyNew (name, KEY_END);
 		keyAddBaseName (key, "usersize");
 		keySetBinary (key, &(split->handles[i]->usersize), sizeof (ssize_t));
 		ksAppendKey (global, key);
 		ELEKTRA_LOG_DEBUG (">>>> STORING key: %s, string: %s, strlen: %ld, valSize: %ld", keyName (key), keyString (key),
 				   strlen (keyString (key)), keyGetValueSize (key));
+		keyDel (key);
 
 		key = keyNew (name, KEY_END);
 		keyAddBaseName (key, "systemsize");
 		keySetBinary (key, &(split->handles[i]->systemsize), sizeof (ssize_t));
 		ksAppendKey (global, key);
 		ELEKTRA_LOG_DEBUG (">>>> STORING key: %s, string: %s, strlen: %ld, valSize: %ld", keyName (key), keyString (key),
 				   strlen (keyString (key)), keyGetValueSize (key));
+		keyDel (key);
 
 		key = keyNew (name, KEY_END);
 		keyAddBaseName (key, "syncbits");
 		keySetBinary (key, &(split->syncbits[i]), sizeof (splitflag_t));
 		ksAppendKey (global, key);
 		ELEKTRA_LOG_DEBUG (">>>> STORING key: %s, string: %s, strlen: %ld, valSize: %ld", keyName (key), keyString (key),
 				   strlen (keyString (key)), keyGetValueSize (key));
+		keyDel (key);
 
 		elektraFree (name);
 	}

src/libs/merge/kdbmerge.c

@@ -849,6 +849,7 @@ static int handleArrays (KeySet * ourSet, KeySet * theirSet, KeySet * baseSet, K
 			if (baseArray == NULL)
 			{
 				ELEKTRA_SET_INTERNAL_ERROR (informationKey, "Could not convert `base` KeySet into char[] for LibGit.");
+				keyDel (checkedKey);
 				ksDel (toAppend);
 				return -1;
 			}
@@ -857,6 +858,7 @@ static int handleArrays (KeySet * ourSet, KeySet * theirSet, KeySet * baseSet, K
 			{
 				ELEKTRA_SET_INTERNAL_ERROR (informationKey, "Could not convert `our` KeySet into char[] for LibGit.");
 				elektraFree (baseArray);
+				keyDel (checkedKey);
 				ksDel (toAppend);
 				return -1;
 			}
@@ -866,6 +868,7 @@ static int handleArrays (KeySet * ourSet, KeySet * theirSet, KeySet * baseSet, K
 				ELEKTRA_SET_INTERNAL_ERROR (informationKey, "Could not convert `their` KeySet into char[] for LibGit.");
 				elektraFree (ourArray);
 				elektraFree (baseArray);
+				keyDel (checkedKey);
 				ksDel (toAppend);
 				return -1;
 			}
@@ -919,6 +922,7 @@ static int handleArrays (KeySet * ourSet, KeySet * theirSet, KeySet * baseSet, K
 			elektraFree (baseArray);
 			keyDel (keyInOur);
 			keyDel (keyInTheir);
+			keyDel (checkedKey);
 		}
 	}
 	if (toAppend != NULL)

src/libs/meta/meta.c

@@ -598,7 +598,7 @@ int elektraSortTopology (KeySet * ks, Key ** array)
 	{
 		cur = localArray[j];
 		KeySet * deps = elektraMetaArrayToKS (cur, "dep");
-		ksLookupByName (deps, "meta:/dep", KDB_O_POP);
+		keyDel (ksLookupByName (deps, "meta:/dep", KDB_O_POP));
 		Key * tmpDep;
 		switch (ksGetSize (deps))
 		{

src/libs/opts/opts.c

@@ -382,6 +382,7 @@ bool processSpec (struct Specification * spec, KeySet * ks, Key * specParent, Ke
 					keyName (parent));
 				return false;
 			}
+			keyDel (parent);
 		}
 	}
 
@@ -846,6 +847,7 @@ bool processShortOptSpec (struct Specification * spec, struct OptionData * optio
 							"The option '-%c' has already been specified for the key '%s'. Additional key: %s",
 							shortOpt, keyGetMetaString (existing, "key"), keyName (key));
 		keyDel (shortOptSpec);
+		keyDel (existing);
 		return false;
 	}
 
@@ -1003,6 +1005,7 @@ bool processEnvVars (KeySet * usedEnvVars, Key * specKey, Key ** keyWithOpt, Key
 				errorKey, "The environment variable '%s' has already been specified for the key '%s'. Additional key: %s",
 				envVar, keyGetMetaString (existing, "key"), keyName (specKey));
 			elektraFree (envsLinePart);
+			keyDel (existing);
 			keyDel (envVarKey);
 			ksDel (envVars);
 			return false;
@@ -1602,6 +1605,7 @@ bool parseShortOptions (Key * command, KeySet * optionsSpec, KeySet * options, i
 		{
 			ELEKTRA_SET_VALIDATION_SEMANTIC_ERRORF (errorKey, "Unknown short option: -%c", keyBaseName (shortOpt)[0]);
 			keyDel (shortOpt);
+			keyDel (optSpec);
 			return false;
 		}
 
@@ -1621,8 +1625,10 @@ bool parseShortOptions (Key * command, KeySet * optionsSpec, KeySet * options, i
 		{
 			ELEKTRA_SET_VALIDATION_SEMANTIC_ERRORF (errorKey, "This option cannot be repeated: -%c", keyBaseName (shortOpt)[0]);
 			keyDel (shortOpt);
+			keyDel (optSpec);
 			return false;
 		}
+		keyDel (optSpec);
 
 		bool last = false;
 		if (elektraStrCmp (hasArg, "required") == 0)
@@ -1634,6 +1640,7 @@ bool parseShortOptions (Key * command, KeySet * optionsSpec, KeySet * options, i
 					ELEKTRA_SET_VALIDATION_SEMANTIC_ERRORF (errorKey, "Missing argument for short option: -%c",
 										keyBaseName (shortOpt)[0]);
 					keyDel (shortOpt);
+					keyDel (option);
 					return false;
 				}
 				// use next as arg and skip
@@ -1711,14 +1718,17 @@ bool parseLongOption (Key * command, KeySet * optionsSpec, KeySet * options, int
 	{
 		ELEKTRA_SET_VALIDATION_SEMANTIC_ERRORF (errorKey, "This option cannot be repeated: --%s", keyBaseName (longOpt));
 		keyDel (longOpt);
+		keyDel (optSpec);
 		return false;
 	}
 	else if (keyGetMetaString (option, "short") != NULL)
 	{
 		keyDel (longOpt);
+		keyDel (optSpec);
 		// short option found already ignore long version
 		return true;
 	}
+	keyDel (optSpec);
 
 	if (elektraStrCmp (hasArg, "required") == 0)
 	{

src/libs/pluginprocess/tests/testlib_pluginprocess.c

@@ -223,7 +223,7 @@ static void test_reservedParentKeyName (void)
 	output_warnings (parentKey);
 	output_error (parentKey);
 
-	// TODO: always in ks? keyDel (parentKey);
+	keyDel (parentKey);
 	ksDel (ks);
 	ksDel (conf);
 	elektraFree (plugin);
@@ -328,7 +328,7 @@ static void test_childAddingParentKey (void)
 	output_warnings (parentKey);
 	output_error (parentKey);
 
-	// TODO: always in ks? keyDel (parentKey);
+	keyDel (parentKey);
 	ksDel (ks);
 	ksDel (conf);
 	elektraFree (plugin);

src/plugins/cache/testmod_cache.c

@@ -57,6 +57,7 @@ static void test_cacheNonBackendKeys (void)
 	succeed_if (freshResult == 0, "key was persisted/cached, even though it was not committed");
 	ksDel (freshConf);
 
+	keyDel (doNotCache);
 	keyDel (key);
 	ksDel (conf);
 	kdbClose (handle, 0);

src/plugins/csvstorage/csvstorage.c

@@ -753,11 +753,7 @@ int elektraCsvstorageSet (Plugin * handle, KeySet * returned, Key * parentKey)
 	{
 		exportKS = ksCut (config, exportKey);
 		ksAppend (config, exportKS);
-		Key * k = ksLookup (exportKS, exportKey, KDB_O_POP);
-		if (keyGetRef (k) == 0)
-		{
-			keyDel (k);
-		}
+		keyDel (ksLookup (exportKS, exportKey, KDB_O_POP));
 		ksRewind (exportKS);
 	}
 	short useHeader = 0;

src/plugins/keytometa/keytometa.c

@@ -121,10 +121,7 @@ void removeKeyFromResult (Key * convertKey, Key * target, KeySet * orig)
 	 */
 	keySetMeta (convertKey, CONVERT_TARGET, keyName (target));
 	Key * key = ksLookup (orig, convertKey, KDB_O_POP);
-	if (keyGetRef (key) == 0)
-	{
-		keyDel (key);
-	}
+	keyDel (key);
 }
 
 static void flushConvertedKeys (Key * target, KeySet * converted, KeySet * orig)

src/plugins/macaddr/testmod_macaddr.c

@@ -64,6 +64,7 @@ static void testAddressesSetGet (const char * keyValue, unsigned long long longV
 	convertLong (intChar, longValue);
 	succeed_if (!strcmp (getKeyString (testKs, "user:/tests/mac/addr"), intChar), "error");
 	succeed_if (!strcmp (keyString (keyGetMeta (key, "origvalue")), keyValue), "error");
+	keyDel (key);
 	ksDel (testKs);
 }
 
@@ -144,6 +145,7 @@ static void testRestoreValue (void)
 	getKeyString (testKs, "user:/tests/mac/addr");
 	setKey (testKs);
 	succeed_if (!strcmp (keyString (key), val), "error");
+	keyDel (key);
 	ksDel (testKs);
 }
 

src/plugins/passwd/passwd.c

@@ -287,6 +287,7 @@ static struct passwd * KStoPasswd (KeySet * ks, SortBy index)
 		pwd->pw_passwd = "";
 	else
 		pwd->pw_passwd = (char *) keyString (found);
+	keyDel (parent);
 	keyDel (lookup);
 	return pwd;
 }

src/plugins/process/process.c

@@ -50,7 +50,7 @@ static int validPluginName (Key * pluginNameKey, Key * errorKey)
 static void cleanup (Process * process, Key * errorKey)
 {
 	if (process->plugin) elektraInvokeClose (process->plugin, errorKey);
-	if (process->pluginName && keyGetRef (process->pluginName) == 0) keyDel (process->pluginName);
+	if (process->pluginName) keyDel (process->pluginName);
 	ksDel (process->pluginConfig);
 	elektraFree (process);
 }