[SystemZ][z/OS] Missing locale functions libc++

[muiez]

Summary

The aim is to add the missing z/OS specific locale functions for libc++ (newlocale, freelocale and uselocale).

[ldionne]

I am fine with this change in the sense of how it integrates with the rest of libc++. I did not review the implementation itself - I trust you folks that it works, otherwise it'll break on your own platform :-).

I strongly recommend addressing my small comment about the formatting in uselocale.

libcxx/src/support/ibm/xlocale_zos.cpp

123–126

This is a really really weird way to save a few lines of code. I would never do that, it looks too much like an unintended mistake.

[ldionne]

Also, please wait for CI to finish before you ship this.

[muiez]

Coding style addressed

[curdeius]

Some nitty-picky comments.

libcxx/src/support/ibm/xlocale_zos.cpp

19

Nit (here and elsewhere): comments are supposed to be full phrases with full stops (dots) at the end.

78

CamelCase? If think that snake_case should be used.

99

previously current -> previous?

102

Typo: separated.

[muiez]

addressed comments

[curdeius]

LGTM.

libcxx/include/__support/ibm/locale_mgmt_zos.h

45

Last missing dot (no need to update the review, just add it when landing).

[muiez]

added last dot in comment

libcxx/include/CMakeLists.txt

set(files
   string.h
   string_view
   strstream
   __support/android/locale_bionic.h
   __support/fuchsia/xlocale.h
   __support/ibm/gettod_zos.h
   __support/ibm/limits.h
   __support/ibm/locale_mgmt_aix.h
+  __support/ibm/locale_mgmt_zos.h
   __support/ibm/nanosleep.h
   __support/ibm/support.h
   __support/ibm/xlocale.h
   __support/musl/xlocale.h
   __support/newlib/xlocale.h
   __support/nuttx/xlocale.h
   __support/openbsd/xlocale.h
   __support/solaris/floatingpoint.h

libcxx/include/__support/ibm/locale_mgmt_zos.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SUPPORT_IBM_LOCALE_MGMT_ZOS_H
+#define _LIBCPP_SUPPORT_IBM_LOCALE_MGMT_ZOS_H
+
+#if defined(__MVS__)
+#include <locale.h>
+#include <string>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define _LC_MAX           LC_MESSAGES          /* highest real category */
+#define _NCAT             (_LC_MAX + 1)        /* maximum + 1 */
+
+#define _CATMASK(n)       (1 << (n))
+#define LC_COLLATE_MASK   _CATMASK(LC_COLLATE)
+#define LC_CTYPE_MASK     _CATMASK(LC_CTYPE)
+#define LC_MONETARY_MASK  _CATMASK(LC_MONETARY)
+#define LC_NUMERIC_MASK   _CATMASK(LC_NUMERIC)
+#define LC_TIME_MASK      _CATMASK(LC_TIME)
+#define LC_MESSAGES_MASK  _CATMASK(LC_MESSAGES)
+#define LC_ALL_MASK       (_CATMASK(_NCAT) - 1)
+
+typedef struct locale_struct {
+  int category_mask;
+  std::string lc_collate;
+  std::string lc_ctype;
+  std::string lc_monetary;
+  std::string lc_numeric;
+  std::string lc_time;
+  std::string lc_messages;
+} * locale_t;
+
+// z/OS does not have newlocale, freelocale and uselocale.
+// The functions below are workarounds in single thread mode
+locale_t newlocale(int category_mask, const char* locale, locale_t base);
+void freelocale(locale_t locobj);
+locale_t uselocale(locale_t newloc);
+
+#ifdef __cplusplus
+}
+#endif
+#endif // defined(__MVS__)
+#endif // _LIBCPP_SUPPORT_IBM_LOCALE_MGMT_ZOS_H

libcxx/include/__support/ibm/xlocale.h

 // -*- C++ -*-
 //===-----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_SUPPORT_IBM_XLOCALE_H
 #define _LIBCPP_SUPPORT_IBM_XLOCALE_H
 
 #include <__support/ibm/locale_mgmt_aix.h>
+#include <__support/ibm/locale_mgmt_zos.h>
 
 #include "cstdlib"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #if defined(_AIX)

libcxx/src/CMakeLists.txt

list(APPEND LIBCXX_SOURCES
       )
   endif()
 elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
   list(APPEND LIBCXX_SOURCES
     support/solaris/mbsnrtowcs.inc
     support/solaris/wcsnrtombs.inc
     support/solaris/xlocale.cpp
     )
