⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 wince_stdlib_main.c

📁 WinDriver Cypress USB 偵錯程式 for Wince 5.0
💻 C
📖 第 1 页 / 共 2 页
字号:
    cutlim = ULONG_MAX % (unsigned long int) base;

    overflow = 0;
    i = 0;
    for (c = *s; c != '\0'; c = *++s)
    {
        if (isdigit(c))
            c -= '0';
        else if (isalpha(c))
            c = toupper(c) - 'A' + 10;
        else
            break;
        if (c >= base)
            break;
        if (i > cutoff || (i == cutoff && c > cutlim))
            overflow = 1;
        else
        {
            i *= (unsigned long int) base;
            i += c;
        }
    }

    if (s == save)
        goto noconv;

    if (endptr != NULL)
        *endptr = (char *) s;

    return (negative ? - ((long)i) : i);

noconv:
    if (endptr != NULL)
        *endptr = (char *) nptr;
    return 0L;
}

#define    BUF    40

#define    LONG        0x01    /* l: long or double */
#define    LONGDBL        0x02    /* L: long double; unimplemented */
#define    SHORT        0x04    /* h: short */
#define    SUPPRESS    0x08    /* suppress assignment */
#define    POINTER        0x10    /* weird %p pointer (`fake hex') */
#define    NOSKIP        0x20    /* do not skip blanks */
#define    WIDTH        0x40    /* width */

#define    SIGNOK        0x40    /* +/- is (still) legal */
#define    NDIGITS        0x80    /* no digits detected */

#define    DPTOK        0x100    /* (float) decimal point is still legal */
#define    EXPOK        0x200    /* (float) exponent (e+3, etc) still legal */

#define    PFXOK        0x100    /* 0x prefix is (still) legal */
#define    NZDIGITS    0x200    /* no zero digits detected */

#define    CT_CHAR        0    /* %c conversion */
#define    CT_CCL        1    /* %[...] conversion */
#define    CT_STRING    2    /* %s conversion */
#define    CT_INT        3    /* integer, i.e., strtol or strtoul */
#define    CT_FLOAT    4    /* floating, i.e., strtod */

#define u_char unsigned char
#define u_long unsigned long

static const u_char * __cdecl sccl(char *tab, const u_char *fmt);

