Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 1 of 2.

1 files changed, 883 insertions, 883 deletions

diff --git a/contrib/libs/cxxsupp/openmp/kmp_str.c b/contrib/libs/cxxsupp/openmp/kmp_str.c
index b5f700551e..8adf3e3876 100644
--- a/contrib/libs/cxxsupp/openmp/kmp_str.c
+++ b/contrib/libs/cxxsupp/openmp/kmp_str.c
@@ -1,883 +1,883 @@
-/*
- * kmp_str.c -- String manipulation routines.
- */
-
-
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.txt for details.
-//
-//===----------------------------------------------------------------------===//
-
-
-#include "kmp_str.h"
-
-#include <stdarg.h>    // va_*
-#include <stdio.h>     // vsnprintf()
-#include <stdlib.h>    // malloc(), realloc()
-
-#include "kmp.h"
-#include "kmp_i18n.h"
-
-/*
-    ------------------------------------------------------------------------------------------------
-    String buffer.
-    ------------------------------------------------------------------------------------------------
-
-    Usage:
-
-        // Declare buffer and initialize it.
-        kmp_str_buf_t  buffer;
-	__kmp_str_buf_init( & buffer );
-
-        // Print to buffer.
-        __kmp_str_buf_print( & buffer, "Error in file \"%s\" line %d\n", "foo.c", 12 );
-        __kmp_str_buf_print( & buffer, "    <%s>\n", line );
-
-        // Use buffer contents. buffer.str is a pointer to data, buffer.used is a number of printed
-        // characters (not including terminating zero).
-        write( fd, buffer.str, buffer.used );
-
-        // Free buffer.
-        __kmp_str_buf_free( & buffer );
-
-        // Alternatively, you can detach allocated memory from buffer:
-        __kmp_str_buf_detach( & buffer );
-        return buffer.str;    // That memory should be freed eventually.
-
-
-    Notes:
-
-        * Buffer users may use buffer.str and buffer.used. Users should not change any fields of
-          buffer directly.
-
-        * buffer.str is never NULL. If buffer is empty, buffer.str points to empty string ("").
-
-        * For performance reasons, buffer uses stack memory (buffer.bulk) first. If stack memory is
-          exhausted, buffer allocates memory on heap by malloc(), and reallocates it by realloc()
-          as amount of used memory grows.
-
-        * Buffer doubles amount of allocated memory each time it is exhausted.
-
-    ------------------------------------------------------------------------------------------------
-*/
-
-// TODO: __kmp_str_buf_print() can use thread local memory allocator.
-
-#define KMP_STR_BUF_INVARIANT( b )                                                                \
-    {                                                                                             \
-        KMP_DEBUG_ASSERT( (b)->str != NULL );                                                     \
-        KMP_DEBUG_ASSERT( (b)->size >= sizeof( (b)->bulk ) );                                     \
-        KMP_DEBUG_ASSERT( (b)->size % sizeof( (b)->bulk ) == 0 );                                 \
-        KMP_DEBUG_ASSERT( (unsigned)(b)->used < (b)->size );                                      \
-        KMP_DEBUG_ASSERT( (b)->size == sizeof( (b)->bulk ) ? (b)->str == & (b)->bulk[ 0 ] : 1 );  \
-        KMP_DEBUG_ASSERT( (b)->size > sizeof( (b)->bulk ) ? (b)->str != & (b)->bulk[ 0 ] : 1 );   \
-    }
-
-void
- __kmp_str_buf_clear(
-     kmp_str_buf_t * buffer
-) {
-    KMP_STR_BUF_INVARIANT( buffer );
-    if ( buffer->used > 0 ) {
-        buffer->used = 0;
-        buffer->str[ 0 ] = 0;
-    }; // if
-    KMP_STR_BUF_INVARIANT( buffer );
-} // __kmp_str_buf_clear
-
-
-void
-__kmp_str_buf_reserve(
-    kmp_str_buf_t * buffer,
-    int             size
-) {
-
-    KMP_STR_BUF_INVARIANT( buffer );
-    KMP_DEBUG_ASSERT( size >= 0 );
-
-    if ( buffer->size < (unsigned int)size ) {
-
-        // Calculate buffer size.
-        do {
-            buffer->size *= 2;
-        } while ( buffer->size < (unsigned int)size );
-
-        // Enlarge buffer.
-        if ( buffer->str == & buffer->bulk[ 0 ] ) {
-            buffer->str = (char *) KMP_INTERNAL_MALLOC( buffer->size );
-            if ( buffer->str == NULL ) {
-		KMP_FATAL( MemoryAllocFailed );
-            }; // if
-            KMP_MEMCPY_S( buffer->str, buffer->size, buffer->bulk, buffer->used + 1 );
-        } else {
-            buffer->str = (char *) KMP_INTERNAL_REALLOC( buffer->str, buffer->size );
-            if ( buffer->str == NULL ) {
-		KMP_FATAL( MemoryAllocFailed );
-            }; // if
-        }; // if
-
-    }; // if
-
-    KMP_DEBUG_ASSERT( buffer->size > 0 );
-    KMP_DEBUG_ASSERT( buffer->size >= (unsigned)size );
-    KMP_STR_BUF_INVARIANT( buffer );
-
-} // __kmp_str_buf_reserve
-
-
-void
-__kmp_str_buf_detach(
-    kmp_str_buf_t *  buffer
-) {
-
-    KMP_STR_BUF_INVARIANT( buffer );
-
-    // If internal bulk is used, allocate memory and copy it.
-    if ( buffer->size <= sizeof( buffer->bulk ) ) {
-        buffer->str = (char *) KMP_INTERNAL_MALLOC( buffer->size );
-        if ( buffer->str == NULL ) {
-		KMP_FATAL( MemoryAllocFailed );
-        }; // if
-        KMP_MEMCPY_S( buffer->str, buffer->size, buffer->bulk, buffer->used + 1 );
-    }; // if
-
-} // __kmp_str_buf_detach
-
-
-void
-__kmp_str_buf_free(
-    kmp_str_buf_t * buffer
-) {
-    KMP_STR_BUF_INVARIANT( buffer );
-    if ( buffer->size > sizeof( buffer->bulk ) ) {
-        KMP_INTERNAL_FREE( buffer->str );
-    }; // if
-    buffer->str  = buffer->bulk;
-    buffer->size = sizeof( buffer->bulk );
-    buffer->used = 0;
-    KMP_STR_BUF_INVARIANT( buffer );
-} // __kmp_str_buf_free
-
-
-void
-__kmp_str_buf_cat(
-    kmp_str_buf_t * buffer,
-    char const *    str,
-    int             len
-) {
-    KMP_STR_BUF_INVARIANT( buffer );
-    KMP_DEBUG_ASSERT( str != NULL );
-    KMP_DEBUG_ASSERT( len >= 0 );
-    __kmp_str_buf_reserve( buffer, buffer->used + len + 1 );
-    KMP_MEMCPY( buffer->str + buffer->used, str, len );
-    buffer->str[ buffer->used + len ] = 0;
-    buffer->used += len;
-    KMP_STR_BUF_INVARIANT( buffer );
-} // __kmp_str_buf_cat
-
-
-void
-__kmp_str_buf_vprint(
-    kmp_str_buf_t *  buffer,
-    char const *     format,
-    va_list          args
-) {
-
-    KMP_STR_BUF_INVARIANT( buffer );
-
-    for ( ; ; ) {
-
-        int const free = buffer->size - buffer->used;
-        int       rc;
-        int       size;
-
-        // Try to format string.
-        {
-            /*
-                On Linux* OS Intel(R) 64, vsnprintf() modifies args argument, so vsnprintf() crashes if it
-                is called for the second time with the same args. To prevent the crash, we have to
-                pass a fresh intact copy of args to vsnprintf() on each iteration.
-
-                Unfortunately, standard va_copy() macro is not available on Windows* OS. However, it
-                seems vsnprintf() does not modify args argument on Windows* OS.
-            */
-
-            #if ! KMP_OS_WINDOWS
-                va_list _args;
-                __va_copy( _args, args );  // Make copy of args.
-                #define args _args         // Substitute args with its copy, _args.
-            #endif // KMP_OS_WINDOWS
-            rc = KMP_VSNPRINTF( buffer->str + buffer->used, free, format, args );
-            #if ! KMP_OS_WINDOWS
-                #undef args                // Remove substitution.
-                va_end( _args );
-            #endif // KMP_OS_WINDOWS
-        }
-
-        // No errors, string has been formatted.
-        if ( rc >= 0 && rc < free ) {
-            buffer->used += rc;
-            break;
-        }; // if
-
-        // Error occurred, buffer is too small.
-        if ( rc >= 0 ) {
-            // C99-conforming implementation of vsnprintf returns required buffer size.
-            size = buffer->used + rc + 1;
-        } else {
-            // Older implementations just return -1. Double buffer size.
-            size = buffer->size * 2;
-        }; // if
-
-        // Enlarge buffer.
-        __kmp_str_buf_reserve( buffer, size );
-
-        // And try again.
-
-    }; // forever
-
-    KMP_DEBUG_ASSERT( buffer->size > 0 );
-    KMP_STR_BUF_INVARIANT( buffer );
-
-} // __kmp_str_buf_vprint
-
-
-void
-__kmp_str_buf_print(
-    kmp_str_buf_t *  buffer,
-    char const *     format,
-    ...
-) {
-
-    va_list args;
-    va_start( args, format );
-    __kmp_str_buf_vprint( buffer, format, args );
-    va_end( args );
-
-} // __kmp_str_buf_print
-
-
-/*
-    The function prints specified size to buffer. Size is expressed using biggest possible unit, for
-    example 1024 is printed as "1k".
-*/
-
-void
-__kmp_str_buf_print_size(
-    kmp_str_buf_t * buf,
-    size_t          size
-) {
-
-    char const * names[] = { "", "k", "M", "G", "T", "P", "E", "Z", "Y" };
-    int const    units   = sizeof( names ) / sizeof( char const * );
-    int          u       = 0;
-    if ( size > 0 ) {
-        while ( ( size % 1024 == 0 ) && ( u + 1 < units ) ) {
-            size = size / 1024;
-            ++ u;
-        }; // while
-    }; // if
-
-    __kmp_str_buf_print( buf, "%" KMP_SIZE_T_SPEC "%s", size, names[ u ] );
-
-} // __kmp_str_buf_print_size
-
-
-void
-__kmp_str_fname_init(
-    kmp_str_fname_t * fname,
-    char const *      path
-) {
-
-    fname->path = NULL;
-    fname->dir  = NULL;
-    fname->base = NULL;
-
-    if ( path != NULL ) {
-        char * slash = NULL;    // Pointer to the last character of dir.
-        char * base  = NULL;    // Pointer to the beginning of basename.
-        fname->path = __kmp_str_format( "%s", path );
-            // Original code used strdup() function to copy a string, but on Windows* OS Intel(R) 64 it
-            // causes assertioon id debug heap, so I had to replace strdup with __kmp_str_format().
-        if ( KMP_OS_WINDOWS ) {
-            __kmp_str_replace( fname->path, '\\', '/' );
-        }; // if
-        fname->dir = __kmp_str_format( "%s", fname->path );
-        slash = strrchr( fname->dir, '/' );
-        if ( KMP_OS_WINDOWS && slash == NULL ) {           // On Windows* OS, if slash not found,
-            char first = TOLOWER( fname->dir[ 0 ] );     // look for drive.
-            if ( 'a' <= first && first <= 'z' && fname->dir[ 1 ] == ':' ) {
-                slash = & fname->dir[ 1 ];
-            }; // if
-        }; // if
-        base = ( slash == NULL ? fname->dir : slash + 1 );
-        fname->base = __kmp_str_format( "%s", base );    // Copy basename
-        * base = 0;                    // and truncate dir.
-    }; // if
-
-} // kmp_str_fname_init
-
-
-void
-__kmp_str_fname_free(
-    kmp_str_fname_t * fname
-) {
-    __kmp_str_free( (char const **)( & fname->path ) );
-    __kmp_str_free( (char const **)( & fname->dir  ) );
-    __kmp_str_free( (char const **)( & fname->base ) );
-} // kmp_str_fname_free
-
-
-int
-__kmp_str_fname_match(
-    kmp_str_fname_t const * fname,
-    char const *            pattern
-) {
-
-    int dir_match  = 1;
-    int base_match = 1;
-
-    if ( pattern != NULL ) {
-        kmp_str_fname_t ptrn;
-        __kmp_str_fname_init( & ptrn, pattern );
-        dir_match =
-            strcmp( ptrn.dir, "*/" ) == 0
-            ||
-            ( fname->dir != NULL && __kmp_str_eqf( fname->dir, ptrn.dir ) );
-        base_match =
-            strcmp( ptrn.base, "*" ) == 0
-            ||
-            ( fname->base != NULL && __kmp_str_eqf( fname->base, ptrn.base ) );
-        __kmp_str_fname_free( & ptrn );
-    }; // if
-
-    return dir_match && base_match;
-
-} // __kmp_str_fname_match
-
-
-kmp_str_loc_t
-__kmp_str_loc_init(
-    char const * psource,
-    int          init_fname
-) {
-
-    kmp_str_loc_t loc;
-
-    loc._bulk = NULL;
-    loc.file  = NULL;
-    loc.func  = NULL;
-    loc.line  = 0;
-    loc.col   = 0;
-
-    if ( psource != NULL ) {
-
-        char * str   = NULL;
-        char * dummy = NULL;
-        char * line  = NULL;
-        char * col   = NULL;
-
-        // Copy psource to keep it intact.
-        loc._bulk = __kmp_str_format( "%s", psource );
-
-        // Parse psource string: ";file;func;line;col;;"
-        str = loc._bulk;
-        __kmp_str_split( str, ';', & dummy,    & str );
-        __kmp_str_split( str, ';', & loc.file, & str );
-        __kmp_str_split( str, ';', & loc.func, & str );
-        __kmp_str_split( str, ';', & line,     & str );
-        __kmp_str_split( str, ';', & col,      & str );
-
-        // Convert line and col into numberic values.
-        if ( line != NULL ) {
-            loc.line = atoi( line );
-            if ( loc.line < 0 ) {
-                loc.line = 0;
-            }; // if
-        }; // if
-        if ( col != NULL ) {
-            loc.col = atoi( col );
-            if ( loc.col < 0 ) {
-                loc.col = 0;
-            }; // if
-        }; // if
-
-    }; // if
-
-    __kmp_str_fname_init( & loc.fname, init_fname ? loc.file : NULL );
-
-    return loc;
-
-} // kmp_str_loc_init
-
-
-void
-__kmp_str_loc_free(
-    kmp_str_loc_t * loc
-) {
-    __kmp_str_fname_free( & loc->fname );
-    KMP_INTERNAL_FREE( loc->_bulk );
-    loc->_bulk = NULL;
-    loc->file  = NULL;
-    loc->func  = NULL;
-} // kmp_str_loc_free
-
-
-
-/*
-    This function is intended to compare file names. On Windows* OS file names are case-insensitive,
-    so functions performs case-insensitive comparison. On Linux* OS it performs case-sensitive
-    comparison.
-    Note: The function returns *true* if strings are *equal*.
-*/
-
-int
-__kmp_str_eqf(         // True, if strings are equal, false otherwise.
-    char const * lhs,  // First string.
-    char const * rhs   // Second string.
-) {
-    int result;
-    #if KMP_OS_WINDOWS
-        result = ( _stricmp( lhs, rhs ) == 0 );
-    #else
-        result = ( strcmp( lhs, rhs ) == 0 );
-    #endif
-    return result;
-} // __kmp_str_eqf
-
-
-/*
-    This function is like sprintf, but it *allocates* new buffer, which must be freed eventually by
-    __kmp_str_free(). The function is very convenient for constructing strings, it successfully
-    replaces strdup(), strcat(), it frees programmer from buffer allocations and helps to avoid
-    buffer overflows. Examples:
-
-        str = __kmp_str_format( "%s", orig );              // strdup(), do not care about buffer size.
-        __kmp_str_free( & str );
-        str = __kmp_str_format( "%s%s", orig1, orig2 );    // strcat(), do not care about buffer size.
-        __kmp_str_free( & str );
-        str = __kmp_str_format( "%s/%s.txt", path, file ); // constructing string.
-        __kmp_str_free( & str );
-
-    Performance note:
-        This function allocates memory with malloc() calls, so do not call it from
-        performance-critical code. In performance-critical code consider using kmp_str_buf_t
-        instead, since it uses stack-allocated buffer for short strings.
-
-    Why does this function use malloc()?
-        1. __kmp_allocate() returns cache-aligned memory allocated with malloc(). There are no
-           reasons in using __kmp_allocate() for strings due to extra overhead while cache-aligned
-           memory is not necessary.
-        2. __kmp_thread_malloc() cannot be used because it requires pointer to thread structure.
-           We need to perform string operations during library startup (for example, in
-           __kmp_register_library_startup()) when no thread structures are allocated yet.
-    So standard malloc() is the only available option.
-*/
-
-// TODO: Find and replace all regular free() with __kmp_str_free().
-
-char *
-__kmp_str_format(           // Allocated string.
-    char const * format,    // Format string.
-    ...                     // Other parameters.
-) {
-
-    va_list args;
-    int     size   = 512;
-    char *  buffer = NULL;
-    int     rc;
-
-    // Allocate buffer.
-    buffer = (char *) KMP_INTERNAL_MALLOC( size );
-    if ( buffer == NULL ) {
-	KMP_FATAL( MemoryAllocFailed );
-    }; // if
-
-    for ( ; ; ) {
-
-        // Try to format string.
-        va_start( args, format );
-        rc = KMP_VSNPRINTF( buffer, size, format, args );
-        va_end( args );
-
-        // No errors, string has been formatted.
-        if ( rc >= 0 && rc < size ) {
-            break;
-        }; // if
-
-        // Error occurred, buffer is too small.
-        if ( rc >= 0 ) {
-            // C99-conforming implementation of vsnprintf returns required buffer size.
-            size = rc + 1;
-        } else {
-            // Older implementations just return -1.
-            size = size * 2;
-        }; // if
-
-        // Enlarge buffer and try again.
-        buffer = (char *) KMP_INTERNAL_REALLOC( buffer, size );
-        if ( buffer == NULL ) {
-    	    KMP_FATAL( MemoryAllocFailed );
-        }; // if
-
-    }; // forever
-
-    return buffer;
-
-} // func __kmp_str_format
-
-
-void
-__kmp_str_free(
-    char const * * str
-) {
-    KMP_DEBUG_ASSERT( str != NULL );
-    KMP_INTERNAL_FREE( (void *) * str );
-    * str = NULL;
-} // func __kmp_str_free
-
-
-/* If len is zero, returns true iff target and data have exact case-insensitive match.
-   If len is negative, returns true iff target is a case-insensitive substring of data.
-   If len is positive, returns true iff target is a case-insensitive substring of data or
-     vice versa, and neither is shorter than len.
-*/
-int
-__kmp_str_match(
-    char const * target,
-    int          len,
-    char const * data
-) {
-    int i;
-    if ( target == NULL || data == NULL ) {
-        return FALSE;
-    }; // if
-    for ( i = 0; target[i] && data[i]; ++ i ) {
-        if ( TOLOWER( target[i] ) != TOLOWER( data[i] ) ) {
-            return FALSE;
-        }; // if
-    }; // for i
-    return ( ( len > 0 ) ? i >= len : ( ! target[i] && ( len || ! data[i] ) ) );
-} // __kmp_str_match
-
-
-int
-__kmp_str_match_false( char const * data ) {
-    int result =
-        __kmp_str_match( "false",   1, data ) ||
-        __kmp_str_match( "off",     2, data ) ||
-        __kmp_str_match( "0",       1, data ) ||
-        __kmp_str_match( ".false.", 2, data ) ||
-        __kmp_str_match( ".f.",     2, data ) ||
-        __kmp_str_match( "no",      1, data );
-    return result;
-} // __kmp_str_match_false
-
-
-int
-__kmp_str_match_true( char const * data ) {
-    int result =
-        __kmp_str_match( "true",   1, data ) ||
-        __kmp_str_match( "on",     2, data ) ||
-        __kmp_str_match( "1",      1, data ) ||
-        __kmp_str_match( ".true.", 2, data ) ||
-        __kmp_str_match( ".t.",    2, data ) ||
-        __kmp_str_match( "yes",    1, data );
-    return result;
-} // __kmp_str_match_true
-
-void
-__kmp_str_replace(
-    char * str,
-    char   search_for,
-    char   replace_with
-) {
-
-    char * found = NULL;
-
-    found = strchr( str, search_for );
-    while ( found ) {
-        * found = replace_with;
-        found = strchr( found + 1, search_for );
-    }; // while
-
-} // __kmp_str_replace
-
-
-void
-__kmp_str_split(
-    char *  str,    // I: String to split.
-    char    delim,  // I: Character to split on.
-    char ** head,   // O: Pointer to head (may be NULL).
-    char ** tail    // O: Pointer to tail (may be NULL).
-) {
-    char * h = str;
-    char * t = NULL;
-    if ( str != NULL ) {
-        char * ptr = strchr( str, delim );
-        if ( ptr != NULL ) {
-            * ptr  = 0;
-            t = ptr + 1;
-        }; // if
-    }; // if
-    if ( head != NULL ) {
-        * head = h;
-    }; // if
-    if ( tail != NULL ) {
-        * tail = t;
-    }; // if
-} // __kmp_str_split
-
-/*
-    strtok_r() is not available on Windows* OS. This function reimplements strtok_r().
-*/
-char *
-__kmp_str_token(
-    char *       str,   // String to split into tokens. Note: String *is* modified!
-    char const * delim, // Delimiters.
-    char **      buf    // Internal buffer.
-) {
-    char * token = NULL;
-    #if KMP_OS_WINDOWS
-        // On Windows* OS there is no strtok_r() function. Let us implement it.
-        if ( str != NULL ) {
-            * buf = str;                       // First call, initialize buf.
-        }; // if
-        * buf += strspn( * buf, delim );       // Skip leading delimiters.
-        if ( ** buf != 0 ) {                   // Rest of the string is not yet empty.
-            token = * buf;                     // Use it as result.
-            * buf += strcspn( * buf, delim );  // Skip non-delimiters.
-            if ( ** buf != 0 ) {               // Rest of the string is not yet empty.
-                ** buf = 0;                    // Terminate token here.
-                * buf += 1;                    // Advance buf to start with the next token next time.
-            }; // if
-        }; // if
-    #else
-        // On Linux* OS and OS X*, strtok_r() is available. Let us use it.
-        token = strtok_r( str, delim, buf );
-    #endif
-    return token;
-}; // __kmp_str_token
-
-
-int
-__kmp_str_to_int(
-    char const * str,
-    char         sentinel
-) {
-    int result, factor;
-    char const * t;
-
-    result = 0;
-
-    for (t = str; *t != '\0'; ++t) {
-        if (*t < '0' || *t > '9')
-            break;
-        result = (result * 10) + (*t - '0');
-    }
-
-    switch (*t) {
-    case '\0':          /* the current default for no suffix is bytes */
-	factor = 1;
-        break;
-    case 'b': case 'B': /* bytes */
-	++t;
-	factor = 1;
-        break;
-    case 'k': case 'K': /* kilo-bytes */
-	++t;
-	factor = 1024;
-        break;
-    case 'm': case 'M': /* mega-bytes */
-	++t;
-	factor = (1024 * 1024);
-        break;
-    default:
-	if(*t != sentinel)
-	    return (-1);
-	t = "";
-	factor = 1;
-    }
-
-    if (result > (INT_MAX / factor))
-	result = INT_MAX;
-    else
-	result *= factor;
-
-    return (*t != 0 ? 0 : result);
-
-} // __kmp_str_to_int
-
-
-/*
-    The routine parses input string. It is expected it is a unsigned integer with optional unit.
-    Units are: "b" for bytes, "kb" or just "k" for kilobytes, "mb" or "m" for megabytes, ..., "yb"
-    or "y" for yottabytes. :-) Unit name is case-insensitive. The routine returns 0 if everything is
-    ok, or error code: -1 in case of overflow, -2 in case of unknown unit. *size is set to parsed
-    value. In case of overflow *size is set to KMP_SIZE_T_MAX, in case of unknown unit *size is set
-    to zero.
-*/
-void
-__kmp_str_to_size(         // R: Error code.
-    char const *   str,    // I: String of characters, unsigned number and unit ("b", "kb", etc).
-    size_t *       out,    // O: Parsed number.
-    size_t         dfactor, // I: The factor if none of the letters specified.
-    char const * * error   // O: Null if everything is ok, error message otherwise.
-) {
-
-    size_t value    = 0;
-    size_t factor   = 0;
-    int    overflow = 0;
-    int    i        = 0;
-    int    digit;
-
-
-    KMP_DEBUG_ASSERT( str != NULL );
-
-    // Skip spaces.
-    while ( str[ i ] == ' ' || str[ i ] == '\t') {
-        ++ i;
-    }; // while
-
-    // Parse number.
-    if ( str[ i ] < '0' || str[ i ] > '9' ) {
-        * error = KMP_I18N_STR( NotANumber );
-        return;
-    }; // if
-    do {
-        digit = str[ i ] - '0';
-        overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 );
-        value = ( value * 10 ) + digit;
-        ++ i;
-    } while ( str[ i ] >= '0' && str[ i ] <= '9' );
-
-    // Skip spaces.
-    while ( str[ i ] == ' ' || str[ i ] == '\t' ) {
-        ++ i;
-    }; // while
-
-    // Parse unit.
-    #define _case( ch, exp )                            \
-        case ch :                                       \
-        case ch - ( 'a' - 'A' ) : {                     \
-            size_t shift = (exp) * 10;                  \
-            ++ i;                                       \
-            if ( shift < sizeof( size_t ) * 8 ) {       \
-                factor = (size_t)( 1 ) << shift;        \
-            } else {                                    \
-                overflow = 1;                           \
-            };                                          \
-        } break;
-    switch ( str[ i ] ) {
-        _case( 'k', 1 ); // Kilo
-        _case( 'm', 2 ); // Mega
-        _case( 'g', 3 ); // Giga
-        _case( 't', 4 ); // Tera
-        _case( 'p', 5 ); // Peta
-        _case( 'e', 6 ); // Exa
-        _case( 'z', 7 ); // Zetta
-        _case( 'y', 8 ); // Yotta
-        // Oops. No more units...
-    }; // switch
-    #undef _case
-    if ( str[ i ] == 'b' || str[ i ] == 'B' ) {    // Skip optional "b".
-	if ( factor == 0 ) {
-	    factor = 1;
-	}
-        ++ i;
-    }; // if
-    if ( ! ( str[ i ] == ' ' || str[ i ] == '\t' || str[ i ] == 0 ) ) { // Bad unit
-        * error = KMP_I18N_STR( BadUnit );
-        return;
-    }; // if
-
-    if ( factor == 0 ) {
-	factor = dfactor;
-    }
-
-    // Apply factor.
-    overflow = overflow || ( value > ( KMP_SIZE_T_MAX / factor ) );
-    value *= factor;
-
-    // Skip spaces.
-    while ( str[ i ] == ' ' || str[ i ] == '\t' ) {
-        ++ i;
-    }; // while
-
-    if ( str[ i ] != 0 ) {
-        * error = KMP_I18N_STR( IllegalCharacters );
-        return;
-    }; // if
-
-    if ( overflow ) {
-        * error = KMP_I18N_STR( ValueTooLarge );
-        * out = KMP_SIZE_T_MAX;
-        return;
-    }; // if
-
-    * error = NULL;
-    * out = value;
-
-} // __kmp_str_to_size
-
-
-void
-__kmp_str_to_uint(         // R: Error code.
-    char const *   str,    // I: String of characters, unsigned number.
-    kmp_uint64 *   out,    // O: Parsed number.
-    char const * * error   // O: Null if everything is ok, error message otherwise.
-) {
-
-    size_t value    = 0;
-    int    overflow = 0;
-    int    i        = 0;
-    int    digit;
-
-
-    KMP_DEBUG_ASSERT( str != NULL );
-
-    // Skip spaces.
-    while ( str[ i ] == ' ' || str[ i ] == '\t' ) {
-        ++ i;
-    }; // while
-
-    // Parse number.
-    if ( str[ i ] < '0' || str[ i ] > '9' ) {
-        * error = KMP_I18N_STR( NotANumber );
-        return;
-    }; // if
-    do {
-        digit = str[ i ] - '0';
-        overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 );
-        value = ( value * 10 ) + digit;
-        ++ i;
-    } while ( str[ i ] >= '0' && str[ i ] <= '9' );
-
-    // Skip spaces.
-    while ( str[ i ] == ' ' || str[ i ] == '\t' ) {
-        ++ i;
-    }; // while
-
-    if ( str[ i ] != 0 ) {
-        * error = KMP_I18N_STR( IllegalCharacters );
-        return;
-    }; // if
-
-    if ( overflow ) {
-        * error = KMP_I18N_STR( ValueTooLarge );
-        * out = (kmp_uint64) -1;
-        return;
-    }; // if
-
-    * error = NULL;
-    * out = value;
-
-} // __kmp_str_to_unit
-
-
-
-// end of file //
+/* 
+ * kmp_str.c -- String manipulation routines. 
+ */ 
+ 
+ 
+//===----------------------------------------------------------------------===// 
+// 
+//                     The LLVM Compiler Infrastructure 
+// 
+// This file is dual licensed under the MIT and the University of Illinois Open 
+// Source Licenses. See LICENSE.txt for details. 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+ 
+#include "kmp_str.h" 
+ 
+#include <stdarg.h>    // va_* 
+#include <stdio.h>     // vsnprintf() 
+#include <stdlib.h>    // malloc(), realloc() 
+ 
+#include "kmp.h" 
+#include "kmp_i18n.h" 
+ 
+/* 
+    ------------------------------------------------------------------------------------------------ 
+    String buffer. 
+    ------------------------------------------------------------------------------------------------ 
+ 
+    Usage: 
+ 
+        // Declare buffer and initialize it. 
+        kmp_str_buf_t  buffer; 
+	__kmp_str_buf_init( & buffer ); 
+ 
+        // Print to buffer. 
+        __kmp_str_buf_print( & buffer, "Error in file \"%s\" line %d\n", "foo.c", 12 ); 
+        __kmp_str_buf_print( & buffer, "    <%s>\n", line ); 
+ 
+        // Use buffer contents. buffer.str is a pointer to data, buffer.used is a number of printed 
+        // characters (not including terminating zero). 
+        write( fd, buffer.str, buffer.used ); 
+ 
+        // Free buffer. 
+        __kmp_str_buf_free( & buffer ); 
+ 
+        // Alternatively, you can detach allocated memory from buffer: 
+        __kmp_str_buf_detach( & buffer ); 
+        return buffer.str;    // That memory should be freed eventually. 
+ 
+ 
+    Notes: 
+ 
+        * Buffer users may use buffer.str and buffer.used. Users should not change any fields of 
+          buffer directly. 
+ 
+        * buffer.str is never NULL. If buffer is empty, buffer.str points to empty string (""). 
+ 
+        * For performance reasons, buffer uses stack memory (buffer.bulk) first. If stack memory is 
+          exhausted, buffer allocates memory on heap by malloc(), and reallocates it by realloc() 
+          as amount of used memory grows. 
+ 
+        * Buffer doubles amount of allocated memory each time it is exhausted. 
+ 
+    ------------------------------------------------------------------------------------------------ 
+*/ 
+ 
+// TODO: __kmp_str_buf_print() can use thread local memory allocator. 
+ 
+#define KMP_STR_BUF_INVARIANT( b )                                                                \ 
+    {                                                                                             \ 
+        KMP_DEBUG_ASSERT( (b)->str != NULL );                                                     \ 
+        KMP_DEBUG_ASSERT( (b)->size >= sizeof( (b)->bulk ) );                                     \ 
+        KMP_DEBUG_ASSERT( (b)->size % sizeof( (b)->bulk ) == 0 );                                 \ 
+        KMP_DEBUG_ASSERT( (unsigned)(b)->used < (b)->size );                                      \ 
+        KMP_DEBUG_ASSERT( (b)->size == sizeof( (b)->bulk ) ? (b)->str == & (b)->bulk[ 0 ] : 1 );  \ 
+        KMP_DEBUG_ASSERT( (b)->size > sizeof( (b)->bulk ) ? (b)->str != & (b)->bulk[ 0 ] : 1 );   \ 
+    } 
+ 
+void 
+ __kmp_str_buf_clear( 
+     kmp_str_buf_t * buffer 
+) { 
+    KMP_STR_BUF_INVARIANT( buffer ); 
+    if ( buffer->used > 0 ) { 
+        buffer->used = 0; 
+        buffer->str[ 0 ] = 0; 
+    }; // if 
+    KMP_STR_BUF_INVARIANT( buffer ); 
+} // __kmp_str_buf_clear 
+ 
+ 
+void 
+__kmp_str_buf_reserve( 
+    kmp_str_buf_t * buffer, 
+    int             size 
+) { 
+ 
+    KMP_STR_BUF_INVARIANT( buffer ); 
+    KMP_DEBUG_ASSERT( size >= 0 ); 
+ 
+    if ( buffer->size < (unsigned int)size ) { 
+ 
+        // Calculate buffer size. 
+        do { 
+            buffer->size *= 2; 
+        } while ( buffer->size < (unsigned int)size ); 
+ 
+        // Enlarge buffer. 
+        if ( buffer->str == & buffer->bulk[ 0 ] ) { 
+            buffer->str = (char *) KMP_INTERNAL_MALLOC( buffer->size ); 
+            if ( buffer->str == NULL ) { 
+		KMP_FATAL( MemoryAllocFailed ); 
+            }; // if 
+            KMP_MEMCPY_S( buffer->str, buffer->size, buffer->bulk, buffer->used + 1 ); 
+        } else { 
+            buffer->str = (char *) KMP_INTERNAL_REALLOC( buffer->str, buffer->size ); 
+            if ( buffer->str == NULL ) { 
+		KMP_FATAL( MemoryAllocFailed ); 
+            }; // if 
+        }; // if 
+ 
+    }; // if 
+ 
+    KMP_DEBUG_ASSERT( buffer->size > 0 ); 
+    KMP_DEBUG_ASSERT( buffer->size >= (unsigned)size ); 
+    KMP_STR_BUF_INVARIANT( buffer ); 
+ 
+} // __kmp_str_buf_reserve 
+ 
+ 
+void 
+__kmp_str_buf_detach( 
+    kmp_str_buf_t *  buffer 
+) { 
+ 
+    KMP_STR_BUF_INVARIANT( buffer ); 
+ 
+    // If internal bulk is used, allocate memory and copy it. 
+    if ( buffer->size <= sizeof( buffer->bulk ) ) { 
+        buffer->str = (char *) KMP_INTERNAL_MALLOC( buffer->size ); 
+        if ( buffer->str == NULL ) { 
+		KMP_FATAL( MemoryAllocFailed ); 
+        }; // if 
+        KMP_MEMCPY_S( buffer->str, buffer->size, buffer->bulk, buffer->used + 1 ); 
+    }; // if 
+ 
+} // __kmp_str_buf_detach 
+ 
+ 
+void 
+__kmp_str_buf_free( 
+    kmp_str_buf_t * buffer 
+) { 
+    KMP_STR_BUF_INVARIANT( buffer ); 
+    if ( buffer->size > sizeof( buffer->bulk ) ) { 
+        KMP_INTERNAL_FREE( buffer->str ); 
+    }; // if 
+    buffer->str  = buffer->bulk; 
+    buffer->size = sizeof( buffer->bulk ); 
+    buffer->used = 0; 
+    KMP_STR_BUF_INVARIANT( buffer ); 
+} // __kmp_str_buf_free 
+ 
+ 
+void 
+__kmp_str_buf_cat( 
+    kmp_str_buf_t * buffer, 
+    char const *    str, 
+    int             len 
+) { 
+    KMP_STR_BUF_INVARIANT( buffer ); 
+    KMP_DEBUG_ASSERT( str != NULL ); 
+    KMP_DEBUG_ASSERT( len >= 0 ); 
+    __kmp_str_buf_reserve( buffer, buffer->used + len + 1 ); 
+    KMP_MEMCPY( buffer->str + buffer->used, str, len ); 
+    buffer->str[ buffer->used + len ] = 0; 
+    buffer->used += len; 
+    KMP_STR_BUF_INVARIANT( buffer ); 
+} // __kmp_str_buf_cat 
+ 
+ 
+void 
+__kmp_str_buf_vprint( 
+    kmp_str_buf_t *  buffer, 
+    char const *     format, 
+    va_list          args 
+) { 
+ 
+    KMP_STR_BUF_INVARIANT( buffer ); 
+ 
+    for ( ; ; ) { 
+ 
+        int const free = buffer->size - buffer->used; 
+        int       rc; 
+        int       size; 
+ 
+        // Try to format string. 
+        { 
+            /* 
+                On Linux* OS Intel(R) 64, vsnprintf() modifies args argument, so vsnprintf() crashes if it 
+                is called for the second time with the same args. To prevent the crash, we have to 
+                pass a fresh intact copy of args to vsnprintf() on each iteration. 
+ 
+                Unfortunately, standard va_copy() macro is not available on Windows* OS. However, it 
+                seems vsnprintf() does not modify args argument on Windows* OS. 
+            */ 
+ 
+            #if ! KMP_OS_WINDOWS 
+                va_list _args; 
+                __va_copy( _args, args );  // Make copy of args. 
+                #define args _args         // Substitute args with its copy, _args. 
+            #endif // KMP_OS_WINDOWS 
+            rc = KMP_VSNPRINTF( buffer->str + buffer->used, free, format, args ); 
+            #if ! KMP_OS_WINDOWS 
+                #undef args                // Remove substitution. 
+                va_end( _args ); 
+            #endif // KMP_OS_WINDOWS 
+        } 
+ 
+        // No errors, string has been formatted. 
+        if ( rc >= 0 && rc < free ) { 
+            buffer->used += rc; 
+            break; 
+        }; // if 
+ 
+        // Error occurred, buffer is too small. 
+        if ( rc >= 0 ) { 
+            // C99-conforming implementation of vsnprintf returns required buffer size. 
+            size = buffer->used + rc + 1; 
+        } else { 
+            // Older implementations just return -1. Double buffer size. 
+            size = buffer->size * 2; 
+        }; // if 
+ 
+        // Enlarge buffer. 
+        __kmp_str_buf_reserve( buffer, size ); 
+ 
+        // And try again. 
+ 
+    }; // forever 
+ 
+    KMP_DEBUG_ASSERT( buffer->size > 0 ); 
+    KMP_STR_BUF_INVARIANT( buffer ); 
+ 
+} // __kmp_str_buf_vprint 
+ 
+ 
+void 
+__kmp_str_buf_print( 
+    kmp_str_buf_t *  buffer, 
+    char const *     format, 
+    ... 
+) { 
+ 
+    va_list args; 
+    va_start( args, format ); 
+    __kmp_str_buf_vprint( buffer, format, args ); 
+    va_end( args ); 
+ 
+} // __kmp_str_buf_print 
+ 
+ 
+/* 
+    The function prints specified size to buffer. Size is expressed using biggest possible unit, for 
+    example 1024 is printed as "1k". 
+*/ 
+ 
+void 
+__kmp_str_buf_print_size( 
+    kmp_str_buf_t * buf, 
+    size_t          size 
+) { 
+ 
+    char const * names[] = { "", "k", "M", "G", "T", "P", "E", "Z", "Y" }; 
+    int const    units   = sizeof( names ) / sizeof( char const * ); 
+    int          u       = 0; 
+    if ( size > 0 ) { 
+        while ( ( size % 1024 == 0 ) && ( u + 1 < units ) ) { 
+            size = size / 1024; 
+            ++ u; 
+        }; // while 
+    }; // if 
+ 
+    __kmp_str_buf_print( buf, "%" KMP_SIZE_T_SPEC "%s", size, names[ u ] ); 
+ 
+} // __kmp_str_buf_print_size 
+ 
+ 
+void 
+__kmp_str_fname_init( 
+    kmp_str_fname_t * fname, 
+    char const *      path 
+) { 
+ 
+    fname->path = NULL; 
+    fname->dir  = NULL; 
+    fname->base = NULL; 
+ 
+    if ( path != NULL ) { 
+        char * slash = NULL;    // Pointer to the last character of dir. 
+        char * base  = NULL;    // Pointer to the beginning of basename. 
+        fname->path = __kmp_str_format( "%s", path ); 
+            // Original code used strdup() function to copy a string, but on Windows* OS Intel(R) 64 it 
+            // causes assertioon id debug heap, so I had to replace strdup with __kmp_str_format(). 
+        if ( KMP_OS_WINDOWS ) { 
+            __kmp_str_replace( fname->path, '\\', '/' ); 
+        }; // if 
+        fname->dir = __kmp_str_format( "%s", fname->path ); 
+        slash = strrchr( fname->dir, '/' ); 
+        if ( KMP_OS_WINDOWS && slash == NULL ) {           // On Windows* OS, if slash not found, 
+            char first = TOLOWER( fname->dir[ 0 ] );     // look for drive. 
+            if ( 'a' <= first && first <= 'z' && fname->dir[ 1 ] == ':' ) { 
+                slash = & fname->dir[ 1 ]; 
+            }; // if 
+        }; // if 
+        base = ( slash == NULL ? fname->dir : slash + 1 ); 
+        fname->base = __kmp_str_format( "%s", base );    // Copy basename 
+        * base = 0;                    // and truncate dir. 
+    }; // if 
+ 
+} // kmp_str_fname_init 
+ 
+ 
+void 
+__kmp_str_fname_free( 
+    kmp_str_fname_t * fname 
+) { 
+    __kmp_str_free( (char const **)( & fname->path ) ); 
+    __kmp_str_free( (char const **)( & fname->dir  ) ); 
+    __kmp_str_free( (char const **)( & fname->base ) ); 
+} // kmp_str_fname_free 
+ 
+ 
+int 
+__kmp_str_fname_match( 
+    kmp_str_fname_t const * fname, 
+    char const *            pattern 
+) { 
+ 
+    int dir_match  = 1; 
+    int base_match = 1; 
+ 
+    if ( pattern != NULL ) { 
+        kmp_str_fname_t ptrn; 
+        __kmp_str_fname_init( & ptrn, pattern ); 
+        dir_match = 
+            strcmp( ptrn.dir, "*/" ) == 0 
+            || 
+            ( fname->dir != NULL && __kmp_str_eqf( fname->dir, ptrn.dir ) ); 
+        base_match = 
+            strcmp( ptrn.base, "*" ) == 0 
+            || 
+            ( fname->base != NULL && __kmp_str_eqf( fname->base, ptrn.base ) ); 
+        __kmp_str_fname_free( & ptrn ); 
+    }; // if 
+ 
+    return dir_match && base_match; 
+ 
+} // __kmp_str_fname_match 
+ 
+ 
+kmp_str_loc_t 
+__kmp_str_loc_init( 
+    char const * psource, 
+    int          init_fname 
+) { 
+ 
+    kmp_str_loc_t loc; 
+ 
+    loc._bulk = NULL; 
+    loc.file  = NULL; 
+    loc.func  = NULL; 
+    loc.line  = 0; 
+    loc.col   = 0; 
+ 
+    if ( psource != NULL ) { 
+ 
+        char * str   = NULL; 
+        char * dummy = NULL; 
+        char * line  = NULL; 
+        char * col   = NULL; 
+ 
+        // Copy psource to keep it intact. 
+        loc._bulk = __kmp_str_format( "%s", psource ); 
+ 
+        // Parse psource string: ";file;func;line;col;;" 
+        str = loc._bulk; 
+        __kmp_str_split( str, ';', & dummy,    & str ); 
+        __kmp_str_split( str, ';', & loc.file, & str ); 
+        __kmp_str_split( str, ';', & loc.func, & str ); 
+        __kmp_str_split( str, ';', & line,     & str ); 
+        __kmp_str_split( str, ';', & col,      & str ); 
+ 
+        // Convert line and col into numberic values. 
+        if ( line != NULL ) { 
+            loc.line = atoi( line ); 
+            if ( loc.line < 0 ) { 
+                loc.line = 0; 
+            }; // if 
+        }; // if 
+        if ( col != NULL ) { 
+            loc.col = atoi( col ); 
+            if ( loc.col < 0 ) { 
+                loc.col = 0; 
+            }; // if 
+        }; // if 
+ 
+    }; // if 
+ 
+    __kmp_str_fname_init( & loc.fname, init_fname ? loc.file : NULL ); 
+ 
+    return loc; 
+ 
+} // kmp_str_loc_init 
+ 
+ 
+void 
+__kmp_str_loc_free( 
+    kmp_str_loc_t * loc 
+) { 
+    __kmp_str_fname_free( & loc->fname ); 
+    KMP_INTERNAL_FREE( loc->_bulk ); 
+    loc->_bulk = NULL; 
+    loc->file  = NULL; 
+    loc->func  = NULL; 
+} // kmp_str_loc_free 
+ 
+ 
+ 
+/* 
+    This function is intended to compare file names. On Windows* OS file names are case-insensitive, 
+    so functions performs case-insensitive comparison. On Linux* OS it performs case-sensitive 
+    comparison. 
+    Note: The function returns *true* if strings are *equal*. 
+*/ 
+ 
+int 
+__kmp_str_eqf(         // True, if strings are equal, false otherwise. 
+    char const * lhs,  // First string. 
+    char const * rhs   // Second string. 
+) { 
+    int result; 
+    #if KMP_OS_WINDOWS 
+        result = ( _stricmp( lhs, rhs ) == 0 ); 
+    #else 
+        result = ( strcmp( lhs, rhs ) == 0 ); 
+    #endif 
+    return result; 
+} // __kmp_str_eqf 
+ 
+ 
+/* 
+    This function is like sprintf, but it *allocates* new buffer, which must be freed eventually by 
+    __kmp_str_free(). The function is very convenient for constructing strings, it successfully 
+    replaces strdup(), strcat(), it frees programmer from buffer allocations and helps to avoid 
+    buffer overflows. Examples: 
+ 
+        str = __kmp_str_format( "%s", orig );              // strdup(), do not care about buffer size. 
+        __kmp_str_free( & str ); 
+        str = __kmp_str_format( "%s%s", orig1, orig2 );    // strcat(), do not care about buffer size. 
+        __kmp_str_free( & str ); 
+        str = __kmp_str_format( "%s/%s.txt", path, file ); // constructing string. 
+        __kmp_str_free( & str ); 
+ 
+    Performance note: 
+        This function allocates memory with malloc() calls, so do not call it from 
+        performance-critical code. In performance-critical code consider using kmp_str_buf_t 
+        instead, since it uses stack-allocated buffer for short strings. 
+ 
+    Why does this function use malloc()? 
+        1. __kmp_allocate() returns cache-aligned memory allocated with malloc(). There are no 
+           reasons in using __kmp_allocate() for strings due to extra overhead while cache-aligned 
+           memory is not necessary. 
+        2. __kmp_thread_malloc() cannot be used because it requires pointer to thread structure. 
+           We need to perform string operations during library startup (for example, in 
+           __kmp_register_library_startup()) when no thread structures are allocated yet. 
+    So standard malloc() is the only available option. 
+*/ 
+ 
+// TODO: Find and replace all regular free() with __kmp_str_free(). 
+ 
+char * 
+__kmp_str_format(           // Allocated string. 
+    char const * format,    // Format string. 
+    ...                     // Other parameters. 
+) { 
+ 
+    va_list args; 
+    int     size   = 512; 
+    char *  buffer = NULL; 
+    int     rc; 
+ 
+    // Allocate buffer. 
+    buffer = (char *) KMP_INTERNAL_MALLOC( size ); 
+    if ( buffer == NULL ) { 
+	KMP_FATAL( MemoryAllocFailed ); 
+    }; // if 
+ 
+    for ( ; ; ) { 
+ 
+        // Try to format string. 
+        va_start( args, format ); 
+        rc = KMP_VSNPRINTF( buffer, size, format, args ); 
+        va_end( args ); 
+ 
+        // No errors, string has been formatted. 
+        if ( rc >= 0 && rc < size ) { 
+            break; 
+        }; // if 
+ 
+        // Error occurred, buffer is too small. 
+        if ( rc >= 0 ) { 
+            // C99-conforming implementation of vsnprintf returns required buffer size. 
+            size = rc + 1; 
+        } else { 
+            // Older implementations just return -1. 
+            size = size * 2; 
+        }; // if 
+ 
+        // Enlarge buffer and try again. 
+        buffer = (char *) KMP_INTERNAL_REALLOC( buffer, size ); 
+        if ( buffer == NULL ) { 
+    	    KMP_FATAL( MemoryAllocFailed ); 
+        }; // if 
+ 
+    }; // forever 
+ 
+    return buffer; 
+ 
+} // func __kmp_str_format 
+ 
+ 
+void 
+__kmp_str_free( 
+    char const * * str 
+) { 
+    KMP_DEBUG_ASSERT( str != NULL ); 
+    KMP_INTERNAL_FREE( (void *) * str ); 
+    * str = NULL; 
+} // func __kmp_str_free 
+ 
+ 
+/* If len is zero, returns true iff target and data have exact case-insensitive match. 
+   If len is negative, returns true iff target is a case-insensitive substring of data. 
+   If len is positive, returns true iff target is a case-insensitive substring of data or 
+     vice versa, and neither is shorter than len. 
+*/ 
+int 
+__kmp_str_match( 
+    char const * target, 
+    int          len, 
+    char const * data 
+) { 
+    int i; 
+    if ( target == NULL || data == NULL ) { 
+        return FALSE; 
+    }; // if 
+    for ( i = 0; target[i] && data[i]; ++ i ) { 
+        if ( TOLOWER( target[i] ) != TOLOWER( data[i] ) ) { 
+            return FALSE; 
+        }; // if 
+    }; // for i 
+    return ( ( len > 0 ) ? i >= len : ( ! target[i] && ( len || ! data[i] ) ) ); 
+} // __kmp_str_match 
+ 
+ 
+int 
+__kmp_str_match_false( char const * data ) { 
+    int result = 
+        __kmp_str_match( "false",   1, data ) || 
+        __kmp_str_match( "off",     2, data ) || 
+        __kmp_str_match( "0",       1, data ) || 
+        __kmp_str_match( ".false.", 2, data ) || 
+        __kmp_str_match( ".f.",     2, data ) || 
+        __kmp_str_match( "no",      1, data ); 
+    return result; 
+} // __kmp_str_match_false 
+ 
+ 
+int 
+__kmp_str_match_true( char const * data ) { 
+    int result = 
+        __kmp_str_match( "true",   1, data ) || 
+        __kmp_str_match( "on",     2, data ) || 
+        __kmp_str_match( "1",      1, data ) || 
+        __kmp_str_match( ".true.", 2, data ) || 
+        __kmp_str_match( ".t.",    2, data ) || 
+        __kmp_str_match( "yes",    1, data ); 
+    return result; 
+} // __kmp_str_match_true 
+ 
+void 
+__kmp_str_replace( 
+    char * str, 
+    char   search_for, 
+    char   replace_with 
+) { 
+ 
+    char * found = NULL; 
+ 
+    found = strchr( str, search_for ); 
+    while ( found ) { 
+        * found = replace_with; 
+        found = strchr( found + 1, search_for ); 
+    }; // while 
+ 
+} // __kmp_str_replace 
+ 
+ 
+void 
+__kmp_str_split( 
+    char *  str,    // I: String to split. 
+    char    delim,  // I: Character to split on. 
+    char ** head,   // O: Pointer to head (may be NULL). 
+    char ** tail    // O: Pointer to tail (may be NULL). 
+) { 
+    char * h = str; 
+    char * t = NULL; 
+    if ( str != NULL ) { 
+        char * ptr = strchr( str, delim ); 
+        if ( ptr != NULL ) { 
+            * ptr  = 0; 
+            t = ptr + 1; 
+        }; // if 
+    }; // if 
+    if ( head != NULL ) { 
+        * head = h; 
+    }; // if 
+    if ( tail != NULL ) { 
+        * tail = t; 
+    }; // if 
+} // __kmp_str_split 
+ 
+/* 
+    strtok_r() is not available on Windows* OS. This function reimplements strtok_r(). 
+*/ 
+char * 
+__kmp_str_token( 
+    char *       str,   // String to split into tokens. Note: String *is* modified! 
+    char const * delim, // Delimiters. 
+    char **      buf    // Internal buffer. 
+) { 
+    char * token = NULL; 
+    #if KMP_OS_WINDOWS 
+        // On Windows* OS there is no strtok_r() function. Let us implement it. 
+        if ( str != NULL ) { 
+            * buf = str;                       // First call, initialize buf. 
+        }; // if 
+        * buf += strspn( * buf, delim );       // Skip leading delimiters. 
+        if ( ** buf != 0 ) {                   // Rest of the string is not yet empty. 
+            token = * buf;                     // Use it as result. 
+            * buf += strcspn( * buf, delim );  // Skip non-delimiters. 
+            if ( ** buf != 0 ) {               // Rest of the string is not yet empty. 
+                ** buf = 0;                    // Terminate token here. 
+                * buf += 1;                    // Advance buf to start with the next token next time. 
+            }; // if 
+        }; // if 
+    #else 
+        // On Linux* OS and OS X*, strtok_r() is available. Let us use it. 
+        token = strtok_r( str, delim, buf ); 
+    #endif 
+    return token; 
+}; // __kmp_str_token 
+ 
+ 
+int 
+__kmp_str_to_int( 
+    char const * str, 
+    char         sentinel 
+) { 
+    int result, factor; 
+    char const * t; 
+ 
+    result = 0; 
+ 
+    for (t = str; *t != '\0'; ++t) { 
+        if (*t < '0' || *t > '9') 
+            break; 
+        result = (result * 10) + (*t - '0'); 
+    } 
+ 
+    switch (*t) { 
+    case '\0':          /* the current default for no suffix is bytes */ 
+	factor = 1; 
+        break; 
+    case 'b': case 'B': /* bytes */ 
+	++t; 
+	factor = 1; 
+        break; 
+    case 'k': case 'K': /* kilo-bytes */ 
+	++t; 
+	factor = 1024; 
+        break; 
+    case 'm': case 'M': /* mega-bytes */ 
+	++t; 
+	factor = (1024 * 1024); 
+        break; 
+    default: 
+	if(*t != sentinel) 
+	    return (-1); 
+	t = ""; 
+	factor = 1; 
+    } 
+ 
+    if (result > (INT_MAX / factor)) 
+	result = INT_MAX; 
+    else 
+	result *= factor; 
+ 
+    return (*t != 0 ? 0 : result); 
+ 
+} // __kmp_str_to_int 
+ 
+ 
+/* 
+    The routine parses input string. It is expected it is a unsigned integer with optional unit. 
+    Units are: "b" for bytes, "kb" or just "k" for kilobytes, "mb" or "m" for megabytes, ..., "yb" 
+    or "y" for yottabytes. :-) Unit name is case-insensitive. The routine returns 0 if everything is 
+    ok, or error code: -1 in case of overflow, -2 in case of unknown unit. *size is set to parsed 
+    value. In case of overflow *size is set to KMP_SIZE_T_MAX, in case of unknown unit *size is set 
+    to zero. 
+*/ 
+void 
+__kmp_str_to_size(         // R: Error code. 
+    char const *   str,    // I: String of characters, unsigned number and unit ("b", "kb", etc). 
+    size_t *       out,    // O: Parsed number. 
+    size_t         dfactor, // I: The factor if none of the letters specified. 
+    char const * * error   // O: Null if everything is ok, error message otherwise. 
+) { 
+ 
+    size_t value    = 0; 
+    size_t factor   = 0; 
+    int    overflow = 0; 
+    int    i        = 0; 
+    int    digit; 
+ 
+ 
+    KMP_DEBUG_ASSERT( str != NULL ); 
+ 
+    // Skip spaces. 
+    while ( str[ i ] == ' ' || str[ i ] == '\t') { 
+        ++ i; 
+    }; // while 
+ 
+    // Parse number. 
+    if ( str[ i ] < '0' || str[ i ] > '9' ) { 
+        * error = KMP_I18N_STR( NotANumber ); 
+        return; 
+    }; // if 
+    do { 
+        digit = str[ i ] - '0'; 
+        overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 ); 
+        value = ( value * 10 ) + digit; 
+        ++ i; 
+    } while ( str[ i ] >= '0' && str[ i ] <= '9' ); 
+ 
+    // Skip spaces. 
+    while ( str[ i ] == ' ' || str[ i ] == '\t' ) { 
+        ++ i; 
+    }; // while 
+ 
+    // Parse unit. 
+    #define _case( ch, exp )                            \ 
+        case ch :                                       \ 
+        case ch - ( 'a' - 'A' ) : {                     \ 
+            size_t shift = (exp) * 10;                  \ 
+            ++ i;                                       \ 
+            if ( shift < sizeof( size_t ) * 8 ) {       \ 
+                factor = (size_t)( 1 ) << shift;        \ 
+            } else {                                    \ 
+                overflow = 1;                           \ 
+            };                                          \ 
+        } break; 
+    switch ( str[ i ] ) { 
+        _case( 'k', 1 ); // Kilo 
+        _case( 'm', 2 ); // Mega 
+        _case( 'g', 3 ); // Giga 
+        _case( 't', 4 ); // Tera 
+        _case( 'p', 5 ); // Peta 
+        _case( 'e', 6 ); // Exa 
+        _case( 'z', 7 ); // Zetta 
+        _case( 'y', 8 ); // Yotta 
+        // Oops. No more units... 
+    }; // switch 
+    #undef _case 
+    if ( str[ i ] == 'b' || str[ i ] == 'B' ) {    // Skip optional "b". 
+	if ( factor == 0 ) { 
+	    factor = 1; 
+	} 
+        ++ i; 
+    }; // if 
+    if ( ! ( str[ i ] == ' ' || str[ i ] == '\t' || str[ i ] == 0 ) ) { // Bad unit 
+        * error = KMP_I18N_STR( BadUnit ); 
+        return; 
+    }; // if 
+ 
+    if ( factor == 0 ) { 
+	factor = dfactor; 
+    } 
+ 
+    // Apply factor. 
+    overflow = overflow || ( value > ( KMP_SIZE_T_MAX / factor ) ); 
+    value *= factor; 
+ 
+    // Skip spaces. 
+    while ( str[ i ] == ' ' || str[ i ] == '\t' ) { 
+        ++ i; 
+    }; // while 
+ 
+    if ( str[ i ] != 0 ) { 
+        * error = KMP_I18N_STR( IllegalCharacters ); 
+        return; 
+    }; // if 
+ 
+    if ( overflow ) { 
+        * error = KMP_I18N_STR( ValueTooLarge ); 
+        * out = KMP_SIZE_T_MAX; 
+        return; 
+    }; // if 
+ 
+    * error = NULL; 
+    * out = value; 
+ 
+} // __kmp_str_to_size 
+ 
+ 
+void 
+__kmp_str_to_uint(         // R: Error code. 
+    char const *   str,    // I: String of characters, unsigned number. 
+    kmp_uint64 *   out,    // O: Parsed number. 
+    char const * * error   // O: Null if everything is ok, error message otherwise. 
+) { 
+ 
+    size_t value    = 0; 
+    int    overflow = 0; 
+    int    i        = 0; 
+    int    digit; 
+ 
+ 
+    KMP_DEBUG_ASSERT( str != NULL ); 
+ 
+    // Skip spaces. 
+    while ( str[ i ] == ' ' || str[ i ] == '\t' ) { 
+        ++ i; 
+    }; // while 
+ 
+    // Parse number. 
+    if ( str[ i ] < '0' || str[ i ] > '9' ) { 
+        * error = KMP_I18N_STR( NotANumber ); 
+        return; 
+    }; // if 
+    do { 
+        digit = str[ i ] - '0'; 
+        overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 ); 
+        value = ( value * 10 ) + digit; 
+        ++ i; 
+    } while ( str[ i ] >= '0' && str[ i ] <= '9' ); 
+ 
+    // Skip spaces. 
+    while ( str[ i ] == ' ' || str[ i ] == '\t' ) { 
+        ++ i; 
+    }; // while 
+ 
+    if ( str[ i ] != 0 ) { 
+        * error = KMP_I18N_STR( IllegalCharacters ); 
+        return; 
+    }; // if 
+ 
+    if ( overflow ) { 
+        * error = KMP_I18N_STR( ValueTooLarge ); 
+        * out = (kmp_uint64) -1; 
+        return; 
+    }; // if 
+ 
+    * error = NULL; 
+    * out = value; 
+ 
+} // __kmp_str_to_unit 
+ 
+ 
+ 
+// end of file //