path: root/contrib/libs/cxxsupp/openmp/kmp_i18n.c

/*
 * kmp_i18n.c
 */


//===----------------------------------------------------------------------===//
//
//                     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_i18n.h"

#include "kmp_os.h"
#include "kmp_debug.h"
#include "kmp.h"
#include "kmp_lock.h"
#include "kmp_io.h"          // __kmp_printf.

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <locale.h>
#include <stdarg.h>

#include "kmp_i18n_default.inc"
#include "kmp_str.h"
#include "kmp_environment.h"

#undef KMP_I18N_OK

#define get_section( id )  ( (id) >> 16 )
#define get_number( id )   ( (id) & 0xFFFF )

kmp_msg_t           __kmp_msg_empty = { kmp_mt_dummy, 0, "", 0  };
kmp_msg_t           __kmp_msg_null  = { kmp_mt_dummy, 0, NULL, 0 };
static char const * no_message_available = "(No message available)";

enum kmp_i18n_cat_status {
    KMP_I18N_CLOSED,    // Not yet opened or closed.
    KMP_I18N_OPENED,    // Opened successfully, ready to use.
    KMP_I18N_ABSENT     // Opening failed, message catalog should not be used.
}; // enum kmp_i18n_cat_status
typedef enum kmp_i18n_cat_status  kmp_i18n_cat_status_t;
static volatile kmp_i18n_cat_status_t  status = KMP_I18N_CLOSED;

/*
    Message catalog is opened at first usage, so we have to synchronize opening to avoid race and
    multiple openings.

    Closing does not require synchronization, because catalog is closed very late at library
    shutting down, when no other threads are alive.
*/

static void __kmp_i18n_do_catopen();
static kmp_bootstrap_lock_t  lock = KMP_BOOTSTRAP_LOCK_INITIALIZER( lock );
    // `lock' variable may be placed into __kmp_i18n_catopen function because it is used only by
    // that function. But we afraid a (buggy) compiler may treat it wrongly. So we put it outside of
    // function just in case.

void
__kmp_i18n_catopen(
) {
    if ( status == KMP_I18N_CLOSED ) {
        __kmp_acquire_bootstrap_lock( & lock );
        if ( status == KMP_I18N_CLOSED ) {
            __kmp_i18n_do_catopen();
        }; // if
        __kmp_release_bootstrap_lock( & lock );
    }; // if
} // func __kmp_i18n_catopen


/*
    ================================================================================================
    Linux* OS and OS X* part.
    ================================================================================================
*/

#if KMP_OS_UNIX
#define KMP_I18N_OK

#include <nl_types.h>

#define KMP_I18N_NULLCAT ((nl_catd)( -1 ))
static nl_catd       cat  = KMP_I18N_NULLCAT;    // !!! Shall it be volatile?
static char const *  name = ( KMP_VERSION_MAJOR == 4 ? "libguide.cat" : "libomp.cat" );

/*
    Useful links:
        http://www.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap08.html#tag_08_02
        http://www.opengroup.org/onlinepubs/000095399/functions/catopen.html
        http://www.opengroup.org/onlinepubs/000095399/functions/setlocale.html
*/

