Human readable size to bytes in C

humanread.c

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <errno.h>
#include <string.h>

static char *human_readable_suffix = "kMGT";

size_t *parse_human_readable(char *input, size_t *target) {
    char *endp = input;
    char *match = NULL;
    size_t shift = 0;
    errno = 0;

    long double value = strtold(input, &endp);
    if(errno || endp == input || value < 0)
        return NULL;

    if(!(match = strchr(human_readable_suffix, *endp)))
        return NULL;

    if(*match)
        shift = (match - human_readable_suffix + 1) * 10;

    *target = value * (1LU << shift);

    return target;
}

int test(char *input, size_t expected) {
    size_t value;

    if(!parse_human_readable(input, &value)) {
        if(expected == 0)
            return printf("%-6s => error (expected)\n", input);

        return printf("%-6s => error, expected: %lu\n", input, expected);
    }

    if(expected == value)
        return printf("%-6s => %14lu [ok, expected: %lu]\n", input, value, expected);

    return printf("%-6s => %14lu [error, expected: %lu]\n", input, value, expected);
}

int main(void) {
    test("1337", 1337);
    test("857.54", 857);
    test("128k", 128 * 1024);
    test("1.5k", 1536);
    test("8M", 8 * 1024 * 1024);
    test("0x55", 0x55);
    test("0x55k", 0x55 * 1024);
    test("1T", 1024 * 1024 * 1024 * 1024LU);
    test("32.", 32);
    test("-87", 0);
    test("abcd", 0);
    test("32x", 0);

    return 0;
}

Ouput:

1337   =>           1337 [ok, expected: 1337]
857.54 =>            857 [ok, expected: 857]
128k   =>         131072 [ok, expected: 131072]
1.5k   =>           1536 [ok, expected: 1536]
8M     =>        8388608 [ok, expected: 8388608]
0x55   =>             85 [ok, expected: 85]
0x55k  =>          87040 [ok, expected: 87040]
1T     =>  1099511627776 [ok, expected: 1099511627776]
32.    =>             32 [ok, expected: 32]
-87    => error (expected)
abcd   => error (expected)
32x    => error (expected)