/* We need to return "0" when we convert 0 */

STRCMP_EQUALS("0", itoa10(0, buffer));

char *itoa10(int value, char *buffer) {
    char *result = buffer;
    *buffer++ = '0';
    *buffer = '\0';
    return result;
}

/* We need to return "1" when we convert 1 */

STRCMP_EQUALS("1", itoa10(1, buffer));

char *itoa10(int value, char *buffer) {
    char *result = buffer;
    *buffer++ = '0' + value;
    *buffer = '\0';
    return result;
}

/* We need to return "10" when we convert 10, which
   is kind of tricky, but we can create "01" easily enough */


STRCMP_EQUALS("01", itoa10(10, buffer));

char *itoa10(int value, char *buffer)
{
    char *result = buffer;
    do {
        *buffer++ = '0' + value % 10;
        value /= 10;
    } while (value > 0);
    *buffer = '\0';
    return result;
}

/* So, now let's reverse it so that we get "10" when we convert 10 */

STRCMP_EQUALS("10", itoa10(10, buffer));

char *itoa10(int value, char *buffer)
{
    char *result = buffer;
    do {
        *buffer++ = '0' + value % 10;
        value /= 10;
    } while (value > 0);
    *buffer = '\0';
    return strrev(result);
}

/* We haven't dealt with negative numbers yet, so let's do it */

STRCMP_EQUALS("-1", itoa10(-1, buffer));

static int abs(int value)
{
    return value < 0 ? -value : value;
}

char *itoa10(int value, char *buffer)
{
    char *result = buffer;
    int current = value;
    do {
        *buffer++ = '0' + abs(current % 10);
        current /= 10;
    } while (current != 0);
    if (value < 0)
        *buffer++ = '-';
    *buffer = '\0';
    return strrev(result);
}

/* That is one dense piece of code.  What can we do to clean it up? */

/* We can extract a little chunk.. naming it int_to_revstring */

static int abs(int value)
{
    return value < 0 ? -value : value;
}

static void int_to_revstring(int value, char *buffer)
{
    int current = value;
    do {
        *buffer++ = '0' + abs(current % 10);
        current /= 10;
    } while (current != 0);
    if (value < 0)
        *buffer++ = '-';
    *buffer = '\0';
}

char *itoa10(int value, char *buffer)
{
    int_to_revstring(value, buffer);
    return strrev(buffer);
}

/* But int_to_revstring is still a little dense.  It would
   be clearer if it only dealt with non-negatives */

/* When we separate the logic for negative numbers and non-negative numbers
   we don't need abs any more, and the code reads well. */

static void nonneg_int_to_revstring(int value, char *buffer)
{
    do {
        *buffer++ = '0' + value % 10;
        value /= 10;
    } while (value > 0);
    *buffer = '\0';
}

static void int_to_revstring(int value, char *buffer)
{
    if (value >= 0)
        nonneg_int_to_revstring(value, buffer);
    else {
        nonneg_int_to_revstring(-value, buffer);
        strcat(buffer, "-");
    }
}

char *itoa10(int value, char *buffer)
{
    int_to_revstring(value, buffer);
    return strrev(buffer);
}

/* This is pretty clear, but I'm not happy with it.
   Yes, the functions are small, but 'reverse strings' are just
   an alien concept. */

/* Rolling back to the denser code and dropping the magic number */

static int abs(int value)
{
    return value < 0 ? -value : value;
}

char *itoa10(int value, char *buffer)
{
    char *result = buffer;
    int current = value;
    const int radix = 10;

    do {
        *buffer++ = '0' + abs(current % radix);
        current /= radix;
    } while (current != 0);
    if (value < 0)
        *buffer++ = '-';
    *buffer = '\0';
    return strrev(result);
}

/* Isn't it interesting that this denser code contains the concept
   of a reversed string representation of an int, but that concept
   doesn't seem to sit well on its own?

   What do you think? */