WebSVN – Kolibri OS – Diff – /contrib/sdk/sources/newlib/libc/stdio/vfscanf.c

 #define FLOATING_POINT
 #endif
 #endif
+#ifdef STRING_ONLY
-#ifdef STRING_ONLY
+#undef _newlib_flockfile_start
-#undef _flockfile
+#undef _newlib_flockfile_exit
+#undef _newlib_flockfile_end
-#undef _funlockfile
+#define _newlib_flockfile_start(x) {}
-#define _flockfile(x) {}
+#define _newlib_flockfile_exit(x) {}
-#define _funlockfile(x) {}
+#define _newlib_flockfile_end(x) {}
 #define _ungetc_r _sungetc_r
 #define __srefill_r __ssrefill_r
 #define _fread_r _sfread_r
 #endif
 #ifdef FLOATING_POINT
+#include
 #include
 #include
 /* Currently a test is made to see if long double processing is warranted.
 extern _LONG_DOUBLE _strtold _PARAMS((char *s, char **sptr));
 #endif
-#include "floatio.h"
+#include "floatio.h"
-#if ((MAXEXP+MAXFRACT+3) > MB_LEN_MAX)
-#  define BUF (MAXEXP+MAXFRACT+3)        /* 3 = sign + decimal point + NUL */
-#else
 #  define BUF MB_LEN_MAX
-#endif
+#define BUF (MAXEXP+MAXFRACT+MB_LEN_MAX+2) /* decimal point + sign + NUL */
 /* An upper bound for how long a long prints in decimal.  4 / 13 approximates
 #define	CT_CCL		1	/* %[...] conversion */
 #define	CT_STRING	2	/* %s conversion */
 #define	CT_INT		3	/* integer, i.e., strtol or strtoul */
 #define	CT_FLOAT	4	/* floating, i.e., strtod */
 #if 0
-#define u_char unsigned char
-#endif
-#define u_char char
+#define u_char unsigned char
 #define u_long unsigned long
 #ifndef _NO_LONGLONG
 _DEFUN(VFSCANF, (fp, fmt, ap),
        register FILE *fp _AND
        _CONST char *fmt _AND
        va_list ap)
+{
+  struct _reent *reent = _REENT;
-  CHECK_INIT(_REENT, fp);
+  CHECK_INIT(reent, fp);
-  return __SVFSCANF_R (_REENT, fp, fmt, ap);
+  return __SVFSCANF_R (reent, fp, fmt, ap);
+}
 int
 _DEFUN(__SVFSCANF, (fp, fmt0, ap),
 		 : va_arg (ap, void *)))))
 #else
 # define GET_ARG(n, ap, type) (va_arg (ap, type))
 #endif
-  _flockfile (fp);
+  _newlib_flockfile_start (fp);
   ORIENT (fp, -1);
   for (;;)
+    {
 #ifndef _MB_CAPABLE
       wc = *fmt;
 #else
-      nbytes = __mbtowc (rptr, &wc, fmt, MB_CUR_MAX, __locale_charset (),
+      nbytes = __mbtowc (rptr, &wc, (char *) fmt, MB_CUR_MAX,
-			 &state);
+			 __locale_charset (), &state);
       if (nbytes < 0) {
 	wc = 0xFFFD; /* Unicode replacement character */
 	nbytes = 1;
 	memset (&state, 0, sizeof (state));
+      }
 	  /*
 	   * Disgusting backwards compatibility hacks.	XXX
 	   */
 	case '\0':		/* compat */
-	  _funlockfile (fp);
+	  _newlib_flockfile_exit (fp);
 	  return EOF;
 	default:		/* compat */
 	  long zeroes, exp_adjust;
 	  char *exp_start = NULL;
 	  unsigned width_left = 0;
 	  char nancount = 0;
 	  char infcount = 0;
+	  const char *decpt = _localeconv_r (rptr)->decimal_point;
+#ifdef _MB_CAPABLE
+	  int decptpos = 0;
+#endif
 #ifdef hardway
 	  if (width == 0 || width > sizeof (buf) - 1)
 #else
 	  /* size_t is unsigned, hence this optimisation */
 	  if (width - 1 > sizeof (buf) - 2)
+		    {
 		      infcount = 8;
 		      goto fok;
+		    }
 		  break;
-		case '.':
-		  if (flags & DPTOK)
-		    {
-		      flags &= ~(SIGNOK | DPTOK);
-		      leading_zeroes = zeroes;
-		      goto fok;
-		    }
-		  break;
 		case 'e':
 		case 'E':
 		  /* no exponent without some digits */
 		  if ((flags & (NDIGITS | EXPOK)) == EXPOK
 		      || ((flags & EXPOK) && zeroes))
 			SIGNOK | NDIGITS;
 		      zeroes = 0;
 		      goto fok;
+		    }
 		  break;
+		default:
+#ifndef _MB_CAPABLE
+		  if ((unsigned char) c == (unsigned char) decpt[0]
+		      && (flags & DPTOK))
+		    {
+		      flags &= ~(SIGNOK | DPTOK);
+		      leading_zeroes = zeroes;
+		      goto fok;
+		    }
+		  break;
+#else
+		  if (flags & DPTOK)
+		    {
+		      while ((unsigned char) c
+			     == (unsigned char) decpt[decptpos])
+			{
+			  if (decpt[++decptpos] == '\0')
+			    {
+			      /* We read the complete decpt seq. */
+			      flags &= ~(SIGNOK | DPTOK);
+			      leading_zeroes = zeroes;
+			      p = stpncpy (p, decpt, decptpos);
+			      decptpos = 0;
+			      goto fskip;
+			    }
+			  ++nread;
+			  if (--fp->_r > 0)
+			    fp->_p++;
+			  else if (__srefill_r (rptr, fp))
+			    break;		/* EOF */
+			  c = *fp->_p;
+			}
+		      if (decptpos > 0)
+			{
+			  /* We read part of a multibyte decimal point,
+			     but the rest is invalid or we're at EOF,
+			     so back off. */
+			  while (decptpos-- > 0)
+			    {
+			      _ungetc_r (rptr, (unsigned char) decpt[decptpos],
+					 fp);
+			      --nread;
+			    }
+			}
+		    }
+		  break;
+#endif
+		}
 	      break;
 	    fok:
 	      *p++ = c;
 	    fskip:
 input_failure:
   /* On read failure, return EOF failure regardless of matches; errno
      should have been set prior to here.  On EOF failure (including
      invalid format string), return EOF if no matches yet, else number
      of matches made prior to failure.  */
-  _funlockfile (fp);
+  _newlib_flockfile_exit (fp);
   return nassigned && !(fp->_flags & __SERR) ? nassigned : EOF;
 match_failure:
 all_done:
   /* Return number of matches, which can be 0 on match failure.  */
-  _funlockfile (fp);
+  _newlib_flockfile_end (fp);
   return nassigned;
+}
 #ifndef _NO_POS_ARGS

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/newlib/libc/stdio/vfscanf.c – Rev 4874 → 4921