refactor: Remove unused C-style casts

MarcoFalke · MarcoFalke · commit fa6394dd10ae · 2023-07-24T15:32:00.000+02:00
diff --git a/src/crypto/common.h b/src/crypto/common.h
@@ -17,73 +17,73 @@
 uint16_t static inline ReadLE16(const unsigned char* ptr)
 {
     uint16_t x;
-    memcpy((char*)&x, ptr, 2);
+    memcpy(&x, ptr, 2);
     return le16toh(x);
 }
 
 uint32_t static inline ReadLE32(const unsigned char* ptr)
 {
     uint32_t x;
-    memcpy((char*)&x, ptr, 4);
+    memcpy(&x, ptr, 4);
     return le32toh(x);
 }
 
 uint64_t static inline ReadLE64(const unsigned char* ptr)
 {
     uint64_t x;
-    memcpy((char*)&x, ptr, 8);
+    memcpy(&x, ptr, 8);
     return le64toh(x);
 }
 
 void static inline WriteLE16(unsigned char* ptr, uint16_t x)
 {
     uint16_t v = htole16(x);
-    memcpy(ptr, (char*)&v, 2);
+    memcpy(ptr, &v, 2);
 }
 
 void static inline WriteLE32(unsigned char* ptr, uint32_t x)
 {
     uint32_t v = htole32(x);
-    memcpy(ptr, (char*)&v, 4);
+    memcpy(ptr, &v, 4);
 }
 
 void static inline WriteLE64(unsigned char* ptr, uint64_t x)
 {
     uint64_t v = htole64(x);
-    memcpy(ptr, (char*)&v, 8);
+    memcpy(ptr, &v, 8);
 }
 
 uint16_t static inline ReadBE16(const unsigned char* ptr)
 {
     uint16_t x;
-    memcpy((char*)&x, ptr, 2);
+    memcpy(&x, ptr, 2);
     return be16toh(x);
 }
 
 uint32_t static inline ReadBE32(const unsigned char* ptr)
 {
     uint32_t x;
-    memcpy((char*)&x, ptr, 4);
+    memcpy(&x, ptr, 4);
     return be32toh(x);
 }
 
 uint64_t static inline ReadBE64(const unsigned char* ptr)
 {
     uint64_t x;
-    memcpy((char*)&x, ptr, 8);
+    memcpy(&x, ptr, 8);
     return be64toh(x);
 }
 
 void static inline WriteBE32(unsigned char* ptr, uint32_t x)
 {
     uint32_t v = htobe32(x);
-    memcpy(ptr, (char*)&v, 4);
+    memcpy(ptr, &v, 4);
 }
 
 void static inline WriteBE64(unsigned char* ptr, uint64_t x)
 {
     uint64_t v = htobe64(x);
-    memcpy(ptr, (char*)&v, 8);
+    memcpy(ptr, &v, 8);
 }
 
 /** Return the smallest number n such that (x >> n) == 0 (or 64 if the highest bit in x is set. */
diff --git a/src/test/argsman_tests.cpp b/src/test/argsman_tests.cpp
@@ -112,7 +112,7 @@ class CheckValueTest : public TestChain100Setup
         test.SetupArgs({{"-value", flags}});
         const char* argv[] = {"ignored", arg};
         std::string error;
-        bool success = test.ParseParameters(arg ? 2 : 1, (char**)argv, error);
+        bool success = test.ParseParameters(arg ? 2 : 1, argv, error);
 
         BOOST_CHECK_EQUAL(test.GetSetting("-value").write(), expect.setting.write());
         auto settings_list = test.GetSettingsList("-value");
@@ -217,13 +217,13 @@ BOOST_AUTO_TEST_CASE(util_ParseParameters)
     std::string error;
     LOCK(testArgs.cs_args);
     testArgs.SetupArgs({a, b, ccc, d});
-    BOOST_CHECK(testArgs.ParseParameters(0, (char**)argv_test, error));
+    BOOST_CHECK(testArgs.ParseParameters(0, argv_test, error));
     BOOST_CHECK(testArgs.m_settings.command_line_options.empty() && testArgs.m_settings.ro_config.empty());
 
