port/stdio/doscan.c

	doscan.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*  Copyright (c) 1988 AT&T */
/*    All Rights Reserved   */


/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include "synonyms.h"
#include <sys/types.h>
#include "mtlib.h"
#include "file64.h"
#include <stdio.h>
#include <ctype.h>
#include <stdarg.h>
#include <values.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <thread.h>
#include <synch.h>
#include <stdlib.h>
#include <fnmatch.h>
#include <limits.h>
#include <wchar.h>
#include <unistd.h>
#include "libc.h"
#include "stdiom.h"
#include "xpg6.h"

#define NCHARS  (1 << BITSPERBYTE)

/* if the _IOWRT flag is set, this must be a call from sscanf */
#define locgetc(cnt)    (cnt += 1, (iop->_flag & _IOWRT) ? \
                ((*iop->_ptr == '\0') ? EOF : *iop->_ptr++) : \
                GETC(iop))
#define locungetc(cnt, x) (cnt -= 1, (x == EOF) ? EOF : \
                ((iop->_flag & _IOWRT) ? *(--iop->_ptr) : \
                    (++iop->_cnt, *(--iop->_ptr))))

#define wlocgetc()  ((iop->_flag & _IOWRT) ? \
                ((*iop->_ptr == '\0') ? EOF : *iop->_ptr++) : \
                GETC(iop))
#define wlocungetc(x) ((x == EOF) ? EOF : \
                ((iop->_flag & _IOWRT) ? *(--iop->_ptr) : \
                    UNGETC(x, iop)))

#define MAXARGS 30  /* max. number of args for fast positional paramters */

/*
 * stva_list is used to subvert C's restriction that a variable with an
 * array type can not appear on the left hand side of an assignment operator.
 * By putting the array inside a structure, the functionality of assigning to
 * the whole array through a simple assignment is achieved..
 */
typedef struct stva_list {
    va_list ap;
} stva_list;

static int number(int *, int *, int, int, int, int, FILE *, va_list *);
static int readchar(FILE *, int *);
static int string(int *, int *, int, int, int, char *, FILE *, va_list *);
static int wstring(int *, int *, int, int, int, FILE *, va_list *);
static int  wbrstring(int *, int *, int, int, int, FILE *,
    unsigned char *, va_list *);
#ifdef  _WIDE
static int  brstring(int *, int *, int, int, int, FILE *,
    unsigned char *, va_list *);
#endif
static int _bi_getwc(FILE *);
static int _bi_ungetwc(wint_t, FILE *);

#ifdef  _WIDE
static int _mkarglst(const wchar_t *, stva_list, stva_list[]);
static wint_t   _wd_getwc(int *, FILE *);
static wint_t   _wd_ungetwc(int *, wchar_t, FILE *);
static int  _watoi(wchar_t *);
#else  /* _WIDE */
static int _mkarglst(const char *, stva_list, stva_list[]);
#endif /* _WIDE */

#ifndef _WIDE
int
_doscan(FILE *iop, const char *fmt, va_list va_Alist)
{
    int ret;
    rmutex_t *lk;

    if (iop->_flag & _IOWRT)
        ret = __doscan_u(iop, fmt, va_Alist, 0);
    else {
        FLOCKFILE(lk, iop);
        ret = __doscan_u(iop, fmt, va_Alist, 0);
        FUNLOCKFILE(lk);
    }
    return (ret);
}
#endif  /* _WIDE */

/* ARGSUSED3 */
#ifdef  _WIDE
int
__wdoscan_u(FILE *iop, const wchar_t *fmt, va_list va_Alist, int scflag)
#else  /* _WIDE */
int
__doscan_u(FILE *iop, const char *sfmt, va_list va_Alist, int scflag)
#endif /* _WIDE */
{
#ifdef  _WIDE
    wchar_t ch;
    wchar_t inchar, size;
    int nmatch = 0, len, stow;
#else  /* _WIDE */
    int ch;
    int     nmatch = 0, len, inchar, stow, size;
#endif /* _WIDE */

    unsigned char   *bracket_str = NULL;
    int     chcount, flag_eof;
    char    tab[NCHARS];

    /* variables for postional parameters */
#ifdef  _WIDE
    const wchar_t   *sformat = fmt; /* save the beginning of the format */
#else  /* _WIDE */
    const unsigned char *fmt = (const unsigned char *)sfmt;
    const char  *sformat = sfmt; /* save the beginning of the format */
#endif /* _WIDE */
    int     fpos = 1;   /* 1 if first postional parameter */
    stva_list   args,   /* used to step through the argument list */
        sargs;  /* used to save the start of the argument list */
    stva_list   arglst[MAXARGS];
                    /*
                     * array giving the appropriate values
                     * for va_arg() to retrieve the
                     * corresponding argument:
                     * arglst[0] is the first argument
                     * arglst[1] is the second argument,etc.
                     */
    /* Check if readable stream */
    if (!(iop->_flag & (_IOREAD | _IORW))) {
        errno = EBADF;
        return (EOF);
    }

    /*
     * Initialize args and sargs to the start of the argument list.
     * We don't know any portable way to copy an arbitrary C object
     * so we use a system-specific routine(probably a macro) from
     * stdarg.h.  (Remember that if va_list is an array, in_args will
     * be a pointer and &in_args won't be what we would want for
     * memcpy.)
     */
    va_copy(args.ap, va_Alist);

    sargs = args;

    chcount = 0; flag_eof = 0;

    /*
     * ****************************************************
     * Main loop: reads format to determine a pattern,
     *      and then goes to read input stream
     *      in attempt to match the pattern.
     * ****************************************************
     */
    for (; ; ) {
        if ((ch = *fmt++) == '\0') {
            return (nmatch); /* end of format */
        }
#ifdef  _WIDE
        if (iswspace(ch)) {
            if (!flag_eof) {
                while (iswspace(inchar =
                        _wd_getwc(&chcount, iop)))
                    ;
                if (_wd_ungetwc(&chcount, inchar, iop) == WEOF)
                    flag_eof = 1;
            }
            continue;
        }
        if (ch != '%' || (ch = *fmt++) == '%') {
            if ((inchar = _wd_getwc(&chcount, iop)) == ch)
                continue;
            if (_wd_ungetwc(&chcount, inchar, iop) != WEOF) {
                return (nmatch); /* failed to match input */
            }
            break;
        }
#else  /* _WIDE */
        if (isspace(ch)) {
            if (!flag_eof) {
                while (isspace(inchar = locgetc(chcount)))
                    ;
                if (locungetc(chcount, inchar) == EOF)
                    flag_eof = 1;

            }
            continue;
        }
        if (ch != '%' || (ch = *fmt++) == '%') {
            if ((inchar = locgetc(chcount)) == ch)
                continue;
            if (locungetc(chcount, inchar) != EOF) {
                return (nmatch); /* failed to match input */
            }
            break;
        }
#endif /* _WIDE */

charswitch: /* target of a goto 8-( */

        if (ch == '*') {
            stow = 0;
            ch = *fmt++;
        } else
            stow = 1;

#ifdef  _WIDE
        for (len = 0; ((ch >= 0) && (ch < 256) && isdigit(ch));
                                ch = *fmt++)
            len = len * 10 + ch - '0';
#else  /* _WIDE */
        for (len = 0; isdigit(ch); ch = *fmt++)
            len = len * 10 + ch - '0';
#endif /* _WIDE */

        if (ch == '$') {
            /*
             * positional parameter handling - the number
             * specified in len gives the argument to which
             * the next conversion should be applied.
             * WARNING: This implementation of positional
             * parameters assumes that the sizes of all pointer
             * types are the same. (Code similar to that
             * in the portable doprnt.c should be used if this
             * assumption does not hold for a particular
             * port.)
             */
            if (fpos) {
                if (_mkarglst(sformat, sargs, arglst) != 0) {
                    return (EOF);
                } else {
                    fpos = 0;
                }
            }
            if (len <= MAXARGS) {
                args = arglst[len - 1];
            } else {
                args = arglst[MAXARGS - 1];
                for (len -= MAXARGS; len > 0; len--)
                    (void) va_arg(args.ap, void *);
            }
            len = 0;
            ch = *fmt++;
            goto charswitch;
        }

        if (len == 0)
            len = MAXINT;
#ifdef  _WIDE
        if ((size = ch) == 'l' || (size == 'h') || (size == 'L') ||
            (size == 'j') || (size == 't') || (size == 'z'))
            ch = *fmt++;
#else  /* _WIDE */
        if ((size = ch) == 'l' || (size == 'h') || (size == 'L') ||
            (size == 'w') || (size == 'j') || (size == 't') ||
            (size == 'z'))
            ch = *fmt++;
#endif /* _WIDE */
        if (size == 'l' && ch == 'l') {
            size = 'm';     /* size = 'm' if long long */
            ch = *fmt++;
        } else if (size == 'h' && ch == 'h') {
            size = 'b';     /* use size = 'b' if char */
            ch = *fmt++;
        } else if ((size == 't') || (size == 'z')) {
            size = 'l';
        } else if (size == 'j') {
#ifndef _LP64
            /* check scflag for size of u/intmax_t (32-bit libc) */
            if (!(scflag & _F_INTMAX32))
            {
#endif
                size = 'm';
#ifndef _LP64
            }
#endif
        }
        if (ch == '\0') {
            return (EOF);       /* unexpected end of format */
        }
#ifdef  _WIDE
        if (ch == '[') {
            wchar_t c;
            size_t  len;
            int negflg = 0;
            wchar_t *p;
            wchar_t *wbracket_str;
            size_t  wlen, clen;

            /* p points to the address of '[' */
            p = (wchar_t *)fmt - 1;
            len = 0;
            if (*fmt == '^') {
                len++;
                fmt++;
                negflg = 1;
            }
            if (((c = *fmt) == ']') || (c == '-')) {
                len++;
                fmt++;
            }
            while ((c = *fmt) != ']') {
                if (c == '\0') {
                    return (EOF); /* unexpected EOF */
                } else {
                    len++;
                    fmt++;
                }
            }
            fmt++;
            len += 2;
            wbracket_str = (wchar_t *)
                malloc(sizeof (wchar_t) * (len + 1));
            if (wbracket_str == NULL) {
                errno = ENOMEM;
                return (EOF);
            } else {
                (void) wmemcpy(wbracket_str,
                        (const wchar_t *)p, len);
                *(wbracket_str + len) = L'\0';
                if (negflg && *(wbracket_str + 1) == '^') {
                    *(wbracket_str + 1) = L'!';
                }
            }
            wlen = wcslen(wbracket_str);
            clen = wcstombs((char *)NULL, wbracket_str, 0);
            if (clen == (size_t)-1) {
                free(wbracket_str);
                return (EOF);
            }
            bracket_str = (unsigned char *)
                malloc(sizeof (unsigned char) * (clen + 1));
            if (bracket_str == NULL) {
                free(wbracket_str);
                errno = ENOMEM;
                return (EOF);
            }
            clen = wcstombs((char *)bracket_str, wbracket_str,
                wlen + 1);
            free(wbracket_str);
            if (clen == (size_t)-1) {
                free(bracket_str);
                return (EOF);
            }
        }
#else  /* _WIDE */
        if (ch == '[') {
            if (size == 'l') {
                int c, len, i;
                int negflg = 0;
                unsigned char   *p;

                p = (unsigned char *)(fmt - 1);
                len = 0;
                if (*fmt == '^') {
                    len++;
                    fmt++;
                    negflg = 1;
                }
                if (((c = *fmt) == ']') || (c == '-')) {
                    len++;
                    fmt++;
                }
                while ((c = *fmt) != ']') {
                    if (c == '\0') {
                        return (EOF);
                    } else if (isascii(c)) {
                        len++;
                        fmt++;
                    } else {
                        i = mblen((const char *)fmt,
                            MB_CUR_MAX);
                        if (i <= 0) {
                            return (EOF);
                        } else {
                            len += i;
                            fmt += i;
                        }
                    }
                }
                fmt++;
                len += 2;
                bracket_str = (unsigned char *)
                    malloc(sizeof (unsigned char) *
                    (len + 1));
                if (bracket_str == NULL) {
                    errno = ENOMEM;
                    return (EOF);
                } else {
                    (void) strncpy((char *)bracket_str,
                        (const char *)p, len);
                    *(bracket_str + len) = '\0';
                    if (negflg &&
                        *(bracket_str + 1) == '^') {
                        *(bracket_str + 1) = '!';
                    }
                }
            } else {
                int t = 0;
                int b, c, d;

                if (*fmt == '^') {
                    t++;
                    fmt++;
                }
                (void) memset(tab, !t, NCHARS);
                if ((c = *fmt) == ']' || c == '-') {
                    tab[c] = t;
                    fmt++;
                }

                while ((c = *fmt) != ']') {
                    if (c == '\0') {
                        return (EOF);
                    }
                    b = *(fmt - 1);
                    d = *(fmt + 1);
                    if ((c == '-') && (d != ']') &&
                                (b < d)) {
                        (void) memset(&tab[b], t,
                                d - b + 1);
                        fmt += 2;
                    } else {
                        tab[c] = t;
                        fmt++;
                    }
                }
                fmt++;
            }
        }
#endif /* _WIDE */

#ifdef  _WIDE
        if ((ch >= 0) && (ch < 256) &&
            isupper((int)ch)) { /* no longer documented */
            if (_lib_version == c_issue_4) {
                if (size != 'm' && size != 'L')
                    size = 'l';
            }
            ch = _tolower((int)ch);
        }
        if (ch != 'n' && !flag_eof) {
            if (ch != 'c' && ch != 'C' && ch != '[') {
                while (iswspace(inchar =
                        _wd_getwc(&chcount, iop)))
                    ;
                if (_wd_ungetwc(&chcount, inchar, iop) == WEOF)
                    break;

            }
        }
#else  /* _WIDE */
        if (isupper(ch)) { /* no longer documented */
            if (_lib_version == c_issue_4) {
                if (size != 'm' && size != 'L')
                    size = 'l';
            }
            ch = _tolower(ch);
        }
        if (ch != 'n' && !flag_eof) {
            if (ch != 'c' && ch != 'C' && ch != '[') {
                while (isspace(inchar = locgetc(chcount)))
                    ;
                if (locungetc(chcount, inchar) == EOF)
                    break;
            }
        }
#endif /* _WIDE */

        switch (ch) {
        case 'C':
        case 'S':
        case 'c':
        case 's':
#ifdef  _WIDE
            if ((size == 'l') || (size == 'C') || (size == 'S'))
#else  /* _WIDE */
            if ((size == 'w') || (size == 'l') || (size == 'C') ||
                (size == 'S'))
#endif /* _WIDE */
            {
                size = wstring(&chcount, &flag_eof, stow,
                    (int)ch, len, iop, &args.ap);
            } else {
                size = string(&chcount, &flag_eof, stow,
                    (int)ch, len, tab, iop, &args.ap);
            }
            break;
        case '[':
            if (size == 'l') {
                size = wbrstring(&chcount, &flag_eof, stow,
                    (int)ch, len, iop, bracket_str,
                    &args.ap);
                free(bracket_str);
                bracket_str = NULL;
            } else {
#ifdef  _WIDE
                size = brstring(&chcount, &flag_eof, stow,
                    (int)ch, len, iop, bracket_str,
                    &args.ap);
                free(bracket_str);
                bracket_str = NULL;
#else  /* _WIDE */
                size = string(&chcount, &flag_eof, stow,
                    ch, len, tab, iop, &args.ap);
#endif /* _WIDE */
            }
            break;

        case 'n':
            if (stow == 0)
                continue;
            if (size == 'b')    /* char */
                *va_arg(args.ap, char *) = (char)chcount;
            else if (size == 'h')
                *va_arg(args.ap, short *) = (short)chcount;
            else if (size == 'l')
                *va_arg(args.ap, long *) = (long)chcount;
            else if (size == 'm') /* long long */
                *va_arg(args.ap, long long *) =
                    (long long) chcount;
            else
                *va_arg(args.ap, int *) = (int)chcount;
            continue;

        case 'i':
        default:
            size = number(&chcount, &flag_eof, stow, (int)ch,
                len, (int)size, iop, &args.ap);
            break;
        }
        if (size)
            nmatch += stow;
        else {
            return ((flag_eof && !nmatch) ? EOF : nmatch);
        }
        continue;
    }
    if (bracket_str)
        free(bracket_str);
    return (nmatch != 0 ? nmatch : EOF); /* end of input */
}

