用c语言中的putchar()实现printf()

#include <stdio.h>
#include <stdlib.h>
#include<stdarg.h>
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
// 用putchar()实现printf()

static void
putch(int ch, int *cnt)
{
    putchar(ch);
    *cnt++;
}

int
vcprintf(const char *fmt, va_list ap)
{
    int cnt = 0;

    my_vprintfmt((void*)putch, &cnt, fmt, ap);
    return cnt;
}

int
cprintf(const char *fmt, ...)
{
    va_list ap;
    int cnt;

    va_start(ap, fmt);
    cnt = vcprintf(fmt, ap);
    va_end(ap);

    return cnt;
}
 
int
strnlen(const char *s, size_t size)
{
    int n;

    for (n = 0; size > 0 && *s != '\0'; s++, size--)
        n++;
    return n;
}
enum {
    // Kernel error codes -- keep in sync with list in lib/printfmt.c.
    E_UNSPECIFIED    = 1,    // Unspecified or unknown problem
    E_BAD_ENV    = 2,    // Environment doesn't exist or otherwise
                // cannot be used in requested action
    E_INVAL        = 3,    // Invalid parameter
    E_NO_MEM    = 4,    // Request failed due to memory shortage
    E_NO_FREE_ENV    = 5,    // Attempt to create a new environment beyond
                // the maximum allowed
    E_FAULT        = 6,    // Memory fault

    MAXERROR
};

/*
 * Space or zero padding and a field width are supported for the numeric
 * formats only.
 *
 * The special format %e takes an integer error code
 * and prints a string describing the error.
 * The integer may be positive or negative,
 * so that -E_NO_MEM and E_NO_MEM are equivalent.
 */

static const char * const error_string[MAXERROR] =
{
    [E_UNSPECIFIED]    = "unspecified error",
    [E_BAD_ENV]    = "bad environment",
    [E_INVAL]    = "invalid parameter",
    [E_NO_MEM]    = "out of memory",
    [E_NO_FREE_ENV]    = "out of environments",
    [E_FAULT]    = "segmentation fault",
};

/*
 * Print a number (base <= 16) in reverse order,
 * using specified putch function and associated pointer putdat.
 */
static void
printnum(void (*putch)(int, void*), void *putdat,
     unsigned long long num, unsigned base, int width, int padc)
{
    // first recursively print all preceding (more significant) digits
    if (num >= base) {
        printnum(putch, putdat, num / base, base, width - 1, padc);
    } else {
        // print any needed pad characters before first digit
        while (--width > 0)
            putch(padc, putdat);
    }

    // then print this (the least significant) digit
    putch("0123456789abcdef"[num % base], putdat);
}

// Get an unsigned int of various possible sizes from a varargs list,
// depending on the lflag parameter.
static unsigned long long
getuint(va_list *ap, int lflag)
{
    if (lflag >= 2)
        return va_arg(*ap, unsigned long long);
    else if (lflag)
        return va_arg(*ap, unsigned long);
    else
        return va_arg(*ap, unsigned int);
}

// Same as getuint but signed - can't use getuint
// because of sign extension
static long long
getint(va_list *ap, int lflag)
{
    if (lflag >= 2)
        return va_arg(*ap, long long);
    else if (lflag)
        return va_arg(*ap, long);
    else
        return va_arg(*ap, int);
}

void
printfmt(void (*putch)(int, void*), void *putdat, const char *fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    my_vprintfmt(putch, putdat, fmt, ap);
    va_end(ap);
}

