Logo Search packages:      
Sourcecode: openexr version File versions  Download package

IexThrowErrnoExc.cpp

///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2002, 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>

namespace Iex {


void throwErrnoExc (const std::string &text, int errnum)
{
    const char *entext = strerror (errnum);
    std::string tmp (text);
    int pos;

    while (-1 != (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);
}


} // namespace Iex

Generated by  Doxygen 1.6.0   Back to index