void
__kmp_i18n_do_catopen(
) {
    int    english = 0;
    char * lang    = __kmp_env_get( "LANG" );
    // TODO: What about LC_ALL or LC_MESSAGES?

    KMP_DEBUG_ASSERT( status == KMP_I18N_CLOSED );
    KMP_DEBUG_ASSERT( cat    == KMP_I18N_NULLCAT );

    english =
	lang == NULL                       ||  // In all these cases English language is used.
	strcmp( lang, "" )            == 0 ||
        strcmp( lang, " " )           == 0 ||
              // Workaround for Fortran RTL bug DPD200137873 "Fortran runtime resets LANG env var
              // to space if it is not set".
	strcmp( lang, "C" )           == 0 ||
	strcmp( lang, "POSIX" )       == 0;

    if ( ! english ) {  // English language is not yet detected, let us continue.
        // Format of LANG is: [language[_territory][.codeset][@modifier]]
        // Strip all parts except language.
        char * tail = NULL;
        __kmp_str_split( lang, '@', & lang, & tail );
        __kmp_str_split( lang, '.', & lang, & tail );
        __kmp_str_split( lang, '_', & lang, & tail );
        english = ( strcmp( lang, "en" ) == 0 );
    }; // if

    KMP_INTERNAL_FREE( lang );

    // Do not try to open English catalog because internal messages are
    // exact copy of messages in English catalog.
    if ( english ) {
	status = KMP_I18N_ABSENT;  // mark catalog as absent so it will not be re-opened.
	return;
    }

    cat = catopen( name, 0 );
    // TODO: Why do we pass 0 in flags?
    status = ( cat == KMP_I18N_NULLCAT ? KMP_I18N_ABSENT : KMP_I18N_OPENED );

    if ( status == KMP_I18N_ABSENT ) {
      if (__kmp_generate_warnings > kmp_warnings_low) { // AC: only issue warning in case explicitly asked to
        int    error   = errno; // Save errno immediately.
	char * nlspath = __kmp_env_get( "NLSPATH" );
        char * lang    = __kmp_env_get( "LANG" );

	// Infinite recursion will not occur -- status is KMP_I18N_ABSENT now, so
	// __kmp_i18n_catgets() will not try to open catalog, but will return default message.
	__kmp_msg(
	    kmp_ms_warning,
	    KMP_MSG( CantOpenMessageCatalog, name ),
	    KMP_ERR( error ),
	    KMP_HNT( CheckEnvVar, "NLSPATH", nlspath ),
            KMP_HNT( CheckEnvVar, "LANG", lang ),
	    __kmp_msg_null
	);
	KMP_INFORM( WillUseDefaultMessages );
        KMP_INTERNAL_FREE( nlspath );
        KMP_INTERNAL_FREE( lang );
      }
    } else { // status == KMP_I18N_OPENED

        int section = get_section( kmp_i18n_prp_Version );
        int number  = get_number( kmp_i18n_prp_Version );
        char const * expected = __kmp_i18n_default_table.sect[ section ].str[ number ];
            // Expected version of the catalog.
        kmp_str_buf_t version;   // Actual version of the catalog.
        __kmp_str_buf_init( & version );
        __kmp_str_buf_print( & version, "%s", catgets( cat, section, number, NULL ) );

            // String returned by catgets is invalid after closing the catalog, so copy it.
        if ( strcmp( version.str, expected ) != 0 ) {
            __kmp_i18n_catclose();     // Close bad catalog.
            status = KMP_I18N_ABSENT;  // And mark it as absent.
            if (__kmp_generate_warnings > kmp_warnings_low) { // AC: only issue warning in case explicitly asked to
                // And now print a warning using default messages.
                char const * name    = "NLSPATH";
                char const * nlspath = __kmp_env_get( name );
                __kmp_msg(
                    kmp_ms_warning,
                    KMP_MSG( WrongMessageCatalog, name, version.str, expected ),
                    KMP_HNT( CheckEnvVar, name, nlspath ),
                    __kmp_msg_null
                );
                KMP_INFORM( WillUseDefaultMessages );
                KMP_INTERNAL_FREE( (void *) nlspath );
            } // __kmp_generate_warnings
        }; // if
        __kmp_str_buf_free( & version );

    }; // if

} // func __kmp_i18n_do_catopen


void
__kmp_i18n_catclose(
) {
    if ( status == KMP_I18N_OPENED ) {
        KMP_DEBUG_ASSERT( cat != KMP_I18N_NULLCAT );
        catclose( cat );
        cat = KMP_I18N_NULLCAT;
    }; // if
    status = KMP_I18N_CLOSED;
} // func __kmp_i18n_catclose


char const *
__kmp_i18n_catgets(
    kmp_i18n_id_t  id
) {

    int section = get_section( id );
    int number  = get_number( id );
    char const * message = NULL;

    if ( 1 <= section && section <= __kmp_i18n_default_table.size ) {
        if ( 1 <= number && number <= __kmp_i18n_default_table.sect[ section ].size ) {
            if ( status == KMP_I18N_CLOSED ) {
                __kmp_i18n_catopen();
            }; // if
            if ( status == KMP_I18N_OPENED ) {
                message =
                    catgets(
                        cat,
                        section, number,
                        __kmp_i18n_default_table.sect[ section ].str[ number ]
                    );
            }; // if
            if ( message == NULL ) {
                message = __kmp_i18n_default_table.sect[ section ].str[ number ];
            }; // if
        }; // if
    }; // if
    if ( message == NULL ) {
        message = no_message_available;
    }; // if
    return message;

} // func __kmp_i18n_catgets


#endif // KMP_OS_UNIX

/*
    ================================================================================================
    Windows* OS part.
    ================================================================================================
*/

#if KMP_OS_WINDOWS
#define KMP_I18N_OK

#include "kmp_environment.h"
#include <windows.h>

#define KMP_I18N_NULLCAT  NULL
static HMODULE       cat  = KMP_I18N_NULLCAT;    // !!! Shall it be volatile?
static char const *  name = ( KMP_VERSION_MAJOR == 4 ? "libguide40ui.dll" : "libompui.dll" );

static kmp_i18n_table_t  table             = { 0, NULL };
    // Messages formatted by FormatMessage() should be freed, but catgets() interface assumes
    // user will not free messages. So we cache all the retrieved messages in the table, which
    // are freed at catclose().
static UINT const        default_code_page = CP_OEMCP;
static UINT              code_page         = default_code_page;

static char const * ___catgets( kmp_i18n_id_t  id );
static UINT         get_code_page();
static void         kmp_i18n_table_free( kmp_i18n_table_t * table );


static UINT
get_code_page(
) {

    UINT cp = default_code_page;
    char const * value = __kmp_env_get( "KMP_CODEPAGE" );
    if ( value != NULL ) {
        if ( _stricmp( value, "ANSI" ) == 0 ) {
            cp = CP_ACP;
        } else if ( _stricmp( value, "OEM" ) == 0 ) {
            cp = CP_OEMCP;
        } else if ( _stricmp( value, "UTF-8" ) == 0 || _stricmp( value, "UTF8" ) == 0 ) {
            cp = CP_UTF8;
        } else if ( _stricmp( value, "UTF-7" ) == 0 || _stricmp( value, "UTF7" ) == 0 ) {
            cp = CP_UTF7;
        } else {
            // !!! TODO: Issue a warning?
        }; // if
    }; // if
    KMP_INTERNAL_FREE( (void *) value );
    return cp;

} // func get_code_page


static void
kmp_i18n_table_free(
    kmp_i18n_table_t * table
) {
    int s;
    int m;
    for ( s = 0; s < table->size; ++ s ) {
        for ( m = 0; m < table->sect[ s ].size; ++ m ) {
            // Free message.
            KMP_INTERNAL_FREE( (void *) table->sect[ s ].str[ m ] );
            table->sect[ s ].str[ m ] = NULL;
        }; // for m
        table->sect[ s ].size = 0;
        // Free section itself.
        KMP_INTERNAL_FREE ( (void *) table->sect[ s ].str );
        table->sect[ s ].str = NULL;
    }; // for s
    table->size = 0;
    KMP_INTERNAL_FREE( (void *) table->sect );
    table->sect = NULL;
} // kmp_i8n_table_free


void
__kmp_i18n_do_catopen(
) {

    LCID          locale_id = GetThreadLocale();
    WORD 	  lang_id = LANGIDFROMLCID( locale_id );
    WORD          primary_lang_id = PRIMARYLANGID( lang_id );
    kmp_str_buf_t path;

    KMP_DEBUG_ASSERT( status == KMP_I18N_CLOSED );
    KMP_DEBUG_ASSERT( cat    == KMP_I18N_NULLCAT );

    __kmp_str_buf_init( & path );

    // Do not try to open English catalog because internal messages are
    // exact copy of messages in English catalog.
    if ( primary_lang_id == LANG_ENGLISH ) {
	status = KMP_I18N_ABSENT;  // mark catalog as absent so it will not be re-opened.
	goto end;
    }; // if

    // Construct resource DLL name.
    /*
        Simple
            LoadLibrary( name )
        is not suitable due to security issue (see
        http://www.microsoft.com/technet/security/advisory/2269637.mspx). We have to specify full
        path to the message catalog.
    */
    {

        // Get handle of our DLL first.
        HMODULE handle;
        BOOL brc =
            GetModuleHandleEx(
                GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
                reinterpret_cast< LPCSTR >( & __kmp_i18n_do_catopen ),
                & handle
            );
        if ( ! brc ) {    // Error occurred.
            status = KMP_I18N_ABSENT;  // mark catalog as absent so it will not be re-opened.
            goto end;
            // TODO: Enable multiple messages (KMP_MSG) to be passed to __kmp_msg; and print
            // a proper warning.
        }; // if

        // Now get path to the our DLL.
        for ( ; ; ) {
            DWORD drc = GetModuleFileName( handle, path.str, path.size );
            if ( drc == 0 ) {    // Error occurred.
                status = KMP_I18N_ABSENT;
                goto end;
            }; // if
            if ( drc < path.size ) {
                path.used = drc;
                break;
            }; // if
            __kmp_str_buf_reserve( & path, path.size * 2 );
        }; // forever

        // Now construct the name of message catalog.
        kmp_str_fname fname;
        __kmp_str_fname_init( & fname, path.str );
        __kmp_str_buf_clear( & path );
        __kmp_str_buf_print( & path, "%s%lu/%s", fname.dir, (unsigned long)( locale_id ), name );
        __kmp_str_fname_free( & fname );

    }

    // For security reasons, use LoadLibraryEx() and load message catalog as a data file.
    cat = LoadLibraryEx( path.str, NULL, LOAD_LIBRARY_AS_DATAFILE );
    status = ( cat == KMP_I18N_NULLCAT ? KMP_I18N_ABSENT : KMP_I18N_OPENED );

    if ( status == KMP_I18N_ABSENT ) {
      if (__kmp_generate_warnings > kmp_warnings_low) { // AC: only issue warning in case explicitly asked to
	DWORD error = GetLastError();
	// Infinite recursion will not occur -- status is KMP_I18N_ABSENT now, so
	// __kmp_i18n_catgets() will not try to open catalog but will return default message.
        /*
         If message catalog for another architecture found (e.g. OpenMP RTL
	 for IA-32 architecture opens libompui.dll for Intel(R) 64)
	 Windows* OS returns error 193 (ERROR_BAD_EXE_FORMAT). However,
         FormatMessage fails to return a message for this error, so user
	 will see:

         OMP: Warning #2: Cannot open message catalog "1041\libompui.dll":
         OMP: System error #193: (No system error message available)
         OMP: Info #3: Default messages will be used.

         Issue a hint in this case to let cause of trouble more understandable.
        */
	__kmp_msg(
	    kmp_ms_warning,
	    KMP_MSG( CantOpenMessageCatalog, path.str ),
	    KMP_SYSERRCODE( error ),
            ( error == ERROR_BAD_EXE_FORMAT ? KMP_HNT( BadExeFormat, path.str, KMP_ARCH_STR ) : __kmp_msg_null ),
	    __kmp_msg_null
	);
	KMP_INFORM( WillUseDefaultMessages );
      }
    } else { // status == KMP_I18N_OPENED

        int section = get_section( kmp_i18n_prp_Version );
        int number  = get_number( kmp_i18n_prp_Version );
        char const * expected = __kmp_i18n_default_table.sect[ section ].str[ number ];
        kmp_str_buf_t version;   // Actual version of the catalog.
        __kmp_str_buf_init( & version );
        __kmp_str_buf_print( & version, "%s", ___catgets( kmp_i18n_prp_Version ) );
            // String returned by catgets is invalid after closing the catalog, so copy it.
        if ( strcmp( version.str, expected ) != 0 ) {
            // Close bad catalog.
            __kmp_i18n_catclose();
            status = KMP_I18N_ABSENT;  // And mark it as absent.
            if (__kmp_generate_warnings > kmp_warnings_low) {
                // And now print a warning using default messages.
                __kmp_msg(
                    kmp_ms_warning,
                    KMP_MSG( WrongMessageCatalog, path.str, version.str, expected ),
                    __kmp_msg_null
                );
                KMP_INFORM( WillUseDefaultMessages );
            } // __kmp_generate_warnings
        }; // if
        __kmp_str_buf_free( & version );

    }; // if
    code_page = get_code_page();

    end:
        __kmp_str_buf_free( & path );
        return;

} // func __kmp_i18n_do_catopen


void
__kmp_i18n_catclose(
) {
    if ( status == KMP_I18N_OPENED ) {
        KMP_DEBUG_ASSERT( cat != KMP_I18N_NULLCAT );
        kmp_i18n_table_free( & table );
        FreeLibrary( cat );
        cat = KMP_I18N_NULLCAT;
    }; // if
    code_page = default_code_page;
    status = KMP_I18N_CLOSED;
} // func __kmp_i18n_catclose

/*
    We use FormatMessage() to get strings from catalog, get system error messages, etc.
    FormatMessage() tends to return Windows* OS-style end-of-lines, "\r\n". When string is printed,
    printf() also replaces all the occurrences of "\n" with "\r\n" (again!), so sequences like
    "\r\r\r\n" appear in output. It is not too good.

    Additional mess comes from message catalog: Our catalog source en_US.mc file (generated by
    message-converter.pl) contains only "\n" characters, but en_US_msg_1033.bin file (produced by
    mc.exe) may contain "\r\n" or just "\n". This mess goes from en_US_msg_1033.bin file to
    message catalog, libompui.dll. For example, message

        Error

    (there is "\n" at the end) is compiled by mc.exe to "Error\r\n", while

        OMP: Error %1!d!: %2!s!\n

    (there is "\n" at the end as well) is compiled to "OMP: Error %1!d!: %2!s!\r\n\n".

    Thus, stripping all "\r" normalizes string and returns it to canonical form, so printf() will
    produce correct end-of-line sequences.

    ___strip_crs() serves for this purpose: it removes all the occurrences of "\r" in-place and
    returns new length of string.
*/
static
int
___strip_crs(
    char * str
) {
    int in  = 0;  // Input character index.
    int out = 0;  // Output character index.
    for ( ; ; ) {
        if ( str[ in ] != '\r' ) {
            str[ out ] = str[ in ];
            ++ out;
        }; // if
        if ( str[ in ] == 0 ) {
            break;
        }; // if
        ++ in;
    }; // forever
    return out - 1;
} // func __strip_crs


static
char const *
___catgets(
    kmp_i18n_id_t  id
) {

    char *    result = NULL;
    PVOID     addr   = NULL;
    wchar_t * wmsg   = NULL;
    DWORD     wlen   = 0;
    char *    msg    = NULL;
    int       len    = 0;
    int       rc;

    KMP_DEBUG_ASSERT( cat != KMP_I18N_NULLCAT );
    wlen =    // wlen does *not* include terminating null.
        FormatMessageW(
            FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_HMODULE |
                FORMAT_MESSAGE_IGNORE_INSERTS,
            cat,
            id,
            0,             // LangId
            (LPWSTR) & addr,
            0,             // Size in elements, not in bytes.
            NULL
        );
    if ( wlen <= 0 ) {
        goto end;
    }; // if
    wmsg = (wchar_t *) addr;  // Warning: wmsg may be not nul-terminated!

    // Calculate length of multibyte message.
    len =     // Since wlen does not include terminating null, len does not include it also.
        WideCharToMultiByte(
            code_page,
            0,                // Flags.
            wmsg, wlen,       // Wide buffer and size.
            NULL, 0,          // Buffer and size.
            NULL, NULL        // Default char and used default char.
        );
    if ( len <= 0 ) {
        goto end;
    }; // if

    // Allocate memory.
    msg = (char *) KMP_INTERNAL_MALLOC( len + 1 );

    // Convert wide message to multibyte one.
    rc =
        WideCharToMultiByte(
            code_page,
            0,                // Flags.
            wmsg, wlen,       // Wide buffer and size.
            msg, len,         // Buffer and size.
            NULL, NULL        // Default char and used default char.
        );
    if ( rc <= 0 || rc > len ) {
        goto end;
    }; // if
    KMP_DEBUG_ASSERT( rc == len );
    len = rc;
    msg[ len ] = 0;           // Put terminating null to the end.

    // Stripping all "\r" before stripping last end-of-line simplifies the task.
    len = ___strip_crs( msg );

    // Every message in catalog is terminated with "\n". Strip it.
    if ( len >= 1 && msg[ len - 1 ] == '\n' ) {
        -- len;
        msg[ len ] = 0;
    }; // if

    // Everything looks ok.
    result = msg;
    msg    = NULL;

    end:

    if ( msg != NULL ) {
        KMP_INTERNAL_FREE( msg );
    }; // if
    if ( wmsg != NULL ) {
        LocalFree( wmsg );
    }; // if

    return result;

} // ___catgets


