[SystemZ][z/OS] ASCII/EBCDIC support for libc++

[muiez]

Summary

The aim of this patch is to provide ASCII/EBCDIC support for libc++ on z/OS and start a discussion about the approach. The approach taken involves using different inline namespaces for the ASCII/EBCDIC versions of the functions, and having implementations based on whether __NATIVE_ASCII_F is defined. More details are in the design document.

It should be noted that this patch does not include the script to build libc++ on z/OS in both 32 and 64-bit mode (and combining the A/E in a shared library). This will be in a separate patch.

Nonetheless, this patch cannot yet land because of a dependency on an underlying compiler feature (pragma map), which is in the works of being upstreamed.

[• Quuxplusone]

This is above my pay grade, but FWIW, this looks to me like a huge unmaintainable complication. It feels bad to say "you must take on the huge burden of maintaining this out-of-tree," but IMHO it would be worse for libc++ to say "libc++ should take on the burden of maintaining this in-tree."
If @ldionne feels the same, then perhaps a compromise approach would be to propose merely granularizing the src/ files enough to segregate "code affected by this patch" from "code that isn't." Right now the PR is a maze of #ifdefs; I assume it would be easier for you to maintain an out-of-tree patch if it was just "swap out these few specific files."

[SeanP]

@Quuxplusone what parts of this do you feel are unmaintainable? We are open to ideas on how to address any concerns you have.

I see the changes break down into these groups:

• adding the namespace wrappers - these are simple additions that shouldn't impact anyone outside of z/OS
• platform specializations - these have #if's but always (except for two table definitions) occur within a block handling specialization for other platforms too
• code wrapped in _LIBCPP_ADDITIONAL_CHAR_ENCODING - I like the idea of moving these to separate files. It was one alterative we considered
• error messages - yes these add a bunch of #if's. This sounds like the code that alarmed you. We have a better solution being worked on. That solution replaces the string literals with passing an enum to a macro. We can remove these changes and promote the new solution when ready. The new solution gets rid of all of those #if's.

I really don't want to create a separate copy of the library as that will just be forking it. We would rather point customers to one place to get their C++ library.

[SeanP]

libcxx/docs/DesignDocs/MultipleCharEncodings.rst

90

We have a better way of doing this that is being worked on now.

In a nutshell code like:

return string("The associated promise has been destructed prior "
                      "to the associated state becoming ready.");

will be replaced with:

return string(getMessage(_BROKEN_PROMISE));

and getMessage will expand out to an array of the strings index.

This will eliminate all of the #if's. I also see a potential benefit that this could be the ground work for enabling internationalization of the runtime messages.

[muiez]

Improved solution for error messages, eliminate #ifs.

[muiez]

Update design doc to account for alternate solution to translate libcxx err messages based on char-mode.

[muiez]

libcxx/docs/DesignDocs/MultipleCharEncodings.rst

90

Updated the diff to include this better way of translating error messages.

[• Quuxplusone]

libcxx/include/filesystem

921

My comment about "merely granularizing", concretely, would be something like "pull out lines 910–1518 into a new header, libcxx/include/__filesystem/somemeaningfulname.h," so that we didn't have headers that flipped back and forth between CES and non-CES "modes"; every header would be either all-under-CES or never-mention-CES.

I'm not saying that you clearly should do that granularizing. If ldionne or whoever didn't like that direction, or didn't like the PR regardless, then I admit it would be wasted work on your part. However, if you have the cycles to spare, I think it would be at least, interesting to see that approach proof-of-concepted.

Also, if you did that, then I bet you could make combined macros _LIBCPP_BEGIN_NAMESPACE_STD_CES and _LIBCPP_END_NAMESPACE_STD_CES, because you'd never be opening the CES namespace without also opening _VSTD. Right?

[muiez]

@ldionne, any thoughts on the approach and/or discussion so far? Your insight would be appreciated.

[ldionne]

Thanks for the detailed design document, this was really helpful in understanding what this patch is about.