/* ****************************************************************** */
/* Functions to read the input stream in an attempt to match incoming */
/* data to the current pattern from the main loop of _doscan(). */
/* ****************************************************************** */
static int
number(int *chcount, int *flag_eof, int stow, int type, int len, int size,
    FILE *iop, va_list *listp)
{
    char    numbuf[64];
    char    *np = numbuf;
    int c, base, inchar, lookahead;
    int     digitseen = 0, floater = 0, negflg = 0;
    int     lc;
    long long   lcval = 0LL;

    switch (type) {
    case 'e':
    case 'f':
    case 'g':
        /*
         * lc = 0 corresponds to c90 mode: do not recognize
         *  hexadecimal fp strings; attempt to push back
         *  all unused characters read
         *
         * lc = -1 corresponds to c99 mode: recognize hexa-
         *  decimal fp strings; push back at most one
         *  unused character
         */
        lc = (__xpg6 & _C99SUSv3_recognize_hexfp)? -1 : 0;
        floater = 1;
        break;

    case 'a':
        lc = -1;
        floater = 1;
        break;

    case 'd':
    case 'u':
    case 'i':
        base = 10;
        break;
    case 'o':
        base = 8;
        break;
    case 'p':
#ifdef  _LP64
        size = 'l'; /* pointers are long in LP64 */
#endif  /*  _LP64   */
        /* FALLTHROUGH */
    case 'x':
        base = 16;
        break;
    default:
        return (0); /* unrecognized conversion character */
    }

    if (floater != 0) {
        /*
         * Handle floating point with
         * file_to_decimal.
         */
        decimal_mode        dm;
        decimal_record      dr;
        fp_exception_field_type efs;
        enum decimal_string_form form;
        char            *echar;
        int         nread;
        char            buffer[1024+1];
        char            *nb = buffer;

        if (len > 1024)
            len = 1024;
        file_to_decimal(&nb, len, lc, &dr, &form, &echar, iop, &nread);
        if (lc == -1) {
            /*
             * In C99 mode, the entire string read has to be
             * accepted in order to qualify as a match
             */
            if (nb != buffer + nread)
                form = invalid_form;
        }
        if (stow && (form != invalid_form)) {
#if defined(__sparc)
            dm.rd = _QgetRD();
            if (size == 'L') {      /* long double */
                if ((int)form < 0)
                    __hex_to_quadruple(&dr, dm.rd,
                        va_arg(*listp, quadruple *),
                        &efs);
                else
                    decimal_to_quadruple(
                        va_arg(*listp, quadruple *),
                        &dm, &dr, &efs);
            }
#elif defined(__i386) || defined(__amd64)
            dm.rd = __xgetRD();
            if (size == 'L') {      /* long double */
                if ((int)form < 0)
                    __hex_to_extended(&dr, dm.rd,
                        va_arg(*listp, extended *),
                        &efs);
                else
                    decimal_to_extended(
                        va_arg(*listp, extended *),
                        &dm, &dr, &efs);
            }
#else
#error Unknown architecture
#endif
            else if (size == 'l') {     /* double */
                if ((int)form < 0)
                    __hex_to_double(&dr, dm.rd,
                        va_arg(*listp, double *), &efs);
                else
                    decimal_to_double(
                        va_arg(*listp, double *),
                        &dm, &dr, &efs);
            } else {            /* float */
                if ((int)form < 0)
                    __hex_to_single(&dr, dm.rd,
                        va_arg(*listp, single *), &efs);
                else
                    decimal_to_single((single *)
                        va_arg(*listp, single *),
                        &dm, &dr, &efs);
            }
            if ((efs & (1 << fp_overflow)) != 0) {
                errno = ERANGE;
            }
            if ((efs & (1 << fp_underflow)) != 0) {
                errno = ERANGE;
            }
        }
        (*chcount) += nread;    /* Count characters read. */
        c = locgetc((*chcount));
        if (locungetc((*chcount), c) == EOF)
            *flag_eof = 1;
        return ((form == invalid_form) ? 0 : 1);
                /* successful match if non-zero */
    }

    switch (c = locgetc((*chcount))) {
    case '-':
        negflg++;
        /* FALLTHROUGH */
    case '+':
        if (--len <= 0)
            break;
        if ((c = locgetc((*chcount))) != '0')
            break;
        /* FALLTHROUGH */
    case '0':
        /*
         * If %i or %x, the characters 0x or 0X may optionally precede
         * the sequence of letters and digits (base 16).
         */
        if ((type != 'i' && type != 'x') || (len <= 1))
            break;
        if (((inchar = locgetc((*chcount))) == 'x') ||
            (inchar == 'X')) {
            lookahead = readchar(iop, chcount);
            if (isxdigit(lookahead)) {
                base = 16;

                if (len <= 2) {
                    (void) locungetc((*chcount), lookahead);
                    /* Take into account the 'x' */
                    len -= 1;
                } else {
                    c = lookahead;
                    /* Take into account '0x' */
                    len -= 2;
                }
            } else {
                (void) locungetc((*chcount), lookahead);
                (void) locungetc((*chcount), inchar);
            }
        } else {
            /* inchar wans't 'x'. */
            (void) locungetc((*chcount), inchar); /* Put it back. */
            if (type == 'i') /* Only %i accepts an octal. */
                base = 8;
        }
    }
    for (; --len  >= 0; *np++ = (char)c, c = locgetc((*chcount))) {
        if (np > numbuf + 62) {
            errno = ERANGE;
            return (0);
        }
        if (isdigit(c) || base == 16 && isxdigit(c)) {
            int digit = c - (isdigit(c) ? '0' :
                isupper(c) ? 'A' - 10 : 'a' - 10);
            if (digit >= base)
                break;
            if (stow)
                lcval = base * lcval + digit;
            digitseen++;
            continue;
        }
        break;
    }

    if (stow && digitseen) {
        /* suppress possible overflow on 2's-comp negation */
        if (negflg && lcval != (1ULL << 63))
            lcval = -lcval;
        switch (size) {
            case 'm':
                *va_arg(*listp, long long *) = lcval;
                break;
            case 'l':
                *va_arg(*listp, long *) = (long)lcval;
                break;
            case 'h':
                *va_arg(*listp, short *) = (short)lcval;
                break;
            case 'b':
                *va_arg(*listp, char *) = (char)lcval;
                break;
            default:
                *va_arg(*listp, int *) = (int)lcval;
                break;
        }
    }
    if (locungetc((*chcount), c) == EOF)
        *flag_eof = 1;
    return (digitseen); /* successful match if non-zero */
}