void
my_vprintfmt(void (*putch)(int, void*), void *putdat, const char *fmt, va_list ap)
{
    register const char *p;
    register int ch, err;
    unsigned long long num;
    int base, lflag, width, precision, altflag;
    char padc;

    while (1) {
        while ((ch = *(unsigned char *) fmt++) != '%') {
            if (ch == '\0')
                return;
            putch(ch, putdat);
        }

        // Process a %-escape sequence
        padc = ' ';
        width = -1;
        precision = -1;
        lflag = 0;
        altflag = 0;
    reswitch:
        switch (ch = *(unsigned char *) fmt++) {

        // flag to pad on the right
        case '-':
            padc = '-';
            goto reswitch;

        // flag to pad with 0's instead of spaces
        case '0':
            padc = '0';
            goto reswitch;

        // width field
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            for (precision = 0; ; ++fmt) {
                precision = precision * 10 + ch - '0';
                ch = *fmt;
                if (ch < '0' || ch > '9')
                    break;
            }
            goto process_precision;

        case '*':
            precision = va_arg(ap, int);
            goto process_precision;

        case '.':
            if (width < 0)
                width = 0;
            goto reswitch;

        case '#':
            altflag = 1;
            goto reswitch;

        process_precision:
            if (width < 0)
                width = precision, precision = -1;
            goto reswitch;

        // long flag (doubled for long long)
        case 'l':
            lflag++;
            goto reswitch;

        // character
        case 'c':
            putch(va_arg(ap, int), putdat);
            break;

        // error message
        case 'e':
            err = va_arg(ap, int);
            if (err < 0)
                err = -err;
            if (err >= MAXERROR || (p = error_string[err]) == NULL)
                printfmt(putch, putdat, "error %d", err);
            else
                printfmt(putch, putdat, "%s", p);
            break;

        // string
        case 's':
            if ((p = va_arg(ap, char *)) == NULL)
                p = "(null)";
            if (width > 0 && padc != '-')
                for (width -= strnlen(p, precision); width > 0; width--)
                    putch(padc, putdat);
            for (; (ch = *p++) != '\0' && (precision < 0 || --precision >= 0); width--)
                if (altflag && (ch < ' ' || ch > '~'))
                    putch('?', putdat);
                else
                    putch(ch, putdat);
            for (; width > 0; width--)
                putch(' ', putdat);
            break;

        // (signed) decimal
        case 'd':
            num = getint(&ap, lflag);
            if ((long long) num < 0) {
                putch('-', putdat);
                num = -(long long) num;
            }
            base = 10;
            goto number;

        // unsigned decimal
        case 'u':
            num = getuint(&ap, lflag);
            base = 10;
            goto number;

        // (unsigned) octal
        case 'o':
            // Replace this with your code.
            putch('X', putdat);
            putch('X', putdat);
            putch('X', putdat);
            break;

        // pointer
        case 'p':
            putch('0', putdat);
            putch('x', putdat);
            num = (unsigned long long)
                (uintptr_t) va_arg(ap, void *);
            base = 16;
            goto number;

        // (unsigned) hexadecimal
        case 'x':
            num = getuint(&ap, lflag);
            base = 16;
        number:
            printnum(putch, putdat, num, base, width, padc);
            break;

        // escaped '%' character
        case '%':
            putch(ch, putdat);
            break;

        // unrecognized escape sequence - just print it literally
        default:
            putch('%', putdat);
            for (fmt--; fmt[-1] != '%'; fmt--)
                /* do nothing */;
            break;
        }
    }
}



int main(int argc, char *argv[]) {
    char s[]= "hello,world";   

    cprintf("6828 decimal is %o octal!\n", 6828);

    cprintf("%s\n",s);

    cprintf("%10s\n",s);

    cprintf("%.10s\n",s);

    cprintf("%-10s\n",s); 
    cprintf("%-015s\n",s);
    cprintf("%0-15s\n",s);
    cprintf("%015s\n",s);

    cprintf("%15s\n",s);

    cprintf("%.15s\n",s);

    cprintf("%-15s\n",s);

    cprintf("%15.10s\n",s);

    cprintf("%-15.10s\n",s);
    cprintf("%e\n",1);
    cprintf("%e\n",2);
    cprintf("%e\n",10);
    cprintf("%s\n",0);

    cprintf("x=%d y=%d\n", 3);
    scanf("%*d");
    return 0;
}