printk.c

一个实时操作系统的源代码。包括任务的调度机制、文件系统等

        else if (base == 8)
            width--;
    }
    i = 0;
    if (num == 0)
        tmp[i++]='0';
    else while (num != 0)
        tmp[i++] = digits[do_div(&num,base)];
    if (i > precision)
        precision = i;
    width -= precision;
    if (!(type&(ZEROPAD+LEFT))) {
        while(width-->0) {
            if (bi < size)
                buff[bi++] = ' ';
        }
    }
    if (sign) {
        if (bi < size)
            buff[bi++] = sign;
    }
    if (type & SPECIAL) {
        if (base==8) {

            if (bi < size)
                buff[bi++] = '0';

        } else if (base==16) {

            if (bi < size)
                buff[bi++] = '0';
                
            if (bi < size)
                buff[bi++] = 'x';/*digits[33];*/
        }
    }
    if (!(type & LEFT)) {
        while (width-- > 0) {
            if (bi < size)
                buff[bi++] = c;
        }
    }
    while (i < precision--) {

        if (bi < size)
            buff[bi++] = '0';
    }
    while (i-- > 0) {
        if (bi < size)
            buff[bi++] = tmp[i];
    }
    while (width-- > 0) {
        if (bi < size)
            buff[bi++] = ' ';
    }
    
    return bi;
}


int sprintf(char * buf, const char *fmt, ...);

int __vsprintf(char *buff, int size, const char *fmt, va_list args)
{
    int len;
    unsigned long num;
    int i, base;
    char c;
    const char *s;

    int flags;      /* flags to number() */

    int field_width;    /* width of output field */
    int precision;      /* min. # of digits for integers; max
                   number of chars for from string */
    int qualifier;      /* 'h', 'l', or 'L' for integer fields */
                /* 'z' support added 23/7/1999 S.H.    */
                /* 'z' changed to 'Z' --davidm 1/25/99 */

    int bi = 0;

    /* Reserve a byte for null. */
    size--;

    for (; *fmt; ++fmt) {
    
        if (*fmt != '%') {
            /**
             * Ordinary character */
            
            if (bi < size)
                buff[bi++] = *fmt;
            continue;
        }

        /* process flags */
        flags = 0;
        
    repeat:
        /* This also skips first '%'. */
        ++fmt;
        switch (*fmt) {
            case '-': flags |= LEFT;    goto repeat;
            case '+': flags |= PLUS;    goto repeat;
            case ' ': flags |= SPACE;   goto repeat;
            case '#': flags |= SPECIAL; goto repeat;
            case '0': flags |= ZEROPAD; goto repeat;
        }

        /* get field width */
        field_width = -1;
        if (isdigit(*fmt))
            field_width = skip_atoi(&fmt);

        /* get the precision */
        precision = -1;
        if (*fmt == '.') {
            ++fmt;  
            if (isdigit(*fmt))
                precision = skip_atoi(&fmt);
        }

        /* get the conversion qualifier */
        qualifier = -1;
        if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
            *fmt =='Z' || *fmt == 'z') {
            qualifier = *fmt;
            ++fmt;
            if (qualifier == 'l' && *fmt == 'l') {
                qualifier = 'L';
                ++fmt;
            }
        }

        /* default base */
        base = 10;

        switch (*fmt) {
        case 'c':
            if (!(flags & LEFT)) {
                while (--field_width > 0) {

                    if (bi < size)
                        buff[bi++] = ' ';
                }
            }
            c = (unsigned char)va_arg(args, int);

            if (bi < size)
                buff[bi++] = c;
                
            while (--field_width > 0) {

                if (bi < size)
                    buff[bi++] = ' ';
            }
            continue;

        case 's':
            s = va_arg(args, char *);
            if (!s)
                s = "<NULL>";

            len = __strnlen(s, precision);

            if (!(flags & LEFT)) {
                while (len < field_width--) {
                    if (bi < size)
                        buff[bi++] = ' ';
                }
            }
            for (i = 0; i < len; ++i) {

                if (bi < size)
                    buff[bi++] = *s++;
            }
            while (len < field_width--) {
                if (bi < size)
                    buff[bi++] = ' ';
            }
            continue;

        case 'P':
            flags |= LARGE;

        case 'p':
            if (field_width == -1) {
                field_width = 2*sizeof(void *);
                flags |= ZEROPAD;
            }
            bi += number(buff + bi, size - bi,
                    (unsigned long) va_arg(args, void *),
                    16, field_width, precision, flags);
            continue;


        case 'n':
            /* FIXME:
            * What does C99 say about the overflow case here? */
            if (qualifier == 'l') {
                long * ip = va_arg(args, long *);
                *ip = bi;
            } else if (qualifier == 'Z' || qualifier == 'z') {
                mmsz_t * ip = va_arg(args, mmsz_t *);
                *ip = bi;
            } else {
                int * ip = va_arg(args, int *);
                *ip = bi;
            }
            continue;

        case '%':
            if (bi < size)
                buff[bi++] = '%';
            continue;

            /* integer number formats - set up the flags and "break" */
        case 'o':
            base = 8;
            break;

        case 'X':
            flags |= LARGE;
        case 'x':
            base = 16;
            break;

        case 'd':
        case 'i':
            flags |= SIGN;
        case 'u':
            break;

        default:
            if (bi < size)
                buff[bi++] = '%';

            if (*fmt) {
                if (bi < size)
                    buff[bi++] = *fmt;
            } else {
                --fmt;
            }
            continue;
        }
        
        if (qualifier == 'L')
            num = va_arg(args, long);
        else if (qualifier == 'l') {
            num = va_arg(args, unsigned long);
            if (flags & SIGN)
                num = (signed long) num;
        } else if (qualifier == 'Z' || qualifier == 'z') {
            num = va_arg(args, mmsz_t);
        } else if (qualifier == 'h') {
            num = (unsigned short) va_arg(args, int);
            if (flags & SIGN)
                num = (signed short) num;
        } else {
            num = va_arg(args, unsigned int);
            if (flags & SIGN)
                num = (signed int) num;
        }
        bi += number(buff + bi, size - bi, num, base,
                field_width, precision, flags);
    }

    buff[bi] = '\0';

    /**
     * The trailing null byte doesn't count towards the total. */
    return bi;
}

int sprintf(char * buf, const char *fmt, ...)
{
    va_list args;
    int i;
    va_start(args, fmt);
    i = __vsprintf(buf, CFG_DUMP_BUFFSZ, fmt, args);
    va_end(args);
    return i;
}

void printk(const char *fmt, ...)
{
    va_list args;
    int i;
    va_start(args, fmt);
    i = __vsprintf(sbuf, CFG_DUMP_BUFFSZ, fmt, args);
    va_end(args);
    __ui_writec(sbuf, i);
}

#endif


/*===========================================================================*/