/* Get a character. If not using sscanf and at the buffer's end */
/* then do a direct read(). Characters read via readchar() */
/* can be  pushed back on the input stream by locungetc((*chcount),) */
/* since there is padding allocated at the end of the stream buffer. */
static int
readchar(FILE *iop, int *chcount)
{
    int inchar;
    char    buf[1];

    if ((iop->_flag & _IOWRT) || (iop->_cnt != 0))
        inchar = locgetc((*chcount));
    else {
        if (read(FILENO(iop), buf, 1) != 1)
            return (EOF);
        inchar = (int)buf[0];
        (*chcount) += 1;
    }
    return (inchar);
}

static int
string(int *chcount, int *flag_eof, int stow, int type, int len, char *tab,
    FILE *iop, va_list *listp)
{
    int ch;
    char    *ptr;
    char    *start;

    start = ptr = stow ? va_arg(*listp, char *) : NULL;
    if (((type == 'c') || (type == 'C')) && len == MAXINT)
        len = 1;
#ifdef  _WIDE
    while ((ch = locgetc((*chcount))) != EOF &&
        !(((type == 's') || (type == 'S')) && isspace(ch))) {
#else  /* _WIDE */
    while ((ch = locgetc((*chcount))) != EOF &&
        !(((type == 's') || (type == 'S')) &&
            isspace(ch) || type == '[' && tab[ch])) {
#endif /* _WIDE */
        if (stow)
            *ptr = (char)ch;
        ptr++;
        if (--len <= 0)
            break;
    }
    if (ch == EOF) {
        (*flag_eof) = 1;
        (*chcount) -= 1;
    } else if (len > 0 && locungetc((*chcount), ch) == EOF)
        (*flag_eof) = 1;
    if (ptr == start)
        return (0); /* no match */
    if (stow && ((type != 'c') && (type != 'C')))
        *ptr = '\0';
    return (1); /* successful match */
}

/* This function initializes arglst, to contain the appropriate */
/* va_list values for the first MAXARGS arguments. */
/* WARNING: this code assumes that the sizes of all pointer types */
/* are the same. (Code similar to that in the portable doprnt.c */
/* should be used if this assumption is not true for a */
/* particular port.) */

#ifdef  _WIDE
static int
_mkarglst(const wchar_t *fmt, stva_list args, stva_list arglst[])
#else  /* _WIDE */
static int
_mkarglst(const char *fmt, stva_list args, stva_list arglst[])
#endif /* _WIDE */
{
#ifdef  _WIDE
#define STRCHR  wcschr
#define STRSPN  wcsspn
#define ATOI(x) _watoi((wchar_t *)x)
#define SPNSTR1 L"01234567890"
#define SPNSTR2 L"# +-.0123456789hL$"
#else  /* _WIDE */
#define STRCHR  strchr
#define STRSPN  strspn
#define ATOI(x) atoi(x)
#define SPNSTR1 "01234567890"
#define SPNSTR2 "# +-.0123456789hL$"
#endif /* _WIDE */

    int maxnum, curargno;
    size_t n;

    maxnum = -1;
    curargno = 0;

    while ((fmt = STRCHR(fmt, '%')) != NULL) {
        fmt++;  /* skip % */
        if (*fmt == '*' || *fmt == '%')
            continue;
        if (fmt[n = STRSPN(fmt, SPNSTR1)] == L'$') {
            /* convert to zero base */
            curargno = ATOI(fmt) - 1;
            fmt += n + 1;
        }

        if (maxnum < curargno)
            maxnum = curargno;
        curargno++; /* default to next in list */

        fmt += STRSPN(fmt, SPNSTR2);
        if (*fmt == '[') {
            int     i;
            fmt++; /* has to be at least on item in scan list */
            if (*fmt == ']') {
                fmt++;
            }
            while (*fmt != ']') {
                if (*fmt == L'\0') {
                    return (-1); /* bad format */
#ifdef  _WIDE
                } else {
                    fmt++;
                }
#else  /* _WIDE */
                } else if (isascii(*fmt)) {
                    fmt++;
                } else {
                    i = mblen((const char *)
                        fmt, MB_CUR_MAX);
                    if (i <= 0) {
                        return (-1);
                    } else {
                        fmt += i;
                    }
                }
#endif /* _WIDE */
            }
        }
    }
    if (maxnum > MAXARGS)
        maxnum = MAXARGS;
    for (n = 0; n <= maxnum; n++) {
        arglst[n] = args;
        (void) va_arg(args.ap, void *);
    }
    return (0);
}