int __cdecl vsscanf(char *buffer, const char *fmt, va_list ap)
{
    int c;
    size_t width;
    char *p;
    int n;
    int flags = 0;
    char *p0;
    int nassigned;
    int nread;
    int base = 0;
    char ccltab[256];
    char buf[BUF];
    BOOL seen_eof = FALSE;
    int i = 0;

    static short basefix[17] =
        { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };

    nassigned = 0;
    nread = 0;
    for (;;) 
    {
        c = *fmt++;
        if (c == 0)
            goto done;
        if (isspace(c)) 
        {
            for (;;) 
            {
                    c = buffer[i++];
                if (!c) 
                {
                  seen_eof = TRUE;
                  break;
                }
                if (!isspace(c)) 
                {
                    i--;
                    break;
                }
                nread++;
            }
            continue;
        }
        if (c != '%')
            goto literal;
        width = 0;
        flags = 0;

again:        c = *fmt++;
        switch (c)
        {
        case '%':
literal:
                n = buffer[i++];
            if (!n)
                goto eof_failure;
            if (n != c)
            {
                i--;
                goto match_failure;
            }
            nread++;
            continue;

        case '*':
            if (flags) goto control_failure;
            flags = SUPPRESS;
            goto again;
        case 'l':
            if (flags & ~(SUPPRESS | WIDTH)) goto control_failure;
            flags |= LONG;
            goto again;
        case 'L':
            if (flags & ~(SUPPRESS | WIDTH)) goto control_failure;
            flags |= LONGDBL;
            goto again;
        case 'h':
            if (flags & ~(SUPPRESS | WIDTH)) goto control_failure;
            flags |= SHORT;
            goto again;

        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
            if (flags & ~(SUPPRESS | WIDTH)) goto control_failure;
            flags |= WIDTH;
            width = width * 10 + c - '0';
            goto again;

        case 'D':
            flags |= LONG;
            // FALLTHROUGH
        case 'd':
            c = CT_INT;
            base = 10;
            break;

        case 'i':
            c = CT_INT;
            base = 0;
            break;

        case 'O':
            flags |= LONG;
            // FALLTHROUGH
        case 'o':
            c = CT_INT;
            base = 8;
            break;

        case 'u':
            c = CT_INT;
            base = 10;
            break;

        case 'X':
        case 'x':
            flags |= PFXOK;
            c = CT_INT;
            base = 16;
            break;

        case 's':
            c = CT_STRING;
            break;

        case '[':
            fmt = (char *) sccl(ccltab, (const u_char *) fmt);
            flags |= NOSKIP;
            c = CT_CCL;
            break;

        case 'c':
            flags |= NOSKIP;
            c = CT_CHAR;
            break;

        case 'p':
            flags |= POINTER | PFXOK;
            c = CT_INT;
            base = 16;
            break;

        case 'n':
            if (flags & SUPPRESS)
                continue;
            if (flags & SHORT)
                *va_arg(ap, short *) = nread;
            else if (flags & LONG)
                *va_arg(ap, long *) = nread;
            else
                *va_arg(ap, int *) = nread;
            continue;

        case '\0':
                nassigned = -1;
            goto done;

        default:
            if (isupper(c))
                flags |= LONG;
            c = CT_INT;
            base = 10;
            break;
        }

        if (!buffer[i])
            goto eof_failure;

        if ((flags & NOSKIP) == 0)
        {
            n = (unsigned char)buffer[i];
            while (isspace(n))
            {
            i++;
            nread++;
            n = buffer[i];
            if (!n)
                goto eof_failure;
            }
        }

        switch (c)
        {
        case CT_CHAR:
            if (width == 0)
                width = 1;
            if (flags & SUPPRESS)
            {
                size_t sum = 0;
                for (;;)
                {
                    n = strlen(buffer+i);
                if (n < (int)width)
                {
                    sum += n;
                    width -= n;
                    i += n;
                    if (!buffer[i])
                    if (sum == 0)
                        goto eof_failure;
                    else
                    {
                        seen_eof = TRUE;
                        break;
                    }
                }
                else
                {
                    sum += width;
                    i += width;
                    break;
                }
                }
                nread += sum;
            }
            else
            {
                if (strlen(buffer+i) != width)
                goto eof_failure;
                memcpy ((char*)va_arg(ap, char*), buffer+i, width);
                i += width;
                nread += width;
                nassigned++;
            }
            break;

        case CT_CCL:
            if (width == 0)
                width = ~0;
            if (flags & SUPPRESS)
            {
                n = 0;
                while (ccltab[(unsigned char)buffer[i]])
                {
                    n++, i++;
                    if (--width == 0)
                    break;
                    if (!buffer[i])
                    {
                    if (n == 0)
                        goto eof_failure;
                    seen_eof = TRUE;
                    break;
                    }
                }
                if (n == 0)
                    goto match_failure;
            }
            else
            {
                p0 = p = va_arg(ap, char *);
                while (ccltab[(unsigned char)buffer[i]])
                {
                *p++ = buffer[i++];
                if (--width == 0)
                    break;
                if (!buffer[i])
                {
                    if (p == p0)
                    goto eof_failure;
                    seen_eof = TRUE;
                    break;
                }
                }
                n = p - p0;
                if (n == 0)
                goto match_failure;
                *p = 0;
                nassigned++;
            }
            nread += n;
            break;

        case CT_STRING:
            if (width == 0)
                width = ~0;
            if (flags & SUPPRESS)
            {
                n = 0;
                while (!isspace((unsigned char)buffer[i]))
                {
                    n++, i++;
                    if (--width == 0)
                        break;
                    if (!buffer[i])
                    {
                        seen_eof = TRUE;
                        break;
                    }
                }
                nread += n;
            }
            else
            {
                p0 = p = va_arg(ap, char *);
                while (!isspace((unsigned char)buffer[i]))
                {
                    *p++ = buffer[i++];
                    if (--width == 0)
                        break;
                    if (!buffer[i])
                    {
                        seen_eof = TRUE;
                        break;
                    }
                }
                *p = 0;
                nread += p - p0;
                nassigned++;
            }
            continue;

        case CT_INT:
            if (width == 0 || width > sizeof(buf) - 1)
                width = sizeof(buf) - 1;
            flags |= SIGNOK | NDIGITS | NZDIGITS;
            for (p = buf; width; width--)
            {
                c = (unsigned char)buffer[i];
                switch (c)
                {
                case '0':
                    if (base == 0)
                    {
                        base = 8;
                        flags |= PFXOK;
                    }
                    if (flags & NZDIGITS)
                        flags &= ~(SIGNOK|NZDIGITS|NDIGITS);
                    else
                        flags &= ~(SIGNOK|PFXOK|NDIGITS);
                    goto ok;

                case '1': case '2': case '3':
                case '4': case '5': case '6': case '7':
                    base = basefix[base];
                    flags &= ~(SIGNOK | PFXOK | NDIGITS);
                    goto ok;

                case '8': case '9':
                    base = basefix[base];
                    if (base <= 8)
                        break;
                    flags &= ~(SIGNOK | PFXOK | NDIGITS);
                    goto ok;

                case 'A': case 'B': case 'C':
                case 'D': case 'E': case 'F':
                case 'a': case 'b': case 'c':
                case 'd': case 'e': case 'f':
                    if (base <= 10)
                        break;
                    flags &= ~(SIGNOK | PFXOK | NDIGITS);
                    goto ok;

                case '+': case '-':
                    if (flags & SIGNOK)
                    {
                        flags &= ~SIGNOK;
                        goto ok;
                    }
                    break;

                case 'x': case 'X':
                    if (flags & PFXOK && p == buf + 1)
                    {
                        base = 16;
                        flags &= ~PFXOK;
                        goto ok;
                    }
                    break;
                }

                break;
        ok:
                *p++ = c;
                i++;
                if (!buffer[i]) {
                    seen_eof = TRUE;
                    break;
                }
                }
            if (flags & NDIGITS)
            {
                if (p > buf)
                {
                    buffer[--i] = *(u_char *)--p;
                }
                goto match_failure;
            }
            c = ((u_char *)p)[-1];
            if (c == 'x' || c == 'X')
            {
                --p;
                buffer[--i] = c;
            }
            if ((flags & SUPPRESS) == 0)
            {
                u_long res;

                *p = 0;
                res = strtol(buf, (char **)NULL, base);
                if (flags & POINTER)
                    *va_arg(ap, void **) = (void *)res;
                else if (flags & SHORT)
                    *va_arg(ap, short *) = (short) res;
                else if (flags & LONG)
                    *va_arg(ap, long *) = res;
                else
                    *va_arg(ap, int *) = res;
                nassigned++;
            }
            nread += p - buf;
            break;

        }
    }
eof_failure:
    seen_eof = TRUE;
    if (nassigned == 0)
        nassigned = -1;
control_failure:
match_failure:
done:
    return (nassigned);
}

static const u_char * __cdecl sccl(char *tab, const u_char *fmt)
{
    int c, n, v;

    c = *fmt++;
    if (c == '^') 
    {
        v = 1;
        c = *fmt++;
    } else
        v = 0;
    for (n = 0; n < 256; n++)
        tab[n] = v;
    if (c == 0)
        return (fmt - 1);

    v = 1 - v;
    for (;;) {
        tab[c] = v;
doswitch:
        n = *fmt++;
        switch (n)
        {
        case 0:
            return (fmt - 1);

        case '-':
            n = *fmt;
            if (n == ']' || n < c) 
            {
                c = '-';
                break;
            }
            fmt++;
            do {
                tab[++c] = v;
            } while (c < n);
            goto doswitch;
            break;

        case ']':
            return (fmt);

        default:
            c = n;
            break;
        }
    }
}

int __cdecl sscanf(const char *buf, const char *fmt, ...)
{
    va_list args;
    int i;

    va_start(args, fmt);
    i=vsscanf((char *) buf,fmt,args);
    va_end(args);
    return i;
}

#endif // defined(_WIN32_WCE) && (_WIN32_WCE==200)

#ifdef __cplusplus
}
#endif  // __cplusplus 

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -