iostream.h: cin and cout for C using GCC and C11 extensions

_README.md

iostream.h

iostream.h (ab?)uses _Generic, __builtin_choose_expr, __typeof__, statement expressions, and recursive variadic macro expansion to create a cin and cout for C11+GCC extension compilers.

Should you use this? Of course not. But it's pretty f***ing cool.

Usage

#include <stdbool.h>
#include <stdio.h>
#include "iostream.h"

int main(void) {
    int x;
    cout("Give me an int!", '\n');
    cin(x);
    cout(x, endl);
    
    double d;
    cout("Give me a double!", "\n");
    cin(d);
    cout(x, endl);
    
    char buf[21];
    cout("Give me a string (20 chars. max, but I won't overflow, I promise)!", endl);
    cin(buf, sizeof(buf));
    cout(buf, '\n');
    
    char *buf = NULL;
    char **buf_p = &buf;
    cout("Give me a string and go nuts!", endl, "Any length, I don't mind!\n");
    cin(buf_p);
    cout(buf, "\nDid you doubt me?\n");
    free(buf);
    
    bool b;
    cout("Give me a number that is either zero or non-zero", endl);
    cin(b);
    cout("is your number zero? The answer is ", b, endl);
    cout("true or false?", endl);
    cin(b, boolalpha);
    cout("You picked ", b, endl);
}

iostream.h

/* Copyright (C) 2019 easyaspi314 (Devin).
 * Released under the MIT license.
 *
 * Permission is hereby granted, free of charge, to any person 
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or 
 * sell copies of the Software, and to permit persons to whom
 * the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall
 * be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE. */


/* iostream.h: cin and cout, for C.
 * Requires a recent GCC or Clang version with support for C11,
 * __builtin_choose_expr, and _Generic, and preferrably it should
 * have a getline implementation, although it isn't required.
 *
 * Usage: See below. */
#define __STDC_WANT_LIB_EXT2__ 1
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

// https://github.com/swansontec/map-macro
#include "map.h"

// Clears the data left over by scanf.
static inline void _clear_stdin(void)
{
    int _c;
    while ((_c = getchar()) != '\n' && _c != EOF)
        ;
}

/// A wrapper for fgets which also null terminates the string and doesn't
/// leave anything in stdin.
__attribute__((__unused__))
static int _length_getline(char *_x, size_t _length)
{
    if (_x == NULL || _length < 1) {
        return EOF;
    }

    memset(_x, 0, _length); 

    // Skip whitespace and read the first character.
    if (scanf(" %c", _x) == EOF) {
        return EOF;
    }
    if (_length == 2) {
        return 1;
    }
    // Read starting at the first character because we just got it from
    // scanf.
    if (fgets(_x + 1, (int)_length - 1, stdin) == NULL) {
        return EOF;
    }

    // Find the newline in the string. Replace it with '\0' if it exists,
    // or clear out the line because there is data left over.
    char *_newline = strchr(_x, '\n');
    if (_newline != NULL) {
        *_newline = '\0';
    } else {
        // There is extra data, ignore it.
        _clear_stdin();
    }
    return 1;
}

/// Dynamically allocates a buffer large enough to store the next line from stdin, null terminates it (removing '\n'),
/// and stores it in _x.
__attribute__((__unused__))
static int _malloc_getline(char **_x)
{
#if !defined(IOSTREAM_DISABLE_GETLINE) \
   && (defined(__STDC_ALLOC_LIB__) /* C2x hyyype! */ \
        || (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200803L) || defined(_GNU_SOURCE) /* glibc */ \
        || defined(_WITH_GETLINE) /* BSD */ \
      )
    if (_x == NULL) {
        return EOF;
    }

    char _tmp;
    // Skip whitespace until the first character.
    if (scanf(" %c", &_tmp) == EOF) {
        return EOF;
    }

    // We have to put that first one back and read again. 
    // getline will (re)allocate memory and you can't just give an
    // offset pointer to realloc.
    ungetc(_tmp, stdin);

    // Set up *_x for getline
    *_x = NULL;
    size_t _size = 0;

    // Read the line
    if (getline(_x, &_size, stdin) == -1) {
        free(*_x);
        *_x = NULL;
        return EOF;
    }

    // Replace '\n' with '\0'.
    char *_newline = strchr(*_x, '\n');
    if (_newline != NULL) {
        *_newline = '\0';
    }
    return 1;

#else // No getline. :(
    if (_x == NULL) {
        return EOF;
    }
    // 64 should be a decent size.
    int _size = 64;
    int _offset = 1;

    *_x = malloc((size_t)_size + 2);
    if (*_x == NULL) {
        return EOF;
    }
    // Skip whitespace and read the first character
    if (scanf(" %c", *_x) == EOF) {
        free(*_x);
        *_x = NULL;
        return EOF;
    }

    // Read in chunks starting at the first character.
    while (fgets((*_x) + _offset, _size + 1, stdin) != NULL) {
        char *_newline;
        // Find the newline and replace it if we can
        if ((_newline = strchr((*_x) + _offset, '\n')) != NULL) {
            *_newline = '\0';
            return 1;
        } else if (feof(stdin)) {
            // We might be at the end.
            return 1;
        } else {
            // Grow the buffer by _size
            _offset += _size;
            char *_tmp = realloc(*_x, (size_t)(_size + _offset + 1));
            if (_tmp == NULL) {
                free(*_x);
                *_x = NULL;
                return EOF;
            }
            *_x = _tmp;
        }
    }
    // shouldn't be able to get here but ok whatever
    return EOF;
#endif // No getline
}

