Finish Improving Performance

data/function.cpp

@@ -1,32 +0,0 @@
-#include "function.h"
-
-// Virtual Function Information
-template <typename T>
-__VirtualFunctionInfo<T>::__VirtualFunctionInfo(T *const addr_, void *const parent_):
-    addr(addr_),
-    parent(parent_) {}
-template <typename T>
-bool __VirtualFunctionInfo<T>::can_overwrite() const {
-    return ((void *) *addr) != parent;
-}
-
-// Function Information
-template <typename Ret, typename... Args>
-__Function<Ret(Args...)>::__Function(const char *const name_, const __Function<Ret(Args...)>::ptr_type func_, const __Function<Ret(Args...)>::ptr_type thunk_):
-    is_virtual(false),
-    func(func_),
-    enabled(true),
-    name(name_),
-    backup(func_),
-    thunk(thunk_) {}
-template <typename Ret, typename... Args>
-__Function<Ret(Args...)>::__Function(const char *const name_, __Function<Ret(Args...)>::ptr_type *const func_, void *const parent, const __Function<Ret(Args...)>::ptr_type thunk_):
-    is_virtual(true),
-    func(__VirtualFunctionInfo(func_, parent)),
-    enabled(std::get<__VirtualFunctionInfo<ptr_type>>(func).can_overwrite()),
-    name(name_),
-    backup(*get_vtable_addr()),
-    thunk(thunk_) {}
-
-// Thunks
-thunk_enabler_t thunk_enabler;

data/function.h

@@ -1,110 +0,0 @@
-#pragma once
-
-#include <variant>
-#include <functional>
-#include <type_traits>
-
-// Virtual Function Information
-template <typename T>
-class __Function;
-template <typename T>
-class __VirtualFunctionInfo {
-    __VirtualFunctionInfo(T *addr_, void *parent_);
-    [[nodiscard]] bool can_overwrite() const;
-    T *const addr;
-    void *const parent;
-    friend class __Function<std::remove_pointer_t<T>>;
-};
-
-// Thunks
-typedef void *(*thunk_enabler_t)(void *target, void *thunk);
-extern thunk_enabler_t thunk_enabler;
-
-// Function Information
-template <typename Ret, typename... Args>
-class __Function<Ret(Args...)> {
-public:
-    // Types
-    using ptr_type = Ret (*)(Args...);
-    using type = std::function<Ret(Args...)>;
-    using overwrite_type = std::function<Ret(type, Args...)>;
-
-    // Normal Function
-    __Function(const char *name_, ptr_type func_, ptr_type thunk_);
-    // Virtual Function
-    __Function(const char *name_, ptr_type *func_, void *parent, ptr_type thunk_);
-
-    // Overwrite Function
-    [[nodiscard]] bool overwrite(overwrite_type target) {
-        // Check If Enabled
-        if (!enabled) {
-            return false;
-        }
-        // Enable Thunk
-        enable_thunk();
-        // Overwrite
-        type original = get_thunk_target();
-        thunk_target = [original, target](Args... args) {
-            return target(original, std::forward<Args>(args)...);
-        };
-        return true;
-    }
-
-    // Getters
-    [[nodiscard]] ptr_type get(bool result_will_be_stored) {
-        if (!enabled) {
-            return nullptr;
-        } else {
-            if (result_will_be_stored) {
-                enable_thunk();
-            }
-            if (is_virtual) {
-                return *get_vtable_addr();
-            } else {
-                return std::get<ptr_type>(func);
-            }
-        }
-    }
-    [[nodiscard]] ptr_type *get_vtable_addr() const {
-        if (is_virtual) {
-            return std::get<__VirtualFunctionInfo<ptr_type>>(func).addr;
-        } else {
-            return nullptr;
-        }
-    }
-    [[nodiscard]] type get_thunk_target() const {
-        if (thunk_target) {
-            return thunk_target;
-        } else {
-            return backup;
-        }
-    }
-
-private:
-    // Current Function
-    const bool is_virtual;
-    std::variant<ptr_type, __VirtualFunctionInfo<ptr_type>> func;
-
-public:
-    // State
-    const bool enabled;
-    const char *const name;
-
-    // Backup Of Original Function Pointer
-    const ptr_type backup;
-
-private:
-    // Thunk
-    const ptr_type thunk;
-    type thunk_target;
-    bool thunk_enabled = false;
-    void enable_thunk() {
-        if (!thunk_enabled && enabled) {
-            ptr_type real_thunk = (ptr_type) thunk_enabler((void *) backup, (void *) thunk);
-            if (!is_virtual) {
-                func = real_thunk;
-            }
-            thunk_enabled = true;
-        }
-    }
-};

data/out.cpp

@@ -1,15 +1,10 @@
+#define LEAN_SYMBOLS_HEADER
 #include "{{ headerPath }}"