However, I share @Quuxplusone 's concerns. This is adding a lot of complexity, especially the part about deciding whether a function should be in an encoding-dependent namespace or not. This means that whenever we add new code, we'll need to ask ourselves the question "oh, should this be in a CES namespace or not"? This is on the same level of annoyance as the _LIBCPP_INLINE_VISIBILITY macro we have everywhere (but wait, not quite everywhere, which is why it's so evil), which is an enormous mess and a barrier to contributions, a source of bugs, and a source of confusion all the time. I am concerned by the approach taken here, as I feel it's adding just another _LIBCPP_INLINE_VISIBILITY.

I suspect there are alternate solutions to supporting multiple encodings without mangling the library like this. For starters, it seems like the namespacing is primarily aimed at reducing code duplication when you link two libc++s built with different character encodings, instead of using the existing knob for tweaking the namespace, i.e. defining _LIBCPP_ABI_NAMESPACE. I believe you could build the whole library twice, once with _LIBCPP_ABI_NAMESPACE=__ascii and once with _LIBCPP_ABI_NAMESPACE=__ebcdic instead. You'd end up with more code duplication, however I believe it would be vastly more beneficial and general to solve this problem by working on enabling better code de-duplication at the optimizer level. I know there has been a lot of work on outlining in LLVM, for example, perhaps that could be investigated? IOW: I think libc++ already gives you the knob you need for the namespace changes you're making here -- they might not be granular enough, however mangling the library isn't the right way to get what you need.

Regarding the string literals, I don't have as big an issue with those -- it looks roughly like an attempt to localize those error messages, which is not convenient but at least it is systematic. However, I don't understand why the compiler isn't performing those translations itself, since it knows which encoding we're compiling for.

To make progress on this:

1. Have you tried using _LIBCPP_ABI_NAMESPACE?
2. Is it possible for the compiler to perform the encoding translation for string literals? It would not only be simpler, but it would also solve issues more generally for your users who want to use alternate encodings, not only in libc++/libc++abi.

TL;DR: These changes are quite intrusive and mangling the library like this doesn't strike me as the right approach, especially since I think we already have general knobs to solve some of these issues. It adds a lot of complexity and room for mistakes for the benefit of a single platform. I would like to investigate alternate ways to solve your problems, with some possible avenues to explore laid out above.

[muiez]

Thanks @ldionne for your detailed feedback and suggestions.

To make progress on this:

1. Have you tried using _LIBCPP_ABI_NAMESPACE?

I prototyped with your suggestion to build the whole library twice, once with _LIBCPP_ABI_NAMESPACE=__ascii and once with _LIBCPP_ABI_NAMESPACE=__ebcdic; however, some symbols (with this approach) should not end up having __ascii / __ebcdic variations. In particular, we need to make sure there is only one variation generated, outside the A/E namespace. For example, we want the *error_category to be independent of A/E. These can be passed and thrown around. We want a system_error_category to be handled the same regardless whether it came from A or E. With that being said, would it be okay to move these instances to the c++abi (like std::exception was)? Or should we exclude them from the _LIBCPP_ABI_NAMESPACE part, for example using:

namespace std  // purposefully not using versioning namespace
{
...
}

We can gather a list of candidates to cross check with you; however, the first ones that come to mind are the exception derived classes and mutex's.

[muiez]

Resolve merge conflict with main

[muiez]

Closing since this patch is divided into the following (with comments addressed and better approach):

• Foundational A/E changes: https://reviews.llvm.org/D114813
• Localize runtime error messages: https://reviews.llvm.org/D118179
• Add ASCII/32bit variant: https://reviews.llvm.org/D118503
• Exception derived classes as a separate library for z/OS: https://reviews.llvm.org/D118620

libcxx/docs/DesignDocs/MultipleCharEncodings.rst

+
+============================
+Multiple Character Encodings
+============================
+
+Rationale
+------------------------------------------
+Some platforms, such as z/OS, support multiple character encodings. In turn, the runtime needs to provide 
+several versions of the library as well. For example, z/OS needs an EBCDIC and ASCII version for character
+encoding sensitive (CES) instances.
+
+Approach
+------------------------------------------
+
+Injecting inline namespaces for CES instances. Each encoding will have a seperate inline namespace.
+For example, when an ordinary function calls a function in the CES namespace it splits off into the appropriate encoding path
+(such as ASCII or EBCDIC). To achieve this, we define the :code:`_LIBCPP_BEGIN_NAMESPACE_CES` and :code:`_LIBCPP_END_NAMESPACE_CES` macros in `libcxx/include/__config` to wrap CES 
+members of the enclosing namespace. Note, the definition of these macros are conditional on the character mode set at compile time (for example the :code:`-fzos-le-char-mode=ascii` Clang option on z/OS). However, they are defined empty for non-CES platforms.
+
+************
+Implications
+************
+
+To allow for multiple versions of the library to be shipped as one, we need to build the library as many times as
+the number of encodings (with appropriate options set for each build) and combine the symbols. For z/OS, this will be twice (once for EBCDIC and another for ASCII). 
+In particular, only CES source files (i.e. files that have CES code), need to be compiled more than once. For example, on z/OS there is a list (:code:`LIBCXX_CHARS_SENSITIVE_SOURCES`
+in `libcxx/src/CMakeLists.txt`) that maintains the CES source files. In other words, the libc++ library is compiled in EBCDIC encoding and a few files (:code:`LIBCXX_CHARS_SENSITIVE_SOURCES`) are
+compiled in the alternative (ASCII) encoding as well.
+
+
+Nonetheless, CES source files and headers may have symbols that are outside the CES namespace. When building more than once, this may lead to 
+duplicate symbols. To avoid this, the :code:`_LIBCPP_ADDITIONAL_CHAR_ENCODING` macro is defined for the additional encodings to prevent duplication of exported symbols. With regards to z/OS, the primary encoding is EBCDIC and the additional char encoding is ASCII (fixed in *libcxx/include/__config*).
+For example, :code:`__throw_runtime_error` in *libcxx/src/locale.cpp* is wrapped as follows to avoid compiling more than once.
+
+.. code-block:: c++
+
+    #if !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
+    void __throw_runtime_error(const char* msg)
+    {
+    ...
+    }
+    #endif // !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
+
+It should be noted that injecting a namespace will alter the symbol names exported from the library. As a result, recompilation of programs may be required.
+
+************************************************
+What is considered character encoding sensitive?
+************************************************
+Exported classes and functions that deal with character and string literals and such functionality are subject to being CES. In general, examining the signature should help determine if an instance 
+should be in the CES namespace:
+
+- Functions with :code:`[w]char *` in their signature (i.e. arguments and/or return type).
+- String conversion functions such as :code:`to_string(int __val)`.
+- The :code:`char_traits` class. This allows us to avoid having unnecessary classes in the CES namespace. In particular, this class is used to handle most of the encoding, 
+  since many CES instances are instantiated with the :code:`char_traits` class. For example, :code:`basic_string` is already a template instantiated with multiple 
+  character types (see demangled symbol above). 
+  
+  Nontheless, classes/functions only need the CES namespace added if they have encoding 
+  sensitive features and *don't* have :code:`char_traits` as a template parameter.
+- The :code:`ios_base` class. This is needed to handle CES I/O. 
+
+It should be noted that this is not an exhaustive list.
+
+Exception classes should **not** be in the CES namespaces, otherwise the throw may not be caught at the right place. 
+
+********************************************
+How to add an instance to the CES namespace?
+********************************************
+
+Simply put, we need to wrap the declaration and definition with :code:`_LIBCPP_BEGIN_NAMESPACE_CES` and :code:`_LIBCPP_END_NAMESPACE_CES`. For example,
+here is how :code:`char_traits` class was added to the CES namespace:
+
+.. code-block:: c++
+
+    _LIBCPP_BEGIN_NAMESPACE_CES
+
+    // char_traits
+    template <class _CharT>
+    struct _LIBCPP_TEMPLATE_VIS char_traits {
+    ...
+    }
+
+    _LIBCPP_END_NAMESPACE_CES
+
+Note that there might be more dependencies so other instances may need to be added to the CES namespace as well.
+ 
+*********************
+Enabling bimodal mode
+*********************
+
+There are some instances that we must select the correct encoding during the **execution** of a program. For example, :code:`__future_error_category::message(int)` (`libcxx/src/future.cpp`) should be returned
+in EBCDIC or ASCII depending on the execution environment. Hence, we have an approach to have both (EBCDIC & ASCII) encodings in RTTI (Runtime Type Information). In particular, we replace string literals with
+passing an enum to a macro.
+
+For example, code like:
+
+:code:`return string("The associated promise has been destructed prior to the associated state becoming ready.");`
+
+will be replaced with:
+
+:code:`return string(getMessage(_BROKEN_PROMISE));`

libcxx/include/__config

 #  include <features.h>
 #  if defined(__GLIBC_PREREQ)
 #    define _LIBCPP_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b)
 #  else
 #    define _LIBCPP_GLIBC_PREREQ(a, b) 0
 #  endif // defined(__GLIBC_PREREQ)
 #endif // defined(__linux__)
 
+// CES stands for CHAR_ENCODING_SENSITIVE
+#if defined(__MVS__) 
+#include <features.h> // for __NATIVE_ASCII_F
+#ifdef __NATIVE_ASCII_F
+  #define _LIBCPP_ADDITIONAL_CHAR_ENCODING
+  #define _LIBCPP_CES_NAMESPACE _ASCII::
+  #define _LIBCPP_BEGIN_NAMESPACE_CES inline namespace _ASCII {
+  #define _LIBCPP_END_NAMESPACE_CES                           }
+#else
+  #define _LIBCPP_CES_NAMESPACE _EBCDIC::
+  #define _LIBCPP_BEGIN_NAMESPACE_CES inline namespace _EBCDIC {
+  #define _LIBCPP_END_NAMESPACE_CES                            }
+#endif // __NATIVE_ASCII_F
+#else
+#define _LIBCPP_CES_NAMESPACE
+#define _LIBCPP_BEGIN_NAMESPACE_CES
+#define _LIBCPP_END_NAMESPACE_CES
+#endif // defined(__MVS__)
+
 #ifdef __LITTLE_ENDIAN__
 #  if __LITTLE_ENDIAN__
 #    define _LIBCPP_LITTLE_ENDIAN
 #  endif  // __LITTLE_ENDIAN__
 #endif // __LITTLE_ENDIAN__
 
 #ifdef __BIG_ENDIAN__
 #  if __BIG_ENDIAN__

 // Some systems do not provide gets() in their C library, for security reasons.
 #if defined(_LIBCPP_MSVCRT) || \
     (defined(__FreeBSD_version) && __FreeBSD_version >= 1300043) || \
     defined(__OpenBSD__)
 #   define _LIBCPP_C_HAS_NO_GETS
 #endif
 
 #if defined(__BIONIC__) || defined(__NuttX__) ||      \
-    defined(__Fuchsia__) || defined(__wasi__) || defined(_LIBCPP_HAS_MUSL_LIBC) || \
-    defined(__MVS__) || defined(__OpenBSD__)
+    defined(__Fuchsia__) || defined(__wasi__) ||      \
+    defined(_LIBCPP_HAS_MUSL_LIBC) || defined(__OpenBSD__)
 #define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
 #endif
 
 #if __has_feature(cxx_atomic) || __has_extension(c_atomic) || __has_keyword(_Atomic)
 #  define _LIBCPP_HAS_C_ATOMIC_IMP
 #elif defined(_LIBCPP_COMPILER_GCC)
 #  define _LIBCPP_HAS_GCC_ATOMIC_IMP
 #endif

libcxx/include/__iterator/ostreambuf_iterator.h

 #include <iosfwd> // for forward declaration of basic_streambuf
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+_LIBCPP_BEGIN_NAMESPACE_CES
+template <class _Ch, class _Tr>
+_LIBCPP_HIDDEN
+ostreambuf_iterator<_Ch, _Tr>
+__pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s,
+                 const _Ch* __ob, const _Ch* __op, const _Ch* __oe,
+                 ios_base& __iob, _Ch __fl);
+_LIBCPP_END_NAMESPACE_CES
+
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator
 #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
     : public iterator<output_iterator_tag, void, void, void, void>
 #endif
 {
 _LIBCPP_SUPPRESS_DEPRECATED_POP
public:
     _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++()    {return *this;}
     _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++(int) {return *this;}
     _LIBCPP_INLINE_VISIBILITY bool failed() const _NOEXCEPT {return __sbuf_ == nullptr;}
 
     template <class _Ch, class _Tr>
     friend
     _LIBCPP_HIDDEN
     ostreambuf_iterator<_Ch, _Tr>
-    __pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s,
+    _LIBCPP_CES_NAMESPACE __pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s,
                      const _Ch* __ob, const _Ch* __op, const _Ch* __oe,
                      ios_base& __iob, _Ch __fl);
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_OSTREAMBUF_ITERATOR_H

libcxx/include/__locale

 # include <__support/musl/xlocale.h>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 #if !defined(_LIBCPP_LOCALE__L_EXTENSIONS)
 struct __libcpp_locale_guard {
   _LIBCPP_INLINE_VISIBILITY
   __libcpp_locale_guard(locale_t& __loc) : __old_loc_(uselocale(__loc)) {}
 
   _LIBCPP_INLINE_VISIBILITY
   ~__libcpp_locale_guard() {
#elif defined(_NEWLIB_VERSION)
     static const mask digit  = _N;
     static const mask punct  = _P;
     static const mask xdigit = _X | _N;
     static const mask blank  = _B;
     static const mask __regex_word = 0x80;
 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
 # define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT
+#elif defined(__MVS__)
+#if defined(__NATIVE_ASCII_F)
+    typedef unsigned int mask;
+    static const mask space  = _ISSPACE_A;
+    static const mask print  = _ISPRINT_A;
+    static const mask cntrl  = _ISCNTRL_A;
+    static const mask upper  = _ISUPPER_A;
+    static const mask lower  = _ISLOWER_A;
+    static const mask alpha  = _ISALPHA_A;
+    static const mask digit  = _ISDIGIT_A;
+    static const mask punct  = _ISPUNCT_A;
+    static const mask xdigit = _ISXDIGIT_A;
+    static const mask blank  = _ISBLANK_A;
+#else
+    typedef unsigned short mask;
+    static const mask space  = __ISSPACE;
+    static const mask print  = __ISPRINT;
+    static const mask cntrl  = __ISCNTRL;
+    static const mask upper  = __ISUPPER;
+    static const mask lower  = __ISLOWER;
+    static const mask alpha  = __ISALPHA;
+    static const mask digit  = __ISDIGIT;
+    static const mask punct  = __ISPUNCT;
+    static const mask xdigit = __ISXDIGIT;
+    static const mask blank  = __ISBLANK;
+#endif
+    static const mask __regex_word = 0x8000;
 #else
 # error unknown rune table for this platform -- do you mean to define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE?
 #endif
     static const mask alnum  = alpha | digit;
     static const mask graph  = alnum | punct;
 
     _LIBCPP_INLINE_VISIBILITY ctype_base() {}
 };

 #if defined(__GLIBC__) || defined(__EMSCRIPTEN__)
     static const int* __classic_upper_table() _NOEXCEPT;
     static const int* __classic_lower_table() _NOEXCEPT;
 #endif
 #if defined(__NetBSD__)
     static const short* __classic_upper_table() _NOEXCEPT;
     static const short* __classic_lower_table() _NOEXCEPT;
 #endif
+#if defined(__MVS__)
+    static const unsigned short* __classic_upper_table() _NOEXCEPT;
+    static const unsigned short* __classic_lower_table() _NOEXCEPT;
+#endif
 
 protected:
     ~ctype();
     virtual char_type do_toupper(char_type __c) const;
     virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
     virtual char_type do_tolower(char_type __c) const;
     virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
     virtual char_type do_widen(char __c) const;

 protected:
     ~numpunct_byname();
 
 private:
     void __init(const char*);
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___LOCALE

libcxx/include/__string

#define _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
   _Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, basic_string const&, size_type, size_type) const) \
   _Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*, size_type) const) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*)) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, basic_string const&, size_type, size_type)) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::iterator basic_string<_CharType>::insert(basic_string::const_iterator, value_type)) \
   _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::resize(size_type, value_type)) \
   _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, basic_string const&, size_type, size_type))
 
-
+_LIBCPP_BEGIN_NAMESPACE_CES
 // char_traits
 
 template <class _CharT>
 struct _LIBCPP_TEMPLATE_VIS char_traits
 {
     typedef _CharT    char_type;
     typedef int       int_type;
     typedef streamoff off_type;
struct __quoted_output_proxy
     _CharT  __delim;
     _CharT  __escape;
 
     __quoted_output_proxy(_Iter __f, _Iter __l, _CharT __d, _CharT __e)
     : __first(__f), __last(__l), __delim(__d), __escape(__e) {}
     //  This would be a nice place for a string_ref
 };
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___STRING

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;
 
+_LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 // 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
+_LIBCPP_FUNC_VIS locale_t newlocale(int category_mask, const char* locale, locale_t base);
+_LIBCPP_FUNC_VIS void freelocale(locale_t locobj);
+_LIBCPP_FUNC_VIS locale_t uselocale(locale_t newloc);
+
+_LIBCPP_END_NAMESPACE_CES
+_LIBCPP_END_NAMESPACE_STD
+
 #endif // defined(__MVS__)
 #endif // _LIBCPP_SUPPORT_IBM_LOCALE_MGMT_ZOS_H

libcxx/include/__support/ibm/xlocale.h

 #include <__support/xlocale/__posix_l_fallback.h>
 #endif // defined(__MVS__)
 
 namespace {
 
 struct __setAndRestore {
   explicit __setAndRestore(locale_t locale) {
     if (locale == (locale_t)0) {
-      __cloc = newlocale(LC_ALL_MASK, "C", /* base */ (locale_t)0);
-      __stored = uselocale(__cloc);
+      __cloc = std::newlocale(LC_ALL_MASK, "C", /* base */ (locale_t)0);
+      __stored = std::uselocale(__cloc);
     } else {
-      __stored = uselocale(locale);
+      __stored = std::uselocale(locale);
     }
   }
 
   ~__setAndRestore() {
-    uselocale(__stored);
+    std::uselocale(__stored);
     if (__cloc)
-      freelocale(__cloc);
+      std::freelocale(__cloc);
   }
 
 private:
   locale_t __stored = (locale_t)0;
   locale_t __cloc = (locale_t)0;
 };
 
 } // namespace

libcxx/include/charconv

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 namespace __itoa {
 _LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u64toa(uint64_t __value, char* __buffer) _NOEXCEPT;
 _LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u32toa(uint32_t __value, char* __buffer) _NOEXCEPT;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 

 from_chars(const char* __first, const char* __last, _Tp& __value, int __base)
 {
     _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
     return __from_chars_integral(__first, __last, __value, __base);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_CHARCONV

libcxx/include/codecvt

 #include <__config>
 #include <__locale>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 enum codecvt_mode
 {
     consume_header = 4,
     generate_header = 2,
     little_endian = 1
 };
 
public:
     _LIBCPP_INLINE_VISIBILITY
     explicit codecvt_utf8_utf16(size_t __refs = 0)
         : __codecvt_utf8_utf16<_Elem>(__refs, _Maxcode, _Mode) {}
 
     _LIBCPP_INLINE_VISIBILITY
     ~codecvt_utf8_utf16() {}
 };
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_CODECVT

libcxx/include/filesystem

public:
   _LIBCPP_INLINE_VISIBILITY
   void permissions(perms __p) noexcept { __prms_ = __p; }
 
 private:
   file_type __ft_;
   perms __prms_;
 };
 
+_LIBCPP_BEGIN_NAMESPACE_CES
 class _LIBCPP_TYPE_VIS directory_entry;
+_LIBCPP_END_NAMESPACE_CES
 
 template <class _Tp>
 struct __can_convert_char {
   static const bool value = false;
 };
 template <class _Tp>
 struct __can_convert_char<const _Tp> : public __can_convert_char<_Tp> {};
 template <>
struct _PathExport<char8_t> {
 
   template <class _Str>
   static void __append(_Str& __dest, const __path_string& __src) {
     _Narrower()(back_inserter(__dest), __src.data(), __src.data() + __src.size());
   }
 };
 #endif /* !_LIBCPP_HAS_NO_CHAR8_T */
 #endif /* _LIBCPP_WIN32API */
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 class _LIBCPP_TYPE_VIS path {
   template <class _SourceOrIter, class _Tp = path&>
   using _EnableIfPathable =
       typename enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type;
 
   template <class _Tp>
   using _SourceChar = typename __is_pathable<_Tp>::__char_type;
private:
   inline _LIBCPP_INLINE_VISIBILITY path&
   __assign_view(__string_view const& __s) noexcept {
     __pn_ = string_type(__s);
     return *this;
   }
   string_type __pn_;
 };
 
+_LIBCPP_END_NAMESPACE_CES
+
 inline _LIBCPP_INLINE_VISIBILITY void swap(path& __lhs, path& __rhs) noexcept {
   __lhs.swap(__rhs);
 }
 
 _LIBCPP_FUNC_VIS
 size_t hash_value(const path& __p) noexcept;
 
 template <class _InputIt>

 #if defined(_LIBCPP_WIN32API)
   using _Traits = __is_pathable<_Source>;
   return u8path(_VSTD::__unwrap_iter(_Traits::__range_begin(__s)), _VSTD::__unwrap_iter(_Traits::__range_end(__s)));
 #else
   return path(__s);
 #endif
 }
 