-    BOOST_CHECK(testArgs.ParseParameters(1, (char**)argv_test, error));
+    BOOST_CHECK(testArgs.ParseParameters(1, argv_test, error));
     BOOST_CHECK(testArgs.m_settings.command_line_options.empty() && testArgs.m_settings.ro_config.empty());
 
-    BOOST_CHECK(testArgs.ParseParameters(7, (char**)argv_test, error));
+    BOOST_CHECK(testArgs.ParseParameters(7, argv_test, error));
     // expectation: -ignored is ignored (program name argument),
     // -a, -b and -ccc end up in map, -d ignored because it is after
     // a non-option argument (non-GNU option parsing)
@@ -248,17 +248,17 @@ BOOST_AUTO_TEST_CASE(util_ParseInvalidParameters)
 
     const char* argv[] = {"ignored", "-registered"};
     std::string error;
-    BOOST_CHECK(test.ParseParameters(2, (char**)argv, error));
+    BOOST_CHECK(test.ParseParameters(2, argv, error));
     BOOST_CHECK_EQUAL(error, "");
 
     argv[1] = "-unregistered";
-    BOOST_CHECK(!test.ParseParameters(2, (char**)argv, error));
+    BOOST_CHECK(!test.ParseParameters(2, argv, error));
     BOOST_CHECK_EQUAL(error, "Invalid parameter -unregistered");
 
     // Make sure registered parameters prefixed with a chain type trigger errors.
     // (Previously, they were accepted and ignored.)
     argv[1] = "-test.registered";
-    BOOST_CHECK(!test.ParseParameters(2, (char**)argv, error));
+    BOOST_CHECK(!test.ParseParameters(2, argv, error));
     BOOST_CHECK_EQUAL(error, "Invalid parameter -test.registered");
 }
 
@@ -269,7 +269,7 @@ static void TestParse(const std::string& str, bool expected_bool, int64_t expect
     std::string arg = "-value=" + str;
     const char* argv[] = {"ignored", arg.c_str()};
     std::string error;
-    BOOST_CHECK(test.ParseParameters(2, (char**)argv, error));
+    BOOST_CHECK(test.ParseParameters(2, argv, error));
     BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false), expected_bool);
     BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true), expected_bool);
     BOOST_CHECK_EQUAL(test.GetIntArg("-value", 99998), expected_int);
@@ -331,7 +331,7 @@ BOOST_AUTO_TEST_CASE(util_GetBoolArg)
     std::string error;
     LOCK(testArgs.cs_args);
     testArgs.SetupArgs({a, b, c, d, e, f});
-    BOOST_CHECK(testArgs.ParseParameters(7, (char**)argv_test, error));
+    BOOST_CHECK(testArgs.ParseParameters(7, argv_test, error));
 
     // Each letter should be set.
     for (const char opt : "abcdef")
@@ -368,7 +368,7 @@ BOOST_AUTO_TEST_CASE(util_GetBoolArgEdgeCases)
     const char *argv_test[] = {"ignored", "-nofoo", "-foo", "-nobar=0"};
     testArgs.SetupArgs({foo, bar});
     std::string error;
-    BOOST_CHECK(testArgs.ParseParameters(4, (char**)argv_test, error));
+    BOOST_CHECK(testArgs.ParseParameters(4, argv_test, error));
 
     // This was passed twice, second one overrides the negative setting.
     BOOST_CHECK(!testArgs.IsArgNegated("-foo"));
@@ -380,7 +380,7 @@ BOOST_AUTO_TEST_CASE(util_GetBoolArgEdgeCases)
 
     // Config test
     const char *conf_test = "nofoo=1\nfoo=1\nnobar=0\n";
-    BOOST_CHECK(testArgs.ParseParameters(1, (char**)argv_test, error));
+    BOOST_CHECK(testArgs.ParseParameters(1, argv_test, error));
     testArgs.ReadConfigString(conf_test);
 
     // This was passed twice, second one overrides the negative setting,
@@ -395,7 +395,7 @@ BOOST_AUTO_TEST_CASE(util_GetBoolArgEdgeCases)
     // Combined test
     const char *combo_test_args[] = {"ignored", "-nofoo", "-bar"};
     const char *combo_test_conf = "foo=1\nnobar=1\n";
