Subversion Repositories openrisc

/*-

/*-

 * Copyright (c) 1990 The Regents of the University of California.

 * Copyright (c) 1990 The Regents of the University of California.

 * All rights reserved.

 * All rights reserved.

 *

 *

 * Redistribution and use in source and binary forms are permitted

 * Redistribution and use in source and binary forms are permitted

 * provided that the above copyright notice and this paragraph are

 * provided that the above copyright notice and this paragraph are

 * duplicated in all such forms and that any documentation,

 * duplicated in all such forms and that any documentation,

 * advertising materials, and other materials related to such

 * advertising materials, and other materials related to such

 * distribution and use acknowledge that the software was developed

 * distribution and use acknowledge that the software was developed

 * by the University of California, Berkeley.  The name of the

 * by the University of California, Berkeley.  The name of the

 * University may not be used to endorse or promote products derived

 * University may not be used to endorse or promote products derived

 * from this software without specific prior written permission.

 * from this software without specific prior written permission.

 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR

 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED

 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

 */

 */

/*

/*

FUNCTION

FUNCTION

<<vfwscanf>>, <<vwscanf>>, <<vswscanf>>---scan and format argument list from wide character input

<<vfwscanf>>, <<vwscanf>>, <<vswscanf>>---scan and format argument list from wide character input

INDEX

INDEX

        vfwscanf

        vfwscanf

INDEX

INDEX

        _vfwscanf

        _vfwscanf

INDEX

INDEX

        vwscanf

        vwscanf

INDEX

INDEX

        _vwscanf

        _vwscanf

INDEX

INDEX

        vswscanf

        vswscanf

INDEX

INDEX

        _vswscanf

        _vswscanf

ANSI_SYNOPSIS

ANSI_SYNOPSIS

        #include <stdio.h>

        #include <stdio.h>

        #include <stdarg.h>

        #include <stdarg.h>

        int vwscanf(const wchar_t *<[fmt]>, va_list <[list]>);

        int vwscanf(const wchar_t *<[fmt]>, va_list <[list]>);

        int vfwscanf(FILE *<[fp]>, const wchar_t *<[fmt]>, va_list <[list]>);

        int vfwscanf(FILE *<[fp]>, const wchar_t *<[fmt]>, va_list <[list]>);

        int vswscanf(const wchar_t *<[str]>, const wchar_t *<[fmt]>, va_list <[list]>);

        int vswscanf(const wchar_t *<[str]>, const wchar_t *<[fmt]>, va_list <[list]>);

        int _vwscanf(struct _reent *<[reent]>, const wchar_t *<[fmt]>,

        int _vwscanf(struct _reent *<[reent]>, const wchar_t *<[fmt]>,

                       va_list <[list]>);

                       va_list <[list]>);

        int _vfwscanf(struct _reent *<[reent]>, FILE *<[fp]>, const wchar_t *<[fmt]>,

        int _vfwscanf(struct _reent *<[reent]>, FILE *<[fp]>, const wchar_t *<[fmt]>,

                       va_list <[list]>);

                       va_list <[list]>);

        int _vswscanf(struct _reent *<[reent]>, const wchar_t *<[str]>,

        int _vswscanf(struct _reent *<[reent]>, const wchar_t *<[str]>,

                       const wchar_t *<[fmt]>, va_list <[list]>);

                       const wchar_t *<[fmt]>, va_list <[list]>);

TRAD_SYNOPSIS

TRAD_SYNOPSIS

        #include <stdio.h>

        #include <stdio.h>

        #include <varargs.h>

        #include <varargs.h>

        int vwscanf( <[fmt]>, <[ist]>)

        int vwscanf( <[fmt]>, <[ist]>)

        wchar_t *<[fmt]>;

        wchar_t *<[fmt]>;

        va_list <[list]>;

        va_list <[list]>;

        int vfwscanf( <[fp]>, <[fmt]>, <[list]>)

        int vfwscanf( <[fp]>, <[fmt]>, <[list]>)

        FILE *<[fp]>;

        FILE *<[fp]>;

        wchar_t *<[fmt]>;

        wchar_t *<[fmt]>;

        va_list <[list]>;

        va_list <[list]>;

        int vswscanf( <[str]>, <[fmt]>, <[list]>)

        int vswscanf( <[str]>, <[fmt]>, <[list]>)

        wchar_t *<[str]>;

        wchar_t *<[str]>;

        wchar_t *<[fmt]>;

        wchar_t *<[fmt]>;

        va_list <[list]>;

        va_list <[list]>;

        int _vwscanf( <[reent]>, <[fmt]>, <[ist]>)

        int _vwscanf( <[reent]>, <[fmt]>, <[ist]>)

        struct _reent *<[reent]>;

        struct _reent *<[reent]>;

        wchar_t *<[fmt]>;

        wchar_t *<[fmt]>;

        va_list <[list]>;

        va_list <[list]>;

        int _vfwscanf( <[reent]>, <[fp]>, <[fmt]>, <[list]>)

        int _vfwscanf( <[reent]>, <[fp]>, <[fmt]>, <[list]>)

        struct _reent *<[reent]>;

        struct _reent *<[reent]>;

        FILE *<[fp]>;

        FILE *<[fp]>;

        wchar_t *<[fmt]>;

        wchar_t *<[fmt]>;

        va_list <[list]>;

        va_list <[list]>;

        int _vswscanf( <[reent]>, <[str]>, <[fmt]>, <[list]>)

        int _vswscanf( <[reent]>, <[str]>, <[fmt]>, <[list]>)

        struct _reent *<[reent]>;

        struct _reent *<[reent]>;

        wchar_t *<[str]>;

        wchar_t *<[str]>;

        wchar_t *<[fmt]>;

        wchar_t *<[fmt]>;

        va_list <[list]>;

        va_list <[list]>;

DESCRIPTION

DESCRIPTION

<<vwscanf>>, <<vfwscanf>>, and <<vswscanf>> are (respectively) variants

<<vwscanf>>, <<vfwscanf>>, and <<vswscanf>> are (respectively) variants

of <<wscanf>>, <<fwscanf>>, and <<swscanf>>.  They differ only in

of <<wscanf>>, <<fwscanf>>, and <<swscanf>>.  They differ only in

allowing their caller to pass the variable argument list as a

allowing their caller to pass the variable argument list as a

<<va_list>> object (initialized by <<va_start>>) rather than

<<va_list>> object (initialized by <<va_start>>) rather than

directly accepting a variable number of arguments.

directly accepting a variable number of arguments.

RETURNS

RETURNS

The return values are consistent with the corresponding functions:

The return values are consistent with the corresponding functions:

<<vwscanf>> returns the number of input fields successfully scanned,

<<vwscanf>> returns the number of input fields successfully scanned,

converted, and stored; the return value does not include scanned

converted, and stored; the return value does not include scanned

fields which were not stored.

fields which were not stored.

If <<vwscanf>> attempts to read at end-of-file, the return value

If <<vwscanf>> attempts to read at end-of-file, the return value

is <<EOF>>.

is <<EOF>>.

If no fields were stored, the return value is <<0>>.

If no fields were stored, the return value is <<0>>.

The routines <<_vwscanf>>, <<_vfwscanf>>, and <<_vswscanf>> are

The routines <<_vwscanf>>, <<_vfwscanf>>, and <<_vswscanf>> are

reentrant versions which take an additional first parameter which points

reentrant versions which take an additional first parameter which points

to the reentrancy structure.

to the reentrancy structure.

PORTABILITY

PORTABILITY

C99, POSIX-1.2008

C99, POSIX-1.2008

*/

