landzo

【开源】线性CCD自适应性算法攻略

        {
            /* precision_used = TRUE; */

            /*
             * Must get precision field width, if present.
             */
            /* precision_width = 0; */
            done = FALSE;
            while (!done)
            {
                switch (/* c = uncomment if used below */ *++p)
                {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
#if 0
                    precision_width = (precision_width * 10) +
                                      (c - '0');
#endif
                    break;
                default:
                    /* we've gone one char too far */
                    --p;
                    done = TRUE;
                    break;
                }
            }
        }
        else
        {
            /* we've gone one char too far */
            --p;
#if 0
            precision_used = FALSE;
            precision_width = 0;
#endif
        }

        /*
         * Check for the length modifier.
         */
        /* length_modifier = 0; */
        switch (/* c = */ *++p)
        {
        case 'h':
            /* length_modifier |= LENMOD_h; */
            break;
        case 'l':
            /* length_modifier |= LENMOD_l; */
            break;
        case 'L':
            /* length_modifier |= LENMOD_L; */
            break;
        default:
            /* we've gone one char too far */
            --p;
            break;
        }

        /*
         * Now we're ready to examine the format.
         */
        switch (c = *++p)
        {
        case 'd':
        case 'i':
            ival = (int)va_arg(ap, int);
            vlen = printk_mknumstr(vstr, &ival, TRUE, 10);
            vstrp = &vstr[vlen];

            if (ival < 0)
            {
                schar = '-';
                ++vlen;
            }
            else
            {
                if (IS_FLAG_PLUS(flags_used))
                {
                    schar = '+';
                    ++vlen;
                }
                else
                {
                    if (IS_FLAG_SPACE(flags_used))
                    {
                        schar = ' ';
                        ++vlen;
                    }
                    else
                    {
                        schar = 0;
                    }
                }
            }
            dschar = FALSE;

            /*
             * do the ZERO pad.
             */
            if (IS_FLAG_ZERO(flags_used))
            {
                if (schar)
                    printk_putc(schar, &count, info);
                dschar = TRUE;

                printk_pad_zero (vlen, field_width, &count, info);
                vlen = field_width;
            }
            else
            {
                if (!IS_FLAG_MINUS(flags_used))
                {
                    printk_pad_space (vlen, field_width, &count, info);

                    if (schar)
                        printk_putc(schar, &count, info);
                    dschar = TRUE;
                }
            }

            /* the string was built in reverse order, now display in */
            /* correct order */
            if (!dschar && schar)
            {
                printk_putc(schar, &count, info);
            }
            goto cont_xd;

        case 'x':
        case 'X':
            uval = (unsigned int)va_arg(ap, unsigned int);
            vlen = printk_mknumstr(vstr, &uval, FALSE, 16);
            vstrp = &vstr[vlen];

            dschar = FALSE;
            if (IS_FLAG_ZERO(flags_used))
            {
                if (IS_FLAG_POUND(flags_used))
                {
                    printk_putc('0', &count, info);
                    printk_putc('x', &count, info);
                    /*vlen += 2;*/
                    dschar = TRUE;
                }
                printk_pad_zero (vlen, field_width, &count, info);
                vlen = field_width;
            }
            else
            {
                if (!IS_FLAG_MINUS(flags_used))
                {
                    if (IS_FLAG_POUND(flags_used))
                    {
                        vlen += 2;
                    }
                    printk_pad_space (vlen, field_width, &count, info);
                    if (IS_FLAG_POUND(flags_used))
                    {
                        printk_putc('0', &count, info);
                        printk_putc('x', &count, info);
                        dschar = TRUE;
                    }
                }
            }

            if ((IS_FLAG_POUND(flags_used)) && !dschar)
            {
                printk_putc('0', &count, info);
                printk_putc('x', &count, info);
                vlen += 2;
            }
            goto cont_xd;

        case 'o':
            uval = (unsigned int)va_arg(ap, unsigned int);
            vlen = printk_mknumstr(vstr, &uval, FALSE, 8);
            goto cont_u;
        case 'b':
            uval = (unsigned int)va_arg(ap, unsigned int);
            vlen = printk_mknumstr(vstr, &uval, FALSE, 2);
            goto cont_u;
        case 'p':
            uval = (unsigned int)va_arg(ap, void *);
            vlen = printk_mknumstr(vstr, &uval, FALSE, 16);
            goto cont_u;
        case 'u':
            uval = (unsigned int)va_arg(ap, unsigned int);
            vlen = printk_mknumstr(vstr, &uval, FALSE, 10);

cont_u:
            vstrp = &vstr[vlen];

            if (IS_FLAG_ZERO(flags_used))
            {
                printk_pad_zero (vlen, field_width, &count, info);
                vlen = field_width;
            }
            else
            {
                if (!IS_FLAG_MINUS(flags_used))
                {
                    printk_pad_space (vlen, field_width, &count, info);
                }
            }

cont_xd:
            while (*vstrp)
                printk_putc(*vstrp--, &count, info);

            if (IS_FLAG_MINUS(flags_used))
            {
                printk_pad_space (vlen, field_width, &count, info);
            }
            break;

        case 'c':
            cval = (char)va_arg(ap, unsigned int);
            printk_putc(cval, &count, info);
            break;
        case 's':
            sval = (char *)va_arg(ap, char *);
            if (sval)
            {
                vlen = strlen(sval);
                if (!IS_FLAG_MINUS(flags_used))
                {
                    printk_pad_space (vlen, field_width, &count, info);
                }
                while (*sval)
                    printk_putc(*sval++, &count, info);
                if (IS_FLAG_MINUS(flags_used))
                {
                    printk_pad_space (vlen, field_width, &count, info);
                }
            }
            break;
        case 'n':
            ivalp = (int *)va_arg(ap, int *);
            *ivalp = count;
            break;
        default:
            printk_putc(c, &count, info);
            break;
        }
    }
    return count;
}

/********************************************************************/
#ifdef  NPRINTF     //禁用printf
int
printf (const char *fmt, ...)
{
    return 1;     //报告发送成功
}
#else
int
printf (const char *fmt, ...)
{
    va_list ap;
    int rvalue;
    PRINTK_INFO info;


    info.dest = DEST_CONSOLE;
    info.func = &out_char;
    /*
     * Initialize the pointer to the variable length argument list.
     */
    va_start(ap, fmt);
    rvalue = printk(&info, fmt, ap);
    /*
     * Cleanup the variable length argument list.
     */
    va_end(ap);
    return rvalue;
}
#endif

/********************************************************************/
int
sprintf (char *s, const char *fmt, ...)
{
    va_list ap;
    int rvalue = 0;
    PRINTK_INFO info;

    /*
     * Initialize the pointer to the variable length argument list.
     */
    if (s != 0)
    {
        info.dest = DEST_STRING;
        info.loc = s;
        va_start(ap, fmt);
        rvalue = printk(&info, fmt, ap);
        *info.loc = '\0';
        va_end(ap);
    }
    return rvalue;
}

/********************************************************************/