+_LIBCPP_BEGIN_NAMESPACE_CES
 class _LIBCPP_TYPE_VIS path::iterator {
 public:
   enum _ParserState : unsigned char {
     _Singular,
     _BeforeBegin,
     _InRootName,
     _InRootDir,
     _InFilenames,
return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
          __lhs.__entry_.data() == __rhs.__entry_.data();
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path::iterator& __lhs,
                                                  const path::iterator& __rhs) {
   return !(__lhs == __rhs);
 }
 
+_LIBCPP_END_NAMESPACE_CES
+
 // TODO(ldionne): We need to pop the pragma and push it again after
 //                filesystem_error to work around PR41078.
 _LIBCPP_AVAILABILITY_FILESYSTEM_POP
 
 class _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
 public:
   _LIBCPP_INLINE_VISIBILITY
   filesystem_error(const string& __what, error_code __ec)

 }
 #else
 void __throw_filesystem_error(_Args&&...) {
   _VSTD::abort();
 }
 #endif
 
 // operational functions
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 _LIBCPP_FUNC_VIS
 path __absolute(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 path __canonical(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 void __copy(const path& __from, const path& __to, copy_options __opt,
             error_code* __ec = nullptr);

 _LIBCPP_FUNC_VIS
 file_status __symlink_status(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 path __system_complete(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 path __temp_directory_path(error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 path __weakly_canonical(path const& __p, error_code* __ec = nullptr);
+_LIBCPP_END_NAMESPACE_CES
 
 inline _LIBCPP_INLINE_VISIBILITY path current_path() {
   return __current_path();
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path current_path(error_code& __ec) {
   return __current_path(&__ec);
 }
inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p) {
   return __weakly_canonical(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p,
                                                        error_code& __ec) {
   return __weakly_canonical(__p, &__ec);
 }
 
+_LIBCPP_BEGIN_NAMESPACE_CES
 class directory_iterator;
 class recursive_directory_iterator;
 class _LIBCPP_HIDDEN __dir_stream;
 
 class directory_entry {
   typedef _VSTD_FS::path _Path;
 
 public:

 begin(recursive_directory_iterator __iter) noexcept {
   return __iter;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
 end(recursive_directory_iterator) noexcept {
   return recursive_directory_iterator();
 }
+_LIBCPP_END_NAMESPACE_CES
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 template <>
 _LIBCPP_AVAILABILITY_FILESYSTEM

libcxx/include/ios

 #include <atomic>     // for __xindex_
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 typedef ptrdiff_t streamsize;
 
 class _LIBCPP_TYPE_VIS ios_base
 {
 public:
     class _LIBCPP_EXCEPTION_ABI failure;
 
#endif
     long*           __iarray_;
     size_t          __iarray_size_;
     size_t          __iarray_cap_;
     void**          __parray_;
     size_t          __parray_size_;
     size_t          __parray_cap_;
 };
 
+_LIBCPP_FUNC_VIS
+const error_category& iostream_category() _NOEXCEPT;
+_LIBCPP_END_NAMESPACE_CES
+
 //enum class io_errc
 _LIBCPP_DECLARE_STRONG_ENUM(io_errc)
 {
     stream = 1
 };
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc)
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc> : public true_type { };
 
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc::__lx> : public true_type { };
 #endif
 
-_LIBCPP_FUNC_VIS
-const error_category& iostream_category() _NOEXCEPT;
-
 inline _LIBCPP_INLINE_VISIBILITY
 error_code
 make_error_code(io_errc __e) _NOEXCEPT
 {
     return error_code(static_cast<int>(__e), iostream_category());
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_condition
 make_error_condition(io_errc __e) _NOEXCEPT
 {
     return error_condition(static_cast<int>(__e), iostream_category());
 }
 
+_LIBCPP_BEGIN_NAMESPACE_CES
+
 class _LIBCPP_EXCEPTION_ABI ios_base::failure
     : public system_error
 {
 public:
     explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
     explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
     failure(const failure&) _NOEXCEPT = default;
     virtual ~failure() _NOEXCEPT;

 inline _LIBCPP_INLINE_VISIBILITY
 void
 ios_base::exceptions(iostate __iostate)
 {
     __exceptions_ = __iostate;
     clear(__rdstate_);
 }
 
+_LIBCPP_END_NAMESPACE_CES
+
 template <class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS basic_ios
     : public ios_base
 {
 public:
     // types:
     typedef _CharT char_type;
     typedef _Traits traits_type;

libcxx/include/iosfwd

 #include <__config>
 #include <__mbstate_t.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 class _LIBCPP_TYPE_VIS ios_base;
 
 template<class _CharT>  struct _LIBCPP_TEMPLATE_VIS char_traits;
 template<> struct char_traits<char>;
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 template<> struct char_traits<char8_t>;
 #endif
 template<> struct char_traits<char16_t>;
 template<> struct char_traits<char32_t>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template<> struct char_traits<wchar_t>;
 #endif
 
+_LIBCPP_END_NAMESPACE_CES
+
 template<class _Tp>     class _LIBCPP_TEMPLATE_VIS allocator;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >
     class _LIBCPP_TEMPLATE_VIS basic_ios;
 
 template <class _CharT, class _Traits = char_traits<_CharT> >
     class _LIBCPP_TEMPLATE_VIS basic_streambuf;
 template <class _CharT, class _Traits = char_traits<_CharT> >

libcxx/include/iostream

 #include <ostream>
 #include <streambuf>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 extern _LIBCPP_FUNC_VIS istream cin;
 extern _LIBCPP_FUNC_VIS ostream cout;
 extern _LIBCPP_FUNC_VIS ostream cerr;
 extern _LIBCPP_FUNC_VIS ostream clog;
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern _LIBCPP_FUNC_VIS wistream wcin;
 extern _LIBCPP_FUNC_VIS wostream wcout;
 extern _LIBCPP_FUNC_VIS wostream wcerr;
 extern _LIBCPP_FUNC_VIS wostream wclog;
 #endif
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_IOSTREAM

libcxx/include/locale

 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 #if defined(__APPLE__) || defined(__FreeBSD__)
 #  define _LIBCPP_GET_C_LOCALE 0
 #elif defined(__NetBSD__)
 #  define _LIBCPP_GET_C_LOCALE LC_C_LOCALE
 #else
 #  define _LIBCPP_GET_C_LOCALE __cloc()
    // Get the C locale object

     {
         __rt = this;
         if ((__cm_ & ios_base::out) && sync())
             __rt = nullptr;
     }
     return __rt;
 }
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_LOCALE

libcxx/include/regex

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 #define _LIBCPP_REGEX_COMPLEXITY_FACTOR 4096
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 namespace regex_constants
 {
 
 // syntax_option_type
 
 enum syntax_option_type
 {

 bool
 regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const
 {
     if (__ct_->is(__m, __c))
         return true;
     return (__c == '_' && (__m & __regex_word));
 }
 
+#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
+    #define _MASK07 0xF0
+    #define _MASK89 0xF8
+    #define _TOLOWER(c) (c &= 0xBF)
+#else
+    #define _MASK07 0x30
+    #define _MASK89 0x38
+    #define _TOLOWER(c) (c |= 0x20)
+#endif
+
 template <class _CharT>
 int
 regex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix)
 {
-    if ((__ch & 0xF8u) == 0x30)  // '0' <= __ch && __ch <= '7'
+    if ((__ch & 0xF8u) == _MASK07)  // '0' <= __ch && __ch <= '7'
         return __ch - '0';
     if (__radix != 8)
     {
-        if ((__ch & 0xFEu) == 0x38)  // '8' <= __ch && __ch <= '9'
+        if ((__ch & 0xFEu) == _MASK89)  // '8' <= __ch && __ch <= '9'
             return __ch - '0';
         if (__radix == 16)
         {
-            __ch |= 0x20;  // tolower
+            _TOLOWER(__ch);  // tolower
             if ('a' <= __ch && __ch <= 'f')
                 return __ch - ('a' - 10);
         }
     }
     return -1;
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS

 {
     basic_string<_CharT> __r;
     _VSTD::regex_replace(back_inserter(__r), __s,
                         __s + char_traits<_CharT>::length(__s), __e,
                         __fmt, __flags);
     return __r;
 }
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_REGEX

libcxx/include/string

 void
 swap(basic_string<_CharT, _Traits, _Allocator>& __lhs,
      basic_string<_CharT, _Traits, _Allocator>& __rhs)
      _NOEXCEPT_(_NOEXCEPT_(__lhs.swap(__rhs)))
 {
     __lhs.swap(__rhs);
 }
 
+_LIBCPP_BEGIN_NAMESPACE_CES
+
 _LIBCPP_FUNC_VIS int                stoi  (const string& __str, size_t* __idx = nullptr, int __base = 10);
 _LIBCPP_FUNC_VIS long               stol  (const string& __str, size_t* __idx = nullptr, int __base = 10);
 _LIBCPP_FUNC_VIS unsigned long      stoul (const string& __str, size_t* __idx = nullptr, int __base = 10);
 _LIBCPP_FUNC_VIS long long          stoll (const string& __str, size_t* __idx = nullptr, int __base = 10);
 _LIBCPP_FUNC_VIS unsigned long long stoull(const string& __str, size_t* __idx = nullptr, int __base = 10);
 
 _LIBCPP_FUNC_VIS float       stof (const string& __str, size_t* __idx = nullptr);
 _LIBCPP_FUNC_VIS double      stod (const string& __str, size_t* __idx = nullptr);

 _LIBCPP_FUNC_VIS wstring to_wstring(unsigned long __val);
 _LIBCPP_FUNC_VIS wstring to_wstring(long long __val);
 _LIBCPP_FUNC_VIS wstring to_wstring(unsigned long long __val);
 _LIBCPP_FUNC_VIS wstring to_wstring(float __val);
 _LIBCPP_FUNC_VIS wstring to_wstring(double __val);
 _LIBCPP_FUNC_VIS wstring to_wstring(long double __val);
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
+_LIBCPP_END_NAMESPACE_CES
+
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_TEMPLATE_DATA_VIS
 const typename basic_string<_CharT, _Traits, _Allocator>::size_type
                basic_string<_CharT, _Traits, _Allocator>::npos;
 
 template <class _CharT, class _Allocator>
 struct _LIBCPP_TEMPLATE_VIS
     hash<basic_string<_CharT, char_traits<_CharT>, _Allocator> >

libcxx/include/strstream

 #include <istream>
 #include <ostream>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 class _LIBCPP_TYPE_VIS strstreambuf
     : public streambuf
 {
 public:
 #ifndef _LIBCPP_CXX03_LANG
     strstreambuf() : strstreambuf(0) {}
     explicit strstreambuf(streamsize __alsize);
#endif // _LIBCPP_CXX03_LANG
     int pcount() const {return __sb_.pcount();}
     _LIBCPP_INLINE_VISIBILITY
     char* str()        {return __sb_.str();}
 
 private:
     strstreambuf __sb_; // exposition only
 };
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STRSTREAM

libcxx/src/any.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 "any"
+#include "include/error_message.h"
 
 namespace std {
-const char* bad_any_cast::what() const noexcept {
-    return "bad any cast";
-}
+const char* bad_any_cast::what() const noexcept { return getRuntimeErrorString(RM_BAD_ANY_CAST); }
 }
 
 
 #include <experimental/__config>
 
 //  Preserve std::experimental::any_bad_cast for ABI compatibility
 //  Even though it no longer exists in a header file
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast
 {
 public:
     virtual const char* what() const noexcept;
 };
 
-const char* bad_any_cast::what() const noexcept {
-    return "bad any cast";
-}
+const char* bad_any_cast::what() const noexcept { return getRuntimeErrorString(RM_BAD_ANY_CAST); }
 
 _LIBCPP_END_NAMESPACE_LFTS

libcxx/src/charconv.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 "charconv"
 #include <string.h>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 namespace __itoa
 {
 
 static constexpr char cDigitsLut[200] = {
     '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0',
     '7', '0', '8', '0', '9', '1', '0', '1', '1', '1', '2', '1', '3', '1', '4',
     '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', '2', '0', '2', '1', '2',
else
         buffer = append4(buffer, v1 % 10000);
     }
 
     return buffer;
 }
 
 }  // namespace __itoa
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/filesystem/directory_iterator.cpp

 
 #endif
 
 } // namespace
 } // namespace detail
 
 using detail::ErrorHandler;
 
+_LIBCPP_BEGIN_NAMESPACE_CES
+
 #if defined(_LIBCPP_WIN32API)
 class __dir_stream {
 public:
   __dir_stream() = delete;
   __dir_stream& operator=(const __dir_stream&) = delete;
 
   __dir_stream(__dir_stream&& __ds) noexcept : __stream_(__ds.__stream_),
                                                __root_(move(__ds.__root_)),
if (m_ec.value() == EACCES && allow_eacess) {
       __imp_.reset();
       err.report(m_ec, "attempting recursion into " PATH_CSTR_FMT,
                  at_ent.c_str());
     }
   }
   return false;
 }
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_FILESYSTEM

libcxx/src/filesystem/operations.cpp

 using detail::capture_errno;
 using detail::ErrorHandler;
 using detail::StatT;
 using detail::TimeSpec;
 using parser::createView;
 using parser::PathParser;
 using parser::string_view_t;
 
+#if !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
 const bool _FilesystemClock::is_steady;
 
 _FilesystemClock::time_point _FilesystemClock::now() noexcept {
   typedef chrono::duration<rep> __secs;
 #if defined(_LIBCPP_WIN32API)
   typedef chrono::duration<rep, nano> __nsecs;
   FILETIME time;
   GetSystemTimeAsFileTime(&time);
__storage_->__what_ = [&]() -> string {
     case 2:
       return detail::format_string("filesystem error: %s [" PATH_CSTR_FMT "] [" PATH_CSTR_FMT "]",
                                    derived_what, path1().c_str(), path2().c_str());
     }
     _LIBCPP_UNREACHABLE();
   }();
 }
 
+#endif // !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
+
+_LIBCPP_BEGIN_NAMESPACE_CES
+
 static path __do_absolute(const path& p, path* cwd, error_code* ec) {
   if (ec)
     ec->clear();
   if (p.is_absolute())
     return p;
   *cwd = __current_path(ec);
   if (ec && *ec)
     return {};
for (; it != directory_iterator(); it.increment(m_ec2)) {
              options | copy_options::__in_recursive_copy, ec);
       if (ec && *ec) {
         return;
       }
     }
   }
 }
 
+_LIBCPP_END_NAMESPACE_CES
+
 namespace detail {
 namespace {
 
 #if defined(_LIBCPP_FILESYSTEM_USE_SENDFILE)
   bool copy_file_impl(FileDescriptor& read_fd, FileDescriptor& write_fd, error_code& ec) {
     size_t count = read_fd.get_stat().st_size;
     do {
       ssize_t res;
#elif defined(_LIBCPP_FILESYSTEM_USE_FSTREAM)
   }
 #else
 # error "Unknown implementation for copy_file_impl"
 #endif // copy_file_impl implementation
 
 } // end anonymous namespace
 } // end namespace detail
 
+_LIBCPP_BEGIN_NAMESPACE_CES
+
 bool __copy_file(const path& from, const path& to, copy_options options,
                  error_code* ec) {
   using detail::FileDescriptor;
   ErrorHandler<bool> err("copy_file", ec, &to, &from);
 
   error_code m_ec;
   FileDescriptor from_fd = FileDescriptor::create_with_status(
       &from, m_ec, O_RDONLY | O_NONBLOCK | O_BINARY);
if ((res = CompareRootDir(&LHS, &RHS)) != 0)
     return res;
 
   if ((res = CompareRelative(&LHS, &RHS)) != 0)
     return res;
 
   return CompareEndState(&LHS, &RHS);
 }
 
+_LIBCPP_END_NAMESPACE_CES
+
 ////////////////////////////////////////////////////////////////////////////
 // path.nonmembers
 size_t hash_value(const path& __p) noexcept {
   auto PP = PathParser::CreateBegin(__p.native());
   size_t hash_value = 0;
   hash<string_view_t> hasher;
   while (PP) {
     hash_value = __hash_combine(hash_value, hasher(*PP));
     ++PP;
   }
   return hash_value;
 }
 
+_LIBCPP_BEGIN_NAMESPACE_CES
+
 ////////////////////////////////////////////////////////////////////////////
 // path.itr
 path::iterator path::begin() const {
   auto PP = PathParser::CreateBegin(__pn_);
   iterator it;
   it.__path_ptr_ = this;
   it.__state_ = static_cast<path::iterator::_ParserState>(PP.State);
   it.__entry_ = PP.RawEntry;
if (_VSTD_FS::exists(st)) {
     error_code ignored_ec;
     __data_.__write_time_ =
         __extract_last_write_time(__p_, full_st, &ignored_ec);
   }
 
   return failure_ec;
 }
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_FILESYSTEM

libcxx/src/functional.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 "functional"
+#include "include/error_message.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
 bad_function_call::~bad_function_call() noexcept
 {
 }
 #endif
 
 #ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE
 const char*
 bad_function_call::what() const noexcept
 {
-    return "std::bad_function_call";
+    return getRuntimeErrorString(RM_BAD_FUNCTION_CALL);
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/future.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 "__config"
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 
 #include "future"
 #include "string"
+#include "include/error_message.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_HIDDEN __future_error_category
     : public __do_message
 {
 public:
     virtual const char* name() const noexcept;

 
 string
 __future_error_category::message(int ev) const
 {
     switch (static_cast<future_errc>(ev))
     {
     case future_errc(0):  // For backwards compatibility with C++11 (LWG 2056)
     case future_errc::broken_promise:
-        return string("The associated promise has been destructed prior "
-                      "to the associated state becoming ready.");
+      return string(getRuntimeErrorString(RM_BROKEN_PROMISE));
     case future_errc::future_already_retrieved:
-        return string("The future has already been retrieved from "
-                      "the promise or packaged_task.");
+      return string(getRuntimeErrorString(RM_FUTURE_ALREADY_RETRIEVED));
     case future_errc::promise_already_satisfied:
-        return string("The state of the promise has already been set.");
+      return string(getRuntimeErrorString(RM_PROMISE_ALREADY_SATISFIED));
     case future_errc::no_state:
-        return string("Operation not permitted on an object without "
-                      "an associated state.");
+      return string(getRuntimeErrorString(RM_NO_STATE));
     }
-    return string("unspecified future_errc value\n");
+    return string(getRuntimeErrorString(RM_UNSPECIFIED_FEV));
 }
 
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #elif defined(__GNUC__) || defined(__GNUG__)
 #pragma GCC diagnostic pop
 #endif
 

libcxx/src/include/error_message.h

+//===----------------------------------------------------------------------===////
+//
+// 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 ERROR_MESSAGE_H
+#define ERROR_MESSAGE_H
+
+#ifdef __MVS__
+#  define _AE_BIMODAL 1
+#  include <_Nascii.h>
+#endif
+
+#include "__config"
+
+#define ErrorList                                                                                                      \
+  ErrMsg(RM_BROKEN_PROMISE,                                                                                            \
+         "The associated promise has been destructed prior to the associated state becoming ready."),                  \
+      ErrMsg(RM_FUTURE_ALREADY_RETRIEVED, "The future has already been retrieved from the promise or packaged_task."), \
+      ErrMsg(RM_PROMISE_ALREADY_SATISFIED, "The state of the promise has already been set."),                          \
+      ErrMsg(RM_NO_STATE, "Operation not permitted on an object without an associated state."),                        \
+      ErrMsg(RM_UNSPECIFIED_FEV, "unspecified future_errc value\n"),                                                   \
+      ErrMsg(RM_PURE_VIRTUAL_FUNCTION, "Pure virtual function called!"),                                               \
+      ErrMsg(RM_DELETED_VIRTUAL_FUNCTION, "Deleted virtual function called!"),                                         \
+      ErrMsg(RM_WHAT_BAD_OPTIONAL, "bad_optional_access"),                                                             \
+      ErrMsg(RM_LIBCXXABI, "libc++abi: "),                                                                             \
+      ErrMsg(RM_NL, "\n"),                                                                                             \
+      ErrMsg(RM_UNSPECIFIED_ICE, "unspecified iostream_category error"),                                               \
+      ErrMsg(RM_STRERROR_MSG, "unexpected error from ::strerror_r"),                                                   \
+      ErrMsg(RM_UNKNOWN_ERROR, "Unknown error %d"),                                                                    \
+      ErrMsg(RM_UNSPECIFIED_GCE, "unspecified generic_category error"),                                                \
+      ErrMsg(RM_UNSPECIFIED_SCE, "unspecified system_category error"),                                                 \
+      ErrMsg(RM_BAD_ANY_CAST, "bad any cast"),                                                                         \
+      ErrMsg(RM_BAD_FUNCTION_CALL, "std::bad_function_call"),                                                          \
+      ErrMsg(RM_BAD_WEAK_PTR, "bad_weak_ptr"),                                                                         \
+      ErrMsg(RM_BAD_VARIANT_ACS, "bad_variant_access"),
+
+#define ErrMsg(N, D) N
+enum Errs { ErrorList };
+#undef ErrMsg
+
+#define ErrMsg(N, D) D
+#ifdef __MVS__
+#  pragma convert("IBM-1047")
+static constexpr const char* const ErrTextEBCDIC[] = {ErrorList};
+#  pragma convert(pop)
+#  pragma convert("ISO8859-1")
+static constexpr const char* const ErrTextASCII[] = {ErrorList};
+#  pragma convert(pop)
+#else
+static constexpr const char* const ErrText = {ErrorList};
+#endif
+#undef ErrMsg
+
+#ifdef __MVS__
+_LIBCPP_INLINE_VISIBILITY
+inline const char* getRuntimeErrorString(int error) _NOEXCEPT {
+  return (__isASCII() ? ErrTextASCII[error] : ErrTextEBCDIC[error]);
+}
+#else
+_LIBCPP_INLINE_VISIBILITY
+inline constexpr const char* getRuntimeErrorString(int error) _NOEXCEPT { return ErrText[error]; }
+#endif
+
+#endif // ERROR_MESSAGE_H

libcxx/src/ios.cpp

 
 #include "ios"
 
 #include <stdlib.h>
 
 #include "__locale"
 #include "algorithm"
 #include "include/config_elast.h"
+#include "include/error_message.h"
 #include "limits"
 #include "memory"
 #include "new"
 #include "string"
 #include "__undef_macros"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 class _LIBCPP_HIDDEN __iostream_category
     : public __do_message
 {
 public:
     virtual const char* name() const noexcept;
     virtual string message(int ev) const;
 };
 
 const char*
 __iostream_category::name() const noexcept
 {
     return "iostream";
 }
 
 string
 __iostream_category::message(int ev) const
 {
     if (ev != static_cast<int>(io_errc::stream)
 #ifdef _LIBCPP_ELAST
         && ev <= _LIBCPP_ELAST
 #endif // _LIBCPP_ELAST
         )
         return __do_message::message(ev);
-    return string("unspecified iostream_category error");
+    return string(getRuntimeErrorString(RM_UNSPECIFIED_ICE));
 }
 
 const error_category&
 iostream_category() noexcept
 {
     static __iostream_category s;
     return s;
 }

 ios_base::sync_with_stdio(bool sync)
 {
     static bool previous_state = true;
     bool r = previous_state;
     previous_state = sync;
     return r;
 }
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/iostream.cpp

 #include "string"
 #include "new"
 
 #define _str(s) #s
 #define str(s) _str(s)
 #define _LIBCPP_ABI_NAMESPACE_STR str(_LIBCPP_ABI_NAMESPACE)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 _ALIGNAS_TYPE (istream) _LIBCPP_FUNC_VIS char cin[sizeof(istream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
 __asm__("?cin@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_istream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
 _ALIGNAS_TYPE (__stdinbuf<char> ) static char __cin[sizeof(__stdinbuf <char>)];
 static mbstate_t mb_cin;

 {
     static DoIOSInit init_the_streams; // gets initialized once
 }
 
 ios_base::Init::~Init()
 {
 }
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/locale.cpp

 
 // On Linux, wint_t and wchar_t have different signed-ness, and this causes
 // lots of noise in the build log, but no bugs that I know of.
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wsign-conversion"
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 struct __libcpp_unique_locale {
   __libcpp_unique_locale(const char* nm) : __loc_(newlocale(LC_ALL_MASK, nm, 0)) {}
 
   ~__libcpp_unique_locale() {
     if (__loc_)
       freelocale(__loc_);
   }

 }
 
 wchar_t
 ctype<wchar_t>::do_toupper(char_type c) const
 {
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
     return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c;
 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
-      defined(__NetBSD__)
+      defined(__NetBSD__) || defined(__MVS__)
     return isascii(c) ? ctype<char>::__classic_upper_table()[c] : c;
 #else
     return (isascii(c) && iswlower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'a'+L'A' : c;
 #endif
 }
 
 const wchar_t*
 ctype<wchar_t>::do_toupper(char_type* low, const char_type* high) const
 {
     for (; low != high; ++low)
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
         *low = isascii(*low) ? _DefaultRuneLocale.__mapupper[*low] : *low;
 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
-      defined(__NetBSD__)
+      defined(__NetBSD__) || defined(__MVS__)
         *low = isascii(*low) ? ctype<char>::__classic_upper_table()[*low]
                              : *low;
 #else
         *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? (*low-L'a'+L'A') : *low;
 #endif
     return low;
 }
 
 wchar_t
 ctype<wchar_t>::do_tolower(char_type c) const
 {
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
     return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c;
 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
-      defined(__NetBSD__)
+      defined(__NetBSD__) || defined(__MVS__)
     return isascii(c) ? ctype<char>::__classic_lower_table()[c] : c;
 #else
     return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'A'+'a' : c;
 #endif
 }
 
 const wchar_t*
 ctype<wchar_t>::do_tolower(char_type* low, const char_type* high) const
 {
     for (; low != high; ++low)
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
         *low = isascii(*low) ? _DefaultRuneLocale.__maplower[*low] : *low;
 #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
-      defined(__NetBSD__)
+      defined(__NetBSD__) || defined(__MVS__)
         *low = isascii(*low) ? ctype<char>::__classic_lower_table()[*low]
                              : *low;
 #else
         *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-L'A'+L'a' : *low;
 #endif
     return low;
 }
 

 char
 ctype<char>::do_toupper(char_type c) const
 {
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
     return isascii(c) ?
       static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(c)]) : c;
 #elif defined(__NetBSD__)
     return static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]);
-#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
+#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
     return isascii(c) ?
       static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]) : c;
 #else
     return (isascii(c) && islower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'a'+'A' : c;
 #endif
 }
 
 const char*
 ctype<char>::do_toupper(char_type* low, const char_type* high) const
 {
     for (; low != high; ++low)
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
         *low = isascii(*low) ?
           static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(*low)]) : *low;
 #elif defined(__NetBSD__)
         *low = static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(*low)]);
-#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
+#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
         *low = isascii(*low) ?
           static_cast<char>(__classic_upper_table()[static_cast<size_t>(*low)]) : *low;
 #else
         *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-'a'+'A' : *low;
 #endif
     return low;
 }
 
 char
 ctype<char>::do_tolower(char_type c) const
 {
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
     return isascii(c) ?
       static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(c)]) : c;
 #elif defined(__NetBSD__)
     return static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(c)]);
-#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
+#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
     return isascii(c) ?
       static_cast<char>(__classic_lower_table()[static_cast<size_t>(c)]) : c;
 #else
     return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'A'+'a' : c;
 #endif
 }
 
 const char*
 ctype<char>::do_tolower(char_type* low, const char_type* high) const
 {
     for (; low != high; ++low)
 #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
         *low = isascii(*low) ? static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(*low)]) : *low;
 #elif defined(__NetBSD__)
         *low = static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(*low)]);
-#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
+#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
         *low = isascii(*low) ? static_cast<char>(__classic_lower_table()[static_cast<size_t>(*low)]) : *low;
 #else
         *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-'A'+'a' : *low;
 #endif
     return low;
 }
 
 char

     return __pctype_func();
 #elif defined(__EMSCRIPTEN__)
     return *__ctype_b_loc();
 #elif defined(_NEWLIB_VERSION)
     // Newlib has a 257-entry table in ctype_.c, where (char)0 starts at [1].
     return _ctype_ + 1;
 #elif defined(_AIX)
     return (const unsigned int *)__lc_ctype_ptr->obj->mask;
+#elif defined(__MVS__)
+#if defined(__NATIVE_ASCII_F)
+    return const_cast<const ctype<char>::mask*> (__OBJ_DATA(__lc_ctype_a)->mask);
+#else
+    return const_cast<const ctype<char>::mask*> (__ctypec);
+#endif
 #else
     // Platform not supported: abort so the person doing the port knows what to
     // fix
 # warning  ctype<char>::classic_table() is not implemented
     printf("ctype<char>::classic_table() is not implemented\n");
     abort();
     return NULL;
 #endif

     return *__ctype_tolower_loc();
 }
 
 const int*
 ctype<char>::__classic_upper_table() noexcept
 {
     return *__ctype_toupper_loc();
 }