+elseif(ZOS)
+  list(APPEND LIBCXX_SOURCES
+    support/ibm/xlocale_zos.cpp
+    )
 endif()
 
 if (LIBCXX_ENABLE_FILESYSTEM)
   list(APPEND LIBCXX_SOURCES
     filesystem/filesystem_common.h
     filesystem/operations.cpp
     filesystem/directory_iterator.cpp
     filesystem/posix_compat.h

libcxx/src/support/ibm/xlocale_zos.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__support/ibm/xlocale.h>
+#include <sstream>
+#include <vector>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+locale_t newlocale(int category_mask, const char* locale, locale_t base) {
+  // Maintain current locale name(s) to restore later
+  std::string current_loc_name(setlocale(LC_ALL, 0));
+
+  // Check for errors
+  if (category_mask == LC_ALL_MASK && setlocale(LC_ALL, locale) == NULL) {
+    errno = EINVAL;
+    return (locale_t)0;
+  } else {
+    for (int _Cat = 0; _Cat <= _LC_MAX; ++_Cat) {
+      if ((_CATMASK(_Cat) & category_mask) != 0 && setlocale(_Cat, locale) == NULL) {
+        setlocale(LC_ALL, current_loc_name.c_str());
+        errno = EINVAL;
+        return (locale_t)0;
+      }
+    }
+  }
+  
+  // Create new locale
+  locale_t newloc = new locale_struct();
+
+  if (base) {
+    if (category_mask != LC_ALL_MASK) {
+      // Copy base when it will not be overwritten
+      memcpy(newloc, base, sizeof (locale_struct));
+      newloc->category_mask = category_mask | base->category_mask;
+    }
+    delete base;
+  } else {
+    newloc->category_mask = category_mask;
+  }
+
+  if (category_mask & LC_COLLATE_MASK)
+    newloc->lc_collate = locale;
+  if (category_mask & LC_CTYPE_MASK)
+    newloc->lc_ctype = locale;
+  if (category_mask & LC_MONETARY_MASK)
+    newloc->lc_monetary = locale;
+  if (category_mask & LC_NUMERIC_MASK)
+    newloc->lc_numeric = locale;
+  if (category_mask & LC_TIME_MASK)
+    newloc->lc_time = locale;
+  if (category_mask & LC_MESSAGES_MASK)
+    newloc->lc_messages = locale;
+
+  // Restore current locale
+  setlocale(LC_ALL, current_loc_name.c_str());
+  return (locale_t)newloc;
+}
+
+void freelocale(locale_t locobj) {
+  delete locobj;
+}
+
+locale_t uselocale(locale_t newloc) {
+  // Maintain current locale name(s)
+  std::string current_loc_name(setlocale(LC_ALL, 0));
+
+  if (newloc) {
+    // Set locales and check for errors
+    bool isError = 
+      (newloc->category_mask & LC_COLLATE_MASK && 
+        setlocale(LC_COLLATE, newloc->lc_collate.c_str()) == NULL) ||
+      (newloc->category_mask & LC_CTYPE_MASK && 
+        setlocale(LC_CTYPE, newloc->lc_ctype.c_str()) == NULL) ||
+      (newloc->category_mask & LC_MONETARY_MASK && 
+        setlocale(LC_MONETARY, newloc->lc_monetary.c_str()) == NULL) ||
+      (newloc->category_mask & LC_NUMERIC_MASK && 
+        setlocale(LC_NUMERIC, newloc->lc_numeric.c_str()) == NULL) ||
+      (newloc->category_mask & LC_TIME_MASK && 
+        setlocale(LC_TIME, newloc->lc_time.c_str()) == NULL) ||
+      (newloc->category_mask & LC_MESSAGES_MASK && 
+        setlocale(LC_MESSAGES, newloc->lc_messages.c_str()) == NULL);
+
+    if (isError) {
+      setlocale(LC_ALL, current_loc_name.c_str());
+      errno = EINVAL;
+      return (locale_t)0;
+    }
+  }
+
+  // Construct and return previously current locale
+  locale_t current_loc = new locale_struct();
+
+  // current_loc_name might be a comma-seperated locale name list
+  if (current_loc_name.find(',') != std::string::npos) {
+    // Tokenize locale name list
+    const char delimiter = ',';
+    std::vector<std::string> tokenized;
+    std::stringstream ss(current_loc_name);
+    std::string s;
+
+    while (std::getline(ss, s, delimiter)) {
+        tokenized.push_back(s);
+    }
+
+    _LIBCPP_ASSERT(tokenized.size() >= _NCAT, "locale-name list is too short");
+
+    current_loc->lc_collate = tokenized[LC_COLLATE];
+    current_loc->lc_ctype = tokenized[LC_CTYPE];
+    current_loc->lc_monetary = tokenized[LC_MONETARY];
+    current_loc->lc_numeric = tokenized[LC_NUMERIC];
+    current_loc->lc_time = tokenized[LC_TIME];
+    // Skip LC_TOD
+    current_loc->lc_messages = tokenized[LC_MESSAGES];
+  } else {
+    current_loc->lc_collate = current_loc->lc_ctype =
+    current_loc->lc_monetary = current_loc->lc_numeric =
+    current_loc->lc_time = current_loc->lc_messages =
+    current_loc_name;
+  }
+
+  current_loc->category_mask = LC_ALL_MASK;
+  return current_loc;
+}
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus