contrib/openmp/runtime/src/kmp_i18n.cpp

   1 /*
   2  * kmp_i18n.cpp
   3  */
   4
   5 //===----------------------------------------------------------------------===//
   6 //
   7 //                     The LLVM Compiler Infrastructure
   8 //
   9 // This file is dual licensed under the MIT and the University of Illinois Open
  10 // Source Licenses. See LICENSE.txt for details.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "kmp_i18n.h"
  15
  16 #include "kmp.h"
  17 #include "kmp_debug.h"
  18 #include "kmp_io.h" // __kmp_printf.
  19 #include "kmp_lock.h"
  20 #include "kmp_os.h"
  21
  22 #include <errno.h>
  23 #include <locale.h>
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 #include "kmp_environment.h"
  29 #include "kmp_i18n_default.inc"
  30 #include "kmp_str.h"
  31
  32 #undef KMP_I18N_OK
  33
  34 #define get_section(id) ((id) >> 16)
  35 #define get_number(id) ((id)&0xFFFF)
  36
  37 kmp_msg_t __kmp_msg_null = {kmp_mt_dummy, 0, NULL, 0};
  38 static char const *no_message_available = "(No message available)";
  39
  40 static void __kmp_msg(kmp_msg_severity_t severity, kmp_msg_t message,
  41                       va_list ap);
  42
  43 enum kmp_i18n_cat_status {
  44   KMP_I18N_CLOSED, // Not yet opened or closed.
  45   KMP_I18N_OPENED, // Opened successfully, ready to use.
  46   KMP_I18N_ABSENT // Opening failed, message catalog should not be used.
  47 }; // enum kmp_i18n_cat_status
  48 typedef enum kmp_i18n_cat_status kmp_i18n_cat_status_t;
  49 static volatile kmp_i18n_cat_status_t status = KMP_I18N_CLOSED;
  50
  51 /* Message catalog is opened at first usage, so we have to synchronize opening
  52    to avoid race and multiple openings.
  53
  54    Closing does not require synchronization, because catalog is closed very late
  55    at library shutting down, when no other threads are alive.  */
  56
  57 static void __kmp_i18n_do_catopen();
  58 static kmp_bootstrap_lock_t lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(lock);
  59 // `lock' variable may be placed into __kmp_i18n_catopen function because it is
  60 // used only by that function. But we afraid a (buggy) compiler may treat it
  61 // wrongly. So we put it outside of function just in case.
  62
  63 void __kmp_i18n_catopen() {
  64   if (status == KMP_I18N_CLOSED) {
  65     __kmp_acquire_bootstrap_lock(&lock);
  66     if (status == KMP_I18N_CLOSED) {
  67       __kmp_i18n_do_catopen();
  68     }
  69     __kmp_release_bootstrap_lock(&lock);
  70   }
  71 } // func __kmp_i18n_catopen
  72
  73 /* Linux* OS and OS X* part */
  74 #if KMP_OS_UNIX
  75 #define KMP_I18N_OK
  76
  77 #include <nl_types.h>
  78
  79 #define KMP_I18N_NULLCAT ((nl_catd)(-1))
  80 static nl_catd cat = KMP_I18N_NULLCAT; // !!! Shall it be volatile?
  81 static char const *name =
  82     (KMP_VERSION_MAJOR == 4 ? "libguide.cat" : "libomp.cat");
  83
  84 /* Useful links:
  85 http://www.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap08.html#tag_08_02
  86 http://www.opengroup.org/onlinepubs/000095399/functions/catopen.html
  87 http://www.opengroup.org/onlinepubs/000095399/functions/setlocale.html
  88 */
  89
  90 void __kmp_i18n_do_catopen() {
  91   int english = 0;
  92   char *lang = __kmp_env_get("LANG");
  93   // TODO: What about LC_ALL or LC_MESSAGES?
  94
  95   KMP_DEBUG_ASSERT(status == KMP_I18N_CLOSED);
  96   KMP_DEBUG_ASSERT(cat == KMP_I18N_NULLCAT);
  97
  98   english = lang == NULL || // In all these cases English language is used.
  99             strcmp(lang, "") == 0 || strcmp(lang, " ") == 0 ||
 100             // Workaround for Fortran RTL bug DPD200137873 "Fortran runtime
 101             // resets LANG env var to space if it is not set".
 102             strcmp(lang, "C") == 0 || strcmp(lang, "POSIX") == 0;
 103
 104   if (!english) { // English language is not yet detected, let us continue.
 105     // Format of LANG is: [language[_territory][.codeset][@modifier]]
 106     // Strip all parts except language.
 107     char *tail = NULL;
 108     __kmp_str_split(lang, '@', &lang, &tail);
 109     __kmp_str_split(lang, '.', &lang, &tail);
 110     __kmp_str_split(lang, '_', &lang, &tail);
 111     english = (strcmp(lang, "en") == 0);
 112   }
 113
 114   KMP_INTERNAL_FREE(lang);
 115
 116   // Do not try to open English catalog because internal messages are
 117   // exact copy of messages in English catalog.
 118   if (english) {
 119     status = KMP_I18N_ABSENT; // mark catalog as absent so it will not
 120     // be re-opened.
 121     return;
 122   }
 123
 124   cat = catopen(name, 0);
 125   // TODO: Why do we pass 0 in flags?
 126   status = (cat == KMP_I18N_NULLCAT ? KMP_I18N_ABSENT : KMP_I18N_OPENED);
 127
 128   if (status == KMP_I18N_ABSENT) {
 129     if (__kmp_generate_warnings > kmp_warnings_low) {
 130       // AC: only issue warning in case explicitly asked to
 131       int error = errno; // Save errno immediately.
 132       char *nlspath = __kmp_env_get("NLSPATH");
 133       char *lang = __kmp_env_get("LANG");
 134
 135       // Infinite recursion will not occur -- status is KMP_I18N_ABSENT now, so
 136       // __kmp_i18n_catgets() will not try to open catalog, but will return
 137       // default message.
 138       kmp_msg_t err_code = KMP_ERR(error);
 139       __kmp_msg(kmp_ms_warning, KMP_MSG(CantOpenMessageCatalog, name), err_code,
 140                 KMP_HNT(CheckEnvVar, "NLSPATH", nlspath),
 141                 KMP_HNT(CheckEnvVar, "LANG", lang), __kmp_msg_null);
 142       if (__kmp_generate_warnings == kmp_warnings_off) {
 143         __kmp_str_free(&err_code.str);
 144       }
 145
 146       KMP_INFORM(WillUseDefaultMessages);
 147       KMP_INTERNAL_FREE(nlspath);
 148       KMP_INTERNAL_FREE(lang);
 149     }
 150   } else { // status == KMP_I18N_OPENED
 151     int section = get_section(kmp_i18n_prp_Version);
 152     int number = get_number(kmp_i18n_prp_Version);
 153     char const *expected = __kmp_i18n_default_table.sect[section].str[number];
 154     // Expected version of the catalog.
 155     kmp_str_buf_t version; // Actual version of the catalog.
 156     __kmp_str_buf_init(&version);
 157     __kmp_str_buf_print(&version, "%s", catgets(cat, section, number, NULL));
 158
 159     // String returned by catgets is invalid after closing catalog, so copy it.
 160     if (strcmp(version.str, expected) != 0) {
 161       __kmp_i18n_catclose(); // Close bad catalog.
 162       status = KMP_I18N_ABSENT; // And mark it as absent.
 163       if (__kmp_generate_warnings > kmp_warnings_low) {
 164         // AC: only issue warning in case explicitly asked to
 165         // And now print a warning using default messages.
 166         char const *name = "NLSPATH";
 167         char const *nlspath = __kmp_env_get(name);
 168         __kmp_msg(kmp_ms_warning,
 169                   KMP_MSG(WrongMessageCatalog, name, version.str, expected),
 170                   KMP_HNT(CheckEnvVar, name, nlspath), __kmp_msg_null);
 171         KMP_INFORM(WillUseDefaultMessages);
 172         KMP_INTERNAL_FREE(CCAST(char *, nlspath));
 173       } // __kmp_generate_warnings
 174     }
 175     __kmp_str_buf_free(&version);
 176   }
 177 } // func __kmp_i18n_do_catopen
 178
 179 void __kmp_i18n_catclose() {
 180   if (status == KMP_I18N_OPENED) {
 181     KMP_DEBUG_ASSERT(cat != KMP_I18N_NULLCAT);
 182     catclose(cat);
 183     cat = KMP_I18N_NULLCAT;
 184   }
 185   status = KMP_I18N_CLOSED;
 186 } // func __kmp_i18n_catclose
 187
 188 char const *__kmp_i18n_catgets(kmp_i18n_id_t id) {
 189
 190   int section = get_section(id);
 191   int number = get_number(id);
 192   char const *message = NULL;
 193
 194   if (1 <= section && section <= __kmp_i18n_default_table.size) {
 195     if (1 <= number && number <= __kmp_i18n_default_table.sect[section].size) {
 196       if (status == KMP_I18N_CLOSED) {
 197         __kmp_i18n_catopen();
 198       }
 199       if (status == KMP_I18N_OPENED) {
 200         message = catgets(cat, section, number,
 201                           __kmp_i18n_default_table.sect[section].str[number]);
 202       }
 203       if (message == NULL) {
 204         message = __kmp_i18n_default_table.sect[section].str[number];
 205       }
 206     }
 207   }
 208   if (message == NULL) {
 209     message = no_message_available;
 210   }
 211   return message;
 212
 213 } // func __kmp_i18n_catgets
 214
 215 #endif // KMP_OS_UNIX
 216
 217 /* Windows* OS part. */
 218
 219 #if KMP_OS_WINDOWS
 220 #define KMP_I18N_OK
 221
 222 #include "kmp_environment.h"
 223 #include <windows.h>
 224
 225 #define KMP_I18N_NULLCAT NULL
 226 static HMODULE cat = KMP_I18N_NULLCAT; // !!! Shall it be volatile?
 227 static char const *name =
 228     (KMP_VERSION_MAJOR == 4 ? "libguide40ui.dll" : "libompui.dll");
 229
 230 static kmp_i18n_table_t table = {0, NULL};
 231 // Messages formatted by FormatMessage() should be freed, but catgets()
 232 // interface assumes user will not free messages. So we cache all the retrieved
 233 // messages in the table, which are freed at catclose().
 234 static UINT const default_code_page = CP_OEMCP;
 235 static UINT code_page = default_code_page;
 236
 237 static char const *___catgets(kmp_i18n_id_t id);
 238 static UINT get_code_page();
 239 static void kmp_i18n_table_free(kmp_i18n_table_t *table);
 240
 241 static UINT get_code_page() {
 242
 243   UINT cp = default_code_page;
 244   char const *value = __kmp_env_get("KMP_CODEPAGE");
 245   if (value != NULL) {
 246     if (_stricmp(value, "ANSI") == 0) {
 247       cp = CP_ACP;
 248     } else if (_stricmp(value, "OEM") == 0) {
 249       cp = CP_OEMCP;
 250     } else if (_stricmp(value, "UTF-8") == 0 || _stricmp(value, "UTF8") == 0) {
 251       cp = CP_UTF8;
 252     } else if (_stricmp(value, "UTF-7") == 0 || _stricmp(value, "UTF7") == 0) {
 253       cp = CP_UTF7;
 254     } else {
 255       // !!! TODO: Issue a warning?
 256     }
 257   }
 258   KMP_INTERNAL_FREE((void *)value);
 259   return cp;
 260
 261 } // func get_code_page
 262
 263 static void kmp_i18n_table_free(kmp_i18n_table_t *table) {
 264   int s;
 265   int m;
 266   for (s = 0; s < table->size; ++s) {
 267     for (m = 0; m < table->sect[s].size; ++m) {
 268       // Free message.
 269       KMP_INTERNAL_FREE((void *)table->sect[s].str[m]);
 270       table->sect[s].str[m] = NULL;
 271     }
 272     table->sect[s].size = 0;
 273     // Free section itself.
 274     KMP_INTERNAL_FREE((void *)table->sect[s].str);
 275     table->sect[s].str = NULL;
 276   }
 277   table->size = 0;
 278   KMP_INTERNAL_FREE((void *)table->sect);
 279   table->sect = NULL;
 280 } // kmp_i18n_table_free
 281
 282 void __kmp_i18n_do_catopen() {
 283
 284   LCID locale_id = GetThreadLocale();
 285   WORD lang_id = LANGIDFROMLCID(locale_id);
 286   WORD primary_lang_id = PRIMARYLANGID(lang_id);
 287   kmp_str_buf_t path;
 288
 289   KMP_DEBUG_ASSERT(status == KMP_I18N_CLOSED);
 290   KMP_DEBUG_ASSERT(cat == KMP_I18N_NULLCAT);
 291
 292   __kmp_str_buf_init(&path);
 293
 294   // Do not try to open English catalog because internal messages are exact copy
 295   // of messages in English catalog.
 296   if (primary_lang_id == LANG_ENGLISH) {
 297     status = KMP_I18N_ABSENT; // mark catalog as absent so it will not
 298     // be re-opened.
 299     goto end;
 300   }
 301
 302   // Construct resource DLL name.
 303   /* Simple LoadLibrary( name ) is not suitable due to security issue (see
 304      http://www.microsoft.com/technet/security/advisory/2269637.mspx). We have
 305      to specify full path to the message catalog.  */
 306   {
 307     // Get handle of our DLL first.
 308     HMODULE handle;
 309     BOOL brc = GetModuleHandleEx(
 310         GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
 311             GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
 312         reinterpret_cast<LPCSTR>(&__kmp_i18n_do_catopen), &handle);
 313     if (!brc) { // Error occurred.
 314       status = KMP_I18N_ABSENT; // mark catalog as absent so it will not be
 315       // re-opened.
 316       goto end;
 317       // TODO: Enable multiple messages (KMP_MSG) to be passed to __kmp_msg; and
 318       // print a proper warning.
 319     }
 320
 321     // Now get path to the our DLL.
 322     for (;;) {
 323       DWORD drc = GetModuleFileName(handle, path.str, path.size);
 324       if (drc == 0) { // Error occurred.
 325         status = KMP_I18N_ABSENT;
 326         goto end;
 327       }
 328       if (drc < path.size) {
 329         path.used = drc;
 330         break;
 331       }
 332       __kmp_str_buf_reserve(&path, path.size * 2);
 333     }
 334
 335     // Now construct the name of message catalog.
 336     kmp_str_fname fname;
 337     __kmp_str_fname_init(&fname, path.str);
 338     __kmp_str_buf_clear(&path);
 339     __kmp_str_buf_print(&path, "%s%lu/%s", fname.dir,
 340                         (unsigned long)(locale_id), name);
 341     __kmp_str_fname_free(&fname);
 342   }
 343
 344   // For security reasons, use LoadLibraryEx() and load message catalog as a
 345   // data file.
 346   cat = LoadLibraryEx(path.str, NULL, LOAD_LIBRARY_AS_DATAFILE);
 347   status = (cat == KMP_I18N_NULLCAT ? KMP_I18N_ABSENT : KMP_I18N_OPENED);
 348
 349   if (status == KMP_I18N_ABSENT) {
 350     if (__kmp_generate_warnings > kmp_warnings_low) {
 351       // AC: only issue warning in case explicitly asked to
 352       DWORD error = GetLastError();
 353       // Infinite recursion will not occur -- status is KMP_I18N_ABSENT now, so
 354       // __kmp_i18n_catgets() will not try to open catalog but will return
 355       // default message.
 356       /* If message catalog for another architecture found (e.g. OpenMP RTL for
 357          IA-32 architecture opens libompui.dll for Intel(R) 64) Windows* OS
 358          returns error 193 (ERROR_BAD_EXE_FORMAT). However, FormatMessage fails
 359          to return a message for this error, so user will see:
 360
 361          OMP: Warning #2: Cannot open message catalog "1041\libompui.dll":
 362          OMP: System error #193: (No system error message available)
 363          OMP: Info #3: Default messages will be used.
 364
 365          Issue hint in this case so cause of trouble is more understandable. */
 366       kmp_msg_t err_code = KMP_SYSERRCODE(error);
 367       __kmp_msg(kmp_ms_warning, KMP_MSG(CantOpenMessageCatalog, path.str),
 368                 err_code, (error == ERROR_BAD_EXE_FORMAT
 369                                ? KMP_HNT(BadExeFormat, path.str, KMP_ARCH_STR)
 370                                : __kmp_msg_null),
 371                 __kmp_msg_null);
 372       if (__kmp_generate_warnings == kmp_warnings_off) {
 373         __kmp_str_free(&err_code.str);
 374       }
 375       KMP_INFORM(WillUseDefaultMessages);
 376     }
 377   } else { // status == KMP_I18N_OPENED
 378
 379     int section = get_section(kmp_i18n_prp_Version);
 380     int number = get_number(kmp_i18n_prp_Version);
 381     char const *expected = __kmp_i18n_default_table.sect[section].str[number];
 382     kmp_str_buf_t version; // Actual version of the catalog.
 383     __kmp_str_buf_init(&version);
 384     __kmp_str_buf_print(&version, "%s", ___catgets(kmp_i18n_prp_Version));
 385     // String returned by catgets is invalid after closing catalog, so copy it.
 386     if (strcmp(version.str, expected) != 0) {
 387       // Close bad catalog.
 388       __kmp_i18n_catclose();
 389       status = KMP_I18N_ABSENT; // And mark it as absent.
 390       if (__kmp_generate_warnings > kmp_warnings_low) {
 391         // And now print a warning using default messages.
 392         __kmp_msg(kmp_ms_warning,
 393                   KMP_MSG(WrongMessageCatalog, path.str, version.str, expected),
 394                   __kmp_msg_null);
 395         KMP_INFORM(WillUseDefaultMessages);
 396       } // __kmp_generate_warnings
 397     }
 398     __kmp_str_buf_free(&version);
 399   }
 400   code_page = get_code_page();
 401
 402 end:
 403   __kmp_str_buf_free(&path);
 404   return;
 405 } // func __kmp_i18n_do_catopen
 406
 407 void __kmp_i18n_catclose() {
 408   if (status == KMP_I18N_OPENED) {
 409     KMP_DEBUG_ASSERT(cat != KMP_I18N_NULLCAT);
 410     kmp_i18n_table_free(&table);
 411     FreeLibrary(cat);
 412     cat = KMP_I18N_NULLCAT;
 413   }
 414   code_page = default_code_page;
 415   status = KMP_I18N_CLOSED;
 416 } // func __kmp_i18n_catclose
 417
 418 /* We use FormatMessage() to get strings from catalog, get system error
 419    messages, etc. FormatMessage() tends to return Windows* OS-style
 420    end-of-lines, "\r\n". When string is printed, printf() also replaces all the
 421    occurrences of "\n" with "\r\n" (again!), so sequences like "\r\r\r\n"
 422    appear in output. It is not too good.
 423
 424    Additional mess comes from message catalog: Our catalog source en_US.mc file
 425    (generated by message-converter.pl) contains only "\n" characters, but
 426    en_US_msg_1033.bin file (produced by mc.exe) may contain "\r\n" or just "\n".
 427    This mess goes from en_US_msg_1033.bin file to message catalog,
 428    libompui.dll. For example, message
 429
 430    Error
 431
 432    (there is "\n" at the end) is compiled by mc.exe to "Error\r\n", while
 433
 434    OMP: Error %1!d!: %2!s!\n
 435
 436    (there is "\n" at the end as well) is compiled to "OMP: Error %1!d!:
 437    %2!s!\r\n\n".
 438
 439    Thus, stripping all "\r" normalizes string and returns it to canonical form,
 440    so printf() will produce correct end-of-line sequences.
 441
 442    ___strip_crs() serves for this purpose: it removes all the occurrences of
 443    "\r" in-place and returns new length of string.  */
 444 static int ___strip_crs(char *str) {
 445   int in = 0; // Input character index.
 446   int out = 0; // Output character index.
 447   for (;;) {
 448     if (str[in] != '\r') {
 449       str[out] = str[in];
 450       ++out;
 451     }
 452     if (str[in] == 0) {
 453       break;
 454     }
 455     ++in;
 456   }
 457   return out - 1;
 458 } // func __strip_crs
 459
 460 static char const *___catgets(kmp_i18n_id_t id) {
 461
 462   char *result = NULL;
 463   PVOID addr = NULL;
 464   wchar_t *wmsg = NULL;
 465   DWORD wlen = 0;
 466   char *msg = NULL;
 467   int len = 0;
 468   int rc;
 469
 470   KMP_DEBUG_ASSERT(cat != KMP_I18N_NULLCAT);
 471   wlen = // wlen does *not* include terminating null.
 472       FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
 473                          FORMAT_MESSAGE_FROM_HMODULE |
 474                          FORMAT_MESSAGE_IGNORE_INSERTS,
 475                      cat, id,
 476                      0, // LangId
 477                      (LPWSTR)&addr,
 478                      0, // Size in elements, not in bytes.
 479                      NULL);
 480   if (wlen <= 0) {
 481     goto end;
 482   }
 483   wmsg = (wchar_t *)addr; // Warning: wmsg may be not nul-terminated!
 484
 485   // Calculate length of multibyte message.
 486   // Since wlen does not include terminating null, len does not include it also.
 487   len = WideCharToMultiByte(code_page,
 488                             0, // Flags.
 489                             wmsg, wlen, // Wide buffer and size.
 490                             NULL, 0, // Buffer and size.
 491                             NULL, NULL // Default char and used default char.
 492                             );
 493   if (len <= 0) {
 494     goto end;
 495   }
 496
 497   // Allocate memory.
 498   msg = (char *)KMP_INTERNAL_MALLOC(len + 1);
 499
 500   // Convert wide message to multibyte one.
 501   rc = WideCharToMultiByte(code_page,
 502                            0, // Flags.
 503                            wmsg, wlen, // Wide buffer and size.
 504                            msg, len, // Buffer and size.
 505                            NULL, NULL // Default char and used default char.
 506                            );
 507   if (rc <= 0 || rc > len) {
 508     goto end;
 509   }
 510   KMP_DEBUG_ASSERT(rc == len);
 511   len = rc;
 512   msg[len] = 0; // Put terminating null to the end.
 513
 514   // Stripping all "\r" before stripping last end-of-line simplifies the task.
 515   len = ___strip_crs(msg);
 516
 517   // Every message in catalog is terminated with "\n". Strip it.
 518   if (len >= 1 && msg[len - 1] == '\n') {
 519     --len;
 520     msg[len] = 0;
 521   }
 522
 523   // Everything looks ok.
 524   result = msg;
 525   msg = NULL;
 526
 527 end:
 528
 529   if (msg != NULL) {
 530     KMP_INTERNAL_FREE(msg);
 531   }
 532   if (wmsg != NULL) {
 533     LocalFree(wmsg);
 534   }
 535
 536   return result;
 537
 538 } // ___catgets
 539
 540 char const *__kmp_i18n_catgets(kmp_i18n_id_t id) {
 541
 542   int section = get_section(id);
 543   int number = get_number(id);
 544   char const *message = NULL;
 545
 546   if (1 <= section && section <= __kmp_i18n_default_table.size) {
 547     if (1 <= number && number <= __kmp_i18n_default_table.sect[section].size) {
 548       if (status == KMP_I18N_CLOSED) {
 549         __kmp_i18n_catopen();
 550       }
 551       if (cat != KMP_I18N_NULLCAT) {
 552         if (table.size == 0) {
 553           table.sect = (kmp_i18n_section_t *)KMP_INTERNAL_CALLOC(
 554               (__kmp_i18n_default_table.size + 2), sizeof(kmp_i18n_section_t));
 555           table.size = __kmp_i18n_default_table.size;
 556         }
 557         if (table.sect[section].size == 0) {
 558           table.sect[section].str = (const char **)KMP_INTERNAL_CALLOC(
 559               __kmp_i18n_default_table.sect[section].size + 2,
 560               sizeof(char const *));
 561           table.sect[section].size =
 562               __kmp_i18n_default_table.sect[section].size;
 563         }
 564         if (table.sect[section].str[number] == NULL) {
 565           table.sect[section].str[number] = ___catgets(id);
 566         }
 567         message = table.sect[section].str[number];
 568       }
 569       if (message == NULL) {
 570         // Catalog is not opened or message is not found, return default
 571         // message.
 572         message = __kmp_i18n_default_table.sect[section].str[number];
 573       }
 574     }
 575   }
 576   if (message == NULL) {
 577     message = no_message_available;
 578   }
 579   return message;
 580
 581 } // func __kmp_i18n_catgets
 582
 583 #endif // KMP_OS_WINDOWS
 584
 585 // -----------------------------------------------------------------------------
 586
 587 #ifndef KMP_I18N_OK
 588 #error I18n support is not implemented for this OS.
 589 #endif // KMP_I18N_OK
 590
 591 // -----------------------------------------------------------------------------
 592
 593 void __kmp_i18n_dump_catalog(kmp_str_buf_t *buffer) {
 594
 595   struct kmp_i18n_id_range_t {
 596     kmp_i18n_id_t first;
 597     kmp_i18n_id_t last;
 598   }; // struct kmp_i18n_id_range_t
 599
 600   static struct kmp_i18n_id_range_t ranges[] = {
 601       {kmp_i18n_prp_first, kmp_i18n_prp_last},
 602       {kmp_i18n_str_first, kmp_i18n_str_last},
 603       {kmp_i18n_fmt_first, kmp_i18n_fmt_last},
 604       {kmp_i18n_msg_first, kmp_i18n_msg_last},
 605       {kmp_i18n_hnt_first, kmp_i18n_hnt_last}}; // ranges
 606
 607   int num_of_ranges = sizeof(ranges) / sizeof(struct kmp_i18n_id_range_t);
 608   int range;
 609   kmp_i18n_id_t id;
 610
 611   for (range = 0; range < num_of_ranges; ++range) {
 612     __kmp_str_buf_print(buffer, "*** Set #%d ***\n", range + 1);
 613     for (id = (kmp_i18n_id_t)(ranges[range].first + 1); id < ranges[range].last;
 614          id = (kmp_i18n_id_t)(id + 1)) {
 615       __kmp_str_buf_print(buffer, "%d: <<%s>>\n", id, __kmp_i18n_catgets(id));
 616     }
 617   }
 618
 619   __kmp_printf("%s", buffer->str);
 620
 621 } // __kmp_i18n_dump_catalog
 622
 623 // -----------------------------------------------------------------------------
 624 kmp_msg_t __kmp_msg_format(unsigned id_arg, ...) {
 625
 626   kmp_msg_t msg;
 627   va_list args;
 628   kmp_str_buf_t buffer;
 629   __kmp_str_buf_init(&buffer);
 630
 631   va_start(args, id_arg);
 632
 633   // We use unsigned for the ID argument and explicitly cast it here to the
 634   // right enumerator because variadic functions are not compatible with
 635   // default promotions.
 636   kmp_i18n_id_t id = (kmp_i18n_id_t)id_arg;
 637
 638 #if KMP_OS_UNIX
 639   // On Linux* OS and OS X*, printf() family functions process parameter
 640   // numbers, for example:  "%2$s %1$s".
 641   __kmp_str_buf_vprint(&buffer, __kmp_i18n_catgets(id), args);
 642 #elif KMP_OS_WINDOWS
 643   // On Winodws, printf() family functions does not recognize GNU style
 644   // parameter numbers, so we have to use FormatMessage() instead. It recognizes
 645   // parameter numbers, e. g.:  "%2!s! "%1!s!".
 646   {
 647     LPTSTR str = NULL;
 648     int len;
 649     FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
 650                   __kmp_i18n_catgets(id), 0, 0, (LPTSTR)(&str), 0, &args);
 651     len = ___strip_crs(str);
 652     __kmp_str_buf_cat(&buffer, str, len);
 653     LocalFree(str);
 654   }
 655 #else
 656 #error
 657 #endif
 658   va_end(args);
 659   __kmp_str_buf_detach(&buffer);
 660
 661   msg.type = (kmp_msg_type_t)(id >> 16);
 662   msg.num = id & 0xFFFF;
 663   msg.str = buffer.str;
 664   msg.len = buffer.used;
 665
 666   return msg;
 667
 668 } // __kmp_msg_format
 669
 670 // -----------------------------------------------------------------------------
 671 static char *sys_error(int err) {
 672
 673   char *message = NULL;
 674
 675 #if KMP_OS_WINDOWS
 676
 677   LPVOID buffer = NULL;
 678   int len;
 679   DWORD rc;
 680   rc = FormatMessage(
 681       FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, err,
 682       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language.
 683       (LPTSTR)&buffer, 0, NULL);
 684   if (rc > 0) {
 685     // Message formatted. Copy it (so we can free it later with normal free().
 686     message = __kmp_str_format("%s", (char *)buffer);
 687     len = ___strip_crs(message); // Delete carriage returns if any.
 688     // Strip trailing newlines.
 689     while (len > 0 && message[len - 1] == '\n') {
 690       --len;
 691     }
 692     message[len] = 0;
 693   } else {
 694     // FormatMessage() failed to format system error message. GetLastError()
 695     // would give us error code, which we would convert to message... this it
 696     // dangerous recursion, which cannot clarify original error, so we will not
 697     // even start it.
 698   }
 699   if (buffer != NULL) {
 700     LocalFree(buffer);
 701   }
 702
 703 #else // Non-Windows* OS: Linux* OS or OS X*
 704
 705 /* There are 2 incompatible versions of strerror_r:
 706
 707    char * strerror_r( int, char *, size_t );  // GNU version
 708    int    strerror_r( int, char *, size_t );  // XSI version
 709 */
 710
 711 #if (defined(__GLIBC__) && defined(_GNU_SOURCE)) ||                            \
 712     (defined(__BIONIC__) && defined(_GNU_SOURCE) &&                            \
 713      __ANDROID_API__ >= __ANDROID_API_M__)
 714   // GNU version of strerror_r.
 715
 716   char buffer[2048];
 717   char *const err_msg = strerror_r(err, buffer, sizeof(buffer));
 718   // Do not eliminate this assignment to temporary variable, otherwise compiler
 719   // would not issue warning if strerror_r() returns `int' instead of expected
 720   // `char *'.
 721   message = __kmp_str_format("%s", err_msg);
 722
 723 #else // OS X*, FreeBSD* etc.
 724   // XSI version of strerror_r.
 725   int size = 2048;
 726   char *buffer = (char *)KMP_INTERNAL_MALLOC(size);
 727   int rc;
 728   if (buffer == NULL) {
 729     KMP_FATAL(MemoryAllocFailed);
 730   }
 731   rc = strerror_r(err, buffer, size);
 732   if (rc == -1) {
 733     rc = errno; // XSI version sets errno.
 734   }
 735   while (rc == ERANGE) { // ERANGE means the buffer is too small.
 736     KMP_INTERNAL_FREE(buffer);
 737     size *= 2;
 738     buffer = (char *)KMP_INTERNAL_MALLOC(size);
 739     if (buffer == NULL) {
 740       KMP_FATAL(MemoryAllocFailed);
 741     }
 742     rc = strerror_r(err, buffer, size);
 743     if (rc == -1) {
 744       rc = errno; // XSI version sets errno.
 745     }
 746   }
 747   if (rc == 0) {
 748     message = buffer;
 749   } else { // Buffer is unused. Free it.
 750     KMP_INTERNAL_FREE(buffer);
 751   }
 752
 753 #endif
 754
 755 #endif /* KMP_OS_WINDOWS */
 756
 757   if (message == NULL) {
 758     // TODO: I18n this message.
 759     message = __kmp_str_format("%s", "(No system error message available)");
 760   }
 761   return message;
 762 } // sys_error
 763
 764 // -----------------------------------------------------------------------------
 765 kmp_msg_t __kmp_msg_error_code(int code) {
 766
 767   kmp_msg_t msg;
 768   msg.type = kmp_mt_syserr;
 769   msg.num = code;
 770   msg.str = sys_error(code);
 771   msg.len = KMP_STRLEN(msg.str);
 772   return msg;
 773
 774 } // __kmp_msg_error_code
 775
 776 // -----------------------------------------------------------------------------
 777 kmp_msg_t __kmp_msg_error_mesg(char const *mesg) {
 778
 779   kmp_msg_t msg;
 780   msg.type = kmp_mt_syserr;
 781   msg.num = 0;
 782   msg.str = __kmp_str_format("%s", mesg);
 783   msg.len = KMP_STRLEN(msg.str);
 784   return msg;
 785
 786 } // __kmp_msg_error_mesg
 787
 788 // -----------------------------------------------------------------------------
 789 void __kmp_msg(kmp_msg_severity_t severity, kmp_msg_t message, va_list args) {
 790   kmp_i18n_id_t format; // format identifier
 791   kmp_msg_t fmsg; // formatted message
 792   kmp_str_buf_t buffer;
 793
 794   if (severity != kmp_ms_fatal && __kmp_generate_warnings == kmp_warnings_off)
 795     return; // no reason to form a string in order to not print it
 796
 797   __kmp_str_buf_init(&buffer);
 798
 799   // Format the primary message.
 800   switch (severity) {
 801   case kmp_ms_inform: {
 802     format = kmp_i18n_fmt_Info;
 803   } break;
 804   case kmp_ms_warning: {
 805     format = kmp_i18n_fmt_Warning;
 806   } break;
 807   case kmp_ms_fatal: {
 808     format = kmp_i18n_fmt_Fatal;
 809   } break;
 810   default: { KMP_DEBUG_ASSERT(0); }
 811   }
 812   fmsg = __kmp_msg_format(format, message.num, message.str);
 813   __kmp_str_free(&message.str);
 814   __kmp_str_buf_cat(&buffer, fmsg.str, fmsg.len);
 815   __kmp_str_free(&fmsg.str);
 816
 817   // Format other messages.
 818   for (;;) {
 819     message = va_arg(args, kmp_msg_t);
 820     if (message.type == kmp_mt_dummy && message.str == NULL) {
 821       break;
 822     }
 823     switch (message.type) {
 824     case kmp_mt_hint: {
 825       format = kmp_i18n_fmt_Hint;
 826       // we cannot skip %1$ and only use %2$ to print the message without the
 827       // number
 828       fmsg = __kmp_msg_format(format, message.str);
 829     } break;
 830     case kmp_mt_syserr: {
 831       format = kmp_i18n_fmt_SysErr;
 832       fmsg = __kmp_msg_format(format, message.num, message.str);
 833     } break;
 834     default: { KMP_DEBUG_ASSERT(0); }
 835     }
 836     __kmp_str_free(&message.str);
 837     __kmp_str_buf_cat(&buffer, fmsg.str, fmsg.len);
 838     __kmp_str_free(&fmsg.str);
 839   }
 840
 841   // Print formatted messages.
 842   // This lock prevents multiple fatal errors on the same problem.
 843   // __kmp_acquire_bootstrap_lock( & lock );    // GEH - This lock causing tests
 844   // to hang on OS X*.
 845   __kmp_printf("%s", buffer.str);
 846   __kmp_str_buf_free(&buffer);
 847
 848   // __kmp_release_bootstrap_lock( & lock );  // GEH - this lock causing tests
 849   // to hang on OS X*.
 850
 851 } // __kmp_msg
 852
 853 void __kmp_msg(kmp_msg_severity_t severity, kmp_msg_t message, ...) {
 854   va_list args;
 855   va_start(args, message);
 856   __kmp_msg(severity, message, args);
 857   va_end(args);
 858 }
 859
 860 void __kmp_fatal(kmp_msg_t message, ...) {
 861   va_list args;
 862   va_start(args, message);
 863   __kmp_msg(kmp_ms_fatal, message, args);
 864   va_end(args);
 865 #if KMP_OS_WINDOWS
 866   // Delay to give message a chance to appear before reaping
 867   __kmp_thread_sleep(500);
 868 #endif
 869   __kmp_abort_process();
 870 } // __kmp_fatal
 871
 872 // end of file //