char const *
__kmp_i18n_catgets(
    kmp_i18n_id_t  id
) {

    int section = get_section( id );
    int number  = get_number( id );
    char const * message = NULL;

    if ( 1 <= section && section <= __kmp_i18n_default_table.size ) {
        if ( 1 <= number && number <= __kmp_i18n_default_table.sect[ section ].size ) {
            if ( status == KMP_I18N_CLOSED ) {
                __kmp_i18n_catopen();
            }; // if
            if ( cat != KMP_I18N_NULLCAT ) {
                if ( table.size == 0 ) {
                    table.sect = (kmp_i18n_section_t *)
                        KMP_INTERNAL_CALLOC(
                            ( __kmp_i18n_default_table.size + 2 ),
                            sizeof( kmp_i18n_section_t )
                        );
                    table.size = __kmp_i18n_default_table.size;
                }; // if
                if ( table.sect[ section ].size == 0 ) {
                    table.sect[ section ].str = (const char **)
                        KMP_INTERNAL_CALLOC(
                            __kmp_i18n_default_table.sect[ section ].size + 2,
                            sizeof( char const * )
                        );
                    table.sect[ section ].size = __kmp_i18n_default_table.sect[ section ].size;
                }; // if
                if ( table.sect[ section ].str[ number ] == NULL ) {
                    table.sect[ section ].str[ number ] = ___catgets( id );
                }; // if
                message = table.sect[ section ].str[ number ];
            }; // if
            if ( message == NULL ) {
                // Catalog is not opened or message is not found, return default message.
                message = __kmp_i18n_default_table.sect[ section ].str[ number ];
            }; // if
        }; // if
    }; // if
    if ( message == NULL ) {
        message = no_message_available;
    }; // if
    return message;

} // func __kmp_i18n_catgets


#endif // KMP_OS_WINDOWS

// -------------------------------------------------------------------------------------------------

#ifndef KMP_I18N_OK
    #error I18n support is not implemented for this OS.
#endif // KMP_I18N_OK

// -------------------------------------------------------------------------------------------------

void
__kmp_i18n_dump_catalog(
    kmp_str_buf_t * buffer
) {

    struct kmp_i18n_id_range_t {
        kmp_i18n_id_t  first;
        kmp_i18n_id_t  last;
    }; // struct kmp_i18n_id_range_t

    static struct kmp_i18n_id_range_t ranges[] = {
        { kmp_i18n_prp_first, kmp_i18n_prp_last },
        { kmp_i18n_str_first, kmp_i18n_str_last },
        { kmp_i18n_fmt_first, kmp_i18n_fmt_last },
        { kmp_i18n_msg_first, kmp_i18n_msg_last },
        { kmp_i18n_hnt_first, kmp_i18n_hnt_last }
    }; // ranges

    int           num_of_ranges = sizeof( ranges ) / sizeof( struct kmp_i18n_id_range_t );
    int           range;
    kmp_i18n_id_t id;

    for ( range = 0; range < num_of_ranges; ++ range ) {
        __kmp_str_buf_print( buffer, "*** Set #%d ***\n", range + 1 );
        for ( id = (kmp_i18n_id_t)( ranges[ range ].first + 1 );
              id < ranges[ range ].last;
              id = (kmp_i18n_id_t)( id + 1 ) ) {
             __kmp_str_buf_print( buffer, "%d: <<%s>>\n", id, __kmp_i18n_catgets( id ) );
        }; // for id
    }; // for range

    __kmp_printf( "%s", buffer->str );

} // __kmp_i18n_dump_catalog

