Cross-platform C without the C runtime library

While recompiling a couple of my libraries for C code on unix, I realized that none of them would work on Windows without the CRT. And so began my mission to create a headerfile for my libraries that would allow cross-compatible code.

A couple of issues I ran into:

• mem functions require <string.h> which requires the CRT.
• heap has a bit of different syntax, and I'm too lazy to write an ifdef for every allocation.
• float requires _fltused to be set for the floating point emulation library through MSVC? (more research is required on this...)

The solution to the issues:

• Write some static inlines for the mem functions
• Create macros for heap allocation
• Define _fltused manually

With those solutions, I present a platform headerfile that implements a subset of the C standard library using macros. It's not complete, but it is enough to get started with a cross-platform C project without the CRT.

platform.h

#ifndef PLATFORM_H
#define PLATFORM_H

// This is so I don't have to write out a big if defined for platforms
#if defined(_WIN32) || defined(_WIN64)
    #define PLATFORM_WINDOWS
#elif defined(__linux__) || defined(__APPLE__)
    #define PLATFORM_UNIX
#else
    #error "platform not supported"
#endif

// stdint is available on both unix and Windows
#include <stdint.h>

// calloc, realloc, and free are done through macros.
// I haven't had any issues with this yet.
#ifdef PLATFORM_WINDOWS
    #define CCALLOC(type, num) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (num) * sizeof(type))
    #define CREALLOC(ptr, type, num) HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (ptr), (num) * sizeof(type))
    #define CNULLFREE(ptr) HeapFree(GetProcessHeap(), 0, (ptr)); (ptr) = NULL;

    // Inclusion of stddef because the mem functions are prototyped
    // and require size_t.
    #include <stddef.h>

    // These functions are the most canonical definitions I could find online.
    static inline int memcmp (const void * str1, const void * str2, size_t count)
    {
        const uint8_t * s1 = (const uint8_t *)str1;
        const uint8_t * s2 = (const uint8_t *)str2;

        while (count-- > 0)
        {
            if (*s1++ != *s2++)
                return s1[-1] < s2[-1] ? -1 : 1;
        }
        return 0;
    }

    static inline void * memset (void * s, int c, size_t n)
    {
        uint8_t * p= s;
        while (n--)
            *p++= c;
        return s;
    }

    static inline void * memcpy (void * dest, const void * src, size_t n)
    {
        char *       d= dest;
        const char * s= src;
        while (n--)
            *d++= *s++;
        return dest;
    }

#elif defined(PLATFORM_UNIX)
    #define CCALLOC(type, num) calloc((num), sizeof(type))
    #define CREALLOC(ptr, type, num) realloc((ptr), (num) * sizeof(type))
    #define CNULLFREE(ptr) free(ptr); (ptr)= NULL;
    #include <stdlib.h>
    // Inclusion of string.h for the mem functions
    #include <string.h>
#endif // PLATFORM_WINDOWS

#endif // PLATFORM_H

To get around the floating point emulation (which seems to be a left over from the 8086 processor days??), I made a separate header and source file to define it manually.

fltused.h

#ifndef FLTUSED_H
#define FLTUSED_H

#include "platform.h"

#ifdef PLATFORM_WINDOWS
extern int _fltused;
#endif // PLATFORM_WINDOWS

#endif // FLTUSED_H

fltused.c

#include "fltused.h"

#ifdef PLATFORM_WINDOWS
int _fltused = 1;
#endif

Conclusion

Using cmake, I was able to compile and run ctest on my unity tests without any issues on both unix and Windows. Each of my libraries had to be tweaked, however, but small changes thanks to my platform headerfile.

An example of this is below:

htable.h

#ifdef PLATFORM_WINDOWS
    #define WIN32_LEAN_AND_MEAN
    #include <Windows.h>
#elif defined(PLATFORM_UNIX)
    #include <stdlib.h>
#else
    #error "Unsupported platform"
#endif

htable.c

htable_t * htable_create (const uint32_t initial_capacity)
{
    htable_t * p_ht = NULL;

    if (0 == initial_capacity)
    {
        goto EXIT;
    }

    p_ht = CCALLOC(htable_t, 1); // yay macro

    if (NULL == p_ht)
    {
        DLOG("Failed to alloc memory for htable\n");
        goto EXIT;
    }

    p_ht->ht_size  = 0;
    p_ht->ht_cap   = initial_capacity;
    p_ht->pp_items = CCALLOC(htable_node_t *, p_ht->ht_cap); // yay macro

    if (NULL == p_ht->pp_items)
    {
        DLOG("Failed to alloc memory for htable items\n");
        CNULLFREE(p_ht); // yay macro
        goto EXIT;
    }

    if (0 != pthread_rwlock_init(&(p_ht->htable_rwlock), NULL))
    {
        DLOG("Failed to init rwlock for htable\n");
        CNULLFREE(p_ht->pp_items); // yay macro
        CNULLFREE(p_ht); // yay macro
    }

EXIT:
    return p_ht;
}

As a sidenote, the DLOG macro is from my debug library that prevents strings from being compiled into the final binary when building the release version.

Additionally, it uses token-pasting/concatenation for the strings on Windows due to wide chars, and keeps it normal for unix.

debug.h

#ifdef PLATFORM_WINDOWS
    #ifdef _DEBUG
        ...
        VOID log_debug(LPCWSTR p_format, ...);
        #define DLOG(fmt, ...) log_debug(L##fmt, ##__VA_ARGS__)
    #else
        #define log_debug(format, ...) ((void)0)
        #define DLOG(fmt, ...) ((void)0)
    #endif
#elif defined(PLATFORM_UNIX)
        ...
        void log_debug(const char * p_format, ...);
        #define DLOG(fmt, ...) log_debug(fmt, ##__VA_ARGS__)
    #else
        #define log_debug(format, ...) ((void)0)
        #define DLOG(fmt, ...) ((void)0)
    #endif
...

The preprocessor goes through and replaces any call for DLOG when not in debug mode to be a void function, which then gets optimized out.

Smooth cross-platform development from here on out (I hope). If you made it this far, enjoy this ->