-#endif // __GLIBC__ || __NETBSD__ || __EMSCRIPTEN__
+#elif defined(__MVS__)
+const unsigned short*
+ctype<char>::__classic_lower_table() _NOEXCEPT
+{
+#if defined(__NATIVE_ASCII_F)
+  return const_cast<const unsigned short*>(__OBJ_DATA(__lc_ctype_a)->lower);
+#else
+  return const_cast<const unsigned short*>(__ctype + __TOLOWER_INDEX);
+#endif
+}
+const unsigned short *
+ctype<char>::__classic_upper_table() _NOEXCEPT
+{
+#if defined(__NATIVE_ASCII_F)
+  return const_cast<const unsigned short*>(__OBJ_DATA(__lc_ctype_a)->upper);
+#else
+  return const_cast<const unsigned short*>(__ctype + __TOUPPER_INDEX);
+#endif
+}
+#endif // __GLIBC__ || __NETBSD__ || __EMSCRIPTEN__ || __MVS__
 
 // template <> class ctype_byname<char>
 
 ctype_byname<char>::ctype_byname(const char* name, size_t refs)
     : ctype<char>(0, false, refs),
       __l(newlocale(LC_ALL_MASK, name, 0))
 {
     if (__l == 0)

                lc->int_n_cs_precedes, lc->int_n_sep_by_space,
                lc->int_n_sign_posn, L' ');
 #endif // !_LIBCPP_MSVCRT
 }
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 void __do_nothing(void*) {}
 
-void __throw_runtime_error(const char* msg)
-{
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    throw runtime_error(msg);
-#else
-    (void)msg;
-    _VSTD::abort();
-#endif
-}
-
                            template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>;
 _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<wchar_t>;)
 
+
                            template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<char>;
 _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<wchar_t>;)
 
                            template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<char>;
 _LIBCPP_IF_WIDE_CHARACTERS(template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<wchar_t>;)
 
                            template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<char>;
 _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<wchar_t>;)

 _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<wchar_t, char, mbstate_t>;)
 template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char, mbstate_t>;
 template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char, mbstate_t>;
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char8_t, mbstate_t>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char8_t, mbstate_t>;
 #endif
 
+_LIBCPP_END_NAMESPACE_CES
+
+#if !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
+void __throw_runtime_error(const char* msg)
+{
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    throw runtime_error(msg);
+#else
+    (void)msg;
+    _VSTD::abort();
+#endif
+}
+#endif // !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
+
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/memory.cpp

 #ifndef _LIBCPP_HAS_NO_THREADS
 #   include "mutex"
 #   include "thread"
 #   if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
 #       pragma comment(lib, "pthread")
 #   endif
 #endif
 #include "include/atomic_support.h"
+#include "include/error_message.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 const allocator_arg_t allocator_arg = allocator_arg_t();
 
 bad_weak_ptr::~bad_weak_ptr() noexcept {}
 
-const char*
-bad_weak_ptr::what() const noexcept
-{
-    return "bad_weak_ptr";
-}
+const char* bad_weak_ptr::what() const noexcept { return getRuntimeErrorString(RM_BAD_WEAK_PTR); }
 
 __shared_count::~__shared_count()
 {
 }
 
 __shared_weak_count::~__shared_weak_count()
 {
 }

libcxx/src/optional.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 "optional"
 #include "__availability"