// -------------------------------------------------------------------------------------------------

kmp_msg_t
__kmp_msg_format(
    kmp_i18n_id_t id,
    ...
) {

    kmp_msg_t      msg;
    va_list        args;
    kmp_str_buf_t  buffer;
    __kmp_str_buf_init( & buffer );

    va_start( args, id );
    #if KMP_OS_UNIX
        // On Linux* OS and OS X*, printf() family functions process parameter numbers, for example:
        // "%2$s %1$s".
        __kmp_str_buf_vprint( & buffer, __kmp_i18n_catgets( id ), args );
    #elif KMP_OS_WINDOWS
        // On Winodws, printf() family functions does not recognize GNU style parameter numbers,
        // so we have to use FormatMessage() instead. It recognizes parameter numbers, e. g.:
        // "%2!s! "%1!s!".
        {
            LPTSTR str = NULL;
            int    len;
            FormatMessage(
                FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
                __kmp_i18n_catgets( id ),
                0, 0,
                (LPTSTR)( & str ),
                0,
                & args
            );
            len = ___strip_crs( str );
            __kmp_str_buf_cat( & buffer, str, len );
            LocalFree( str );
        }
    #else
        #error
    #endif
    va_end( args );
    __kmp_str_buf_detach( & buffer );

    msg.type = (kmp_msg_type_t)( id >> 16 );
    msg.num  = id & 0xFFFF;
    msg.str  = buffer.str;
    msg.len  = buffer.used;

    return msg;

} // __kmp_msg_format

// -------------------------------------------------------------------------------------------------

static
char *
sys_error(
    int err
) {

    char * message = NULL;

    #if KMP_OS_WINDOWS

        LPVOID  buffer = NULL;
        int     len;
        DWORD   rc;
        rc =
            FormatMessage(
                FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                NULL,
                err,
                MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), // Default language.
                (LPTSTR) & buffer,
                0,
                NULL
            );
        if ( rc > 0 ) {
            // Message formatted. Copy it (so we can free it later with normal free().
            message = __kmp_str_format( "%s", (char *) buffer );
            len = ___strip_crs( message ); // Delete carriage returns if any.
            // Strip trailing newlines.
            while ( len > 0 && message[ len - 1 ] == '\n' ) {
                -- len;
            }; // while
            message[ len ] = 0;
        } else {
            // FormatMessage() failed to format system error message. GetLastError() would give us
            // error code, which we would convert to message... this it dangerous recursion, which
            // cannot clarify original error, so we will not even start it.
        }; // if
        if ( buffer != NULL ) {
            LocalFree( buffer );
        }; // if

    #else // Non-Windows* OS: Linux* OS or OS X*

        /*
            There are 2 incompatible versions of strerror_r:

                char * strerror_r( int, char *, size_t );  // GNU version
                int    strerror_r( int, char *, size_t );  // XSI version
        */

        #if KMP_OS_LINUX

            // GNU version of strerror_r.

            char   buffer[ 2048 ];
            char * const err_msg = strerror_r( err, buffer, sizeof( buffer ) );
                // Do not eliminate this assignment to temporary variable, otherwise compiler would
                // not issue warning if strerror_r() returns `int' instead of expected `char *'.
            message = __kmp_str_format( "%s", err_msg );

        #else // OS X*, FreeBSD* etc.

            // XSI version of strerror_r.

            int    size   = 2048;
            // TODO: Add checking result of malloc().
            char * buffer = (char *) KMP_INTERNAL_MALLOC( size );
            int    rc;
            rc = strerror_r( err, buffer, size );
            if ( rc == -1 ) {
                rc = errno;            // XSI version sets errno.
            }; // if
            while ( rc == ERANGE ) {   // ERANGE means the buffer is too small.
                KMP_INTERNAL_FREE( buffer );
                size *= 2;
                buffer = (char *) KMP_INTERNAL_MALLOC( size );
                rc = strerror_r( err, buffer, size );
                if ( rc == -1 ) {
                    rc = errno;        // XSI version sets errno.
                }; // if
            }; // while
            if ( rc == 0 ) {
                message = buffer;
            } else {
                // Buffer is unused. Free it.
                KMP_INTERNAL_FREE( buffer );
            }; // if

        #endif

    #endif /* KMP_OS_WINDOWS */

    if ( message == NULL ) {
        // TODO: I18n this message.
        message = __kmp_str_format( "%s", "(No system error message available)" );
    }; // if
    return message;

} // sys_error