-#include "{{ data }}/function.cpp"
 
-// Thunks
+// Thunk Template
-template <typename T>
+template <auto *const *func>
-struct __Thunk;
+decltype(auto) __thunk(auto... args) {
-template <typename Ret, typename... Args>
+    return (*func)->get_thunk_target()(std::forward<decltype(args)>(args)...);
-struct __Thunk<Ret(Args...)> {
+}
-    template <__Function<Ret(Args...)> *const *func>
-    static Ret call(Args... args) {
-        return (*func)->get_thunk_target()(std::forward<Args>(args)...);
-    }
-};
 
 {{ main }}

data/out.h

@@ -6,7 +6,8 @@
 #endif
 
 // Headers
-#include "{{ data }}/function.h"
+#include <variant>
+#include <functional>
 #include <cstddef>
 #include <string>
 #include <vector>
@@ -14,6 +15,123 @@
 #include <type_traits>
 #include <cstring>
 
+// Virtual Function Information
+template <typename T>
+class __Function;
+template <typename T>
+class __VirtualFunctionInfo {
+    __VirtualFunctionInfo(T *const addr_, void *const parent_):
+        addr(addr_),
+        parent(parent_) {}
+    [[nodiscard]] bool can_overwrite() const {
+        return ((void *) *addr) != parent;
+    }
+    T *const addr;
+    void *const parent;
+    friend class __Function<std::remove_pointer_t<T>>;
+};
+
+// Thunks
+typedef void *(*thunk_enabler_t)(void *target, void *thunk);
+extern thunk_enabler_t thunk_enabler;
+
+// Function Information
+template <typename Ret, typename... Args>
+class __Function<Ret(Args...)> {
+public:
+    // Types
+    using ptr_type = Ret (*)(Args...);
+    using type = std::function<Ret(Args...)>;
+    using overwrite_type = std::function<Ret(type, Args...)>;
+
+    // Normal Function
+    __Function(const char *const name_, const ptr_type func_, const ptr_type thunk_):
+        func(func_),
+        enabled(true),
+        name(name_),
+        backup(func_),
+        thunk(thunk_) {}
+    // Virtual Function
+    __Function(const char *const name_, ptr_type *const func_, void *const parent, const ptr_type thunk_):
+        func(__VirtualFunctionInfo(func_, parent)),
+        enabled(std::get<__VirtualFunctionInfo<ptr_type>>(func).can_overwrite()),
+        name(name_),
+        backup(*get_vtable_addr()),
+        thunk(thunk_) {}
+
+    // Overwrite Function
+    [[nodiscard]] bool overwrite(overwrite_type target) {
+        // Check If Enabled
+        if (!enabled) {
+            return false;
+        }
+        // Enable Thunk
+        enable_thunk();
+        // Overwrite
+        type original = get_thunk_target();
+        thunk_target = [original, target](Args... args) {
+            return target(original, std::forward<Args>(args)...);
+        };
+        return true;
+    }
+
+    // Getters
+    [[nodiscard]] ptr_type get(bool result_will_be_stored) {
+        if (!enabled) {
+            return nullptr;
+        } else {
+            if (result_will_be_stored) {
+                enable_thunk();
+            }
+            if (is_virtual()) {
+                return *get_vtable_addr();
+            } else {
+                return std::get<ptr_type>(func);
+            }
+        }
+    }
+    [[nodiscard]] ptr_type *get_vtable_addr() const {
+        return std::get<__VirtualFunctionInfo<ptr_type>>(func).addr;
+    }
+    [[nodiscard]] type get_thunk_target() const {
+        if (thunk_target) {
+            return thunk_target;
+        } else {
+            return backup;
+        }
+    }
+
+private:
+    // Current Function
+    std::variant<ptr_type, __VirtualFunctionInfo<ptr_type>> func;
+    [[nodiscard]] bool is_virtual() const {
+        return func.index() == 1;
+    }
+
+public:
+    // State
+    const bool enabled;
+    const char *const name;
+
+    // Backup Of Original Function Pointer
+    const ptr_type backup;
+
+private:
+    // Thunk
+    const ptr_type thunk;
+    type thunk_target;
+    bool thunk_enabled = false;
+    void enable_thunk() {
+        if (!thunk_enabled && enabled) {
+            ptr_type real_thunk = (ptr_type) thunk_enabler((void *) backup, (void *) thunk);
+            if (!is_virtual()) {
+                func = real_thunk;
+            }
+            thunk_enabled = true;
+        }
+    }
+};
+
 // Shortcuts
 typedef unsigned char uchar;
 typedef unsigned short ushort;

src/common.ts

