//===----------------------------------------------------------------------===//

//

// 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>

#ifdef _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS

#   define _LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS

#endif

#include <__assert>

#include <cerrno>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <string>

#include <string.h>

#include <system_error>

#include "include/config_elast.h"

#if defined(__ANDROID__)

#include <android/api-level.h>

#endif

_LIBCPP_BEGIN_NAMESPACE_STD

// class error_category

#if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)

error_category::error_category() noexcept

{

}

#endif

error_category::~error_category() noexcept

{

}

error_condition

error_category::default_error_condition(int ev) const noexcept

{

    return error_condition(ev, *this);

}

bool

error_category::equivalent(int code, const error_condition& condition) const noexcept

{

    return default_error_condition(code) == condition;

}

bool

error_category::equivalent(const error_code& code, int condition) const noexcept

{

    return *this == code.category() && code.value() == condition;

}

#if !defined(_LIBCPP_HAS_NO_THREADS)

namespace {

//  GLIBC also uses 1024 as the maximum buffer size internally.

constexpr size_t strerror_buff_size = 1024;

string do_strerror_r(int ev);

#if defined(_LIBCPP_MSVCRT_LIKE)

string do_strerror_r(int ev) {

  char buffer[strerror_buff_size];

  if (::strerror_s(buffer, strerror_buff_size, ev) == 0)

    return string(buffer);

  std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);

  return string(buffer);

}

#else

// Only one of the two following functions will be used, depending on

// the return type of strerror_r:

// For the GNU variant, a char* return value:

__attribute__((unused)) const char *

handle_strerror_r_return(char *strerror_return, char *buffer) {

  // GNU always returns a string pointer in its return value. The

  // string might point to either the input buffer, or a static

  // buffer, but we don't care which.

  return strerror_return;

}

// For the POSIX variant: an int return value.

__attribute__((unused)) const char *

handle_strerror_r_return(int strerror_return, char *buffer) {

  // The POSIX variant either:

  // - fills in the provided buffer and returns 0

  // - returns a positive error value, or

  // - returns -1 and fills in errno with an error value.

  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");

  // 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 we didn't get any message, print one now.

    if (!error_message[0]) {

      std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);

      error_message = buffer;

    }

    errno = old_errno;

    return string(error_message);

}

#endif

} // end namespace

#endif

string

__do_message::message(int ev) const

{

#if defined(_LIBCPP_HAS_NO_THREADS)

    return string(::strerror(ev));

#else

    return do_strerror_r(ev);

#endif

}

class _LIBCPP_HIDDEN __generic_error_category

    : public __do_message

{

public:

    virtual const char* name() const noexcept;

    virtual string message(int ev) const;

};

const char*

__generic_error_category::name() const noexcept

{

    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 __do_message::message(ev);

}

const error_category&

generic_category() noexcept

{

    static __generic_error_category s;

    return s;

}

class _LIBCPP_HIDDEN __system_error_category

    : public __do_message

{

public:

    virtual const char* name() const noexcept;

    virtual string message(int ev) const;

    virtual error_condition default_error_condition(int ev) const noexcept;

};

const char*

__system_error_category::name() const noexcept

{

    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 __do_message::message(ev);

}

error_condition

__system_error_category::default_error_condition(int ev) const noexcept

{

#ifdef _LIBCPP_ELAST

    if (ev > _LIBCPP_ELAST)

      return error_condition(ev, system_category());

#endif // _LIBCPP_ELAST

    return error_condition(ev, generic_category());

}

const error_category&

system_category() noexcept

{

    static __system_error_category s;

    return s;

}

// error_condition

string

error_condition::message() const

{

    return __cat_->message(__val_);

}

// error_code

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), "")),

      __ec_(error_code(ev, ecat))

{

}

system_error::~system_error() noexcept

{

}

void

__throw_system_error(int ev, const char* what_arg)

{

#ifndef _LIBCPP_NO_EXCEPTIONS

    throw system_error(error_code(ev, system_category()), what_arg);

#else

    (void)ev;

    (void)what_arg;

    _VSTD::abort();

#endif

}

_LIBCPP_END_NAMESPACE_STD