+#include "include/error_message.h"
 
 namespace std
 {
 
 bad_optional_access::~bad_optional_access() noexcept = default;
 
-const char* bad_optional_access::what() const noexcept {
-  return "bad_optional_access";
-  }
+const char* bad_optional_access::what() const noexcept { return getRuntimeErrorString(RM_WHAT_BAD_OPTIONAL); }
 
 } // std
 
 
 #include <experimental/__config>
 
 //  Preserve std::experimental::bad_optional_access for ABI compatibility
 //  Even though it no longer exists in a header file

libcxx/src/random.cpp

 
 random_device::random_device(const string& __token)
     : __f_(open(__token.c_str(), O_RDONLY))
 {
     if (__f_ < 0)
         __throw_system_error(errno, ("random_device failed to open " + __token).c_str());
 }
 
+#if !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
+
 random_device::~random_device()
 {
     close(__f_);
 }
 
 unsigned
 random_device::operator()()
 {
while (n > 0)
             continue;
         }
         n -= static_cast<size_t>(s);
         p += static_cast<size_t>(s);
     }
     return r;
 }
 
+#endif // !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
+
 #elif defined(_LIBCPP_USING_NACL_RANDOM)
 
 random_device::random_device(const string& __token)
 {
     if (__token != "/dev/urandom")
         __throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
     int error = nacl_secure_random_init();
     if (error)
if (err)
         __throw_system_error(err, "random_device rand_s failed.");
     return r;
 }
 
 #else
 #error "Random device not implemented for this architecture"
 #endif
 
+#if !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
 double
 random_device::entropy() const noexcept
 {
 #if defined(_LIBCPP_USING_DEV_RANDOM) && defined(RNDGETENTCNT)
   int ent;
   if (::ioctl(__f_, RNDGETENTCNT, &ent) < 0)
     return 0;
 
   if (ent < 0)
     return 0;
 
   if (ent > std::numeric_limits<result_type>::digits)
     return std::numeric_limits<result_type>::digits;
 
   return ent;
 #elif defined(__OpenBSD__)
   return std::numeric_limits<result_type>::digits;
 #else
   return 0;
 #endif
 }