@@ -104,4 +104,5 @@ export function preventConstruction(self: string) {
     out += `${INDENT}${self}(const ${self} &) = delete;\n`;
     out += `${INDENT}${self} &operator=(const ${self} &) = delete;\n`;
     return out;
-}
+}
+export const LEAN_HEADER_GUARD = '#ifndef LEAN_SYMBOLS_HEADER\n';

src/index.ts

@@ -1,4 +1,5 @@
 import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { STRUCTURE_FILES, EXTENSION, formatFile, getDataDir } from './common';
 import { getStructure } from './map';
 import { Struct } from './struct';
@@ -14,9 +15,8 @@ function invalidFileType(file: string) {
     throw new Error(`Invalid File Type: ${file}`);
 }
 const sourceOutput = process.argv.shift()!;
-if (!sourceOutput.endsWith('.cpp')) {
+fs.rmSync(sourceOutput, {force: true, recursive: true});
-    invalidFileType(sourceOutput);
+fs.mkdirSync(sourceOutput, {recursive: true});
-}
 const headerOutput = process.argv.shift()!;
 if (!headerOutput.endsWith('.h')) {
     invalidFileType(headerOutput);
@@ -151,28 +151,38 @@ function makeMainHeader(output: string) {
 makeMainHeader(headerOutput);
 
 // Generate Compiled Code
-function makeCompiledCode(output: string) {
+function makeCompiledCode(outputDir: string) {
     // Load Symbols
     const structureObjects = loadSymbols();
 
     // Generate
-    let declarations = '';
+    let first = true;
     for (const structure of structureObjects) {
+        // Thunks
+        let declarations = '';
+        if (first) {
+            first = false;
+            declarations += '// Thunk Enabler\n';
+            declarations += 'thunk_enabler_t thunk_enabler;\n\n';
+        }
+
+        // Structure
         const name = structure.getName();
         declarations += `// ${name}\n`;
         try {
-            declarations += structure.generateCode();
+            declarations += structure.generateCode().trim();
         } catch (e) {
             console.log(`Error Generating Code: ${name}: ${e instanceof Error ? e.stack : e}`);
             process.exit(1);
         }
         declarations += '\n';
-    }
 
-    // Write
+        // Write
-    const headerPath = fs.realpathSync(headerOutput);
+        const headerPath = fs.realpathSync(headerOutput);
-    const main = declarations.trim();
+        const main = declarations.trim();
-    const result = formatFile('out.cpp', {headerPath, main, data: getDataDir()});
+        const result = formatFile('out.cpp', {headerPath, main, data: getDataDir()});
-    fs.writeFileSync(output, result);
+        const output = path.join(outputDir, name + '.cpp');
+        fs.writeFileSync(output, result);
+    }
 }
 makeCompiledCode(sourceOutput);

src/method.ts

@@ -27,24 +27,22 @@ export class Method {
     getType() {
         return this.getName() + '_t';
     }
-    getProperty(hasWrapper: boolean) {
+    #getRawType() {
-        let out = INDENT;
+        return INTERNAL + 'raw_' + this.getType();
-        if (hasWrapper) {
-            out += `${this.getWrapperType()}::ptr_type ${this.shortName}`;
-        } else {
-            out += `${formatType(this.returnType.trim())}(*${this.shortName})${this.args.trim()}`;
-        }
-        out += ';\n';
-        return out;
     }
-    getWrapperType() {
+    getProperty() {
-        return `std::remove_pointer_t<decltype(${this.getName()})>`;
+        return `${INDENT}${this.#getRawType()} *${this.shortName};\n`;
-    }
-    #getSignature() {
-        return this.returnType.trim() + this.args.trim();
     }
     #getFullType() {
-        return `${INTERNAL}Function<${this.#getSignature()}>`;
+        return `${INTERNAL}Function<${this.#getRawType()}>`;
+    }
+
+    // Typedefs
+    generateTypedefs() {
+        let out = '';
+        out += `typedef ${formatType(this.returnType.trim())}${this.#getRawType()}${this.args.trim()};\n`;
+        out += `typedef std::function<${this.#getRawType()}> ${this.getType()};\n`;
+        return out;
     }
 
     // Overwrite Helper
@@ -53,9 +51,7 @@ export class Method {
     }
     generate(code: boolean, isVirtual: boolean, parentSelf?: string) {
         let out = '';
-        if (!code) {
+        out += 'extern ';
-            out += 'extern ';
-        }
         const type = this.#getFullType();
         out += `${type} *const ${this.getName()}`;
         if (code) {
@@ -64,14 +60,11 @@ export class Method {
                 const parentMethod = parentSelf ? `(void *) ${this.#getVirtualCall(parentSelf)}` : 'nullptr';
                 out += `&${this.#getVirtualCall()}, ${parentMethod}`;
             } else {
-                out += `${this.getWrapperType()}::ptr_type(${toHex(this.address)})`;
+                out += `(${this.#getRawType()} *) ${toHex(this.address)}`;
             }
-            out += `, ${INTERNAL}Thunk<${this.#getSignature()}>::call<&${this.getName()}>)`;
+            out += `, ${INTERNAL}thunk<&${this.getName()}>)`;
         }
         out += ';\n';
-        if (!code) {
-            out += `typedef ${this.getWrapperType()}::type ${this.getType()};\n`;
-        }
         return out;
     }
 }

src/struct.ts

@@ -1,4 +1,4 @@
-import { INDENT, STRUCTURE_FILES, toHex, assertSize, INTERNAL, preventConstruction } from './common';
+import { INDENT, STRUCTURE_FILES, toHex, assertSize, INTERNAL, preventConstruction, LEAN_HEADER_GUARD } from './common';
 import { Method } from './method';
 import { Property, StaticProperty } from './property';
 import { VTable } from './vtable';
@@ -139,32 +139,29 @@ export class Struct {
 
     // Generate C++ Method Shortcuts
     #generateMethod(method: Method, isVirtual: boolean) {
-        // Generate Method Call
-        let call = '';
-        if (isVirtual) {
-            call += `this->vtable->${method.shortName}`;
-        } else {
-            call += `${method.getName()}->get(false)`;
-        }
-        call += '(';
-        if (!method.isStatic) {
-            call += `(${method.self} *) this, `;
-        }
-        call += 'std::forward<Args>(args)...)';
-        // Generate Shortcut
         let out = '';
-        out += `${INDENT}template <typename... Args>\n`;
         out += INDENT;
         if (method.isStatic) {
             out += 'static ';
         }
-        out += `auto ${method.shortName}(Args&&... args) -> decltype(${call}) {\n`;
+        out += `decltype(auto) ${method.shortName}(auto&&... args) {\n`;
-        out += `${INDENT}${INDENT}return ${call};\n`;
+        out += `${INDENT}${INDENT}return `;
+        if (isVirtual) {
+            out += `this->vtable->${method.shortName}`;
+        } else {
+            out += `${method.getName()}->get(false)`;
+        }
+        out += '(';
+        if (!method.isStatic) {
+            out += `(${method.self} *) this, `;
+        }
+        out += 'std::forward<decltype(args)>(args)...);\n';
         out += `${INDENT}}\n`;
         return out;
     }
     #generateMethods() {
         let out = '';
+        out += LEAN_HEADER_GUARD;
         // Normal Methods
         for (const method of this.#methods) {
             out += this.#generateMethod(method, false);
@@ -179,6 +176,7 @@ export class Struct {
             }
         }
         // Return
+        out += '#endif\n';
         return out;
     }
 
