Compiler Explorer

Source code

// fmt.h
//
// Include library implementation into the translation unit:
// #define FMT_IMPLEMENTATION

#ifndef FMT_H
#define FMT_H

// =================================================================================================
//  Configuration
// =================================================================================================

// Automatically flush file and console writers after each newline. Otherwise, by default, writers
// are only auto-flushed once the internal buffer gets full.
//
// Enable this option, so you don't have to manually flush the writers.
//
// #define FMT_FLUSH_AFTER_NEWLINES

// Include an interface for dynamic allocation of writers:
// #define FMT_DYN_INTERFACE

// Define a custom interface implementation for writing into console and files.
//
// Otherwise, by default:
//  - WriteFile from kernel32 is used on Windows.
//  - write from <unistd.h> is used on Linux.

#ifndef FMT_FILE_T
    #define FMT_USE_DEFAULT_FILE_INTERFACE

#if defined(_WIN32)
        #define FMT_FILE_T void *
        #define FMT_FILE_STDOUT fmt__win32_console_handle(FMT_CONSOLE_STDOUT)
        #define FMT_FILE_STDERR fmt__win32_console_handle(FMT_CONSOLE_STDERR)
        #define FMT_FILE_WRITE(file, ptr, size) fmt__file_write(file, (u8 const *) (ptr), size)
    #elif defined(linux)
        #define FMT_FILE_T int
        #define FMT_FILE_STDOUT ((FMT_FILE_T) 1)
        #define FMT_FILE_STDERR ((FMT_FILE_T) 2)
        #define FMT_FILE_WRITE(file, ptr, size) fmt__file_write(file, (u8 const *) (ptr), size)
    #else
        #error "This platform is not supported by default. " \
               "You need to manually define an interface for writing into console and files."
    #endif
#endif

// Define a custom allocator for dynamic allocation of writers.
//
// Otherwise, by default:
//  - HeapAlloc/HeapFree from kernel32 is used on Windows.
//  - malloc/free from <stdlib.h> is used on Linux.

#if defined(FMT_DYN_INTERFACE) && !defined(FMT_ALLOCATOR_T)
    #define FMT_USE_DEFAULT_ALLOCATOR

#if defined(_WIN32)

#define FMT_ALLOCATOR_T void *
        #define FMT_ALLOCATOR NULL

#define FMT_ALLOC(allocator, size) \
            ((void) (allocator), HeapAlloc(GetProcessHeap(), 0, size))

#define FMT_DEALLOC(allocator, ptr) \
            ((void) (allocator), HeapFree(GetProcessHeap(), 0, ptr))

#elif defined(linux)

#define FMT_ALLOCATOR_T void *
        #define FMT_ALLOCATOR NULL

#define FMT_ALLOC(allocator, size) ((void) (allocator), malloc(size))
        #define FMT_DEALLOC(allocator, ptr) ((void) (allocator), free(ptr))

#else
        #error "This platform is not supported by default. " \
               \
               "You need to either define a custom allocator or disable the interface for " \
               "dynamic allocation of writers."
    #endif
#endif

#ifndef FMT_BUFFER_SIZE
    #define FMT_BUFFER_SIZE ((isize) 4096)
#endif

// Make implementation private to the translation unit:
#ifdef FMT_STATIC_IMPLEMENTATION
    #define FMT_API static
#else
    #define FMT_API
#endif

#ifndef FMT_USIZE_T
    #define FMT_USIZE_T unsigned long
    #define FMT_ISIZE_T long
#endif

#ifndef FMT_U8_T
    #define FMT_U8_T unsigned char
    #define FMT_I8_T char

#define FMT_U16_T unsigned short
    #define FMT_I16_T short

#define FMT_U32_T unsigned int
    #define FMT_I32_T int

#define FMT_U64_T unsigned long long
    #define FMT_I64_T long long
#endif

#ifndef FMT_MEMCPY
    #define FMT_MEMCPY fmt__nostd_memcpy
#endif

#ifndef FMT_MEMMOVE
    #define FMT_MEMMOVE fmt__nostd_memmove
#endif

// =================================================================================================
//  Usage examples
// =================================================================================================

// clang-format off

// Formatting a variety of different types of values.
#if 0
    #define FMT_IMPLEMENTATION
    #include "fmt.h"

