///////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2002-2012, Industrial Light & Magic, a division of Lucas

// Digital Ltd. LLC

// 

// All rights reserved.

// 

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

// *       Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// *       Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

// *       Neither the name of Industrial Light & Magic nor the names of

// its contributors may be used to endorse or promote products derived

// from this software without specific prior written permission. 

// 

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

///////////////////////////////////////////////////////////////////////////

//----------------------------------------------------------------

//

//	Exceptions that correspond to "errno" error codes,

//	and a function to make throwing those exceptions easy.

//

//----------------------------------------------------------------

#include "IexThrowErrnoExc.h"

#include "IexErrnoExc.h"

#include <string.h>

#include <errno.h>

#ifdef PLATFORM_WINDOWS

#include <windows.h>

#endif

IEX_INTERNAL_NAMESPACE_SOURCE_ENTER

void throwErrnoExc (const std::string &text, int errnum)

{

#ifdef PLATFORM_WINDOWS

    if (0 != getenv("IEXDEBUGTHROW"))

        DebugBreak();

#endif

    const char *entext = strerror (errnum);

    std::string tmp (text);

    std::string::size_type pos;

    while (std::string::npos != (pos = tmp.find ("%T")))

	tmp.replace (pos, 2, entext, strlen (entext));

    switch (errnum)

    {

      #if defined (EPERM)

	  case EPERM:

	    throw EpermExc (tmp);

      #endif

      #if defined (ENOENT)

	  case ENOENT:

	    throw EnoentExc (tmp);

      #endif

      #if defined (ESRCH)

	  case ESRCH:

	    throw EsrchExc (tmp);

      #endif

      #if defined (EINTR)

	  case EINTR:

	    throw EintrExc (tmp);

      #endif

      #if defined (EIO)

	  case EIO:

	    throw EioExc (tmp);

      #endif

      #if defined (ENXIO)

	  case ENXIO:

	    throw EnxioExc (tmp);

      #endif

      #if defined (E2BIG)

	  case E2BIG:

	    throw E2bigExc (tmp);

      #endif

      #if defined (ENOEXEC)

	  case ENOEXEC:

	    throw EnoexecExc (tmp);

      #endif

      #if defined (EBADF)

	  case EBADF:

	    throw EbadfExc (tmp);

      #endif

      #if defined (ECHILD)

	  case ECHILD:

	    throw EchildExc (tmp);

      #endif

      #if defined (EAGAIN)

	  case EAGAIN:

	    throw EagainExc (tmp);

      #endif

      #if defined (ENOMEM)

	  case ENOMEM:

	    throw EnomemExc (tmp);

      #endif

      #if defined (EACCES)

	  case EACCES:

	    throw EaccesExc (tmp);

      #endif

      #if defined (EFAULT)

	  case EFAULT:

	    throw EfaultExc (tmp);

      #endif

      #if defined (ENOTBLK)

	  case ENOTBLK:

	    throw EnotblkExc (tmp);

      #endif

      #if defined (EBUSY)

	  case EBUSY:

	    throw EbusyExc (tmp);

      #endif

      #if defined (EEXIST)

	  case EEXIST:

	    throw EexistExc (tmp);

      #endif

      #if defined (EXDEV)

	  case EXDEV:

	    throw ExdevExc (tmp);

      #endif

      #if defined (ENODEV)

	  case ENODEV:

	    throw EnodevExc (tmp);

      #endif

      #if defined (ENOTDIR)

	  case ENOTDIR:

	    throw EnotdirExc (tmp);

      #endif

      #if defined (EISDIR)

	  case EISDIR:

	    throw EisdirExc (tmp);

      #endif

      #if defined (EINVAL)

	  case EINVAL:

	    throw EinvalExc (tmp);

      #endif

      #if defined (ENFILE)

	  case ENFILE:

	    throw EnfileExc (tmp);

      #endif

      #if defined (EMFILE)

	  case EMFILE:

	    throw EmfileExc (tmp);

      #endif

      #if defined (ENOTTY)

	  case ENOTTY:

	    throw EnottyExc (tmp);

      #endif

      #if defined (ETXTBSY)

	  case ETXTBSY:

	    throw EtxtbsyExc (tmp);

      #endif

      #if defined (EFBIG)

	  case EFBIG:

	    throw EfbigExc (tmp);

      #endif

      #if defined (ENOSPC)

	  case ENOSPC:

	    throw EnospcExc (tmp);

      #endif

      #if defined (ESPIPE)

	  case ESPIPE:

	    throw EspipeExc (tmp);

      #endif

      #if defined (EROFS)

	  case EROFS:

	    throw ErofsExc (tmp);

      #endif

      #if defined (EMLINK)

	  case EMLINK:

	    throw EmlinkExc (tmp);

      #endif

      #if defined (EPIPE)

	  case EPIPE:

	    throw EpipeExc (tmp);

      #endif

      #if defined (EDOM)

	  case EDOM:

	    throw EdomExc (tmp);

      #endif

      #if defined (ERANGE)

	  case ERANGE:

	    throw ErangeExc (tmp);

      #endif

      #if defined (ENOMSG)

	  case ENOMSG:

	    throw EnomsgExc (tmp);

      #endif

      #if defined (EIDRM)

	  case EIDRM:

	    throw EidrmExc (tmp);

      #endif

      #if defined (ECHRNG)

	  case ECHRNG:

	    throw EchrngExc (tmp);

      #endif

      #if defined (EL2NSYNC)

	  case EL2NSYNC:

	    throw El2nsyncExc (tmp);

      #endif

      #if defined (EL3HLT)

	  case EL3HLT:

	    throw El3hltExc (tmp);

      #endif

      #if defined (EL3RST)

	  case EL3RST:

	    throw El3rstExc (tmp);

      #endif

      #if defined (ELNRNG)

	  case ELNRNG:

	    throw ElnrngExc (tmp);

      #endif

      #if defined (EUNATCH)

	  case EUNATCH:

	    throw EunatchExc (tmp);

      #endif

      #if defined (ENOSCI)

	  case ENOCSI:

	    throw EnocsiExc (tmp);

      #endif

      #if defined (EL2HLT)

	  case EL2HLT:

	    throw El2hltExc (tmp);

      #endif

      #if defined (EDEADLK)

	  case EDEADLK:

	    throw EdeadlkExc (tmp);

      #endif

      #if defined (ENOLCK)

	  case ENOLCK:

	    throw EnolckExc (tmp);

      #endif

      #if defined (EBADE)

	  case EBADE:

	    throw EbadeExc (tmp);

      #endif

      #if defined (EBADR)

	  case EBADR:

	    throw EbadrExc (tmp);

      #endif

      #if defined (EXFULL)

	  case EXFULL:

	    throw ExfullExc (tmp);

      #endif

      #if defined (ENOANO)

	  case ENOANO:

	    throw EnoanoExc (tmp);

      #endif

      #if defined (EBADRQC)

	  case EBADRQC:

	    throw EbadrqcExc (tmp);

      #endif

      #if defined (EBADSLT)

	  case EBADSLT:

	    throw EbadsltExc (tmp);

      #endif

      #if defined (EDEADLOCK) && defined (EDEADLK)

	  #if EDEADLOCK != EDEADLK

	      case EDEADLOCK:

		throw EdeadlockExc (tmp);

	  #endif

      #elif defined (EDEADLOCK)

	  case EDEADLOCK:

	    throw EdeadlockExc (tmp);

      #endif

      #if defined (EBFONT)

	  case EBFONT:

	    throw EbfontExc (tmp);

      #endif

      #if defined (ENOSTR)

	  case ENOSTR:

	    throw EnostrExc (tmp);

      #endif

      #if defined (ENODATA)

	  case ENODATA:

	    throw EnodataExc (tmp);

      #endif

      #if defined (ETIME)

	  case ETIME:

	    throw EtimeExc (tmp);

      #endif

      #if defined (ENOSR)

	  case ENOSR:

	    throw EnosrExc (tmp);

      #endif

      #if defined (ENONET)

	  case ENONET:

	    throw EnonetExc (tmp);

      #endif

      #if defined (ENOPKG)

	  case ENOPKG:

	    throw EnopkgExc (tmp);

      #endif

      #if defined (EREMOTE)

	  case EREMOTE:

	    throw EremoteExc (tmp);

      #endif

      #if defined (ENOLINK)

	  case ENOLINK:

	    throw EnolinkExc (tmp);

      #endif

      #if defined (EADV)

	  case EADV:

	    throw EadvExc (tmp);

      #endif

      #if defined (ESRMNT)

	  case ESRMNT:

	    throw EsrmntExc (tmp);

      #endif

      #if defined (ECOMM)

	  case ECOMM:

	    throw EcommExc (tmp);

      #endif

      #if defined (EPROTO)

	  case EPROTO:

	    throw EprotoExc (tmp);

      #endif

      #if defined (EMULTIHOP)

	  case EMULTIHOP:

	    throw EmultihopExc (tmp);

      #endif

      #if defined (EBADMSG)

	  case EBADMSG:

	    throw EbadmsgExc (tmp);

      #endif

      #if defined (ENAMETOOLONG)

	  case ENAMETOOLONG:

	    throw EnametoolongExc (tmp);

      #endif

      #if defined (EOVERFLOW)

	  case EOVERFLOW:

	    throw EoverflowExc (tmp);

      #endif

      #if defined (ENOTUNIQ)

	  case ENOTUNIQ:

	    throw EnotuniqExc (tmp);

      #endif

      #if defined (EBADFD)

	  case EBADFD:

	    throw EbadfdExc (tmp);

      #endif

      #if defined (EREMCHG)

	  case EREMCHG:

	    throw EremchgExc (tmp);

      #endif

      #if defined (ELIBACC)

	  case ELIBACC:

	    throw ElibaccExc (tmp);

      #endif

      #if defined (ELIBBAD)

	  case ELIBBAD:

	    throw ElibbadExc (tmp);

      #endif

      #if defined (ELIBSCN)

	  case ELIBSCN:

	    throw ElibscnExc (tmp);

      #endif

      #if defined (ELIBMAX)

	  case ELIBMAX:

	    throw ElibmaxExc (tmp);

      #endif

      #if defined (ELIBEXEC)

	  case ELIBEXEC:

	    throw ElibexecExc (tmp);

      #endif

      #if defined (EILSEQ)

	  case EILSEQ:

	    throw EilseqExc (tmp);

      #endif

      #if defined (ENOSYS)

	  case ENOSYS:

	    throw EnosysExc (tmp);

      #endif

      #if defined (ELOOP)

	  case ELOOP:

	    throw EloopExc (tmp);

      #endif

      #if defined (ERESTART)

	  case ERESTART:

	    throw ErestartExc (tmp);

      #endif

      #if defined (ESTRPIPE)

	  case ESTRPIPE:

	    throw EstrpipeExc (tmp);

      #endif

      #if defined (ENOTEMPTY)

	  case ENOTEMPTY:

	    throw EnotemptyExc (tmp);

      #endif

      #if defined (EUSERS)

	  case EUSERS:

	    throw EusersExc (tmp);

      #endif

      #if defined (ENOTSOCK)

	  case ENOTSOCK:

	    throw EnotsockExc (tmp);

      #endif

      #if defined (EDESTADDRREQ)

	  case EDESTADDRREQ:

	    throw EdestaddrreqExc (tmp);

      #endif

      #if defined (EMSGSIZE)

	  case EMSGSIZE:

	    throw EmsgsizeExc (tmp);

      #endif

      #if defined (EPROTOTYPE)

	  case EPROTOTYPE:

	    throw EprototypeExc (tmp);

      #endif

      #if defined (ENOPROTOOPT)

	  case ENOPROTOOPT:

	    throw EnoprotooptExc (tmp);

      #endif

      #if defined (EPROTONOSUPPORT)

	  case EPROTONOSUPPORT:

	    throw EprotonosupportExc (tmp);

      #endif

      #if defined (ESOCKTNOSUPPORT)

	  case ESOCKTNOSUPPORT:

	    throw EsocktnosupportExc (tmp);

      #endif

      #if defined (EOPNOTSUPP)

	  case EOPNOTSUPP:

	    throw EopnotsuppExc (tmp);

      #endif

      #if defined (EPFNOSUPPORT)

	  case EPFNOSUPPORT:

	    throw EpfnosupportExc (tmp);

      #endif

      #if defined (EAFNOSUPPORT)

	  case EAFNOSUPPORT:

	    throw EafnosupportExc (tmp);

      #endif

      #if defined (EADDRINUSE)

	  case EADDRINUSE:

	    throw EaddrinuseExc (tmp);

      #endif

      #if defined (EADDRNOTAVAIL)

	  case EADDRNOTAVAIL:

	    throw EaddrnotavailExc (tmp);

      #endif

      #if defined (ENETDOWN)

	  case ENETDOWN:

	    throw EnetdownExc (tmp);

      #endif

      #if defined (ENETUNREACH)

	  case ENETUNREACH:

	    throw EnetunreachExc (tmp);

      #endif

      #if defined (ENETRESET)

	  case ENETRESET:

	    throw EnetresetExc (tmp);

      #endif

      #if defined (ECONNABORTED)

	  case ECONNABORTED:

	    throw EconnabortedExc (tmp);

      #endif

      #if defined (ECONNRESET)

	  case ECONNRESET:

	    throw EconnresetExc (tmp);

      #endif

      #if defined (ENOBUFS)

	  case ENOBUFS:

	    throw EnobufsExc (tmp);

      #endif

      #if defined (EISCONN)

	  case EISCONN:

	    throw EisconnExc (tmp);

      #endif

      #if defined (ENOTCONN)

	  case ENOTCONN:

	    throw EnotconnExc (tmp);

      #endif

      #if defined (ESHUTDOWN)

	  case ESHUTDOWN:

	    throw EshutdownExc (tmp);

      #endif

      #if defined (ETOOMANYREFS)

	  case ETOOMANYREFS:

	    throw EtoomanyrefsExc (tmp);

      #endif

      #if defined (ETIMEDOUT)

	  case ETIMEDOUT:

	    throw EtimedoutExc (tmp);

      #endif

      #if defined (ECONNREFUSED)

	  case ECONNREFUSED:

	    throw EconnrefusedExc (tmp);

      #endif

      #if defined (EHOSTDOWN)

	  case EHOSTDOWN:

	    throw EhostdownExc (tmp);

      #endif

      #if defined (EHOSTUNREACH)

	  case EHOSTUNREACH:

	    throw EhostunreachExc (tmp);

      #endif

      #if defined (EALREADY)

	  case EALREADY:

	    throw EalreadyExc (tmp);

      #endif

      #if defined (EINPROGRESS)

	  case EINPROGRESS:

	    throw EinprogressExc (tmp);

      #endif

      #if defined (ESTALE)

	  case ESTALE:

	    throw EstaleExc (tmp);

      #endif

      #if defined (EIORESID)

	  case EIORESID:

	    throw EioresidExc (tmp);

      #endif

      #if defined (EUCLEAN)

	  case EUCLEAN:

	    throw EucleanExc (tmp);

      #endif

      #if defined (ENOTNAM)

	  case ENOTNAM:

	    throw EnotnamExc (tmp);

      #endif

      #if defined (ENAVAIL)

	  case ENAVAIL:

	    throw EnavailExc (tmp);

      #endif

      #if defined (EISNAM)

	  case EISNAM:

	    throw EisnamExc (tmp);

      #endif

      #if defined (EREMOTEIO)

	  case EREMOTEIO:

	    throw EremoteioExc (tmp);

      #endif

      #if defined (EINIT)

	  case EINIT:

	    throw EinitExc (tmp);

      #endif

      #if defined (EREMDEV)

	  case EREMDEV:

	    throw EremdevExc (tmp);

      #endif

      #if defined (ECANCELED)

	  case ECANCELED:

	    throw EcanceledExc (tmp);

      #endif

      #if defined (ENOLIMFILE)

	  case ENOLIMFILE:

	    throw EnolimfileExc (tmp);

      #endif

      #if defined (EPROCLIM)

	  case EPROCLIM:

	    throw EproclimExc (tmp);

      #endif

      #if defined (EDISJOINT)

	  case EDISJOINT:

	    throw EdisjointExc (tmp);

      #endif

      #if defined (ENOLOGIN)

	  case ENOLOGIN:

	    throw EnologinExc (tmp);

      #endif

      #if defined (ELOGINLIM)

	  case ELOGINLIM:

	    throw EloginlimExc (tmp);

      #endif

      #if defined (EGROUPLOOP)

	  case EGROUPLOOP:

	    throw EgrouploopExc (tmp);

      #endif

      #if defined (ENOATTACH)

	  case ENOATTACH:

	    throw EnoattachExc (tmp);

      #endif

      #if defined (ENOTSUP) && defined (EOPNOTSUPP)

	  #if ENOTSUP != EOPNOTSUPP

	      case ENOTSUP:

		throw EnotsupExc (tmp);

	  #endif

      #elif defined (ENOTSUP)

	  case ENOTSUP:

	    throw EnotsupExc (tmp);

      #endif

      #if defined (ENOATTR)

	  case ENOATTR:

	    throw EnoattrExc (tmp);

      #endif

      #if defined (EDIRCORRUPTED)

	  case EDIRCORRUPTED:

	    throw EdircorruptedExc (tmp);

      #endif

      #if defined (EDQUOT)

	  case EDQUOT:

	    throw EdquotExc (tmp);

      #endif

      #if defined (ENFSREMOTE)

	  case ENFSREMOTE:

	    throw EnfsremoteExc (tmp);

      #endif

      #if defined (ECONTROLLER)

	  case ECONTROLLER:

	    throw EcontrollerExc (tmp);

      #endif

      #if defined (ENOTCONTROLLER)

	  case ENOTCONTROLLER:

	    throw EnotcontrollerExc (tmp);

      #endif

      #if defined (EENQUEUED)

	  case EENQUEUED:

	    throw EenqueuedExc (tmp);

      #endif

      #if defined (ENOTENQUEUED)

	  case ENOTENQUEUED:

	    throw EnotenqueuedExc (tmp);

      #endif

      #if defined (EJOINED)

	  case EJOINED:

	    throw EjoinedExc (tmp);

      #endif

      #if defined (ENOTJOINED)

	  case ENOTJOINED:

	    throw EnotjoinedExc (tmp);

      #endif

      #if defined (ENOPROC)

	  case ENOPROC:

	    throw EnoprocExc (tmp);

      #endif

      #if defined (EMUSTRUN)

	  case EMUSTRUN:

	    throw EmustrunExc (tmp);

      #endif

      #if defined (ENOTSTOPPED)

	  case ENOTSTOPPED:

	    throw EnotstoppedExc (tmp);

      #endif

      #if defined (ECLOCKCPU)

	  case ECLOCKCPU:

	    throw EclockcpuExc (tmp);

      #endif

      #if defined (EINVALSTATE)

	  case EINVALSTATE:

	    throw EinvalstateExc (tmp);

      #endif

      #if defined (ENOEXIST)

	  case ENOEXIST:

	    throw EnoexistExc (tmp);

      #endif

      #if defined (EENDOFMINOR)

	  case EENDOFMINOR:

	    throw EendofminorExc (tmp);

      #endif

      #if defined (EBUFSIZE)

	  case EBUFSIZE:

	    throw EbufsizeExc (tmp);

      #endif

      #if defined (EEMPTY)

	  case EEMPTY:

	    throw EemptyExc (tmp);

      #endif

      #if defined (ENOINTRGROUP)

	  case ENOINTRGROUP:

	    throw EnointrgroupExc (tmp);

      #endif

      #if defined (EINVALMODE)

	  case EINVALMODE:

	    throw EinvalmodeExc (tmp);

      #endif

      #if defined (ECANTEXTENT)

	  case ECANTEXTENT:

	    throw EcantextentExc (tmp);

      #endif

      #if defined (EINVALTIME)

	  case EINVALTIME:

	    throw EinvaltimeExc (tmp);

      #endif

      #if defined (EDESTROYED)

	  case EDESTROYED:

	    throw EdestroyedExc (tmp);

      #endif

    }

    throw ErrnoExc (tmp);

}

void throwErrnoExc (const std::string &text)

{

    throwErrnoExc (text, errno);

}

void throwErrnoExc()

{

    std::string txt = "%T.";

    throwErrnoExc (txt);

}

IEX_INTERNAL_NAMESPACE_SOURCE_EXIT