// Reads either "true" or "false" from stdin like std::boolalpha if _alpha
// is true, or reads an integer and converts to bool.
static int _read_bool(_Bool *_b, _Bool _alpha)
{
    if (_b == NULL) {
        return EOF;
    }
    if (_alpha) {
        char _buf[7];
        // We read just enough to get a full word plus a space.
        if (scanf("%6s", _buf) == EOF) {
            return EOF;
        }
        if (strlen(_buf) == 5 && !strcmp(_buf, "false")) {
            *_b = 0;
        } else if (strlen(_buf) == 4 && !strcmp(_buf, "true")) {
            *_b = 1;
        } else {
            return EOF;
        }
        return 1;
    } else {
        long long val = 0;
        // Read into long long because it is the largest type we can have.
        // Otherwise, truncation might cause issues.
        if (scanf("%lli", &val) < 1) {
            return EOF;
        }

        // "cast to bool"
        *_b = !!val;
        return 1;
    }
}

// clang-format doesn't handle _Generic properly.
// clang-format off

// To make cin work with strict aliasing.
union _iostream_pun {
    _Bool *_b;
    char *_c;
    char **_char_p;
    unsigned char *_hhu;
    signed char *_hhi;
    unsigned short *_hu;
    signed short *_hi;
    unsigned int *_u;
    signed int *_i;
    unsigned long *_lu;
    signed long *_li;
    unsigned long long *_llu;
    signed long long *_lli;
    float *_f;
    double *_lf;
    long double *_Lf;
    void *_p;
};


/// See below.
#define _cin_impl(x, len) __extension__ ({                                                \
    union _iostream_pun _x = { ._p = &(x) };                                              \
    int _tmp = _Generic((x),                                                              \
        _Bool: _read_bool(_x._b, len),                                                    \
        char: scanf(" %c", _x._c),                                                        \
        signed char: scanf("%hhi", _x._hhi),                                              \
        unsigned char: scanf("%hhu", _x._hhu),                                            \
        signed short: scanf("%hi", _x._hi),                                               \
        unsigned short: scanf("%hu", _x._hu),                                             \
        signed int: scanf("%i", _x._i),                                                   \
        unsigned int: scanf("%u", _x._u),                                                 \
        signed long: scanf("%li", _x._li),                                                \
        unsigned long: scanf("%lu", _x._lu),                                              \
        signed long long: scanf("%lli", _x._lli),                                         \
        unsigned long long: scanf("%llu", _x._llu),                                       \
        float: scanf("%f", _x._f),                                                        \
        double: scanf("%lf", _x._lf),                                                     \
        long double: scanf("%Lf", _x._Lf),                                                \
        /* uintptr_t hides the "cast to pointer from smaller size" warning */             \
        char **: _malloc_getline((char **)((uintptr_t)(x))),                              \
        char *: _length_getline((char *)((uintptr_t)(x)), len /* bufsize */)              \
    );                                                                                    \
    /* set the value to zero on errors like std::cin. */                                  \
    if (_tmp < 1) {                                                                       \
        _Generic((x),                                                                     \
            char *: (void)0, char **: (void)0, default: (void)memset(_x._p, 0, sizeof(x)) \
        );                                                                                \
    }                                                                                     \
    /* Don't clear when we have char * or char ** as those do that automatically. */      \
    _Generic((x), char *: (void)0, char **: (void)0, default: _clear_stdin());            \
    _tmp;                                                                                 \
})


