// %NO_EDIT_WARNING%

////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2005-2024 The Octave Project Developers
//
// See the file COPYRIGHT.md in the top-level directory of this
// distribution or <https://octave.org/copyright/>.
//
// This file is part of Octave.
//
// Octave is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Octave is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Octave; see the file COPYING.  If not, see
// <https://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////////////

#if defined (HAVE_CONFIG_H)
#  include "config.h"
#endif

#include <cerrno>

#include "singleton-cleanup.h"

#include "oct-errno.h"
#include "oct-map.h"
#include "error.h"

octave_errno *octave_errno::s_instance = nullptr;

octave_errno::octave_errno ()
{
  struct errno_struct
  {
    const char *name;
    int value;
  };

  static errno_struct errno_codes[] =
  {
    // POSIX.

#if defined (E2BIG)
    { "E2BIG", E2BIG },
#endif
#if defined (EACCES)
    { "EACCES", EACCES },
#endif
#if defined (EADDRINUSE)
    { "EADDRINUSE", EADDRINUSE },
#endif
#if defined (EADDRNOTAVAIL)
    { "EADDRNOTAVAIL", EADDRNOTAVAIL },
#endif
#if defined (EAFNOSUPPORT)
    { "EAFNOSUPPORT", EAFNOSUPPORT },
#endif
#if defined (EAGAIN)
    { "EAGAIN", EAGAIN },
#endif
#if defined (EALREADY)
    { "EALREADY", EALREADY },
#endif
#if defined (EBADF)
    { "EBADF", EBADF },
#endif
#if defined (EBUSY)
    { "EBUSY", EBUSY },
#endif
#if defined (ECHILD)
    { "ECHILD", ECHILD },
#endif
#if defined (ECONNABORTED)
    { "ECONNABORTED", ECONNABORTED },
#endif
#if defined (ECONNREFUSED)
    { "ECONNREFUSED", ECONNREFUSED },
#endif
#if defined (ECONNRESET)
    { "ECONNRESET", ECONNRESET },
#endif
#if defined (EDEADLK)
    { "EDEADLK", EDEADLK },
#endif
#if defined (EDESTADDRREQ)
    { "EDESTADDRREQ", EDESTADDRREQ },
#endif
#if defined (EDOM)
    { "EDOM", EDOM },
#endif
#if defined (EDQUOT)
    { "EDQUOT", EDQUOT },
#endif
#if defined (EEXIST)
    { "EEXIST", EEXIST },
#endif
#if defined (EFAULT)
    { "EFAULT", EFAULT },
#endif
#if defined (EFBIG)
    { "EFBIG", EFBIG },
#endif
#if defined (EHOSTDOWN)
    { "EHOSTDOWN", EHOSTDOWN },
#endif
#if defined (EHOSTUNREACH)
    { "EHOSTUNREACH", EHOSTUNREACH },
#endif
#if defined (EINPROGRESS)
    { "EINPROGRESS", EINPROGRESS },
#endif
#if defined (EINTR)
    { "EINTR", EINTR },
#endif
#if defined (EINVAL)
    { "EINVAL", EINVAL },
#endif
#if defined (EIO)
    { "EIO", EIO },
#endif
#if defined (EISCONN)
    { "EISCONN", EISCONN },
#endif
#if defined (EISDIR)
    { "EISDIR", EISDIR },
#endif
#if defined (ELOOP)
    { "ELOOP", ELOOP },
#endif
#if defined (EMFILE)
    { "EMFILE", EMFILE },
#endif
#if defined (EMLINK)
    { "EMLINK", EMLINK },
#endif
#if defined (EMSGSIZE)
    { "EMSGSIZE", EMSGSIZE },
#endif
#if defined (ENAMETOOLONG)
    { "ENAMETOOLONG", ENAMETOOLONG },
#endif
#if defined (ENETDOWN)
    { "ENETDOWN", ENETDOWN },
#endif
#if defined (ENETRESET)
    { "ENETRESET", ENETRESET },
#endif
#if defined (ENETUNREACH)
    { "ENETUNREACH", ENETUNREACH },
#endif
#if defined (ENFILE)
    { "ENFILE", ENFILE },
#endif
#if defined (ENOBUFS)
    { "ENOBUFS", ENOBUFS },
#endif
#if defined (ENODEV)
    { "ENODEV", ENODEV },
#endif
#if defined (ENOENT)
    { "ENOENT", ENOENT },
#endif
#if defined (ENOEXEC)
    { "ENOEXEC", ENOEXEC },
#endif
#if defined (ENOLCK)
    { "ENOLCK", ENOLCK },
#endif
#if defined (ENOMEM)
    { "ENOMEM", ENOMEM },
#endif
#if defined (ENOPROTOOPT)
    { "ENOPROTOOPT", ENOPROTOOPT },
#endif
#if defined (ENOSPC)
    { "ENOSPC", ENOSPC },
#endif
#if defined (ENOSYS)
    { "ENOSYS", ENOSYS },
#endif
#if defined (ENOTBLK)
    { "ENOTBLK", ENOTBLK },
#endif
#if defined (ENOTCONN)
    { "ENOTCONN", ENOTCONN },
#endif
#if defined (ENOTDIR)
    { "ENOTDIR", ENOTDIR },
#endif
#if defined (ENOTEMPTY)
    { "ENOTEMPTY", ENOTEMPTY },
#endif
#if defined (ENOTSOCK)
    { "ENOTSOCK", ENOTSOCK },
#endif
#if defined (ENOTTY)
    { "ENOTTY", ENOTTY },
#endif
#if defined (ENXIO)
    { "ENXIO", ENXIO },
#endif
#if defined (EOPNOTSUPP)
    { "EOPNOTSUPP", EOPNOTSUPP },
#endif
#if defined (EPERM)
    { "EPERM", EPERM },
#endif
#if defined (EPFNOSUPPORT)
    { "EPFNOSUPPORT", EPFNOSUPPORT },
#endif
#if defined (EPIPE)
    { "EPIPE", EPIPE },
#endif
#if defined (EPROTONOSUPPORT)
    { "EPROTONOSUPPORT", EPROTONOSUPPORT },
#endif
#if defined (EPROTOTYPE)
    { "EPROTOTYPE", EPROTOTYPE },
#endif
#if defined (ERANGE)
    { "ERANGE", ERANGE },
#endif
#if defined (EREMOTE)
    { "EREMOTE", EREMOTE },
#endif
#if defined (ERESTART)
    { "ERESTART", ERESTART },
#endif
#if defined (EROFS)
    { "EROFS", EROFS },
#endif
#if defined (ESHUTDOWN)
    { "ESHUTDOWN", ESHUTDOWN },
#endif
#if defined (ESOCKTNOSUPPORT)
    { "ESOCKTNOSUPPORT", ESOCKTNOSUPPORT },
#endif
#if defined (ESPIPE)
    { "ESPIPE", ESPIPE },
#endif
#if defined (ESRCH)
    { "ESRCH", ESRCH },
#endif
#if defined (ESTALE)
    { "ESTALE", ESTALE },
#endif
#if defined (ETIMEDOUT)
    { "ETIMEDOUT", ETIMEDOUT },
#endif
#if defined (ETOOMANYREFS)
    { "ETOOMANYREFS", ETOOMANYREFS },
#endif
#if defined (ETXTBSY)
    { "ETXTBSY", ETXTBSY },
#endif
#if defined (EUSERS)
    { "EUSERS", EUSERS },
#endif
#if defined (EWOULDBLOCK)
    { "EWOULDBLOCK", EWOULDBLOCK },
#endif
#if defined (EXDEV)
    { "EXDEV", EXDEV },
#endif

    // Others (duplicates are OK).

    @SYSDEP_ERRNO_LIST@

    { nullptr, 0 },
  };

  // Stuff them all in a map for fast access.

  errno_struct *ptr = errno_codes;

  while (ptr->name)
    {
      m_errno_tbl[ptr->name] = ptr->value;
      ptr++;
    }
}

bool
octave_errno::instance_ok ()
{
  bool retval = true;

  if (! s_instance)
    {
      s_instance = new octave_errno ();
      singleton_cleanup_list::add (cleanup_instance);
    }

  return retval;
}

int
octave_errno::lookup (const std::string& name)
{
  return (instance_ok ()) ? s_instance->do_lookup (name) : -1;
}

octave_scalar_map
octave_errno::list ()
{
  return (instance_ok ()) ? s_instance->do_list () : octave_scalar_map ();
}

int
octave_errno::do_lookup (const std::string& name)
{
  return (m_errno_tbl.find (name) != m_errno_tbl.end ()) ? m_errno_tbl[name]
         : -1;
}

octave_scalar_map
octave_errno::do_list ()
{
  octave_scalar_map retval;

  for (const auto& p : m_errno_tbl)
    {
      retval.assign (p.first, p.second);
    }

  return retval;
}