int main(void) {
        FMT_STDOUT("Bool: {} or {}\n", FMT(bool, true), FMT(bool, false));

FMT_STDOUT("ASCII char: '{}'\n", FMT(char, '@'));

FMT_STDOUT("Unicode code point: '{}'\n", FMT(CodePoint, 0x1f41b));

FMT_STDOUT("C-style string: \"{}\"\n", FMT(String, "hello"));

FMT_STDOUT(
            "UTF-16 string: \"{}\"\n",
            FMT(U16String,
                u"Оказывается, под линуксом строковые литералы с префиксом L кодируются в UTF-32. "
                u"А этот UTF-16 префикс появился только в C11."),
        );

FMT_STDOUT("Max 64-bit int: {}\n", FMT(i64, I64_MAX, .plus = true));
        FMT_STDOUT("Min 64-bit int: {}\n", FMT(i64, I64_MIN));

FMT_STDOUT(
            "Hex int: 0x{}\n",
            FMT(u32, 0xababa, .hex = true, .uppercase = true, .precision = 8)
        );

FMT_STDOUT("Negative int in binary: 0b{}\n", FMT(i16, -64, .bin = true));

// This writer is stack-allocated.
        FmtWriter console = FMT_STDOUT_WRITER();

i32 cell_width = 5;
        i32 table_size = 21;
        for (i32 i = 0; i < table_size * table_size; i += 1) {
            i32 x = i % table_size, y = i / table_size;

if (x == 0 && y == 0) {
                fmt_write_arg(&console, &FMT(String, "", .pad = cell_width));
            } else if (x == 0 || y == 0) {
                fmt_write_arg(&console, &FMT(i32, x | y, .pad = cell_width, .padder = ' '));
            } else {
                fmt_write_arg(&console, &FMT(i32, x * y, .pad = cell_width, .padder = ' '));
            }

if (x == table_size - 1) {
                fmt_write_char(&console, '\n');
            }
        }

fmt_flush(&console);
    }
#endif

// Defining a custom formatter.
#if 0
    #define FMT_IMPLEMENTATION
    #include "fmt.h"

typedef struct {
        i32 x, y;
    } Vec2;

#define FMT_Vec2(type, name, value, ...) \
        FMT_Pointer(type, name, value, .fmt = fmt_vec2, __VA_ARGS__)

isize fmt_vec2(FmtWriter *writer, void const *vector) {
        Vec2 const *v = vector;
        return FMT_WRITE(writer, "vec2({}, {})", FMT(i32, v->x), FMT(i32, v->y));
    }

int main(void) {
        Vec2 vector = {42, -24};
        FMT_STDOUT("{}\n", FMT(Vec2, &vector));
    }
#endif

// Defining a custom allocator.
#if 0
    #include <stddef.h> // NULL
    #include <stdint.h> // uint8_t, intptr_t
    #include <stdlib.h> // exit

#define FMT_ALLOCATOR_T MyAllocator *
    typedef struct {
        uint8_t buffer[8192];
        intptr_t size;
    } MyAllocator;

#define FMT_ALLOCATOR (&my_allocator)
    MyAllocator my_allocator = {.size = 0};

#define FMT_ALLOC my_alloc
    void *my_alloc(MyAllocator *my_alloc, intptr_t size) {
        if (my_alloc->size + size <= sizeof(my_alloc->buffer)) {
            uint8_t *ptr = my_alloc->buffer + my_alloc->size;
            my_alloc->size += size;
            return ptr;
        } else {
            return NULL;
        }
    }

#define FMT_DEALLOC my_dealloc
    void my_dealloc(MyAllocator *my_alloc, void *ptr) {
        (void) my_alloc;
        (void) ptr;
    }

#define FMT_IMPLEMENTATION
    #define FMT_DYN_INTERFACE
    #include "fmt.h"

FmtWriter get_console(void) {
        FmtWriter console;
        if (!fmt_dyn_console_writer(FMT_ALLOCATOR, FMT_CONSOLE_STDOUT, &console)) {
            exit(1);
        }

return console;
    }

int main(void) {
        FmtWriter console = get_console();

fmt_write_string(&console, "Hey\n");
        fmt_flush(&console);

fmt_dyn_console_writer_destroy(FMT_ALLOCATOR, &console);
    }
#endif

// Rendering to a string + an example of how to use named args.
#if 0
    #include <stdlib.h> // malloc/free

#define FMT_IMPLEMENTATION
    #include "fmt.h"

