rfreeimage 0.1.0

data/vendor/FreeImage/Source/OpenEXR/Iex/IexThrowErrnoExc.cpp

@@ -0,0 +1,873 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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