/// int cin(T x, [size_t len|bool boolalpha]):
/// Reads a line from stdin into x using _Generic to determine the type.
/// For char *, the len argument is required and it sets the limit to how long the input
/// will be including a null terminator.
/// For both char * and char **, the string will be null terminated, with any newlines
/// removed.
///
/// Usage:
///   // Basic arithmetic types can be read like so:
///   {int, char, signed char, unsigned long long, float, etc} x;
///   cin(x);
///
///   // Truncated strings pass the length (including the null terminator) as a second argument.
///   char str[21];
///   cin(str, sizeof(str));
///
///   // A dynamically allocated line will be recieved like so
///   char *buf = NULL;
///   char **tmp = &buf;
///   cin(tmp);
///   // don't forget to free!
///
/// Caveats:
///  - To read a character, use 'char'. To read an 8-bit signed integer, use 'signed char',
///    and for an 8-bit unsigned integer, use 'unsigned char'.
///  - Hex and octal are only detected with signed variables, due to the limitations of
///    scanf.
///  - As shown above, you need a temporary variable set to the address of a null char
///    pointer to get the automatic memory allocation to work. The buffer must be freed.
///
/// Returns EOF on an error, or anything else otherwise.
#define cin(...) _cin_impl_wrap(__VA_ARGS__, 0, 0)

/// Wrapper for cin that prevents variadic macro warnings.
#define _cin_impl_wrap(x, len, ...) _cin_impl(x, len + 0)


#define boolalpha 1
/// For those who prefer it.
#define endl ((char)'\n')

/// Attempts to use lexical parsing to tell whether an int is a char literal or not.
/// See below for how it works.
#define _is_char_literal(x) (sizeof(#x) > 3 && ((#x)[0] == '\'' || (#x)[sizeof(#x) - 2] == '\''))

/// Prints x to the console. See cout below.
#define _cout_impl(x) __extension__({                                                      \
    /* typeof doesn't decay array to pointer. We can however use __builtin_choose_expr     \
     * to either select the type of the argument or const char *. */                       \
    __typeof__(                                                                            \
        __builtin_choose_expr(_Generic((x), char *: 0, const char *: 0, default: 1),       \
                                       (x),                                                \
                                       (const char *)NULL)                                 \
    ) _x = (x);                                                                            \
    /* XXX: Does this violate strict aliasing? GCC doesn't warn about it. */               \
    const void *_val = &_x;                                                                \
    _Generic((x),                                                                          \
        _Bool: fputs((*(const _Bool *)(_val)) ? "true" : "false", stdout),                 \
        char: putchar(*(const char *)(_val)),                                              \
        signed char: printf("%hhi", *(const signed char *)(_val)),                         \
        unsigned char: printf("%hhu", *(const unsigned char *)(_val)),                     \
        signed short: printf("%hi", *(const signed short *)(_val)),                        \
        unsigned short: printf("%hu", *(const unsigned short *)(_val)),                    \
        signed int: (_is_char_literal(x) ? putchar(*(const signed int *)(_val))            \
                                          : printf("%i", *(const signed int *)(_val))),    \
        unsigned int: (_is_char_literal(x) ? putchar(*(const signed int *)(_val))          \
                                          : printf("%u", *(const unsigned int *)(_val))),  \
        signed long: printf("%li", *(const signed long *)(_val)),                          \
        unsigned long: printf("%lu", *(const unsigned long *)(_val)),                      \
        signed long long: printf("%lli", *(const signed long long *)(_val)),               \
        unsigned long long: printf("%llu", *(const unsigned long long *)(_val)),           \
        float: printf("%f", (const double)*(const float *)(_val)),                         \
        double: printf("%lf", *(const double *)(_val)),                                    \
        long double: printf("%Lf", *(const long double *)(_val)),                          \
        char *: fputs((const char *)((const uintptr_t)(_x)), stdout),                      \
        const char *: fputs((const char *)((const uintptr_t)(_x)), stdout),                \
        void *: printf("%p", (const void *)(const uintptr_t)(x))                           \
    );                                                                                     \
})

/// Expand the cout statement into a ternary that will avoid calling further _cout_impls in
/// the case of an error.
#define _cout_expand(x) (_cout_impl(x) == EOF) ? EOF :