-    BOOST_CHECK(testArgs.ParseParameters(3, (char**)combo_test_args, error));
+    BOOST_CHECK(testArgs.ParseParameters(3, combo_test_args, error));
     testArgs.ReadConfigString(combo_test_conf);
 
     // Command line overrides, but doesn't erase old setting
@@ -655,62 +655,62 @@ BOOST_AUTO_TEST_CASE(util_GetChainTypeString)
     const char* testnetconf = "testnet=1\nregtest=0\n[test]\nregtest=1";
     std::string error;
 
-    BOOST_CHECK(test_args.ParseParameters(0, (char**)argv_testnet, error));
+    BOOST_CHECK(test_args.ParseParameters(0, argv_testnet, error));
     BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "main");
 
-    BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_testnet, error));
+    BOOST_CHECK(test_args.ParseParameters(2, argv_testnet, error));
     BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
-    BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_regtest, error));
+    BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error));
     BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "regtest");
 
-    BOOST_CHECK(test_args.ParseParameters(3, (char**)argv_test_no_reg, error));
+    BOOST_CHECK(test_args.ParseParameters(3, argv_test_no_reg, error));
     BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
-    BOOST_CHECK(test_args.ParseParameters(3, (char**)argv_both, error));
+    BOOST_CHECK(test_args.ParseParameters(3, argv_both, error));
     BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
 
-    BOOST_CHECK(test_args.ParseParameters(0, (char**)argv_testnet, error));
+    BOOST_CHECK(test_args.ParseParameters(0, argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
-    BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_testnet, error));
+    BOOST_CHECK(test_args.ParseParameters(2, argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
-    BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_regtest, error));
+    BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
 
