Commit: 96666e31b322ff73f7ad6f70b0c556b25bbb9c2d - mingw-org-wsl (git)

The MinGW.org Windows System Libraries

Commit MetaInfo

• Revisão: 96666e31b322ff73f7ad6f70b0c556b25bbb9c2d (tree)
• Hora: 2016-10-31 04:12:05
• Autor: Keith Marshall <keithmarshall@user...>
• Commiter: Keith Marshall

Mensagem de Log

Merge post 2016-10-18 updates from legacy branch.

Mudança Sumário

• modified: mingwrt/ChangeLog
• modified: mingwrt/include/io.h
• modified: mingwrt/include/wchar.h
• modified: mingwrt/mingwex/stdio/pformat.c

Diff

--- a/mingwrt/ChangeLog
+++ b/mingwrt/ChangeLog
@@ -1,3 +1,31 @@
[phone]  Keith Marshall  <[e-mail]>
+
+	Merge post 2016-10-18 updates from legacy branch.
+
+	* include/io.h include/wchar.h: Updated.
+	* mingwex/stdio/pformat.c: Likewise.
+
[phone]  Keith Marshall  <[e-mail]>
+
+	Work around MSDN inconsistencies in _finddata_t naming.
+
+	* include/io.h (_finddata64_t, _wfinddata64_): Define them
+	respectively as aberrant alternative data type names for each of...
+	(__finddata64_t, __wfinddata64_t): ...these original names.
+	(_wfinddata32_t): Similarly, define this with...
+	(__wfinddata32_t): ...this alternative name.
+
+	* include/wchar.h (_wfinddata32_t): Correct references in comments.
+
[phone]  Keith Marshall  <[e-mail]>
+
+	Fix a potentially infinite printf() format conversion loop.
+
+	* mingwex/stdio/pformat.c (__pformat_emit_xfloat)
+	[value.__pformat_fpreg_mantissa == 0]: Do not attempt to normalize
+	it; there are no 1-bits to promote, so repeated shifting until one
+	appears in most significant position will never terminate.
+
 2016-10-18  Keith Marshall  <[e-mail]>
 
 	Merge mingwrt-3.22.4 updates into 5.0-active branch.

--- a/mingwrt/include/io.h
+++ b/mingwrt/include/io.h
@@ -221,6 +221,12 @@ int _findnexti64 (intptr_t, struct _finddatai64_t *);
  * to the original generic _findfirst()/_findnext() implementation).
  */
 struct __finddata64_t __struct_finddata_t (__time64_t, __int64);
+/*
+ * Some MSDN documents, (particularly more recent documents), may
+ * inconsistently refer to this structural type by the anomalous
+ * name of _finddata64_t; support this anomaly.
+ */
+#define _finddata64_t  __finddata64_t
 
 _CRTIMP __cdecl __MINGW_NOTHROW
 intptr_t _findfirst64 (const char *, struct __finddata64_t *);
@@ -360,6 +366,13 @@ int _wfindnexti64 (intptr_t, struct _wfinddatai64_t *);
  * MSVCRT.DLL, after it originally appeared in MSVCR61.DLL.
  */
 struct __wfinddata64_t __struct_finddata_t (__time64_t, __int64);
+/*
+ * As in the case of the __finddata64_t structure, some MSDN
+ * documents, (particularly more recent documents), may refer
+ * to __wfinddata64_t by the inconsistently anomalous name of
+ * _wfinddata64_t; also support this anomaly.
+ */
+#define _wfinddata64_t  __wfinddata64_t
 
 _CRTIMP __cdecl __MINGW_NOTHROW
 intptr_t _wfindfirst64 (const wchar_t *, struct __wfinddata64_t *);
@@ -372,15 +385,26 @@ int _wfindnext64 (intptr_t, struct __wfinddata64_t *);
  * exclusive to it and its later derivatives; none of these are
  * available in any version of MSVCRT.DLL.
  */
-struct __wfinddata32_t __struct_finddata_t (__time32_t, __int32);
+struct _wfinddata32_t    __struct_finddata_t (__time32_t, __int32);
 struct _wfinddata32i64_t __struct_finddata_t (__time32_t, __int64);
 struct _wfinddata64i32_t __struct_finddata_t (__time64_t, __int32);
+/*
+ * As in the __finddata64_t vs. _finddata64_t, and __wfinddata64_t
+ * vs. _wfinddata64_t anomalous cases, there is at least one historic
+ * MSDN reference to a __wfinddata32_t structural type, in a context
+ * where _wfinddata32_t may be expected.  In this case, it appears
+ * that __wfinddata32_t is the anomaly, and that it may be peculiar
+ * to the VS-2005 documentation; nevertheless, the corresponding
+ * definition is provided here, for the possible convenience of
+ * any user who may depend on it, (but please avoid it).
+ */
+#define __wfinddata32_t  _wfinddata32_t
 
 _CRTIMP __cdecl __MINGW_NOTHROW
-intptr_t _wfindfirst32 (const wchar_t *, struct __wfinddata32_t *);
+intptr_t _wfindfirst32 (const wchar_t *, struct _wfinddata32_t *);
 
 _CRTIMP __cdecl __MINGW_NOTHROW
-int _wfindnext32 (intptr_t, struct __wfinddata32_t *);
+int _wfindnext32 (intptr_t, struct _wfinddata32_t *);
 
 _CRTIMP __cdecl __MINGW_NOTHROW
 intptr_t _wfindfirst32i64 (const wchar_t *, struct _wfinddata32i64_t *);
@@ -406,11 +430,11 @@ int _wfindnext64i32 (intptr_t, struct _wfinddata64i32_t *);
  */
 __CRT_ALIAS __cdecl __MINGW_NOTHROW
 intptr_t _wfindfirst (const wchar_t *__filespec, struct _wfinddata_t *__search)
-{ return _wfindfirst32 (__filespec, (struct __wfinddata32_t *)(__search)); }
+{ return _wfindfirst32 (__filespec, (struct _wfinddata32_t *)(__search)); }
 
 __CRT_ALIAS __cdecl __MINGW_NOTHROW
 int _wfindnext (intptr_t __handle, struct _wfinddata_t *__search)
-{ return _wfindnext32 (__handle, (struct __wfinddata32_t *)(__search)); }
+{ return _wfindnext32 (__handle, (struct _wfinddata32_t *)(__search)); }
 
 __CRT_ALIAS __cdecl __MINGW_NOTHROW
 intptr_t _wfindfirsti64 (const wchar_t *__filespec, struct _wfinddatai64_t *__search)

--- a/mingwrt/include/wchar.h
+++ b/mingwrt/include/wchar.h
@@ -268,8 +268,8 @@
  * ...and these, which are only available in the non-free run-times
  * from MSVCR80.DLL onwards:
  *
- *  intptr_t _wfindfirst32 (wchar_t *, struct __wfinddata32_t *);
- *  int _wfindnext32 (intptr_t, struct __wfinddata32_t *);
+ *  intptr_t _wfindfirst32 (wchar_t *, struct _wfinddata32_t *);
+ *  int _wfindnext32 (intptr_t, struct _wfinddata32_t *);
  *
  *  intptr_t _wfindfirst32i64 (wchar_t *, struct _wfinddata32i64_t *);
  *  int _wfindnext32i64 (intptr_t, struct _wfinddata32i64_t *);

--- a/mingwrt/mingwex/stdio/pformat.c
+++ b/mingwrt/mingwex/stdio/pformat.c
@@ -1629,121 +1629,126 @@ void __pformat_emit_xfloat( __pformat_fpreg_t value, __pformat_t *stream )
    * be placed before the radix point, leaving at most 15 digits
    * to satisfy any requested precision; thus...
    */
