// Trying an obsolete GNU printf extension.
 
#include <limits.h>
#include <stdio.h>
#include <printf.h>
 
#define BITS(x) (sizeof(x) * CHAR_BIT)
 
#define MIN(a, b) \
({ __auto_type _x = (a); __auto_type _y = (b); \
   (_y < _x) ? _y : _x; })
 
#define MAX(a, b) \
({ __auto_type _x = (a); __auto_type _y = (b); \
   (_y > _x) ? _y : _x; })
 
int fillc(int c, int n, FILE *stream)
{
    int result = 0;
    for (int i = 0; i < n && result != EOF; i++)
        result = fputc(c, stream);
    return result;
}
 
int bitlimit(const struct printf_info *info)
{
    if (info->is_char)
        return BITS(char);
    if (info->is_short)
        return BITS(short);
    if (info->is_long)
        return BITS(long int);
    if (info->is_long_double)
        return BITS(long long int);
    return BITS(int);
}
 
int bitlength(unsigned long long int x)
{
    return BITS(x) - __builtin_clzll(x | 1);
}
 
int print_binary(FILE *stream, const struct printf_info *info, const void *const *args)
{
    unsigned long long int value = *(const unsigned long long int *) args[0];
    int width = info->width;
    int count = MIN(bitlength(value), bitlimit(info));
 
    if (!info->left)
        fillc(info->pad, width - count, stream);
    for (int i = count-1; i >= 0; i--)
        fputc(((value >> i) & 1) + '0', stream);
    if (info->left)
        fillc(info->pad, width - count, stream);
    return MAX(width, count);
}
 
int print_binary_arginfo(const struct printf_info *info, size_t n, int *argtypes)
{
    if (n > 0)
        argtypes[0] = PA_INT | PA_FLAG_LONG_LONG;
    return 1;
}
 
int main(void)
{
    register_printf_function('B', print_binary, print_binary_arginfo);
    for (int i = 0; i < 16; i++) {
        printf("<%8B>; <%-8B>; <%08B>; <%B>\n", i, i, i, i);
    }
    const char *format[] = {
        "<%hhB>\n", "<%hB>\n", "<%B>\n", "<%lB>\n", "<%llB>\n", 0};
    for (const char **p = format; *p != 0; p++) {
        printf(*p, -1ULL);
    }
    return 0;
}

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