reimplement OpenSHC::Text::TextEditorState

IMPLEMENTATION_CHEAT_SHEET.md

@@ -144,6 +144,7 @@ SEC_RNG::ptr->currentNumber1 % 4
   }
   ```
   Consider this, should a switch structure arise with strange fallthrough and loops, like SHC_3BB0A8C1_0x004870B0.
+- Non-consecutive case labels will likely result in a mixture of if-else and switch cases, sometimes even only if-elses. These are hard to spot. One sign, outside of weird decompiler artifacts, is that logic might be put inside a lot of conditions that feature only a single variable. Another can be a lot of GOTOs.
 
 ### Loops
 
@@ -196,6 +197,8 @@ you might have found an unrolled loop. Therefore, try to reproduce the logic in
 
 If GOTOs are present that clearly jump to the start of a loop, but the logic does not allow to do this without a GOTO, for example from a loop inside a loop, you might be able to move the continue or break condition to the outside. Methods could be placing a fitting condition related to the contained loop conditions after the loop or using a boolean flag that then functions as conditional. Both can sometimes be optimized away.
 
+If an explicit loop condition is removed from the compiler, it is able to prove all paths through the loop. If such a case happens where the condition is actually eliminated from the re-implementation, the re-implementation might be missing a condition that is present in the logic somewhere, but removed from the loop condition itself. The optimization pass failed to detect the resulting predictable loop in this latter case and the condition remains.
+
 ### GOTO
 
 A function may contain multiple GOTOs.
@@ -262,25 +265,36 @@ They are replaced by specific assembly instructions or otherwise inlined.
 A list of all intrinsics can be found in `intrin.h` in the std library, but these are mainly very low level instructions.
 However, there are also C functions that can be replaced by intrinsics. The following attempts to extract these from the header:
 
-| Intrinsic | Does                                                                                           |
-| --------- | ---------------------------------------------------------------------------------------------- |
-| `memcpy`  | Copies a memory block. **Does not support overlapping regions** (use `memmove` for overlap).   |
-| `memset`  | Fills a memory block with a byte value.                                                        |
-| `memcmp`  | Compares two memory blocks byte-by-byte.                                                       |
-| `memchr`  | Searches memory for the first occurrence of a byte.                                            |
-| `strcpy`  | Copies a null-terminated C string.                                                             |
-| `strlen`  | Returns the length of a null-terminated string (excluding `\0`).                               |
-| `strcmp`  | Compares two null-terminated C strings.                                                        |
-| `strcat`  | Appends one null-terminated C string to another.                                               |
-| `strncpy` | Copies up to N characters from a string; **may not null-terminate** if the source is too long. |
-| `strncmp` | Compares up to N characters of two strings.                                                    |
-| `wcscpy`  | Copies a null-terminated wide-character string.                                                |
-| `wcslen`  | Returns the length of a null-terminated wide string.                                           |
-| `ceil`    | Rounds a floating-point value upward to the nearest integer value.                             |
-| `abs`     | Returns the absolute value of an `int`.                                                        |
-| `labs`    | Returns the absolute value of a `long`.                                                        |
-| `longjmp` | Restores a saved execution context created by `setjmp`, continuing execution from that point.  |
-| `_setjmp` | Saves the current execution context for later restoration with `longjmp`.                      |
+| Intrinsic                 | Does                                                                                                                 |
+|---------------------------|----------------------------------------------------------------------------------------------------------------------|
+| `memcpy`                  | Copies a memory block. **Does not support overlapping regions** (use `memmove` for overlap).                         |
+| `memset`                  | Fills a memory block with a byte value.                                                                              |
+| `memcmp`                  | Compares two memory blocks byte-by-byte.                                                                             |
+| `memchr`                  | Searches memory for the first occurrence of a byte.                                                                  |
+| `strcpy`                  | Copies a null-terminated C string.                                                                                   |
+| `strlen`                  | Returns the length of a null-terminated string (excluding `\0`).                                                     |
+| `strcmp`                  | Compares two null-terminated C strings.                                                                              |
+| `strcat`                  | Appends one null-terminated C string to another.                                                                     |
+| `strncpy`                 | Copies up to N characters from a string; **may not null-terminate** if the source is too long.                       |
+| `strncmp`                 | Compares up to N characters of two strings.                                                                          |
+| `strset`                  | Sets every character in a null-terminated string to the specified character.                                         |
+| `_strset`                 | Microsoft-specific version of `strset`; sets every character in a null-terminated string to the specified character. |
+| `wcscpy`                  | Copies a null-terminated wide-character string.                                                                      |
+| `wcslen`                  | Returns the length of a null-terminated wide string.                                                                 |
+| `wcscmp`                  | Compares two null-terminated wide-character strings.                                                                 |
+| `wcscat`                  | Appends one null-terminated wide-character string to another.                                                        |
+| `wcsncpy`                 | Copies up to N wide characters; **may not null-terminate** if the source is too long.                                |
+| `wcsncmp`                 | Compares up to N wide characters of two strings.                                                                     |
+| `_wcsset`                 | Sets every character in a null-terminated wide string to the specified wide character.                               |
+| `ceil`                    | Returns the smallest integral floating-point value greater than or equal to the argument.                            |
+| `abs`                     | Returns the absolute value of an `int`.                                                                              |
+| `labs`                    | Returns the absolute value of a `long`.                                                                              |
+| `longjmp`                 | Restores a saved execution context created by `setjmp`, continuing execution from that point.                        |
+| `_setjmp`                 | Saves the current execution context for later restoration with `longjmp`.                                            |
+| `_AddressOfReturnAddress` | Returns the address of the current function's return-address storage.                                                |
+| `_WriteBarrier`           | Prevents certain compiler memory-write reorderings across the barrier.                                               |
+| `__trap`                  | Generates a processor/compiler trap, optionally with arguments.                                                      |
+
 
 In cases where the decompiler seems to perform one of these actions via simple instructions, one can also try one of these functions.
 

src/OpenSHC/OS.func.hpp

@@ -171,5 +171,13 @@ namespace OS_Func {
         void(__cdecl*)(int _Code), REIMPLEMENTED_CRT, Address::SHC_3BB0A8C1_0x00583D55, &OpenSHC::OS::_exit)
     _exit;
 
+    MACRO_FUNCTION_RESOLVER(int(__cdecl*)(FILE*, wchar_t const*, ...), REIMPLEMENTED_CRT,
+        Address::SHC_3BB0A8C1_0x005807A8, &OpenSHC::OS::_fwprintf)
+    _fwprintf;
+
+    MACRO_FUNCTION_RESOLVER(
+        long(__cdecl*)(wchar_t const*), REIMPLEMENTED_CRT, Address::SHC_3BB0A8C1_0x00580C0B, &OpenSHC::OS::__wtol)
+    __wtol;
+
 } // namespace OS_Func
 } // namespace OpenSHC

src/OpenSHC/OS.hpp

@@ -99,5 +99,9 @@ namespace OS {
 
     void __cdecl _exit(int _Code);
 
+    int _fwprintf(FILE* stream, wchar_t const* format, ...);
+
+    long __wtol(wchar_t const* str);
+
 } // namespace OS
 } // namespace OpenSHC

src/OpenSHC/OS/OS.cpp

@@ -146,5 +146,19 @@ namespace OS {
     // STUB: STRONGHOLDCRUSADER 0x00583D55
     void _exit(int _Code) { exit(_Code); }
 
+    // STUB: STRONGHOLDCRUSADER 0x005807A8
+    int _fwprintf(FILE* stream, wchar_t const* format, ...)
+    {
+        // needed for proxy
+        va_list args;
+        va_start(args, format);
+        int result = vfwprintf(stream, format, args);
+        va_end(args);
+        return result;
+    }
+
+    // STUB: STRONGHOLDCRUSADER 0x00580C0B
+    long __wtol(wchar_t const* str) { return _wtol(str); }
+
 }
 }

src/OpenSHC/Text/TextEditorState.func.hpp

@@ -36,16 +36,16 @@ namespace Text {
         findOrAddHelpSectionName;
 
         MACRO_FUNCTION_RESOLVER(
-            uint (TextEditorState::*)(FILE*), false, Address::SHC_3BB0A8C1_0x0045D200, &TextEditorState::parseHLPPart)
+            LPWSTR (TextEditorState::*)(FILE*), false, Address::SHC_3BB0A8C1_0x0045D200, &TextEditorState::parseHLPPart)
         parseHLPPart;
 
         MACRO_FUNCTION_RESOLVER(void (TextEditorState::*)(), false, Address::SHC_3BB0A8C1_0x0045D370,
             &TextEditorState::loadHelpSectionGraphics)
         loadHelpSectionGraphics;
 
-        MACRO_FUNCTION_RESOLVER(undefined* (TextEditorState::*)(int*), false, Address::SHC_3BB0A8C1_0x0045D3C0,
-            &TextEditorState::getWideCharPointer)
-        getWideCharPointer;
+        MACRO_FUNCTION_RESOLVER(uint (TextEditorState::*)(int*), false, Address::SHC_3BB0A8C1_0x0045D3C0,
+            &TextEditorState::getWideCharOrWideCharPointer)
+        getWideCharOrWideCharPointer;
 
         MACRO_FUNCTION_RESOLVER(void (TextEditorState::*)(), false, Address::SHC_3BB0A8C1_0x0045D430,
             &TextEditorState::renderHelpImageHotspots)
@@ -103,19 +103,19 @@ namespace Text {
             &TextEditorState::saveHelpFileToResource)
         saveHelpFileToResource;
 
-        MACRO_FUNCTION_RESOLVER(undefined4 (TextEditorState::*)(undefined4), false, Address::SHC_3BB0A8C1_0x0045F080,
-            &TextEditorState::getHelpTokenAdvanceLength)
-        getHelpTokenAdvanceLength;
+        MACRO_FUNCTION_RESOLVER(int (TextEditorState::*)(HelpTextToken), false, Address::SHC_3BB0A8C1_0x0045F080,
+            &TextEditorState::helpToken_getHelpTokenAdvanceLength)
+        helpToken_getHelpTokenAdvanceLength;
 
-        MACRO_FUNCTION_RESOLVER(void (TextEditorState::*)(undefined4), false, Address::SHC_3BB0A8C1_0x0045F0D0,
-            &TextEditorState::insertHelpTextToken)
-        insertHelpTextToken;
+        MACRO_FUNCTION_RESOLVER(void (TextEditorState::*)(HelpTextToken), false, Address::SHC_3BB0A8C1_0x0045F0D0,
+            &TextEditorState::helpToken_insertSpaceForHelpTextToken)
+        helpToken_insertSpaceForHelpTextToken;
 
         MACRO_FUNCTION_RESOLVER(void (TextEditorState::*)(), false, Address::SHC_3BB0A8C1_0x0045F240,
             &TextEditorState::closeHelpDialogAndReturnToMenu)
         closeHelpDialogAndReturnToMenu;
 
-        MACRO_FUNCTION_RESOLVER(int (TextEditorState::*)(LPCSTR), false, Address::SHC_3BB0A8C1_0x0045F470,
+        MACRO_FUNCTION_RESOLVER(FILE* (TextEditorState::*)(LPCSTR), false, Address::SHC_3BB0A8C1_0x0045F470,
             &TextEditorState::readCrusaderHelpHlp)
         readCrusaderHelpHlp;
 
@@ -167,7 +167,7 @@ namespace Text {
             &TextEditorState::openMapDescriptionEditorDialog)
         openMapDescriptionEditorDialog;
 
-        MACRO_FUNCTION_RESOLVER(void (TextEditorState::*)(char*, undefined4), false, Address::SHC_3BB0A8C1_0x004620F0,
+        MACRO_FUNCTION_RESOLVER(void (TextEditorState::*)(char*, int), false, Address::SHC_3BB0A8C1_0x004620F0,
             &TextEditorState::setCustomHelpText)
         setCustomHelpText;