/// int cout(...):
/// Prints one or more items to stdout, using _Generic to deduce the proper types
/// Usage:
///   {int, char, unsigned int, const char *} x = ...;
///   cout(x, cin_endl);
///
///   cout("Hello world");
///
/// Note: Because character literals are int by default, detection of these is a little
/// hacky.
/// If the literal LEXICALLY begins or ends in a single quote (') or is manually cast
/// to char, it will use putchar. As in, the actual macro parameters are stringified and
/// checked.
///
///   cout('a');          // a
///   cout(('a'));        // 97
///   cout((char)('a'));  // a
///   cout('a' + 1);      // b
///   cout(1 + 'a');      // b
///   cout(1 + 'a' + 2);  // 100
///   int c = 'a';
///   cout(c);            // 97
///   cout((char)c);      // a
///
/// Returns: 
#define cout(...) __extension__ ({ MAP(_cout_expand, __VA_ARGS__) EOF; })
// clang-format on

#ifdef IOSTREAM_DEMO
#include <stdbool.h>
// Just a little demo/test.
int main(void)
{
    const char *space1 = " ";
    char space2[] = " ";

    // should print Hello 1 2 3
    cout((char)72, 'd' + 1, 3 + 'i', "l", 'o', ' ', 0x1, space1, 2ll, space2, (unsigned short)3u, endl);
    int x;
    cout("int: ");
    cin(x);
    cout(x, endl);
    bool b;
    cout("bool (nonzero): ");
    cin(b);
    cout(b, endl);
    cout("bool (\"true\" or \"false\"): ");
    cin(b, boolalpha);
    cout(b, endl);
    char y;
    cout("char: ");
    cin(y);
    cout(y, endl);
    char buf[21];
    cout("string (20 max): ");
    cin(buf, sizeof(buf));
    cout(buf, endl);
    char* buf_alloc = NULL;
    char** buf_alloc_p = &buf_alloc;
    cout("string: (any length): ");
    cin(buf_alloc_p);
    cout(buf_alloc, endl);
    free(buf_alloc);
    float f;
    cout("float: ");
    cin(f);
    cout(f, endl);
}
#endif

map.h

/*
 * Copyright (C) 2012 William Swanson
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy,
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * Except as contained in this notice, the names of the authors or
 * their institutions shall not be used in advertising or otherwise to
 * promote the sale, use or other dealings in this Software without
 * prior written authorization from the authors.
 */

/* https://github.com/swansontec/map-macro */
#ifndef MAP_H_INCLUDED
#define MAP_H_INCLUDED

#define EVAL0(...) __VA_ARGS__
#define EVAL1(...) EVAL0(EVAL0(EVAL0(__VA_ARGS__)))
#define EVAL2(...) EVAL1(EVAL1(EVAL1(__VA_ARGS__)))
#define EVAL3(...) EVAL2(EVAL2(EVAL2(__VA_ARGS__)))
#define EVAL4(...) EVAL3(EVAL3(EVAL3(__VA_ARGS__)))
#define EVAL(...)  EVAL4(EVAL4(EVAL4(__VA_ARGS__)))

#define MAP_END(...)
#define MAP_OUT
#define MAP_COMMA ,

#define MAP_GET_END2() 0, MAP_END
#define MAP_GET_END1(...) MAP_GET_END2
#define MAP_GET_END(...) MAP_GET_END1
#define MAP_NEXT0(test, next, ...) next MAP_OUT
#define MAP_NEXT1(test, next) MAP_NEXT0(test, next, 0)
#define MAP_NEXT(test, next)  MAP_NEXT1(MAP_GET_END test, next)

#define MAP0(f, x, peek, ...) f(x) MAP_NEXT(peek, MAP1)(f, peek, __VA_ARGS__)
#define MAP1(f, x, peek, ...) f(x) MAP_NEXT(peek, MAP0)(f, peek, __VA_ARGS__)

#define MAP_LIST_NEXT1(test, next) MAP_NEXT0(test, MAP_COMMA next, 0)
#define MAP_LIST_NEXT(test, next)  MAP_LIST_NEXT1(MAP_GET_END test, next)

#define MAP_LIST0(f, x, peek, ...) f(x) MAP_LIST_NEXT(peek, MAP_LIST1)(f, peek, __VA_ARGS__)
#define MAP_LIST1(f, x, peek, ...) f(x) MAP_LIST_NEXT(peek, MAP_LIST0)(f, peek, __VA_ARGS__)

/**
 * Applies the function macro `f` to each of the remaining parameters.
 */
#define MAP(f, ...) EVAL(MAP1(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))

/**
 * Applies the function macro `f` to each of the remaining parameters and
 * inserts commas between the results.
 */
#define MAP_LIST(f, ...) EVAL(MAP_LIST1(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))

#endif