*/

#include <_ansi.h>

#include <_ansi.h>

#include <reent.h>

#include <reent.h>

#include <newlib.h>

#include <newlib.h>

#include <ctype.h>

#include <ctype.h>

#include <wctype.h>

#include <wctype.h>

#include <stdio.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdlib.h>

#include <stdint.h>

#include <stdint.h>

#include <limits.h>

#include <limits.h>

#include <wchar.h>

#include <wchar.h>

#include <string.h>

#include <string.h>

#include <stdarg.h>

#include <stdarg.h>

#include <errno.h>

#include <errno.h>

#include "local.h"

#include "local.h"

#ifdef INTEGER_ONLY

#ifdef INTEGER_ONLY

#define VFWSCANF vfiwscanf

#define VFWSCANF vfiwscanf

#define _VFWSCANF_R _vfiwscanf_r

#define _VFWSCANF_R _vfiwscanf_r

#define __SVFWSCANF __svfiwscanf

#define __SVFWSCANF __svfiwscanf

#ifdef STRING_ONLY

#ifdef STRING_ONLY

#  define __SVFWSCANF_R __ssvfiwscanf_r

#  define __SVFWSCANF_R __ssvfiwscanf_r

#else

#else

#  define __SVFWSCANF_R __svfiwscanf_r

#  define __SVFWSCANF_R __svfiwscanf_r

#endif

#endif

#else

#else

#define VFWSCANF vfwscanf

#define VFWSCANF vfwscanf

#define _VFWSCANF_R _vfwscanf_r

#define _VFWSCANF_R _vfwscanf_r

#define __SVFWSCANF __svfwscanf

#define __SVFWSCANF __svfwscanf

#ifdef STRING_ONLY

#ifdef STRING_ONLY

#  define __SVFWSCANF_R __ssvfwscanf_r

#  define __SVFWSCANF_R __ssvfwscanf_r

#else

#else

#  define __SVFWSCANF_R __svfwscanf_r

#  define __SVFWSCANF_R __svfwscanf_r

#endif

#endif

#ifndef NO_FLOATING_POINT

#ifndef NO_FLOATING_POINT

#define FLOATING_POINT

#define FLOATING_POINT

#endif

#endif

#endif

#endif

#ifdef STRING_ONLY

#ifdef STRING_ONLY

#undef _flockfile

#undef _flockfile

#undef _funlockfile

#undef _funlockfile

#define _flockfile(x) {}

#define _flockfile(x) {}

#define _funlockfile(x) {}

#define _funlockfile(x) {}

#define _ungetwc_r _sungetwc_r

#define _ungetwc_r _sungetwc_r

#define __srefill_r __ssrefill_r

#define __srefill_r __ssrefill_r

#define _fgetwc_r _sfgetwc_r

#define _fgetwc_r _sfgetwc_r

#endif

#endif

#ifdef FLOATING_POINT

#ifdef FLOATING_POINT

#include <math.h>

#include <math.h>

#include <float.h>

#include <float.h>

/* Currently a test is made to see if long double processing is warranted.

/* Currently a test is made to see if long double processing is warranted.

   This could be changed in the future should the _ldtoa_r code be

   This could be changed in the future should the _ldtoa_r code be

   preferred over _dtoa_r.  */

   preferred over _dtoa_r.  */

#define _NO_LONGDBL

#define _NO_LONGDBL

#if defined _WANT_IO_LONG_DOUBLE && (LDBL_MANT_DIG > DBL_MANT_DIG)

#if defined _WANT_IO_LONG_DOUBLE && (LDBL_MANT_DIG > DBL_MANT_DIG)

#undef _NO_LONGDBL

#undef _NO_LONGDBL

extern _LONG_DOUBLE _wcstold_r _PARAMS((wchar_t *s, wchar_t **sptr));

extern _LONG_DOUBLE _wcstold_r _PARAMS((wchar_t *s, wchar_t **sptr));

#endif

#endif

#include "floatio.h"

#include "floatio.h"

#if ((MAXEXP+MAXFRACT+3) > MB_LEN_MAX)

#if ((MAXEXP+MAXFRACT+3) > MB_LEN_MAX)

#  define BUF (MAXEXP+MAXFRACT+3)        /* 3 = sign + decimal point + NUL */

#  define BUF (MAXEXP+MAXFRACT+3)        /* 3 = sign + decimal point + NUL */

#else

#else

#  define BUF MB_LEN_MAX

#  define BUF MB_LEN_MAX

#endif

#endif

/* An upper bound for how long a long prints in decimal.  4 / 13 approximates

/* An upper bound for how long a long prints in decimal.  4 / 13 approximates

   log (2).  Add one char for roundoff compensation and one for the sign.  */

   log (2).  Add one char for roundoff compensation and one for the sign.  */

#define MAX_LONG_LEN ((CHAR_BIT * sizeof (long)  - 1) * 4 / 13 + 2)

#define MAX_LONG_LEN ((CHAR_BIT * sizeof (long)  - 1) * 4 / 13 + 2)

#else

#else

#define BUF     40

#define BUF     40

#endif

#endif

#define _NO_LONGLONG

#define _NO_LONGLONG

#if defined _WANT_IO_LONG_LONG \

#if defined _WANT_IO_LONG_LONG \

        && (defined __GNUC__ || __STDC_VERSION__ >= 199901L)

        && (defined __GNUC__ || __STDC_VERSION__ >= 199901L)

# undef _NO_LONGLONG

# undef _NO_LONGLONG

#endif

#endif

#define _NO_POS_ARGS

#define _NO_POS_ARGS

#ifdef _WANT_IO_POS_ARGS

#ifdef _WANT_IO_POS_ARGS

# undef _NO_POS_ARGS

# undef _NO_POS_ARGS

# ifdef NL_ARGMAX

# ifdef NL_ARGMAX

#  define MAX_POS_ARGS NL_ARGMAX

#  define MAX_POS_ARGS NL_ARGMAX

# else

# else

#  define MAX_POS_ARGS 32

#  define MAX_POS_ARGS 32

# endif

# endif

static void * get_arg (int, va_list *, int *, void **);

static void * get_arg (int, va_list *, int *, void **);

#endif /* _WANT_IO_POS_ARGS */

#endif /* _WANT_IO_POS_ARGS */

/*

/*

 * Flags used during conversion.

 * Flags used during conversion.

 */

 */

#define LONG            0x01    /* l: long or double */

#define LONG            0x01    /* l: long or double */

#define LONGDBL         0x02    /* L/ll: long double or long long */

#define LONGDBL         0x02    /* L/ll: long double or long long */

#define SHORT           0x04    /* h: short */

#define SHORT           0x04    /* h: short */

#define CHAR            0x08    /* hh: 8 bit integer */

#define CHAR            0x08    /* hh: 8 bit integer */

#define SUPPRESS        0x10    /* suppress assignment */

#define SUPPRESS        0x10    /* suppress assignment */

#define POINTER         0x20    /* weird %p pointer (`fake hex') */

#define POINTER         0x20    /* weird %p pointer (`fake hex') */

#define NOSKIP          0x40    /* do not skip blanks */

#define NOSKIP          0x40    /* do not skip blanks */

/*

/*

 * The following are used in numeric conversions only:

 * The following are used in numeric conversions only:

 * SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point;

 * SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point;

 * SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral.

 * SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral.

 */

 */

#define SIGNOK          0x80    /* +/- is (still) legal */

#define SIGNOK          0x80    /* +/- is (still) legal */

#define NDIGITS         0x100   /* no digits detected */

#define NDIGITS         0x100   /* no digits detected */

#define DPTOK           0x200   /* (float) decimal point is still legal */

#define DPTOK           0x200   /* (float) decimal point is still legal */

#define EXPOK           0x400   /* (float) exponent (e+3, etc) still legal */

#define EXPOK           0x400   /* (float) exponent (e+3, etc) still legal */

#define PFXOK           0x200   /* 0x prefix is (still) legal */

#define PFXOK           0x200   /* 0x prefix is (still) legal */

#define NZDIGITS        0x400   /* no zero digits detected */

#define NZDIGITS        0x400   /* no zero digits detected */

#define HAVESIGN        0x10000 /* sign detected */

#define HAVESIGN        0x10000 /* sign detected */

/*

/*

 * Conversion types.

 * Conversion types.

 */

 */

#define CT_CHAR         0        /* %c conversion */

#define CT_CHAR         0        /* %c conversion */

#define CT_CCL          1       /* %[...] conversion */

#define CT_CCL          1       /* %[...] conversion */

#define CT_STRING       2       /* %s conversion */

#define CT_STRING       2       /* %s conversion */

#define CT_INT          3       /* integer, i.e., wcstol or wcstoul */

#define CT_INT          3       /* integer, i.e., wcstol or wcstoul */

#define CT_FLOAT        4       /* floating, i.e., wcstod */

#define CT_FLOAT        4       /* floating, i.e., wcstod */

#define INCCL(_c)       \

#define INCCL(_c)       \

        (cclcompl ? (wmemchr(ccls, (_c), ccle - ccls) == NULL) : \

        (cclcompl ? (wmemchr(ccls, (_c), ccle - ccls) == NULL) : \

        (wmemchr(ccls, (_c), ccle - ccls) != NULL))

        (wmemchr(ccls, (_c), ccle - ccls) != NULL))

/*

/*

 * vfwscanf

 * vfwscanf

 */

 */

#ifndef STRING_ONLY

#ifndef STRING_ONLY

#ifndef _REENT_ONLY

#ifndef _REENT_ONLY

int

int

_DEFUN(VFWSCANF, (fp, fmt, ap),

_DEFUN(VFWSCANF, (fp, fmt, ap),

       register FILE *fp _AND

       register FILE *fp _AND

       _CONST wchar_t *fmt _AND

       _CONST wchar_t *fmt _AND

       va_list ap)

       va_list ap)

{

{

  CHECK_INIT(_REENT, fp);

  CHECK_INIT(_REENT, fp);

  return __SVFWSCANF_R (_REENT, fp, fmt, ap);

  return __SVFWSCANF_R (_REENT, fp, fmt, ap);

}

}

int

int

_DEFUN(__SVFWSCANF, (fp, fmt0, ap),

_DEFUN(__SVFWSCANF, (fp, fmt0, ap),

       register FILE *fp _AND

       register FILE *fp _AND

       wchar_t _CONST *fmt0 _AND

       wchar_t _CONST *fmt0 _AND

       va_list ap)

       va_list ap)

{

{

  return __SVFWSCANF_R (_REENT, fp, fmt0, ap);

  return __SVFWSCANF_R (_REENT, fp, fmt0, ap);

}

}

#endif /* !_REENT_ONLY */

#endif /* !_REENT_ONLY */

int

int

_DEFUN(_VFWSCANF_R, (data, fp, fmt, ap),

_DEFUN(_VFWSCANF_R, (data, fp, fmt, ap),

       struct _reent *data _AND

       struct _reent *data _AND

       register FILE *fp   _AND

       register FILE *fp   _AND

       _CONST wchar_t *fmt    _AND

       _CONST wchar_t *fmt    _AND

       va_list ap)

       va_list ap)

{

{

  CHECK_INIT(data, fp);

  CHECK_INIT(data, fp);

  return __SVFWSCANF_R (data, fp, fmt, ap);

  return __SVFWSCANF_R (data, fp, fmt, ap);

}

}

#endif /* !STRING_ONLY */

#endif /* !STRING_ONLY */

#ifdef STRING_ONLY

#ifdef STRING_ONLY

/* When dealing with the swscanf family, we don't want to use the

/* When dealing with the swscanf family, we don't want to use the

 * regular ungetwc which will drag in file I/O items we don't need.

 * regular ungetwc which will drag in file I/O items we don't need.

 * So, we create our own trimmed-down version.  */

 * So, we create our own trimmed-down version.  */

static wint_t

static wint_t

_DEFUN(_sungetwc_r, (data, fp, ch),

_DEFUN(_sungetwc_r, (data, fp, ch),

        struct _reent *data _AND

        struct _reent *data _AND

        wint_t wc           _AND

        wint_t wc           _AND

        register FILE *fp)

        register FILE *fp)

{

{

  if (wc == WEOF)

  if (wc == WEOF)

    return (WEOF);

    return (WEOF);

  /* After ungetc, we won't be at eof anymore */

  /* After ungetc, we won't be at eof anymore */

  fp->_flags &= ~__SEOF;

  fp->_flags &= ~__SEOF;

  /*

  /*

   * If we are in the middle of ungetwc'ing, just continue.

   * If we are in the middle of ungetwc'ing, just continue.

   * This may require expanding the current ungetc buffer.

   * This may require expanding the current ungetc buffer.

   */

   */

  if (HASUB (fp))

  if (HASUB (fp))

    {

    {

      if (fp->_r >= fp->_ub._size && __submore (data, fp))

      if (fp->_r >= fp->_ub._size && __submore (data, fp))

        {

        {

          return EOF;

          return EOF;

        }

        }

      fp->_p -= sizeof (wchar_t);

      fp->_p -= sizeof (wchar_t);

      *fp->_p = (wchar_t) wc;

      *fp->_p = (wchar_t) wc;

      fp->_r += sizeof (wchar_t);

      fp->_r += sizeof (wchar_t);

      return wc;

      return wc;

    }

    }

  /*

  /*

   * If we can handle this by simply backing up, do so,

   * If we can handle this by simply backing up, do so,

   * but never replace the original character.

   * but never replace the original character.

   * (This makes swscanf() work when scanning `const' data.)

   * (This makes swscanf() work when scanning `const' data.)

   */

   */

  if (fp->_bf._base != NULL && fp->_p > fp->_bf._base

  if (fp->_bf._base != NULL && fp->_p > fp->_bf._base

      && ((wchar_t *)fp->_p)[-1] == wc)

      && ((wchar_t *)fp->_p)[-1] == wc)

    {

    {

      fp->_p -= sizeof (wchar_t);

      fp->_p -= sizeof (wchar_t);

      fp->_r += sizeof (wchar_t);

      fp->_r += sizeof (wchar_t);

      return wc;

      return wc;

    }

    }

  /*

  /*

   * Create an ungetc buffer.

   * Create an ungetc buffer.

   * Initially, we will use the `reserve' buffer.

   * Initially, we will use the `reserve' buffer.

   */

   */

  fp->_ur = fp->_r;

  fp->_ur = fp->_r;

  fp->_up = fp->_p;

  fp->_up = fp->_p;

  fp->_ub._base = fp->_ubuf;

  fp->_ub._base = fp->_ubuf;

  fp->_ub._size = sizeof (fp->_ubuf);

  fp->_ub._size = sizeof (fp->_ubuf);

  fp->_p = &fp->_ubuf[sizeof (fp->_ubuf) - sizeof (wchar_t)];

  fp->_p = &fp->_ubuf[sizeof (fp->_ubuf) - sizeof (wchar_t)];

  *(wchar_t *) fp->_p = wc;

  *(wchar_t *) fp->_p = wc;

  fp->_r = 2;

  fp->_r = 2;

  return wc;

  return wc;

}

}

extern int __ssrefill_r _PARAMS ((struct _reent *ptr, register FILE * fp));

extern int __ssrefill_r _PARAMS ((struct _reent *ptr, register FILE * fp));

static size_t

static size_t

_DEFUN(_sfgetwc_r, (ptr, fp),

_DEFUN(_sfgetwc_r, (ptr, fp),

       struct _reent * ptr _AND

       struct _reent * ptr _AND

       FILE * fp)

       FILE * fp)

{

{

  wchar_t wc;

  wchar_t wc;

  if (fp->_r <= 0 && __ssrefill_r (ptr, fp))

  if (fp->_r <= 0 && __ssrefill_r (ptr, fp))

    return (WEOF);

    return (WEOF);

  wc = *(wchar_t *) fp->_p;

  wc = *(wchar_t *) fp->_p;

  fp->_p += sizeof (wchar_t);

  fp->_p += sizeof (wchar_t);

  fp->_r -= sizeof (wchar_t);

  fp->_r -= sizeof (wchar_t);

  return (wc);

  return (wc);

}

}

#endif /* STRING_ONLY */

#endif /* STRING_ONLY */

