Restoring authorship annotation for <mcheshkov@yandex-team.ru>. Commit 1 of 2.

18 files changed, 4900 insertions, 4900 deletions

diff --git a/contrib/libs/icu/io/locbund.cpp b/contrib/libs/icu/io/locbund.cpp
index 46c97bc043..0f7f52844f 100644
--- a/contrib/libs/icu/io/locbund.cpp
+++ b/contrib/libs/icu/io/locbund.cpp
@@ -1,4 +1,4 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2016 and later: Unicode, Inc. and others. 
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 *******************************************************************************
@@ -47,7 +47,7 @@ U_CDECL_END
 
 static inline UNumberFormat * copyInvariantFormatter(ULocaleBundle *result, UNumberFormatStyle style) {
     U_NAMESPACE_USE
-    static UMutex gLock;
+    static UMutex gLock; 
     Mutex lock(&gLock);
     if (result->fNumberFormat[style-1] == NULL) {
         if (gPosixNumberFormat[style-1] == NULL) {
diff --git a/contrib/libs/icu/io/locbund.h b/contrib/libs/icu/io/locbund.h
index 5879e28f01..2f22fc8a37 100644
--- a/contrib/libs/icu/io/locbund.h
+++ b/contrib/libs/icu/io/locbund.h
@@ -1,4 +1,4 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2016 and later: Unicode, Inc. and others. 
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 *******************************************************************************
diff --git a/contrib/libs/icu/io/sprintf.cpp b/contrib/libs/icu/io/sprintf.cpp
index 3a593abb48..726fd599fd 100644
--- a/contrib/libs/icu/io/sprintf.cpp
+++ b/contrib/libs/icu/io/sprintf.cpp
@@ -1,262 +1,262 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-*
-*   Copyright (C) 2001-2014, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*
-******************************************************************************
-*
-* File sprintf.c
-*
-* Modification History:
-*
-*   Date        Name            Description
-*   02/08/2001  george          Creation. Copied from uprintf.c
-*   03/27/2002  Mark Schneckloth Many fixes regarding alignment, null termination
-*       (mschneckloth@atomz.com) and other various problems.
-*   08/07/2003  george          Reunify printf implementations
-*******************************************************************************
-*/
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_CONVERSION
-
-#include "unicode/ustdio.h"
-#include "unicode/ustring.h"
-#include "unicode/putil.h"
-
-#include "uprintf.h"
-#include "locbund.h"
-
-#include "cmemory.h"
-#include <ctype.h>
-
-/* u_minstrncpy copies the minimum number of code units of (count or output->available) */
-static int32_t
-u_sprintf_write(void        *context,
-                const UChar *str,
-                int32_t     count)
-{
-    u_localized_print_string *output = (u_localized_print_string *)context;
-    int32_t size = ufmt_min(count, output->available);
-
-    u_strncpy(output->str + (output->len - output->available), str, size);
-    output->available -= size;
-    return size;
-}
-
-static int32_t
-u_sprintf_pad_and_justify(void                        *context,
-                          const u_printf_spec_info    *info,
-                          const UChar                 *result,
-                          int32_t                     resultLen)
-{
-    u_localized_print_string *output = (u_localized_print_string *)context;
-    int32_t written = 0;
-    int32_t lengthOfResult = resultLen;
-
-    resultLen = ufmt_min(resultLen, output->available);
-
-    /* pad and justify, if needed */
-    if(info->fWidth != -1 && resultLen < info->fWidth) {
-        int32_t paddingLeft = info->fWidth - resultLen;
-        int32_t outputPos = output->len - output->available;
-  
-        if (paddingLeft + resultLen > output->available) {
-            paddingLeft = output->available - resultLen;
-            if (paddingLeft < 0) {
-                paddingLeft = 0;
-            }
-            /* paddingLeft = output->available - resultLen;*/
-        }
-        written += paddingLeft;
-
-        /* left justify */
-        if(info->fLeft) {
-            written += u_sprintf_write(output, result, resultLen);
-            u_memset(&output->str[outputPos + resultLen], info->fPadChar, paddingLeft);
-            output->available -= paddingLeft;
-        }
-        /* right justify */
-        else {
-            u_memset(&output->str[outputPos], info->fPadChar, paddingLeft);
-            output->available -= paddingLeft;
-            written += u_sprintf_write(output, result, resultLen);
-        }
-    }
-    /* just write the formatted output */
-    else {
-        written = u_sprintf_write(output, result, resultLen);
-    }
-    
-    if (written >= 0 && lengthOfResult > written) {
-    	return lengthOfResult;
-    }
-
-    return written;
-}
-
-U_CAPI int32_t U_EXPORT2
-u_sprintf(UChar       *buffer,
-          const char    *patternSpecification,
-          ... )
-{
-    va_list ap;
-    int32_t written;
-
-    va_start(ap, patternSpecification);
-    written = u_vsnprintf(buffer, INT32_MAX, patternSpecification, ap);
-    va_end(ap);
-
-    return written;
-}
-
-U_CAPI int32_t U_EXPORT2
-u_sprintf_u(UChar     *buffer,
-            const UChar    *patternSpecification,
-            ... )
-{
-    va_list ap;
-    int32_t written;
-
-    va_start(ap, patternSpecification);
-    written = u_vsnprintf_u(buffer, INT32_MAX, patternSpecification, ap);
-    va_end(ap);
-
-    return written;
-}
-
-U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_vsprintf(UChar       *buffer,
-           const char     *patternSpecification,
-           va_list         ap)
-{
-    return u_vsnprintf(buffer, INT32_MAX, patternSpecification, ap);
-}
-
-U_CAPI int32_t U_EXPORT2
-u_snprintf(UChar       *buffer,
-           int32_t         count,
-           const char    *patternSpecification,
-           ... )
-{
-    va_list ap;
-    int32_t written;
-
-    va_start(ap, patternSpecification);
-    written = u_vsnprintf(buffer, count, patternSpecification, ap);
-    va_end(ap);
-
-    return written;
-}
-
-U_CAPI int32_t U_EXPORT2
-u_snprintf_u(UChar     *buffer,
-             int32_t        count,
-             const UChar    *patternSpecification,
-             ... )
-{
-    va_list ap;
-    int32_t written;
-
-    va_start(ap, patternSpecification);
-    written = u_vsnprintf_u(buffer, count, patternSpecification, ap);
-    va_end(ap);
-
-    return written;
-}
-
-U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_vsnprintf(UChar       *buffer,
-            int32_t         count,
-            const char     *patternSpecification,
-            va_list         ap)
-{
-    int32_t written;
-    UChar *pattern;
-    UChar patBuffer[UFMT_DEFAULT_BUFFER_SIZE];
-    int32_t size = (int32_t)strlen(patternSpecification) + 1;
-
-    /* convert from the default codepage to Unicode */
-    if (size >= (int32_t)MAX_UCHAR_BUFFER_SIZE(patBuffer)) {
-        pattern = (UChar *)uprv_malloc(size * sizeof(UChar));
-        if(pattern == 0) {
-            return 0;
-        }
-    }
-    else {
-        pattern = patBuffer;
-    }
-    u_charsToUChars(patternSpecification, pattern, size);
-
-    /* do the work */
-    written = u_vsnprintf_u(buffer, count, pattern, ap);
-
-    /* clean up */
-    if (pattern != patBuffer) {
-        uprv_free(pattern);
-    }
-
-    return written;
-}
-
+// © 2016 and later: Unicode, Inc. and others. 
+// License & terms of use: http://www.unicode.org/copyright.html 
+/* 
+****************************************************************************** 
+* 
+*   Copyright (C) 2001-2014, International Business Machines 
+*   Corporation and others.  All Rights Reserved. 
+* 
+****************************************************************************** 
+* 
+* File sprintf.c 
+* 
+* Modification History: 
+* 
+*   Date        Name            Description 
+*   02/08/2001  george          Creation. Copied from uprintf.c 
+*   03/27/2002  Mark Schneckloth Many fixes regarding alignment, null termination 
+*       (mschneckloth@atomz.com) and other various problems. 
+*   08/07/2003  george          Reunify printf implementations 
+******************************************************************************* 
+*/ 
+ 
+#include "unicode/utypes.h" 
+ 
+#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_CONVERSION 
+ 
+#include "unicode/ustdio.h" 
+#include "unicode/ustring.h" 
+#include "unicode/putil.h" 
+ 
+#include "uprintf.h" 
+#include "locbund.h" 
+ 
+#include "cmemory.h" 
+#include <ctype.h> 
+ 
+/* u_minstrncpy copies the minimum number of code units of (count or output->available) */ 
+static int32_t 
+u_sprintf_write(void        *context, 
+                const UChar *str, 
+                int32_t     count) 
+{ 
+    u_localized_print_string *output = (u_localized_print_string *)context; 
+    int32_t size = ufmt_min(count, output->available); 
+ 
+    u_strncpy(output->str + (output->len - output->available), str, size); 
+    output->available -= size; 
+    return size; 
+} 
+ 
+static int32_t 
+u_sprintf_pad_and_justify(void                        *context, 
+                          const u_printf_spec_info    *info, 
+                          const UChar                 *result, 
+                          int32_t                     resultLen) 
+{ 
+    u_localized_print_string *output = (u_localized_print_string *)context; 
+    int32_t written = 0; 
+    int32_t lengthOfResult = resultLen; 
+ 
+    resultLen = ufmt_min(resultLen, output->available); 
+ 
+    /* pad and justify, if needed */ 
+    if(info->fWidth != -1 && resultLen < info->fWidth) { 
+        int32_t paddingLeft = info->fWidth - resultLen; 
+        int32_t outputPos = output->len - output->available; 
+   
+        if (paddingLeft + resultLen > output->available) { 
+            paddingLeft = output->available - resultLen; 
+            if (paddingLeft < 0) { 
+                paddingLeft = 0; 
+            } 
+            /* paddingLeft = output->available - resultLen;*/ 
+        } 
+        written += paddingLeft; 
+ 
+        /* left justify */ 
+        if(info->fLeft) { 
+            written += u_sprintf_write(output, result, resultLen); 
+            u_memset(&output->str[outputPos + resultLen], info->fPadChar, paddingLeft); 
+            output->available -= paddingLeft; 
+        } 
+        /* right justify */ 
+        else { 
+            u_memset(&output->str[outputPos], info->fPadChar, paddingLeft); 
+            output->available -= paddingLeft; 
+            written += u_sprintf_write(output, result, resultLen); 
+        } 
+    } 
+    /* just write the formatted output */ 
+    else { 
+        written = u_sprintf_write(output, result, resultLen); 
+    } 
+     
+    if (written >= 0 && lengthOfResult > written) { 
+    	return lengthOfResult; 
+    } 
+ 
+    return written; 
+} 
+ 
+U_CAPI int32_t U_EXPORT2 
+u_sprintf(UChar       *buffer, 
+          const char    *patternSpecification, 
+          ... ) 
+{ 
+    va_list ap; 
+    int32_t written; 
+ 
+    va_start(ap, patternSpecification); 
+    written = u_vsnprintf(buffer, INT32_MAX, patternSpecification, ap); 
+    va_end(ap); 
+ 
+    return written; 
+} 
+ 
 U_CAPI int32_t U_EXPORT2 
-u_vsprintf_u(UChar       *buffer, 
-             const UChar *patternSpecification, 
-             va_list     ap) 
+u_sprintf_u(UChar     *buffer, 
+            const UChar    *patternSpecification, 
+            ... ) 
+{ 
+    va_list ap; 
+    int32_t written; 
+ 
+    va_start(ap, patternSpecification); 
+    written = u_vsnprintf_u(buffer, INT32_MAX, patternSpecification, ap); 
+    va_end(ap); 
+ 
+    return written; 
+} 
+ 
+U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_vsprintf(UChar       *buffer, 
+           const char     *patternSpecification, 
+           va_list         ap) 
+{ 
+    return u_vsnprintf(buffer, INT32_MAX, patternSpecification, ap); 
+} 
+ 
+U_CAPI int32_t U_EXPORT2 
+u_snprintf(UChar       *buffer, 
+           int32_t         count, 
+           const char    *patternSpecification, 
+           ... ) 
+{ 
+    va_list ap; 
+    int32_t written; 
+ 
+    va_start(ap, patternSpecification); 
+    written = u_vsnprintf(buffer, count, patternSpecification, ap); 
+    va_end(ap); 
+ 
+    return written; 
+} 
+ 
+U_CAPI int32_t U_EXPORT2 
+u_snprintf_u(UChar     *buffer, 
+             int32_t        count, 
+             const UChar    *patternSpecification, 
+             ... ) 
+{ 
+    va_list ap; 
+    int32_t written; 
+ 
+    va_start(ap, patternSpecification); 
+    written = u_vsnprintf_u(buffer, count, patternSpecification, ap); 
+    va_end(ap); 
+ 
+    return written; 
+} 
+ 
+U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_vsnprintf(UChar       *buffer, 
+            int32_t         count, 
+            const char     *patternSpecification, 
+            va_list         ap) 
+{ 
+    int32_t written; 
+    UChar *pattern; 
+    UChar patBuffer[UFMT_DEFAULT_BUFFER_SIZE]; 
+    int32_t size = (int32_t)strlen(patternSpecification) + 1; 
+ 
+    /* convert from the default codepage to Unicode */ 
+    if (size >= (int32_t)MAX_UCHAR_BUFFER_SIZE(patBuffer)) { 
+        pattern = (UChar *)uprv_malloc(size * sizeof(UChar)); 
+        if(pattern == 0) { 
+            return 0; 
+        } 
+    } 
+    else { 
+        pattern = patBuffer; 
+    } 
+    u_charsToUChars(patternSpecification, pattern, size); 
+ 
+    /* do the work */ 
+    written = u_vsnprintf_u(buffer, count, pattern, ap); 
+ 
+    /* clean up */ 
+    if (pattern != patBuffer) { 
+        uprv_free(pattern); 
+    } 
+ 
+    return written; 
+} 
+ 
+U_CAPI int32_t U_EXPORT2  
+u_vsprintf_u(UChar       *buffer,  
+             const UChar *patternSpecification,  
+             va_list     ap)  
+{  
+    return u_vsnprintf_u(buffer, INT32_MAX, patternSpecification, ap);  
+}  
+ 
+static const u_printf_stream_handler g_sprintf_stream_handler = { 
+    u_sprintf_write, 
+    u_sprintf_pad_and_justify 
+}; 
+ 
+U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_vsnprintf_u(UChar    *buffer, 
+              int32_t        count, 
+              const UChar    *patternSpecification, 
+              va_list        ap) 
 { 
-    return u_vsnprintf_u(buffer, INT32_MAX, patternSpecification, ap); 
+    int32_t          written = 0;   /* haven't written anything yet */ 
+    int32_t			 result = 0; /* test the return value of u_printf_parse */ 
+ 
+    u_localized_print_string outStr; 
+ 
+    if (count < 0) { 
+        count = INT32_MAX; 
+    } 
+ 
+    outStr.str = buffer; 
+    outStr.len = count; 
+    outStr.available = count; 
+ 
+    if(u_locbund_init(&outStr.fBundle, "en_US_POSIX") == 0) { 
+        return 0; 
+    } 
+ 
+    /* parse and print the whole format string */ 
+    result = u_printf_parse(&g_sprintf_stream_handler, patternSpecification, &outStr, &outStr, &outStr.fBundle, &written, ap); 
+     
+    /* Terminate the buffer, if there's room. */ 
+    if (outStr.available > 0) { 
+        buffer[outStr.len - outStr.available] = 0x0000; 
+    } 
+ 
+    /* Release the cloned bundle, if we cloned it. */ 
+    u_locbund_close(&outStr.fBundle); 
+ 
+    /* parsing error */  
+    if (result < 0) { 
+    	return result; 
+    } 
+    /* return # of UChars written */ 
+    return written; 
 } 
-
-static const u_printf_stream_handler g_sprintf_stream_handler = {
-    u_sprintf_write,
-    u_sprintf_pad_and_justify
-};
-
-U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_vsnprintf_u(UChar    *buffer,
-              int32_t        count,
-              const UChar    *patternSpecification,
-              va_list        ap)
-{
-    int32_t          written = 0;   /* haven't written anything yet */
-    int32_t			 result = 0; /* test the return value of u_printf_parse */
-
-    u_localized_print_string outStr;
-
-    if (count < 0) {
-        count = INT32_MAX;
-    }
-
-    outStr.str = buffer;
-    outStr.len = count;
-    outStr.available = count;
-
-    if(u_locbund_init(&outStr.fBundle, "en_US_POSIX") == 0) {
-        return 0;
-    }
-
-    /* parse and print the whole format string */
-    result = u_printf_parse(&g_sprintf_stream_handler, patternSpecification, &outStr, &outStr, &outStr.fBundle, &written, ap);
-    
-    /* Terminate the buffer, if there's room. */
-    if (outStr.available > 0) {
-        buffer[outStr.len - outStr.available] = 0x0000;
-    }
-
-    /* Release the cloned bundle, if we cloned it. */
-    u_locbund_close(&outStr.fBundle);
-
-    /* parsing error */ 
-    if (result < 0) {
-    	return result;
-    }
-    /* return # of UChars written */
-    return written;
-}
-
-#endif /* #if !UCONFIG_NO_FORMATTING */
-
+ 
+#endif /* #if !UCONFIG_NO_FORMATTING */ 
+ 
diff --git a/contrib/libs/icu/io/sscanf.cpp b/contrib/libs/icu/io/sscanf.cpp
index 47c0bace27..9fac103b07 100644
--- a/contrib/libs/icu/io/sscanf.cpp
+++ b/contrib/libs/icu/io/sscanf.cpp
@@ -1,130 +1,130 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-*
-*   Copyright (C) 2000-2014, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*
-******************************************************************************
-*
-* File sscanf.c
-*
-* Modification History:
-*
-*   Date        Name        Description
-*   02/08/00    george      Creation. Copied from uscanf.c
-******************************************************************************
-*/
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_CONVERSION
-
-#include "unicode/putil.h"
-#include "unicode/ustdio.h"
-#include "unicode/ustring.h"
-#include "uscanf.h"
-#include "ufile.h"
-#include "ufmt_cmn.h"
-
-#include "cmemory.h"
-#include "cstring.h"
-
-
-U_CAPI int32_t U_EXPORT2
-u_sscanf(const UChar   *buffer,
-         const char    *patternSpecification,
-         ... )
-{
-    va_list ap;
-    int32_t converted;
-
-    va_start(ap, patternSpecification);
-    converted = u_vsscanf(buffer, patternSpecification, ap);
-    va_end(ap);
-
-    return converted;
-}
-
-U_CAPI int32_t U_EXPORT2
-u_sscanf_u(const UChar    *buffer,
-           const UChar    *patternSpecification,
-           ... )
-{
-    va_list ap;
-    int32_t converted;
-
-    va_start(ap, patternSpecification);
-    converted = u_vsscanf_u(buffer, patternSpecification, ap);
-    va_end(ap);
-
-    return converted;
-}
-
-U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_vsscanf(const UChar   *buffer,
-          const char    *patternSpecification,
-          va_list        ap)
-{
-    int32_t converted;
-    UChar *pattern;
-    UChar patBuffer[UFMT_DEFAULT_BUFFER_SIZE];
-    int32_t size = (int32_t)uprv_strlen(patternSpecification) + 1;
-
-    /* convert from the default codepage to Unicode */
-    if (size >= (int32_t)MAX_UCHAR_BUFFER_SIZE(patBuffer)) {
-        pattern = (UChar *)uprv_malloc(size * sizeof(UChar));
-        if(pattern == 0) {
-            return 0;
-        }
-    }
-    else {
-        pattern = patBuffer;
-    }
-    u_charsToUChars(patternSpecification, pattern, size);
-
-    /* do the work */
-    converted = u_vsscanf_u(buffer, pattern, ap);
-
-    /* clean up */
-    if (pattern != patBuffer) {
-        uprv_free(pattern);
-    }
-
-    return converted;
-}
-
-U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_vsscanf_u(const UChar *buffer,
-            const UChar *patternSpecification,
-            va_list     ap)
-{
-    int32_t         converted;
-    UFILE           inStr;
-
-    inStr.fConverter = NULL;
-    inStr.fFile = NULL;
-    inStr.fOwnFile = FALSE;
-#if !UCONFIG_NO_TRANSLITERATION
-    inStr.fTranslit = NULL;
-#endif
-    inStr.fUCBuffer[0] = 0;
-    inStr.str.fBuffer = (UChar *)buffer;
-    inStr.str.fPos = (UChar *)buffer;
-    inStr.str.fLimit = buffer + u_strlen(buffer);
-
-    if(u_locbund_init(&inStr.str.fBundle, "en_US_POSIX") == 0) {
-        return 0;
-    }
-
-    converted = u_scanf_parse(&inStr, patternSpecification, ap);
-
-    u_locbund_close(&inStr.str.fBundle);
-
-    /* return # of items converted */
-    return converted;
-}
-
-#endif /* #if !UCONFIG_NO_FORMATTING */
-
+// © 2016 and later: Unicode, Inc. and others. 
+// License & terms of use: http://www.unicode.org/copyright.html 
+/* 
+****************************************************************************** 
+* 
+*   Copyright (C) 2000-2014, International Business Machines 
+*   Corporation and others.  All Rights Reserved. 
+* 
+****************************************************************************** 
+* 
+* File sscanf.c 
+* 
+* Modification History: 
+* 
+*   Date        Name        Description 
+*   02/08/00    george      Creation. Copied from uscanf.c 
+****************************************************************************** 
+*/ 
+ 
+#include "unicode/utypes.h" 
+ 
+#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_CONVERSION 
+ 
+#include "unicode/putil.h" 
+#include "unicode/ustdio.h" 
+#include "unicode/ustring.h" 
+#include "uscanf.h" 
+#include "ufile.h" 
+#include "ufmt_cmn.h" 
+ 
+#include "cmemory.h" 
+#include "cstring.h" 
+ 
+ 
+U_CAPI int32_t U_EXPORT2 
+u_sscanf(const UChar   *buffer, 
+         const char    *patternSpecification, 
+         ... ) 
+{ 
+    va_list ap; 
+    int32_t converted; 
+ 
+    va_start(ap, patternSpecification); 
+    converted = u_vsscanf(buffer, patternSpecification, ap); 
+    va_end(ap); 
+ 
+    return converted; 
+} 
+ 
+U_CAPI int32_t U_EXPORT2 
+u_sscanf_u(const UChar    *buffer, 
+           const UChar    *patternSpecification, 
+           ... ) 
+{ 
+    va_list ap; 
+    int32_t converted; 
+ 
+    va_start(ap, patternSpecification); 
+    converted = u_vsscanf_u(buffer, patternSpecification, ap); 
+    va_end(ap); 
+ 
+    return converted; 
+} 
+ 
+U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_vsscanf(const UChar   *buffer, 
+          const char    *patternSpecification, 
+          va_list        ap) 
+{ 
+    int32_t converted; 
+    UChar *pattern; 
+    UChar patBuffer[UFMT_DEFAULT_BUFFER_SIZE]; 
+    int32_t size = (int32_t)uprv_strlen(patternSpecification) + 1; 
+ 
+    /* convert from the default codepage to Unicode */ 
+    if (size >= (int32_t)MAX_UCHAR_BUFFER_SIZE(patBuffer)) { 
+        pattern = (UChar *)uprv_malloc(size * sizeof(UChar)); 
+        if(pattern == 0) { 
+            return 0; 
+        } 
+    } 
+    else { 
+        pattern = patBuffer; 
+    } 
+    u_charsToUChars(patternSpecification, pattern, size); 
+ 
+    /* do the work */ 
+    converted = u_vsscanf_u(buffer, pattern, ap); 
+ 
+    /* clean up */ 
+    if (pattern != patBuffer) { 
+        uprv_free(pattern); 
+    } 
+ 
+    return converted; 
+} 
+ 
+U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_vsscanf_u(const UChar *buffer, 
+            const UChar *patternSpecification, 
+            va_list     ap) 
+{ 
+    int32_t         converted; 
+    UFILE           inStr; 
+ 
+    inStr.fConverter = NULL; 
+    inStr.fFile = NULL; 
+    inStr.fOwnFile = FALSE; 
+#if !UCONFIG_NO_TRANSLITERATION 
+    inStr.fTranslit = NULL; 
+#endif 
+    inStr.fUCBuffer[0] = 0; 
+    inStr.str.fBuffer = (UChar *)buffer; 
+    inStr.str.fPos = (UChar *)buffer; 
+    inStr.str.fLimit = buffer + u_strlen(buffer); 
+ 
+    if(u_locbund_init(&inStr.str.fBundle, "en_US_POSIX") == 0) { 
+        return 0; 
+    } 
+ 
+    converted = u_scanf_parse(&inStr, patternSpecification, ap); 
+ 
+    u_locbund_close(&inStr.str.fBundle); 
+ 
+    /* return # of items converted */ 
+    return converted; 
+} 
+ 
+#endif /* #if !UCONFIG_NO_FORMATTING */ 
+ 
diff --git a/contrib/libs/icu/io/ucln_io.cpp b/contrib/libs/icu/io/ucln_io.cpp
index 5cd367cfad..4dd7d6b0f5 100644
--- a/contrib/libs/icu/io/ucln_io.cpp
+++ b/contrib/libs/icu/io/ucln_io.cpp
@@ -1,4 +1,4 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2016 and later: Unicode, Inc. and others. 
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 ******************************************************************************
@@ -8,7 +8,7 @@
 *                                                                            *
 ******************************************************************************
 *   file name:  ucln_io.cpp
-*   encoding:   UTF-8
+*   encoding:   UTF-8 
 *   tab size:   8 (not used)
 *   indentation:4
 *
@@ -16,7 +16,7 @@
 *   created by: George Rhoten
 */
 
-#include "unicode/utypes.h"
+#include "unicode/utypes.h" 
 #include "mutex.h"
 #include "ucln.h"
 #include "ucln_io.h"
diff --git a/contrib/libs/icu/io/ucln_io.h b/contrib/libs/icu/io/ucln_io.h
index 20dcb88ac7..52207bb686 100644
--- a/contrib/libs/icu/io/ucln_io.h
+++ b/contrib/libs/icu/io/ucln_io.h
@@ -1,4 +1,4 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2016 and later: Unicode, Inc. and others. 
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 ******************************************************************************
@@ -8,7 +8,7 @@
 *                                                                            *
 ******************************************************************************
 *   file name:  ucln_io.h
-*   encoding:   UTF-8
+*   encoding:   UTF-8 
 *   tab size:   8 (not used)
 *   indentation:4
 *
diff --git a/contrib/libs/icu/io/ufile.cpp b/contrib/libs/icu/io/ufile.cpp
index 1d8c221cdc..7d07c10389 100644
--- a/contrib/libs/icu/io/ufile.cpp
+++ b/contrib/libs/icu/io/ufile.cpp
@@ -1,343 +1,343 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-*
-*   Copyright (C) 1998-2015, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*
-******************************************************************************
-*
-* File ufile.cpp
-*
-* Modification History:
-*
-*   Date        Name        Description
-*   11/19/98    stephen     Creation.
-*   03/12/99    stephen     Modified for new C API.
-*   06/16/99    stephen     Changed T_LocaleBundle to u_locbund
-*   07/19/99    stephen     Fixed to use ucnv's default codepage.
-******************************************************************************
-*/
-
-#include "unicode/platform.h"
-#if defined(__GNUC__) && !defined(__clang__) && defined(__STRICT_ANSI__)
-// g++, fileno isn't defined                  if     __STRICT_ANSI__ is defined.
-// clang fails to compile the <string> header unless __STRICT_ANSI__ is defined.
-// __GNUC__ is set by both gcc and clang.
-#undef __STRICT_ANSI__
-#endif
-
-#include "locmap.h"
-#include "unicode/ustdio.h"
-
-#if !UCONFIG_NO_CONVERSION
-
-#include <stdlib.h>
-
-#include "ufile.h"
-#include "unicode/uloc.h"
-#include "unicode/ures.h"
-#include "unicode/ucnv.h"
-#include "unicode/ustring.h"
-#include "cstring.h"
-#include "cmemory.h"
-
-#if U_PLATFORM_USES_ONLY_WIN32_API && !defined(fileno)
-/* Windows likes to rename Unix-like functions */
-#define fileno _fileno
-#endif
-
-static UFILE*
-finit_owner(FILE         *f,
-              const char *locale,
-              const char *codepage,
-              UBool       takeOwnership
-              )
-{
-    UErrorCode status = U_ZERO_ERROR;
-    UFILE     *result;
-    if(f == NULL) {
-        return 0;
-    }
-    result = (UFILE*) uprv_malloc(sizeof(UFILE));
-    if(result == NULL) {
-        return 0;
-    }
-
-    uprv_memset(result, 0, sizeof(UFILE));
-    result->fFileno = fileno(f);
-    result->fFile = f;
-
-    result->str.fBuffer = result->fUCBuffer;
-    result->str.fPos    = result->fUCBuffer;
-    result->str.fLimit  = result->fUCBuffer;
-
-#if !UCONFIG_NO_FORMATTING
-        /* if locale is 0, use the default */
-        if(u_locbund_init(&result->str.fBundle, locale) == 0) {
-            /* DO NOT FCLOSE HERE! */
-            uprv_free(result);
-            return 0;
-        }
-#endif
-
-    /* If the codepage is not "" use the ucnv_open default behavior */
-    if(codepage == NULL || *codepage != '\0') {
-        result->fConverter = ucnv_open(codepage, &status);
-    }
-    /* else result->fConverter is already memset'd to NULL. */
-
-    if(U_SUCCESS(status)) {
-        result->fOwnFile = takeOwnership;
-    }
-    else {
-#if !UCONFIG_NO_FORMATTING
-        u_locbund_close(&result->str.fBundle);
-#endif
-        /* DO NOT fclose here!!!!!! */
-        uprv_free(result);
-        result = NULL;
-    }
-
-    return result;
-}
-
-U_CAPI UFILE* U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_finit(FILE          *f,
-        const char    *locale,
-        const char    *codepage)
-{
-    return finit_owner(f, locale, codepage, FALSE);
-}
-
-U_CAPI UFILE* U_EXPORT2
-u_fadopt(FILE         *f,
-        const char    *locale,
-        const char    *codepage)
-{
-    return finit_owner(f, locale, codepage, TRUE);
-}
-
-U_CAPI UFILE* U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fopen(const char    *filename,
-        const char    *perm,
-        const char    *locale,
-        const char    *codepage)
-{
-    UFILE     *result;
-    FILE     *systemFile = fopen(filename, perm);
-    if(systemFile == 0) {
-        return 0;
-    }
-
-    result = finit_owner(systemFile, locale, codepage, TRUE);
-
-    if (!result) {
-        /* Something bad happened.
-           Maybe the converter couldn't be opened. */
-        fclose(systemFile);
-    }
-
-    return result; /* not a file leak */
-}
-
-U_CAPI UFILE* U_EXPORT2
-u_fopen_u(const UChar   *filename,
-        const char    *perm,
-        const char    *locale,
-        const char    *codepage)
-{
-    UFILE     *result;
-    char buffer[256];
-
-    u_austrcpy(buffer, filename);
-
-    result = u_fopen(buffer, perm, locale, codepage);
-#if U_PLATFORM_USES_ONLY_WIN32_API
-    /* Try Windows API _wfopen if the above fails. */
-    if (!result) {
-        // TODO: test this code path, including wperm.
-        wchar_t wperm[40] = {};
-        size_t  retVal;
-        mbstowcs_s(&retVal, wperm, UPRV_LENGTHOF(wperm), perm, _TRUNCATE);
-        FILE *systemFile = _wfopen((const wchar_t *)filename, wperm);
-        if (systemFile) {
-            result = finit_owner(systemFile, locale, codepage, TRUE);
-        }
-        if (!result) {
-            /* Something bad happened.
-               Maybe the converter couldn't be opened. */
-            fclose(systemFile);
-        }
-    }
-#endif
-    return result; /* not a file leak */
-}
-
-U_CAPI UFILE* U_EXPORT2
-u_fstropen(UChar *stringBuf,
-           int32_t      capacity,
-           const char  *locale)
-{
-    UFILE *result;
-
-    if (capacity < 0) {
-        return NULL;
-    }
-
-    result = (UFILE*) uprv_malloc(sizeof(UFILE));
-    /* Null pointer test */
-    if (result == NULL) {
-        return NULL; /* Just get out. */
-    }
-    uprv_memset(result, 0, sizeof(UFILE));
-    result->str.fBuffer = stringBuf;
-    result->str.fPos    = stringBuf;
-    result->str.fLimit  = stringBuf+capacity;
-
-#if !UCONFIG_NO_FORMATTING
-    /* if locale is 0, use the default */
-    if(u_locbund_init(&result->str.fBundle, locale) == 0) {
-        /* DO NOT FCLOSE HERE! */
-        uprv_free(result);
-        return 0;
-    }
-#endif
-
-    return result;
-}
-
-U_CAPI UBool U_EXPORT2
-u_feof(UFILE  *f)
-{
-    UBool endOfBuffer;
-    if (f == NULL) {
-        return TRUE;
-    }
-    endOfBuffer = (UBool)(f->str.fPos >= f->str.fLimit);
-    if (f->fFile != NULL) {
-        return endOfBuffer && feof(f->fFile);
-    }
-    return endOfBuffer;
-}
-
-U_CAPI void U_EXPORT2
-u_fflush(UFILE *file)
-{
-    ufile_flush_translit(file);
-    ufile_flush_io(file);
-    if (file->fFile) {
-        fflush(file->fFile);
-    }
-    else if (file->str.fPos < file->str.fLimit) {
-        *(file->str.fPos++) = 0;
-    }
-    /* TODO: flush input */
-}
-
-U_CAPI void
-u_frewind(UFILE *file)
-{
-    u_fflush(file);
-    ucnv_reset(file->fConverter);
-    if (file->fFile) {
-        rewind(file->fFile);
-        file->str.fLimit = file->fUCBuffer;
-        file->str.fPos   = file->fUCBuffer;
-    }
-    else {
-        file->str.fPos = file->str.fBuffer;
-    }
-}
-
-U_CAPI void U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fclose(UFILE *file)
-{
-    if (file) {
-        u_fflush(file);
-        ufile_close_translit(file);
-
-        if(file->fOwnFile)
-            fclose(file->fFile);
-
-#if !UCONFIG_NO_FORMATTING
-        u_locbund_close(&file->str.fBundle);
-#endif
-
-        ucnv_close(file->fConverter);
-        uprv_free(file);
-    }
-}
-
-U_CAPI FILE* U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fgetfile(    UFILE         *f)
-{
-    return f->fFile;
-}
-
-#if !UCONFIG_NO_FORMATTING
-
-U_CAPI const char*  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fgetlocale(    UFILE        *file)
-{
-    return file->str.fBundle.fLocale;
-}
-
-U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fsetlocale(UFILE      *file,
-             const char *locale)
-{
-    u_locbund_close(&file->str.fBundle);
-
-    return u_locbund_init(&file->str.fBundle, locale) == 0 ? -1 : 0;
-}
-
-#endif
-
-U_CAPI const char* U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fgetcodepage(UFILE        *file)
-{
-    UErrorCode     status = U_ZERO_ERROR;
-    const char     *codepage = NULL;
-
-    if (file->fConverter) {
-        codepage = ucnv_getName(file->fConverter, &status);
-        if(U_FAILURE(status))
-            return 0;
-    }
-    return codepage;
-}
-
-U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fsetcodepage(    const char    *codepage,
-               UFILE        *file)
-{
-    UErrorCode status = U_ZERO_ERROR;
-    int32_t retVal = -1;
-
-    /* We use the normal default codepage for this system, and not the one for the locale. */
-    if ((file->str.fPos == file->str.fBuffer) && (file->str.fLimit == file->str.fBuffer)) {
-        ucnv_close(file->fConverter);
-        file->fConverter = ucnv_open(codepage, &status);
-        if(U_SUCCESS(status)) {
-            retVal = 0;
-        }
-    }
-    return retVal;
-}
-
-
-U_CAPI UConverter * U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fgetConverter(UFILE *file)
-{
-    return file->fConverter;
-}
-#if !UCONFIG_NO_FORMATTING
-U_CAPI const UNumberFormat* U_EXPORT2 u_fgetNumberFormat(UFILE *file)
-{
-    return u_locbund_getNumberFormat(&file->str.fBundle, UNUM_DECIMAL);
-}
-#endif
-
-#endif
+// © 2016 and later: Unicode, Inc. and others. 
+// License & terms of use: http://www.unicode.org/copyright.html 
+/* 
+****************************************************************************** 
+* 
+*   Copyright (C) 1998-2015, International Business Machines 
+*   Corporation and others.  All Rights Reserved. 
+* 
+****************************************************************************** 
+* 
+* File ufile.cpp 
+* 
+* Modification History: 
+* 
+*   Date        Name        Description 
+*   11/19/98    stephen     Creation. 
+*   03/12/99    stephen     Modified for new C API. 
+*   06/16/99    stephen     Changed T_LocaleBundle to u_locbund 
+*   07/19/99    stephen     Fixed to use ucnv's default codepage. 
+****************************************************************************** 
+*/ 
+ 
+#include "unicode/platform.h" 
+#if defined(__GNUC__) && !defined(__clang__) && defined(__STRICT_ANSI__) 
+// g++, fileno isn't defined                  if     __STRICT_ANSI__ is defined. 
+// clang fails to compile the <string> header unless __STRICT_ANSI__ is defined. 
+// __GNUC__ is set by both gcc and clang. 
+#undef __STRICT_ANSI__ 
+#endif 
+ 
+#include "locmap.h" 
+#include "unicode/ustdio.h" 
+ 
+#if !UCONFIG_NO_CONVERSION 
+ 
+#include <stdlib.h> 
+ 
+#include "ufile.h" 
+#include "unicode/uloc.h" 
+#include "unicode/ures.h" 
+#include "unicode/ucnv.h" 
+#include "unicode/ustring.h" 
+#include "cstring.h" 
+#include "cmemory.h" 
+ 
+#if U_PLATFORM_USES_ONLY_WIN32_API && !defined(fileno) 
+/* Windows likes to rename Unix-like functions */ 
+#define fileno _fileno 
+#endif 
+ 
+static UFILE* 
+finit_owner(FILE         *f, 
+              const char *locale, 
+              const char *codepage, 
+              UBool       takeOwnership 
+              ) 
+{ 
+    UErrorCode status = U_ZERO_ERROR; 
+    UFILE     *result; 
+    if(f == NULL) { 
+        return 0; 
+    } 
+    result = (UFILE*) uprv_malloc(sizeof(UFILE)); 
+    if(result == NULL) { 
+        return 0; 
+    } 
+ 
+    uprv_memset(result, 0, sizeof(UFILE)); 
+    result->fFileno = fileno(f); 
+    result->fFile = f; 
+ 
+    result->str.fBuffer = result->fUCBuffer; 
+    result->str.fPos    = result->fUCBuffer; 
+    result->str.fLimit  = result->fUCBuffer; 
+ 
+#if !UCONFIG_NO_FORMATTING 
+        /* if locale is 0, use the default */ 
+        if(u_locbund_init(&result->str.fBundle, locale) == 0) { 
+            /* DO NOT FCLOSE HERE! */ 
+            uprv_free(result); 
+            return 0; 
+        } 
+#endif 
+ 
+    /* If the codepage is not "" use the ucnv_open default behavior */ 
+    if(codepage == NULL || *codepage != '\0') { 
+        result->fConverter = ucnv_open(codepage, &status); 
+    } 
+    /* else result->fConverter is already memset'd to NULL. */ 
+ 
+    if(U_SUCCESS(status)) { 
+        result->fOwnFile = takeOwnership; 
+    } 
+    else { 
+#if !UCONFIG_NO_FORMATTING 
+        u_locbund_close(&result->str.fBundle); 
+#endif 
+        /* DO NOT fclose here!!!!!! */ 
+        uprv_free(result); 
+        result = NULL; 
+    } 
+ 
+    return result; 
+} 
+ 
+U_CAPI UFILE* U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_finit(FILE          *f, 
+        const char    *locale, 
+        const char    *codepage) 
+{ 
+    return finit_owner(f, locale, codepage, FALSE); 
+} 
+ 
+U_CAPI UFILE* U_EXPORT2 
+u_fadopt(FILE         *f, 
+        const char    *locale, 
+        const char    *codepage) 
+{ 
+    return finit_owner(f, locale, codepage, TRUE); 
+} 
+ 
+U_CAPI UFILE* U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fopen(const char    *filename, 
+        const char    *perm, 
+        const char    *locale, 
+        const char    *codepage) 
+{ 
+    UFILE     *result; 
+    FILE     *systemFile = fopen(filename, perm); 
+    if(systemFile == 0) { 
+        return 0; 
+    } 
+ 
+    result = finit_owner(systemFile, locale, codepage, TRUE); 
+ 
+    if (!result) { 
+        /* Something bad happened. 
+           Maybe the converter couldn't be opened. */ 
+        fclose(systemFile); 
+    } 
+ 
+    return result; /* not a file leak */ 
+} 
+ 
+U_CAPI UFILE* U_EXPORT2 
+u_fopen_u(const UChar   *filename, 
+        const char    *perm, 
+        const char    *locale, 
+        const char    *codepage) 
+{ 
+    UFILE     *result; 
+    char buffer[256]; 
+ 
+    u_austrcpy(buffer, filename); 
+ 
+    result = u_fopen(buffer, perm, locale, codepage); 
+#if U_PLATFORM_USES_ONLY_WIN32_API 
+    /* Try Windows API _wfopen if the above fails. */ 
+    if (!result) { 
+        // TODO: test this code path, including wperm. 
+        wchar_t wperm[40] = {}; 
+        size_t  retVal; 
+        mbstowcs_s(&retVal, wperm, UPRV_LENGTHOF(wperm), perm, _TRUNCATE); 
+        FILE *systemFile = _wfopen((const wchar_t *)filename, wperm); 
+        if (systemFile) { 
+            result = finit_owner(systemFile, locale, codepage, TRUE); 
+        } 
+        if (!result) { 
+            /* Something bad happened. 
+               Maybe the converter couldn't be opened. */ 
+            fclose(systemFile); 
+        } 
+    } 
+#endif 
+    return result; /* not a file leak */ 
+} 
+ 
+U_CAPI UFILE* U_EXPORT2 
+u_fstropen(UChar *stringBuf, 
+           int32_t      capacity, 
+           const char  *locale) 
+{ 
+    UFILE *result; 
+ 
+    if (capacity < 0) { 
+        return NULL; 
+    } 
+ 
+    result = (UFILE*) uprv_malloc(sizeof(UFILE)); 
+    /* Null pointer test */ 
+    if (result == NULL) { 
+        return NULL; /* Just get out. */ 
+    } 
+    uprv_memset(result, 0, sizeof(UFILE)); 
+    result->str.fBuffer = stringBuf; 
+    result->str.fPos    = stringBuf; 
+    result->str.fLimit  = stringBuf+capacity; 
+ 
+#if !UCONFIG_NO_FORMATTING 
+    /* if locale is 0, use the default */ 
+    if(u_locbund_init(&result->str.fBundle, locale) == 0) { 
+        /* DO NOT FCLOSE HERE! */ 
+        uprv_free(result); 
+        return 0; 
+    } 
+#endif 
+ 
+    return result; 
+} 
+ 
+U_CAPI UBool U_EXPORT2 
+u_feof(UFILE  *f) 
+{ 
+    UBool endOfBuffer; 
+    if (f == NULL) { 
+        return TRUE; 
+    } 
+    endOfBuffer = (UBool)(f->str.fPos >= f->str.fLimit); 
+    if (f->fFile != NULL) { 
+        return endOfBuffer && feof(f->fFile); 
+    } 
+    return endOfBuffer; 
+} 
+ 
+U_CAPI void U_EXPORT2 
+u_fflush(UFILE *file) 
+{ 
+    ufile_flush_translit(file); 
+    ufile_flush_io(file); 
+    if (file->fFile) { 
+        fflush(file->fFile); 
+    } 
+    else if (file->str.fPos < file->str.fLimit) { 
+        *(file->str.fPos++) = 0; 
+    } 
+    /* TODO: flush input */ 
+} 
+ 
+U_CAPI void 
+u_frewind(UFILE *file) 
+{ 
+    u_fflush(file); 
+    ucnv_reset(file->fConverter); 
+    if (file->fFile) { 
+        rewind(file->fFile); 
+        file->str.fLimit = file->fUCBuffer; 
+        file->str.fPos   = file->fUCBuffer; 
+    } 
+    else { 
+        file->str.fPos = file->str.fBuffer; 
+    } 
+} 
+ 
+U_CAPI void U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fclose(UFILE *file) 
+{ 
+    if (file) { 
+        u_fflush(file); 
+        ufile_close_translit(file); 
+ 
+        if(file->fOwnFile) 
+            fclose(file->fFile); 
+ 
+#if !UCONFIG_NO_FORMATTING 
+        u_locbund_close(&file->str.fBundle); 
+#endif 
+ 
+        ucnv_close(file->fConverter); 
+        uprv_free(file); 
+    } 
+} 
+ 
+U_CAPI FILE* U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fgetfile(    UFILE         *f) 
+{ 
+    return f->fFile; 
+} 
+ 
+#if !UCONFIG_NO_FORMATTING 
+ 
+U_CAPI const char*  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fgetlocale(    UFILE        *file) 
+{ 
+    return file->str.fBundle.fLocale; 
+} 
+ 
+U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fsetlocale(UFILE      *file, 
+             const char *locale) 
+{ 
+    u_locbund_close(&file->str.fBundle); 
+ 
+    return u_locbund_init(&file->str.fBundle, locale) == 0 ? -1 : 0; 
+} 
+ 
+#endif 
+ 
+U_CAPI const char* U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fgetcodepage(UFILE        *file) 
+{ 
+    UErrorCode     status = U_ZERO_ERROR; 
+    const char     *codepage = NULL; 
+ 
+    if (file->fConverter) { 
+        codepage = ucnv_getName(file->fConverter, &status); 
+        if(U_FAILURE(status)) 
+            return 0; 
+    } 
+    return codepage; 
+} 
+ 
+U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fsetcodepage(    const char    *codepage, 
+               UFILE        *file) 
+{ 
+    UErrorCode status = U_ZERO_ERROR; 
+    int32_t retVal = -1; 
+ 
+    /* We use the normal default codepage for this system, and not the one for the locale. */ 
+    if ((file->str.fPos == file->str.fBuffer) && (file->str.fLimit == file->str.fBuffer)) { 
+        ucnv_close(file->fConverter); 
+        file->fConverter = ucnv_open(codepage, &status); 
+        if(U_SUCCESS(status)) { 
+            retVal = 0; 
+        } 
+    } 
+    return retVal; 
+} 
+ 
+ 
+U_CAPI UConverter * U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fgetConverter(UFILE *file) 
+{ 
+    return file->fConverter; 
+} 
+#if !UCONFIG_NO_FORMATTING 
+U_CAPI const UNumberFormat* U_EXPORT2 u_fgetNumberFormat(UFILE *file) 
+{ 
+    return u_locbund_getNumberFormat(&file->str.fBundle, UNUM_DECIMAL); 
+} 
+#endif 
+ 
+#endif 
diff --git a/contrib/libs/icu/io/ufile.h b/contrib/libs/icu/io/ufile.h
index e85208fcd3..498e5689cf 100644
--- a/contrib/libs/icu/io/ufile.h
+++ b/contrib/libs/icu/io/ufile.h
@@ -1,4 +1,4 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2016 and later: Unicode, Inc. and others. 
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
  *******************************************************************************
@@ -25,8 +25,8 @@
 
 #if !UCONFIG_NO_CONVERSION
 
-#include <stdio.h>
-
+#include <stdio.h> 
+ 
 #include "unicode/ucnv.h"
 #include "unicode/utrans.h"
 #include "locbund.h"
diff --git a/contrib/libs/icu/io/ufmt_cmn.cpp b/contrib/libs/icu/io/ufmt_cmn.cpp
index 0b6c18ff96..ad6f4afc75 100644
--- a/contrib/libs/icu/io/ufmt_cmn.cpp
+++ b/contrib/libs/icu/io/ufmt_cmn.cpp
@@ -1,259 +1,259 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-*
-*   Copyright (C) 1998-2014, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*
-******************************************************************************
-*
-* File ufmt_cmn.c
-*
-* Modification History:
-*
-*   Date        Name        Description
-*   12/02/98    stephen     Creation.
-*   03/12/99    stephen     Modified for new C API.
-*   03/15/99    stephen     Added defaultCPToUnicode, unicodeToDefaultCP
-*   07/19/99    stephen     Fixed bug in defaultCPToUnicode
-******************************************************************************
-*/
-
-#include "cstring.h"
-#include "cmemory.h"
-#include "ufmt_cmn.h"
-#include "unicode/uchar.h"
-#include "unicode/ucnv.h"
-#include "ustr_cnv.h"
-
-#if !UCONFIG_NO_CONVERSION
-
-
-#define DIGIT_0     0x0030
-#define DIGIT_9     0x0039
-#define LOWERCASE_A 0x0061
-#define UPPERCASE_A 0x0041
-#define LOWERCASE_Z 0x007A
-#define UPPERCASE_Z 0x005A
-
-int
-ufmt_digitvalue(UChar c)
-{
-    if( ((c>=DIGIT_0)&&(c<=DIGIT_9)) ||
-        ((c>=LOWERCASE_A)&&(c<=LOWERCASE_Z)) ||
-        ((c>=UPPERCASE_A)&&(c<=UPPERCASE_Z))  )
-    {
-      return c - DIGIT_0 - (c >= 0x0041 ? (c >= 0x0061 ? 39 : 7) : 0);
-    }
-    else
-    {
-      return -1;
-    }
-}
-
-UBool
-ufmt_isdigit(UChar     c,
-             int32_t     radix)
-{
-    int digitVal = ufmt_digitvalue(c);
-
-    return (UBool)(digitVal < radix && digitVal >= 0);
-}
-
-#define TO_UC_DIGIT(a) a <= 9 ? (DIGIT_0 + a) : (0x0037 + a)
-#define TO_LC_DIGIT(a) a <= 9 ? (DIGIT_0 + a) : (0x0057 + a)
-
-void 
-ufmt_64tou(UChar     *buffer, 
-          int32_t   *len,
-          uint64_t  value, 
-          uint8_t  radix,
-          UBool     uselower,
-          int32_t   minDigits)
-{
-    int32_t  length = 0;
-    uint32_t digit;
-    UChar    *left, *right, temp;
-    
-    do {
-        digit = (uint32_t)(value % radix);
-        value = value / radix;
-        buffer[length++] = (UChar)(uselower ? TO_LC_DIGIT(digit) 
-            : TO_UC_DIGIT(digit));
-    } while(value);
-
-    /* pad with zeroes to make it minDigits long */
-    if(minDigits != -1 && length < minDigits) {
-        while(length < minDigits && length < *len)
-            buffer[length++] = DIGIT_0;  /*zero padding */
-    }
-
-    /* reverse the buffer */
-    left     = buffer;
-    right = buffer + length;
-    while(left < --right) {
-        temp     = *left;
-        *left++     = *right;
-        *right     = temp;
-    }
-    
-    *len = length;
-}
-
-void 
-ufmt_ptou(UChar    *buffer, 
-          int32_t   *len,
-          void      *value, 
-          UBool     uselower)
-{
-    int32_t i;
-    int32_t length = 0;
-    uint8_t *ptrIdx = (uint8_t *)&value;
-
-#if U_IS_BIG_ENDIAN
-    for (i = 0; i < (int32_t)sizeof(void *); i++)
-#else
-    for (i = (int32_t)sizeof(void *)-1; i >= 0 ; i--)
-#endif
-    {
-        uint8_t byteVal = ptrIdx[i];
-        uint16_t firstNibble = (uint16_t)(byteVal>>4);
-        uint16_t secondNibble = (uint16_t)(byteVal&0xF);
-        if (uselower) {
-            buffer[length++]=TO_LC_DIGIT(firstNibble);
-            buffer[length++]=TO_LC_DIGIT(secondNibble);
-        }
-        else {
-            buffer[length++]=TO_UC_DIGIT(firstNibble);
-            buffer[length++]=TO_UC_DIGIT(secondNibble);
-        }
-    }
-
-    *len = length;
-}
-
-int64_t
-ufmt_uto64(const UChar     *buffer, 
-          int32_t     *len,
-          int8_t     radix)
-{
-    const UChar     *limit;
-    int32_t         count;
-    uint64_t        result;
-    
-    
-    /* intialize parameters */
-    limit     = buffer + *len;
-    count     = 0;
-    result    = 0;
-    
-    /* iterate through buffer */
-    while(ufmt_isdigit(*buffer, radix) && buffer < limit) {
-        
-        /* read the next digit */
-        result *= radix;
-        result += ufmt_digitvalue(*buffer++);
-        
-        /* increment our count */
-        ++count;
-    }
-    
-    *len = count;
-    return static_cast<int64_t>(result);
-}
-
-#define NIBBLE_PER_BYTE 2
-void *
-ufmt_utop(const UChar     *buffer,
-          int32_t     *len)
-{
-    int32_t count, resultIdx, incVal, offset;
-    /* This union allows the pointer to be written as an array. */
-    union {
-        void *ptr;
-        uint8_t bytes[sizeof(void*)];
-    } result;
-    
-    /* intialize variables */
-    count      = 0;
-    offset     = 0;
-    result.ptr = NULL;
-
-    /* Skip the leading zeros */
-    while(buffer[count] == DIGIT_0 || u_isspace(buffer[count])) {
-        count++;
-        offset++;
-    }
-
-    /* iterate through buffer, stop when you hit the end */
-    while(count < *len && ufmt_isdigit(buffer[count], 16)) {
-        /* increment the count consumed */
-        ++count;
-    }
-
-    /* detect overflow */
-    if (count - offset > (int32_t)(sizeof(void*)*NIBBLE_PER_BYTE)) {
-        offset = count - (int32_t)(sizeof(void*)*NIBBLE_PER_BYTE);
-    }
-    
-    /* Initialize the direction of the input */
-#if U_IS_BIG_ENDIAN
-    incVal = -1;
-    resultIdx = (int32_t)(sizeof(void*) - 1);
-#else
-    incVal = 1;
-    resultIdx = 0;
-#endif
-    /* Write how much was consumed. */
-    *len = count;
-    while(--count >= offset) {
-        /* Get the first nibble of the byte */
-        uint8_t byte = (uint8_t)ufmt_digitvalue(buffer[count]);
-
-        if (count > offset) {
-            /* Get the second nibble of the byte when available */
-            byte = (uint8_t)(byte + (ufmt_digitvalue(buffer[--count]) << 4));
-        }
-        /* Write the byte into the array */
-        result.bytes[resultIdx] = byte;
-        resultIdx += incVal;
-    }
-
-    return result.ptr;
-}
-
-UChar*
-ufmt_defaultCPToUnicode(const char *s, int32_t sSize,
-                        UChar *target, int32_t tSize)
-{
-    UChar *alias;
-    UErrorCode status = U_ZERO_ERROR;
-    UConverter *defConverter = u_getDefaultConverter(&status);
-    
-    if(U_FAILURE(status) || defConverter == 0)
-        return 0;
-
-    if(sSize <= 0) {
-        sSize = static_cast<int32_t>(uprv_strlen(s)) + 1;
-    }
-    
-    /* perform the conversion in one swoop */
-    if(target != 0) {
-        
-        alias = target;
-        ucnv_toUnicode(defConverter, &alias, alias + tSize, &s, s + sSize - 1, 
-            NULL, TRUE, &status);
-        
-        
-        /* add the null terminator */
-        *alias = 0x0000;
-    }
-    
-    u_releaseDefaultConverter(defConverter);
-    
-    return target;
-}
-
-
-#endif
+// © 2016 and later: Unicode, Inc. and others. 
+// License & terms of use: http://www.unicode.org/copyright.html 
+/* 
+****************************************************************************** 
+* 
+*   Copyright (C) 1998-2014, International Business Machines 
+*   Corporation and others.  All Rights Reserved. 
+* 
+****************************************************************************** 
+* 
+* File ufmt_cmn.c 
+* 
+* Modification History: 
+* 
+*   Date        Name        Description 
+*   12/02/98    stephen     Creation. 
+*   03/12/99    stephen     Modified for new C API. 
+*   03/15/99    stephen     Added defaultCPToUnicode, unicodeToDefaultCP 
+*   07/19/99    stephen     Fixed bug in defaultCPToUnicode 
+****************************************************************************** 
+*/ 
+ 
+#include "cstring.h" 
+#include "cmemory.h" 
+#include "ufmt_cmn.h" 
+#include "unicode/uchar.h" 
+#include "unicode/ucnv.h" 
+#include "ustr_cnv.h" 
+ 
+#if !UCONFIG_NO_CONVERSION 
+ 
+ 
+#define DIGIT_0     0x0030 
+#define DIGIT_9     0x0039 
+#define LOWERCASE_A 0x0061 
+#define UPPERCASE_A 0x0041 
+#define LOWERCASE_Z 0x007A 
+#define UPPERCASE_Z 0x005A 
+ 
+int 
+ufmt_digitvalue(UChar c) 
+{ 
+    if( ((c>=DIGIT_0)&&(c<=DIGIT_9)) || 
+        ((c>=LOWERCASE_A)&&(c<=LOWERCASE_Z)) || 
+        ((c>=UPPERCASE_A)&&(c<=UPPERCASE_Z))  ) 
+    { 
+      return c - DIGIT_0 - (c >= 0x0041 ? (c >= 0x0061 ? 39 : 7) : 0); 
+    } 
+    else 
+    { 
+      return -1; 
+    } 
+} 
+ 
+UBool 
+ufmt_isdigit(UChar     c, 
+             int32_t     radix) 
+{ 
+    int digitVal = ufmt_digitvalue(c); 
+ 
+    return (UBool)(digitVal < radix && digitVal >= 0); 
+} 
+ 
+#define TO_UC_DIGIT(a) a <= 9 ? (DIGIT_0 + a) : (0x0037 + a) 
+#define TO_LC_DIGIT(a) a <= 9 ? (DIGIT_0 + a) : (0x0057 + a) 
+ 
+void  
+ufmt_64tou(UChar     *buffer,  
+          int32_t   *len, 
+          uint64_t  value,  
+          uint8_t  radix, 
+          UBool     uselower, 
+          int32_t   minDigits) 
+{ 
+    int32_t  length = 0; 
+    uint32_t digit; 
+    UChar    *left, *right, temp; 
+     
+    do { 
+        digit = (uint32_t)(value % radix); 
+        value = value / radix; 
+        buffer[length++] = (UChar)(uselower ? TO_LC_DIGIT(digit)  
+            : TO_UC_DIGIT(digit)); 
+    } while(value); 
+ 
+    /* pad with zeroes to make it minDigits long */ 
+    if(minDigits != -1 && length < minDigits) { 
+        while(length < minDigits && length < *len) 
+            buffer[length++] = DIGIT_0;  /*zero padding */ 
+    } 
+ 
+    /* reverse the buffer */ 
+    left     = buffer; 
+    right = buffer + length; 
+    while(left < --right) { 
+        temp     = *left; 
+        *left++     = *right; 
+        *right     = temp; 
+    } 
+     
+    *len = length; 
+} 
+ 
+void  
+ufmt_ptou(UChar    *buffer,  
+          int32_t   *len, 
+          void      *value,  
+          UBool     uselower) 
+{ 
+    int32_t i; 
+    int32_t length = 0; 
+    uint8_t *ptrIdx = (uint8_t *)&value; 
+ 
+#if U_IS_BIG_ENDIAN 
+    for (i = 0; i < (int32_t)sizeof(void *); i++) 
+#else 
+    for (i = (int32_t)sizeof(void *)-1; i >= 0 ; i--) 
+#endif 
+    { 
+        uint8_t byteVal = ptrIdx[i]; 
+        uint16_t firstNibble = (uint16_t)(byteVal>>4); 
+        uint16_t secondNibble = (uint16_t)(byteVal&0xF); 
+        if (uselower) { 
+            buffer[length++]=TO_LC_DIGIT(firstNibble); 
+            buffer[length++]=TO_LC_DIGIT(secondNibble); 
+        } 
+        else { 
+            buffer[length++]=TO_UC_DIGIT(firstNibble); 
+            buffer[length++]=TO_UC_DIGIT(secondNibble); 
+        } 
+    } 
+ 
+    *len = length; 
+} 
+ 
+int64_t 
+ufmt_uto64(const UChar     *buffer,  
+          int32_t     *len, 
+          int8_t     radix) 
+{ 
+    const UChar     *limit; 
+    int32_t         count; 
+    uint64_t        result; 
+     
+     
+    /* intialize parameters */ 
+    limit     = buffer + *len; 
+    count     = 0; 
+    result    = 0; 
+     
+    /* iterate through buffer */ 
+    while(ufmt_isdigit(*buffer, radix) && buffer < limit) { 
+         
+        /* read the next digit */ 
+        result *= radix; 
+        result += ufmt_digitvalue(*buffer++); 
+         
+        /* increment our count */ 
+        ++count; 
+    } 
+     
+    *len = count; 
+    return static_cast<int64_t>(result); 
+} 
+ 
+#define NIBBLE_PER_BYTE 2 
+void * 
+ufmt_utop(const UChar     *buffer, 
+          int32_t     *len) 
+{ 
+    int32_t count, resultIdx, incVal, offset; 
+    /* This union allows the pointer to be written as an array. */ 
+    union { 
+        void *ptr; 
+        uint8_t bytes[sizeof(void*)]; 
+    } result; 
+     
+    /* intialize variables */ 
+    count      = 0; 
+    offset     = 0; 
+    result.ptr = NULL; 
+ 
+    /* Skip the leading zeros */ 
+    while(buffer[count] == DIGIT_0 || u_isspace(buffer[count])) { 
+        count++; 
+        offset++; 
+    } 
+ 
+    /* iterate through buffer, stop when you hit the end */ 
+    while(count < *len && ufmt_isdigit(buffer[count], 16)) { 
+        /* increment the count consumed */ 
+        ++count; 
+    } 
+ 
+    /* detect overflow */ 
+    if (count - offset > (int32_t)(sizeof(void*)*NIBBLE_PER_BYTE)) { 
+        offset = count - (int32_t)(sizeof(void*)*NIBBLE_PER_BYTE); 
+    } 
+     
+    /* Initialize the direction of the input */ 
+#if U_IS_BIG_ENDIAN 
+    incVal = -1; 
+    resultIdx = (int32_t)(sizeof(void*) - 1); 
+#else 
+    incVal = 1; 
+    resultIdx = 0; 
+#endif 
+    /* Write how much was consumed. */ 
+    *len = count; 
+    while(--count >= offset) { 
+        /* Get the first nibble of the byte */ 
+        uint8_t byte = (uint8_t)ufmt_digitvalue(buffer[count]); 
+ 
+        if (count > offset) { 
+            /* Get the second nibble of the byte when available */ 
+            byte = (uint8_t)(byte + (ufmt_digitvalue(buffer[--count]) << 4)); 
+        } 
+        /* Write the byte into the array */ 
+        result.bytes[resultIdx] = byte; 
+        resultIdx += incVal; 
+    } 
+ 
+    return result.ptr; 
+} 
+ 
+UChar* 
+ufmt_defaultCPToUnicode(const char *s, int32_t sSize, 
+                        UChar *target, int32_t tSize) 
+{ 
+    UChar *alias; 
+    UErrorCode status = U_ZERO_ERROR; 
+    UConverter *defConverter = u_getDefaultConverter(&status); 
+     
+    if(U_FAILURE(status) || defConverter == 0) 
+        return 0; 
+ 
+    if(sSize <= 0) { 
+        sSize = static_cast<int32_t>(uprv_strlen(s)) + 1; 
+    } 
+     
+    /* perform the conversion in one swoop */ 
+    if(target != 0) { 
+         
+        alias = target; 
+        ucnv_toUnicode(defConverter, &alias, alias + tSize, &s, s + sSize - 1,  
+            NULL, TRUE, &status); 
+         
+         
+        /* add the null terminator */ 
+        *alias = 0x0000; 
+    } 
+     
+    u_releaseDefaultConverter(defConverter); 
+     
+    return target; 
+} 
+ 
+ 
+#endif 
diff --git a/contrib/libs/icu/io/ufmt_cmn.h b/contrib/libs/icu/io/ufmt_cmn.h
index 33b56a0175..12194a5818 100644
--- a/contrib/libs/icu/io/ufmt_cmn.h
+++ b/contrib/libs/icu/io/ufmt_cmn.h
@@ -1,4 +1,4 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2016 and later: Unicode, Inc. and others. 
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 ******************************************************************************
@@ -26,7 +26,7 @@
 #include "unicode/utf16.h"
 
 #define UFMT_DEFAULT_BUFFER_SIZE 128
-#define MAX_UCHAR_BUFFER_SIZE(buffer) ((int32_t)(sizeof(buffer)/(U16_MAX_LENGTH*sizeof(UChar))))
+#define MAX_UCHAR_BUFFER_SIZE(buffer) ((int32_t)(sizeof(buffer)/(U16_MAX_LENGTH*sizeof(UChar)))) 
 #define MAX_UCHAR_BUFFER_NEEDED(strLen) ((strLen+1)*U16_MAX_LENGTH*sizeof(UChar))
 
 /** 
diff --git a/contrib/libs/icu/io/uprintf.cpp b/contrib/libs/icu/io/uprintf.cpp
index 3c9effaada..238588a722 100644
--- a/contrib/libs/icu/io/uprintf.cpp
+++ b/contrib/libs/icu/io/uprintf.cpp
@@ -1,4 +1,4 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2016 and later: Unicode, Inc. and others. 
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 ******************************************************************************
@@ -183,7 +183,7 @@ u_vfprintf(    UFILE        *f,
     else {
         pattern = buffer;
     }
-    u_charsToUChars(patternSpecification, pattern, static_cast<int32_t>(size));
+    u_charsToUChars(patternSpecification, pattern, static_cast<int32_t>(size)); 
 
     /* do the work */
     count = u_vfprintf_u(f, pattern, ap);
diff --git a/contrib/libs/icu/io/uprintf.h b/contrib/libs/icu/io/uprintf.h
index 0fd6066e56..b1aa4930c7 100644
--- a/contrib/libs/icu/io/uprintf.h
+++ b/contrib/libs/icu/io/uprintf.h
@@ -1,4 +1,4 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2016 and later: Unicode, Inc. and others. 
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 ******************************************************************************
diff --git a/contrib/libs/icu/io/uprntf_p.cpp b/contrib/libs/icu/io/uprntf_p.cpp
index 1fbaf06c95..497e48e0f5 100644
--- a/contrib/libs/icu/io/uprntf_p.cpp
+++ b/contrib/libs/icu/io/uprntf_p.cpp
@@ -1,1606 +1,1606 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-*
-*   Copyright (C) 1998-2016, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*
-******************************************************************************
-*
-* File uprntf_p.c
-*
-* Modification History:
-*
-*   Date        Name        Description
-*   11/23/98    stephen     Creation.
-*   03/12/99    stephen     Modified for new C API.
-*   08/07/2003  george      Reunify printf implementations
-******************************************************************************
-*/
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_CONVERSION
-
-#include "unicode/ustring.h"
-#include "unicode/utf16.h"
-#include "uprintf.h"
-#include "ufmt_cmn.h"
-#include "cmemory.h"
-#include "putilimp.h"
-
-/* ANSI style formatting */
-/* Use US-ASCII characters only for formatting */
-
-/* % */
-#define UFMT_SIMPLE_PERCENT {ufmt_simple_percent, u_printf_simple_percent_handler}
-/* s */
-#define UFMT_STRING         {ufmt_string, u_printf_string_handler}
-/* c */
-#define UFMT_CHAR           {ufmt_char, u_printf_char_handler}
-/* d, i */
-#define UFMT_INT            {ufmt_int, u_printf_integer_handler}
-/* u */
-#define UFMT_UINT           {ufmt_int, u_printf_uinteger_handler}
-/* o */
-#define UFMT_OCTAL          {ufmt_int, u_printf_octal_handler}
-/* x, X */
-#define UFMT_HEX            {ufmt_int, u_printf_hex_handler}
-/* f */
-#define UFMT_DOUBLE         {ufmt_double, u_printf_double_handler}
-/* e, E */
-#define UFMT_SCIENTIFIC     {ufmt_double, u_printf_scientific_handler}
-/* g, G */
-#define UFMT_SCIDBL         {ufmt_double, u_printf_scidbl_handler}
-/* n */
-#define UFMT_COUNT          {ufmt_count, u_printf_count_handler}
-
-/* non-ANSI extensions */
-/* Use US-ASCII characters only for formatting */
-
-/* p */
-#define UFMT_POINTER        {ufmt_pointer, u_printf_pointer_handler}
-/* V */
-#define UFMT_SPELLOUT       {ufmt_double, u_printf_spellout_handler}
-/* P */
-#define UFMT_PERCENT        {ufmt_double, u_printf_percent_handler}
-/* C  K is old format */
-#define UFMT_UCHAR          {ufmt_uchar, u_printf_uchar_handler}
-/* S  U is old format */
-#define UFMT_USTRING        {ufmt_ustring, u_printf_ustring_handler}
-
-
-#define UFMT_EMPTY {ufmt_empty, NULL}
-
-/**
- * A u_printf handler function.  
- * A u_printf handler is responsible for handling a single u_printf 
- * format specification, for example 'd' or 's'.
- * @param stream The UFILE to which to write output.
- * @param info A pointer to a <TT>u_printf_spec_info</TT> struct containing
- * information on the format specification.
- * @param args A pointer to the argument data
- * @return The number of Unicode characters written to <TT>stream</TT>.
- */
-typedef int32_t U_EXPORT2
-u_printf_handler(const u_printf_stream_handler  *handler,
-
-                 void                           *context,
-                 ULocaleBundle                  *formatBundle,
-                 const u_printf_spec_info       *info,
-                 const ufmt_args                *args);
-
-typedef struct u_printf_info {
-    ufmt_type_info info;
-    u_printf_handler *handler;
-} u_printf_info;
-
-/**
- * Struct encapsulating a single uprintf format specification.
- */
-typedef struct u_printf_spec {
-  u_printf_spec_info    fInfo;        /* Information on this spec */
-  int32_t        fWidthPos;     /* Position of width in arg list */
-  int32_t        fPrecisionPos;    /* Position of precision in arg list */
-  int32_t        fArgPos;    /* Position of data in arg list */
-} u_printf_spec;
-
-#define UPRINTF_NUM_FMT_HANDLERS 108
-
-/* We do not use handlers for 0-0x1f */
-#define UPRINTF_BASE_FMT_HANDLERS 0x20
-
-/* buffer size for formatting */
-#define UPRINTF_BUFFER_SIZE 1024
-#define UPRINTF_SYMBOL_BUFFER_SIZE 8
-
-static const UChar gNullStr[] = {0x28, 0x6E, 0x75, 0x6C, 0x6C, 0x29, 0}; /* "(null)" */
-static const UChar gSpaceStr[] = {0x20, 0}; /* " " */
-
-/* Sets the sign of a format based on u_printf_spec_info */
-/* TODO: Is setting the prefix symbol to a positive sign a good idea in all locales? */
-static void
-u_printf_set_sign(UNumberFormat        *format,
-                   const u_printf_spec_info     *info,
-                   UChar *prefixBuffer,
-                   int32_t *prefixBufLen,
-                   UErrorCode *status)
-{
-    if(info->fShowSign) {
-        *prefixBufLen = unum_getTextAttribute(format,
-                                              UNUM_POSITIVE_PREFIX,
-                                              prefixBuffer,
-                                              *prefixBufLen,
-                                              status);
-        if (info->fSpace) {
-            /* Setting UNUM_PLUS_SIGN_SYMBOL affects the exponent too. */
-            /* unum_setSymbol(format, UNUM_PLUS_SIGN_SYMBOL, gSpaceStr, 1, &status); */
-            unum_setTextAttribute(format, UNUM_POSITIVE_PREFIX, gSpaceStr, 1, status);
-        }
-        else {
-            UChar plusSymbol[UPRINTF_SYMBOL_BUFFER_SIZE];
-            int32_t symbolLen;
-
-            symbolLen = unum_getSymbol(format,
-                UNUM_PLUS_SIGN_SYMBOL,
-                plusSymbol,
-                UPRV_LENGTHOF(plusSymbol),
-                status);
-            unum_setTextAttribute(format,
-                UNUM_POSITIVE_PREFIX,
-                plusSymbol,
-                symbolLen,
-                status);
-        }
-    }
-    else {
-        *prefixBufLen = 0;
-    }
-}
-
-static void
-u_printf_reset_sign(UNumberFormat        *format,
-                   const u_printf_spec_info     *info,
-                   UChar *prefixBuffer,
-                   int32_t *prefixBufLen,
-                   UErrorCode *status)
-{
-    if(info->fShowSign) {
-        unum_setTextAttribute(format,
-                              UNUM_POSITIVE_PREFIX,
-                              prefixBuffer,
-                              *prefixBufLen,
-                              status);
-    }
-}
-
-
-/* handle a '%' */
-static int32_t
-u_printf_simple_percent_handler(const u_printf_stream_handler  *handler,
-                                void                           *context,
-                                ULocaleBundle                  *formatBundle,
-                                const u_printf_spec_info       *info,
-                                const ufmt_args                *args)
-{
-    (void)formatBundle;
-    (void)info;
-    (void)args;
-    static const UChar PERCENT[] = { UP_PERCENT };
-
-    /* put a single '%' onto the output */
-    return handler->write(context, PERCENT, 1);
-}
-
-/* handle 's' */
-static int32_t
-u_printf_string_handler(const u_printf_stream_handler  *handler,
-                        void                           *context,
-                        ULocaleBundle                  *formatBundle,
-                        const u_printf_spec_info       *info,
-                        const ufmt_args                *args)
-{
-    (void)formatBundle;
-    UChar *s;
-    UChar buffer[UFMT_DEFAULT_BUFFER_SIZE];
-    int32_t len, written;
-    int32_t argSize;
-    const char *arg = (const char*)(args[0].ptrValue);
-
-    /* convert from the default codepage to Unicode */
-    if (arg) {
-        argSize = (int32_t)strlen(arg) + 1;
-        if (argSize >= MAX_UCHAR_BUFFER_SIZE(buffer)) {
-            s = ufmt_defaultCPToUnicode(arg, argSize,
-                    (UChar *)uprv_malloc(MAX_UCHAR_BUFFER_NEEDED(argSize)),
-                    MAX_UCHAR_BUFFER_NEEDED(argSize));
-            if(s == NULL) {
-                return 0;
-            }
-        }
-        else {
-            s = ufmt_defaultCPToUnicode(arg, argSize, buffer,
-                    UPRV_LENGTHOF(buffer));
-        }
-    }
-    else {
-        s = (UChar *)gNullStr;
-    }
-    len = u_strlen(s);
-
-    /* width = minimum # of characters to write */
-    /* precision = maximum # of characters to write */
-    if (info->fPrecision != -1 && info->fPrecision < len) {
-        len = info->fPrecision;
-    }
-
-    written = handler->pad_and_justify(context, info, s, len);
-
-    /* clean up */
-    if (gNullStr != s && buffer != s) {
-        uprv_free(s);
-    }
-
-    return written;
-}
-
-static int32_t
-u_printf_char_handler(const u_printf_stream_handler  *handler,
-                      void                           *context,
-                      ULocaleBundle                  *formatBundle,
-                      const u_printf_spec_info       *info,
-                      const ufmt_args                *args)
-{
-    (void)formatBundle;
-    UChar s[U16_MAX_LENGTH+1];
-    int32_t len = 1, written;
-    unsigned char arg = (unsigned char)(args[0].int64Value);
-
-    /* convert from default codepage to Unicode */
-    ufmt_defaultCPToUnicode((const char *)&arg, 2, s, UPRV_LENGTHOF(s));
-
-    /* Remember that this may be an MBCS character */
-    if (arg != 0) {
-        len = u_strlen(s);
-    }
-
-    /* width = minimum # of characters to write */
-    /* precision = maximum # of characters to write */
-    /* precision is ignored when handling a char */
-
-    written = handler->pad_and_justify(context, info, s, len);
-
-    return written;
-}
-
-static int32_t
-u_printf_double_handler(const u_printf_stream_handler  *handler,
-                        void                           *context,
-                        ULocaleBundle                  *formatBundle,
-                        const u_printf_spec_info       *info,
-                        const ufmt_args                *args)
-{
-    double        num         = (double) (args[0].doubleValue);
-    UNumberFormat  *format;
-    UChar          result[UPRINTF_BUFFER_SIZE];
-    UChar          prefixBuffer[UPRINTF_BUFFER_SIZE];
-    int32_t        prefixBufferLen = sizeof(prefixBuffer);
-    int32_t        minDecimalDigits;
-    int32_t        maxDecimalDigits;
-    int32_t        resultLen;
-    UErrorCode     status        = U_ZERO_ERROR;
-
-    prefixBuffer[0] = 0;
-
-    /* mask off any necessary bits */
-    /*  if(! info->fIsLongDouble)
-    num &= DBL_MAX;*/
-
-    /* get the formatter */
-    format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL);
-
-    /* handle error */
-    if(format == 0)
-        return 0;
-
-    /* save the formatter's state */
-    minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
-    maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);
-
-    /* set the appropriate flags and number of decimal digits on the formatter */
-    if(info->fPrecision != -1) {
-        /* set the # of decimal digits */
-        unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
-    }
-    else if(info->fAlt) {
-        /* '#' means always show decimal point */
-        /* copy of printf behavior on Solaris - '#' shows 6 digits */
-        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
-    }
-    else {
-        /* # of decimal digits is 6 if precision not specified regardless of locale */
-        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
-    }
-
-    /* set whether to show the sign */
-    if (info->fShowSign) {
-        u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status);
-    }
-
-    /* format the number */
-    resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status);
-
-    if (U_FAILURE(status)) {
-        resultLen = 0;
-    }
-
-    /* restore the number format */
-    /* TODO: Is this needed? */
-    unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
-    unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);
-
-    if (info->fShowSign) {
-        /* Reset back to original value regardless of what the error was */
-        UErrorCode localStatus = U_ZERO_ERROR;
-        u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus);
-    }
-
-    return handler->pad_and_justify(context, info, result, resultLen);
-}
-
-/* HSYS */
-static int32_t
-u_printf_integer_handler(const u_printf_stream_handler  *handler,
-                         void                           *context,
-                         ULocaleBundle                  *formatBundle,
-                         const u_printf_spec_info       *info,
-                         const ufmt_args                *args)
-{
-    int64_t         num        = args[0].int64Value;
-    UNumberFormat   *format;
-    UChar           result[UPRINTF_BUFFER_SIZE];
-    UChar           prefixBuffer[UPRINTF_BUFFER_SIZE];
-    int32_t         prefixBufferLen = sizeof(prefixBuffer);
-    int32_t         minDigits     = -1;
-    int32_t         resultLen;
-    UErrorCode      status        = U_ZERO_ERROR;
-
-    prefixBuffer[0] = 0;
-
-    /* mask off any necessary bits */
-    if (info->fIsShort)
-        num = (int16_t)num;
-    else if (!info->fIsLongLong)
-        num = (int32_t)num;
-
-    /* get the formatter */
-    format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL);
-
-    /* handle error */
-    if(format == 0)
-        return 0;
-
-    /* set the appropriate flags on the formatter */
-
-    /* set the minimum integer digits */
-    if(info->fPrecision != -1) {
-        /* set the minimum # of digits */
-        minDigits = unum_getAttribute(format, UNUM_MIN_INTEGER_DIGITS);
-        unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, info->fPrecision);
-    }
-
-    /* set whether to show the sign */
-    if(info->fShowSign) {
-        u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status);
-    }
-
-    /* format the number */
-    resultLen = unum_formatInt64(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status);
-
-    if (U_FAILURE(status)) {
-        resultLen = 0;
-    }
-
-    /* restore the number format */
-    if (minDigits != -1) {
-        unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, minDigits);
-    }
-
-    if (info->fShowSign) {
-        /* Reset back to original value regardless of what the error was */
-        UErrorCode localStatus = U_ZERO_ERROR;
-        u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus);
-    }
-
-    return handler->pad_and_justify(context, info, result, resultLen);
-}
-
-static int32_t
-u_printf_hex_handler(const u_printf_stream_handler  *handler,
-                     void                           *context,
-                     ULocaleBundle                  *formatBundle,
-                     const u_printf_spec_info       *info,
-                     const ufmt_args                *args)
-{
-    (void)formatBundle;
-    int64_t         num        = args[0].int64Value;
-    UChar           result[UPRINTF_BUFFER_SIZE];
-    int32_t         len        = UPRINTF_BUFFER_SIZE;
-
-
-    /* mask off any necessary bits */
-    if (info->fIsShort)
-        num &= UINT16_MAX;
-    else if (!info->fIsLongLong)
-        num &= UINT32_MAX;
-
-    /* format the number, preserving the minimum # of digits */
-    ufmt_64tou(result, &len, num, 16,
-        (UBool)(info->fSpec == 0x0078),
-        (info->fPrecision == -1 && info->fZero) ? info->fWidth : info->fPrecision);
-
-    /* convert to alt form, if desired */
-    if(num != 0 && info->fAlt && len < UPRINTF_BUFFER_SIZE - 2) {
-        /* shift the formatted string right by 2 chars */
-        memmove(result + 2, result, len * sizeof(UChar));
-        result[0] = 0x0030;
-        result[1] = info->fSpec;
-        len += 2;
-    }
-
-    return handler->pad_and_justify(context, info, result, len);
-}
-
-static int32_t
-u_printf_octal_handler(const u_printf_stream_handler  *handler,
-                       void                           *context,
-                       ULocaleBundle                  *formatBundle,
-                       const u_printf_spec_info       *info,
-                       const ufmt_args                *args)
-{
-    (void)formatBundle;
-    int64_t         num        = args[0].int64Value;
-    UChar           result[UPRINTF_BUFFER_SIZE];
-    int32_t         len        = UPRINTF_BUFFER_SIZE;
-
-
-    /* mask off any necessary bits */
-    if (info->fIsShort)
-        num &= UINT16_MAX;
-    else if (!info->fIsLongLong)
-        num &= UINT32_MAX;
-
-    /* format the number, preserving the minimum # of digits */
-    ufmt_64tou(result, &len, num, 8,
-        FALSE, /* doesn't matter for octal */
-        info->fPrecision == -1 && info->fZero ? info->fWidth : info->fPrecision);
-
-    /* convert to alt form, if desired */
-    if(info->fAlt && result[0] != 0x0030 && len < UPRINTF_BUFFER_SIZE - 1) {
-        /* shift the formatted string right by 1 char */
-        memmove(result + 1, result, len * sizeof(UChar));
-        result[0] = 0x0030;
-        len += 1;
-    }
-
-    return handler->pad_and_justify(context, info, result, len);
-}
-
-static int32_t
-u_printf_uinteger_handler(const u_printf_stream_handler *handler,
-                          void                          *context,
-                          ULocaleBundle                 *formatBundle,
-                          const u_printf_spec_info      *info,
-                          const ufmt_args               *args)
-{
-    int64_t         num        = args[0].int64Value;
-    UNumberFormat   *format;
-    UChar           result[UPRINTF_BUFFER_SIZE];
-    int32_t         minDigits     = -1;
-    int32_t         resultLen;
-    UErrorCode      status        = U_ZERO_ERROR;
-
-    /* TODO: Fix this once uint64_t can be formatted. */
-    if (info->fIsShort)
-        num &= UINT16_MAX;
-    else if (!info->fIsLongLong)
-        num &= UINT32_MAX;
-
-    /* get the formatter */
-    format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL);
-
-    /* handle error */
-    if(format == 0)
-        return 0;
-
-    /* set the appropriate flags on the formatter */
-
-    /* set the minimum integer digits */
-    if(info->fPrecision != -1) {
-        /* set the minimum # of digits */
-        minDigits = unum_getAttribute(format, UNUM_MIN_INTEGER_DIGITS);
-        unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, info->fPrecision);
-    }
-
-    /* To mirror other stdio implementations, we ignore the sign argument */
-
-    /* format the number */
-    resultLen = unum_formatInt64(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status);
-
-    if (U_FAILURE(status)) {
-        resultLen = 0;
-    }
-
-    /* restore the number format */
-    if (minDigits != -1) {
-        unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, minDigits);
-    }
-
-    return handler->pad_and_justify(context, info, result, resultLen);
-}
-
-static int32_t
-u_printf_pointer_handler(const u_printf_stream_handler  *handler,
-                         void                           *context,
-                         ULocaleBundle                  *formatBundle,
-                         const u_printf_spec_info       *info,
-                         const ufmt_args                *args)
+// © 2016 and later: Unicode, Inc. and others. 
+// License & terms of use: http://www.unicode.org/copyright.html 
+/* 
+****************************************************************************** 
+* 
+*   Copyright (C) 1998-2016, International Business Machines 
+*   Corporation and others.  All Rights Reserved. 
+* 
+****************************************************************************** 
+* 
+* File uprntf_p.c 
+* 
+* Modification History: 
+* 
+*   Date        Name        Description 
+*   11/23/98    stephen     Creation. 
+*   03/12/99    stephen     Modified for new C API. 
+*   08/07/2003  george      Reunify printf implementations 
+****************************************************************************** 
+*/ 
+ 
+#include "unicode/utypes.h" 
+ 
+#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_CONVERSION 
+ 
+#include "unicode/ustring.h" 
+#include "unicode/utf16.h" 
+#include "uprintf.h" 
+#include "ufmt_cmn.h" 
+#include "cmemory.h" 
+#include "putilimp.h" 
+ 
+/* ANSI style formatting */ 
+/* Use US-ASCII characters only for formatting */ 
+ 
+/* % */ 
+#define UFMT_SIMPLE_PERCENT {ufmt_simple_percent, u_printf_simple_percent_handler} 
+/* s */ 
+#define UFMT_STRING         {ufmt_string, u_printf_string_handler} 
+/* c */ 
+#define UFMT_CHAR           {ufmt_char, u_printf_char_handler} 
+/* d, i */ 
+#define UFMT_INT            {ufmt_int, u_printf_integer_handler} 
+/* u */ 
+#define UFMT_UINT           {ufmt_int, u_printf_uinteger_handler} 
+/* o */ 
+#define UFMT_OCTAL          {ufmt_int, u_printf_octal_handler} 
+/* x, X */ 
+#define UFMT_HEX            {ufmt_int, u_printf_hex_handler} 
+/* f */ 
+#define UFMT_DOUBLE         {ufmt_double, u_printf_double_handler} 
+/* e, E */ 
+#define UFMT_SCIENTIFIC     {ufmt_double, u_printf_scientific_handler} 
+/* g, G */ 
+#define UFMT_SCIDBL         {ufmt_double, u_printf_scidbl_handler} 
+/* n */ 
+#define UFMT_COUNT          {ufmt_count, u_printf_count_handler} 
+ 
+/* non-ANSI extensions */ 
+/* Use US-ASCII characters only for formatting */ 
+ 
+/* p */ 
+#define UFMT_POINTER        {ufmt_pointer, u_printf_pointer_handler} 
+/* V */ 
+#define UFMT_SPELLOUT       {ufmt_double, u_printf_spellout_handler} 
+/* P */ 
+#define UFMT_PERCENT        {ufmt_double, u_printf_percent_handler} 
+/* C  K is old format */ 
+#define UFMT_UCHAR          {ufmt_uchar, u_printf_uchar_handler} 
+/* S  U is old format */ 
+#define UFMT_USTRING        {ufmt_ustring, u_printf_ustring_handler} 
+ 
+ 
+#define UFMT_EMPTY {ufmt_empty, NULL} 
+ 
+/** 
+ * A u_printf handler function.   
+ * A u_printf handler is responsible for handling a single u_printf  
+ * format specification, for example 'd' or 's'. 
+ * @param stream The UFILE to which to write output. 
+ * @param info A pointer to a <TT>u_printf_spec_info</TT> struct containing 
+ * information on the format specification. 
+ * @param args A pointer to the argument data 
+ * @return The number of Unicode characters written to <TT>stream</TT>. 
+ */ 
+typedef int32_t U_EXPORT2 
+u_printf_handler(const u_printf_stream_handler  *handler, 
+ 
+                 void                           *context, 
+                 ULocaleBundle                  *formatBundle, 
+                 const u_printf_spec_info       *info, 
+                 const ufmt_args                *args); 
+ 
+typedef struct u_printf_info { 
+    ufmt_type_info info; 
+    u_printf_handler *handler; 
+} u_printf_info; 
+ 
+/** 
+ * Struct encapsulating a single uprintf format specification. 
+ */ 
+typedef struct u_printf_spec { 
+  u_printf_spec_info    fInfo;        /* Information on this spec */ 
+  int32_t        fWidthPos;     /* Position of width in arg list */ 
+  int32_t        fPrecisionPos;    /* Position of precision in arg list */ 
+  int32_t        fArgPos;    /* Position of data in arg list */ 
+} u_printf_spec; 
+ 
+#define UPRINTF_NUM_FMT_HANDLERS 108 
+ 
+/* We do not use handlers for 0-0x1f */ 
+#define UPRINTF_BASE_FMT_HANDLERS 0x20 
+ 
+/* buffer size for formatting */ 
+#define UPRINTF_BUFFER_SIZE 1024 
+#define UPRINTF_SYMBOL_BUFFER_SIZE 8 
+ 
+static const UChar gNullStr[] = {0x28, 0x6E, 0x75, 0x6C, 0x6C, 0x29, 0}; /* "(null)" */ 
+static const UChar gSpaceStr[] = {0x20, 0}; /* " " */ 
+ 
+/* Sets the sign of a format based on u_printf_spec_info */ 
+/* TODO: Is setting the prefix symbol to a positive sign a good idea in all locales? */ 
+static void 
+u_printf_set_sign(UNumberFormat        *format, 
+                   const u_printf_spec_info     *info, 
+                   UChar *prefixBuffer, 
+                   int32_t *prefixBufLen, 
+                   UErrorCode *status) 
 { 
-    (void)formatBundle;
-    UChar           result[UPRINTF_BUFFER_SIZE];
-    int32_t         len  = UPRINTF_BUFFER_SIZE;
-
-    /* format the pointer in hex */
-    ufmt_ptou(result, &len, args[0].ptrValue, TRUE/*, info->fPrecision*/);
-
-    return handler->pad_and_justify(context, info, result, len);
-}
-
-static int32_t
-u_printf_scientific_handler(const u_printf_stream_handler  *handler,
-                            void                           *context,
-                            ULocaleBundle                  *formatBundle,
-                            const u_printf_spec_info       *info,
-                            const ufmt_args                *args)
-{
-    double          num         = (double) (args[0].doubleValue);
-    UNumberFormat   *format;
-    UChar           result[UPRINTF_BUFFER_SIZE];
-    UChar           prefixBuffer[UPRINTF_BUFFER_SIZE];
-    int32_t         prefixBufferLen = sizeof(prefixBuffer);
-    int32_t         minDecimalDigits;
-    int32_t         maxDecimalDigits;
-    UErrorCode      status        = U_ZERO_ERROR;
-    UChar srcExpBuf[UPRINTF_SYMBOL_BUFFER_SIZE];
-    int32_t srcLen, expLen;
-    int32_t resultLen;
-    UChar expBuf[UPRINTF_SYMBOL_BUFFER_SIZE];
-
-    prefixBuffer[0] = 0;
-
-    /* mask off any necessary bits */
-    /*  if(! info->fIsLongDouble)
-    num &= DBL_MAX;*/
-
-    /* get the formatter */
-    format = u_locbund_getNumberFormat(formatBundle, UNUM_SCIENTIFIC);
-
-    /* handle error */
-    if(format == 0)
-        return 0;
-
-    /* set the appropriate flags on the formatter */
-
-    srcLen = unum_getSymbol(format,
-        UNUM_EXPONENTIAL_SYMBOL,
-        srcExpBuf,
-        sizeof(srcExpBuf),
-        &status);
-
-    /* Upper/lower case the e */
-    if (info->fSpec == (UChar)0x65 /* e */) {
-        expLen = u_strToLower(expBuf, (int32_t)sizeof(expBuf),
-            srcExpBuf, srcLen,
-            formatBundle->fLocale,
-            &status);
-    }
-    else {
-        expLen = u_strToUpper(expBuf, (int32_t)sizeof(expBuf),
-            srcExpBuf, srcLen,
-            formatBundle->fLocale,
-            &status);
-    }
-
-    unum_setSymbol(format,
-        UNUM_EXPONENTIAL_SYMBOL,
-        expBuf,
-        expLen,
-        &status);
-
-    /* save the formatter's state */
-    minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
-    maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);
-
-    /* set the appropriate flags and number of decimal digits on the formatter */
-    if(info->fPrecision != -1) {
-        /* set the # of decimal digits */
-        if (info->fOrigSpec == (UChar)0x65 /* e */ || info->fOrigSpec == (UChar)0x45 /* E */) {
-            unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
-        }
-        else {
-            unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, 1);
-            unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, info->fPrecision);
-        }
-    }
-    else if(info->fAlt) {
-        /* '#' means always show decimal point */
-        /* copy of printf behavior on Solaris - '#' shows 6 digits */
-        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
-    }
-    else {
-        /* # of decimal digits is 6 if precision not specified */
-        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
-    }
-
-    /* set whether to show the sign */
-    if (info->fShowSign) {
-        u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status);
-    }
-
-    /* format the number */
-    resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status);
-
-    if (U_FAILURE(status)) {
-        resultLen = 0;
-    }
-
-    /* restore the number format */
-    /* TODO: Is this needed? */
-    unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
-    unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);
-
-    /* Since we're the only one using the scientific
-       format, we don't need to save the old exponent value. */
-    /*unum_setSymbol(format,
-        UNUM_EXPONENTIAL_SYMBOL,
-        srcExpBuf,
-        srcLen,
-        &status);*/
-
-    if (info->fShowSign) {
-        /* Reset back to original value regardless of what the error was */
-        UErrorCode localStatus = U_ZERO_ERROR;
-        u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus);
-    }
-
-    return handler->pad_and_justify(context, info, result, resultLen);
-}
-
-static int32_t
-u_printf_percent_handler(const u_printf_stream_handler  *handler,
-                         void                           *context,
-                         ULocaleBundle                  *formatBundle,
-                         const u_printf_spec_info       *info,
-                         const ufmt_args                *args)
-{
-    double          num         = (double) (args[0].doubleValue);
-    UNumberFormat   *format;
-    UChar           result[UPRINTF_BUFFER_SIZE];
-    UChar           prefixBuffer[UPRINTF_BUFFER_SIZE];
-    int32_t         prefixBufferLen = sizeof(prefixBuffer);
-    int32_t         minDecimalDigits;
-    int32_t         maxDecimalDigits;
-    int32_t         resultLen;
-    UErrorCode      status        = U_ZERO_ERROR;
-
-    prefixBuffer[0] = 0;
-
-    /* mask off any necessary bits */
-    /*  if(! info->fIsLongDouble)
-    num &= DBL_MAX;*/
-
-    /* get the formatter */
-    format = u_locbund_getNumberFormat(formatBundle, UNUM_PERCENT);
-
-    /* handle error */
-    if(format == 0)
-        return 0;
-
-    /* save the formatter's state */
-    minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
-    maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);
-
-    /* set the appropriate flags and number of decimal digits on the formatter */
-    if(info->fPrecision != -1) {
-        /* set the # of decimal digits */
-        unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
-    }
-    else if(info->fAlt) {
-        /* '#' means always show decimal point */
-        /* copy of printf behavior on Solaris - '#' shows 6 digits */
-        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
-    }
-    else {
-        /* # of decimal digits is 6 if precision not specified */
-        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
-    }
-
-    /* set whether to show the sign */
-    if (info->fShowSign) {
-        u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status);
-    }
-
-    /* format the number */
-    resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status);
-
-    if (U_FAILURE(status)) {
-        resultLen = 0;
-    }
-
-    /* restore the number format */
-    /* TODO: Is this needed? */
-    unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
-    unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);
-
-    if (info->fShowSign) {
-        /* Reset back to original value regardless of what the error was */
-        UErrorCode localStatus = U_ZERO_ERROR;
-        u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus);
-    }
-
-    return handler->pad_and_justify(context, info, result, resultLen);
-}
-
-static int32_t
-u_printf_ustring_handler(const u_printf_stream_handler  *handler,
-                         void                           *context,
-                         ULocaleBundle                  *formatBundle,
-                         const u_printf_spec_info       *info,
-                         const ufmt_args                *args)
-{
-    (void)formatBundle;
-    int32_t len, written;
-    const UChar *arg = (const UChar*)(args[0].ptrValue);
-
-    /* allocate enough space for the buffer */
-    if (arg == NULL) {
-        arg = gNullStr;
-    }
-    len = u_strlen(arg);
-
-    /* width = minimum # of characters to write */
-    /* precision = maximum # of characters to write */
-    if (info->fPrecision != -1 && info->fPrecision < len) {
-        len = info->fPrecision;
-    }
-
-    /* determine if the string should be padded */
-    written = handler->pad_and_justify(context, info, arg, len);
-
-    return written;
-}
-
-static int32_t
-u_printf_uchar_handler(const u_printf_stream_handler  *handler,
-                       void                           *context,
-                       ULocaleBundle                  *formatBundle,
-                       const u_printf_spec_info       *info,
-                       const ufmt_args                *args)
-{
-    (void)formatBundle;
-    int32_t written = 0;
-    UChar arg = (UChar)(args[0].int64Value);
-
-    /* width = minimum # of characters to write */
-    /* precision = maximum # of characters to write */
-    /* precision is ignored when handling a uchar */
-
-    /* determine if the string should be padded */
-    written = handler->pad_and_justify(context, info, &arg, 1);
-
-    return written;
-}
-
-static int32_t
-u_printf_scidbl_handler(const u_printf_stream_handler  *handler,
-                        void                           *context,
-                        ULocaleBundle                  *formatBundle,
-                        const u_printf_spec_info       *info,
-                        const ufmt_args                *args)
-{
-    u_printf_spec_info scidbl_info;
-    double      num = args[0].doubleValue;
-    int32_t     retVal;
-    UNumberFormat *format;
-    int32_t maxSigDecimalDigits, significantDigits;
-
-    memcpy(&scidbl_info, info, sizeof(u_printf_spec_info));
-
-    /* determine whether to use 'd', 'e' or 'f' notation */
-    if (scidbl_info.fPrecision == -1 && num == uprv_trunc(num))
-    {
-        /* use 'f' notation */
-        scidbl_info.fSpec = 0x0066;
-        scidbl_info.fPrecision = 0;
-        /* call the double handler */
-        retVal = u_printf_double_handler(handler, context, formatBundle, &scidbl_info, args);
-    }
-    else if(num < 0.0001 || (scidbl_info.fPrecision < 1 && 1000000.0 <= num)
-        || (scidbl_info.fPrecision != -1 && num > uprv_pow10(scidbl_info.fPrecision)))
-    {
-        /* use 'e' or 'E' notation */
-        scidbl_info.fSpec = scidbl_info.fSpec - 2;
-        if (scidbl_info.fPrecision == -1) {
-            scidbl_info.fPrecision = 5;
-        }
-        /* call the scientific handler */
-        retVal = u_printf_scientific_handler(handler, context, formatBundle, &scidbl_info, args);
-    }
-    else {
-        format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL);
-        /* Check for null pointer */
-        if (format == NULL) {
-            return 0;
-        }
-        maxSigDecimalDigits = unum_getAttribute(format, UNUM_MAX_SIGNIFICANT_DIGITS);
-        significantDigits = scidbl_info.fPrecision;
-
-        /* use 'f' notation */
-        scidbl_info.fSpec = 0x0066;
-        if (significantDigits == -1) {
-            significantDigits = 6;
-        }
-        unum_setAttribute(format, UNUM_SIGNIFICANT_DIGITS_USED, TRUE);
-        unum_setAttribute(format, UNUM_MAX_SIGNIFICANT_DIGITS, significantDigits);
-        /* call the double handler */
-        retVal = u_printf_double_handler(handler, context, formatBundle, &scidbl_info, args);
-        unum_setAttribute(format, UNUM_MAX_SIGNIFICANT_DIGITS, maxSigDecimalDigits);
-        unum_setAttribute(format, UNUM_SIGNIFICANT_DIGITS_USED, FALSE);
-    }
-    return retVal;
-}
-
-static int32_t
-u_printf_count_handler(const u_printf_stream_handler  *handler,
-                       void                           *context,
-                       ULocaleBundle                  *formatBundle,
-                       const u_printf_spec_info       *info,
-                       const ufmt_args                *args)
-{
-    (void)handler;
-    (void)context;
-    (void)formatBundle;
-    int32_t *count = (int32_t*)(args[0].ptrValue);
-
-    /* in the special case of count, the u_printf_spec_info's width */
-    /* will contain the # of chars written thus far */
-    *count = info->fWidth;
-
-    return 0;
-}
-
-static int32_t
-u_printf_spellout_handler(const u_printf_stream_handler *handler,
-                          void                          *context,
-                          ULocaleBundle                 *formatBundle,
-                          const u_printf_spec_info      *info,
-                          const ufmt_args               *args)
-{
-    double          num         = (double) (args[0].doubleValue);
-    UNumberFormat   *format;
-    UChar           result[UPRINTF_BUFFER_SIZE];
-    UChar           prefixBuffer[UPRINTF_BUFFER_SIZE];
-    int32_t         prefixBufferLen = sizeof(prefixBuffer);
-    int32_t         minDecimalDigits;
-    int32_t         maxDecimalDigits;
-    int32_t         resultLen;
-    UErrorCode      status        = U_ZERO_ERROR;
-
-    prefixBuffer[0] = 0;
-
-    /* mask off any necessary bits */
-    /*  if(! info->fIsLongDouble)
-    num &= DBL_MAX;*/
-
-    /* get the formatter */
-    format = u_locbund_getNumberFormat(formatBundle, UNUM_SPELLOUT);
-
-    /* handle error */
-    if(format == 0)
-        return 0;
-
-    /* save the formatter's state */
-    minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
-    maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);
-
-    /* set the appropriate flags and number of decimal digits on the formatter */
-    if(info->fPrecision != -1) {
-        /* set the # of decimal digits */
-        unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
-    }
-    else if(info->fAlt) {
-        /* '#' means always show decimal point */
-        /* copy of printf behavior on Solaris - '#' shows 6 digits */
-        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
-    }
-    else {
-        /* # of decimal digits is 6 if precision not specified */
-        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
-    }
-
-    /* set whether to show the sign */
-    if (info->fShowSign) {
-        u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status);
-    }
-
-    /* format the number */
-    resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status);
-
-    if (U_FAILURE(status)) {
-        resultLen = 0;
-    }
-
-    /* restore the number format */
-    /* TODO: Is this needed? */
-    unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
-    unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);
-
-    if (info->fShowSign) {
-        /* Reset back to original value regardless of what the error was */
-        UErrorCode localStatus = U_ZERO_ERROR;
-        u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus);
-    }
-
-    return handler->pad_and_justify(context, info, result, resultLen);
-}
-
-/* Use US-ASCII characters only for formatting. Most codepages have
- characters 20-7F from Unicode. Using any other codepage specific
- characters will make it very difficult to format the string on
- non-Unicode machines */
-static const u_printf_info g_u_printf_infos[UPRINTF_NUM_FMT_HANDLERS] = {
-/* 0x20 */
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_SIMPLE_PERCENT,UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-
-/* 0x30 */
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-
-/* 0x40 */
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_UCHAR,
-    UFMT_EMPTY,         UFMT_SCIENTIFIC,    UFMT_EMPTY,         UFMT_SCIDBL,
-#ifdef U_USE_OBSOLETE_IO_FORMATTING
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_UCHAR/*deprecated*/,
-#else
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-#endif
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-
-/* 0x50 */
-    UFMT_PERCENT,       UFMT_EMPTY,         UFMT_EMPTY,         UFMT_USTRING,
-#ifdef U_USE_OBSOLETE_IO_FORMATTING
-    UFMT_EMPTY,         UFMT_USTRING/*deprecated*/,UFMT_SPELLOUT,      UFMT_EMPTY,
-#else
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_SPELLOUT,      UFMT_EMPTY,
-#endif
-    UFMT_HEX,           UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-
-/* 0x60 */
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_CHAR,
-    UFMT_INT,           UFMT_SCIENTIFIC,    UFMT_DOUBLE,        UFMT_SCIDBL,
-    UFMT_EMPTY,         UFMT_INT,           UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_COUNT,         UFMT_OCTAL,
-
-/* 0x70 */
-    UFMT_POINTER,       UFMT_EMPTY,         UFMT_EMPTY,         UFMT_STRING,
-    UFMT_EMPTY,         UFMT_UINT,          UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_HEX,           UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-};
-
-/* flag characters for uprintf */
-#define FLAG_MINUS 0x002D
-#define FLAG_PLUS 0x002B
-#define FLAG_SPACE 0x0020
-#define FLAG_POUND 0x0023
-#define FLAG_ZERO  0x0030
-#define FLAG_PAREN 0x0028
-
-#define ISFLAG(s)    (s) == FLAG_MINUS || \
-            (s) == FLAG_PLUS || \
-            (s) == FLAG_SPACE || \
-            (s) == FLAG_POUND || \
-            (s) == FLAG_ZERO || \
-            (s) == FLAG_PAREN
-
-/* special characters for uprintf */
-#define SPEC_ASTERISK 0x002A
-#define SPEC_DOLLARSIGN 0x0024
-#define SPEC_PERIOD 0x002E
-#define SPEC_PERCENT 0x0025
-
-/* unicode digits */
-#define DIGIT_ZERO 0x0030
-#define DIGIT_ONE 0x0031
-#define DIGIT_TWO 0x0032
-#define DIGIT_THREE 0x0033
-#define DIGIT_FOUR 0x0034
-#define DIGIT_FIVE 0x0035
-#define DIGIT_SIX 0x0036
-#define DIGIT_SEVEN 0x0037
-#define DIGIT_EIGHT 0x0038
-#define DIGIT_NINE 0x0039
-
-#define ISDIGIT(s)    (s) == DIGIT_ZERO || \
-            (s) == DIGIT_ONE || \
-            (s) == DIGIT_TWO || \
-            (s) == DIGIT_THREE || \
-            (s) == DIGIT_FOUR || \
-            (s) == DIGIT_FIVE || \
-            (s) == DIGIT_SIX || \
-            (s) == DIGIT_SEVEN || \
-            (s) == DIGIT_EIGHT || \
-            (s) == DIGIT_NINE
-
-/* u_printf modifiers */
-#define MOD_H 0x0068
-#define MOD_LOWERL 0x006C
-#define MOD_L 0x004C
-
-#define ISMOD(s)    (s) == MOD_H || \
-            (s) == MOD_LOWERL || \
-            (s) == MOD_L
-/* Returns an array of the parsed argument type given in the format string. */
-static ufmt_args* parseArguments(const UChar *alias, va_list ap, UErrorCode *status) {
-    ufmt_args *arglist = NULL;
-    ufmt_type_info *typelist = NULL;
-    UBool *islonglong = NULL;
-    int32_t size = 0;
-    int32_t pos = 0;
-    UChar type;
-    uint16_t handlerNum;
-    const UChar *aliasStart = alias;
-
-    /* get maximum number of arguments */
-    for(;;) {
-        /* find % */
-        while(*alias != UP_PERCENT && *alias != 0x0000) {
-            alias++;
-        }
-
-        if(*alias == 0x0000) {
-            break;
-        }
-
-        alias++;
-
-        /* handle the pos number */
-        if(ISDIGIT(*alias)) {
-
-            /* handle positional parameters */
-            if(ISDIGIT(*alias)) {
-                pos = (int) (*alias++ - DIGIT_ZERO);
-
-                while(ISDIGIT(*alias)) {
-                    pos *= 10;
-                    pos += (int) (*alias++ - DIGIT_ZERO);
-                }
-            }
-
-            /* if there is no '$', don't read anything */
-            if(*alias != SPEC_DOLLARSIGN) {
-                return NULL;
-            }
-        } else {
-            return NULL;
-        }
-
-        if (pos > size) {
-            size = pos;
-        }
-    }
-
-    /* create the parsed argument list */
-    typelist = (ufmt_type_info*)uprv_malloc(sizeof(ufmt_type_info) * size);
-    islonglong = (UBool*)uprv_malloc(sizeof(UBool) * size);
-    arglist = (ufmt_args*)uprv_malloc(sizeof(ufmt_args) * size);
-
-    /* If malloc failed, return NULL */
-    if (!typelist || !islonglong || !arglist) {
-        if (typelist) {
-            uprv_free(typelist);
-        }
-
-        if (islonglong) {
-            uprv_free(islonglong);
-        }
-
-        if (arglist) {
-            uprv_free(arglist);
-        }
-
-        *status = U_MEMORY_ALLOCATION_ERROR;
-        return NULL;
-    }
-
-    /* reset alias back to the beginning */
-    alias = aliasStart;
-
-    for(;;) {
-        /* find % */
-        while(*alias != UP_PERCENT && *alias != 0x0000) {
-            alias++;
-        }
-
-        if(*alias == 0x0000) {
-            break;
-        }
-
-        alias++;
-
-        /* handle positional parameters */
-        if(ISDIGIT(*alias)) {
-            pos = (int) (*alias++ - DIGIT_ZERO);
-
-            while(ISDIGIT(*alias)) {
-                pos *= 10;
-                pos += (int) (*alias++ - DIGIT_ZERO);
-            }
-        }
-        /* offset position by 1 */
-        pos--;
-
-        /* skip over everything except for the type */
-        while (ISMOD(*alias) || ISFLAG(*alias) || ISDIGIT(*alias) || 
-            *alias == SPEC_ASTERISK || *alias == SPEC_PERIOD || *alias == SPEC_DOLLARSIGN) {
-                islonglong[pos] = FALSE;
-                if (ISMOD(*alias)) {
-                    alias++;
-                    if (*alias == MOD_LOWERL) {
-                        islonglong[pos] = TRUE;
+    if(info->fShowSign) { 
+        *prefixBufLen = unum_getTextAttribute(format, 
+                                              UNUM_POSITIVE_PREFIX, 
+                                              prefixBuffer, 
+                                              *prefixBufLen, 
+                                              status); 
+        if (info->fSpace) { 
+            /* Setting UNUM_PLUS_SIGN_SYMBOL affects the exponent too. */ 
+            /* unum_setSymbol(format, UNUM_PLUS_SIGN_SYMBOL, gSpaceStr, 1, &status); */ 
+            unum_setTextAttribute(format, UNUM_POSITIVE_PREFIX, gSpaceStr, 1, status); 
+        } 
+        else { 
+            UChar plusSymbol[UPRINTF_SYMBOL_BUFFER_SIZE]; 
+            int32_t symbolLen; 
+ 
+            symbolLen = unum_getSymbol(format, 
+                UNUM_PLUS_SIGN_SYMBOL, 
+                plusSymbol, 
+                UPRV_LENGTHOF(plusSymbol), 
+                status); 
+            unum_setTextAttribute(format, 
+                UNUM_POSITIVE_PREFIX, 
+                plusSymbol, 
+                symbolLen, 
+                status); 
+        } 
+    } 
+    else { 
+        *prefixBufLen = 0; 
+    } 
+} 
+ 
+static void 
+u_printf_reset_sign(UNumberFormat        *format, 
+                   const u_printf_spec_info     *info, 
+                   UChar *prefixBuffer, 
+                   int32_t *prefixBufLen, 
+                   UErrorCode *status) 
+{ 
+    if(info->fShowSign) { 
+        unum_setTextAttribute(format, 
+                              UNUM_POSITIVE_PREFIX, 
+                              prefixBuffer, 
+                              *prefixBufLen, 
+                              status); 
+    } 
+} 
+ 
+ 
+/* handle a '%' */ 
+static int32_t 
+u_printf_simple_percent_handler(const u_printf_stream_handler  *handler, 
+                                void                           *context, 
+                                ULocaleBundle                  *formatBundle, 
+                                const u_printf_spec_info       *info, 
+                                const ufmt_args                *args) 
+{ 
+    (void)formatBundle; 
+    (void)info; 
+    (void)args; 
+    static const UChar PERCENT[] = { UP_PERCENT }; 
+ 
+    /* put a single '%' onto the output */ 
+    return handler->write(context, PERCENT, 1); 
+} 
+ 
+/* handle 's' */ 
+static int32_t 
+u_printf_string_handler(const u_printf_stream_handler  *handler, 
+                        void                           *context, 
+                        ULocaleBundle                  *formatBundle, 
+                        const u_printf_spec_info       *info, 
+                        const ufmt_args                *args) 
+{ 
+    (void)formatBundle; 
+    UChar *s; 
+    UChar buffer[UFMT_DEFAULT_BUFFER_SIZE]; 
+    int32_t len, written; 
+    int32_t argSize; 
+    const char *arg = (const char*)(args[0].ptrValue); 
+ 
+    /* convert from the default codepage to Unicode */ 
+    if (arg) { 
+        argSize = (int32_t)strlen(arg) + 1; 
+        if (argSize >= MAX_UCHAR_BUFFER_SIZE(buffer)) { 
+            s = ufmt_defaultCPToUnicode(arg, argSize, 
+                    (UChar *)uprv_malloc(MAX_UCHAR_BUFFER_NEEDED(argSize)), 
+                    MAX_UCHAR_BUFFER_NEEDED(argSize)); 
+            if(s == NULL) { 
+                return 0; 
+            } 
+        } 
+        else { 
+            s = ufmt_defaultCPToUnicode(arg, argSize, buffer, 
+                    UPRV_LENGTHOF(buffer)); 
+        } 
+    } 
+    else { 
+        s = (UChar *)gNullStr; 
+    } 
+    len = u_strlen(s); 
+ 
+    /* width = minimum # of characters to write */ 
+    /* precision = maximum # of characters to write */ 
+    if (info->fPrecision != -1 && info->fPrecision < len) { 
+        len = info->fPrecision; 
+    } 
+ 
+    written = handler->pad_and_justify(context, info, s, len); 
+ 
+    /* clean up */ 
+    if (gNullStr != s && buffer != s) { 
+        uprv_free(s); 
+    } 
+ 
+    return written; 
+} 
+ 
+static int32_t 
+u_printf_char_handler(const u_printf_stream_handler  *handler, 
+                      void                           *context, 
+                      ULocaleBundle                  *formatBundle, 
+                      const u_printf_spec_info       *info, 
+                      const ufmt_args                *args) 
+{ 
+    (void)formatBundle; 
+    UChar s[U16_MAX_LENGTH+1]; 
+    int32_t len = 1, written; 
+    unsigned char arg = (unsigned char)(args[0].int64Value); 
+ 
+    /* convert from default codepage to Unicode */ 
+    ufmt_defaultCPToUnicode((const char *)&arg, 2, s, UPRV_LENGTHOF(s)); 
+ 
+    /* Remember that this may be an MBCS character */ 
+    if (arg != 0) { 
+        len = u_strlen(s); 
+    } 
+ 
+    /* width = minimum # of characters to write */ 
+    /* precision = maximum # of characters to write */ 
+    /* precision is ignored when handling a char */ 
+ 
+    written = handler->pad_and_justify(context, info, s, len); 
+ 
+    return written; 
+} 
+ 
+static int32_t 
+u_printf_double_handler(const u_printf_stream_handler  *handler, 
+                        void                           *context, 
+                        ULocaleBundle                  *formatBundle, 
+                        const u_printf_spec_info       *info, 
+                        const ufmt_args                *args) 
+{ 
+    double        num         = (double) (args[0].doubleValue); 
+    UNumberFormat  *format; 
+    UChar          result[UPRINTF_BUFFER_SIZE]; 
+    UChar          prefixBuffer[UPRINTF_BUFFER_SIZE]; 
+    int32_t        prefixBufferLen = sizeof(prefixBuffer); 
+    int32_t        minDecimalDigits; 
+    int32_t        maxDecimalDigits; 
+    int32_t        resultLen; 
+    UErrorCode     status        = U_ZERO_ERROR; 
+ 
+    prefixBuffer[0] = 0; 
+ 
+    /* mask off any necessary bits */ 
+    /*  if(! info->fIsLongDouble) 
+    num &= DBL_MAX;*/ 
+ 
+    /* get the formatter */ 
+    format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL); 
+ 
+    /* handle error */ 
+    if(format == 0) 
+        return 0; 
+ 
+    /* save the formatter's state */ 
+    minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS); 
+    maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS); 
+ 
+    /* set the appropriate flags and number of decimal digits on the formatter */ 
+    if(info->fPrecision != -1) { 
+        /* set the # of decimal digits */ 
+        unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision); 
+    } 
+    else if(info->fAlt) { 
+        /* '#' means always show decimal point */ 
+        /* copy of printf behavior on Solaris - '#' shows 6 digits */ 
+        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); 
+    } 
+    else { 
+        /* # of decimal digits is 6 if precision not specified regardless of locale */ 
+        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); 
+    } 
+ 
+    /* set whether to show the sign */ 
+    if (info->fShowSign) { 
+        u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status); 
+    } 
+ 
+    /* format the number */ 
+    resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status); 
+ 
+    if (U_FAILURE(status)) { 
+        resultLen = 0; 
+    } 
+ 
+    /* restore the number format */ 
+    /* TODO: Is this needed? */ 
+    unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits); 
+    unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits); 
+ 
+    if (info->fShowSign) { 
+        /* Reset back to original value regardless of what the error was */ 
+        UErrorCode localStatus = U_ZERO_ERROR; 
+        u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus); 
+    } 
+ 
+    return handler->pad_and_justify(context, info, result, resultLen); 
+} 
+ 
+/* HSYS */ 
+static int32_t 
+u_printf_integer_handler(const u_printf_stream_handler  *handler, 
+                         void                           *context, 
+                         ULocaleBundle                  *formatBundle, 
+                         const u_printf_spec_info       *info, 
+                         const ufmt_args                *args) 
+{ 
+    int64_t         num        = args[0].int64Value; 
+    UNumberFormat   *format; 
+    UChar           result[UPRINTF_BUFFER_SIZE]; 
+    UChar           prefixBuffer[UPRINTF_BUFFER_SIZE]; 
+    int32_t         prefixBufferLen = sizeof(prefixBuffer); 
+    int32_t         minDigits     = -1; 
+    int32_t         resultLen; 
+    UErrorCode      status        = U_ZERO_ERROR; 
+ 
+    prefixBuffer[0] = 0; 
+ 
+    /* mask off any necessary bits */ 
+    if (info->fIsShort) 
+        num = (int16_t)num; 
+    else if (!info->fIsLongLong) 
+        num = (int32_t)num; 
+ 
+    /* get the formatter */ 
+    format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL); 
+ 
+    /* handle error */ 
+    if(format == 0) 
+        return 0; 
+ 
+    /* set the appropriate flags on the formatter */ 
+ 
+    /* set the minimum integer digits */ 
+    if(info->fPrecision != -1) { 
+        /* set the minimum # of digits */ 
+        minDigits = unum_getAttribute(format, UNUM_MIN_INTEGER_DIGITS); 
+        unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, info->fPrecision); 
+    } 
+ 
+    /* set whether to show the sign */ 
+    if(info->fShowSign) { 
+        u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status); 
+    } 
+ 
+    /* format the number */ 
+    resultLen = unum_formatInt64(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status); 
+ 
+    if (U_FAILURE(status)) { 
+        resultLen = 0; 
+    } 
+ 
+    /* restore the number format */ 
+    if (minDigits != -1) { 
+        unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, minDigits); 
+    } 
+ 
+    if (info->fShowSign) { 
+        /* Reset back to original value regardless of what the error was */ 
+        UErrorCode localStatus = U_ZERO_ERROR; 
+        u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus); 
+    } 
+ 
+    return handler->pad_and_justify(context, info, result, resultLen); 
+} 
+ 
+static int32_t 
+u_printf_hex_handler(const u_printf_stream_handler  *handler, 
+                     void                           *context, 
+                     ULocaleBundle                  *formatBundle, 
+                     const u_printf_spec_info       *info, 
+                     const ufmt_args                *args) 
+{ 
+    (void)formatBundle; 
+    int64_t         num        = args[0].int64Value; 
+    UChar           result[UPRINTF_BUFFER_SIZE]; 
+    int32_t         len        = UPRINTF_BUFFER_SIZE; 
+ 
+ 
+    /* mask off any necessary bits */ 
+    if (info->fIsShort) 
+        num &= UINT16_MAX; 
+    else if (!info->fIsLongLong) 
+        num &= UINT32_MAX; 
+ 
+    /* format the number, preserving the minimum # of digits */ 
+    ufmt_64tou(result, &len, num, 16, 
+        (UBool)(info->fSpec == 0x0078), 
+        (info->fPrecision == -1 && info->fZero) ? info->fWidth : info->fPrecision); 
+ 
+    /* convert to alt form, if desired */ 
+    if(num != 0 && info->fAlt && len < UPRINTF_BUFFER_SIZE - 2) { 
+        /* shift the formatted string right by 2 chars */ 
+        memmove(result + 2, result, len * sizeof(UChar)); 
+        result[0] = 0x0030; 
+        result[1] = info->fSpec; 
+        len += 2; 
+    } 
+ 
+    return handler->pad_and_justify(context, info, result, len); 
+} 
+ 
+static int32_t 
+u_printf_octal_handler(const u_printf_stream_handler  *handler, 
+                       void                           *context, 
+                       ULocaleBundle                  *formatBundle, 
+                       const u_printf_spec_info       *info, 
+                       const ufmt_args                *args) 
+{ 
+    (void)formatBundle; 
+    int64_t         num        = args[0].int64Value; 
+    UChar           result[UPRINTF_BUFFER_SIZE]; 
+    int32_t         len        = UPRINTF_BUFFER_SIZE; 
+ 
+ 
+    /* mask off any necessary bits */ 
+    if (info->fIsShort) 
+        num &= UINT16_MAX; 
+    else if (!info->fIsLongLong) 
+        num &= UINT32_MAX; 
+ 
+    /* format the number, preserving the minimum # of digits */ 
+    ufmt_64tou(result, &len, num, 8, 
+        FALSE, /* doesn't matter for octal */ 
+        info->fPrecision == -1 && info->fZero ? info->fWidth : info->fPrecision); 
+ 
+    /* convert to alt form, if desired */ 
+    if(info->fAlt && result[0] != 0x0030 && len < UPRINTF_BUFFER_SIZE - 1) { 
+        /* shift the formatted string right by 1 char */ 
+        memmove(result + 1, result, len * sizeof(UChar)); 
+        result[0] = 0x0030; 
+        len += 1; 
+    } 
+ 
+    return handler->pad_and_justify(context, info, result, len); 
+} 
+ 
+static int32_t 
+u_printf_uinteger_handler(const u_printf_stream_handler *handler, 
+                          void                          *context, 
+                          ULocaleBundle                 *formatBundle, 
+                          const u_printf_spec_info      *info, 
+                          const ufmt_args               *args) 
+{ 
+    int64_t         num        = args[0].int64Value; 
+    UNumberFormat   *format; 
+    UChar           result[UPRINTF_BUFFER_SIZE]; 
+    int32_t         minDigits     = -1; 
+    int32_t         resultLen; 
+    UErrorCode      status        = U_ZERO_ERROR; 
+ 
+    /* TODO: Fix this once uint64_t can be formatted. */ 
+    if (info->fIsShort) 
+        num &= UINT16_MAX; 
+    else if (!info->fIsLongLong) 
+        num &= UINT32_MAX; 
+ 
+    /* get the formatter */ 
+    format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL); 
+ 
+    /* handle error */ 
+    if(format == 0) 
+        return 0; 
+ 
+    /* set the appropriate flags on the formatter */ 
+ 
+    /* set the minimum integer digits */ 
+    if(info->fPrecision != -1) { 
+        /* set the minimum # of digits */ 
+        minDigits = unum_getAttribute(format, UNUM_MIN_INTEGER_DIGITS); 
+        unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, info->fPrecision); 
+    } 
+ 
+    /* To mirror other stdio implementations, we ignore the sign argument */ 
+ 
+    /* format the number */ 
+    resultLen = unum_formatInt64(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status); 
+ 
+    if (U_FAILURE(status)) { 
+        resultLen = 0; 
+    } 
+ 
+    /* restore the number format */ 
+    if (minDigits != -1) { 
+        unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, minDigits); 
+    } 
+ 
+    return handler->pad_and_justify(context, info, result, resultLen); 
+} 
+ 
+static int32_t 
+u_printf_pointer_handler(const u_printf_stream_handler  *handler, 
+                         void                           *context, 
+                         ULocaleBundle                  *formatBundle, 
+                         const u_printf_spec_info       *info, 
+                         const ufmt_args                *args) 
+{  
+    (void)formatBundle; 
+    UChar           result[UPRINTF_BUFFER_SIZE]; 
+    int32_t         len  = UPRINTF_BUFFER_SIZE; 
+ 
+    /* format the pointer in hex */ 
+    ufmt_ptou(result, &len, args[0].ptrValue, TRUE/*, info->fPrecision*/); 
+ 
+    return handler->pad_and_justify(context, info, result, len); 
+} 
+ 
+static int32_t 
+u_printf_scientific_handler(const u_printf_stream_handler  *handler, 
+                            void                           *context, 
+                            ULocaleBundle                  *formatBundle, 
+                            const u_printf_spec_info       *info, 
+                            const ufmt_args                *args) 
+{ 
+    double          num         = (double) (args[0].doubleValue); 
+    UNumberFormat   *format; 
+    UChar           result[UPRINTF_BUFFER_SIZE]; 
+    UChar           prefixBuffer[UPRINTF_BUFFER_SIZE]; 
+    int32_t         prefixBufferLen = sizeof(prefixBuffer); 
+    int32_t         minDecimalDigits; 
+    int32_t         maxDecimalDigits; 
+    UErrorCode      status        = U_ZERO_ERROR; 
+    UChar srcExpBuf[UPRINTF_SYMBOL_BUFFER_SIZE]; 
+    int32_t srcLen, expLen; 
+    int32_t resultLen; 
+    UChar expBuf[UPRINTF_SYMBOL_BUFFER_SIZE]; 
+ 
+    prefixBuffer[0] = 0; 
+ 
+    /* mask off any necessary bits */ 
+    /*  if(! info->fIsLongDouble) 
+    num &= DBL_MAX;*/ 
+ 
+    /* get the formatter */ 
+    format = u_locbund_getNumberFormat(formatBundle, UNUM_SCIENTIFIC); 
+ 
+    /* handle error */ 
+    if(format == 0) 
+        return 0; 
+ 
+    /* set the appropriate flags on the formatter */ 
+ 
+    srcLen = unum_getSymbol(format, 
+        UNUM_EXPONENTIAL_SYMBOL, 
+        srcExpBuf, 
+        sizeof(srcExpBuf), 
+        &status); 
+ 
+    /* Upper/lower case the e */ 
+    if (info->fSpec == (UChar)0x65 /* e */) { 
+        expLen = u_strToLower(expBuf, (int32_t)sizeof(expBuf), 
+            srcExpBuf, srcLen, 
+            formatBundle->fLocale, 
+            &status); 
+    } 
+    else { 
+        expLen = u_strToUpper(expBuf, (int32_t)sizeof(expBuf), 
+            srcExpBuf, srcLen, 
+            formatBundle->fLocale, 
+            &status); 
+    } 
+ 
+    unum_setSymbol(format, 
+        UNUM_EXPONENTIAL_SYMBOL, 
+        expBuf, 
+        expLen, 
+        &status); 
+ 
+    /* save the formatter's state */ 
+    minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS); 
+    maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS); 
+ 
+    /* set the appropriate flags and number of decimal digits on the formatter */ 
+    if(info->fPrecision != -1) { 
+        /* set the # of decimal digits */ 
+        if (info->fOrigSpec == (UChar)0x65 /* e */ || info->fOrigSpec == (UChar)0x45 /* E */) { 
+            unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision); 
+        } 
+        else { 
+            unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, 1); 
+            unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, info->fPrecision); 
+        } 
+    } 
+    else if(info->fAlt) { 
+        /* '#' means always show decimal point */ 
+        /* copy of printf behavior on Solaris - '#' shows 6 digits */ 
+        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); 
+    } 
+    else { 
+        /* # of decimal digits is 6 if precision not specified */ 
+        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); 
+    } 
+ 
+    /* set whether to show the sign */ 
+    if (info->fShowSign) { 
+        u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status); 
+    } 
+ 
+    /* format the number */ 
+    resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status); 
+ 
+    if (U_FAILURE(status)) { 
+        resultLen = 0; 
+    } 
+ 
+    /* restore the number format */ 
+    /* TODO: Is this needed? */ 
+    unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits); 
+    unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits); 
+ 
+    /* Since we're the only one using the scientific 
+       format, we don't need to save the old exponent value. */ 
+    /*unum_setSymbol(format, 
+        UNUM_EXPONENTIAL_SYMBOL, 
+        srcExpBuf, 
+        srcLen, 
+        &status);*/ 
+ 
+    if (info->fShowSign) { 
+        /* Reset back to original value regardless of what the error was */ 
+        UErrorCode localStatus = U_ZERO_ERROR; 
+        u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus); 
+    } 
+ 
+    return handler->pad_and_justify(context, info, result, resultLen); 
+} 
+ 
+static int32_t 
+u_printf_percent_handler(const u_printf_stream_handler  *handler, 
+                         void                           *context, 
+                         ULocaleBundle                  *formatBundle, 
+                         const u_printf_spec_info       *info, 
+                         const ufmt_args                *args) 
+{ 
+    double          num         = (double) (args[0].doubleValue); 
+    UNumberFormat   *format; 
+    UChar           result[UPRINTF_BUFFER_SIZE]; 
+    UChar           prefixBuffer[UPRINTF_BUFFER_SIZE]; 
+    int32_t         prefixBufferLen = sizeof(prefixBuffer); 
+    int32_t         minDecimalDigits; 
+    int32_t         maxDecimalDigits; 
+    int32_t         resultLen; 
+    UErrorCode      status        = U_ZERO_ERROR; 
+ 
+    prefixBuffer[0] = 0; 
+ 
+    /* mask off any necessary bits */ 
+    /*  if(! info->fIsLongDouble) 
+    num &= DBL_MAX;*/ 
+ 
+    /* get the formatter */ 
+    format = u_locbund_getNumberFormat(formatBundle, UNUM_PERCENT); 
+ 
+    /* handle error */ 
+    if(format == 0) 
+        return 0; 
+ 
+    /* save the formatter's state */ 
+    minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS); 
+    maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS); 
+ 
+    /* set the appropriate flags and number of decimal digits on the formatter */ 
+    if(info->fPrecision != -1) { 
+        /* set the # of decimal digits */ 
+        unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision); 
+    } 
+    else if(info->fAlt) { 
+        /* '#' means always show decimal point */ 
+        /* copy of printf behavior on Solaris - '#' shows 6 digits */ 
+        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); 
+    } 
+    else { 
+        /* # of decimal digits is 6 if precision not specified */ 
+        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); 
+    } 
+ 
+    /* set whether to show the sign */ 
+    if (info->fShowSign) { 
+        u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status); 
+    } 
+ 
+    /* format the number */ 
+    resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status); 
+ 
+    if (U_FAILURE(status)) { 
+        resultLen = 0; 
+    } 
+ 
+    /* restore the number format */ 
+    /* TODO: Is this needed? */ 
+    unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits); 
+    unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits); 
+ 
+    if (info->fShowSign) { 
+        /* Reset back to original value regardless of what the error was */ 
+        UErrorCode localStatus = U_ZERO_ERROR; 
+        u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus); 
+    } 
+ 
+    return handler->pad_and_justify(context, info, result, resultLen); 
+} 
+ 
+static int32_t 
+u_printf_ustring_handler(const u_printf_stream_handler  *handler, 
+                         void                           *context, 
+                         ULocaleBundle                  *formatBundle, 
+                         const u_printf_spec_info       *info, 
+                         const ufmt_args                *args) 
+{ 
+    (void)formatBundle; 
+    int32_t len, written; 
+    const UChar *arg = (const UChar*)(args[0].ptrValue); 
+ 
+    /* allocate enough space for the buffer */ 
+    if (arg == NULL) { 
+        arg = gNullStr; 
+    } 
+    len = u_strlen(arg); 
+ 
+    /* width = minimum # of characters to write */ 
+    /* precision = maximum # of characters to write */ 
+    if (info->fPrecision != -1 && info->fPrecision < len) { 
+        len = info->fPrecision; 
+    } 
+ 
+    /* determine if the string should be padded */ 
+    written = handler->pad_and_justify(context, info, arg, len); 
+ 
+    return written; 
+} 
+ 
+static int32_t 
+u_printf_uchar_handler(const u_printf_stream_handler  *handler, 
+                       void                           *context, 
+                       ULocaleBundle                  *formatBundle, 
+                       const u_printf_spec_info       *info, 
+                       const ufmt_args                *args) 
+{ 
+    (void)formatBundle; 
+    int32_t written = 0; 
+    UChar arg = (UChar)(args[0].int64Value); 
+ 
+    /* width = minimum # of characters to write */ 
+    /* precision = maximum # of characters to write */ 
+    /* precision is ignored when handling a uchar */ 
+ 
+    /* determine if the string should be padded */ 
+    written = handler->pad_and_justify(context, info, &arg, 1); 
+ 
+    return written; 
+} 
+ 
+static int32_t 
+u_printf_scidbl_handler(const u_printf_stream_handler  *handler, 
+                        void                           *context, 
+                        ULocaleBundle                  *formatBundle, 
+                        const u_printf_spec_info       *info, 
+                        const ufmt_args                *args) 
+{ 
+    u_printf_spec_info scidbl_info; 
+    double      num = args[0].doubleValue; 
+    int32_t     retVal; 
+    UNumberFormat *format; 
+    int32_t maxSigDecimalDigits, significantDigits; 
+ 
+    memcpy(&scidbl_info, info, sizeof(u_printf_spec_info)); 
+ 
+    /* determine whether to use 'd', 'e' or 'f' notation */ 
+    if (scidbl_info.fPrecision == -1 && num == uprv_trunc(num)) 
+    { 
+        /* use 'f' notation */ 
+        scidbl_info.fSpec = 0x0066; 
+        scidbl_info.fPrecision = 0; 
+        /* call the double handler */ 
+        retVal = u_printf_double_handler(handler, context, formatBundle, &scidbl_info, args); 
+    } 
+    else if(num < 0.0001 || (scidbl_info.fPrecision < 1 && 1000000.0 <= num) 
+        || (scidbl_info.fPrecision != -1 && num > uprv_pow10(scidbl_info.fPrecision))) 
+    { 
+        /* use 'e' or 'E' notation */ 
+        scidbl_info.fSpec = scidbl_info.fSpec - 2; 
+        if (scidbl_info.fPrecision == -1) { 
+            scidbl_info.fPrecision = 5; 
+        } 
+        /* call the scientific handler */ 
+        retVal = u_printf_scientific_handler(handler, context, formatBundle, &scidbl_info, args); 
+    } 
+    else { 
+        format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL); 
+        /* Check for null pointer */ 
+        if (format == NULL) { 
+            return 0; 
+        } 
+        maxSigDecimalDigits = unum_getAttribute(format, UNUM_MAX_SIGNIFICANT_DIGITS); 
+        significantDigits = scidbl_info.fPrecision; 
+ 
+        /* use 'f' notation */ 
+        scidbl_info.fSpec = 0x0066; 
+        if (significantDigits == -1) { 
+            significantDigits = 6; 
+        } 
+        unum_setAttribute(format, UNUM_SIGNIFICANT_DIGITS_USED, TRUE); 
+        unum_setAttribute(format, UNUM_MAX_SIGNIFICANT_DIGITS, significantDigits); 
+        /* call the double handler */ 
+        retVal = u_printf_double_handler(handler, context, formatBundle, &scidbl_info, args); 
+        unum_setAttribute(format, UNUM_MAX_SIGNIFICANT_DIGITS, maxSigDecimalDigits); 
+        unum_setAttribute(format, UNUM_SIGNIFICANT_DIGITS_USED, FALSE); 
+    } 
+    return retVal; 
+} 
+ 
+static int32_t 
+u_printf_count_handler(const u_printf_stream_handler  *handler, 
+                       void                           *context, 
+                       ULocaleBundle                  *formatBundle, 
+                       const u_printf_spec_info       *info, 
+                       const ufmt_args                *args) 
+{ 
+    (void)handler; 
+    (void)context; 
+    (void)formatBundle; 
+    int32_t *count = (int32_t*)(args[0].ptrValue); 
+ 
+    /* in the special case of count, the u_printf_spec_info's width */ 
+    /* will contain the # of chars written thus far */ 
+    *count = info->fWidth; 
+ 
+    return 0; 
+} 
+ 
+static int32_t 
+u_printf_spellout_handler(const u_printf_stream_handler *handler, 
+                          void                          *context, 
+                          ULocaleBundle                 *formatBundle, 
+                          const u_printf_spec_info      *info, 
+                          const ufmt_args               *args) 
+{ 
+    double          num         = (double) (args[0].doubleValue); 
+    UNumberFormat   *format; 
+    UChar           result[UPRINTF_BUFFER_SIZE]; 
+    UChar           prefixBuffer[UPRINTF_BUFFER_SIZE]; 
+    int32_t         prefixBufferLen = sizeof(prefixBuffer); 
+    int32_t         minDecimalDigits; 
+    int32_t         maxDecimalDigits; 
+    int32_t         resultLen; 
+    UErrorCode      status        = U_ZERO_ERROR; 
+ 
+    prefixBuffer[0] = 0; 
+ 
+    /* mask off any necessary bits */ 
+    /*  if(! info->fIsLongDouble) 
+    num &= DBL_MAX;*/ 
+ 
+    /* get the formatter */ 
+    format = u_locbund_getNumberFormat(formatBundle, UNUM_SPELLOUT); 
+ 
+    /* handle error */ 
+    if(format == 0) 
+        return 0; 
+ 
+    /* save the formatter's state */ 
+    minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS); 
+    maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS); 
+ 
+    /* set the appropriate flags and number of decimal digits on the formatter */ 
+    if(info->fPrecision != -1) { 
+        /* set the # of decimal digits */ 
+        unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision); 
+    } 
+    else if(info->fAlt) { 
+        /* '#' means always show decimal point */ 
+        /* copy of printf behavior on Solaris - '#' shows 6 digits */ 
+        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); 
+    } 
+    else { 
+        /* # of decimal digits is 6 if precision not specified */ 
+        unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6); 
+    } 
+ 
+    /* set whether to show the sign */ 
+    if (info->fShowSign) { 
+        u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status); 
+    } 
+ 
+    /* format the number */ 
+    resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status); 
+ 
+    if (U_FAILURE(status)) { 
+        resultLen = 0; 
+    } 
+ 
+    /* restore the number format */ 
+    /* TODO: Is this needed? */ 
+    unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits); 
+    unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits); 
+ 
+    if (info->fShowSign) { 
+        /* Reset back to original value regardless of what the error was */ 
+        UErrorCode localStatus = U_ZERO_ERROR; 
+        u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus); 
+    } 
+ 
+    return handler->pad_and_justify(context, info, result, resultLen); 
+} 
+ 
+/* Use US-ASCII characters only for formatting. Most codepages have 
+ characters 20-7F from Unicode. Using any other codepage specific 
+ characters will make it very difficult to format the string on 
+ non-Unicode machines */ 
+static const u_printf_info g_u_printf_infos[UPRINTF_NUM_FMT_HANDLERS] = { 
+/* 0x20 */ 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_SIMPLE_PERCENT,UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+ 
+/* 0x30 */ 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+ 
+/* 0x40 */ 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_UCHAR, 
+    UFMT_EMPTY,         UFMT_SCIENTIFIC,    UFMT_EMPTY,         UFMT_SCIDBL, 
+#ifdef U_USE_OBSOLETE_IO_FORMATTING 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_UCHAR/*deprecated*/, 
+#else 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+#endif 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+ 
+/* 0x50 */ 
+    UFMT_PERCENT,       UFMT_EMPTY,         UFMT_EMPTY,         UFMT_USTRING, 
+#ifdef U_USE_OBSOLETE_IO_FORMATTING 
+    UFMT_EMPTY,         UFMT_USTRING/*deprecated*/,UFMT_SPELLOUT,      UFMT_EMPTY, 
+#else 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_SPELLOUT,      UFMT_EMPTY, 
+#endif 
+    UFMT_HEX,           UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+ 
+/* 0x60 */ 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_CHAR, 
+    UFMT_INT,           UFMT_SCIENTIFIC,    UFMT_DOUBLE,        UFMT_SCIDBL, 
+    UFMT_EMPTY,         UFMT_INT,           UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_COUNT,         UFMT_OCTAL, 
+ 
+/* 0x70 */ 
+    UFMT_POINTER,       UFMT_EMPTY,         UFMT_EMPTY,         UFMT_STRING, 
+    UFMT_EMPTY,         UFMT_UINT,          UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_HEX,           UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+}; 
+ 
+/* flag characters for uprintf */ 
+#define FLAG_MINUS 0x002D 
+#define FLAG_PLUS 0x002B 
+#define FLAG_SPACE 0x0020 
+#define FLAG_POUND 0x0023 
+#define FLAG_ZERO  0x0030 
+#define FLAG_PAREN 0x0028 
+ 
+#define ISFLAG(s)    (s) == FLAG_MINUS || \ 
+            (s) == FLAG_PLUS || \ 
+            (s) == FLAG_SPACE || \ 
+            (s) == FLAG_POUND || \ 
+            (s) == FLAG_ZERO || \ 
+            (s) == FLAG_PAREN 
+ 
+/* special characters for uprintf */ 
+#define SPEC_ASTERISK 0x002A 
+#define SPEC_DOLLARSIGN 0x0024 
+#define SPEC_PERIOD 0x002E 
+#define SPEC_PERCENT 0x0025 
+ 
+/* unicode digits */ 
+#define DIGIT_ZERO 0x0030 
+#define DIGIT_ONE 0x0031 
+#define DIGIT_TWO 0x0032 
+#define DIGIT_THREE 0x0033 
+#define DIGIT_FOUR 0x0034 
+#define DIGIT_FIVE 0x0035 
+#define DIGIT_SIX 0x0036 
+#define DIGIT_SEVEN 0x0037 
+#define DIGIT_EIGHT 0x0038 
+#define DIGIT_NINE 0x0039 
+ 
+#define ISDIGIT(s)    (s) == DIGIT_ZERO || \ 
+            (s) == DIGIT_ONE || \ 
+            (s) == DIGIT_TWO || \ 
+            (s) == DIGIT_THREE || \ 
+            (s) == DIGIT_FOUR || \ 
+            (s) == DIGIT_FIVE || \ 
+            (s) == DIGIT_SIX || \ 
+            (s) == DIGIT_SEVEN || \ 
+            (s) == DIGIT_EIGHT || \ 
+            (s) == DIGIT_NINE 
+ 
+/* u_printf modifiers */ 
+#define MOD_H 0x0068 
+#define MOD_LOWERL 0x006C 
+#define MOD_L 0x004C 
+ 
+#define ISMOD(s)    (s) == MOD_H || \ 
+            (s) == MOD_LOWERL || \ 
+            (s) == MOD_L 
+/* Returns an array of the parsed argument type given in the format string. */ 
+static ufmt_args* parseArguments(const UChar *alias, va_list ap, UErrorCode *status) { 
+    ufmt_args *arglist = NULL; 
+    ufmt_type_info *typelist = NULL; 
+    UBool *islonglong = NULL; 
+    int32_t size = 0; 
+    int32_t pos = 0; 
+    UChar type; 
+    uint16_t handlerNum; 
+    const UChar *aliasStart = alias; 
+ 
+    /* get maximum number of arguments */ 
+    for(;;) { 
+        /* find % */ 
+        while(*alias != UP_PERCENT && *alias != 0x0000) { 
+            alias++; 
+        } 
+ 
+        if(*alias == 0x0000) { 
+            break; 
+        } 
+ 
+        alias++; 
+ 
+        /* handle the pos number */ 
+        if(ISDIGIT(*alias)) { 
+ 
+            /* handle positional parameters */ 
+            if(ISDIGIT(*alias)) { 
+                pos = (int) (*alias++ - DIGIT_ZERO); 
+ 
+                while(ISDIGIT(*alias)) { 
+                    pos *= 10; 
+                    pos += (int) (*alias++ - DIGIT_ZERO); 
+                } 
+            } 
+ 
+            /* if there is no '$', don't read anything */ 
+            if(*alias != SPEC_DOLLARSIGN) { 
+                return NULL; 
+            } 
+        } else { 
+            return NULL; 
+        } 
+ 
+        if (pos > size) { 
+            size = pos; 
+        } 
+    } 
+ 
+    /* create the parsed argument list */ 
+    typelist = (ufmt_type_info*)uprv_malloc(sizeof(ufmt_type_info) * size); 
+    islonglong = (UBool*)uprv_malloc(sizeof(UBool) * size); 
+    arglist = (ufmt_args*)uprv_malloc(sizeof(ufmt_args) * size); 
+ 
+    /* If malloc failed, return NULL */ 
+    if (!typelist || !islonglong || !arglist) { 
+        if (typelist) { 
+            uprv_free(typelist); 
+        } 
+ 
+        if (islonglong) { 
+            uprv_free(islonglong); 
+        } 
+ 
+        if (arglist) { 
+            uprv_free(arglist); 
+        } 
+ 
+        *status = U_MEMORY_ALLOCATION_ERROR; 
+        return NULL; 
+    } 
+ 
+    /* reset alias back to the beginning */ 
+    alias = aliasStart; 
+ 
+    for(;;) { 
+        /* find % */ 
+        while(*alias != UP_PERCENT && *alias != 0x0000) { 
+            alias++; 
+        } 
+ 
+        if(*alias == 0x0000) { 
+            break; 
+        } 
+ 
+        alias++; 
+ 
+        /* handle positional parameters */ 
+        if(ISDIGIT(*alias)) { 
+            pos = (int) (*alias++ - DIGIT_ZERO); 
+ 
+            while(ISDIGIT(*alias)) { 
+                pos *= 10; 
+                pos += (int) (*alias++ - DIGIT_ZERO); 
+            } 
+        } 
+        /* offset position by 1 */ 
+        pos--; 
+ 
+        /* skip over everything except for the type */ 
+        while (ISMOD(*alias) || ISFLAG(*alias) || ISDIGIT(*alias) ||  
+            *alias == SPEC_ASTERISK || *alias == SPEC_PERIOD || *alias == SPEC_DOLLARSIGN) { 
+                islonglong[pos] = FALSE; 
+                if (ISMOD(*alias)) { 
+                    alias++; 
+                    if (*alias == MOD_LOWERL) { 
+                        islonglong[pos] = TRUE; 
+                    }  
+                }  
+                alias++; 
+        } 
+        type = *alias; 
+ 
+        /* store the argument type in the correct position of the parsed argument list */ 
+        handlerNum = (uint16_t)(type - UPRINTF_BASE_FMT_HANDLERS); 
+        if (handlerNum < UPRINTF_NUM_FMT_HANDLERS) { 
+            typelist[pos] = g_u_printf_infos[ handlerNum ].info; 
+        } else { 
+            typelist[pos] = ufmt_empty; 
+        } 
+    } 
+ 
+    /* store argument in arglist */ 
+    for (pos = 0; pos < size; pos++) { 
+        switch (typelist[pos]) { 
+        case ufmt_string: 
+        case ufmt_ustring: 
+        case ufmt_pointer: 
+            arglist[pos].ptrValue = va_arg(ap, void*); 
+            break; 
+        case ufmt_char: 
+        case ufmt_uchar: 
+        case ufmt_int: 
+            if (islonglong[pos]) { 
+                arglist[pos].int64Value = va_arg(ap, int64_t); 
+            } 
+            else { 
+                arglist[pos].int64Value = va_arg(ap, int32_t); 
+            } 
+            break; 
+        case ufmt_float: 
+            arglist[pos].floatValue = (float) va_arg(ap, double); 
+            break; 
+        case ufmt_double: 
+            arglist[pos].doubleValue = va_arg(ap, double); 
+            break; 
+        default: 
+            /* else args is ignored */ 
+            arglist[pos].ptrValue = NULL; 
+            break; 
+        } 
+    } 
+ 
+    uprv_free(typelist); 
+    uprv_free(islonglong); 
+ 
+    return arglist; 
+} 
+ 
+/* We parse the argument list in Unicode */ 
+U_CFUNC int32_t 
+u_printf_parse(const u_printf_stream_handler *streamHandler, 
+               const UChar     *fmt, 
+               void            *context, 
+               u_localized_print_string *locStringContext, 
+               ULocaleBundle   *formatBundle, 
+               int32_t         *written, 
+               va_list         ap) 
+{ 
+    uint16_t         handlerNum; 
+    ufmt_args        args; 
+    ufmt_type_info   argType; 
+    u_printf_handler *handler; 
+    u_printf_spec    spec; 
+    u_printf_spec_info *info = &(spec.fInfo); 
+ 
+    const UChar *alias = fmt; 
+    const UChar *backup; 
+    const UChar *lastAlias; 
+    const UChar *orgAlias = fmt; 
+    /* parsed argument list */ 
+    ufmt_args *arglist = NULL; /* initialized it to avoid compiler warnings */ 
+    UErrorCode status = U_ZERO_ERROR; 
+    if (!locStringContext || locStringContext->available >= 0) { 
+        /* get the parsed list of argument types */ 
+        arglist = parseArguments(orgAlias, ap, &status); 
+ 
+        /* Return error if parsing failed. */ 
+        if (U_FAILURE(status)) { 
+            return -1; 
+        } 
+    } 
+     
+    /* iterate through the pattern */ 
+    while(!locStringContext || locStringContext->available >= 0) { 
+ 
+        /* find the next '%' */ 
+        lastAlias = alias; 
+        while(*alias != UP_PERCENT && *alias != 0x0000) { 
+            alias++; 
+        } 
+ 
+        /* write any characters before the '%' */ 
+        if(alias > lastAlias) { 
+            *written += (streamHandler->write)(context, lastAlias, (int32_t)(alias - lastAlias)); 
+        } 
+ 
+        /* break if at end of string */ 
+        if(*alias == 0x0000) { 
+            break; 
+        } 
+ 
+        /* initialize spec to default values */ 
+        spec.fWidthPos     = -1; 
+        spec.fPrecisionPos = -1; 
+        spec.fArgPos       = -1; 
+ 
+        uprv_memset(info, 0, sizeof(*info)); 
+        info->fPrecision    = -1; 
+        info->fWidth        = -1; 
+        info->fPadChar      = 0x0020; 
+ 
+        /* skip over the initial '%' */ 
+        alias++; 
+ 
+        /* Check for positional argument */ 
+        if(ISDIGIT(*alias)) { 
+ 
+            /* Save the current position */ 
+            backup = alias; 
+ 
+            /* handle positional parameters */ 
+            if(ISDIGIT(*alias)) { 
+                spec.fArgPos = (int) (*alias++ - DIGIT_ZERO); 
+ 
+                while(ISDIGIT(*alias)) { 
+                    spec.fArgPos *= 10; 
+                    spec.fArgPos += (int) (*alias++ - DIGIT_ZERO); 
+                } 
+            } 
+ 
+            /* if there is no '$', don't read anything */ 
+            if(*alias != SPEC_DOLLARSIGN) { 
+                spec.fArgPos = -1; 
+                alias = backup; 
+            } 
+            /* munge the '$' */ 
+            else 
+                alias++; 
+        } 
+ 
+        /* Get any format flags */ 
+        while(ISFLAG(*alias)) { 
+            switch(*alias++) { 
+ 
+                /* left justify */ 
+            case FLAG_MINUS: 
+                info->fLeft = TRUE; 
+                break; 
+ 
+                /* always show sign */ 
+            case FLAG_PLUS: 
+                info->fShowSign = TRUE; 
+                break; 
+ 
+                /* use space if no sign present */ 
+            case FLAG_SPACE: 
+                info->fShowSign = TRUE; 
+                info->fSpace = TRUE; 
+                break; 
+ 
+                /* use alternate form */ 
+            case FLAG_POUND: 
+                info->fAlt = TRUE; 
+                break; 
+ 
+                /* pad with leading zeroes */ 
+            case FLAG_ZERO: 
+                info->fZero = TRUE; 
+                info->fPadChar = 0x0030; 
+                break; 
+ 
+                /* pad character specified */ 
+            case FLAG_PAREN: 
+ 
+                /* TODO test that all four are numbers */ 
+                /* first four characters are hex values for pad char */ 
+                info->fPadChar = (UChar)ufmt_digitvalue(*alias++); 
+                info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*alias++)); 
+                info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*alias++)); 
+                info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*alias++)); 
+ 
+                /* final character is ignored */ 
+                alias++; 
+ 
+                break; 
+            } 
+        } 
+ 
+        /* Get the width */ 
+ 
+        /* width is specified out of line */ 
+        if(*alias == SPEC_ASTERISK) { 
+ 
+            info->fWidth = -2; 
+ 
+            /* Skip the '*' */ 
+            alias++; 
+ 
+            /* Save the current position */ 
+            backup = alias; 
+ 
+            /* handle positional parameters */ 
+            if(ISDIGIT(*alias)) { 
+                spec.fWidthPos = (int) (*alias++ - DIGIT_ZERO); 
+ 
+                while(ISDIGIT(*alias)) { 
+                    spec.fWidthPos *= 10; 
+                    spec.fWidthPos += (int) (*alias++ - DIGIT_ZERO); 
+                } 
+            } 
+ 
+            /* if there is no '$', don't read anything */ 
+            if(*alias != SPEC_DOLLARSIGN) { 
+                spec.fWidthPos = -1; 
+                alias = backup; 
+            } 
+            /* munge the '$' */ 
+            else 
+                alias++; 
+        } 
+        /* read the width, if present */ 
+        else if(ISDIGIT(*alias)){ 
+            info->fWidth = (int) (*alias++ - DIGIT_ZERO); 
+ 
+            while(ISDIGIT(*alias)) { 
+                info->fWidth *= 10; 
+                info->fWidth += (int) (*alias++ - DIGIT_ZERO); 
+            } 
+        } 
+ 
+        /* Get the precision */ 
+ 
+        if(*alias == SPEC_PERIOD) { 
+ 
+            /* eat up the '.' */ 
+            alias++; 
+ 
+            /* precision is specified out of line */ 
+            if(*alias == SPEC_ASTERISK) { 
+ 
+                info->fPrecision = -2; 
+ 
+                /* Skip the '*' */ 
+                alias++; 
+ 
+                /* save the current position */ 
+                backup = alias; 
+ 
+                /* handle positional parameters */ 
+                if(ISDIGIT(*alias)) { 
+                    spec.fPrecisionPos = (int) (*alias++ - DIGIT_ZERO); 
+ 
+                    while(ISDIGIT(*alias)) { 
+                        spec.fPrecisionPos *= 10; 
+                        spec.fPrecisionPos += (int) (*alias++ - DIGIT_ZERO); 
+                    } 
+ 
+                    /* if there is no '$', don't read anything */ 
+                    if(*alias != SPEC_DOLLARSIGN) { 
+                        spec.fPrecisionPos = -1; 
+                        alias = backup; 
+                    } 
+                    else { 
+                        /* munge the '$' */ 
+                        alias++; 
+                    } 
+                } 
+            } 
+            /* read the precision */ 
+            else if(ISDIGIT(*alias)){ 
+                info->fPrecision = (int) (*alias++ - DIGIT_ZERO); 
+ 
+                while(ISDIGIT(*alias)) { 
+                    info->fPrecision *= 10; 
+                    info->fPrecision += (int) (*alias++ - DIGIT_ZERO); 
+                } 
+            } 
+        } 
+ 
+        /* Get any modifiers */ 
+        if(ISMOD(*alias)) { 
+            switch(*alias++) { 
+ 
+                /* short */ 
+            case MOD_H: 
+                info->fIsShort = TRUE; 
+                break; 
+ 
+                /* long or long long */ 
+            case MOD_LOWERL: 
+                if(*alias == MOD_LOWERL) { 
+                    info->fIsLongLong = TRUE; 
+                    /* skip over the next 'l' */ 
+                    alias++; 
+                } 
+                else 
+                    info->fIsLong = TRUE; 
+                break; 
+ 
+                /* long double */ 
+            case MOD_L: 
+                info->fIsLongDouble = TRUE; 
+                break; 
+            } 
+        } 
+ 
+        /* finally, get the specifier letter */ 
+        info->fSpec = *alias++; 
+        info->fOrigSpec = info->fSpec; 
+ 
+        /* fill in the precision and width, if specified out of line */ 
+ 
+        /* width specified out of line */ 
+        if(spec.fInfo.fWidth == -2) { 
+            if(spec.fWidthPos == -1) { 
+                /* read the width from the argument list */ 
+                info->fWidth = va_arg(ap, int32_t); 
+            } 
+            /* else handle positional parameter */ 
+ 
+            /* if it's negative, take the absolute value and set left alignment */ 
+            if(info->fWidth < 0) { 
+                info->fWidth *= -1; /* Make positive */ 
+                info->fLeft = TRUE; 
+            } 
+        } 
+ 
+        /* precision specified out of line */ 
+        if(info->fPrecision == -2) { 
+            if(spec.fPrecisionPos == -1) { 
+                /* read the precision from the argument list */ 
+                info->fPrecision = va_arg(ap, int32_t); 
+            } 
+            /* else handle positional parameter */ 
+ 
+            /* if it's negative, set it to zero */ 
+            if(info->fPrecision < 0) 
+                info->fPrecision = 0; 
+        } 
+ 
+        handlerNum = (uint16_t)(info->fSpec - UPRINTF_BASE_FMT_HANDLERS); 
+        if (handlerNum < UPRINTF_NUM_FMT_HANDLERS) { 
+            /* query the info function for argument information */ 
+            argType = g_u_printf_infos[ handlerNum ].info; 
+ 
+            /* goto the correct argument on arg_list if position is specified */ 
+            if (spec.fArgPos > 0) { 
+                /* offset position by 1 */ 
+                spec.fArgPos--; 
+                switch(argType) { 
+                case ufmt_count: 
+                    /* set the spec's width to the # of chars written */ 
+                    info->fWidth = *written; 
+                    /* fall through to set the pointer */ 
+                    U_FALLTHROUGH; 
+                case ufmt_string: 
+                case ufmt_ustring: 
+                case ufmt_pointer: 
+                    args.ptrValue = arglist[spec.fArgPos].ptrValue; 
+                    break; 
+                case ufmt_char: 
+                case ufmt_uchar: 
+                case ufmt_int: 
+                    args.int64Value = arglist[spec.fArgPos].int64Value; 
+                    break; 
+                case ufmt_float: 
+                    args.floatValue = arglist[spec.fArgPos].floatValue; 
+                    break; 
+                case ufmt_double: 
+                    args.doubleValue = arglist[spec.fArgPos].doubleValue; 
+                    break; 
+                default: 
+                    /* else args is ignored */ 
+                    args.ptrValue = NULL; 
+                    break; 
+                } 
+            } else { /* no positional argument specified */ 
+                switch(argType) { 
+                case ufmt_count: 
+                    /* set the spec's width to the # of chars written */ 
+                    info->fWidth = *written; 
+                    /* fall through to set the pointer */ 
+                    U_FALLTHROUGH; 
+                case ufmt_string: 
+                case ufmt_ustring: 
+                case ufmt_pointer: 
+                    args.ptrValue = va_arg(ap, void*); 
+                    break; 
+                case ufmt_char: 
+                case ufmt_uchar: 
+                case ufmt_int: 
+                    if (info->fIsLongLong) { 
+                        args.int64Value = va_arg(ap, int64_t); 
+                    } 
+                    else { 
+                        args.int64Value = va_arg(ap, int32_t); 
                     } 
+                    break; 
+                case ufmt_float: 
+                    args.floatValue = (float) va_arg(ap, double); 
+                    break; 
+                case ufmt_double: 
+                    args.doubleValue = va_arg(ap, double); 
+                    break; 
+                default: 
+                    /* else args is ignored */ 
+                    args.ptrValue = NULL; 
+                    break; 
                 } 
-                alias++;
-        }
-        type = *alias;
-
-        /* store the argument type in the correct position of the parsed argument list */
-        handlerNum = (uint16_t)(type - UPRINTF_BASE_FMT_HANDLERS);
-        if (handlerNum < UPRINTF_NUM_FMT_HANDLERS) {
-            typelist[pos] = g_u_printf_infos[ handlerNum ].info;
-        } else {
-            typelist[pos] = ufmt_empty;
-        }
-    }
-
-    /* store argument in arglist */
-    for (pos = 0; pos < size; pos++) {
-        switch (typelist[pos]) {
-        case ufmt_string:
-        case ufmt_ustring:
-        case ufmt_pointer:
-            arglist[pos].ptrValue = va_arg(ap, void*);
-            break;
-        case ufmt_char:
-        case ufmt_uchar:
-        case ufmt_int:
-            if (islonglong[pos]) {
-                arglist[pos].int64Value = va_arg(ap, int64_t);
-            }
-            else {
-                arglist[pos].int64Value = va_arg(ap, int32_t);
-            }
-            break;
-        case ufmt_float:
-            arglist[pos].floatValue = (float) va_arg(ap, double);
-            break;
-        case ufmt_double:
-            arglist[pos].doubleValue = va_arg(ap, double);
-            break;
-        default:
-            /* else args is ignored */
-            arglist[pos].ptrValue = NULL;
-            break;
-        }
-    }
-
-    uprv_free(typelist);
-    uprv_free(islonglong);
-
-    return arglist;
-}
-
-/* We parse the argument list in Unicode */
-U_CFUNC int32_t
-u_printf_parse(const u_printf_stream_handler *streamHandler,
-               const UChar     *fmt,
-               void            *context,
-               u_localized_print_string *locStringContext,
-               ULocaleBundle   *formatBundle,
-               int32_t         *written,
-               va_list         ap)
-{
-    uint16_t         handlerNum;
-    ufmt_args        args;
-    ufmt_type_info   argType;
-    u_printf_handler *handler;
-    u_printf_spec    spec;
-    u_printf_spec_info *info = &(spec.fInfo);
-
-    const UChar *alias = fmt;
-    const UChar *backup;
-    const UChar *lastAlias;
-    const UChar *orgAlias = fmt;
-    /* parsed argument list */
-    ufmt_args *arglist = NULL; /* initialized it to avoid compiler warnings */
-    UErrorCode status = U_ZERO_ERROR;
-    if (!locStringContext || locStringContext->available >= 0) {
-        /* get the parsed list of argument types */
-        arglist = parseArguments(orgAlias, ap, &status);
-
-        /* Return error if parsing failed. */
-        if (U_FAILURE(status)) {
-            return -1;
-        }
-    }
-    
-    /* iterate through the pattern */
-    while(!locStringContext || locStringContext->available >= 0) {
-
-        /* find the next '%' */
-        lastAlias = alias;
-        while(*alias != UP_PERCENT && *alias != 0x0000) {
-            alias++;
-        }
-
-        /* write any characters before the '%' */
-        if(alias > lastAlias) {
-            *written += (streamHandler->write)(context, lastAlias, (int32_t)(alias - lastAlias));
-        }
-
-        /* break if at end of string */
-        if(*alias == 0x0000) {
-            break;
-        }
-
-        /* initialize spec to default values */
-        spec.fWidthPos     = -1;
-        spec.fPrecisionPos = -1;
-        spec.fArgPos       = -1;
-
-        uprv_memset(info, 0, sizeof(*info));
-        info->fPrecision    = -1;
-        info->fWidth        = -1;
-        info->fPadChar      = 0x0020;
-
-        /* skip over the initial '%' */
-        alias++;
-
-        /* Check for positional argument */
-        if(ISDIGIT(*alias)) {
-
-            /* Save the current position */
-            backup = alias;
-
-            /* handle positional parameters */
-            if(ISDIGIT(*alias)) {
-                spec.fArgPos = (int) (*alias++ - DIGIT_ZERO);
-
-                while(ISDIGIT(*alias)) {
-                    spec.fArgPos *= 10;
-                    spec.fArgPos += (int) (*alias++ - DIGIT_ZERO);
-                }
-            }
-
-            /* if there is no '$', don't read anything */
-            if(*alias != SPEC_DOLLARSIGN) {
-                spec.fArgPos = -1;
-                alias = backup;
-            }
-            /* munge the '$' */
-            else
-                alias++;
-        }
-
-        /* Get any format flags */
-        while(ISFLAG(*alias)) {
-            switch(*alias++) {
-
-                /* left justify */
-            case FLAG_MINUS:
-                info->fLeft = TRUE;
-                break;
-
-                /* always show sign */
-            case FLAG_PLUS:
-                info->fShowSign = TRUE;
-                break;
-
-                /* use space if no sign present */
-            case FLAG_SPACE:
-                info->fShowSign = TRUE;
-                info->fSpace = TRUE;
-                break;
-
-                /* use alternate form */
-            case FLAG_POUND:
-                info->fAlt = TRUE;
-                break;
-
-                /* pad with leading zeroes */
-            case FLAG_ZERO:
-                info->fZero = TRUE;
-                info->fPadChar = 0x0030;
-                break;
-
-                /* pad character specified */
-            case FLAG_PAREN:
-
-                /* TODO test that all four are numbers */
-                /* first four characters are hex values for pad char */
-                info->fPadChar = (UChar)ufmt_digitvalue(*alias++);
-                info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*alias++));
-                info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*alias++));
-                info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*alias++));
-
-                /* final character is ignored */
-                alias++;
-
-                break;
-            }
-        }
-
-        /* Get the width */
-
-        /* width is specified out of line */
-        if(*alias == SPEC_ASTERISK) {
-
-            info->fWidth = -2;
-
-            /* Skip the '*' */
-            alias++;
-
-            /* Save the current position */
-            backup = alias;
-
-            /* handle positional parameters */
-            if(ISDIGIT(*alias)) {
-                spec.fWidthPos = (int) (*alias++ - DIGIT_ZERO);
-
-                while(ISDIGIT(*alias)) {
-                    spec.fWidthPos *= 10;
-                    spec.fWidthPos += (int) (*alias++ - DIGIT_ZERO);
-                }
-            }
-
-            /* if there is no '$', don't read anything */
-            if(*alias != SPEC_DOLLARSIGN) {
-                spec.fWidthPos = -1;
-                alias = backup;
-            }
-            /* munge the '$' */
-            else
-                alias++;
-        }
-        /* read the width, if present */
-        else if(ISDIGIT(*alias)){
-            info->fWidth = (int) (*alias++ - DIGIT_ZERO);
-
-            while(ISDIGIT(*alias)) {
-                info->fWidth *= 10;
-                info->fWidth += (int) (*alias++ - DIGIT_ZERO);
-            }
-        }
-
-        /* Get the precision */
-
-        if(*alias == SPEC_PERIOD) {
-
-            /* eat up the '.' */
-            alias++;
-
-            /* precision is specified out of line */
-            if(*alias == SPEC_ASTERISK) {
-
-                info->fPrecision = -2;
-
-                /* Skip the '*' */
-                alias++;
-
-                /* save the current position */
-                backup = alias;
-
-                /* handle positional parameters */
-                if(ISDIGIT(*alias)) {
-                    spec.fPrecisionPos = (int) (*alias++ - DIGIT_ZERO);
-
-                    while(ISDIGIT(*alias)) {
-                        spec.fPrecisionPos *= 10;
-                        spec.fPrecisionPos += (int) (*alias++ - DIGIT_ZERO);
-                    }
-
-                    /* if there is no '$', don't read anything */
-                    if(*alias != SPEC_DOLLARSIGN) {
-                        spec.fPrecisionPos = -1;
-                        alias = backup;
-                    }
-                    else {
-                        /* munge the '$' */
-                        alias++;
-                    }
-                }
-            }
-            /* read the precision */
-            else if(ISDIGIT(*alias)){
-                info->fPrecision = (int) (*alias++ - DIGIT_ZERO);
-
-                while(ISDIGIT(*alias)) {
-                    info->fPrecision *= 10;
-                    info->fPrecision += (int) (*alias++ - DIGIT_ZERO);
-                }
-            }
-        }
-
-        /* Get any modifiers */
-        if(ISMOD(*alias)) {
-            switch(*alias++) {
-
-                /* short */
-            case MOD_H:
-                info->fIsShort = TRUE;
-                break;
-
-                /* long or long long */
-            case MOD_LOWERL:
-                if(*alias == MOD_LOWERL) {
-                    info->fIsLongLong = TRUE;
-                    /* skip over the next 'l' */
-                    alias++;
-                }
-                else
-                    info->fIsLong = TRUE;
-                break;
-
-                /* long double */
-            case MOD_L:
-                info->fIsLongDouble = TRUE;
-                break;
-            }
-        }
-
-        /* finally, get the specifier letter */
-        info->fSpec = *alias++;
-        info->fOrigSpec = info->fSpec;
-
-        /* fill in the precision and width, if specified out of line */
-
-        /* width specified out of line */
-        if(spec.fInfo.fWidth == -2) {
-            if(spec.fWidthPos == -1) {
-                /* read the width from the argument list */
-                info->fWidth = va_arg(ap, int32_t);
-            }
-            /* else handle positional parameter */
-
-            /* if it's negative, take the absolute value and set left alignment */
-            if(info->fWidth < 0) {
-                info->fWidth *= -1; /* Make positive */
-                info->fLeft = TRUE;
-            }
-        }
-
-        /* precision specified out of line */
-        if(info->fPrecision == -2) {
-            if(spec.fPrecisionPos == -1) {
-                /* read the precision from the argument list */
-                info->fPrecision = va_arg(ap, int32_t);
-            }
-            /* else handle positional parameter */
-
-            /* if it's negative, set it to zero */
-            if(info->fPrecision < 0)
-                info->fPrecision = 0;
-        }
-
-        handlerNum = (uint16_t)(info->fSpec - UPRINTF_BASE_FMT_HANDLERS);
-        if (handlerNum < UPRINTF_NUM_FMT_HANDLERS) {
-            /* query the info function for argument information */
-            argType = g_u_printf_infos[ handlerNum ].info;
-
-            /* goto the correct argument on arg_list if position is specified */
-            if (spec.fArgPos > 0) {
-                /* offset position by 1 */
-                spec.fArgPos--;
-                switch(argType) {
-                case ufmt_count:
-                    /* set the spec's width to the # of chars written */
-                    info->fWidth = *written;
-                    /* fall through to set the pointer */
-                    U_FALLTHROUGH;
-                case ufmt_string:
-                case ufmt_ustring:
-                case ufmt_pointer:
-                    args.ptrValue = arglist[spec.fArgPos].ptrValue;
-                    break;
-                case ufmt_char:
-                case ufmt_uchar:
-                case ufmt_int:
-                    args.int64Value = arglist[spec.fArgPos].int64Value;
-                    break;
-                case ufmt_float:
-                    args.floatValue = arglist[spec.fArgPos].floatValue;
-                    break;
-                case ufmt_double:
-                    args.doubleValue = arglist[spec.fArgPos].doubleValue;
-                    break;
-                default:
-                    /* else args is ignored */
-                    args.ptrValue = NULL;
-                    break;
-                }
-            } else { /* no positional argument specified */
-                switch(argType) {
-                case ufmt_count:
-                    /* set the spec's width to the # of chars written */
-                    info->fWidth = *written;
-                    /* fall through to set the pointer */
-                    U_FALLTHROUGH;
-                case ufmt_string:
-                case ufmt_ustring:
-                case ufmt_pointer:
-                    args.ptrValue = va_arg(ap, void*);
-                    break;
-                case ufmt_char:
-                case ufmt_uchar:
-                case ufmt_int:
-                    if (info->fIsLongLong) {
-                        args.int64Value = va_arg(ap, int64_t);
-                    }
-                    else {
-                        args.int64Value = va_arg(ap, int32_t);
-                    }
-                    break;
-                case ufmt_float:
-                    args.floatValue = (float) va_arg(ap, double);
-                    break;
-                case ufmt_double:
-                    args.doubleValue = va_arg(ap, double);
-                    break;
-                default:
-                    /* else args is ignored */
-                    args.ptrValue = NULL;
-                    break;
-                }
-            }
-
-            /* call the handler function */
-            handler = g_u_printf_infos[ handlerNum ].handler;
-            if(handler != 0) {
-                *written += (*handler)(streamHandler, context, formatBundle, info, &args);
-            }
-            else {
-                /* just echo unknown tags */
-                *written += (streamHandler->write)(context, fmt, (int32_t)(alias - lastAlias));
-            }
-        }
-        else {
-            /* just echo unknown tags */
-            *written += (streamHandler->write)(context, fmt, (int32_t)(alias - lastAlias));
-        }
-    }
-    /* delete parsed argument list */
-    if (arglist != NULL) {
-        uprv_free(arglist);
-    }
-    /* return # of characters in this format that have been parsed. */
-    return (int32_t)(alias - fmt);
-}
-
-#endif /* #if !UCONFIG_NO_FORMATTING */
+            } 
+ 
+            /* call the handler function */ 
+            handler = g_u_printf_infos[ handlerNum ].handler; 
+            if(handler != 0) { 
+                *written += (*handler)(streamHandler, context, formatBundle, info, &args); 
+            } 
+            else { 
+                /* just echo unknown tags */ 
+                *written += (streamHandler->write)(context, fmt, (int32_t)(alias - lastAlias)); 
+            } 
+        } 
+        else { 
+            /* just echo unknown tags */ 
+            *written += (streamHandler->write)(context, fmt, (int32_t)(alias - lastAlias)); 
+        } 
+    } 
+    /* delete parsed argument list */ 
+    if (arglist != NULL) { 
+        uprv_free(arglist); 
+    } 
+    /* return # of characters in this format that have been parsed. */ 
+    return (int32_t)(alias - fmt); 
+} 
+ 
+#endif /* #if !UCONFIG_NO_FORMATTING */ 
diff --git a/contrib/libs/icu/io/uscanf.cpp b/contrib/libs/icu/io/uscanf.cpp
index ce2e47a588..f5c7c089cb 100644
--- a/contrib/libs/icu/io/uscanf.cpp
+++ b/contrib/libs/icu/io/uscanf.cpp
@@ -1,108 +1,108 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-*
-*   Copyright (C) 1998-2014, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*
-******************************************************************************
-*
-* File uscanf.c
-*
-* Modification History:
-*
-*   Date        Name        Description
-*   12/02/98    stephen        Creation.
-*   03/13/99    stephen     Modified for new C API.
-******************************************************************************
-*/
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_CONVERSION
-
-#include "unicode/putil.h"
-#include "unicode/ustdio.h"
-#include "unicode/ustring.h"
-#include "uscanf.h"
-#include "ufile.h"
-#include "ufmt_cmn.h"
-
-#include "cmemory.h"
-#include "cstring.h"
-
-
-U_CAPI int32_t U_EXPORT2
-u_fscanf(UFILE        *f,
-         const char    *patternSpecification,
-         ... )
-{
-    va_list ap;
-    int32_t converted;
-
-    va_start(ap, patternSpecification);
-    converted = u_vfscanf(f, patternSpecification, ap);
-    va_end(ap);
-
-    return converted;
-}
-
-U_CAPI int32_t U_EXPORT2
-u_fscanf_u(UFILE        *f,
-           const UChar    *patternSpecification,
-           ... )
-{
-    va_list ap;
-    int32_t converted;
-
-    va_start(ap, patternSpecification);
-    converted = u_vfscanf_u(f, patternSpecification, ap);
-    va_end(ap);
-
-    return converted;
-}
-
-U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_vfscanf(UFILE        *f,
-          const char    *patternSpecification,
-          va_list        ap)
-{
-    int32_t converted;
-    UChar *pattern;
-    UChar patBuffer[UFMT_DEFAULT_BUFFER_SIZE];
-    int32_t size = (int32_t)uprv_strlen(patternSpecification) + 1;
-
-    /* convert from the default codepage to Unicode */
-    if (size >= MAX_UCHAR_BUFFER_SIZE(patBuffer)) {
-        pattern = (UChar *)uprv_malloc(size * sizeof(UChar));
-        if(pattern == 0) {
-            return 0;
-        }
-    }
-    else {
-        pattern = patBuffer;
-    }
-    u_charsToUChars(patternSpecification, pattern, size);
-
-    /* do the work */
-    converted = u_vfscanf_u(f, pattern, ap);
-
-    /* clean up */
-    if (pattern != patBuffer) {
-        uprv_free(pattern);
-    }
-
-    return converted;
-}
-
-U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_vfscanf_u(UFILE       *f,
-            const UChar *patternSpecification,
-            va_list     ap)
-{
-    return u_scanf_parse(f, patternSpecification, ap);
-}
-
-#endif /* #if !UCONFIG_NO_FORMATTING */
-
+// © 2016 and later: Unicode, Inc. and others. 
+// License & terms of use: http://www.unicode.org/copyright.html 
+/* 
+****************************************************************************** 
+* 
+*   Copyright (C) 1998-2014, International Business Machines 
+*   Corporation and others.  All Rights Reserved. 
+* 
+****************************************************************************** 
+* 
+* File uscanf.c 
+* 
+* Modification History: 
+* 
+*   Date        Name        Description 
+*   12/02/98    stephen        Creation. 
+*   03/13/99    stephen     Modified for new C API. 
+****************************************************************************** 
+*/ 
+ 
+#include "unicode/utypes.h" 
+ 
+#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_CONVERSION 
+ 
+#include "unicode/putil.h" 
+#include "unicode/ustdio.h" 
+#include "unicode/ustring.h" 
+#include "uscanf.h" 
+#include "ufile.h" 
+#include "ufmt_cmn.h" 
+ 
+#include "cmemory.h" 
+#include "cstring.h" 
+ 
+ 
+U_CAPI int32_t U_EXPORT2 
+u_fscanf(UFILE        *f, 
+         const char    *patternSpecification, 
+         ... ) 
+{ 
+    va_list ap; 
+    int32_t converted; 
+ 
+    va_start(ap, patternSpecification); 
+    converted = u_vfscanf(f, patternSpecification, ap); 
+    va_end(ap); 
+ 
+    return converted; 
+} 
+ 
+U_CAPI int32_t U_EXPORT2 
+u_fscanf_u(UFILE        *f, 
+           const UChar    *patternSpecification, 
+           ... ) 
+{ 
+    va_list ap; 
+    int32_t converted; 
+ 
+    va_start(ap, patternSpecification); 
+    converted = u_vfscanf_u(f, patternSpecification, ap); 
+    va_end(ap); 
+ 
+    return converted; 
+} 
+ 
+U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_vfscanf(UFILE        *f, 
+          const char    *patternSpecification, 
+          va_list        ap) 
+{ 
+    int32_t converted; 
+    UChar *pattern; 
+    UChar patBuffer[UFMT_DEFAULT_BUFFER_SIZE]; 
+    int32_t size = (int32_t)uprv_strlen(patternSpecification) + 1; 
+ 
+    /* convert from the default codepage to Unicode */ 
+    if (size >= MAX_UCHAR_BUFFER_SIZE(patBuffer)) { 
+        pattern = (UChar *)uprv_malloc(size * sizeof(UChar)); 
+        if(pattern == 0) { 
+            return 0; 
+        } 
+    } 
+    else { 
+        pattern = patBuffer; 
+    } 
+    u_charsToUChars(patternSpecification, pattern, size); 
+ 
+    /* do the work */ 
+    converted = u_vfscanf_u(f, pattern, ap); 
+ 
+    /* clean up */ 
+    if (pattern != patBuffer) { 
+        uprv_free(pattern); 
+    } 
+ 
+    return converted; 
+} 
+ 
+U_CAPI int32_t  U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_vfscanf_u(UFILE       *f, 
+            const UChar *patternSpecification, 
+            va_list     ap) 
+{ 
+    return u_scanf_parse(f, patternSpecification, ap); 
+} 
+ 
+#endif /* #if !UCONFIG_NO_FORMATTING */ 
+ 
diff --git a/contrib/libs/icu/io/uscanf.h b/contrib/libs/icu/io/uscanf.h
index ebb8e79188..1b2ef4906b 100644
--- a/contrib/libs/icu/io/uscanf.h
+++ b/contrib/libs/icu/io/uscanf.h
@@ -1,4 +1,4 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2016 and later: Unicode, Inc. and others. 
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 ******************************************************************************
diff --git a/contrib/libs/icu/io/uscanf_p.cpp b/contrib/libs/icu/io/uscanf_p.cpp
index 6dc1c09dee..73c4da73dc 100644
--- a/contrib/libs/icu/io/uscanf_p.cpp
+++ b/contrib/libs/icu/io/uscanf_p.cpp
@@ -1,1450 +1,1450 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-*
-*   Copyright (C) 1998-2016, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*
-*******************************************************************************
-*
-* File uscnnf_p.c
-*
-* Modification History:
-*
-*   Date        Name        Description
-*   12/02/98    stephen        Creation.
-*   03/13/99    stephen     Modified for new C API.
-*******************************************************************************
-*/
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_CONVERSION
-
-#include "unicode/uchar.h"
-#include "unicode/ustring.h"
-#include "unicode/unum.h"
-#include "unicode/udat.h"
-#include "unicode/uset.h"
-#include "uscanf.h"
-#include "ufmt_cmn.h"
-#include "ufile.h"
-#include "locbund.h"
-
-#include "cmemory.h"
-#include "ustr_cnv.h"
-
-/* flag characters for u_scanf */
-#define FLAG_ASTERISK 0x002A
-#define FLAG_PAREN 0x0028
-
-#define ISFLAG(s)    (s) == FLAG_ASTERISK || \
-            (s) == FLAG_PAREN
-
-/* special characters for u_scanf */
-#define SPEC_DOLLARSIGN 0x0024
-
-/* unicode digits */
-#define DIGIT_ZERO 0x0030
-#define DIGIT_ONE 0x0031
-#define DIGIT_TWO 0x0032
-#define DIGIT_THREE 0x0033
-#define DIGIT_FOUR 0x0034
-#define DIGIT_FIVE 0x0035
-#define DIGIT_SIX 0x0036
-#define DIGIT_SEVEN 0x0037
-#define DIGIT_EIGHT 0x0038
-#define DIGIT_NINE 0x0039
-
-#define ISDIGIT(s)    (s) == DIGIT_ZERO || \
-            (s) == DIGIT_ONE || \
-            (s) == DIGIT_TWO || \
-            (s) == DIGIT_THREE || \
-            (s) == DIGIT_FOUR || \
-            (s) == DIGIT_FIVE || \
-            (s) == DIGIT_SIX || \
-            (s) == DIGIT_SEVEN || \
-            (s) == DIGIT_EIGHT || \
-            (s) == DIGIT_NINE
-
-/* u_scanf modifiers */
-#define MOD_H 0x0068
-#define MOD_LOWERL 0x006C
-#define MOD_L 0x004C
-
-#define ISMOD(s)    (s) == MOD_H || \
-            (s) == MOD_LOWERL || \
-            (s) == MOD_L
-
-/**
- * Struct encapsulating a single uscanf format specification.
- */
-typedef struct u_scanf_spec_info {
-    int32_t fWidth;         /* Width  */
-
-    UChar   fSpec;          /* Format specification  */
-
-    UChar   fPadChar;       /* Padding character  */
-
-    UBool   fSkipArg;       /* TRUE if arg should be skipped */
-    UBool   fIsLongDouble;  /* L flag  */
-    UBool   fIsShort;       /* h flag  */
-    UBool   fIsLong;        /* l flag  */
-    UBool   fIsLongLong;    /* ll flag  */
-    UBool   fIsString;      /* TRUE if this is a NULL-terminated string. */
-} u_scanf_spec_info;
-
-
-/**
- * Struct encapsulating a single u_scanf format specification.
- */
-typedef struct u_scanf_spec {
-    u_scanf_spec_info    fInfo;        /* Information on this spec */
-    int32_t        fArgPos;    /* Position of data in arg list */
-} u_scanf_spec;
-
-/**
- * Parse a single u_scanf format specifier in Unicode.
- * @param fmt A pointer to a '%' character in a u_scanf format specification.
- * @param spec A pointer to a <TT>u_scanf_spec</TT> to receive the parsed
- * format specifier.
- * @return The number of characters contained in this specifier.
- */
-static int32_t
-u_scanf_parse_spec (const UChar     *fmt,
-            u_scanf_spec    *spec)
-{
-    const UChar *s = fmt;
-    const UChar *backup;
-    u_scanf_spec_info *info = &(spec->fInfo);
-
-    /* initialize spec to default values */
-    spec->fArgPos             = -1;
-
-    info->fWidth        = -1;
-    info->fSpec         = 0x0000;
-    info->fPadChar      = 0x0020;
-    info->fSkipArg      = FALSE;
-    info->fIsLongDouble = FALSE;
-    info->fIsShort      = FALSE;
-    info->fIsLong       = FALSE;
-    info->fIsLongLong   = FALSE;
-    info->fIsString     = TRUE;
-
-
-    /* skip over the initial '%' */
-    s++;
-
-    /* Check for positional argument */
-    if(ISDIGIT(*s)) {
-
-        /* Save the current position */
-        backup = s;
-
-        /* handle positional parameters */
-        if(ISDIGIT(*s)) {
-            spec->fArgPos = (int) (*s++ - DIGIT_ZERO);
-
-            while(ISDIGIT(*s)) {
-                spec->fArgPos *= 10;
-                spec->fArgPos += (int) (*s++ - DIGIT_ZERO);
-            }
-        }
-
-        /* if there is no '$', don't read anything */
-        if(*s != SPEC_DOLLARSIGN) {
-            spec->fArgPos = -1;
-            s = backup;
-        }
-        /* munge the '$' */
-        else
-            s++;
-    }
-
-    /* Get any format flags */
-    while(ISFLAG(*s)) {
-        switch(*s++) {
-
-            /* skip argument */
-        case FLAG_ASTERISK:
-            info->fSkipArg = TRUE;
-            break;
-
-            /* pad character specified */
-        case FLAG_PAREN:
-
-            /* first four characters are hex values for pad char */
-            info->fPadChar = (UChar)ufmt_digitvalue(*s++);
-            info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*s++));
-            info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*s++));
-            info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*s++));
-
-            /* final character is ignored */
-            s++;
-
-            break;
-        }
-    }
-
-    /* Get the width */
-    if(ISDIGIT(*s)){
-        info->fWidth = (int) (*s++ - DIGIT_ZERO);
-
-        while(ISDIGIT(*s)) {
-            info->fWidth *= 10;
-            info->fWidth += (int) (*s++ - DIGIT_ZERO);
-        }
-    }
-
-    /* Get any modifiers */
-    if(ISMOD(*s)) {
-        switch(*s++) {
-
-            /* short */
-        case MOD_H:
-            info->fIsShort = TRUE;
-            break;
-
-            /* long or long long */
-        case MOD_LOWERL:
-            if(*s == MOD_LOWERL) {
-                info->fIsLongLong = TRUE;
-                /* skip over the next 'l' */
-                s++;
-            }
-            else
-                info->fIsLong = TRUE;
-            break;
-
-            /* long double */
-        case MOD_L:
-            info->fIsLongDouble = TRUE;
-            break;
-        }
-    }
-
-    /* finally, get the specifier letter */
-    info->fSpec = *s++;
-
-    /* return # of characters in this specifier */
-    return (int32_t)(s - fmt);
-}
-
-#define UP_PERCENT 0x0025
-
-
-/* ANSI style formatting */
-/* Use US-ASCII characters only for formatting */
-
-/* % */
-#define UFMT_SIMPLE_PERCENT {ufmt_simple_percent, u_scanf_simple_percent_handler}
-/* s */
-#define UFMT_STRING         {ufmt_string, u_scanf_string_handler}
-/* c */
-#define UFMT_CHAR           {ufmt_string, u_scanf_char_handler}
-/* d, i */
-#define UFMT_INT            {ufmt_int, u_scanf_integer_handler}
-/* u */
-#define UFMT_UINT           {ufmt_int, u_scanf_uinteger_handler}
-/* o */
-#define UFMT_OCTAL          {ufmt_int, u_scanf_octal_handler}
-/* x, X */
-#define UFMT_HEX            {ufmt_int, u_scanf_hex_handler}
-/* f */
-#define UFMT_DOUBLE         {ufmt_double, u_scanf_double_handler}
-/* e, E */
-#define UFMT_SCIENTIFIC     {ufmt_double, u_scanf_scientific_handler}
-/* g, G */
-#define UFMT_SCIDBL         {ufmt_double, u_scanf_scidbl_handler}
-/* n */
-#define UFMT_COUNT          {ufmt_count, u_scanf_count_handler}
-/* [ */
-#define UFMT_SCANSET        {ufmt_string, u_scanf_scanset_handler}
-
-/* non-ANSI extensions */
-/* Use US-ASCII characters only for formatting */
-
-/* p */
-#define UFMT_POINTER        {ufmt_pointer, u_scanf_pointer_handler}
-/* V */
-#define UFMT_SPELLOUT       {ufmt_double, u_scanf_spellout_handler}
-/* P */
-#define UFMT_PERCENT        {ufmt_double, u_scanf_percent_handler}
-/* C  K is old format */
-#define UFMT_UCHAR          {ufmt_uchar, u_scanf_uchar_handler}
-/* S  U is old format */
-#define UFMT_USTRING        {ufmt_ustring, u_scanf_ustring_handler}
-
-
-#define UFMT_EMPTY {ufmt_empty, NULL}
-
-/**
- * A u_scanf handler function.  
- * A u_scanf handler is responsible for handling a single u_scanf 
- * format specification, for example 'd' or 's'.
- * @param stream The UFILE to which to write output.
- * @param info A pointer to a <TT>u_scanf_spec_info</TT> struct containing
- * information on the format specification.
- * @param args A pointer to the argument data
- * @param fmt A pointer to the first character in the format string
- * following the spec.
- * @param fmtConsumed On output, set to the number of characters consumed
- * in <TT>fmt</TT>. Do nothing, if the argument isn't variable width.
- * @param argConverted The number of arguments converted and assigned, or -1 if an
- * error occurred.
- * @return The number of code points consumed during reading.
- */
-typedef int32_t (*u_scanf_handler) (UFILE   *stream,
-                   u_scanf_spec_info  *info,
-                   ufmt_args                *args,
-                   const UChar              *fmt,
-                   int32_t                  *fmtConsumed,
-                   int32_t                  *argConverted);
-
-typedef struct u_scanf_info {
-    ufmt_type_info info;
-    u_scanf_handler handler;
-} u_scanf_info;
-
-#define USCANF_NUM_FMT_HANDLERS 108
-#define USCANF_SYMBOL_BUFFER_SIZE 8
-
-/* We do not use handlers for 0-0x1f */
-#define USCANF_BASE_FMT_HANDLERS 0x20
-
-
-static int32_t
-u_scanf_skip_leading_ws(UFILE   *input,
-                        UChar   pad)
-{
-    UChar   c;
-    int32_t count = 0;
-    UBool isNotEOF;
-
-    /* skip all leading ws in the input */
-    while( ((isNotEOF = ufile_getch(input, &c)) == TRUE) && (c == pad || u_isWhitespace(c)) )
-    {
-        count++;
-    }
-
-    /* put the final character back on the input */
-    if(isNotEOF)
-        u_fungetc(c, input);
-
-    return count;
-}
-
-/* TODO: Is always skipping the prefix symbol as a positive sign a good idea in all locales? */
-static int32_t
-u_scanf_skip_leading_positive_sign(UFILE   *input,
-                                   UNumberFormat *format,
-                                   UErrorCode *status)
-{
-    UChar   c;
-    int32_t count = 0;
-    UBool isNotEOF;
-    UChar plusSymbol[USCANF_SYMBOL_BUFFER_SIZE];
-    int32_t symbolLen;
-    UErrorCode localStatus = U_ZERO_ERROR;
-
-    if (U_SUCCESS(*status)) {
-        symbolLen = unum_getSymbol(format,
-            UNUM_PLUS_SIGN_SYMBOL,
-            plusSymbol,
-            UPRV_LENGTHOF(plusSymbol),
-            &localStatus);
-
-        if (U_SUCCESS(localStatus)) {
-            /* skip all leading ws in the input */
-            while( ((isNotEOF = ufile_getch(input, &c)) == TRUE) && (count < symbolLen && c == plusSymbol[count]) )
-            {
-                count++;
-            }
-
-            /* put the final character back on the input */
-            if(isNotEOF) {
-                u_fungetc(c, input);
-            }
-        }
-    }
-
-    return count;
-}
-
+// © 2016 and later: Unicode, Inc. and others. 
+// License & terms of use: http://www.unicode.org/copyright.html 
+/* 
+******************************************************************************* 
+* 
+*   Copyright (C) 1998-2016, International Business Machines 
+*   Corporation and others.  All Rights Reserved. 
+* 
+******************************************************************************* 
+* 
+* File uscnnf_p.c 
+* 
+* Modification History: 
+* 
+*   Date        Name        Description 
+*   12/02/98    stephen        Creation. 
+*   03/13/99    stephen     Modified for new C API. 
+******************************************************************************* 
+*/ 
+ 
+#include "unicode/utypes.h" 
+ 
+#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_CONVERSION 
+ 
+#include "unicode/uchar.h" 
+#include "unicode/ustring.h" 
+#include "unicode/unum.h" 
+#include "unicode/udat.h" 
+#include "unicode/uset.h" 
+#include "uscanf.h" 
+#include "ufmt_cmn.h" 
+#include "ufile.h" 
+#include "locbund.h" 
+ 
+#include "cmemory.h" 
+#include "ustr_cnv.h" 
+ 
+/* flag characters for u_scanf */ 
+#define FLAG_ASTERISK 0x002A 
+#define FLAG_PAREN 0x0028 
+ 
+#define ISFLAG(s)    (s) == FLAG_ASTERISK || \ 
+            (s) == FLAG_PAREN 
+ 
+/* special characters for u_scanf */ 
+#define SPEC_DOLLARSIGN 0x0024 
+ 
+/* unicode digits */ 
+#define DIGIT_ZERO 0x0030 
+#define DIGIT_ONE 0x0031 
+#define DIGIT_TWO 0x0032 
+#define DIGIT_THREE 0x0033 
+#define DIGIT_FOUR 0x0034 
+#define DIGIT_FIVE 0x0035 
+#define DIGIT_SIX 0x0036 
+#define DIGIT_SEVEN 0x0037 
+#define DIGIT_EIGHT 0x0038 
+#define DIGIT_NINE 0x0039 
+ 
+#define ISDIGIT(s)    (s) == DIGIT_ZERO || \ 
+            (s) == DIGIT_ONE || \ 
+            (s) == DIGIT_TWO || \ 
+            (s) == DIGIT_THREE || \ 
+            (s) == DIGIT_FOUR || \ 
+            (s) == DIGIT_FIVE || \ 
+            (s) == DIGIT_SIX || \ 
+            (s) == DIGIT_SEVEN || \ 
+            (s) == DIGIT_EIGHT || \ 
+            (s) == DIGIT_NINE 
+ 
+/* u_scanf modifiers */ 
+#define MOD_H 0x0068 
+#define MOD_LOWERL 0x006C 
+#define MOD_L 0x004C 
+ 
+#define ISMOD(s)    (s) == MOD_H || \ 
+            (s) == MOD_LOWERL || \ 
+            (s) == MOD_L 
+ 
+/** 
+ * Struct encapsulating a single uscanf format specification. 
+ */ 
+typedef struct u_scanf_spec_info { 
+    int32_t fWidth;         /* Width  */ 
+ 
+    UChar   fSpec;          /* Format specification  */ 
+ 
+    UChar   fPadChar;       /* Padding character  */ 
+ 
+    UBool   fSkipArg;       /* TRUE if arg should be skipped */ 
+    UBool   fIsLongDouble;  /* L flag  */ 
+    UBool   fIsShort;       /* h flag  */ 
+    UBool   fIsLong;        /* l flag  */ 
+    UBool   fIsLongLong;    /* ll flag  */ 
+    UBool   fIsString;      /* TRUE if this is a NULL-terminated string. */ 
+} u_scanf_spec_info; 
+ 
+ 
+/** 
+ * Struct encapsulating a single u_scanf format specification. 
+ */ 
+typedef struct u_scanf_spec { 
+    u_scanf_spec_info    fInfo;        /* Information on this spec */ 
+    int32_t        fArgPos;    /* Position of data in arg list */ 
+} u_scanf_spec; 
+ 
+/** 
+ * Parse a single u_scanf format specifier in Unicode. 
+ * @param fmt A pointer to a '%' character in a u_scanf format specification. 
+ * @param spec A pointer to a <TT>u_scanf_spec</TT> to receive the parsed 
+ * format specifier. 
+ * @return The number of characters contained in this specifier. 
+ */ 
 static int32_t 
-u_scanf_simple_percent_handler(UFILE        *input,
-                               u_scanf_spec_info *info,
-                               ufmt_args    *args,
-                               const UChar  *fmt,
-                               int32_t      *fmtConsumed,
-                               int32_t      *argConverted)
-{
-    (void)info;
-    (void)args;
-    (void)fmt;
-    (void)fmtConsumed;
-
-    /* make sure the next character in the input is a percent */
-    *argConverted = 0;
-    if(u_fgetc(input) != 0x0025) {
-        *argConverted = -1;
-    }
-    return 1;
-}
-
-static int32_t
-u_scanf_count_handler(UFILE         *input,
-                      u_scanf_spec_info *info,
-                      ufmt_args     *args,
-                      const UChar   *fmt,
-                      int32_t       *fmtConsumed,
-                      int32_t       *argConverted)
-{
-    (void)input;
-    (void)fmt;
-    (void)fmtConsumed;
-
-    /* in the special case of count, the u_scanf_spec_info's width */
-    /* will contain the # of items converted thus far */
-    if (!info->fSkipArg) {
-        if (info->fIsShort)
-            *(int16_t*)(args[0].ptrValue) = (int16_t)(UINT16_MAX & info->fWidth);
-        else if (info->fIsLongLong)
-            *(int64_t*)(args[0].ptrValue) = info->fWidth;
-        else
-            *(int32_t*)(args[0].ptrValue) = (int32_t)(UINT32_MAX & info->fWidth);
-    }
-    *argConverted = 0;
-
-    /* we converted 0 args */
-    return 0;
-}
-
-static int32_t
-u_scanf_double_handler(UFILE        *input,
-                       u_scanf_spec_info *info,
-                       ufmt_args    *args,
-                       const UChar  *fmt,
-                       int32_t      *fmtConsumed,
-                       int32_t      *argConverted)
-{
-    (void)fmt;
-    (void)fmtConsumed;
-
-    int32_t         len;
-    double          num;
-    UNumberFormat   *format;
-    int32_t         parsePos    = 0;
-    int32_t         skipped;
-    UErrorCode      status      = U_ZERO_ERROR;
-
-
-    /* skip all ws in the input */
-    skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
-
-    /* fill the input's internal buffer */
-    ufile_fill_uchar_buffer(input);
-
-    /* determine the size of the input's buffer */
-    len = (int32_t)(input->str.fLimit - input->str.fPos);
-
-    /* truncate to the width, if specified */
-    if(info->fWidth != -1)
-        len = ufmt_min(len, info->fWidth);
-
-    /* get the formatter */
-    format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL);
-
-    /* handle error */
-    if(format == 0)
-        return 0;
-
-    /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
-    skipped += u_scanf_skip_leading_positive_sign(input, format, &status);
-
-    /* parse the number */
-    num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status);
-
-    if (!info->fSkipArg) {
-        if (info->fIsLong)
-            *(double*)(args[0].ptrValue) = num;
-        else if (info->fIsLongDouble)
-            *(long double*)(args[0].ptrValue) = num;
-        else
-            *(float*)(args[0].ptrValue) = (float)num;
-    }
-
-    /* mask off any necessary bits */
-    /*  if(! info->fIsLong_double)
-    num &= DBL_MAX;*/
-
-    /* update the input's position to reflect consumed data */
-    input->str.fPos += parsePos;
-
-    /* we converted 1 arg */
-    *argConverted = !info->fSkipArg;
-    return parsePos + skipped;
-}
-
-#define UPRINTF_SYMBOL_BUFFER_SIZE 8
-
-static int32_t
-u_scanf_scientific_handler(UFILE        *input,
-                           u_scanf_spec_info *info,
-                           ufmt_args    *args,
-                           const UChar  *fmt,
-                           int32_t      *fmtConsumed,
-                           int32_t      *argConverted)
-{
-    (void)fmt;
-    (void)fmtConsumed;
-
-    int32_t         len;
-    double          num;
-    UNumberFormat   *format;
-    int32_t         parsePos    = 0;
-    int32_t         skipped;
-    UErrorCode      status      = U_ZERO_ERROR;
-    UChar srcExpBuf[UPRINTF_SYMBOL_BUFFER_SIZE];
-    int32_t srcLen, expLen;
-    UChar expBuf[UPRINTF_SYMBOL_BUFFER_SIZE];
-
-
-    /* skip all ws in the input */
-    skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
-
-    /* fill the input's internal buffer */
-    ufile_fill_uchar_buffer(input);
-
-    /* determine the size of the input's buffer */
-    len = (int32_t)(input->str.fLimit - input->str.fPos);
-
-    /* truncate to the width, if specified */
-    if(info->fWidth != -1)
-        len = ufmt_min(len, info->fWidth);
-
-    /* get the formatter */
-    format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SCIENTIFIC);
-
-    /* handle error */
-    if(format == 0)
-        return 0;
-
-    /* set the appropriate flags on the formatter */
-
-    srcLen = unum_getSymbol(format,
-        UNUM_EXPONENTIAL_SYMBOL,
-        srcExpBuf,
-        sizeof(srcExpBuf),
-        &status);
-
-    /* Upper/lower case the e */
-    if (info->fSpec == (UChar)0x65 /* e */) {
-        expLen = u_strToLower(expBuf, (int32_t)sizeof(expBuf),
-            srcExpBuf, srcLen,
-            input->str.fBundle.fLocale,
-            &status);
-    }
-    else {
-        expLen = u_strToUpper(expBuf, (int32_t)sizeof(expBuf),
-            srcExpBuf, srcLen,
-            input->str.fBundle.fLocale,
-            &status);
-    }
-
-    unum_setSymbol(format,
-        UNUM_EXPONENTIAL_SYMBOL,
-        expBuf,
-        expLen,
-        &status);
-
-
-
-
-    /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
-    skipped += u_scanf_skip_leading_positive_sign(input, format, &status);
-
-    /* parse the number */
-    num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status);
-
-    if (!info->fSkipArg) {
-        if (info->fIsLong)
-            *(double*)(args[0].ptrValue) = num;
-        else if (info->fIsLongDouble)
-            *(long double*)(args[0].ptrValue) = num;
-        else
-            *(float*)(args[0].ptrValue) = (float)num;
-    }
-
-    /* mask off any necessary bits */
-    /*  if(! info->fIsLong_double)
-    num &= DBL_MAX;*/
-
-    /* update the input's position to reflect consumed data */
-    input->str.fPos += parsePos;
-
-    /* we converted 1 arg */
-    *argConverted = !info->fSkipArg;
-    return parsePos + skipped;
-}
-
-static int32_t
-u_scanf_scidbl_handler(UFILE        *input,
-                       u_scanf_spec_info *info,
-                       ufmt_args    *args,
-                       const UChar  *fmt,
-                       int32_t      *fmtConsumed,
-                       int32_t      *argConverted)
-{
-    (void)fmt;
-    (void)fmtConsumed;
-
-    int32_t       len;
-    double        num;
-    UNumberFormat *scientificFormat, *genericFormat;
-    /*int32_t       scientificResult, genericResult;*/
-    double        scientificResult, genericResult;
-    int32_t       scientificParsePos = 0, genericParsePos = 0, parsePos = 0;
-    int32_t       skipped;
-    UErrorCode    scientificStatus = U_ZERO_ERROR;
-    UErrorCode    genericStatus = U_ZERO_ERROR;
-
-
-    /* since we can't determine by scanning the characters whether */
-    /* a number was formatted in the 'f' or 'g' styles, parse the */
-    /* string with both formatters, and assume whichever one */
-    /* parsed the most is the correct formatter to use */
-
-
-    /* skip all ws in the input */
-    skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
-
-    /* fill the input's internal buffer */
-    ufile_fill_uchar_buffer(input);
-
-    /* determine the size of the input's buffer */
-    len = (int32_t)(input->str.fLimit - input->str.fPos);
-
-    /* truncate to the width, if specified */
-    if(info->fWidth != -1)
-        len = ufmt_min(len, info->fWidth);
-
-    /* get the formatters */
-    scientificFormat = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SCIENTIFIC);
-    genericFormat = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL);
-
-    /* handle error */
-    if(scientificFormat == 0 || genericFormat == 0)
-        return 0;
-
-    /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
-    skipped += u_scanf_skip_leading_positive_sign(input, genericFormat, &genericStatus);
-
-    /* parse the number using each format*/
-
-    scientificResult = unum_parseDouble(scientificFormat, input->str.fPos, len,
-        &scientificParsePos, &scientificStatus);
-
-    genericResult = unum_parseDouble(genericFormat, input->str.fPos, len,
-        &genericParsePos, &genericStatus);
-
-    /* determine which parse made it farther */
-    if(scientificParsePos > genericParsePos) {
-        /* stash the result in num */
-        num = scientificResult;
-        /* update the input's position to reflect consumed data */
-        parsePos += scientificParsePos;
-    }
-    else {
-        /* stash the result in num */
-        num = genericResult;
-        /* update the input's position to reflect consumed data */
-        parsePos += genericParsePos;
-    }
-    input->str.fPos += parsePos;
-
-    if (!info->fSkipArg) {
-        if (info->fIsLong)
-            *(double*)(args[0].ptrValue) = num;
-        else if (info->fIsLongDouble)
-            *(long double*)(args[0].ptrValue) = num;
-        else
-            *(float*)(args[0].ptrValue) = (float)num;
-    }
-
-    /* mask off any necessary bits */
-    /*  if(! info->fIsLong_double)
-    num &= DBL_MAX;*/
-
-    /* we converted 1 arg */
-    *argConverted = !info->fSkipArg;
-    return parsePos + skipped;
-}
-
-static int32_t
-u_scanf_integer_handler(UFILE       *input,
-                        u_scanf_spec_info *info,
-                        ufmt_args   *args,
-                        const UChar *fmt,
-                        int32_t     *fmtConsumed,
-                        int32_t     *argConverted)
-{
-    (void)fmt;
-    (void)fmtConsumed;
-
-    int32_t         len;
-    void            *num        = (void*) (args[0].ptrValue);
-    UNumberFormat   *format;
-    int32_t         parsePos    = 0;
-    int32_t         skipped;
-    UErrorCode      status      = U_ZERO_ERROR;
-    int64_t         result;
-
-
-    /* skip all ws in the input */
-    skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
-
-    /* fill the input's internal buffer */
-    ufile_fill_uchar_buffer(input);
-
-    /* determine the size of the input's buffer */
-    len = (int32_t)(input->str.fLimit - input->str.fPos);
-
-    /* truncate to the width, if specified */
-    if(info->fWidth != -1)
-        len = ufmt_min(len, info->fWidth);
-
-    /* get the formatter */
-    format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL);
-
-    /* handle error */
-    if(format == 0)
-        return 0;
-
-    /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
-    skipped += u_scanf_skip_leading_positive_sign(input, format, &status);
-
-    /* parse the number */
-    result = unum_parseInt64(format, input->str.fPos, len, &parsePos, &status);
-
-    /* mask off any necessary bits */
-    if (!info->fSkipArg) {
-        if (info->fIsShort)
-            *(int16_t*)num = (int16_t)(UINT16_MAX & result);
-        else if (info->fIsLongLong)
-            *(int64_t*)num = result;
-        else
-            *(int32_t*)num = (int32_t)(UINT32_MAX & result);
-    }
-
-    /* update the input's position to reflect consumed data */
-    input->str.fPos += parsePos;
-
-    /* we converted 1 arg */
-    *argConverted = !info->fSkipArg;
-    return parsePos + skipped;
-}
-
-static int32_t
-u_scanf_uinteger_handler(UFILE          *input,
-                         u_scanf_spec_info *info,
-                         ufmt_args      *args,
-                         const UChar    *fmt,
-                         int32_t        *fmtConsumed,
-                         int32_t        *argConverted)
-{
-    /* TODO Fix this when Numberformat handles uint64_t */
-    return u_scanf_integer_handler(input, info, args, fmt, fmtConsumed, argConverted);
-}
-
-static int32_t
-u_scanf_percent_handler(UFILE       *input,
-                        u_scanf_spec_info *info,
-                        ufmt_args   *args,
-                        const UChar *fmt,
-                        int32_t     *fmtConsumed,
-                        int32_t     *argConverted)
-{
-    (void)fmt;
-    (void)fmtConsumed;
-
-    int32_t         len;
-    double          num;
-    UNumberFormat   *format;
-    int32_t         parsePos    = 0;
-    UErrorCode      status      = U_ZERO_ERROR;
-
-
-    /* skip all ws in the input */
-    u_scanf_skip_leading_ws(input, info->fPadChar);
-
-    /* fill the input's internal buffer */
-    ufile_fill_uchar_buffer(input);
-
-    /* determine the size of the input's buffer */
-    len = (int32_t)(input->str.fLimit - input->str.fPos);
-
-    /* truncate to the width, if specified */
-    if(info->fWidth != -1)
-        len = ufmt_min(len, info->fWidth);
-
-    /* get the formatter */
-    format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_PERCENT);
-
-    /* handle error */
-    if(format == 0)
-        return 0;
-
-    /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
-    u_scanf_skip_leading_positive_sign(input, format, &status);
-
-    /* parse the number */
-    num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status);
-
-    if (!info->fSkipArg) {
-        *(double*)(args[0].ptrValue) = num;
-    }
-
-    /* mask off any necessary bits */
-    /*  if(! info->fIsLong_double)
-    num &= DBL_MAX;*/
-
-    /* update the input's position to reflect consumed data */
-    input->str.fPos += parsePos;
-
-    /* we converted 1 arg */
-    *argConverted = !info->fSkipArg;
-    return parsePos;
-}
-
-static int32_t
-u_scanf_string_handler(UFILE        *input,
-                       u_scanf_spec_info *info,
-                       ufmt_args    *args,
-                       const UChar  *fmt,
-                       int32_t      *fmtConsumed,
-                       int32_t      *argConverted)
-{
-    (void)fmt;
-    (void)fmtConsumed;
-
-    const UChar *source;
-    UConverter  *conv;
-    char        *arg    = (char*)(args[0].ptrValue);
-    char        *alias  = arg;
-    char        *limit;
-    UErrorCode  status  = U_ZERO_ERROR;
-    int32_t     count;
-    int32_t     skipped = 0;
-    UChar       c;
-    UBool       isNotEOF = FALSE;
-
-    /* skip all ws in the input */
-    if (info->fIsString) {
-        skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
-    }
-
-    /* get the string one character at a time, truncating to the width */
-    count = 0;
-
-    /* open the default converter */
-    conv = u_getDefaultConverter(&status);
-
-    if(U_FAILURE(status))
-        return -1;
-
+u_scanf_parse_spec (const UChar     *fmt, 
+            u_scanf_spec    *spec) 
+{ 
+    const UChar *s = fmt; 
+    const UChar *backup; 
+    u_scanf_spec_info *info = &(spec->fInfo); 
+ 
+    /* initialize spec to default values */ 
+    spec->fArgPos             = -1; 
+ 
+    info->fWidth        = -1; 
+    info->fSpec         = 0x0000; 
+    info->fPadChar      = 0x0020; 
+    info->fSkipArg      = FALSE; 
+    info->fIsLongDouble = FALSE; 
+    info->fIsShort      = FALSE; 
+    info->fIsLong       = FALSE; 
+    info->fIsLongLong   = FALSE; 
+    info->fIsString     = TRUE; 
+ 
+ 
+    /* skip over the initial '%' */ 
+    s++; 
+ 
+    /* Check for positional argument */ 
+    if(ISDIGIT(*s)) { 
+ 
+        /* Save the current position */ 
+        backup = s; 
+ 
+        /* handle positional parameters */ 
+        if(ISDIGIT(*s)) { 
+            spec->fArgPos = (int) (*s++ - DIGIT_ZERO); 
+ 
+            while(ISDIGIT(*s)) { 
+                spec->fArgPos *= 10; 
+                spec->fArgPos += (int) (*s++ - DIGIT_ZERO); 
+            } 
+        } 
+ 
+        /* if there is no '$', don't read anything */ 
+        if(*s != SPEC_DOLLARSIGN) { 
+            spec->fArgPos = -1; 
+            s = backup; 
+        } 
+        /* munge the '$' */ 
+        else 
+            s++; 
+    } 
+ 
+    /* Get any format flags */ 
+    while(ISFLAG(*s)) { 
+        switch(*s++) { 
+ 
+            /* skip argument */ 
+        case FLAG_ASTERISK: 
+            info->fSkipArg = TRUE; 
+            break; 
+ 
+            /* pad character specified */ 
+        case FLAG_PAREN: 
+ 
+            /* first four characters are hex values for pad char */ 
+            info->fPadChar = (UChar)ufmt_digitvalue(*s++); 
+            info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*s++)); 
+            info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*s++)); 
+            info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*s++)); 
+ 
+            /* final character is ignored */ 
+            s++; 
+ 
+            break; 
+        } 
+    } 
+ 
+    /* Get the width */ 
+    if(ISDIGIT(*s)){ 
+        info->fWidth = (int) (*s++ - DIGIT_ZERO); 
+ 
+        while(ISDIGIT(*s)) { 
+            info->fWidth *= 10; 
+            info->fWidth += (int) (*s++ - DIGIT_ZERO); 
+        } 
+    } 
+ 
+    /* Get any modifiers */ 
+    if(ISMOD(*s)) { 
+        switch(*s++) { 
+ 
+            /* short */ 
+        case MOD_H: 
+            info->fIsShort = TRUE; 
+            break; 
+ 
+            /* long or long long */ 
+        case MOD_LOWERL: 
+            if(*s == MOD_LOWERL) { 
+                info->fIsLongLong = TRUE; 
+                /* skip over the next 'l' */ 
+                s++; 
+            } 
+            else 
+                info->fIsLong = TRUE; 
+            break; 
+ 
+            /* long double */ 
+        case MOD_L: 
+            info->fIsLongDouble = TRUE; 
+            break; 
+        } 
+    } 
+ 
+    /* finally, get the specifier letter */ 
+    info->fSpec = *s++; 
+ 
+    /* return # of characters in this specifier */ 
+    return (int32_t)(s - fmt); 
+} 
+ 
+#define UP_PERCENT 0x0025 
+ 
+ 
+/* ANSI style formatting */ 
+/* Use US-ASCII characters only for formatting */ 
+ 
+/* % */ 
+#define UFMT_SIMPLE_PERCENT {ufmt_simple_percent, u_scanf_simple_percent_handler} 
+/* s */ 
+#define UFMT_STRING         {ufmt_string, u_scanf_string_handler} 
+/* c */ 
+#define UFMT_CHAR           {ufmt_string, u_scanf_char_handler} 
+/* d, i */ 
+#define UFMT_INT            {ufmt_int, u_scanf_integer_handler} 
+/* u */ 
+#define UFMT_UINT           {ufmt_int, u_scanf_uinteger_handler} 
+/* o */ 
+#define UFMT_OCTAL          {ufmt_int, u_scanf_octal_handler} 
+/* x, X */ 
+#define UFMT_HEX            {ufmt_int, u_scanf_hex_handler} 
+/* f */ 
+#define UFMT_DOUBLE         {ufmt_double, u_scanf_double_handler} 
+/* e, E */ 
+#define UFMT_SCIENTIFIC     {ufmt_double, u_scanf_scientific_handler} 
+/* g, G */ 
+#define UFMT_SCIDBL         {ufmt_double, u_scanf_scidbl_handler} 
+/* n */ 
+#define UFMT_COUNT          {ufmt_count, u_scanf_count_handler} 
+/* [ */ 
+#define UFMT_SCANSET        {ufmt_string, u_scanf_scanset_handler} 
+ 
+/* non-ANSI extensions */ 
+/* Use US-ASCII characters only for formatting */ 
+ 
+/* p */ 
+#define UFMT_POINTER        {ufmt_pointer, u_scanf_pointer_handler} 
+/* V */ 
+#define UFMT_SPELLOUT       {ufmt_double, u_scanf_spellout_handler} 
+/* P */ 
+#define UFMT_PERCENT        {ufmt_double, u_scanf_percent_handler} 
+/* C  K is old format */ 
+#define UFMT_UCHAR          {ufmt_uchar, u_scanf_uchar_handler} 
+/* S  U is old format */ 
+#define UFMT_USTRING        {ufmt_ustring, u_scanf_ustring_handler} 
+ 
+ 
+#define UFMT_EMPTY {ufmt_empty, NULL} 
+ 
+/** 
+ * A u_scanf handler function.   
+ * A u_scanf handler is responsible for handling a single u_scanf  
+ * format specification, for example 'd' or 's'. 
+ * @param stream The UFILE to which to write output. 
+ * @param info A pointer to a <TT>u_scanf_spec_info</TT> struct containing 
+ * information on the format specification. 
+ * @param args A pointer to the argument data 
+ * @param fmt A pointer to the first character in the format string 
+ * following the spec. 
+ * @param fmtConsumed On output, set to the number of characters consumed 
+ * in <TT>fmt</TT>. Do nothing, if the argument isn't variable width. 
+ * @param argConverted The number of arguments converted and assigned, or -1 if an 
+ * error occurred. 
+ * @return The number of code points consumed during reading. 
+ */ 
+typedef int32_t (*u_scanf_handler) (UFILE   *stream, 
+                   u_scanf_spec_info  *info, 
+                   ufmt_args                *args, 
+                   const UChar              *fmt, 
+                   int32_t                  *fmtConsumed, 
+                   int32_t                  *argConverted); 
+ 
+typedef struct u_scanf_info { 
+    ufmt_type_info info; 
+    u_scanf_handler handler; 
+} u_scanf_info; 
+ 
+#define USCANF_NUM_FMT_HANDLERS 108 
+#define USCANF_SYMBOL_BUFFER_SIZE 8 
+ 
+/* We do not use handlers for 0-0x1f */ 
+#define USCANF_BASE_FMT_HANDLERS 0x20 
+ 
+ 
+static int32_t 
+u_scanf_skip_leading_ws(UFILE   *input, 
+                        UChar   pad) 
+{ 
+    UChar   c; 
+    int32_t count = 0; 
+    UBool isNotEOF; 
+ 
+    /* skip all leading ws in the input */ 
+    while( ((isNotEOF = ufile_getch(input, &c)) == TRUE) && (c == pad || u_isWhitespace(c)) ) 
+    { 
+        count++; 
+    } 
+ 
+    /* put the final character back on the input */ 
+    if(isNotEOF) 
+        u_fungetc(c, input); 
+ 
+    return count; 
+} 
+ 
+/* TODO: Is always skipping the prefix symbol as a positive sign a good idea in all locales? */ 
+static int32_t 
+u_scanf_skip_leading_positive_sign(UFILE   *input, 
+                                   UNumberFormat *format, 
+                                   UErrorCode *status) 
+{ 
+    UChar   c; 
+    int32_t count = 0; 
+    UBool isNotEOF; 
+    UChar plusSymbol[USCANF_SYMBOL_BUFFER_SIZE]; 
+    int32_t symbolLen; 
+    UErrorCode localStatus = U_ZERO_ERROR; 
+ 
+    if (U_SUCCESS(*status)) { 
+        symbolLen = unum_getSymbol(format, 
+            UNUM_PLUS_SIGN_SYMBOL, 
+            plusSymbol, 
+            UPRV_LENGTHOF(plusSymbol), 
+            &localStatus); 
+ 
+        if (U_SUCCESS(localStatus)) { 
+            /* skip all leading ws in the input */ 
+            while( ((isNotEOF = ufile_getch(input, &c)) == TRUE) && (count < symbolLen && c == plusSymbol[count]) ) 
+            { 
+                count++; 
+            } 
+ 
+            /* put the final character back on the input */ 
+            if(isNotEOF) { 
+                u_fungetc(c, input); 
+            } 
+        } 
+    } 
+ 
+    return count; 
+} 
+ 
+static int32_t  
+u_scanf_simple_percent_handler(UFILE        *input, 
+                               u_scanf_spec_info *info, 
+                               ufmt_args    *args, 
+                               const UChar  *fmt, 
+                               int32_t      *fmtConsumed, 
+                               int32_t      *argConverted) 
+{ 
+    (void)info; 
+    (void)args; 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    /* make sure the next character in the input is a percent */ 
+    *argConverted = 0; 
+    if(u_fgetc(input) != 0x0025) { 
+        *argConverted = -1; 
+    } 
+    return 1; 
+} 
+ 
+static int32_t 
+u_scanf_count_handler(UFILE         *input, 
+                      u_scanf_spec_info *info, 
+                      ufmt_args     *args, 
+                      const UChar   *fmt, 
+                      int32_t       *fmtConsumed, 
+                      int32_t       *argConverted) 
+{ 
+    (void)input; 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    /* in the special case of count, the u_scanf_spec_info's width */ 
+    /* will contain the # of items converted thus far */ 
+    if (!info->fSkipArg) { 
+        if (info->fIsShort) 
+            *(int16_t*)(args[0].ptrValue) = (int16_t)(UINT16_MAX & info->fWidth); 
+        else if (info->fIsLongLong) 
+            *(int64_t*)(args[0].ptrValue) = info->fWidth; 
+        else 
+            *(int32_t*)(args[0].ptrValue) = (int32_t)(UINT32_MAX & info->fWidth); 
+    } 
+    *argConverted = 0; 
+ 
+    /* we converted 0 args */ 
+    return 0; 
+} 
+ 
+static int32_t 
+u_scanf_double_handler(UFILE        *input, 
+                       u_scanf_spec_info *info, 
+                       ufmt_args    *args, 
+                       const UChar  *fmt, 
+                       int32_t      *fmtConsumed, 
+                       int32_t      *argConverted) 
+{ 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    int32_t         len; 
+    double          num; 
+    UNumberFormat   *format; 
+    int32_t         parsePos    = 0; 
+    int32_t         skipped; 
+    UErrorCode      status      = U_ZERO_ERROR; 
+ 
+ 
+    /* skip all ws in the input */ 
+    skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 
+ 
+    /* fill the input's internal buffer */ 
+    ufile_fill_uchar_buffer(input); 
+ 
+    /* determine the size of the input's buffer */ 
+    len = (int32_t)(input->str.fLimit - input->str.fPos); 
+ 
+    /* truncate to the width, if specified */ 
+    if(info->fWidth != -1) 
+        len = ufmt_min(len, info->fWidth); 
+ 
+    /* get the formatter */ 
+    format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL); 
+ 
+    /* handle error */ 
+    if(format == 0) 
+        return 0; 
+ 
+    /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */ 
+    skipped += u_scanf_skip_leading_positive_sign(input, format, &status); 
+ 
+    /* parse the number */ 
+    num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status); 
+ 
+    if (!info->fSkipArg) { 
+        if (info->fIsLong) 
+            *(double*)(args[0].ptrValue) = num; 
+        else if (info->fIsLongDouble) 
+            *(long double*)(args[0].ptrValue) = num; 
+        else 
+            *(float*)(args[0].ptrValue) = (float)num; 
+    } 
+ 
+    /* mask off any necessary bits */ 
+    /*  if(! info->fIsLong_double) 
+    num &= DBL_MAX;*/ 
+ 
+    /* update the input's position to reflect consumed data */ 
+    input->str.fPos += parsePos; 
+ 
+    /* we converted 1 arg */ 
+    *argConverted = !info->fSkipArg; 
+    return parsePos + skipped; 
+} 
+ 
+#define UPRINTF_SYMBOL_BUFFER_SIZE 8 
+ 
+static int32_t 
+u_scanf_scientific_handler(UFILE        *input, 
+                           u_scanf_spec_info *info, 
+                           ufmt_args    *args, 
+                           const UChar  *fmt, 
+                           int32_t      *fmtConsumed, 
+                           int32_t      *argConverted) 
+{ 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    int32_t         len; 
+    double          num; 
+    UNumberFormat   *format; 
+    int32_t         parsePos    = 0; 
+    int32_t         skipped; 
+    UErrorCode      status      = U_ZERO_ERROR; 
+    UChar srcExpBuf[UPRINTF_SYMBOL_BUFFER_SIZE]; 
+    int32_t srcLen, expLen; 
+    UChar expBuf[UPRINTF_SYMBOL_BUFFER_SIZE]; 
+ 
+ 
+    /* skip all ws in the input */ 
+    skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 
+ 
+    /* fill the input's internal buffer */ 
+    ufile_fill_uchar_buffer(input); 
+ 
+    /* determine the size of the input's buffer */ 
+    len = (int32_t)(input->str.fLimit - input->str.fPos); 
+ 
+    /* truncate to the width, if specified */ 
+    if(info->fWidth != -1) 
+        len = ufmt_min(len, info->fWidth); 
+ 
+    /* get the formatter */ 
+    format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SCIENTIFIC); 
+ 
+    /* handle error */ 
+    if(format == 0) 
+        return 0; 
+ 
+    /* set the appropriate flags on the formatter */ 
+ 
+    srcLen = unum_getSymbol(format, 
+        UNUM_EXPONENTIAL_SYMBOL, 
+        srcExpBuf, 
+        sizeof(srcExpBuf), 
+        &status); 
+ 
+    /* Upper/lower case the e */ 
+    if (info->fSpec == (UChar)0x65 /* e */) { 
+        expLen = u_strToLower(expBuf, (int32_t)sizeof(expBuf), 
+            srcExpBuf, srcLen, 
+            input->str.fBundle.fLocale, 
+            &status); 
+    } 
+    else { 
+        expLen = u_strToUpper(expBuf, (int32_t)sizeof(expBuf), 
+            srcExpBuf, srcLen, 
+            input->str.fBundle.fLocale, 
+            &status); 
+    } 
+ 
+    unum_setSymbol(format, 
+        UNUM_EXPONENTIAL_SYMBOL, 
+        expBuf, 
+        expLen, 
+        &status); 
+ 
+ 
+ 
+ 
+    /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */ 
+    skipped += u_scanf_skip_leading_positive_sign(input, format, &status); 
+ 
+    /* parse the number */ 
+    num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status); 
+ 
+    if (!info->fSkipArg) { 
+        if (info->fIsLong) 
+            *(double*)(args[0].ptrValue) = num; 
+        else if (info->fIsLongDouble) 
+            *(long double*)(args[0].ptrValue) = num; 
+        else 
+            *(float*)(args[0].ptrValue) = (float)num; 
+    } 
+ 
+    /* mask off any necessary bits */ 
+    /*  if(! info->fIsLong_double) 
+    num &= DBL_MAX;*/ 
+ 
+    /* update the input's position to reflect consumed data */ 
+    input->str.fPos += parsePos; 
+ 
+    /* we converted 1 arg */ 
+    *argConverted = !info->fSkipArg; 
+    return parsePos + skipped; 
+} 
+ 
+static int32_t 
+u_scanf_scidbl_handler(UFILE        *input, 
+                       u_scanf_spec_info *info, 
+                       ufmt_args    *args, 
+                       const UChar  *fmt, 
+                       int32_t      *fmtConsumed, 
+                       int32_t      *argConverted) 
+{ 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    int32_t       len; 
+    double        num; 
+    UNumberFormat *scientificFormat, *genericFormat; 
+    /*int32_t       scientificResult, genericResult;*/ 
+    double        scientificResult, genericResult; 
+    int32_t       scientificParsePos = 0, genericParsePos = 0, parsePos = 0; 
+    int32_t       skipped; 
+    UErrorCode    scientificStatus = U_ZERO_ERROR; 
+    UErrorCode    genericStatus = U_ZERO_ERROR; 
+ 
+ 
+    /* since we can't determine by scanning the characters whether */ 
+    /* a number was formatted in the 'f' or 'g' styles, parse the */ 
+    /* string with both formatters, and assume whichever one */ 
+    /* parsed the most is the correct formatter to use */ 
+ 
+ 
+    /* skip all ws in the input */ 
+    skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 
+ 
+    /* fill the input's internal buffer */ 
+    ufile_fill_uchar_buffer(input); 
+ 
+    /* determine the size of the input's buffer */ 
+    len = (int32_t)(input->str.fLimit - input->str.fPos); 
+ 
+    /* truncate to the width, if specified */ 
+    if(info->fWidth != -1) 
+        len = ufmt_min(len, info->fWidth); 
+ 
+    /* get the formatters */ 
+    scientificFormat = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SCIENTIFIC); 
+    genericFormat = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL); 
+ 
+    /* handle error */ 
+    if(scientificFormat == 0 || genericFormat == 0) 
+        return 0; 
+ 
+    /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */ 
+    skipped += u_scanf_skip_leading_positive_sign(input, genericFormat, &genericStatus); 
+ 
+    /* parse the number using each format*/ 
+ 
+    scientificResult = unum_parseDouble(scientificFormat, input->str.fPos, len, 
+        &scientificParsePos, &scientificStatus); 
+ 
+    genericResult = unum_parseDouble(genericFormat, input->str.fPos, len, 
+        &genericParsePos, &genericStatus); 
+ 
+    /* determine which parse made it farther */ 
+    if(scientificParsePos > genericParsePos) { 
+        /* stash the result in num */ 
+        num = scientificResult; 
+        /* update the input's position to reflect consumed data */ 
+        parsePos += scientificParsePos; 
+    } 
+    else { 
+        /* stash the result in num */ 
+        num = genericResult; 
+        /* update the input's position to reflect consumed data */ 
+        parsePos += genericParsePos; 
+    } 
+    input->str.fPos += parsePos; 
+ 
+    if (!info->fSkipArg) { 
+        if (info->fIsLong) 
+            *(double*)(args[0].ptrValue) = num; 
+        else if (info->fIsLongDouble) 
+            *(long double*)(args[0].ptrValue) = num; 
+        else 
+            *(float*)(args[0].ptrValue) = (float)num; 
+    } 
+ 
+    /* mask off any necessary bits */ 
+    /*  if(! info->fIsLong_double) 
+    num &= DBL_MAX;*/ 
+ 
+    /* we converted 1 arg */ 
+    *argConverted = !info->fSkipArg; 
+    return parsePos + skipped; 
+} 
+ 
+static int32_t 
+u_scanf_integer_handler(UFILE       *input, 
+                        u_scanf_spec_info *info, 
+                        ufmt_args   *args, 
+                        const UChar *fmt, 
+                        int32_t     *fmtConsumed, 
+                        int32_t     *argConverted) 
+{ 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    int32_t         len; 
+    void            *num        = (void*) (args[0].ptrValue); 
+    UNumberFormat   *format; 
+    int32_t         parsePos    = 0; 
+    int32_t         skipped; 
+    UErrorCode      status      = U_ZERO_ERROR; 
+    int64_t         result; 
+ 
+ 
+    /* skip all ws in the input */ 
+    skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 
+ 
+    /* fill the input's internal buffer */ 
+    ufile_fill_uchar_buffer(input); 
+ 
+    /* determine the size of the input's buffer */ 
+    len = (int32_t)(input->str.fLimit - input->str.fPos); 
+ 
+    /* truncate to the width, if specified */ 
+    if(info->fWidth != -1) 
+        len = ufmt_min(len, info->fWidth); 
+ 
+    /* get the formatter */ 
+    format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL); 
+ 
+    /* handle error */ 
+    if(format == 0) 
+        return 0; 
+ 
+    /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */ 
+    skipped += u_scanf_skip_leading_positive_sign(input, format, &status); 
+ 
+    /* parse the number */ 
+    result = unum_parseInt64(format, input->str.fPos, len, &parsePos, &status); 
+ 
+    /* mask off any necessary bits */ 
+    if (!info->fSkipArg) { 
+        if (info->fIsShort) 
+            *(int16_t*)num = (int16_t)(UINT16_MAX & result); 
+        else if (info->fIsLongLong) 
+            *(int64_t*)num = result; 
+        else 
+            *(int32_t*)num = (int32_t)(UINT32_MAX & result); 
+    } 
+ 
+    /* update the input's position to reflect consumed data */ 
+    input->str.fPos += parsePos; 
+ 
+    /* we converted 1 arg */ 
+    *argConverted = !info->fSkipArg; 
+    return parsePos + skipped; 
+} 
+ 
+static int32_t 
+u_scanf_uinteger_handler(UFILE          *input, 
+                         u_scanf_spec_info *info, 
+                         ufmt_args      *args, 
+                         const UChar    *fmt, 
+                         int32_t        *fmtConsumed, 
+                         int32_t        *argConverted) 
+{ 
+    /* TODO Fix this when Numberformat handles uint64_t */ 
+    return u_scanf_integer_handler(input, info, args, fmt, fmtConsumed, argConverted); 
+} 
+ 
+static int32_t 
+u_scanf_percent_handler(UFILE       *input, 
+                        u_scanf_spec_info *info, 
+                        ufmt_args   *args, 
+                        const UChar *fmt, 
+                        int32_t     *fmtConsumed, 
+                        int32_t     *argConverted) 
+{ 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    int32_t         len; 
+    double          num; 
+    UNumberFormat   *format; 
+    int32_t         parsePos    = 0; 
+    UErrorCode      status      = U_ZERO_ERROR; 
+ 
+ 
+    /* skip all ws in the input */ 
+    u_scanf_skip_leading_ws(input, info->fPadChar); 
+ 
+    /* fill the input's internal buffer */ 
+    ufile_fill_uchar_buffer(input); 
+ 
+    /* determine the size of the input's buffer */ 
+    len = (int32_t)(input->str.fLimit - input->str.fPos); 
+ 
+    /* truncate to the width, if specified */ 
+    if(info->fWidth != -1) 
+        len = ufmt_min(len, info->fWidth); 
+ 
+    /* get the formatter */ 
+    format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_PERCENT); 
+ 
+    /* handle error */ 
+    if(format == 0) 
+        return 0; 
+ 
+    /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */ 
+    u_scanf_skip_leading_positive_sign(input, format, &status); 
+ 
+    /* parse the number */ 
+    num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status); 
+ 
+    if (!info->fSkipArg) { 
+        *(double*)(args[0].ptrValue) = num; 
+    } 
+ 
+    /* mask off any necessary bits */ 
+    /*  if(! info->fIsLong_double) 
+    num &= DBL_MAX;*/ 
+ 
+    /* update the input's position to reflect consumed data */ 
+    input->str.fPos += parsePos; 
+ 
+    /* we converted 1 arg */ 
+    *argConverted = !info->fSkipArg; 
+    return parsePos; 
+} 
+ 
+static int32_t 
+u_scanf_string_handler(UFILE        *input, 
+                       u_scanf_spec_info *info, 
+                       ufmt_args    *args, 
+                       const UChar  *fmt, 
+                       int32_t      *fmtConsumed, 
+                       int32_t      *argConverted) 
+{ 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    const UChar *source; 
+    UConverter  *conv; 
+    char        *arg    = (char*)(args[0].ptrValue); 
+    char        *alias  = arg; 
+    char        *limit; 
+    UErrorCode  status  = U_ZERO_ERROR; 
+    int32_t     count; 
+    int32_t     skipped = 0; 
+    UChar       c; 
+    UBool       isNotEOF = FALSE; 
+ 
+    /* skip all ws in the input */ 
+    if (info->fIsString) { 
+        skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 
+    } 
+ 
+    /* get the string one character at a time, truncating to the width */ 
+    count = 0; 
+ 
+    /* open the default converter */ 
+    conv = u_getDefaultConverter(&status); 
+ 
+    if(U_FAILURE(status)) 
+        return -1; 
+ 
+    while( (info->fWidth == -1 || count < info->fWidth)  
+        && ((isNotEOF = ufile_getch(input, &c)) == TRUE) 
+        && (!info->fIsString || (c != info->fPadChar && !u_isWhitespace(c)))) 
+    { 
+ 
+        if (!info->fSkipArg) { 
+            /* put the character from the input onto the target */ 
+            source = &c; 
+            /* Since we do this one character at a time, do it this way. */ 
+            if (info->fWidth > 0) { 
+                limit = alias + info->fWidth - count; 
+            } 
+            else { 
+                limit = alias + ucnv_getMaxCharSize(conv); 
+            } 
+ 
+            /* convert the character to the default codepage */ 
+            ucnv_fromUnicode(conv, &alias, limit, &source, source + 1, 
+                NULL, TRUE, &status); 
+ 
+            if(U_FAILURE(status)) { 
+                /* clean up */ 
+                u_releaseDefaultConverter(conv); 
+                return -1; 
+            } 
+        } 
+ 
+        /* increment the count */ 
+        ++count; 
+    } 
+ 
+    /* put the final character we read back on the input */ 
+    if (!info->fSkipArg) { 
+        if ((info->fWidth == -1 || count < info->fWidth) && isNotEOF) 
+            u_fungetc(c, input); 
+ 
+        /* add the terminator */ 
+        if (info->fIsString) { 
+            *alias = 0x00; 
+        } 
+    } 
+ 
+    /* clean up */ 
+    u_releaseDefaultConverter(conv); 
+ 
+    /* we converted 1 arg */ 
+    *argConverted = !info->fSkipArg; 
+    return count + skipped; 
+} 
+ 
+static int32_t 
+u_scanf_char_handler(UFILE          *input, 
+                     u_scanf_spec_info *info, 
+                     ufmt_args      *args, 
+                     const UChar    *fmt, 
+                     int32_t        *fmtConsumed, 
+                     int32_t        *argConverted) 
+{ 
+    if (info->fWidth < 0) { 
+        info->fWidth = 1; 
+    } 
+    info->fIsString = FALSE; 
+    return u_scanf_string_handler(input, info, args, fmt, fmtConsumed, argConverted); 
+} 
+ 
+static int32_t 
+u_scanf_ustring_handler(UFILE       *input, 
+                        u_scanf_spec_info *info, 
+                        ufmt_args   *args, 
+                        const UChar *fmt, 
+                        int32_t     *fmtConsumed, 
+                        int32_t     *argConverted) 
+{ 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    UChar   *arg     = (UChar*)(args[0].ptrValue); 
+    UChar   *alias     = arg; 
+    int32_t count; 
+    int32_t skipped = 0; 
+    UChar   c; 
+    UBool   isNotEOF = FALSE; 
+ 
+    /* skip all ws in the input */ 
+    if (info->fIsString) { 
+        skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 
+    } 
+ 
+    /* get the string one character at a time, truncating to the width */ 
+    count = 0; 
+ 
     while( (info->fWidth == -1 || count < info->fWidth) 
-        && ((isNotEOF = ufile_getch(input, &c)) == TRUE)
-        && (!info->fIsString || (c != info->fPadChar && !u_isWhitespace(c))))
-    {
-
-        if (!info->fSkipArg) {
-            /* put the character from the input onto the target */
-            source = &c;
-            /* Since we do this one character at a time, do it this way. */
-            if (info->fWidth > 0) {
-                limit = alias + info->fWidth - count;
-            }
-            else {
-                limit = alias + ucnv_getMaxCharSize(conv);
-            }
-
-            /* convert the character to the default codepage */
-            ucnv_fromUnicode(conv, &alias, limit, &source, source + 1,
-                NULL, TRUE, &status);
-
-            if(U_FAILURE(status)) {
-                /* clean up */
-                u_releaseDefaultConverter(conv);
-                return -1;
-            }
-        }
-
-        /* increment the count */
-        ++count;
-    }
-
-    /* put the final character we read back on the input */
-    if (!info->fSkipArg) {
-        if ((info->fWidth == -1 || count < info->fWidth) && isNotEOF)
-            u_fungetc(c, input);
-
-        /* add the terminator */
-        if (info->fIsString) {
-            *alias = 0x00;
-        }
-    }
-
-    /* clean up */
-    u_releaseDefaultConverter(conv);
-
-    /* we converted 1 arg */
-    *argConverted = !info->fSkipArg;
-    return count + skipped;
-}
-
-static int32_t
-u_scanf_char_handler(UFILE          *input,
-                     u_scanf_spec_info *info,
-                     ufmt_args      *args,
-                     const UChar    *fmt,
-                     int32_t        *fmtConsumed,
-                     int32_t        *argConverted)
-{
-    if (info->fWidth < 0) {
-        info->fWidth = 1;
-    }
-    info->fIsString = FALSE;
-    return u_scanf_string_handler(input, info, args, fmt, fmtConsumed, argConverted);
-}
-
-static int32_t
-u_scanf_ustring_handler(UFILE       *input,
-                        u_scanf_spec_info *info,
-                        ufmt_args   *args,
-                        const UChar *fmt,
-                        int32_t     *fmtConsumed,
-                        int32_t     *argConverted)
-{
-    (void)fmt;
-    (void)fmtConsumed;
-
-    UChar   *arg     = (UChar*)(args[0].ptrValue);
-    UChar   *alias     = arg;
-    int32_t count;
-    int32_t skipped = 0;
-    UChar   c;
-    UBool   isNotEOF = FALSE;
-
-    /* skip all ws in the input */
-    if (info->fIsString) {
-        skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
-    }
-
-    /* get the string one character at a time, truncating to the width */
-    count = 0;
-
-    while( (info->fWidth == -1 || count < info->fWidth)
-        && ((isNotEOF = ufile_getch(input, &c)) == TRUE)
-        && (!info->fIsString || (c != info->fPadChar && !u_isWhitespace(c))))
-    {
-
-        /* put the character from the input onto the target */
-        if (!info->fSkipArg) {
-            *alias++ = c;
-        }
-
-        /* increment the count */
-        ++count;
-    }
-
-    /* put the final character we read back on the input */
-    if (!info->fSkipArg) {
-        if((info->fWidth == -1 || count < info->fWidth) && isNotEOF) {
-            u_fungetc(c, input);
-        }
-
-        /* add the terminator */
-        if (info->fIsString) {
-            *alias = 0x0000;
-        }
-    }
-
-    /* we converted 1 arg */
-    *argConverted = !info->fSkipArg;
-    return count + skipped;
-}
-
-static int32_t
-u_scanf_uchar_handler(UFILE         *input,
-                      u_scanf_spec_info *info,
-                      ufmt_args     *args,
-                      const UChar   *fmt,
-                      int32_t       *fmtConsumed,
-                      int32_t       *argConverted)
-{
-    if (info->fWidth < 0) {
-        info->fWidth = 1;
-    }
-    info->fIsString = FALSE;
-    return u_scanf_ustring_handler(input, info, args, fmt, fmtConsumed, argConverted);
-}
-
-static int32_t
-u_scanf_spellout_handler(UFILE          *input,
-                         u_scanf_spec_info *info,
-                         ufmt_args      *args,
-                         const UChar    *fmt,
-                         int32_t        *fmtConsumed,
-                         int32_t        *argConverted)
-{
-    (void)fmt;
-    (void)fmtConsumed;
-
-    int32_t         len;
-    double          num;
-    UNumberFormat   *format;
-    int32_t         parsePos    = 0;
-    int32_t         skipped;
-    UErrorCode      status      = U_ZERO_ERROR;
-
-
-    /* skip all ws in the input */
-    skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
-
-    /* fill the input's internal buffer */
-    ufile_fill_uchar_buffer(input);
-
-    /* determine the size of the input's buffer */
-    len = (int32_t)(input->str.fLimit - input->str.fPos);
-
-    /* truncate to the width, if specified */
-    if(info->fWidth != -1)
-        len = ufmt_min(len, info->fWidth);
-
-    /* get the formatter */
-    format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SPELLOUT);
-
-    /* handle error */
-    if(format == 0)
-        return 0;
-
-    /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
-    /* This is not applicable to RBNF. */
-    /*skipped += u_scanf_skip_leading_positive_sign(input, format, &status);*/
-
-    /* parse the number */
-    num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status);
-
-    if (!info->fSkipArg) {
-        *(double*)(args[0].ptrValue) = num;
-    }
-
-    /* mask off any necessary bits */
-    /*  if(! info->fIsLong_double)
-    num &= DBL_MAX;*/
-
-    /* update the input's position to reflect consumed data */
-    input->str.fPos += parsePos;
-
-    /* we converted 1 arg */
-    *argConverted = !info->fSkipArg;
-    return parsePos + skipped;
-}
-
-static int32_t
-u_scanf_hex_handler(UFILE       *input,
-                    u_scanf_spec_info *info,
-                    ufmt_args   *args,
-                    const UChar *fmt,
-                    int32_t     *fmtConsumed,
-                    int32_t     *argConverted)
-{
-    (void)fmt;
-    (void)fmtConsumed;
-
-    int32_t     len;
-    int32_t     skipped;
-    void        *num    = (void*) (args[0].ptrValue);
-    int64_t     result;
-
-    /* skip all ws in the input */
-    skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
-
-    /* fill the input's internal buffer */
-    ufile_fill_uchar_buffer(input);
-
-    /* determine the size of the input's buffer */
-    len = (int32_t)(input->str.fLimit - input->str.fPos);
-
-    /* truncate to the width, if specified */
-    if(info->fWidth != -1)
-        len = ufmt_min(len, info->fWidth);
-
-    /* check for alternate form */
-    if( *(input->str.fPos) == 0x0030 &&
-        (*(input->str.fPos + 1) == 0x0078 || *(input->str.fPos + 1) == 0x0058) ) {
-
-        /* skip the '0' and 'x' or 'X' if present */
-        input->str.fPos += 2;
-        len -= 2;
-    }
-
-    /* parse the number */
-    result = ufmt_uto64(input->str.fPos, &len, 16);
-
-    /* update the input's position to reflect consumed data */
-    input->str.fPos += len;
-
-    /* mask off any necessary bits */
-    if (!info->fSkipArg) {
-        if (info->fIsShort)
-            *(int16_t*)num = (int16_t)(UINT16_MAX & result);
-        else if (info->fIsLongLong)
-            *(int64_t*)num = result;
-        else
-            *(int32_t*)num = (int32_t)(UINT32_MAX & result);
-    }
-
-    /* we converted 1 arg */
-    *argConverted = !info->fSkipArg;
-    return len + skipped;
-}
-
-static int32_t
-u_scanf_octal_handler(UFILE         *input,
-                      u_scanf_spec_info *info,
-                      ufmt_args     *args,
-                      const UChar   *fmt,
-                      int32_t       *fmtConsumed,
-                      int32_t       *argConverted)
-{
-    (void)fmt;
-    (void)fmtConsumed;
-
-    int32_t     len;
-    int32_t     skipped;
-    void        *num         = (void*) (args[0].ptrValue);
-    int64_t     result;
-
-    /* skip all ws in the input */
-    skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
-
-    /* fill the input's internal buffer */
-    ufile_fill_uchar_buffer(input);
-
-    /* determine the size of the input's buffer */
-    len = (int32_t)(input->str.fLimit - input->str.fPos);
-
-    /* truncate to the width, if specified */
-    if(info->fWidth != -1)
-        len = ufmt_min(len, info->fWidth);
-
-    /* parse the number */
-    result = ufmt_uto64(input->str.fPos, &len, 8);
-
-    /* update the input's position to reflect consumed data */
-    input->str.fPos += len;
-
-    /* mask off any necessary bits */
-    if (!info->fSkipArg) {
-        if (info->fIsShort)
-            *(int16_t*)num = (int16_t)(UINT16_MAX & result);
-        else if (info->fIsLongLong)
-            *(int64_t*)num = result;
-        else
-            *(int32_t*)num = (int32_t)(UINT32_MAX & result);
-    }
-
-    /* we converted 1 arg */
-    *argConverted = !info->fSkipArg;
-    return len + skipped;
-}
-
-static int32_t
-u_scanf_pointer_handler(UFILE       *input,
-                        u_scanf_spec_info *info,
-                        ufmt_args   *args,
-                        const UChar *fmt,
-                        int32_t     *fmtConsumed,
-                        int32_t     *argConverted)
-{
-    (void)fmt;
-    (void)fmtConsumed;
-
-    int32_t len;
-    int32_t skipped;
-    void    *result;
-    void    **p     = (void**)(args[0].ptrValue);
-
-
-    /* skip all ws in the input */
-    skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
-
-    /* fill the input's internal buffer */
-    ufile_fill_uchar_buffer(input);
-
-    /* determine the size of the input's buffer */
-    len = (int32_t)(input->str.fLimit - input->str.fPos);
-
-    /* truncate to the width, if specified */
-    if(info->fWidth != -1) {
-        len = ufmt_min(len, info->fWidth);
-    }
-
-    /* Make sure that we don't consume too much */
-    if (len > (int32_t)(sizeof(void*)*2)) {
-        len = (int32_t)(sizeof(void*)*2);
-    }
-
-    /* parse the pointer - assign to temporary value */
-    result = ufmt_utop(input->str.fPos, &len);
-
-    if (!info->fSkipArg) {
-        *p = result;
-    }
-
-    /* update the input's position to reflect consumed data */
-    input->str.fPos += len;
-
-    /* we converted 1 arg */
-    *argConverted = !info->fSkipArg;
-    return len + skipped;
-}
-
-static int32_t
-u_scanf_scanset_handler(UFILE       *input,
-                        u_scanf_spec_info *info,
-                        ufmt_args   *args,
-                        const UChar *fmt,
-                        int32_t     *fmtConsumed,
-                        int32_t     *argConverted)
-{
-    USet        *scanset;
-    UErrorCode  status = U_ZERO_ERROR;
-    int32_t     chLeft = INT32_MAX;
-    UChar32     c;
-    UChar       *alias = (UChar*) (args[0].ptrValue);
-    UBool       isNotEOF = FALSE;
-    UBool       readCharacter = FALSE;
-
-    /* Create an empty set */
-    scanset = uset_open(0, -1);
-
-    /* Back up one to get the [ */
-    fmt--;
-
-    /* truncate to the width, if specified and alias the target */
-    if(info->fWidth >= 0) {
-        chLeft = info->fWidth;
-    }
-
-    /* parse the scanset from the fmt string */
-    *fmtConsumed = uset_applyPattern(scanset, fmt, -1, 0, &status);
-
-    /* verify that the parse was successful */
-    if (U_SUCCESS(status)) {
-        c=0;
-
-        /* grab characters one at a time and make sure they are in the scanset */
-        while(chLeft > 0) {
-            if ( ((isNotEOF = ufile_getch32(input, &c)) == TRUE) && uset_contains(scanset, c) ) {
-                readCharacter = TRUE;
-                if (!info->fSkipArg) {
-                    int32_t idx = 0;
-                    UBool isError = FALSE;
-
-                    U16_APPEND(alias, idx, chLeft, c, isError);
-                    if (isError) {
-                        break;
-                    }
-                    alias += idx;
-                }
-                chLeft -= (1 + U_IS_SUPPLEMENTARY(c));
-            }
-            else {
-                /* if the character's not in the scanset, break out */
-                break;
-            }
-        }
-
-        /* put the final character we read back on the input */
-        if(isNotEOF && chLeft > 0) {
-            u_fungetc(c, input);
-        }
-    }
-
-    uset_close(scanset);
-
-    /* if we didn't match at least 1 character, fail */
-    if(!readCharacter)
-        return -1;
-    /* otherwise, add the terminator */
-    else if (!info->fSkipArg) {
-        *alias = 0x00;
-    }
-
-    /* we converted 1 arg */
-    *argConverted = !info->fSkipArg;
-    return (info->fWidth >= 0 ? info->fWidth : INT32_MAX) - chLeft;
-}
-
-/* Use US-ASCII characters only for formatting. Most codepages have
- characters 20-7F from Unicode. Using any other codepage specific
- characters will make it very difficult to format the string on
- non-Unicode machines */
-static const u_scanf_info g_u_scanf_infos[USCANF_NUM_FMT_HANDLERS] = {
-/* 0x20 */
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_SIMPLE_PERCENT,UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-
-/* 0x30 */
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-
-/* 0x40 */
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_UCHAR,
-    UFMT_EMPTY,         UFMT_SCIENTIFIC,    UFMT_EMPTY,         UFMT_SCIDBL,
-#ifdef U_USE_OBSOLETE_IO_FORMATTING
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_UCHAR/*deprecated*/,
-#else
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-#endif
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-
-/* 0x50 */
-    UFMT_PERCENT,       UFMT_EMPTY,         UFMT_EMPTY,         UFMT_USTRING,
-#ifdef U_USE_OBSOLETE_IO_FORMATTING
-    UFMT_EMPTY,         UFMT_USTRING/*deprecated*/,UFMT_SPELLOUT,      UFMT_EMPTY,
-#else
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_SPELLOUT,      UFMT_EMPTY,
-#endif
-    UFMT_HEX,           UFMT_EMPTY,         UFMT_EMPTY,         UFMT_SCANSET,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-
-/* 0x60 */
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_CHAR,
-    UFMT_INT,           UFMT_SCIENTIFIC,    UFMT_DOUBLE,        UFMT_SCIDBL,
-    UFMT_EMPTY,         UFMT_INT,           UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_COUNT,         UFMT_OCTAL,
-
-/* 0x70 */
-    UFMT_POINTER,       UFMT_EMPTY,         UFMT_EMPTY,         UFMT_STRING,
-    UFMT_EMPTY,         UFMT_UINT,          UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_HEX,           UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,
-};
-
-U_CFUNC int32_t
-u_scanf_parse(UFILE     *f,
-            const UChar *patternSpecification,
-            va_list     ap)
-{
-    const UChar     *alias;
-    int32_t         count, converted, argConsumed, cpConsumed;
-    uint16_t        handlerNum;
-
-    ufmt_args       args;
-    u_scanf_spec    spec;
-    ufmt_type_info  info;
-    u_scanf_handler handler;
-
-    /* alias the pattern */
-    alias = patternSpecification;
-
-    /* haven't converted anything yet */
-    argConsumed = 0;
-    converted = 0;
-    cpConsumed = 0;
-
-    /* iterate through the pattern */
-    for(;;) {
-
-        /* match any characters up to the next '%' */
-        while(*alias != UP_PERCENT && *alias != 0x0000 && u_fgetc(f) == *alias) {
-            alias++;
-        }
-
-        /* if we aren't at a '%', or if we're at end of string, break*/
-        if(*alias != UP_PERCENT || *alias == 0x0000)
-            break;
-
-        /* parse the specifier */
-        count = u_scanf_parse_spec(alias, &spec);
-
-        /* update the pointer in pattern */
-        alias += count;
-
-        handlerNum = (uint16_t)(spec.fInfo.fSpec - USCANF_BASE_FMT_HANDLERS);
-        if (handlerNum < USCANF_NUM_FMT_HANDLERS) {
-            /* skip the argument, if necessary */
-            /* query the info function for argument information */
-            info = g_u_scanf_infos[ handlerNum ].info;
-            if (info != ufmt_count && u_feof(f)) {
-                break;
-            }
-            else if(spec.fInfo.fSkipArg) {
-                args.ptrValue = NULL;
-            }
-            else {
-                switch(info) {
-                case ufmt_count:
-                    /* set the spec's width to the # of items converted */
-                    spec.fInfo.fWidth = cpConsumed;
-                    U_FALLTHROUGH;
-                case ufmt_char:
-                case ufmt_uchar:
-                case ufmt_int:
-                case ufmt_string:
-                case ufmt_ustring:
-                case ufmt_pointer:
-                case ufmt_float:
-                case ufmt_double:
-                    args.ptrValue = va_arg(ap, void*);
-                    break;
-
-                default:
-                    /* else args is ignored */
-                    args.ptrValue = NULL;
-                    break;
-                }
-            }
-
-            /* call the handler function */
-            handler = g_u_scanf_infos[ handlerNum ].handler;
-            if(handler != 0) {
-
-                /* reset count to 1 so that += for alias works. */
-                count = 1;
-
-                cpConsumed += (*handler)(f, &spec.fInfo, &args, alias, &count, &argConsumed);
-
-                /* if the handler encountered an error condition, break */
-                if(argConsumed < 0) {
-                    converted = -1;
-                    break;
-                }
-
-                /* add to the # of items converted */
-                converted += argConsumed;
-
-                /* update the pointer in pattern */
-                alias += count-1;
-            }
-            /* else do nothing */
-        }
-        /* else do nothing */
-
-        /* just ignore unknown tags */
-    }
-
-    /* return # of items converted */
-    return converted;
-}
-
-#endif /* #if !UCONFIG_NO_FORMATTING */
+        && ((isNotEOF = ufile_getch(input, &c)) == TRUE) 
+        && (!info->fIsString || (c != info->fPadChar && !u_isWhitespace(c)))) 
+    { 
+ 
+        /* put the character from the input onto the target */ 
+        if (!info->fSkipArg) { 
+            *alias++ = c; 
+        } 
+ 
+        /* increment the count */ 
+        ++count; 
+    } 
+ 
+    /* put the final character we read back on the input */ 
+    if (!info->fSkipArg) { 
+        if((info->fWidth == -1 || count < info->fWidth) && isNotEOF) { 
+            u_fungetc(c, input); 
+        } 
+ 
+        /* add the terminator */ 
+        if (info->fIsString) { 
+            *alias = 0x0000; 
+        } 
+    } 
+ 
+    /* we converted 1 arg */ 
+    *argConverted = !info->fSkipArg; 
+    return count + skipped; 
+} 
+ 
+static int32_t 
+u_scanf_uchar_handler(UFILE         *input, 
+                      u_scanf_spec_info *info, 
+                      ufmt_args     *args, 
+                      const UChar   *fmt, 
+                      int32_t       *fmtConsumed, 
+                      int32_t       *argConverted) 
+{ 
+    if (info->fWidth < 0) { 
+        info->fWidth = 1; 
+    } 
+    info->fIsString = FALSE; 
+    return u_scanf_ustring_handler(input, info, args, fmt, fmtConsumed, argConverted); 
+} 
+ 
+static int32_t 
+u_scanf_spellout_handler(UFILE          *input, 
+                         u_scanf_spec_info *info, 
+                         ufmt_args      *args, 
+                         const UChar    *fmt, 
+                         int32_t        *fmtConsumed, 
+                         int32_t        *argConverted) 
+{ 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    int32_t         len; 
+    double          num; 
+    UNumberFormat   *format; 
+    int32_t         parsePos    = 0; 
+    int32_t         skipped; 
+    UErrorCode      status      = U_ZERO_ERROR; 
+ 
+ 
+    /* skip all ws in the input */ 
+    skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 
+ 
+    /* fill the input's internal buffer */ 
+    ufile_fill_uchar_buffer(input); 
+ 
+    /* determine the size of the input's buffer */ 
+    len = (int32_t)(input->str.fLimit - input->str.fPos); 
+ 
+    /* truncate to the width, if specified */ 
+    if(info->fWidth != -1) 
+        len = ufmt_min(len, info->fWidth); 
+ 
+    /* get the formatter */ 
+    format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SPELLOUT); 
+ 
+    /* handle error */ 
+    if(format == 0) 
+        return 0; 
+ 
+    /* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */ 
+    /* This is not applicable to RBNF. */ 
+    /*skipped += u_scanf_skip_leading_positive_sign(input, format, &status);*/ 
+ 
+    /* parse the number */ 
+    num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status); 
+ 
+    if (!info->fSkipArg) { 
+        *(double*)(args[0].ptrValue) = num; 
+    } 
+ 
+    /* mask off any necessary bits */ 
+    /*  if(! info->fIsLong_double) 
+    num &= DBL_MAX;*/ 
+ 
+    /* update the input's position to reflect consumed data */ 
+    input->str.fPos += parsePos; 
+ 
+    /* we converted 1 arg */ 
+    *argConverted = !info->fSkipArg; 
+    return parsePos + skipped; 
+} 
+ 
+static int32_t 
+u_scanf_hex_handler(UFILE       *input, 
+                    u_scanf_spec_info *info, 
+                    ufmt_args   *args, 
+                    const UChar *fmt, 
+                    int32_t     *fmtConsumed, 
+                    int32_t     *argConverted) 
+{ 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    int32_t     len; 
+    int32_t     skipped; 
+    void        *num    = (void*) (args[0].ptrValue); 
+    int64_t     result; 
+ 
+    /* skip all ws in the input */ 
+    skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 
+ 
+    /* fill the input's internal buffer */ 
+    ufile_fill_uchar_buffer(input); 
+ 
+    /* determine the size of the input's buffer */ 
+    len = (int32_t)(input->str.fLimit - input->str.fPos); 
+ 
+    /* truncate to the width, if specified */ 
+    if(info->fWidth != -1) 
+        len = ufmt_min(len, info->fWidth); 
+ 
+    /* check for alternate form */ 
+    if( *(input->str.fPos) == 0x0030 && 
+        (*(input->str.fPos + 1) == 0x0078 || *(input->str.fPos + 1) == 0x0058) ) { 
+ 
+        /* skip the '0' and 'x' or 'X' if present */ 
+        input->str.fPos += 2; 
+        len -= 2; 
+    } 
+ 
+    /* parse the number */ 
+    result = ufmt_uto64(input->str.fPos, &len, 16); 
+ 
+    /* update the input's position to reflect consumed data */ 
+    input->str.fPos += len; 
+ 
+    /* mask off any necessary bits */ 
+    if (!info->fSkipArg) { 
+        if (info->fIsShort) 
+            *(int16_t*)num = (int16_t)(UINT16_MAX & result); 
+        else if (info->fIsLongLong) 
+            *(int64_t*)num = result; 
+        else 
+            *(int32_t*)num = (int32_t)(UINT32_MAX & result); 
+    } 
+ 
+    /* we converted 1 arg */ 
+    *argConverted = !info->fSkipArg; 
+    return len + skipped; 
+} 
+ 
+static int32_t 
+u_scanf_octal_handler(UFILE         *input, 
+                      u_scanf_spec_info *info, 
+                      ufmt_args     *args, 
+                      const UChar   *fmt, 
+                      int32_t       *fmtConsumed, 
+                      int32_t       *argConverted) 
+{ 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    int32_t     len; 
+    int32_t     skipped; 
+    void        *num         = (void*) (args[0].ptrValue); 
+    int64_t     result; 
+ 
+    /* skip all ws in the input */ 
+    skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 
+ 
+    /* fill the input's internal buffer */ 
+    ufile_fill_uchar_buffer(input); 
+ 
+    /* determine the size of the input's buffer */ 
+    len = (int32_t)(input->str.fLimit - input->str.fPos); 
+ 
+    /* truncate to the width, if specified */ 
+    if(info->fWidth != -1) 
+        len = ufmt_min(len, info->fWidth); 
+ 
+    /* parse the number */ 
+    result = ufmt_uto64(input->str.fPos, &len, 8); 
+ 
+    /* update the input's position to reflect consumed data */ 
+    input->str.fPos += len; 
+ 
+    /* mask off any necessary bits */ 
+    if (!info->fSkipArg) { 
+        if (info->fIsShort) 
+            *(int16_t*)num = (int16_t)(UINT16_MAX & result); 
+        else if (info->fIsLongLong) 
+            *(int64_t*)num = result; 
+        else 
+            *(int32_t*)num = (int32_t)(UINT32_MAX & result); 
+    } 
+ 
+    /* we converted 1 arg */ 
+    *argConverted = !info->fSkipArg; 
+    return len + skipped; 
+} 
+ 
+static int32_t 
+u_scanf_pointer_handler(UFILE       *input, 
+                        u_scanf_spec_info *info, 
+                        ufmt_args   *args, 
+                        const UChar *fmt, 
+                        int32_t     *fmtConsumed, 
+                        int32_t     *argConverted) 
+{ 
+    (void)fmt; 
+    (void)fmtConsumed; 
+ 
+    int32_t len; 
+    int32_t skipped; 
+    void    *result; 
+    void    **p     = (void**)(args[0].ptrValue); 
+ 
+ 
+    /* skip all ws in the input */ 
+    skipped = u_scanf_skip_leading_ws(input, info->fPadChar); 
+ 
+    /* fill the input's internal buffer */ 
+    ufile_fill_uchar_buffer(input); 
+ 
+    /* determine the size of the input's buffer */ 
+    len = (int32_t)(input->str.fLimit - input->str.fPos); 
+ 
+    /* truncate to the width, if specified */ 
+    if(info->fWidth != -1) { 
+        len = ufmt_min(len, info->fWidth); 
+    } 
+ 
+    /* Make sure that we don't consume too much */ 
+    if (len > (int32_t)(sizeof(void*)*2)) { 
+        len = (int32_t)(sizeof(void*)*2); 
+    } 
+ 
+    /* parse the pointer - assign to temporary value */ 
+    result = ufmt_utop(input->str.fPos, &len); 
+ 
+    if (!info->fSkipArg) { 
+        *p = result; 
+    } 
+ 
+    /* update the input's position to reflect consumed data */ 
+    input->str.fPos += len; 
+ 
+    /* we converted 1 arg */ 
+    *argConverted = !info->fSkipArg; 
+    return len + skipped; 
+} 
+ 
+static int32_t 
+u_scanf_scanset_handler(UFILE       *input, 
+                        u_scanf_spec_info *info, 
+                        ufmt_args   *args, 
+                        const UChar *fmt, 
+                        int32_t     *fmtConsumed, 
+                        int32_t     *argConverted) 
+{ 
+    USet        *scanset; 
+    UErrorCode  status = U_ZERO_ERROR; 
+    int32_t     chLeft = INT32_MAX; 
+    UChar32     c; 
+    UChar       *alias = (UChar*) (args[0].ptrValue); 
+    UBool       isNotEOF = FALSE; 
+    UBool       readCharacter = FALSE; 
+ 
+    /* Create an empty set */ 
+    scanset = uset_open(0, -1); 
+ 
+    /* Back up one to get the [ */ 
+    fmt--; 
+ 
+    /* truncate to the width, if specified and alias the target */ 
+    if(info->fWidth >= 0) { 
+        chLeft = info->fWidth; 
+    } 
+ 
+    /* parse the scanset from the fmt string */ 
+    *fmtConsumed = uset_applyPattern(scanset, fmt, -1, 0, &status); 
+ 
+    /* verify that the parse was successful */ 
+    if (U_SUCCESS(status)) { 
+        c=0; 
+ 
+        /* grab characters one at a time and make sure they are in the scanset */ 
+        while(chLeft > 0) { 
+            if ( ((isNotEOF = ufile_getch32(input, &c)) == TRUE) && uset_contains(scanset, c) ) { 
+                readCharacter = TRUE; 
+                if (!info->fSkipArg) { 
+                    int32_t idx = 0; 
+                    UBool isError = FALSE; 
+ 
+                    U16_APPEND(alias, idx, chLeft, c, isError); 
+                    if (isError) { 
+                        break; 
+                    } 
+                    alias += idx; 
+                } 
+                chLeft -= (1 + U_IS_SUPPLEMENTARY(c)); 
+            } 
+            else { 
+                /* if the character's not in the scanset, break out */ 
+                break; 
+            } 
+        } 
+ 
+        /* put the final character we read back on the input */ 
+        if(isNotEOF && chLeft > 0) { 
+            u_fungetc(c, input); 
+        } 
+    } 
+ 
+    uset_close(scanset); 
+ 
+    /* if we didn't match at least 1 character, fail */ 
+    if(!readCharacter) 
+        return -1; 
+    /* otherwise, add the terminator */ 
+    else if (!info->fSkipArg) { 
+        *alias = 0x00; 
+    } 
+ 
+    /* we converted 1 arg */ 
+    *argConverted = !info->fSkipArg; 
+    return (info->fWidth >= 0 ? info->fWidth : INT32_MAX) - chLeft; 
+} 
+ 
+/* Use US-ASCII characters only for formatting. Most codepages have 
+ characters 20-7F from Unicode. Using any other codepage specific 
+ characters will make it very difficult to format the string on 
+ non-Unicode machines */ 
+static const u_scanf_info g_u_scanf_infos[USCANF_NUM_FMT_HANDLERS] = { 
+/* 0x20 */ 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_SIMPLE_PERCENT,UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+ 
+/* 0x30 */ 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+ 
+/* 0x40 */ 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_UCHAR, 
+    UFMT_EMPTY,         UFMT_SCIENTIFIC,    UFMT_EMPTY,         UFMT_SCIDBL, 
+#ifdef U_USE_OBSOLETE_IO_FORMATTING 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_UCHAR/*deprecated*/, 
+#else 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+#endif 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+ 
+/* 0x50 */ 
+    UFMT_PERCENT,       UFMT_EMPTY,         UFMT_EMPTY,         UFMT_USTRING, 
+#ifdef U_USE_OBSOLETE_IO_FORMATTING 
+    UFMT_EMPTY,         UFMT_USTRING/*deprecated*/,UFMT_SPELLOUT,      UFMT_EMPTY, 
+#else 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_SPELLOUT,      UFMT_EMPTY, 
+#endif 
+    UFMT_HEX,           UFMT_EMPTY,         UFMT_EMPTY,         UFMT_SCANSET, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+ 
+/* 0x60 */ 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_CHAR, 
+    UFMT_INT,           UFMT_SCIENTIFIC,    UFMT_DOUBLE,        UFMT_SCIDBL, 
+    UFMT_EMPTY,         UFMT_INT,           UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_COUNT,         UFMT_OCTAL, 
+ 
+/* 0x70 */ 
+    UFMT_POINTER,       UFMT_EMPTY,         UFMT_EMPTY,         UFMT_STRING, 
+    UFMT_EMPTY,         UFMT_UINT,          UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_HEX,           UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+    UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY,         UFMT_EMPTY, 
+}; 
+ 
+U_CFUNC int32_t 
+u_scanf_parse(UFILE     *f, 
+            const UChar *patternSpecification, 
+            va_list     ap) 
+{ 
+    const UChar     *alias; 
+    int32_t         count, converted, argConsumed, cpConsumed; 
+    uint16_t        handlerNum; 
+ 
+    ufmt_args       args; 
+    u_scanf_spec    spec; 
+    ufmt_type_info  info; 
+    u_scanf_handler handler; 
+ 
+    /* alias the pattern */ 
+    alias = patternSpecification; 
+ 
+    /* haven't converted anything yet */ 
+    argConsumed = 0; 
+    converted = 0; 
+    cpConsumed = 0; 
+ 
+    /* iterate through the pattern */ 
+    for(;;) { 
+ 
+        /* match any characters up to the next '%' */ 
+        while(*alias != UP_PERCENT && *alias != 0x0000 && u_fgetc(f) == *alias) { 
+            alias++; 
+        } 
+ 
+        /* if we aren't at a '%', or if we're at end of string, break*/ 
+        if(*alias != UP_PERCENT || *alias == 0x0000) 
+            break; 
+ 
+        /* parse the specifier */ 
+        count = u_scanf_parse_spec(alias, &spec); 
+ 
+        /* update the pointer in pattern */ 
+        alias += count; 
+ 
+        handlerNum = (uint16_t)(spec.fInfo.fSpec - USCANF_BASE_FMT_HANDLERS); 
+        if (handlerNum < USCANF_NUM_FMT_HANDLERS) { 
+            /* skip the argument, if necessary */ 
+            /* query the info function for argument information */ 
+            info = g_u_scanf_infos[ handlerNum ].info; 
+            if (info != ufmt_count && u_feof(f)) { 
+                break; 
+            } 
+            else if(spec.fInfo.fSkipArg) { 
+                args.ptrValue = NULL; 
+            } 
+            else { 
+                switch(info) { 
+                case ufmt_count: 
+                    /* set the spec's width to the # of items converted */ 
+                    spec.fInfo.fWidth = cpConsumed; 
+                    U_FALLTHROUGH; 
+                case ufmt_char: 
+                case ufmt_uchar: 
+                case ufmt_int: 
+                case ufmt_string: 
+                case ufmt_ustring: 
+                case ufmt_pointer: 
+                case ufmt_float: 
+                case ufmt_double: 
+                    args.ptrValue = va_arg(ap, void*); 
+                    break; 
+ 
+                default: 
+                    /* else args is ignored */ 
+                    args.ptrValue = NULL; 
+                    break; 
+                } 
+            } 
+ 
+            /* call the handler function */ 
+            handler = g_u_scanf_infos[ handlerNum ].handler; 
+            if(handler != 0) { 
+ 
+                /* reset count to 1 so that += for alias works. */ 
+                count = 1; 
+ 
+                cpConsumed += (*handler)(f, &spec.fInfo, &args, alias, &count, &argConsumed); 
+ 
+                /* if the handler encountered an error condition, break */ 
+                if(argConsumed < 0) { 
+                    converted = -1; 
+                    break; 
+                } 
+ 
+                /* add to the # of items converted */ 
+                converted += argConsumed; 
+ 
+                /* update the pointer in pattern */ 
+                alias += count-1; 
+            } 
+            /* else do nothing */ 
+        } 
+        /* else do nothing */ 
+ 
+        /* just ignore unknown tags */ 
+    } 
+ 
+    /* return # of items converted */ 
+    return converted; 
+} 
+ 
+#endif /* #if !UCONFIG_NO_FORMATTING */ 
diff --git a/contrib/libs/icu/io/ustdio.cpp b/contrib/libs/icu/io/ustdio.cpp
index d6eb5cf9ec..91f0cd2cf2 100644
--- a/contrib/libs/icu/io/ustdio.cpp
+++ b/contrib/libs/icu/io/ustdio.cpp
@@ -1,732 +1,732 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- ******************************************************************************
- *
- *   Copyright (C) 1998-2016, International Business Machines
- *   Corporation and others.  All Rights Reserved.
- *
- ******************************************************************************
- *
- * File ustdio.c
- *
- * Modification History:
- *
- *   Date        Name        Description
- *   11/18/98    stephen     Creation.
- *   03/12/99    stephen     Modified for new C API.
- *   07/19/99    stephen     Fixed read() and gets()
- ******************************************************************************
- */
-
-#include "unicode/ustdio.h"
-
-#if !UCONFIG_NO_CONVERSION
-
-#include "unicode/putil.h"
-#include "cmemory.h"
-#include "cstring.h"
-#include "ufile.h"
-#include "ufmt_cmn.h"
-#include "unicode/ucnv.h"
-#include "unicode/ustring.h"
-
-#include <string.h>
-
-#define DELIM_LF 0x000A
-#define DELIM_VT 0x000B
-#define DELIM_FF 0x000C
-#define DELIM_CR 0x000D
-#define DELIM_NEL 0x0085
-#define DELIM_LS 0x2028
-#define DELIM_PS 0x2029
-
-/* TODO: is this correct for all codepages? Should we just use \n and let the converter handle it? */
-#if U_PLATFORM_USES_ONLY_WIN32_API
-static const UChar DELIMITERS [] = { DELIM_CR, DELIM_LF, 0x0000 };
-static const uint32_t DELIMITERS_LEN = 2;
-/* TODO: Default newline writing should be detected based upon the converter being used. */
-#else
-static const UChar DELIMITERS [] = { DELIM_LF, 0x0000 };
-static const uint32_t DELIMITERS_LEN = 1;
-#endif
-
-#define IS_FIRST_STRING_DELIMITER(c1) \
- (UBool)((DELIM_LF <= (c1) && (c1) <= DELIM_CR) \
-        || (c1) == DELIM_NEL \
-        || (c1) == DELIM_LS \
-        || (c1) == DELIM_PS)
-#define CAN_HAVE_COMBINED_STRING_DELIMITER(c1) (UBool)((c1) == DELIM_CR)
-#define IS_COMBINED_STRING_DELIMITER(c1, c2) \
- (UBool)((c1) == DELIM_CR && (c2) == DELIM_LF)
-
-
-#if !UCONFIG_NO_TRANSLITERATION
-
-U_CAPI UTransliterator* U_EXPORT2
-u_fsettransliterator(UFILE *file, UFileDirection direction,
-                     UTransliterator *adopt, UErrorCode *status)
-{
-    UTransliterator *old = NULL;
-
-    if(U_FAILURE(*status))
-    {
-        return adopt;
-    }
-
-    if(!file)
-    {
-        *status = U_ILLEGAL_ARGUMENT_ERROR;
-        return adopt;
-    }
-
-    if(direction & U_READ)
-    {
-        /** TODO: implement */
-        *status = U_UNSUPPORTED_ERROR;
-        return adopt;
-    }
-
-    if(adopt == NULL) /* they are clearing it */
-    {
-        if(file->fTranslit != NULL)
-        {
-            /* TODO: Check side */
-            old = file->fTranslit->translit;
-            uprv_free(file->fTranslit->buffer);
-            file->fTranslit->buffer=NULL;
-            uprv_free(file->fTranslit);
-            file->fTranslit=NULL;
-        }
-    }
-    else
-    {
-        if(file->fTranslit == NULL)
-        {
-            file->fTranslit = (UFILETranslitBuffer*) uprv_malloc(sizeof(UFILETranslitBuffer));
-            if(!file->fTranslit)
-            {
-                *status = U_MEMORY_ALLOCATION_ERROR;
-                return adopt;
-            }
-            file->fTranslit->capacity = 0;
-            file->fTranslit->length = 0;
-            file->fTranslit->pos = 0;
-            file->fTranslit->buffer = NULL;
-        }
-        else
-        {
-            old = file->fTranslit->translit;
-            ufile_flush_translit(file);
-        }
-
-        file->fTranslit->translit = adopt;
-    }
-
-    return old;
-}
-
-static const UChar * u_file_translit(UFILE *f, const UChar *src, int32_t *count, UBool flush)
-{
-    int32_t newlen;
-    int32_t junkCount = 0;
-    int32_t textLength;
-    int32_t textLimit;
-    UTransPosition pos;
-    UErrorCode status = U_ZERO_ERROR;
-
-    if(count == NULL)
-    {
-        count = &junkCount;
-    }
-
-    if ((!f)||(!f->fTranslit)||(!f->fTranslit->translit))
-    {
-        /* fast path */
-        return src;
-    }
-
-    /* First: slide over everything */
-    if(f->fTranslit->length > f->fTranslit->pos)
-    {
-        memmove(f->fTranslit->buffer, f->fTranslit->buffer + f->fTranslit->pos,
-            (f->fTranslit->length - f->fTranslit->pos)*sizeof(UChar));
-    }
-    f->fTranslit->length -= f->fTranslit->pos; /* always */
-    f->fTranslit->pos = 0;
-
-    /* Calculate new buffer size needed */
-    newlen = (*count + f->fTranslit->length) * 4;
-
-    if(newlen > f->fTranslit->capacity)
-    {
-        if(f->fTranslit->buffer == NULL)
-        {
-            f->fTranslit->buffer = (UChar*)uprv_malloc(newlen * sizeof(UChar));
-        }
-        else
-        {
-            f->fTranslit->buffer = (UChar*)uprv_realloc(f->fTranslit->buffer, newlen * sizeof(UChar));
-        }
-        /* Check for malloc/realloc failure. */
-        if (f->fTranslit->buffer == NULL) {
-        	return NULL;
-        }
-        f->fTranslit->capacity = newlen;
-    }
-
-    /* Now, copy any data over */
-    u_strncpy(f->fTranslit->buffer + f->fTranslit->length,
-        src,
-        *count);
-    f->fTranslit->length += *count;
-
-    /* Now, translit in place as much as we can  */
-    if(flush == FALSE)
-    {
-        textLength = f->fTranslit->length;
-        pos.contextStart = 0;
-        pos.contextLimit = textLength;
-        pos.start        = 0;
-        pos.limit        = textLength;
-
-        utrans_transIncrementalUChars(f->fTranslit->translit,
-            f->fTranslit->buffer, /* because we shifted */
-            &textLength,
-            f->fTranslit->capacity,
-            &pos,
-            &status);
-
-        /* now: start/limit point to the transliterated text */
-        /* Transliterated is [buffer..pos.start) */
-        *count            = pos.start;
-        f->fTranslit->pos = pos.start;
-        f->fTranslit->length = pos.limit;
-
-        return f->fTranslit->buffer;
-    }
-    else
-    {
-        textLength = f->fTranslit->length;
-        textLimit = f->fTranslit->length;
-
-        utrans_transUChars(f->fTranslit->translit,
-            f->fTranslit->buffer,
-            &textLength,
-            f->fTranslit->capacity,
-            0,
-            &textLimit,
-            &status);
-
-        /* out: converted len */
-        *count = textLimit;
-
-        /* Set pointers to 0 */
-        f->fTranslit->pos = 0;
-        f->fTranslit->length = 0;
-
-        return f->fTranslit->buffer;
-    }
-}
-
-#endif
-
-void
-ufile_flush_translit(UFILE *f)
-{
-#if !UCONFIG_NO_TRANSLITERATION
-    if((!f)||(!f->fTranslit))
-        return;
-#endif
-
-    u_file_write_flush(NULL, 0, f, FALSE, TRUE);
-}
-
-
-void
-ufile_flush_io(UFILE *f)
-{
-  if((!f) || (!f->fFile)) {
-    return; /* skip if no file */
-  }
-
-  u_file_write_flush(NULL, 0, f, TRUE, FALSE);
-}
-
-
-void
-ufile_close_translit(UFILE *f)
-{
-#if !UCONFIG_NO_TRANSLITERATION
-    if((!f)||(!f->fTranslit))
-        return;
-#endif
-
-    ufile_flush_translit(f);
-
-#if !UCONFIG_NO_TRANSLITERATION
-    if(f->fTranslit->translit)
-        utrans_close(f->fTranslit->translit);
-
-    if(f->fTranslit->buffer)
-    {
-        uprv_free(f->fTranslit->buffer);
-    }
-
-    uprv_free(f->fTranslit);
-    f->fTranslit = NULL;
-#endif
-}
-
-
-/* Input/output */
-
-U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fputs(const UChar    *s,
-        UFILE        *f)
-{
-    int32_t count = u_file_write(s, u_strlen(s), f);
-    count += u_file_write(DELIMITERS, DELIMITERS_LEN, f);
-    return count;
-}
-
-U_CAPI UChar32 U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fputc(UChar32      uc,
-        UFILE        *f)
-{
-    UChar buf[2];
-    int32_t idx = 0;
-    UBool isError = FALSE;
-
-    U16_APPEND(buf, idx, UPRV_LENGTHOF(buf), uc, isError);
-    if (isError) {
-        return U_EOF;
-    }
-    return u_file_write(buf, idx, f) == idx ? uc : U_EOF;
-}
-
-
-U_CFUNC int32_t U_EXPORT2
-u_file_write_flush(const UChar *chars,
-                   int32_t     count,
-                   UFILE       *f,
-                   UBool       flushIO,
-                   UBool       flushTranslit)
-{
-    /* Set up conversion parameters */
-    UErrorCode  status       = U_ZERO_ERROR;
-    const UChar *mySource    = chars;
-    const UChar *mySourceBegin; 
-    const UChar *mySourceEnd;
-    char        charBuffer[UFILE_CHARBUFFER_SIZE];
-    char        *myTarget   = charBuffer;
-    int32_t     written      = 0;
-    int32_t     numConverted = 0;
-
-    if (count < 0) {
-        count = u_strlen(chars);
-    }
-
-#if !UCONFIG_NO_TRANSLITERATION
-    if((f->fTranslit) && (f->fTranslit->translit))
-    {
-        /* Do the transliteration */
-        mySource = u_file_translit(f, chars, &count, flushTranslit);
-    }
-#endif
-
-    /* Write to a string. */
-    if (!f->fFile) {
-        int32_t charsLeft = (int32_t)(f->str.fLimit - f->str.fPos);
-        if (flushIO && charsLeft > count) {
-            count++;
-        }
-        written = ufmt_min(count, charsLeft);
-        u_strncpy(f->str.fPos, mySource, written);
-        f->str.fPos += written;
-        return written;
-    }
-
-    mySourceEnd = mySource + count;
-
-    /* Perform the conversion in a loop */
-    do {
-        mySourceBegin = mySource; /* beginning location for this loop */
-        status     = U_ZERO_ERROR;
-        if(f->fConverter != NULL) { /* We have a valid converter */
-            ucnv_fromUnicode(f->fConverter,
-                &myTarget,
-                charBuffer + UFILE_CHARBUFFER_SIZE,
-                &mySource,
-                mySourceEnd,
-                NULL,
-                flushIO,
-                &status);
-        } else { /*weiv: do the invariant conversion */
-            int32_t convertChars = (int32_t) (mySourceEnd - mySource); 
-            if (convertChars > UFILE_CHARBUFFER_SIZE) { 
-                convertChars = UFILE_CHARBUFFER_SIZE; 
-                status = U_BUFFER_OVERFLOW_ERROR; 
+// © 2016 and later: Unicode, Inc. and others. 
+// License & terms of use: http://www.unicode.org/copyright.html 
+/* 
+ ****************************************************************************** 
+ * 
+ *   Copyright (C) 1998-2016, International Business Machines 
+ *   Corporation and others.  All Rights Reserved. 
+ * 
+ ****************************************************************************** 
+ * 
+ * File ustdio.c 
+ * 
+ * Modification History: 
+ * 
+ *   Date        Name        Description 
+ *   11/18/98    stephen     Creation. 
+ *   03/12/99    stephen     Modified for new C API. 
+ *   07/19/99    stephen     Fixed read() and gets() 
+ ****************************************************************************** 
+ */ 
+ 
+#include "unicode/ustdio.h" 
+ 
+#if !UCONFIG_NO_CONVERSION 
+ 
+#include "unicode/putil.h" 
+#include "cmemory.h" 
+#include "cstring.h" 
+#include "ufile.h" 
+#include "ufmt_cmn.h" 
+#include "unicode/ucnv.h" 
+#include "unicode/ustring.h" 
+ 
+#include <string.h> 
+ 
+#define DELIM_LF 0x000A 
+#define DELIM_VT 0x000B 
+#define DELIM_FF 0x000C 
+#define DELIM_CR 0x000D 
+#define DELIM_NEL 0x0085 
+#define DELIM_LS 0x2028 
+#define DELIM_PS 0x2029 
+ 
+/* TODO: is this correct for all codepages? Should we just use \n and let the converter handle it? */ 
+#if U_PLATFORM_USES_ONLY_WIN32_API 
+static const UChar DELIMITERS [] = { DELIM_CR, DELIM_LF, 0x0000 }; 
+static const uint32_t DELIMITERS_LEN = 2; 
+/* TODO: Default newline writing should be detected based upon the converter being used. */ 
+#else 
+static const UChar DELIMITERS [] = { DELIM_LF, 0x0000 }; 
+static const uint32_t DELIMITERS_LEN = 1; 
+#endif 
+ 
+#define IS_FIRST_STRING_DELIMITER(c1) \ 
+ (UBool)((DELIM_LF <= (c1) && (c1) <= DELIM_CR) \ 
+        || (c1) == DELIM_NEL \ 
+        || (c1) == DELIM_LS \ 
+        || (c1) == DELIM_PS) 
+#define CAN_HAVE_COMBINED_STRING_DELIMITER(c1) (UBool)((c1) == DELIM_CR) 
+#define IS_COMBINED_STRING_DELIMITER(c1, c2) \ 
+ (UBool)((c1) == DELIM_CR && (c2) == DELIM_LF) 
+ 
+ 
+#if !UCONFIG_NO_TRANSLITERATION 
+ 
+U_CAPI UTransliterator* U_EXPORT2 
+u_fsettransliterator(UFILE *file, UFileDirection direction, 
+                     UTransliterator *adopt, UErrorCode *status) 
+{ 
+    UTransliterator *old = NULL; 
+ 
+    if(U_FAILURE(*status)) 
+    { 
+        return adopt; 
+    } 
+ 
+    if(!file) 
+    { 
+        *status = U_ILLEGAL_ARGUMENT_ERROR; 
+        return adopt; 
+    } 
+ 
+    if(direction & U_READ) 
+    { 
+        /** TODO: implement */ 
+        *status = U_UNSUPPORTED_ERROR; 
+        return adopt; 
+    } 
+ 
+    if(adopt == NULL) /* they are clearing it */ 
+    { 
+        if(file->fTranslit != NULL) 
+        { 
+            /* TODO: Check side */ 
+            old = file->fTranslit->translit; 
+            uprv_free(file->fTranslit->buffer); 
+            file->fTranslit->buffer=NULL; 
+            uprv_free(file->fTranslit); 
+            file->fTranslit=NULL; 
+        } 
+    } 
+    else 
+    { 
+        if(file->fTranslit == NULL) 
+        { 
+            file->fTranslit = (UFILETranslitBuffer*) uprv_malloc(sizeof(UFILETranslitBuffer)); 
+            if(!file->fTranslit) 
+            { 
+                *status = U_MEMORY_ALLOCATION_ERROR; 
+                return adopt; 
             } 
-            u_UCharsToChars(mySource, myTarget, convertChars); 
-            mySource += convertChars; 
-            myTarget += convertChars; 
-        }
-        numConverted = (int32_t)(myTarget - charBuffer);
-
-        if (numConverted > 0) {
-            /* write the converted bytes */
-            fwrite(charBuffer,
-                sizeof(char),
-                numConverted,
-                f->fFile);
-
-            written     += (int32_t) (mySource - mySourceBegin);
-        }
-        myTarget     = charBuffer;
-    }
-    while(status == U_BUFFER_OVERFLOW_ERROR);
-
-    /* return # of chars written */
-    return written;
-}
-
-U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_file_write(    const UChar     *chars,
-             int32_t        count,
-             UFILE         *f)
-{
-    return u_file_write_flush(chars,count,f,FALSE,FALSE);
-}
-
-
-/* private function used for buffering input */
-void
-ufile_fill_uchar_buffer(UFILE *f)
-{
-    UErrorCode  status;
-    const char  *mySource;
-    const char  *mySourceEnd;
-    UChar       *myTarget;
-    int32_t     bufferSize;
-    int32_t     maxCPBytes;
-    int32_t     bytesRead;
-    int32_t     availLength;
-    int32_t     dataSize;
-    char        charBuffer[UFILE_CHARBUFFER_SIZE];
-    u_localized_string *str;
-
-    if (f->fFile == NULL) {
-        /* There is nothing to do. It's a string. */
-        return;
-    }
-
-    str = &f->str;
-    dataSize = (int32_t)(str->fLimit - str->fPos);
-    if (f->fFileno == 0 && dataSize > 0) {
-        /* Don't read from stdin too many times. There is still some data. */
-        return;
-    }
-
-    /* shift the buffer if it isn't empty */
-    if(dataSize != 0) {
-        u_memmove(f->fUCBuffer, str->fPos, dataSize); /* not accessing beyond memory */
-    }
-
-
-    /* record how much buffer space is available */
-    availLength = UFILE_UCHARBUFFER_SIZE - dataSize;
-
-    /* Determine the # of codepage bytes needed to fill our UChar buffer */
-    /* weiv: if converter is NULL, we use invariant converter with charwidth = 1)*/
-    maxCPBytes = availLength / (f->fConverter!=NULL?(2*ucnv_getMinCharSize(f->fConverter)):1);
-
-    /* Read in the data to convert */
-    if (f->fFileno == 0) {
-        /* Special case. Read from stdin one line at a time. */
-        char *retStr = fgets(charBuffer, ufmt_min(maxCPBytes, UFILE_CHARBUFFER_SIZE), f->fFile);
-        bytesRead = (int32_t)(retStr ? uprv_strlen(charBuffer) : 0);
-    }
-    else {
-        /* A normal file */
-        bytesRead = (int32_t)fread(charBuffer,
-            sizeof(char),
-            ufmt_min(maxCPBytes, UFILE_CHARBUFFER_SIZE),
-            f->fFile);
-    }
-
-    /* Set up conversion parameters */
-    status      = U_ZERO_ERROR;
-    mySource    = charBuffer;
-    mySourceEnd = charBuffer + bytesRead;
-    myTarget    = f->fUCBuffer + dataSize;
-    bufferSize  = UFILE_UCHARBUFFER_SIZE;
-
-    if(f->fConverter != NULL) { /* We have a valid converter */
-        /* Perform the conversion */
-        ucnv_toUnicode(f->fConverter,
-            &myTarget,
-            f->fUCBuffer + bufferSize,
-            &mySource,
-            mySourceEnd,
-            NULL,
-            (UBool)(feof(f->fFile) != 0),
-            &status);
-
-    } else { /*weiv: do the invariant conversion */
-        u_charsToUChars(mySource, myTarget, bytesRead);
-        myTarget += bytesRead;
-    }
-
-    /* update the pointers into our array */
-    str->fPos    = str->fBuffer;
-    str->fLimit  = myTarget;
-}
-
-U_CAPI UChar* U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fgets(UChar        *s,
-        int32_t       n,
-        UFILE        *f)
-{
-    int32_t dataSize;
-    int32_t count;
-    UChar *alias;
-    const UChar *limit;
-    UChar *sItr;
-    UChar currDelim = 0;
-    u_localized_string *str;
-
-    if (n <= 0) {
-        /* Caller screwed up. We need to write the null terminatior. */
-        return NULL;
-    }
-
-    /* fill the buffer if needed */
-    str = &f->str;
-    if (str->fPos >= str->fLimit) {
-        ufile_fill_uchar_buffer(f);
-    }
-
-    /* subtract 1 from n to compensate for the terminator */
-    --n;
-
-    /* determine the amount of data in the buffer */
-    dataSize = (int32_t)(str->fLimit - str->fPos);
-
-    /* if 0 characters were left, return 0 */
-    if (dataSize == 0)
-        return NULL;
-
-    /* otherwise, iteratively fill the buffer and copy */
-    count = 0;
-    sItr = s;
-    currDelim = 0;
-    while (dataSize > 0 && count < n) {
-        alias = str->fPos;
-
-        /* Find how much to copy */
-        if (dataSize < (n - count)) {
-            limit = str->fLimit;
-        }
-        else {
-            limit = alias + (n - count);
-        }
-
-        if (!currDelim) {
-            /* Copy UChars until we find the first occurrence of a delimiter character */
-            while (alias < limit && !IS_FIRST_STRING_DELIMITER(*alias)) {
-                count++;
-                *(sItr++) = *(alias++);
-            }
-            /* Preserve the newline */
-            if (alias < limit && IS_FIRST_STRING_DELIMITER(*alias)) {
-                if (CAN_HAVE_COMBINED_STRING_DELIMITER(*alias)) {
-                    currDelim = *alias;
-                }
-                else {
-                    currDelim = 1;  /* This isn't a newline, but it's used to say
-                                    that we should break later. We've checked all
-                                    possible newline combinations even across buffer
-                                    boundaries. */
-                }
-                count++;
-                *(sItr++) = *(alias++);
-            }
-        }
-        /* If we have a CRLF combination, preserve that too. */
-        if (alias < limit) {
-            if (currDelim && IS_COMBINED_STRING_DELIMITER(currDelim, *alias)) {
-                count++;
-                *(sItr++) = *(alias++);
-            }
-            currDelim = 1;  /* This isn't a newline, but it's used to say
-                            that we should break later. We've checked all
-                            possible newline combinations even across buffer
-                            boundaries. */
-        }
-
-        /* update the current buffer position */
-        str->fPos = alias;
-
-        /* if we found a delimiter */
-        if (currDelim == 1) {
-            /* break out */
-            break;
-        }
-
-        /* refill the buffer */
-        ufile_fill_uchar_buffer(f);
-
-        /* determine the amount of data in the buffer */
-        dataSize = (int32_t)(str->fLimit - str->fPos);
-    }
-
-    /* add the terminator and return s */
-    *sItr = 0x0000;
-    return s;
-}
-
-U_CFUNC UBool U_EXPORT2
-ufile_getch(UFILE *f, UChar *ch)
-{
-    UBool isValidChar = FALSE;
-
-    *ch = U_EOF;
-    /* if we have an available character in the buffer, return it */
-    if(f->str.fPos < f->str.fLimit){
-        *ch = *(f->str.fPos)++;
-        isValidChar = TRUE;
-    }
-    else {
-        /* otherwise, fill the buffer and return the next character */
-        if(f->str.fPos >= f->str.fLimit) {
-            ufile_fill_uchar_buffer(f);
-        }
-        if(f->str.fPos < f->str.fLimit) {
-            *ch = *(f->str.fPos)++;
-            isValidChar = TRUE;
-        }
-    }
-    return isValidChar;
-}
-
-U_CAPI UChar U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fgetc(UFILE        *f)
-{
-    UChar ch;
-    ufile_getch(f, &ch);
-    return ch;
-}
-
-U_CFUNC UBool U_EXPORT2
-ufile_getch32(UFILE *f, UChar32 *c32)
-{
-    UBool isValidChar = FALSE;
-    u_localized_string *str;
-
-    *c32 = U_EOF;
-
-    /* Fill the buffer if it is empty */
-    str = &f->str;
-    if (f && str->fPos + 1 >= str->fLimit) {
-        ufile_fill_uchar_buffer(f);
-    }
-
-    /* Get the next character in the buffer */
-    if (str->fPos < str->fLimit) {
-        *c32 = *(str->fPos)++;
-        if (U_IS_LEAD(*c32)) {
-            if (str->fPos < str->fLimit) {
-                UChar c16 = *(str->fPos)++;
-                *c32 = U16_GET_SUPPLEMENTARY(*c32, c16);
-                isValidChar = TRUE;
-            }
-            else {
-                *c32 = U_EOF;
-            }
-        }
-        else {
-            isValidChar = TRUE;
-        }
-    }
-
-    return isValidChar;
-}
-
-U_CAPI UChar32 U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fgetcx(UFILE        *f)
-{
-    UChar32 ch;
-    ufile_getch32(f, &ch);
-    return ch;
-}
-
-U_CAPI UChar32 U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_fungetc(UChar32        ch,
-    UFILE        *f)
-{
-    u_localized_string *str;
-
-    str = &f->str;
-
-    /* if we're at the beginning of the buffer, sorry! */
-    if (str->fPos == str->fBuffer
-        || (U_IS_LEAD(ch) && (str->fPos - 1) == str->fBuffer))
-    {
-        ch = U_EOF;
-    }
-    else {
-        /* otherwise, put the character back */
-        /* Remember, read them back on in the reverse order. */
-        if (U_IS_LEAD(ch)) {
-            if (*--(str->fPos) != U16_TRAIL(ch)
-                || *--(str->fPos) != U16_LEAD(ch))
-            {
-                ch = U_EOF;
-            }
-        }
-        else if (*--(str->fPos) != ch) {
-            ch = U_EOF;
-        }
-    }
-    return ch;
-}
-
-U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
-u_file_read(    UChar        *chars,
-    int32_t        count,
-    UFILE         *f)
-{
-    int32_t dataSize;
-    int32_t read = 0;
-    u_localized_string *str = &f->str;
-
-    do {
-
-        /* determine the amount of data in the buffer */
-        dataSize = (int32_t)(str->fLimit - str->fPos);
-        if (dataSize <= 0) {
-            /* fill the buffer */
-            ufile_fill_uchar_buffer(f);
-            dataSize = (int32_t)(str->fLimit - str->fPos);
-        }
-
-        /* Make sure that we don't read too much */
-        if (dataSize > (count - read)) {
-            dataSize = count - read;
-        }
-
-        /* copy the current data in the buffer */
-        memcpy(chars + read, str->fPos, dataSize * sizeof(UChar));
-
-        /* update number of items read */
-        read += dataSize;
-
-        /* update the current buffer position */
-        str->fPos += dataSize;
-    }
-    while (dataSize != 0 && read < count);
-
-    return read;
-}
-#endif
+            file->fTranslit->capacity = 0; 
+            file->fTranslit->length = 0; 
+            file->fTranslit->pos = 0; 
+            file->fTranslit->buffer = NULL; 
+        } 
+        else 
+        { 
+            old = file->fTranslit->translit; 
+            ufile_flush_translit(file); 
+        } 
+ 
+        file->fTranslit->translit = adopt; 
+    } 
+ 
+    return old; 
+} 
+ 
+static const UChar * u_file_translit(UFILE *f, const UChar *src, int32_t *count, UBool flush) 
+{ 
+    int32_t newlen; 
+    int32_t junkCount = 0; 
+    int32_t textLength; 
+    int32_t textLimit; 
+    UTransPosition pos; 
+    UErrorCode status = U_ZERO_ERROR; 
+ 
+    if(count == NULL) 
+    { 
+        count = &junkCount; 
+    } 
+ 
+    if ((!f)||(!f->fTranslit)||(!f->fTranslit->translit)) 
+    { 
+        /* fast path */ 
+        return src; 
+    } 
+ 
+    /* First: slide over everything */ 
+    if(f->fTranslit->length > f->fTranslit->pos) 
+    { 
+        memmove(f->fTranslit->buffer, f->fTranslit->buffer + f->fTranslit->pos, 
+            (f->fTranslit->length - f->fTranslit->pos)*sizeof(UChar)); 
+    } 
+    f->fTranslit->length -= f->fTranslit->pos; /* always */ 
+    f->fTranslit->pos = 0; 
+ 
+    /* Calculate new buffer size needed */ 
+    newlen = (*count + f->fTranslit->length) * 4; 
+ 
+    if(newlen > f->fTranslit->capacity) 
+    { 
+        if(f->fTranslit->buffer == NULL) 
+        { 
+            f->fTranslit->buffer = (UChar*)uprv_malloc(newlen * sizeof(UChar)); 
+        } 
+        else 
+        { 
+            f->fTranslit->buffer = (UChar*)uprv_realloc(f->fTranslit->buffer, newlen * sizeof(UChar)); 
+        } 
+        /* Check for malloc/realloc failure. */ 
+        if (f->fTranslit->buffer == NULL) { 
+        	return NULL; 
+        } 
+        f->fTranslit->capacity = newlen; 
+    } 
+ 
+    /* Now, copy any data over */ 
+    u_strncpy(f->fTranslit->buffer + f->fTranslit->length, 
+        src, 
+        *count); 
+    f->fTranslit->length += *count; 
+ 
+    /* Now, translit in place as much as we can  */ 
+    if(flush == FALSE) 
+    { 
+        textLength = f->fTranslit->length; 
+        pos.contextStart = 0; 
+        pos.contextLimit = textLength; 
+        pos.start        = 0; 
+        pos.limit        = textLength; 
+ 
+        utrans_transIncrementalUChars(f->fTranslit->translit, 
+            f->fTranslit->buffer, /* because we shifted */ 
+            &textLength, 
+            f->fTranslit->capacity, 
+            &pos, 
+            &status); 
+ 
+        /* now: start/limit point to the transliterated text */ 
+        /* Transliterated is [buffer..pos.start) */ 
+        *count            = pos.start; 
+        f->fTranslit->pos = pos.start; 
+        f->fTranslit->length = pos.limit; 
+ 
+        return f->fTranslit->buffer; 
+    } 
+    else 
+    { 
+        textLength = f->fTranslit->length; 
+        textLimit = f->fTranslit->length; 
+ 
+        utrans_transUChars(f->fTranslit->translit, 
+            f->fTranslit->buffer, 
+            &textLength, 
+            f->fTranslit->capacity, 
+            0, 
+            &textLimit, 
+            &status); 
+ 
+        /* out: converted len */ 
+        *count = textLimit; 
+ 
+        /* Set pointers to 0 */ 
+        f->fTranslit->pos = 0; 
+        f->fTranslit->length = 0; 
+ 
+        return f->fTranslit->buffer; 
+    } 
+} 
+ 
+#endif 
+ 
+void 
+ufile_flush_translit(UFILE *f) 
+{ 
+#if !UCONFIG_NO_TRANSLITERATION 
+    if((!f)||(!f->fTranslit)) 
+        return; 
+#endif 
+ 
+    u_file_write_flush(NULL, 0, f, FALSE, TRUE); 
+} 
+ 
+ 
+void 
+ufile_flush_io(UFILE *f) 
+{ 
+  if((!f) || (!f->fFile)) { 
+    return; /* skip if no file */ 
+  } 
+ 
+  u_file_write_flush(NULL, 0, f, TRUE, FALSE); 
+} 
+ 
+ 
+void 
+ufile_close_translit(UFILE *f) 
+{ 
+#if !UCONFIG_NO_TRANSLITERATION 
+    if((!f)||(!f->fTranslit)) 
+        return; 
+#endif 
+ 
+    ufile_flush_translit(f); 
+ 
+#if !UCONFIG_NO_TRANSLITERATION 
+    if(f->fTranslit->translit) 
+        utrans_close(f->fTranslit->translit); 
+ 
+    if(f->fTranslit->buffer) 
+    { 
+        uprv_free(f->fTranslit->buffer); 
+    } 
+ 
+    uprv_free(f->fTranslit); 
+    f->fTranslit = NULL; 
+#endif 
+} 
+ 
+ 
+/* Input/output */ 
+ 
+U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fputs(const UChar    *s, 
+        UFILE        *f) 
+{ 
+    int32_t count = u_file_write(s, u_strlen(s), f); 
+    count += u_file_write(DELIMITERS, DELIMITERS_LEN, f); 
+    return count; 
+} 
+ 
+U_CAPI UChar32 U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fputc(UChar32      uc, 
+        UFILE        *f) 
+{ 
+    UChar buf[2]; 
+    int32_t idx = 0; 
+    UBool isError = FALSE; 
+ 
+    U16_APPEND(buf, idx, UPRV_LENGTHOF(buf), uc, isError); 
+    if (isError) { 
+        return U_EOF; 
+    } 
+    return u_file_write(buf, idx, f) == idx ? uc : U_EOF; 
+} 
+ 
+ 
+U_CFUNC int32_t U_EXPORT2 
+u_file_write_flush(const UChar *chars, 
+                   int32_t     count, 
+                   UFILE       *f, 
+                   UBool       flushIO, 
+                   UBool       flushTranslit) 
+{ 
+    /* Set up conversion parameters */ 
+    UErrorCode  status       = U_ZERO_ERROR; 
+    const UChar *mySource    = chars; 
+    const UChar *mySourceBegin;  
+    const UChar *mySourceEnd; 
+    char        charBuffer[UFILE_CHARBUFFER_SIZE]; 
+    char        *myTarget   = charBuffer; 
+    int32_t     written      = 0; 
+    int32_t     numConverted = 0; 
+ 
+    if (count < 0) { 
+        count = u_strlen(chars); 
+    } 
+ 
+#if !UCONFIG_NO_TRANSLITERATION 
+    if((f->fTranslit) && (f->fTranslit->translit)) 
+    { 
+        /* Do the transliteration */ 
+        mySource = u_file_translit(f, chars, &count, flushTranslit); 
+    } 
+#endif 
+ 
+    /* Write to a string. */ 
+    if (!f->fFile) { 
+        int32_t charsLeft = (int32_t)(f->str.fLimit - f->str.fPos); 
+        if (flushIO && charsLeft > count) { 
+            count++; 
+        } 
+        written = ufmt_min(count, charsLeft); 
+        u_strncpy(f->str.fPos, mySource, written); 
+        f->str.fPos += written; 
+        return written; 
+    } 
+ 
+    mySourceEnd = mySource + count; 
+ 
+    /* Perform the conversion in a loop */ 
+    do { 
+        mySourceBegin = mySource; /* beginning location for this loop */ 
+        status     = U_ZERO_ERROR; 
+        if(f->fConverter != NULL) { /* We have a valid converter */ 
+            ucnv_fromUnicode(f->fConverter, 
+                &myTarget, 
+                charBuffer + UFILE_CHARBUFFER_SIZE, 
+                &mySource, 
+                mySourceEnd, 
+                NULL, 
+                flushIO, 
+                &status); 
+        } else { /*weiv: do the invariant conversion */ 
+            int32_t convertChars = (int32_t) (mySourceEnd - mySource);  
+            if (convertChars > UFILE_CHARBUFFER_SIZE) {  
+                convertChars = UFILE_CHARBUFFER_SIZE;  
+                status = U_BUFFER_OVERFLOW_ERROR;  
+            }  
+            u_UCharsToChars(mySource, myTarget, convertChars);  
+            mySource += convertChars;  
+            myTarget += convertChars;  
+        } 
+        numConverted = (int32_t)(myTarget - charBuffer); 
+ 
+        if (numConverted > 0) { 
+            /* write the converted bytes */ 
+            fwrite(charBuffer, 
+                sizeof(char), 
+                numConverted, 
+                f->fFile); 
+ 
+            written     += (int32_t) (mySource - mySourceBegin); 
+        } 
+        myTarget     = charBuffer; 
+    } 
+    while(status == U_BUFFER_OVERFLOW_ERROR); 
+ 
+    /* return # of chars written */ 
+    return written; 
+} 
+ 
+U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_file_write(    const UChar     *chars, 
+             int32_t        count, 
+             UFILE         *f) 
+{ 
+    return u_file_write_flush(chars,count,f,FALSE,FALSE); 
+} 
+ 
+ 
+/* private function used for buffering input */ 
+void 
+ufile_fill_uchar_buffer(UFILE *f) 
+{ 
+    UErrorCode  status; 
+    const char  *mySource; 
+    const char  *mySourceEnd; 
+    UChar       *myTarget; 
+    int32_t     bufferSize; 
+    int32_t     maxCPBytes; 
+    int32_t     bytesRead; 
+    int32_t     availLength; 
+    int32_t     dataSize; 
+    char        charBuffer[UFILE_CHARBUFFER_SIZE]; 
+    u_localized_string *str; 
+ 
+    if (f->fFile == NULL) { 
+        /* There is nothing to do. It's a string. */ 
+        return; 
+    } 
+ 
+    str = &f->str; 
+    dataSize = (int32_t)(str->fLimit - str->fPos); 
+    if (f->fFileno == 0 && dataSize > 0) { 
+        /* Don't read from stdin too many times. There is still some data. */ 
+        return; 
+    } 
+ 
+    /* shift the buffer if it isn't empty */ 
+    if(dataSize != 0) { 
+        u_memmove(f->fUCBuffer, str->fPos, dataSize); /* not accessing beyond memory */ 
+    } 
+ 
+ 
+    /* record how much buffer space is available */ 
+    availLength = UFILE_UCHARBUFFER_SIZE - dataSize; 
+ 
+    /* Determine the # of codepage bytes needed to fill our UChar buffer */ 
+    /* weiv: if converter is NULL, we use invariant converter with charwidth = 1)*/ 
+    maxCPBytes = availLength / (f->fConverter!=NULL?(2*ucnv_getMinCharSize(f->fConverter)):1); 
+ 
+    /* Read in the data to convert */ 
+    if (f->fFileno == 0) { 
+        /* Special case. Read from stdin one line at a time. */ 
+        char *retStr = fgets(charBuffer, ufmt_min(maxCPBytes, UFILE_CHARBUFFER_SIZE), f->fFile); 
+        bytesRead = (int32_t)(retStr ? uprv_strlen(charBuffer) : 0); 
+    } 
+    else { 
+        /* A normal file */ 
+        bytesRead = (int32_t)fread(charBuffer, 
+            sizeof(char), 
+            ufmt_min(maxCPBytes, UFILE_CHARBUFFER_SIZE), 
+            f->fFile); 
+    } 
+ 
+    /* Set up conversion parameters */ 
+    status      = U_ZERO_ERROR; 
+    mySource    = charBuffer; 
+    mySourceEnd = charBuffer + bytesRead; 
+    myTarget    = f->fUCBuffer + dataSize; 
+    bufferSize  = UFILE_UCHARBUFFER_SIZE; 
+ 
+    if(f->fConverter != NULL) { /* We have a valid converter */ 
+        /* Perform the conversion */ 
+        ucnv_toUnicode(f->fConverter, 
+            &myTarget, 
+            f->fUCBuffer + bufferSize, 
+            &mySource, 
+            mySourceEnd, 
+            NULL, 
+            (UBool)(feof(f->fFile) != 0), 
+            &status); 
+ 
+    } else { /*weiv: do the invariant conversion */ 
+        u_charsToUChars(mySource, myTarget, bytesRead); 
+        myTarget += bytesRead; 
+    } 
+ 
+    /* update the pointers into our array */ 
+    str->fPos    = str->fBuffer; 
+    str->fLimit  = myTarget; 
+} 
+ 
+U_CAPI UChar* U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fgets(UChar        *s, 
+        int32_t       n, 
+        UFILE        *f) 
+{ 
+    int32_t dataSize; 
+    int32_t count; 
+    UChar *alias; 
+    const UChar *limit; 
+    UChar *sItr; 
+    UChar currDelim = 0; 
+    u_localized_string *str; 
+ 
+    if (n <= 0) { 
+        /* Caller screwed up. We need to write the null terminatior. */ 
+        return NULL; 
+    } 
+ 
+    /* fill the buffer if needed */ 
+    str = &f->str; 
+    if (str->fPos >= str->fLimit) { 
+        ufile_fill_uchar_buffer(f); 
+    } 
+ 
+    /* subtract 1 from n to compensate for the terminator */ 
+    --n; 
+ 
+    /* determine the amount of data in the buffer */ 
+    dataSize = (int32_t)(str->fLimit - str->fPos); 
+ 
+    /* if 0 characters were left, return 0 */ 
+    if (dataSize == 0) 
+        return NULL; 
+ 
+    /* otherwise, iteratively fill the buffer and copy */ 
+    count = 0; 
+    sItr = s; 
+    currDelim = 0; 
+    while (dataSize > 0 && count < n) { 
+        alias = str->fPos; 
+ 
+        /* Find how much to copy */ 
+        if (dataSize < (n - count)) { 
+            limit = str->fLimit; 
+        } 
+        else { 
+            limit = alias + (n - count); 
+        } 
+ 
+        if (!currDelim) { 
+            /* Copy UChars until we find the first occurrence of a delimiter character */ 
+            while (alias < limit && !IS_FIRST_STRING_DELIMITER(*alias)) { 
+                count++; 
+                *(sItr++) = *(alias++); 
+            } 
+            /* Preserve the newline */ 
+            if (alias < limit && IS_FIRST_STRING_DELIMITER(*alias)) { 
+                if (CAN_HAVE_COMBINED_STRING_DELIMITER(*alias)) { 
+                    currDelim = *alias; 
+                } 
+                else { 
+                    currDelim = 1;  /* This isn't a newline, but it's used to say 
+                                    that we should break later. We've checked all 
+                                    possible newline combinations even across buffer 
+                                    boundaries. */ 
+                } 
+                count++; 
+                *(sItr++) = *(alias++); 
+            } 
+        } 
+        /* If we have a CRLF combination, preserve that too. */ 
+        if (alias < limit) { 
+            if (currDelim && IS_COMBINED_STRING_DELIMITER(currDelim, *alias)) { 
+                count++; 
+                *(sItr++) = *(alias++); 
+            } 
+            currDelim = 1;  /* This isn't a newline, but it's used to say 
+                            that we should break later. We've checked all 
+                            possible newline combinations even across buffer 
+                            boundaries. */ 
+        } 
+ 
+        /* update the current buffer position */ 
+        str->fPos = alias; 
+ 
+        /* if we found a delimiter */ 
+        if (currDelim == 1) { 
+            /* break out */ 
+            break; 
+        } 
+ 
+        /* refill the buffer */ 
+        ufile_fill_uchar_buffer(f); 
+ 
+        /* determine the amount of data in the buffer */ 
+        dataSize = (int32_t)(str->fLimit - str->fPos); 
+    } 
+ 
+    /* add the terminator and return s */ 
+    *sItr = 0x0000; 
+    return s; 
+} 
+ 
+U_CFUNC UBool U_EXPORT2 
+ufile_getch(UFILE *f, UChar *ch) 
+{ 
+    UBool isValidChar = FALSE; 
+ 
+    *ch = U_EOF; 
+    /* if we have an available character in the buffer, return it */ 
+    if(f->str.fPos < f->str.fLimit){ 
+        *ch = *(f->str.fPos)++; 
+        isValidChar = TRUE; 
+    } 
+    else { 
+        /* otherwise, fill the buffer and return the next character */ 
+        if(f->str.fPos >= f->str.fLimit) { 
+            ufile_fill_uchar_buffer(f); 
+        } 
+        if(f->str.fPos < f->str.fLimit) { 
+            *ch = *(f->str.fPos)++; 
+            isValidChar = TRUE; 
+        } 
+    } 
+    return isValidChar; 
+} 
+ 
+U_CAPI UChar U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fgetc(UFILE        *f) 
+{ 
+    UChar ch; 
+    ufile_getch(f, &ch); 
+    return ch; 
+} 
+ 
+U_CFUNC UBool U_EXPORT2 
+ufile_getch32(UFILE *f, UChar32 *c32) 
+{ 
+    UBool isValidChar = FALSE; 
+    u_localized_string *str; 
+ 
+    *c32 = U_EOF; 
+ 
+    /* Fill the buffer if it is empty */ 
+    str = &f->str; 
+    if (f && str->fPos + 1 >= str->fLimit) { 
+        ufile_fill_uchar_buffer(f); 
+    } 
+ 
+    /* Get the next character in the buffer */ 
+    if (str->fPos < str->fLimit) { 
+        *c32 = *(str->fPos)++; 
+        if (U_IS_LEAD(*c32)) { 
+            if (str->fPos < str->fLimit) { 
+                UChar c16 = *(str->fPos)++; 
+                *c32 = U16_GET_SUPPLEMENTARY(*c32, c16); 
+                isValidChar = TRUE; 
+            } 
+            else { 
+                *c32 = U_EOF; 
+            } 
+        } 
+        else { 
+            isValidChar = TRUE; 
+        } 
+    } 
+ 
+    return isValidChar; 
+} 
+ 
+U_CAPI UChar32 U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fgetcx(UFILE        *f) 
+{ 
+    UChar32 ch; 
+    ufile_getch32(f, &ch); 
+    return ch; 
+} 
+ 
+U_CAPI UChar32 U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_fungetc(UChar32        ch, 
+    UFILE        *f) 
+{ 
+    u_localized_string *str; 
+ 
+    str = &f->str; 
+ 
+    /* if we're at the beginning of the buffer, sorry! */ 
+    if (str->fPos == str->fBuffer 
+        || (U_IS_LEAD(ch) && (str->fPos - 1) == str->fBuffer)) 
+    { 
+        ch = U_EOF; 
+    } 
+    else { 
+        /* otherwise, put the character back */ 
+        /* Remember, read them back on in the reverse order. */ 
+        if (U_IS_LEAD(ch)) { 
+            if (*--(str->fPos) != U16_TRAIL(ch) 
+                || *--(str->fPos) != U16_LEAD(ch)) 
+            { 
+                ch = U_EOF; 
+            } 
+        } 
+        else if (*--(str->fPos) != ch) { 
+            ch = U_EOF; 
+        } 
+    } 
+    return ch; 
+} 
+ 
+U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */ 
+u_file_read(    UChar        *chars, 
+    int32_t        count, 
+    UFILE         *f) 
+{ 
+    int32_t dataSize; 
+    int32_t read = 0; 
+    u_localized_string *str = &f->str; 
+ 
+    do { 
+ 
+        /* determine the amount of data in the buffer */ 
+        dataSize = (int32_t)(str->fLimit - str->fPos); 
+        if (dataSize <= 0) { 
+            /* fill the buffer */ 
+            ufile_fill_uchar_buffer(f); 
+            dataSize = (int32_t)(str->fLimit - str->fPos); 
+        } 
+ 
+        /* Make sure that we don't read too much */ 
+        if (dataSize > (count - read)) { 
+            dataSize = count - read; 
+        } 
+ 
+        /* copy the current data in the buffer */ 
+        memcpy(chars + read, str->fPos, dataSize * sizeof(UChar)); 
+ 
+        /* update number of items read */ 
+        read += dataSize; 
+ 
+        /* update the current buffer position */ 
+        str->fPos += dataSize; 
+    } 
+    while (dataSize != 0 && read < count); 
+ 
+    return read; 
+} 
+#endif 
diff --git a/contrib/libs/icu/io/ustream.cpp b/contrib/libs/icu/io/ustream.cpp
index 51676ea0f5..8e1d733c65 100644
--- a/contrib/libs/icu/io/ustream.cpp
+++ b/contrib/libs/icu/io/ustream.cpp
@@ -1,4 +1,4 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2016 and later: Unicode, Inc. and others. 
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 **********************************************************************
@@ -123,7 +123,7 @@ operator>>(STD_ISTREAM& stream, UnicodeString& str)
             /* Was the character consumed? */
             if (us != uBuffer) {
                 /* Reminder: ibm-1390 & JISX0213 can output 2 Unicode code points */
-                int32_t uBuffSize = static_cast<int32_t>(us-uBuffer);
+                int32_t uBuffSize = static_cast<int32_t>(us-uBuffer); 
                 int32_t uBuffIdx = 0;
                 while (uBuffIdx < uBuffSize) {
                     U16_NEXT(uBuffer, uBuffIdx, uBuffSize, ch32);