-    BOOST_CHECK(test_args.ParseParameters(3, (char**)argv_test_no_reg, error));
+    BOOST_CHECK(test_args.ParseParameters(3, argv_test_no_reg, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
-    BOOST_CHECK(test_args.ParseParameters(3, (char**)argv_both, error));
+    BOOST_CHECK(test_args.ParseParameters(3, argv_both, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
 
     // check setting the network to test (and thus making
     // [test] regtest=1 potentially relevant) doesn't break things
     test_args.SelectConfigNetwork("test");
 
-    BOOST_CHECK(test_args.ParseParameters(0, (char**)argv_testnet, error));
+    BOOST_CHECK(test_args.ParseParameters(0, argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
-    BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_testnet, error));
+    BOOST_CHECK(test_args.ParseParameters(2, argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
-    BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_regtest, error));
+    BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
 
-    BOOST_CHECK(test_args.ParseParameters(2, (char**)argv_test_no_reg, error));
+    BOOST_CHECK(test_args.ParseParameters(2, argv_test_no_reg, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "test");
 
-    BOOST_CHECK(test_args.ParseParameters(3, (char**)argv_both, error));
+    BOOST_CHECK(test_args.ParseParameters(3, argv_both, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
 }
diff --git a/src/wallet/crypter.cpp b/src/wallet/crypter.cpp
@@ -112,7 +112,7 @@ bool EncryptSecret(const CKeyingMaterial& vMasterKey, const CKeyingMaterial &vch
     memcpy(chIV.data(), &nIV, WALLET_CRYPTO_IV_SIZE);
     if(!cKeyCrypter.SetKey(vMasterKey, chIV))
         return false;
-    return cKeyCrypter.Encrypt(*((const CKeyingMaterial*)&vchPlaintext), vchCiphertext);
+    return cKeyCrypter.Encrypt(vchPlaintext, vchCiphertext);
 }
 
 bool DecryptSecret(const CKeyingMaterial& vMasterKey, const std::vector<unsigned char>& vchCiphertext, const uint256& nIV, CKeyingMaterial& vchPlaintext)

Original file line number	Diff line number	Diff line change
`@@ -17,73 +17,73 @@`
`17`	`17`	`uint16_t static inline ReadLE16(const unsigned char* ptr)`
`18`	`18`	`{`
`19`	`19`	`uint16_t x;`
`20`		`- memcpy((char*)&x, ptr, 2);`
	`20`	`+ memcpy(&x, ptr, 2);`
`21`	`21`	`return le16toh(x);`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`uint32_t static inline ReadLE32(const unsigned char* ptr)`
`25`	`25`	`{`
`26`	`26`	`uint32_t x;`
`27`		`- memcpy((char*)&x, ptr, 4);`
	`27`	`+ memcpy(&x, ptr, 4);`
`28`	`28`	`return le32toh(x);`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`uint64_t static inline ReadLE64(const unsigned char* ptr)`
`32`	`32`	`{`
`33`	`33`	`uint64_t x;`
`34`		`- memcpy((char*)&x, ptr, 8);`
	`34`	`+ memcpy(&x, ptr, 8);`
`35`	`35`	`return le64toh(x);`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`void static inline WriteLE16(unsigned char* ptr, uint16_t x)`
`39`	`39`	`{`
`40`	`40`	`uint16_t v = htole16(x);`
`41`		`- memcpy(ptr, (char*)&v, 2);`
	`41`	`+ memcpy(ptr, &v, 2);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`void static inline WriteLE32(unsigned char* ptr, uint32_t x)`
`45`	`45`	`{`
`46`	`46`	`uint32_t v = htole32(x);`
`47`		`- memcpy(ptr, (char*)&v, 4);`
	`47`	`+ memcpy(ptr, &v, 4);`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`void static inline WriteLE64(unsigned char* ptr, uint64_t x)`
`51`	`51`	`{`
`52`	`52`	`uint64_t v = htole64(x);`
`53`		`- memcpy(ptr, (char*)&v, 8);`
	`53`	`+ memcpy(ptr, &v, 8);`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`uint16_t static inline ReadBE16(const unsigned char* ptr)`
`57`	`57`	`{`
`58`	`58`	`uint16_t x;`
`59`		`- memcpy((char*)&x, ptr, 2);`
	`59`	`+ memcpy(&x, ptr, 2);`
`60`	`60`	`return be16toh(x);`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`uint32_t static inline ReadBE32(const unsigned char* ptr)`
`64`	`64`	`{`
`65`	`65`	`uint32_t x;`
`66`		`- memcpy((char*)&x, ptr, 4);`
	`66`	`+ memcpy(&x, ptr, 4);`
`67`	`67`	`return be32toh(x);`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`uint64_t static inline ReadBE64(const unsigned char* ptr)`
`71`	`71`	`{`
`72`	`72`	`uint64_t x;`
`73`		`- memcpy((char*)&x, ptr, 8);`
	`73`	`+ memcpy(&x, ptr, 8);`
`74`	`74`	`return be64toh(x);`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`void static inline WriteBE32(unsigned char* ptr, uint32_t x)`
`78`	`78`	`{`
`79`	`79`	`uint32_t v = htobe32(x);`
`80`		`- memcpy(ptr, (char*)&v, 4);`
	`80`	`+ memcpy(ptr, &v, 4);`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`void static inline WriteBE64(unsigned char* ptr, uint64_t x)`
`84`	`84`	`{`
`85`	`85`	`uint64_t v = htobe64(x);`
`86`		`- memcpy(ptr, (char*)&v, 8);`
	`86`	`+ memcpy(ptr, &v, 8);`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`/** Return the smallest number n such that (x >> n) == 0 (or 64 if the highest bit in x is set. */`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ bool EncryptSecret(const CKeyingMaterial& vMasterKey, const CKeyingMaterial &vch`
`112`	`112`	`memcpy(chIV.data(), &nIV, WALLET_CRYPTO_IV_SIZE);`
`113`	`113`	`if(!cKeyCrypter.SetKey(vMasterKey, chIV))`
`114`	`114`	`return false;`
`115`		`- return cKeyCrypter.Encrypt(((const CKeyingMaterial)&vchPlaintext), vchCiphertext);`
	`115`	`+ return cKeyCrypter.Encrypt(vchPlaintext, vchCiphertext);`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`bool DecryptSecret(const CKeyingMaterial& vMasterKey, const std::vector<unsigned char>& vchCiphertext, const uint256& nIV, CKeyingMaterial& vchPlaintext)`