/*
 * For wide character handling
 */
#ifdef  _WIDE
static int
wstring(int *chcount, int *flag_eof, int stow, int type,
    int len, FILE *iop, va_list *listp)
{
    wint_t  wch;
    wchar_t *ptr;
    wchar_t *wstart;
    int dummy;

    wstart = ptr = stow ? va_arg(*listp, wchar_t *) : NULL;

    if ((type == 'c') && len == MAXINT)
        len = 1;
    while (((wch = _wd_getwc(chcount, iop)) != WEOF) &&
        !(type == 's' && iswspace(wch))) {
        if (stow)
            *ptr = wch;
        ptr++;
        if (--len <= 0)
            break;
    }
    if (wch == WEOF) {
        *flag_eof = 1;
        (*chcount) -= 1;
    } else {
        if (len > 0 && _wd_ungetwc(chcount, wch, iop) == WEOF)
            *flag_eof = 1;
    }
    if (ptr == wstart)
        return (0); /* no match */
    if (stow && (type != 'c'))
        *ptr = '\0';
    return (1); /* successful match */
}
#else  /* _WIDE */
static int
wstring(int *chcount, int *flag_eof, int stow, int type, int len, FILE *iop,
    va_list *listp)
{
    int wch;
    wchar_t *ptr;
    wchar_t *wstart;

    wstart = ptr = stow ? va_arg(*listp, wchar_t *) : NULL;

    if ((type == 'c') && len == MAXINT)
        len = 1;
    while (((wch = _bi_getwc(iop)) != EOF) &&
        !(type == 's' && (isascii(wch) ? isspace(wch) : 0))) {
        (*chcount) += _scrwidth((wchar_t)wch);
        if (stow)
            *ptr = wch;
        ptr++;
        if (--len <= 0)
            break;
    }
    if (wch == EOF) {
        (*flag_eof) = 1;
        (*chcount) -= 1;
    } else {
        if (len > 0 && _bi_ungetwc(wch, iop) == EOF)
            (*flag_eof) = 1;
    }
    if (ptr == wstart)
        return (0); /* no match */
    if (stow && (type != 'c'))
        *ptr = '\0';
    return (1); /* successful match */
}
#endif /* _WIDE */