-  if( (stream->precision >= 0) && (stream->precision < 15) )
+  if( value.__pformat_fpreg_mantissa )
   {
-    /* When the user specifies a precision within this range,
-     * we want to adjust the mantissa, to retain just the number
-     * of digits required, rounding up when the high bit of the
-     * leftmost discarded digit is set; (mask of 0x08 accounts
-     * for exactly one digit discarded, shifting 4 bits per
-     * digit, with up to 14 additional digits, to consume the
-     * full availability of 15 precision digits).
-     *
-     * However, before we perform the rounding operation, we
-     * normalise the mantissa, shifting it to the left by as many
-     * bit positions may be necessary, until its highest order bit
-     * is set, thus preserving the maximum number of bits in the
-     * rounded result as possible.
-     */
-    while( value.__pformat_fpreg_mantissa < (LLONG_MAX + 1ULL) )
-      value.__pformat_fpreg_mantissa <<= 1;
-
-    /* We then shift the mantissa one bit position back to the
-     * right, to guard against possible overflow when the rounding
-     * adjustment is added.
-     */
-    value.__pformat_fpreg_mantissa >>= 1;
-
-    /* We now add the rounding adjustment, noting that to keep the
-     * 0x08 mask aligned with the shifted mantissa, we also need to
-     * shift it right by one bit initially, changing its starting
-     * value to 0x04...
-     */
-    value.__pformat_fpreg_mantissa += 0x04LL << (4 * (14 - stream->precision));
-    if( (value.__pformat_fpreg_mantissa & (LLONG_MAX + 1ULL)) == 0ULL )
-      /*
-       * When the rounding adjustment would not have overflowed,
-       * then we shift back to the left again, to fill the vacated
-       * bit we reserved to accommodate the carry.
+    /* ...provided the mantissa is non-zero...
+     */
+    if( (stream->precision >= 0) && (stream->precision < 15) )
+    {
+      /* ...when the user specifies a precision within this range,
+       * we want to adjust the mantissa, to retain just the number
+       * of digits required, rounding up when the high bit of the
+       * leftmost discarded digit is set; (mask of 0x08 accounts
+       * for exactly one digit discarded, shifting 4 bits per
+       * digit, with up to 14 additional digits, to consume the
+       * full availability of 15 precision digits).
+       *
+       * However, before we perform the rounding operation, we
+       * normalise the mantissa, shifting it to the left by as many
+       * bit positions may be necessary, until its highest order bit
+       * is set, thus preserving the maximum number of bits in the
+       * rounded result as possible.
        */
-      value.__pformat_fpreg_mantissa <<= 1;
+      while( value.__pformat_fpreg_mantissa < (LLONG_MAX + 1ULL) )
+	value.__pformat_fpreg_mantissa <<= 1;
 
-    else
-      /* Otherwise the rounding adjustment would have overflowed,
-       * so the carry has already filled the vacated bit; the effect
-       * of this is equivalent to an increment of the exponent.
+      /* We then shift the mantissa one bit position back to the
+       * right, to guard against possible overflow when the rounding
+       * adjustment is added.
        */
-      value.__pformat_fpreg_exponent++;
-
-    /* We now complete the rounding to the required precision, by
-     * shifting the unwanted digits out, from the right hand end of
-     * the mantissa.
-     */
-    value.__pformat_fpreg_mantissa >>= 4 * (15 - stream->precision);
-  }
+      value.__pformat_fpreg_mantissa >>= 1;
 
-  /* Encode the significant digits of the mantissa in hexadecimal
-   * ASCII notation, ready for transfer to the output stream...
-   */
-  while( value.__pformat_fpreg_mantissa )
-  {
-    /* taking the rightmost digit in each pass...
-     */
-    int c = value.__pformat_fpreg_mantissa & 0xF;
-    if( c == value.__pformat_fpreg_mantissa )
-    {
-      /* inserting the radix point, when we reach the last,
-       * (i.e. the most significant digit), unless we found no
-       * less significant digits, with no mandatory radix point
-       * inclusion, and no additional required precision...
+      /* We now add the rounding adjustment, noting that to keep the
+       * 0x08 mask aligned with the shifted mantissa, we also need to
+       * shift it right by one bit initially, changing its starting
+       * value to 0x04...
        */
-      if( (p > buf)
-      ||  (stream->flags & PFORMAT_HASHED) || (stream->precision > 0)  )
+      value.__pformat_fpreg_mantissa += 0x04LL << (4 * (14 - stream->precision));
+      if( (value.__pformat_fpreg_mantissa & (LLONG_MAX + 1ULL)) == 0ULL )
 	/*
-	 * Internally, we represent the radix point as an ASCII '.';
-	 * we will replace it with any locale specific alternative,
-	 * at the time of transfer to the ultimate destination.
+	 * When the rounding adjustment would not have overflowed,
+	 * then we shift back to the left again, to fill the vacated
+	 * bit we reserved to accommodate the carry.
 	 */
-	*p++ = '.';
+	value.__pformat_fpreg_mantissa <<= 1;
+
+      else
+	/* Otherwise the rounding adjustment would have overflowed,
+	 * so the carry has already filled the vacated bit; the effect
+	 * of this is equivalent to an increment of the exponent.
+	 */
+	value.__pformat_fpreg_exponent++;
+
+      /* We now complete the rounding to the required precision, by
+       * shifting the unwanted digits out, from the right hand end of
+       * the mantissa.
+       */
+      value.__pformat_fpreg_mantissa >>= 4 * (15 - stream->precision);
+    }
 
-      /* If the most significant hexadecimal digit of the encoded
-       * output value is greater than one, then the indicated value
-       * will appear too large, by an additional binary exponent
-       * corresponding to the number of higher order bit positions
-       * which it occupies...
+    /* Encode the significant digits of the mantissa in hexadecimal
+     * ASCII notation, ready for transfer to the output stream...
+     */
+    while( value.__pformat_fpreg_mantissa )
+    {
+      /* taking the rightmost digit in each pass...
        */
-      while( value.__pformat_fpreg_mantissa > 1 )
+      int c = value.__pformat_fpreg_mantissa & 0xF;
+      if( c == value.__pformat_fpreg_mantissa )
       {
-	/* so reduce the exponent value to compensate...
+	/* inserting the radix point, when we reach the last,
+	 * (i.e. the most significant digit), unless we found no
+	 * less significant digits, with no mandatory radix point
+	 * inclusion, and no additional required precision...
 	 */
-	value.__pformat_fpreg_exponent--;
-	value.__pformat_fpreg_mantissa >>= 1;
+	if( (p > buf)
+	||  (stream->flags & PFORMAT_HASHED) || (stream->precision > 0)  )
+	  /*
+	   * Internally, we represent the radix point as an ASCII '.';
+	   * we will replace it with any locale specific alternative,
+	   * at the time of transfer to the ultimate destination.
+	   */
+	  *p++ = '.';
+
+	/* If the most significant hexadecimal digit of the encoded
+	 * output value is greater than one, then the indicated value
+	 * will appear too large, by an additional binary exponent
+	 * corresponding to the number of higher order bit positions
+	 * which it occupies...
+	 */
+	while( value.__pformat_fpreg_mantissa > 1 )
+	{
+	  /* so reduce the exponent value to compensate...
+	   */
+	  value.__pformat_fpreg_exponent--;
+	  value.__pformat_fpreg_mantissa >>= 1;
+	}
       }
-    }
 
-    else if( stream->precision > 0 )
-      /*
-       * we have not yet fulfilled the desired precision,
-       * and we have not yet found the most significant digit,
-       * so account for the current digit, within the field
-       * width required to meet the specified precision.
-       */
-      stream->precision--;
+      else if( stream->precision > 0 )
+	/*
+	 * we have not yet fulfilled the desired precision,
+	 * and we have not yet found the most significant digit,
+	 * so account for the current digit, within the field
+	 * width required to meet the specified precision.
+	 */
+	stream->precision--;
 
-    if( (c > 0) || (p > buf) || (stream->precision >= 0) )
-      /*
-       * Ignoring insignificant trailing zeros, (unless required to
-       * satisfy specified precision), store the current encoded digit
-       * into the pending output buffer, in LIFO order, and using the
-       * appropriate case for digits in the `A'..`F' range.
-       */
-      *p++ = c > 9 ? (c - 10 + 'A') | (stream->flags & PFORMAT_XCASE) : c + '0';
+      if( (c > 0) || (p > buf) || (stream->precision >= 0) )
+	/*
+	 * Ignoring insignificant trailing zeros, (unless required to
+	 * satisfy specified precision), store the current encoded digit
+	 * into the pending output buffer, in LIFO order, and using the
+	 * appropriate case for digits in the `A'..`F' range.
+	 */
+	*p++ = c > 9 ? (c - 10 + 'A') | (stream->flags & PFORMAT_XCASE) : c + '0';
 
-    /* Shift out the current digit, (4-bit logical shift right),
-     * to align the next more significant digit to be extracted,
-     * and encoded in the next pass.
-     */
-    value.__pformat_fpreg_mantissa >>= 4;
+      /* Shift out the current digit, (4-bit logical shift right),
+       * to align the next more significant digit to be extracted,
+       * and encoded in the next pass.
+       */
+      value.__pformat_fpreg_mantissa >>= 4;
+    }
   }
 
   if( p == buf )