[GEN][ZH] Add endian compat for BIGFileSystems

[Mauller]

This PR is a prerequisit to a PR to unify AsciiString, it adds endian compatibility functions within an endian_compat header.

These are then used in the BIGFileSystems as they previously reloed on the networking ntohl function.
For StdBIGFileSystem this was being indirectly provided through the windows header in AsciiString. And directly included in win32BigFileSystem through winsock2.

This change is necessary to provide cross compat byte swapping functionality.

[Mauller]

Updated with a more fleshed out endian handling compatability header.

[Mauller]

Updated, Rebased off main and merge conflict fixed.

Tweaked with discussed changes and added endian compat functions to win32Bigfilesystems for generals and zero hour along with stdbigfilesystem.

Should be good to go now.

[xezon]

VC6 does not like the variadic macro. Then we need to do #define static_assert(a,b) and we settle on static asserts always requiring 2 arguments for now.

[Mauller]

VC6 does not like the variadic macro. Then we need to do #define static_assert(a,b) and we settle on static asserts always requiring 2 arguments for now.

Yeah i just noticed this, was just about to change it, should be up in a few seconds.

[Mauller]

Now it doesn't like long long, this is taking a long long time. i should really sort my local VC6 build environment lol.

[xezon]

Looks good.

[Mauller]

Looks good.

It would seem that VC6 doesn't like the helper templates

EDIT: Figured it out, VC6 doesn't support #pragma once and i didn't include traditional header guards.

EDIT2: Nvm wasn't that...

[xezon]

It is using what is called "partial template class specialization". Perhaps VC6 does not support that?

Chat Gippity says

No, Visual C++ 6.0 (VC6) does not support partial template class specialization.

While VC6 does support full class template specialization, it lacks support for partial specialization, which was not fully implemented in Microsoft's compiler until later versions (Visual Studio .NET 2003 and later improved this significantly).

Example of what VC6 does not support:

// This is partial specialization — not supported in VC6
template <typename T, typename U>
class MyClass {};

template <typename T>
class MyClass<T, int> {
    // ...
};

What VC6 does support:

// This is full specialization — supported in VC6
template <typename T, typename U>
class MyClass {};

template <>
class MyClass<int, float> {
    // ...
};

If you need to simulate partial specialization in VC6, you can sometimes use traits classes or template overloading with helper structs, but it's usually a bit hacky.

Here’s a workaround for partial class template specialization in Visual C++ 6.0 (VC6) using helper structs and full specialization, which VC6 does support.

---

🎯 Goal:

Simulate this partial specialization (which VC6 does not support):

template <typename T, typename U>
class MyClass;

template <typename T>
class MyClass<T, int> {
    // specialized for second type being int
};

---

✅ Workaround using helper class:

// Primary implementation — not specialized
template <typename T, typename U>
struct MyClassImpl {
    static void doSomething() {
        // Generic implementation
        std::cout << "Generic MyClassImpl<T, U>\n";
    }
};

// Full specialization of helper for U = int
template <typename T>
struct MyClassImpl<T, int> {
    static void doSomething() {
        std::cout << "Specialized MyClassImpl<T, int>\n";
    }
};

// Wrapper class
template <typename T, typename U>
class MyClass {
public:
    void doSomething() {
        MyClassImpl<T, U>::doSomething();
    }
};

🔧 Usage:

#include <iostream>

int main() {
    MyClass<double, float> a;
    MyClass<char, int> b;

    a.doSomething();  // Prints: Generic MyClassImpl<T, U>
    b.doSomething();  // Prints: Specialized MyClassImpl<T, int>
    return 0;
}

---

💡 Summary:

• The key trick is to push the specialization into a secondary template, and call it from the main class.
• VC6 can fully specialize that helper, even though it can't partially specialize the main template.

Do you want a version of this that works with older C++ features only (e.g. no typename, no std::cout)?

[Mauller]

It is using what is called "partial template class specialization". Perhaps VC6 does not support that?

I have not used it before myself, just looking it up, but It's possibly not working due to a defect in the C++ 98 standard.
So VC6 might not support it with the way it has been implemented.

[Mauller]

Will have a go at this again tomorrow.

[xezon]

The Ai generated workaround looks strange however.

// Full specialization of helper for U = int
template <typename T>
struct MyClassImpl<T, int> {

It describes this as full specialization, but it still looks like partial. I expect this does not work.

[Mauller]

The Ai generated workaround looks strange however.

// Full specialization of helper for U = int
template <typename T>
struct MyClassImpl<T, int> {

It describes this as full specialization, but it still looks like partial. I expect this does not work.

I was thinking that we might have to just do

#if defined(_msc_ver) && _msc_ver < 1300
Littlefiles = ntohl(Littlefiles)
#else
Littlefiles = betoh(Littlefiles)
#endif

In the win32 big file system then conditionally gate the endian compat to include winsock2 for vc6 and hide all the template code.

[xezon]

I think we can do it simpler by creating inline functions. This should be sufficient for non-enum types.

inline uint16_t betoh(uint16_t x) ...
inline uint32_t betoh(uint32_t x) ...

[feliwir]

Letting you know that Linux & macOS both have ntohl , so not sure why we are doing a replacement

[Mauller]

Hopefully this is the one lol.

Checked the byte swap macros by having them get compiled in VS22 and they worked fine.

[Mauller]

Tested the VC6 builds and they work as expected.

[Mauller]

Refactored taking the suggestions into account.

[xezon]

Looks good.

[Mauller]

Pushed with tweaks to the comments, should be good now.

[xezon]

This was quite the journey :P

[Mauller]

This was quite the journey :P

Always learning something along the way.