#ifdef  _WIDE
static wint_t
_wd_getwc(int *chcount, FILE *iop)
{
    wint_t  wc;
    int len;

    if (!(iop->_flag & _IOWRT)) {
        /* call from fwscanf, wscanf */
        wc = __fgetwc_xpg5(iop);
        (*chcount)++;
        return (wc);
    } else {
        /* call from swscanf */
        if (*iop->_ptr == '\0')
            return (WEOF);
        len = mbtowc((wchar_t *)&wc, (const char *)iop->_ptr,
                                MB_CUR_MAX);
        if (len == -1)
            return (WEOF);
        iop->_ptr += len;
        (*chcount)++;
        return (wc);
    }
}

static wint_t
_wd_ungetwc(int *chcount, wchar_t wc, FILE *iop)
{
    wint_t  ret;
    int len;
    char    mbs[MB_LEN_MAX];

    if (wc == WEOF)
        return (WEOF);

    if (!(iop->_flag & _IOWRT)) {
        /* call from fwscanf, wscanf */
        ret = __ungetwc_xpg5((wint_t)wc, iop);
        if (ret != (wint_t)wc)
            return (WEOF);
        (*chcount)--;
        return (ret);
    } else {
        /* call from swscanf */
        len = wctomb(mbs, wc);
        if (len == -1)
            return (WEOF);
        iop->_ptr -= len;
        (*chcount)--;
        return ((wint_t)wc);
    }
}