int main(void) {
        char const *format = "{pill}Rendering{heart}to{heart}a{heart}string{heart}example{pill}\n";
        FormatArg format_args[2] = {
            FMT_KEY(CodePoint, pill, 0x1f48a, .pad = 3, .align = FMT_ALIGN_CENTER),
            FMT_KEY(U16String, heart, u"🩷", .pad = 3, .align = FMT_ALIGN_CENTER),
        };

isize required_string_size = fmt_string_write_args(NULL, 0, format, format_args, 2);
        char *string = malloc(required_string_size);
        if (string == NULL) {
            return 1;
        }

fmt_string_write_args(string, required_string_size, format, format_args, 2);
        FMT_STDOUT("{}", FMT(StringView, string, .size = required_string_size));

free(string);

return 0;
    }
#endif

// clang-format on

// =================================================================================================
//  Typedefs used within the library interface
// =================================================================================================

// I tried to make the library implementation compilable with a C++ compiler, however, heavy use of
// compound literals in macros (e.g. within FMT and FMT_STDOUT) makes it mostly useless in C++.

#ifdef __cplusplus
extern "C" {
#endif

// "ifdef __STDC_VERSION__" check is there because MSVC doesn't define it unless you specify the
// "/std" option explicitly. It would obviously be much better to include <stdbool.h> here instead
// of reinventing the wheel, but I couldn't care less about C standard library headers, I'm sorry.
//
// "#define bool _Bool" instead of "typedef _Bool bool", so that you could #undef my bool, if you
// don't like it.

#if !defined(__cplusplus) && !defined(bool)                                                        \
    && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 202300L)

#define true 1
    #define false 0
    #define bool _Bool

#endif

// I don't want to prefix these types, so configure them to be the same as in the code where the
// header gets included, if you happen to use the same alias names. (C doesn't complain when you
// repeat the same typedef multiple times.)

typedef FMT_U8_T u8;
typedef FMT_I8_T i8;

typedef FMT_U16_T u16;
typedef FMT_I16_T i16;

typedef FMT_U32_T u32;
typedef FMT_I32_T i32;

typedef FMT_U64_T u64;
typedef FMT_I64_T i64;

typedef FMT_USIZE_T usize;
typedef FMT_ISIZE_T isize;

// =================================================================================================
//  Generic polymorphic writer interface
// =================================================================================================

typedef void (*FmtWriteFunction)(void *writer_data, u8 const *data, isize size);
typedef void (*FmtFlushFunction)(void *writer_data);

typedef struct {
    void *data;
    FmtWriteFunction write;
    FmtFlushFunction flush;
} FmtWriter;

FMT_API void fmt_write(FmtWriter *writer, u8 const *data, isize size);
FMT_API void fmt_flush(FmtWriter *writer);

// =================================================================================================
//  Specific writers' implementations
// =================================================================================================

typedef struct {
    u8 *data;
    isize size;
    isize capacity;
} FmtBuffer;

typedef FMT_FILE_T FmtFile;

typedef struct {
    FmtFile file;
    FmtBuffer buffer;
} FmtFileWriter;

FMT_API void fmt_file_writer_write(void *writer_data, u8 const *data, isize size);
FMT_API void fmt_file_writer_flush(void *writer_data);

typedef enum {
    FMT_CONSOLE_STDOUT,
    FMT_CONSOLE_STDERR,
} FmtConsoleOutputType;

FMT_API FmtFile fmt_console_handle(FmtConsoleOutputType console_type);

typedef FmtFileWriter FmtConsoleWriter;

typedef FmtBuffer FmtStringWriter;

FMT_API void fmt_string_writer_write(void *writer_data, u8 const *data, isize size);
FMT_API void fmt_string_writer_flush(void *writer_data);

// =================================================================================================
//  Dynamically allocated writers (they can be copied around and stored anywhere)
// =================================================================================================

#ifdef FMT_DYN_INTERFACE

typedef FMT_ALLOCATOR_T FmtAllocator;

FMT_API bool fmt_dyn_file_writer(FmtAllocator allocator, FmtFile file, FmtWriter *writer);
FMT_API void fmt_dyn_file_writer_destroy(FmtAllocator allocator, FmtWriter *writer);

FMT_API bool fmt_dyn_console_writer(
    FmtAllocator allocator,
    FmtConsoleOutputType console_type,
    FmtWriter *writer
);
FMT_API void fmt_dyn_console_writer_destroy(FmtAllocator allocator, FmtWriter *writer);

FMT_API bool fmt_dyn_string_writer(
    FmtAllocator allocator,
    char *string,
    isize string_capacity,
    FmtWriter *writer
);
FMT_API void fmt_dyn_string_writer_destroy(FmtAllocator allocator, FmtWriter *writer);

#endif // FMT_DYN_INTERFACE

// =================================================================================================
//  Stack-allocated writers (they don't survive getting out of the outer scope)
// =================================================================================================