// -------------------------------------------------------------------------------------------------

kmp_msg_t
__kmp_msg_error_code(
    int  code
) {

    kmp_msg_t      msg;
    msg.type = kmp_mt_syserr;
    msg.num  = code;
    msg.str  = sys_error( code );
    msg.len  = KMP_STRLEN( msg.str );
    return msg;

} // __kmp_msg_error_code

// -------------------------------------------------------------------------------------------------

kmp_msg_t
__kmp_msg_error_mesg(
    char const * mesg
) {

    kmp_msg_t      msg;
    msg.type = kmp_mt_syserr;
    msg.num  = 0;
    msg.str  = __kmp_str_format( "%s", mesg );
    msg.len  = KMP_STRLEN( msg.str );
    return msg;

} // __kmp_msg_error_mesg

// -------------------------------------------------------------------------------------------------

void
__kmp_msg(
    kmp_msg_severity_t  severity,
    kmp_msg_t           message,
    ...
) {

    va_list        args;
    kmp_i18n_id_t  format;      // format identifier
    kmp_msg_t      fmsg;        // formatted message
    kmp_str_buf_t  buffer;

    if ( severity != kmp_ms_fatal && __kmp_generate_warnings == kmp_warnings_off )
        return; // no reason to form a string in order to not print it

    __kmp_str_buf_init( & buffer );

    // Format the primary message.
    switch ( severity ) {
        case kmp_ms_inform : {
            format = kmp_i18n_fmt_Info;
        } break;
        case kmp_ms_warning : {
            format = kmp_i18n_fmt_Warning;
        } break;
        case kmp_ms_fatal : {
            format = kmp_i18n_fmt_Fatal;
        } break;
        default : {
            KMP_DEBUG_ASSERT( 0 );
        };
    }; // switch
    fmsg = __kmp_msg_format( format, message.num, message.str );
    KMP_INTERNAL_FREE( (void *) message.str );
    __kmp_str_buf_cat( & buffer, fmsg.str, fmsg.len );
    KMP_INTERNAL_FREE( (void *) fmsg.str );

    // Format other messages.
    va_start( args, message );
    for ( ; ; ) {
        message = va_arg( args, kmp_msg_t );
        if ( message.type == kmp_mt_dummy && message.str == NULL ) {
            break;
        }; // if
        if ( message.type == kmp_mt_dummy && message.str == __kmp_msg_empty.str ) {
            continue;
        }; // if
        switch ( message.type ) {
            case kmp_mt_hint : {
                format = kmp_i18n_fmt_Hint;
            } break;
            case kmp_mt_syserr : {
                format = kmp_i18n_fmt_SysErr;
            } break;
            default : {
                KMP_DEBUG_ASSERT( 0 );
            };
        }; // switch
        fmsg = __kmp_msg_format( format, message.num, message.str );
        KMP_INTERNAL_FREE( (void *) message.str );
        __kmp_str_buf_cat( & buffer, fmsg.str, fmsg.len );
        KMP_INTERNAL_FREE( (void *) fmsg.str );
    }; // forever
    va_end( args );

    // Print formatted messages.
    // This lock prevents multiple fatal errors on the same problem.
    // __kmp_acquire_bootstrap_lock( & lock );    // GEH - This lock causing tests to hang on OS X*.
    __kmp_printf( "%s", buffer.str );
    __kmp_str_buf_free( & buffer );

    if ( severity == kmp_ms_fatal ) {
        #if KMP_OS_WINDOWS
        __kmp_thread_sleep( 500 );   /* Delay to give message a chance to appear before reaping */
        #endif
        __kmp_abort_process();
    }; // if

    // __kmp_release_bootstrap_lock( & lock );  // GEH - this lock causing tests to hang on OS X*.

} // __kmp_msg

// -------------------------------------------------------------------------------------------------

// end of file //