static int
_watoi(wchar_t *fmt)
{
    int n = 0;
    wchar_t ch;

    ch = *fmt;
    if ((ch >= 0) && (ch < 256) && isdigit((int)ch)) {
        n = ch - '0';
        while (((ch = *++fmt) >= 0) && (ch < 256) &&
                isdigit((int)ch)) {
            n *= 10;
            n += ch - '0';
        }
    }
    return (n);
}
#endif /* _WIDE */

/* ARGSUSED3 */
static int
wbrstring(int *chcount, int *flag_eof, int stow, int type,
    int len, FILE *iop, unsigned char *brstr, va_list *listp)
{
    wint_t  wch;
    int i;
    char    str[MB_LEN_MAX + 1]; /* include null termination */
    wchar_t *ptr, *start;
#ifdef  _WIDE
    int dummy;
#endif /* _WIDE */

    start = ptr = stow ? va_arg(*listp, wchar_t *) : NULL;

#ifdef  _WIDE
    while ((wch = _wd_getwc(&dummy, iop)) != WEOF) {
#else  /* _WIDE */
    while ((wch = _bi_getwc(iop)) != WEOF) {
#endif /* _WIDE */
        i = wctomb(str, (wchar_t)wch);
        if (i == -1) {
            return (0);
        }
        str[i] = '\0';
        if (fnmatch((const char *)brstr, (const char *)str,
            FNM_NOESCAPE)) {
            break;
        } else {
            if (len > 0) {
#ifdef  _WIDE
                (*chcount)++;
#else  /* _WIDE */
                (*chcount) += _scrwidth(wch);
#endif /* _WIDE */
                len--;
                if (stow) {
                    *ptr = wch;
                }
                ptr++;
                if (len <= 0)
                    break;
            } else {
                break;
            }
        }
    }
    if (wch == WEOF) {
        *flag_eof = 1;
    } else {
#ifdef  _WIDE
        if (len > 0 && _wd_ungetwc(&dummy, wch, iop) == WEOF)
#else  /* _WIDE */
        if (len > 0 && _bi_ungetwc(wch, iop) == WEOF)
#endif /* _WIDE */
            *flag_eof = 1;
    }
    if (ptr == start)
        return (0);             /* no match */
    if (stow)
        *ptr = L'\0';
    return (1);                 /* successful match */
}

#ifdef  _WIDE
static int
brstring(int *chcount, int *flag_eof, int stow, int type,
    int len, FILE *iop, unsigned char *brstr, va_list *listp)
{
    wint_t  wch;
    int i;
    char    str[MB_LEN_MAX + 1]; /* include null termination */
    char    *ptr, *start, *p;
    int dummy;

    start = ptr = stow ? va_arg(*listp, char *) : NULL;

    while ((wch = _wd_getwc(&dummy, iop)) != WEOF) {
        p = str;
        i = wctomb(str, (wchar_t)wch);
        if (i == -1) {
            return (0);
        }
        str[i] = '\0';
        if (fnmatch((const char *)brstr, (const char *)str,
            FNM_NOESCAPE)) {
            break;
        } else {
            if (len >= i) {
                (*chcount)++;
                len -= i;
                if (stow) {
                    while (i-- > 0) {
                        *ptr++ = *p++;
                    }
                } else {
                    while (i-- > 0) {
                        ptr++;
                    }
                }
                if (len <= 0)
                    break;
            } else {
                break;
            }
        }
    }
    if (wch == WEOF) {
        *flag_eof = 1;
    } else {
        if (len > 0 && _wd_ungetwc(&dummy, wch, iop) == WEOF)
            *flag_eof = 1;
    }
    if (ptr == start)
        return (0);             /* no match */
    if (stow)
        *ptr = '\0';
    return (1);                 /* successful match */
}
#endif /* _WIDE */

/*
 * Locally define getwc and ungetwc
 */
static int
_bi_getwc(FILE *iop)
{
    int c;
    wchar_t intcode;
    int i, nbytes, cur_max;
    char buff[MB_LEN_MAX];

    if ((c = wlocgetc()) == EOF)
        return (WEOF);

    if (isascii(c)) /* ASCII code */
        return ((wint_t)c);

    buff[0] = (char)c;

    cur_max = (int)MB_CUR_MAX;
    /* MB_CUR_MAX doen't exeed the value of MB_LEN_MAX */
    /* So we use MB_CUR_MAX instead of MB_LEN_MAX for */
    /* improving the performance. */
    for (i = 1; i < cur_max; i++) {
        c = wlocgetc();
        if (c == '\n') {
            (void) wlocungetc(c);
            break;
        }
        if (c == EOF) {
            /* this still may be a valid multibyte character */
            break;
        }
        buff[i] = (char)c;
    }

    if ((nbytes = mbtowc(&intcode, buff, i)) == -1) {
        /*
         * If mbtowc fails, the input was not a legal character.
         *  ungetc all but one character.
         *
         * Note:  the number of pushback characters that
         *  ungetc() can handle must be >= (MB_LEN_MAX - 1).
         *  In Solaris 2.x, the number of pushback
         *  characters is 4.
         */
        while (i-- > 1) {
            (void) wlocungetc((signed char)buff[i]);
        }
        errno = EILSEQ;
        return (WEOF); /* Illegal EUC sequence. */
    }

    while (i-- > nbytes) {
        /*
         * Note:  the number of pushback characters that
         *  ungetc() can handle must be >= (MB_LEN_MAX - 1).
         *  In Solaris 2.x, the number of pushback
         *  characters is 4.
         */
        (void) wlocungetc((signed char)buff[i]);
    }
    return ((int)intcode);
}

static int
_bi_ungetwc(wint_t wc, FILE *iop)
{
    char mbs[MB_LEN_MAX];
    unsigned char *p;
    int n;

    if ((wc == WEOF) || ((iop->_flag & _IOREAD) == 0))
        return (WEOF);

    n = wctomb(mbs, (wchar_t)wc);
    if (n <= 0)
        return (WEOF);

    if (iop->_ptr <= iop->_base) {
        if (iop->_base == NULL) {
            return (WEOF);
        }
        if ((iop->_ptr == iop->_base) && (iop->_cnt == 0)) {
            ++iop->_ptr;
        } else if ((iop->_ptr - n) < (iop->_base - PUSHBACK)) {
            return (WEOF);
        }
    }

    p = (unsigned char *)(mbs+n-1); /* p points the last byte */
    /* if _IOWRT is set to iop->_flag, it means this is */
    /* an invocation from sscanf(), and in that time we */
    /* don't touch iop->_cnt.  Otherwise, which means an */
    /* invocation from fscanf() or scanf(), we touch iop->_cnt */
    if ((iop->_flag & _IOWRT) == 0) {
        /* scanf() and fscanf() */
        iop->_cnt += n;
        while (n--) {
            *--iop->_ptr = *(p--);
        }
    } else {
        /* sscanf() */
        iop->_ptr -= n;
    }
    return (wc);
}