Simplified macro & enhanced std::string operations

Reduce the use of global variables in THOOK macro
Support for construct std::string in allocated memory
Support use destructor/delete to free std::string object

Author: ExtcanaRy

include/modloader/cutils.h

@@ -43,29 +43,24 @@
 
 #define THOOK(name, ret_type, sym, ...)          		    \
     typedef ret_type (*_##name##_t)(__VA_ARGS__);           \
-    _##name##_t _original_##name = NULL;                    \
     ret_type _detour_##name(__VA_ARGS__);                   \
     void _install_##name(void) __attribute__((constructor));\
     void _destroy_##name(void);                             \
                                                             \
     struct _##name {                                        \
-        _##name##_t hook;                                   \
+        void *hook;                                         \
         _##name##_t detour;                                 \
         _##name##_t original;                               \
         void (*install)(void);                              \
         void (*destroy)(void);                              \
-    } name = {NULL, NULL, NULL,                             \
+    } name = {NULL, _detour_##name, NULL,                   \
                 _install_##name, _destroy_##name};          \
                                                             \
     void _install_##name(void)                              \
     {                                                       \
-        modloader_hook_t *_hook_##name =                    \
-                            modloader_hook(SYM(sym),        \
-                                _detour_##name,             \
-                                (void**)&_original_##name); \
-        name.hook = _hook_##name;                           \
-        name.detour = _detour_##name;                       \
-        name.original = _original_##name;                   \
+        name.hook = modloader_hook(SYM(sym),                \
+                                name.detour,                \
+                                (void**)&name.original);    \
     }                                                       \
                                                             \
     void _destroy_##name(void)                              \
@@ -80,14 +75,14 @@ extern "C" {
 #endif
 
 
-// std::string::basic_string(const char *c_str)
-void *std_string_string(const char *c_str);
+// void *sstr = std::string::basic_string(const char *c_str)
+void std_string_string(void **sstr, const char *c_str);
 
 // std::string::c_str()
-const char *std_string_c_str(void *str);
+const char *std_string_c_str(void *sstr);
 
 // std::string::~basic_string()
-void std_string_destroy(void *str, bool should_free);
+void std_string_destroy(void *sstr, bool should_free);
 
 #ifdef __cplusplus
 }

src/cutils.cpp

@@ -1,18 +1,20 @@
 #include <modloader/cutils.h>
 #include <string>
 
-void *std_string_string(const char *c_str) {
-    auto str = new std::string;
-    str->assign(c_str);
-	return (void*)str;
+void std_string_string(void **sstr, const char *c_str) {
+    if (*sstr != nullptr)
+        new (*sstr) std::string(c_str);
+    else
+        *sstr = new std::string(c_str);
 }
 
-const char *std_string_c_str(void *str) {
-	return ((std::string*)str)->c_str();
+const char *std_string_c_str(void *sstr) {
+	return ((std::string*)sstr)->c_str();
 }
 
-void std_string_destroy(void *str, bool should_free) {
-    ((std::string*)str)->~basic_string();
+void std_string_destroy(void *sstr, bool should_free) {
     if (should_free)
-        delete (std::string*)str;
+        delete (std::string*)sstr;
+    else
+        ((std::string*)sstr)->~basic_string();
 }