+#endif // !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/regex.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 "regex"
 #include "algorithm"
 #include "iterator"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 static
 const char*
 make_error_type_string(regex_constants::error_type ecode)
 {
     switch (ecode)
     {
     case regex_constants::error_collate:

 namespace {
 
 struct collationnames
 {
     const char* elem_;
     char char_;
 };
 
+#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
+// EBCDIC IBM-1047
+// Sorted via the EBCDIC collating sequence
+const collationnames collatenames[] =
+{
+    {"a", 0x81},
+    {"alert", 0x2f},
+    {"ampersand", 0x50},
+    {"apostrophe", 0x7d},
+    {"asterisk", 0x5c},
+    {"b", 0x82},
+    {"backslash", 0xe0},
+    {"backspace", 0x16},
+    {"c", 0x83},
+    {"carriage-return", 0xd},
+    {"circumflex", 0x5f},
+    {"circumflex-accent", 0x5f},
+    {"colon", 0x7a},
+    {"comma", 0x6b},
+    {"commercial-at", 0x7c},
+    {"d", 0x84},
+    {"dollar-sign", 0x5b},
+    {"e", 0x85},
+    {"eight", 0xf8},
+    {"equals-sign", 0x7e},
+    {"exclamation-mark", 0x5a},
+    {"f", 0x86},
+    {"five", 0xf5},
+    {"form-feed", 0xc},
+    {"four", 0xf4},
+    {"full-stop", 0x4b},
+    {"g", 0x87},
+    {"grave-accent", 0x79},
+    {"greater-than-sign", 0x6e},
+    {"h", 0x88},
+    {"hyphen", 0x60},
+    {"hyphen-minus", 0x60},
+    {"i", 0x89},
+    {"j", 0x91},
+    {"k", 0x92},
+    {"l", 0x93},
+    {"left-brace", 0xc0},
+    {"left-curly-bracket", 0xc0},
+    {"left-parenthesis", 0x4d},
+    {"left-square-bracket", 0xad},
+    {"less-than-sign", 0x4c},
+    {"low-line", 0x6d},
+    {"m", 0x94},
+    {"n", 0x95},
+    {"newline", 0x15},
+    {"nine", 0xf9},
+    {"number-sign", 0x7b},
+    {"o", 0x96},
+    {"one", 0xf1},
+    {"p", 0x97},
+    {"percent-sign", 0x6c},
+    {"period", 0x4b},
+    {"plus-sign", 0x4e},
+    {"q", 0x98},
+    {"question-mark", 0x6f},
+    {"quotation-mark", 0x7f},
+    {"r", 0x99},
+    {"reverse-solidus", 0xe0},
+    {"right-brace", 0xd0},
+    {"right-curly-bracket", 0xd0},
+    {"right-parenthesis", 0x5d},
+    {"right-square-bracket", 0xbd},
+    {"s", 0xa2},
+    {"semicolon", 0x5e},
+    {"seven", 0xf7},
+    {"six", 0xf6},
+    {"slash", 0x61},
+    {"solidus", 0x61},
+    {"space", 0x40},
+    {"t", 0xa3},
+    {"tab", 0x5},
+    {"three", 0xf3},
+    {"tilde", 0xa1},
+    {"two", 0xf2},
+    {"u", 0xa4},
+    {"underscore", 0x6d},
+    {"v", 0xa5},
+    {"vertical-line", 0x4f},
+    {"vertical-tab", 0xb},
+    {"w", 0xa6},
+    {"x", 0xa7},
+    {"y", 0xa8},
+    {"z", 0xa9},
+    {"zero", 0xf0},
+    {"A", 0xc1},
+    {"B", 0xc2},
+    {"C", 0xc3},
+    {"D", 0xc4},
+    {"E", 0xc5},
+    {"F", 0xc6},
+    {"G", 0xc7},
+    {"H", 0xc8},
+    {"I", 0xc9},
+    {"J", 0xd1},
+    {"K", 0xd2},
+    {"L", 0xd3},
+    {"M", 0xd4},
+    {"N", 0xd5},
+    {"NUL", 0},
+    {"O", 0xd6},
+    {"P", 0xd7},
+    {"Q", 0xd8},
+    {"R", 0xd9},
+    {"S", 0xe2},
+    {"T", 0xe3},
+    {"U", 0xe4},
+    {"V", 0xe5},
+    {"W", 0xe6},
+    {"X", 0xe7},
+    {"Y", 0xe8},
+    {"Z", 0xe9}
+};
+#else
+// ASCII
 const collationnames collatenames[] =
 {
     {"A", 0x41},
     {"B", 0x42},
     {"C", 0x43},
     {"D", 0x44},
     {"E", 0x45},
     {"F", 0x46},
const collationnames collatenames[] =
     {"vertical-line", 0x7c},
     {"vertical-tab", 0x0b},
     {"w", 0x77},
     {"x", 0x78},
     {"y", 0x79},
     {"z", 0x7a},
     {"zero", 0x30}
 };
+#endif
 
 struct classnames
 {
     const char* elem_;
     regex_traits<char>::char_class_type mask_;
 };
 
 const classnames ClassNames[] =
__match_any_but_newline<wchar_t>::__exec(__state& __s) const
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/string.cpp

 as_float( const string& func, const wstring& s, size_t* idx )
 {
     return as_float_helper<long double>( func, s, idx, wcstold );
 }
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 }  // unnamed namespace
 
+_LIBCPP_BEGIN_NAMESPACE_CES
+
 int
 stoi(const string& str, size_t* idx, int base)
 {
     return as_integer<int>( "stoi", str, idx, base );
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 int

 string  to_string (long double val) { return as_string(snprintf,       initial_string< string>()(),  "%Lf", val); }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 wstring to_wstring(float val)       { return as_string(get_swprintf(), initial_string<wstring>()(),  L"%f", val); }
 wstring to_wstring(double val)      { return as_string(get_swprintf(), initial_string<wstring>()(),  L"%f", val); }
 wstring to_wstring(long double val) { return as_string(get_swprintf(), initial_string<wstring>()(), L"%Lf", val); }
 #endif
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/strstream.cpp

 #include "algorithm"
 #include "climits"
 #include "cstring"
 #include "cstdlib"
 #include "__debug"
 #include "__undef_macros"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 strstreambuf::strstreambuf(streamsize __alsize)
     : __strmode_(__dynamic),
       __alsize_(__alsize),
       __palloc_(nullptr),
       __pfree_(nullptr)
 {
 }

 ostrstream::~ostrstream()
 {
 }
 
 strstream::~strstream()
 {
 }
 
+_LIBCPP_END_NAMESPACE_CES
 _LIBCPP_END_NAMESPACE_STD

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
+_LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_CES
 
 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;
if (current_loc_name.find(',') != std::string::npos) {
     previous_loc->lc_time = current_loc_name;
     previous_loc->lc_messages = current_loc_name;
   }
 
   previous_loc->category_mask = LC_ALL_MASK;
   return previous_loc;
 }
 
-#ifdef __cplusplus
-}
-#endif // __cplusplus
+_LIBCPP_END_NAMESPACE_CES
+_LIBCPP_END_NAMESPACE_STD

libcxx/src/support/runtime/stdexcept_default.ipp

 
 static_assert(sizeof(std::__libcpp_refstring) == sizeof(const char*), "");
 
 namespace std // purposefully not using versioning namespace
 {
 
 logic_error::logic_error(const string& msg) : __imp_(msg.c_str()) {}
 
+#if !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
 logic_error::logic_error(const char* msg) : __imp_(msg) {}
 
 logic_error::logic_error(const logic_error& le) noexcept : __imp_(le.__imp_) {}
 
 logic_error& logic_error::operator=(const logic_error& le) noexcept {
   __imp_ = le.__imp_;
   return *this;
 }
 
-runtime_error::runtime_error(const string& msg) : __imp_(msg.c_str()) {}
-
 runtime_error::runtime_error(const char* msg) : __imp_(msg) {}
 
 runtime_error::runtime_error(const runtime_error& re) noexcept
     : __imp_(re.__imp_) {}
 
 runtime_error& runtime_error::operator=(const runtime_error& re) noexcept {
   __imp_ = re.__imp_;
   return *this;
 }
+#endif // !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
+runtime_error::runtime_error(const string& msg) : __imp_(msg.c_str()) {}
+
 
 #if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
 
 const char* logic_error::what() const noexcept { return __imp_.c_str(); }
 
 const char* runtime_error::what() const noexcept { return __imp_.c_str(); }
 
 logic_error::~logic_error() noexcept {}

libcxx/src/system_error.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
 //
 //===----------------------------------------------------------------------===//
 
+#if defined(__MVS__)
+#define _AE_BIMODAL 1
+#endif
+
 #include "__config"
 
 #include "system_error"
 
 #include "include/config_elast.h"
+#include "include/error_message.h"
 #include "cerrno"
 #include "cstring"
 #include "cstdio"
 #include "cstdlib"
 #include "string"
 #include "string.h"
 #include "__debug"
 
 #if defined(__ANDROID__)
 #include <android/api-level.h>
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // class error_category
-
+#if !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
 #if defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
 error_category::error_category() noexcept
 {
 }
 #endif
 
 error_category::~error_category() noexcept
 {
handle_strerror_r_return(int strerror_return, char *buffer) {
   if (strerror_return == 0)
     return buffer;
 
   // Only handle EINVAL. Other errors abort.
   int new_errno = strerror_return == -1 ? errno : strerror_return;
   if (new_errno == EINVAL)
     return "";
 
-  _LIBCPP_ASSERT(new_errno == ERANGE, "unexpected error from ::strerror_r");
+  _LIBCPP_ASSERT(new_errno == ERANGE, getRuntimeErrorString(RM_STRERROR_MSG));
+
   // FIXME maybe? 'strerror_buff_size' is likely to exceed the
   // maximum error size so ERANGE shouldn't be returned.
   std::abort();
 }
 
 // This function handles both GNU and POSIX variants, dispatching to
 // one of the two above functions.
 string do_strerror_r(int ev) {
     char buffer[strerror_buff_size];
     // Preserve errno around the call. (The C++ standard requires that
     // system_error functions not modify errno).
     const int old_errno = errno;
     const char *error_message = handle_strerror_r_return(
-        ::strerror_r(ev, buffer, strerror_buff_size), buffer);
+#if defined(__MVS__)
+        (__isASCII() ? __strerror_r_a : __strerror_r_e)
+#else
+        ::strerror_r
+#endif
+    (ev, buffer, strerror_buff_size), buffer);
     // If we didn't get any message, print one now.
     if (!error_message[0]) {
-      std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
+#if defined(__MVS__)
+      if (__isASCII())
+        __snprintf_a(buffer, strerror_buff_size, getRuntimeErrorString(RM_UNKNOWN_ERROR), ev);
+      else
+        __snprintf_e(buffer, strerror_buff_size, getRuntimeErrorString(RM_UNKNOWN_ERROR), ev);
+#else
+      std::snprintf(buffer, strerror_buff_size, getRuntimeErrorString(RM_UNKNOWN_ERROR), ev);
+#endif
       error_message = buffer;
     }
     errno = old_errno;
     return string(error_message);
 }
 #endif
 } // end namespace
 #endif

 {
     return "generic";
 }
 
 string
 __generic_error_category::message(int ev) const
 {
 #ifdef _LIBCPP_ELAST
-    if (ev > _LIBCPP_ELAST)
-      return string("unspecified generic_category error");
-#endif // _LIBCPP_ELAST
+    return string(getRuntimeErrorString(RM_UNSPECIFIED_GCE));
+#endif  // _LIBCPP_ELAST
     return __do_message::message(ev);
 }
 
 const error_category&
 generic_category() noexcept
 {
     static __generic_error_category s;
     return s;

 {
     return "system";
 }
 
 string
 __system_error_category::message(int ev) const
 {
 #ifdef _LIBCPP_ELAST
-    if (ev > _LIBCPP_ELAST)
-      return string("unspecified system_category error");
-#endif // _LIBCPP_ELAST
+    return string(getRuntimeErrorString(RM_UNSPECIFIED_SCE));
+#endif  // _LIBCPP_ELAST
     return __do_message::message(ev);
 }
 
 error_condition
 __system_error_category::default_error_condition(int ev) const noexcept
 {
 #ifdef _LIBCPP_ELAST
     if (ev > _LIBCPP_ELAST)

 string
 error_code::message() const
 {
     return __cat_->message(__val_);
 }
 
 // system_error
 
-string
-system_error::__init(const error_code& ec, string what_arg)
-{
-    if (ec)
-    {
-        if (!what_arg.empty())
-            what_arg += ": ";
-        what_arg += ec.message();
-    }
-    return what_arg;
-}
-
-system_error::system_error(error_code ec, const string& what_arg)
-    : runtime_error(__init(ec, what_arg)),
-      __ec_(ec)
-{
-}
-
 system_error::system_error(error_code ec, const char* what_arg)
     : runtime_error(__init(ec, what_arg)),
       __ec_(ec)
 {
 }
 
 system_error::system_error(error_code ec)
     : runtime_error(__init(ec, "")),
       __ec_(ec)
 {
 }
 
-system_error::system_error(int ev, const error_category& ecat, const string& what_arg)
-    : runtime_error(__init(error_code(ev, ecat), what_arg)),
-      __ec_(error_code(ev, ecat))
-{
-}
-
 system_error::system_error(int ev, const error_category& ecat, const char* what_arg)
     : runtime_error(__init(error_code(ev, ecat), what_arg)),
       __ec_(error_code(ev, ecat))
 {
 }
 
 system_error::system_error(int ev, const error_category& ecat)
     : runtime_error(__init(error_code(ev, ecat), "")),
#ifndef _LIBCPP_NO_EXCEPTIONS
     throw system_error(error_code(ev, system_category()), what_arg);
 #else
     (void)ev;
     (void)what_arg;
     _VSTD::abort();
 #endif
 }
 
+#endif // !defined(_LIBCPP_ADDITIONAL_CHAR_ENCODING)
+
+string
+system_error::__init(const error_code& ec, string what_arg)
+{
+    if (ec)
+    {
+        if (!what_arg.empty())
+            what_arg += ": ";
+        what_arg += ec.message();
+    }
+    return what_arg;
+}
+
+system_error::system_error(error_code ec, const string& what_arg)
+    : runtime_error(__init(ec, what_arg)),
+      __ec_(ec)
+{
+}
+
+system_error::system_error(int ev, const error_category& ecat, const string& what_arg)
+    : runtime_error(__init(error_code(ev, ecat), what_arg)),
+      __ec_(error_code(ev, ecat))
+{
+}
+
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/variant.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 "variant"
+#include "include/error_message.h"
 
 namespace std {
 
-const char* bad_variant_access::what() const noexcept {
-  return "bad_variant_access";
-}
+const char* bad_variant_access::what() const noexcept { return getRuntimeErrorString(RM_BAD_VARIANT_ACS); }
 
 }  // namespace std

libcxxabi/src/abort_message.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 <include/error_message.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include "abort_message.h"
 
 #ifdef __BIONIC__
 #   include <android/api-level.h>
 #   if __ANDROID_API__ >= 21

 
 void abort_message(const char* format, ...)
 {
     // Write message to stderr. We do this before formatting into a
     // variable-size buffer so that we still get some information if
     // formatting into the variable-sized buffer fails.
 #if !defined(NDEBUG) || !defined(LIBCXXABI_BAREMETAL)
     {
-        fprintf(stderr, "libc++abi: ");
-        va_list list;
-        va_start(list, format);
-        vfprintf(stderr, format, list);
-        va_end(list);
-        fprintf(stderr, "\n");
+#if defined(__MVS__)
+      if (__isASCII()) 
+        __fprintf_a(stderr, getRuntimeErrorString(RM_LIBCXXABI));
+      else
+        __fprintf_e(stderr, getRuntimeErrorString(RM_LIBCXXABI));
+      va_list list;
+      va_start(list, format);
+      if (__isASCII())
+        __vfprintf_a(stderr, format, list);
+      else
+        __vfprintf_e(stderr, format, list);
+      va_end(list);
+      if (__isASCII())
+        __fprintf_a(stderr, getRuntimeErrorString(RM_NL));
+      else
+        __fprintf_e(stderr, getRuntimeErrorString(RM_NL));
+#else
+      fprintf(stderr, getRuntimeErrorString(RM_LIBCXXABI));
+      fprintf(stderr, getRuntimeErrorString(RM_NL));
+#endif
     }
 #endif
 
     // Format the arguments into an allocated buffer. We leak the buffer on
     // purpose, since we're about to abort() anyway.
 #if defined(_LIBCXXABI_USE_CRASHREPORTER_CLIENT)
     char* buffer;
     va_list list;

libcxxabi/src/cxa_virtual.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 <include/error_message.h>
 #include "cxxabi.h"
 #include "abort_message.h"
 
 namespace __cxxabiv1 {
 extern "C" {
 _LIBCXXABI_FUNC_VIS _LIBCXXABI_NORETURN
 void __cxa_pure_virtual(void) {
-  abort_message("Pure virtual function called!");
+  abort_message(getRuntimeErrorString(RM_PURE_VIRTUAL_FUNCTION));
 }
 
 _LIBCXXABI_FUNC_VIS _LIBCXXABI_NORETURN
 void __cxa_deleted_virtual(void) {
-  abort_message("Deleted virtual function called!");
+  abort_message(getRuntimeErrorString(RM_DELETED_VIRTUAL_FUNCTION));
 }
 } // extern "C"
 } // abi