// https://en.cppreference.com/w/c/language/compound_literal
// > The unnamed object to which the compound literal evaluates has static storage duration if the
// > compound literal occurs at file scope and automatic storage duration if the compound literal
// > occurs at block scope (in which case the object's lifetime ends at the end of the enclosing
// > block).
//
// Also:
// https://x.com/mono_morphic/status/1869303586502397994

#define FMT_FILE_WRITER(file_) (FmtWriter) {                                                       \
    .data = &(FmtFileWriter) {                                                                     \
        .file = (file_),                                                                           \
        .buffer = {                                                                                \
            .data = (u8[FMT_BUFFER_SIZE]){},                                                       \
            .size = 0,                                                                             \
            .capacity = FMT_BUFFER_SIZE,                                                           \
        },                                                                                         \
    },                                                                                             \
    .write = fmt_file_writer_write,                                                                \
    .flush = fmt_file_writer_flush,                                                                \
}

#define FMT_CONSOLE_WRITER(console_type) (FmtWriter) {                                             \
    .data = &(FmtConsoleWriter) {                                                                  \
        .file = fmt_console_handle(console_type),                                                  \
        .buffer = {                                                                                \
            .data = (u8[FMT_BUFFER_SIZE]){},                                                       \
            .size = 0,                                                                             \
            .capacity = FMT_BUFFER_SIZE,                                                           \
        },                                                                                         \
    },                                                                                             \
    .write = fmt_file_writer_write,                                                                \
    .flush = fmt_file_writer_flush,                                                                \
}
#define FMT_STDOUT_WRITER() FMT_CONSOLE_WRITER(FMT_CONSOLE_STDOUT)
#define FMT_STDERR_WRITER() FMT_CONSOLE_WRITER(FMT_CONSOLE_STDERR)

#define FMT_STRING_WRITER(string, string_capacity) (FmtWriter) {                                   \
    .data = &(FmtStringWriter) {                                                                   \
        .data = (u8 *) (string),                                                                   \
        .size = 0,                                                                                 \
        .capacity = (string_capacity),                                                             \
    },                                                                                             \
    .write = fmt_string_writer_write,                                                              \
    .flush = fmt_string_writer_flush,                                                              \
}

// =================================================================================================
//  Functions for writing primitive values
// =================================================================================================

typedef u32 FmtCodePoint;

FMT_API isize fmt_write_char(FmtWriter *writer, char value);
FMT_API isize fmt_write_char_repeat(FmtWriter *writer, isize repeat_count, char value);
FMT_API isize fmt_write_code_point(FmtWriter *writer, FmtCodePoint code_point);

FMT_API isize fmt_write_sv(FmtWriter *writer, u8 const *data, isize size);
FMT_API isize fmt_write_u16_sv(FmtWriter *writer, u16 const *data, isize size);

FMT_API isize fmt_write_string(FmtWriter *writer, char const *data);
FMT_API isize fmt_write_u16_string(FmtWriter *writer, u16 const *data);

FMT_API isize fmt_write_bool(FmtWriter *writer, bool value);

typedef struct {
    u64 unsigned_value;
    isize size;
    bool is_negative;
} FmtIntValue;

typedef struct {
    u64 base;
    bool make_uppercase;
    bool include_plus;
    isize precision;
} FmtIntParams;

FMT_API isize
fmt_write_int(FmtWriter *writer, FmtIntValue const *value, FmtIntParams const *params);

typedef enum {
    FMT_ALIGN_RIGHT,
    FMT_ALIGN_CENTER,
    FMT_ALIGN_LEFT,
} FormatAlignment;

FMT_API isize
fmt_left_padding_amount(isize content_width, isize padding, FormatAlignment alignment);

FMT_API isize
fmt_right_padding_amount(isize content_width, isize padding, FormatAlignment alignment);

// =================================================================================================
//  Format arguments
// =================================================================================================

typedef enum {
    FORMAT_ARG_INT,
    FORMAT_ARG_BOOL,
    FORMAT_ARG_CHAR,
    FORMAT_ARG_CODE_POINT,
    FORMAT_ARG_STRING_VIEW,
    FORMAT_ARG_U16_STRING_VIEW,
    FORMAT_ARG_STRING,
    FORMAT_ARG_U16_STRING,
    FORMAT_ARG_POINTER,
} FormatArgKind;

#define FMT_PADDING_PARAMS                                                                         \
    isize pad;                                                                                     \
    char padder;                                                                                   \
    FormatAlignment align

typedef struct {
    FMT_PADDING_PARAMS;
} FormatArgPaddingParams;