int

int

_DEFUN(__SVFWSCANF_R, (rptr, fp, fmt0, ap),

_DEFUN(__SVFWSCANF_R, (rptr, fp, fmt0, ap),

       struct _reent *rptr _AND

       struct _reent *rptr _AND

       register FILE *fp   _AND

       register FILE *fp   _AND

       wchar_t _CONST *fmt0   _AND

       wchar_t _CONST *fmt0   _AND

       va_list ap)

       va_list ap)

{

{

  register wchar_t *fmt = (wchar_t *) fmt0;

  register wchar_t *fmt = (wchar_t *) fmt0;

  register wint_t c;            /* character from format, or conversion */

  register wint_t c;            /* character from format, or conversion */

  register size_t width;        /* field width, or 0 */

  register size_t width;        /* field width, or 0 */

  register wchar_t *p = NULL;   /* points into all kinds of strings */

  register wchar_t *p = NULL;   /* points into all kinds of strings */

  register int n;               /* handy integer */

  register int n;               /* handy integer */

  register int flags;           /* flags as defined above */

  register int flags;           /* flags as defined above */

  register wchar_t *p0;         /* saves original value of p when necessary */

  register wchar_t *p0;         /* saves original value of p when necessary */

  int nassigned;                /* number of fields assigned */

  int nassigned;                /* number of fields assigned */

  int nread;                    /* number of characters consumed from fp */

  int nread;                    /* number of characters consumed from fp */

#ifndef _NO_POS_ARGS

#ifndef _NO_POS_ARGS

  int N;                        /* arg number */

  int N;                        /* arg number */

  int arg_index = 0;             /* index into args processed directly */

  int arg_index = 0;             /* index into args processed directly */

  int numargs = 0;               /* number of varargs read */

  int numargs = 0;               /* number of varargs read */

  void *args[MAX_POS_ARGS];     /* positional args read */

  void *args[MAX_POS_ARGS];     /* positional args read */

  int is_pos_arg;               /* is current format positional? */

  int is_pos_arg;               /* is current format positional? */

#endif

#endif

  int base = 0;                  /* base argument to wcstol/wcstoul */

  int base = 0;                  /* base argument to wcstol/wcstoul */

  mbstate_t mbs;                /* value to keep track of multibyte state */

  mbstate_t mbs;                /* value to keep track of multibyte state */

  #define CCFN_PARAMS   _PARAMS((struct _reent *, const wchar_t *, wchar_t **, int))

  #define CCFN_PARAMS   _PARAMS((struct _reent *, const wchar_t *, wchar_t **, int))

  unsigned long (*ccfn)CCFN_PARAMS=0;    /* conversion function (wcstol/wcstoul) */

  unsigned long (*ccfn)CCFN_PARAMS=0;    /* conversion function (wcstol/wcstoul) */

  wchar_t buf[BUF];             /* buffer for numeric conversions */

  wchar_t buf[BUF];             /* buffer for numeric conversions */

  const wchar_t *ccls;          /* character class start */

  const wchar_t *ccls;          /* character class start */

  const wchar_t *ccle;          /* character class end */

  const wchar_t *ccle;          /* character class end */

  int cclcompl = 0;             /* ccl is complemented? */

  int cclcompl = 0;             /* ccl is complemented? */

  wint_t wi;                    /* handy wint_t */

  wint_t wi;                    /* handy wint_t */

  char *mbp = NULL;             /* multibyte string pointer for %c %s %[ */

  char *mbp = NULL;             /* multibyte string pointer for %c %s %[ */

  size_t nconv;                 /* number of bytes in mb. conversion */

  size_t nconv;                 /* number of bytes in mb. conversion */

  char mbbuf[MB_LEN_MAX];       /* temporary mb. character buffer */

  char mbbuf[MB_LEN_MAX];       /* temporary mb. character buffer */

  char *cp;

  char *cp;

  short *sp;

  short *sp;

  int *ip;

  int *ip;

#ifdef FLOATING_POINT

#ifdef FLOATING_POINT

  float *flp;

  float *flp;

  _LONG_DOUBLE *ldp;

  _LONG_DOUBLE *ldp;

  double *dp;

  double *dp;

#endif

#endif

  long *lp;

  long *lp;

#ifndef _NO_LONGLONG

#ifndef _NO_LONGLONG

  long long *llp;

  long long *llp;

#endif

#endif

  /* `basefix' is used to avoid `if' tests in the integer scanner */

  /* `basefix' is used to avoid `if' tests in the integer scanner */

  static _CONST short basefix[17] =

  static _CONST short basefix[17] =

    {10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};

    {10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};

  /* Macro to support positional arguments */

  /* Macro to support positional arguments */

#ifndef _NO_POS_ARGS

#ifndef _NO_POS_ARGS

# define GET_ARG(n, ap, type)                                   \

# define GET_ARG(n, ap, type)                                   \

  ((type) (is_pos_arg                                           \

  ((type) (is_pos_arg                                           \

           ? (n < numargs                                       \

           ? (n < numargs                                       \

              ? args[n]                                         \

              ? args[n]                                         \

              : get_arg (n, &ap, &numargs, args))               \

              : get_arg (n, &ap, &numargs, args))               \

           : (arg_index++ < numargs                             \

           : (arg_index++ < numargs                             \

              ? args[n]                                         \

              ? args[n]                                         \

              : (numargs < MAX_POS_ARGS                         \

              : (numargs < MAX_POS_ARGS                         \

                 ? args[numargs++] = va_arg (ap, void *)        \

                 ? args[numargs++] = va_arg (ap, void *)        \

                 : va_arg (ap, void *)))))

                 : va_arg (ap, void *)))))

#else

#else

# define GET_ARG(n, ap, type) (va_arg (ap, type))

# define GET_ARG(n, ap, type) (va_arg (ap, type))

#endif

#endif

  __sfp_lock_acquire ();

  __sfp_lock_acquire ();

  _flockfile (fp);

  _flockfile (fp);

  ORIENT (fp, 1);

  ORIENT (fp, 1);

  nassigned = 0;

  nassigned = 0;

  nread = 0;

  nread = 0;

  ccls = ccle = NULL;

  ccls = ccle = NULL;

  for (;;)

  for (;;)

    {

    {

      c = *fmt++;

      c = *fmt++;

      if (c == L'\0')

      if (c == L'\0')

        goto all_done;

        goto all_done;

      if (iswspace (c))

      if (iswspace (c))

        {

        {

          while ((c = _fgetwc_r (rptr, fp)) != WEOF && iswspace(c))

          while ((c = _fgetwc_r (rptr, fp)) != WEOF && iswspace(c))

            ;

            ;

          if (c != WEOF)

          if (c != WEOF)

            _ungetwc_r (rptr, c, fp);

            _ungetwc_r (rptr, c, fp);

          continue;

          continue;

        }

        }

      if (c != L'%')

      if (c != L'%')

        goto literal;

        goto literal;

      width = 0;

      width = 0;

      flags = 0;

      flags = 0;

#ifndef _NO_POS_ARGS

#ifndef _NO_POS_ARGS

      N = arg_index;

      N = arg_index;

      is_pos_arg = 0;

      is_pos_arg = 0;

#endif

#endif

      /*

      /*

       * switch on the format.  continue if done; break once format

       * switch on the format.  continue if done; break once format

       * type is derived.

       * type is derived.

       */

       */

    again:

    again:

      c = *fmt++;

      c = *fmt++;

      switch (c)

      switch (c)

        {

        {

        case L'%':

        case L'%':

        literal:

        literal:

          if ((wi = _fgetwc_r (rptr, fp)) == WEOF)

          if ((wi = _fgetwc_r (rptr, fp)) == WEOF)

            goto input_failure;

            goto input_failure;

          if (wi != c)

          if (wi != c)

            {

            {

              _ungetwc_r (rptr, wi, fp);

              _ungetwc_r (rptr, wi, fp);

              goto input_failure;

              goto input_failure;

            }

            }

          nread++;

          nread++;

          continue;

          continue;

        case L'*':

        case L'*':

          flags |= SUPPRESS;

          flags |= SUPPRESS;

          goto again;

          goto again;

        case L'l':

        case L'l':

#if defined _WANT_IO_C99_FORMATS || !defined _NO_LONGLONG

#if defined _WANT_IO_C99_FORMATS || !defined _NO_LONGLONG

          if (*fmt == L'l')     /* Check for 'll' = long long (SUSv3) */

          if (*fmt == L'l')     /* Check for 'll' = long long (SUSv3) */

            {

            {

              ++fmt;

              ++fmt;

              flags |= LONGDBL;

              flags |= LONGDBL;

            }

            }

          else

          else

#endif

#endif

            flags |= LONG;

            flags |= LONG;

          goto again;

          goto again;

        case L'L':

        case L'L':

          flags |= LONGDBL;

          flags |= LONGDBL;

          goto again;

          goto again;

        case L'h':

        case L'h':

#ifdef _WANT_IO_C99_FORMATS

#ifdef _WANT_IO_C99_FORMATS

          if (*fmt == 'h')      /* Check for 'hh' = char int (SUSv3) */

          if (*fmt == 'h')      /* Check for 'hh' = char int (SUSv3) */

            {

            {

              ++fmt;

              ++fmt;

              flags |= CHAR;

              flags |= CHAR;

            }

            }

          else

          else

#endif

#endif

            flags |= SHORT;

            flags |= SHORT;

          goto again;

          goto again;

#ifdef _WANT_IO_C99_FORMATS

#ifdef _WANT_IO_C99_FORMATS

        case L'j': /* intmax_t */

        case L'j': /* intmax_t */

          if (sizeof (intmax_t) == sizeof (long))

          if (sizeof (intmax_t) == sizeof (long))

            flags |= LONG;

            flags |= LONG;

          else

          else

            flags |= LONGDBL;

            flags |= LONGDBL;

          goto again;

          goto again;

        case L't': /* ptrdiff_t */

        case L't': /* ptrdiff_t */

          if (sizeof (ptrdiff_t) < sizeof (int))

          if (sizeof (ptrdiff_t) < sizeof (int))

            /* POSIX states ptrdiff_t is 16 or more bits, as

            /* POSIX states ptrdiff_t is 16 or more bits, as

               is short.  */

               is short.  */

            flags |= SHORT;

            flags |= SHORT;

          else if (sizeof (ptrdiff_t) == sizeof (int))

          else if (sizeof (ptrdiff_t) == sizeof (int))

            /* no flag needed */;

            /* no flag needed */;

          else if (sizeof (ptrdiff_t) <= sizeof (long))

          else if (sizeof (ptrdiff_t) <= sizeof (long))

            flags |= LONG;

            flags |= LONG;

          else

          else

            /* POSIX states that at least one programming

            /* POSIX states that at least one programming

               environment must support ptrdiff_t no wider than

               environment must support ptrdiff_t no wider than

               long, but that means other environments can

               long, but that means other environments can

               have ptrdiff_t as wide as long long.  */

               have ptrdiff_t as wide as long long.  */

            flags |= LONGDBL;

            flags |= LONGDBL;

          goto again;

          goto again;

        case L'z': /* size_t */

        case L'z': /* size_t */

          if (sizeof (size_t) < sizeof (int))

          if (sizeof (size_t) < sizeof (int))

            /* POSIX states size_t is 16 or more bits, as is short.  */

            /* POSIX states size_t is 16 or more bits, as is short.  */

            flags |= SHORT;

            flags |= SHORT;

          else if (sizeof (size_t) == sizeof (int))

          else if (sizeof (size_t) == sizeof (int))

            /* no flag needed */;

            /* no flag needed */;

          else if (sizeof (size_t) <= sizeof (long))

          else if (sizeof (size_t) <= sizeof (long))

            flags |= LONG;

            flags |= LONG;

          else

          else

            /* POSIX states that at least one programming

            /* POSIX states that at least one programming

               environment must support size_t no wider than

               environment must support size_t no wider than

               long, but that means other environments can

               long, but that means other environments can

               have size_t as wide as long long.  */

               have size_t as wide as long long.  */

            flags |= LONGDBL;

            flags |= LONGDBL;

          goto again;

          goto again;

#endif /* _WANT_IO_C99_FORMATS */

#endif /* _WANT_IO_C99_FORMATS */

        case L'0':

        case L'0':

        case L'1':

        case L'1':

        case L'2':

        case L'2':

        case L'3':

        case L'3':

        case L'4':

        case L'4':

        case L'5':

        case L'5':

        case L'6':

        case L'6':

        case L'7':

        case L'7':

        case L'8':

        case L'8':

        case L'9':

        case L'9':

          width = width * 10 + c - L'0';

          width = width * 10 + c - L'0';

          goto again;

          goto again;

#ifndef _NO_POS_ARGS

#ifndef _NO_POS_ARGS

        case L'$':

        case L'$':

          if (width <= MAX_POS_ARGS)

          if (width <= MAX_POS_ARGS)

            {

            {

              N = width - 1;

              N = width - 1;

              is_pos_arg = 1;

              is_pos_arg = 1;

              width = 0;

              width = 0;

              goto again;

              goto again;

            }

            }

          rptr->_errno = EINVAL;

          rptr->_errno = EINVAL;

          goto input_failure;

          goto input_failure;

#endif /* !_NO_POS_ARGS */

#endif /* !_NO_POS_ARGS */

        case L'd':

        case L'd':

          c = CT_INT;

          c = CT_INT;

          ccfn = (unsigned long (*)CCFN_PARAMS)_wcstol_r;

          ccfn = (unsigned long (*)CCFN_PARAMS)_wcstol_r;

          base = 10;

          base = 10;

          break;

          break;

        case L'i':

        case L'i':

          c = CT_INT;

          c = CT_INT;

          ccfn = (unsigned long (*)CCFN_PARAMS)_wcstol_r;

          ccfn = (unsigned long (*)CCFN_PARAMS)_wcstol_r;

          base = 0;

          base = 0;

          break;

          break;

        case L'o':

        case L'o':

          c = CT_INT;

          c = CT_INT;

          ccfn = _wcstoul_r;

          ccfn = _wcstoul_r;

          base = 8;

          base = 8;

          break;

          break;

        case L'u':

        case L'u':

          c = CT_INT;

          c = CT_INT;