@@ -202,11 +200,18 @@ export class Struct {
         }
 
         // Method Wrappers
+        let typedefs = '';
+        let methodsOut = '';
         for (const method of this.#methods) {
             if (!method.isInherited) {
-                out += method.generate(false, false);
+                typedefs += method.generateTypedefs();
+                methodsOut += method.generate(false, false);
             }
         }
+        out += typedefs;
+        out += LEAN_HEADER_GUARD;
+        out += methodsOut;
+        out += '#endif\n';
 
         // Structure
         out += `struct ${this.#name} {\n`;

src/vtable.ts

@@ -1,4 +1,4 @@
-import { INDENT, POINTER_SIZE, assertSize, getSelfArg, preventConstruction, toHex } from './common';
+import { INDENT, LEAN_HEADER_GUARD, POINTER_SIZE, assertSize, getSelfArg, preventConstruction, toHex } from './common';
 import { Method } from './method';
 import { Property } from './property';
 
@@ -116,13 +116,20 @@ export class VTable {
 
         // Wrappers
         const methods = this.getMethods();
-        if (this.canGenerateWrappers()) {
+        let typedefs = '';
-            for (const info of methods) {
+        let methodsOut = '';
-                if (info) {
+        for (const info of methods) {
-                    out += info.generate(false, true);
+            if (info) {
+                typedefs += info.generateTypedefs();
+                if (this.canGenerateWrappers()) {
+                    methodsOut += info.generate(false, true);
                 }
             }
         }
+        out += typedefs;
+        out += LEAN_HEADER_GUARD;
+        out += methodsOut;
+        out += '#endif\n';
 
         // Structure
         out += `typedef struct ${this.#getName()} ${this.#getName()};\n`;
@@ -130,7 +137,7 @@ export class VTable {
         for (let i = 0; i < methods.length; i++) {
             const info = methods[i];
             if (info) {
-                out += info.getProperty(this.canGenerateWrappers());
+                out += info.getProperty();
             } else {
                 out += `${INDENT}void *unknown${i};\n`;
             }