firmware/src/printf.c

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdio.h>
#include <printf.h>
#include <cpu/inc/cpuMath.h>


static uint32_t StrPrvPrintfEx_number(printf_write_c putc_, void* userData, uint64_t number, bool base10, bool zeroExtend, bool isSigned, uint32_t padToLength, bool caps, bool* bail)
{
    char buf[64];
    uint32_t idx = sizeof(buf) - 1;
    uint32_t chr, i;
    bool neg = false;
    uint32_t numPrinted = 0;

    *bail = false;

    if (padToLength > sizeof(buf) - 1)
        padToLength = sizeof(buf) - 1;

    buf[idx--] = 0;    //terminate

    if (isSigned) {

        if (((int64_t)number) < 0) {

            neg = true;
            number = -number;
        }
    }

    do{
        if (base10) {
            uint64_t t = U64_DIV_BY_CONST_U16(number, 10);
            chr = (number - t * 10) + '0';
            number = t;
        }
        else {
            chr = number & 0x0F;
            number >>= 4;
            chr = (chr >= 10) ? (chr + (caps ? 'A' : 'a') - 10) : (chr + '0');
        }

        buf[idx--] = chr;

        numPrinted++;

    } while (number);

    if (neg) {

        buf[idx--] = '-';
        numPrinted++;
    }

    if (padToLength > numPrinted) {

        padToLength -= numPrinted;
    }
    else {

        padToLength = 0;
    }

    while (padToLength--) {

        buf[idx--] = zeroExtend ? '0' : ' ';
        numPrinted++;
    }

    idx++;


    for(i = 0; i < numPrinted; i++) {

        if (!putc_(userData,(buf + idx)[i])) {

            *bail = true;
            break;
        }
    }


    return i;
}

static uint32_t StrVPrintf_StrLen_withMax(const char* s, uint32_t max)
{
    uint32_t len = 0;

    while ((*s++) && (len < max)) len++;

    return len;
}

static uint32_t StrVPrintf_StrLen(const char* s)
{
    uint32_t len = 0;

    while (*s++) len++;

    return len;
}

static inline char prvGetChar(const char** fmtP)
{

    return *(*fmtP)++;
}

uint32_t cvprintf(printf_write_c putc_f, void* userData, const char* fmtStr, va_list vl)
{

    char c, t;
    uint32_t numPrinted = 0;
    uint64_t val64;

#define putc_(_ud,_c)                \
        do {                 \
            if (!putc_f(_ud,_c))    \
                goto out;    \
        } while(0)

    while ((c = prvGetChar(&fmtStr)) != 0) {

        if (c == '\n') {

            putc_(userData,c);
            numPrinted++;
        }
        else if (c == '%') {

            bool zeroExtend = false, useLong = false, useLongLong = false, useSizeT = false, bail = false, caps = false;
            uint32_t padToLength = 0, len, i;
            const char* str;

more_fmt:

            c = prvGetChar(&fmtStr);

            switch(c) {

                case '%':

                    putc_(userData,c);
                    numPrinted++;
                    break;

                case 'c':

                    t = va_arg(vl,unsigned int);
                    putc_(userData,t);
                    numPrinted++;
                    break;

                case 's':

                    str = va_arg(vl,char*);
                    if (!str) str = "(null)";
                    if (padToLength)
                        len = StrVPrintf_StrLen_withMax(str,padToLength);
                    else
                        padToLength = len = StrVPrintf_StrLen(str);

                    if (len > padToLength)
                        len = padToLength;
                    else {
                        for(i = len; i < padToLength; i++)
                            putc_(userData, ' ');
                    }
                    numPrinted += padToLength;
                    for(i = 0; i < len; i++)
                        putc_(userData,*str++);

                    numPrinted += len;
                    break;

                case '0':
                case '.':

                    if (!zeroExtend && !padToLength) {

                        zeroExtend = true;
                        goto more_fmt;
                    }

                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':

                    padToLength = (padToLength * 10) + c - '0';
                    goto more_fmt;

#define GET_UVAL64() \
        useSizeT ? va_arg(vl, size_t) :                 \
        useLongLong ? va_arg(vl, unsigned long long) :  \
        useLong ? va_arg(vl, unsigned long) :           \
        va_arg(vl, unsigned int)

#define GET_SVAL64() \
        useSizeT ? va_arg(vl, size_t) :                 \
        useLongLong ? va_arg(vl, signed long long) :    \
        useLong ? va_arg(vl, signed long) :             \
        va_arg(vl, signed int)

                case 'u':

                    val64 = GET_UVAL64();
                    numPrinted += StrPrvPrintfEx_number(putc_f, userData, val64, true, zeroExtend,0,padToLength,0,&bail);
                    if (bail)
                        goto out;
                    break;

                case 'd':
                case 'i':

                    val64 = GET_SVAL64();
                    numPrinted += StrPrvPrintfEx_number(putc_f, userData, val64, true, zeroExtend, true, padToLength, false, &bail);
                    if (bail)
                        goto out;
                    break;

                case 'X':
                    caps = true;

                case 'x':

                    val64 = GET_UVAL64();
                    numPrinted += StrPrvPrintfEx_number(putc_f, userData, val64, false, zeroExtend, false, padToLength, caps, &bail);
                    if (bail)
                        goto out;
                    break;

                case 'p':
                    putc_(userData,'0');
                    putc_(userData,'x');
                    numPrinted += 2;
                    val64 = (uintptr_t)va_arg(vl, const void*);
                    numPrinted += StrPrvPrintfEx_number(putc_f, userData, val64, false, zeroExtend, false, padToLength, caps, &bail);
                    if (bail)
                        goto out;
                    break;

#undef GET_UVAL64
#undef GET_SVAL64

                case 'h':
                    // Technically, we're supposed to cast down to short/char, so that
                    // { int x = 256; printf("%hhd", x); } would yield "0" (assuming 32-bit int
                    // and 8-bit char). But the more common usage would be to expect the caller
                    // to do printf("%hhd", (char) x) to get this output, which we're assuming
                    // here to make our implementation simpler.
                    goto more_fmt;

                case 'L':
                case 'l':
                    if (useLong)
                        useLongLong = true;
                    useLong = true;
                    goto more_fmt;

                case 'z':
                    useSizeT = true;
                    goto more_fmt;

                default:

                    putc_(userData,c);
                    numPrinted++;
                    break;

            }
        }
        else {

            putc_(userData,c);
            numPrinted++;
        }
    }

out:

    return numPrinted;
}