Ejemplo n.º 1
0
int isdigit 
    (
    int c       /* character to test */
    )
    {
    return __isdigit(c);
    }
Ejemplo n.º 2
0
Archivo: scanf.c Proyecto: phoboz/vmx
static int valid_digit(char c, char base)
{
        if (base == 16) {
                return __isxdigit(c);
        } else {
                return (__isdigit(c) && (c < '0' + base));
        }
}
Ejemplo n.º 3
0
Archivo: inetLib.c Proyecto: phoboz/vmx
unsigned long inet_addr(char *inetString)
{
    unsigned long val, base, n;
    char c;
    unsigned long parts[MAX_PARTS];
    unsigned long *pp;

    /* If null inet string */
    if (inetString == NULL) {

        errnoSet(S_inetLib_ILLEGAL_INTERNET_ADDRESS);
        return ERROR;

    } /* End if null inet string */

    /* Initialize locals */
    pp = parts;

again:

    val = 0;
    base = 10;

    /* If zero prefix */
    if (*inetString == '0') {

        base = 8;
        inetString++;

        /* If hexadecimal prefix */
        if ( (*inetString == 'x') || (*inetString == 'X') ) {

            base = 16;
            inetString++;

        } /* End if hexadecimal prefix */

    } /* End if zero prefix */

    /* While not string terminator */
    while ( (c = *inetString) ) {

        /* If digit */
        if ( __isdigit((int) c) ) {

            val = (val * base) + (c - '0');
            inetString++;
            continue;

        } /* End if digit */

        /* If hexadecimal digit */
        if ( __isxdigit((int) c) ) {

            val = (val << 4) + (c + 10 - (__islower((int) c) ? 'a' : 'A'));
            inetString++;
            continue;

        } /* End if hexadecimal digit */

        /* If here break loop */
        break;

    } /* End while not string terminator */

    /* If dot found */
    if (*inetString == '.') {

        /* If string to large or value to large */
        if ( (pp >= parts + (MAX_PARTS - 1)) || (val > 0xff) ) {

            errnoSet(S_inetLib_ILLEGAL_INTERNET_ADDRESS);
            return ERROR;

        } /* End if string to large or value to large */

        /* Store value */
        *pp++ = val;

        /* Advance */
        inetString++;

        /* Find next value */
        goto again;

    } /* End if dot found */

    /* If trailing character */
    if ( (*inetString) && !(__isspace((int) *inetString)) ) {

        errnoSet(S_inetLib_ILLEGAL_INTERNET_ADDRESS);
        return ERROR;

    } /* End if trailing character */

    /* Store value */
    *pp++ = val;

    n = pp - parts;

    /* Select parts number */
    switch (n) {

    /* 32 bit address */
    case 1:

        val = parts[0];

        break;

    /* 8.24 bits address */
    case 2:

        /* If value to large */
        if (val > 0xffffff) {

            errnoSet(S_inetLib_ILLEGAL_INTERNET_ADDRESS);
            return ERROR;

        } /* End if value to large */

        /* Store value */
        val = (parts[0] << 24) | parts[1];

        break;

    /* 8.8.16 bits address */
    case 3:

        /* If value to large */
        if (val > 0xffff) {

            errnoSet(S_inetLib_ILLEGAL_INTERNET_ADDRESS);
            return ERROR;

        } /* End if value to large */

        /* Store value */
        val = (parts[0] << 24) | (parts[1] << 16) | parts[2];

        break;

    /* 8.8.8.8 bits */
    case 4:

        /* If value to large */
        if (val > 0xff) {

            errnoSet(S_inetLib_ILLEGAL_INTERNET_ADDRESS);
            return ERROR;

        } /* End if value to large */

        /* Store value */
        val = (parts[0] << 24) | (parts[1] << 16) |
              (parts[2] << 8) | parts[3];

        break;

    default:

        errnoSet(S_inetLib_ILLEGAL_INTERNET_ADDRESS);
        return ERROR;

    } /* End select part number */

    return htonl(val);
}
Ejemplo n.º 4
0
Archivo: scanf.c Proyecto: phoboz/vmx
int vfscanf(FILE *fp, const char *format, va_list ap)
{
#ifdef INCLUDE_LONG_LONG
#define STRTO_L_(s,e,b,u) _strto_ll(s,e,b,u)
#define MAX_DIGITS 64
#define UV_TYPE unsigned long long
#define V_TYPE long long
#else
#define STRTO_L_(s,e,b,u) _strto_l(s,e,b,u)
#define MAX_DIGITS 32
#define UV_TYPE unsigned long
#define V_TYPE long
#endif
#ifdef INCLUDE_FLOAT
        long double ld;
#endif
        UV_TYPE uv;
        struct scan_cookie sc;
        unsigned const char *fmt;
        const char *p;
        unsigned char *b;
        void *vp;
        int cc, i, cnt;
        signed char lval;
        unsigned char store, usflag, base, invert, r0, r1;
        unsigned char buf[MAX_DIGITS+2];
        unsigned char scanset[UCHAR_MAX + 1];

        init_scan_cookie(&sc,fp);

        fmt = (unsigned const char *) format;
        cnt = 0;

        while (*fmt) {
                store = 1;
                lval = 0;
                sc.width = INT_MAX;
                if (*fmt == '%') {              /* Conversion specification. */
                        ++fmt;
                        if (*fmt == '*') {      /* Suppress assignment. */
                                store = 0;
                                ++fmt;
                        }
                        for (i = 0 ; __isdigit(*fmt) ; sc.width = i) {
                                i = (i * 10) + (*fmt++ - '0'); /* Get specified width. */
                        }
                        for (i = 0 ; i < sizeof(qual_s) ; i++) { /* Optional qualifier. */
                                if (qual_s[i] == *fmt) {
                                        ++fmt;
                                        lval += qsz[i];
                                        if ((i < 2) && (qual_s[i] == *fmt)) {   /* Double h or l. */
                                                ++fmt;
                                                lval += qsz[i];
                                        }
                                        break;
                                }
                        }
                        for (p = spec_s ; *p ; p++) {   /* Process format specifier. */
                                if (*fmt != *p) continue;
                                if (p-spec_s < 1) { /* % - match a '%'*/
                                        goto matchchar;
                                }
                                if (p-spec_s < 2) { /* n - store number of chars read */
                                        *(va_arg(ap, int *)) = sc.nread;
                                        scan_getc_nw(&sc);
                                        goto nextfmt;
                                }
                                if (p-spec_s > 3) { /* skip white space if not c or [ */
                                        while (__isspace(scan_getc_nw(&sc)))
                                                {}
                                        scan_ungetc(&sc);
                                }
                                if (p-spec_s < 5) { /* [,c,s - string conversions */
                                        invert = 0;
                                        if (*p == 'c') {
                                                invert = 1;
                                                if (sc.width == INT_MAX) {
                                                        sc.width = 1;
                                                }
                                        }
                                        for (i=0 ; i<= UCHAR_MAX ; i++) {
                                                scanset[i] = ((*p == 's') ? (__isspace(i) == 0) : 0);
                                        }
                                        if (*p == '[') { /* need to build a scanset */
                                                if (*++fmt == '^') {
                                                        invert = 1;
                                                        ++fmt;
                                                }
                                                if (*fmt == ']') {
                                                        scanset[(int)']'] = 1;
                                                        ++fmt;
                                                }
                                                r0 = 0;
                                                while (*fmt && *fmt !=']') { /* build scanset */
                                                        if ((*fmt == '-') && r0 && (fmt[1] != ']')) {
                                                                /* range */
                                                                ++fmt;
                                                                if (*fmt < r0) {
                                                                        r1 = r0;
                                                                        r0 = *fmt;
                                                                } else {
                                                                        r1 = *fmt;
                                                                }
                                                                for (i=r0 ; i<= r1 ; i++) {
                                                                        scanset[i] = 1;
                                                                }
                                                                r0 = 0;
                                                        } else {
                                                                r0 = *fmt;
                                                                scanset[r0] = 1;
                                                        }
                                                        ++fmt;
                                                }
                                                if (!*fmt) { /* format string exhausted! */
                                                        goto done;
                                                }
                                        }
                                        /* ok -- back to common work */
                                        if (sc.width <= 0) {
                                                goto done;
                                        }
                                        if (store) {
                                                b = va_arg(ap, unsigned char *);
                                        } else {
                                                b = buf;
                                        }
                                        cc = scan_getc(&sc);
                                        if (cc <= 0) {
                                                scan_ungetc(&sc);
                                                goto done; /* return EOF if cnt == 0 */
                                        }
                                        i = 0;
                                        while ((cc>0) && (scanset[cc] != invert)) {
                                                i = 1; /* yes, we stored something */
                                                *b = cc;
                                                b += store;
                                                cc = scan_getc(&sc);
                                        }
                                        if (i==0) {
                                                scan_ungetc(&sc);
                                                goto done; /* return cnt */
                                        }
                                        if (*p != 'c') { /* nul-terminate the stored string */
                                                *b = 0;
                                        }
                                        cnt += store;
                                        goto nextfmt;
                                }
                                if (p-spec_s < 12) { /* o,u,p,x,X,i,d - (un)signed integer */
                                        if (*p == 'p') {
                                                /* assume pointer same size as int or long. */
                                                lval = (sizeof(char *) == sizeof(long));
                                        }
                                        usflag = ((p-spec_s) < 10); /* (1)0 if (un)signed */
                                        base = radix[(int)(p-spec_s) - 5];
                                        b = buf;
                                        if (sc.width <= 0) {
                                                goto done;
                                        }
                                        cc = scan_getc(&sc);
                                        if ((cc == '+') || (cc == '-')) { /* Handle leading sign.*/
                                                *b++ = cc;
                                                cc = scan_getc(&sc);
                                        }
                                        if (cc == '0') { /* Possibly set base and handle prefix. */
                                                if ((base == 0) || (base == 16)) {
                                                        cc = scan_getc(&sc);
                                                        if ((cc == 'x') || (cc == 'X')) {
                                                                /* We're committed to base 16 now. */
                                                                base = 16;
                                                                cc = scan_getc(&sc);
                                                        } else { /* oops... back up */
                                                                scan_ungetc(&sc);
                                                                cc = '0';
                                                                if (base == 0) {
                                                                        base = 8;
                                                                }
                                                        }
                                                }
                                        }
                                        if (base == 0) { /* Default to base 10 */
                                                base = 10;
                                        }
                                        /* At this point, we're ready to start reading digits. */
                                        if (cc == '0') {
                                                *b++ = cc; /* Store first leading 0 */
                                                do {    /*     but ignore others. */
                                                        cc = scan_getc(&sc);
                                                } while (cc == '0');
                                        }
                                        while (valid_digit(cc,base)) { /* Now for nonzero digits.*/
                                                if (b - buf < MAX_DIGITS) {
                                                        *b++ = cc;
                                                }
                                                cc = scan_getc(&sc);
                                        }
                                        *b = 0; /* null-terminate */
                                        if ((b == buf) || (*--b == '+') || (*b == '-')) {
                                                scan_ungetc(&sc);
                                                goto done; /* No digits! */
                                        }
                                        if (store) {
                                                if (*buf == '-') {
                                                        usflag = 0;
                                                }
                                                uv = STRTO_L_(buf, NULL, base, usflag);
                                                vp = va_arg(ap, void *);
                                                switch (lval) {
                                                        case 2: /* If no long long, treat as long . */
#ifdef INCLUDE_LONG_LONG
                                                                *((unsigned long long *)vp) = uv;
                                                                break;
#endif
                                                        case 1:
#if ULONG_MAX == UINT_MAX
                                                        case 0: /* int and long int are the same */
#endif
#ifdef INCLUDE_LONG_LONG
                                                                if (usflag) {
                                                                        if (uv > ULONG_MAX) {
                                                                                uv = ULONG_MAX;
                                                                        }
                                                                } else if (((V_TYPE)uv) > LONG_MAX) {
                                                                        uv = LONG_MAX;
                                                                } else if (((V_TYPE)uv) < LONG_MIN) {
                                                                        uv = (UV_TYPE) LONG_MIN;
                                                                }
#endif
                                                                *((unsigned long *)vp) = (unsigned long)uv;
                                                                break;
#if ULONG_MAX != UINT_MAX
                                                        case 0: /* int and long int are different */
                                                                if (usflag) {
                                                                        if (uv > UINT_MAX) {
                                                                                uv = UINT_MAX;
                                                                        }
                                                                } else if (((V_TYPE)uv) > INT_MAX) {
                                                                        uv = INT_MAX;
                                                                } else if (((V_TYPE)uv) < INT_MIN) {
                                                                        uv = (UV_TYPE) INT_MIN;
                                                                }
                                                                *((unsigned int *)vp) = (unsigned int)uv;
                                                                break;
#endif
                                                        case -1:
                                                                if (usflag) {
                                                                        if (uv > USHRT_MAX) {
                                                                                uv = USHRT_MAX;
                                                                        }
                                                                } else if (((V_TYPE)uv) > SHRT_MAX) {
                                                                        uv = SHRT_MAX;
                                                                } else if (((V_TYPE)uv) < SHRT_MIN) {
                                                                        uv = (UV_TYPE) SHRT_MIN;
                                                                }
                                                                *((unsigned short *)vp) = (unsigned short)uv;
                                                                break;
                                                        case -2:
                                                                if (usflag) {
                                                                        if (uv > UCHAR_MAX) {
                                                                                uv = UCHAR_MAX;
                                                                        }
                                                                } else if (((V_TYPE)uv) > CHAR_MAX) {
                                                                        uv = CHAR_MAX;
                                                                } else if (((V_TYPE)uv) < CHAR_MIN) {
                                                                        uv = (UV_TYPE) CHAR_MIN;
                                                                }
                                                                *((unsigned char *)vp) = (unsigned char) uv;
                                                                break;
                                                        default:
                                                                assert(0);
                                                }
                                                ++cnt;
                                        }
                                        goto nextfmt;
                                }
#ifdef INCLUDE_FLOAT
                                else {                  /* floating point */
                                        if (sc.width <= 0) {
Ejemplo n.º 5
0
static void
_dopr(
    char **sbuffer,
    char **buffer,
    size_t *maxlen,
    size_t *retlen,
    int *truncated,
    const char *format,
    va_list args)
{
    char ch;
    LLONG value;
    char *strvalue;
    int min;
    int max;
    int state;
    int flags;
    int cflags;
    size_t currlen;

    state = DP_S_DEFAULT;
    flags = currlen = cflags = min = 0;
    max = -1;
    ch = *format++;

    while (state != DP_S_DONE) {
        if (ch == '\0' || (buffer == NULL && currlen >= *maxlen))
            state = DP_S_DONE;

        switch (state) {
        case DP_S_DEFAULT:
            if (ch == '%')
                state = DP_S_FLAGS;
            else
                doapr_outch(sbuffer,buffer, &currlen, maxlen, ch);
            ch = *format++;
            break;
        case DP_S_FLAGS:
            switch (ch) {
            case '-':
                flags |= DP_F_MINUS;
                ch = *format++;
                break;
            case '+':
                flags |= DP_F_PLUS;
                ch = *format++;
                break;
            case ' ':
                flags |= DP_F_SPACE;
                ch = *format++;
                break;
            case '#':
                flags |= DP_F_NUM;
                ch = *format++;
                break;
            case '0':
                flags |= DP_F_ZERO;
                ch = *format++;
                break;
            default:
                state = DP_S_MIN;
                break;
            }
            break;
        case DP_S_MIN:
            if (__isdigit((unsigned char)ch)){
                min = 10 * min + char_to_int(ch);
                ch = *format++;
            } else if (ch == '*') {
                min = va_arg(args, int);
                ch = *format++;
                state = DP_S_DOT;
            } else
                state = DP_S_DOT;
            break;
        case DP_S_DOT:
            if (ch == '.') {
                state = DP_S_MAX;
                ch = *format++;
            } else
                state = DP_S_MOD;
            break;
        case DP_S_MAX:
            if (__isdigit((unsigned char)ch)) {
                if (max < 0)
                    max = 0;
                max = 10 * max + char_to_int(ch);
                ch = *format++;
            } else if (ch == '*') {
                max = va_arg(args, int);
                ch = *format++;
                state = DP_S_MOD;
            } else
Ejemplo n.º 6
0
inline
bool
doisdigit(char c)
{
  return __isdigit(c);  
}