Disabled external gits

2022-04-07 18:46:57 +02:00
parent 88cb3426ad
commit 15e7120d6d
5316 changed files with 4563444 additions and 6 deletions
--- a/cs440-acg/ext/openexr/IlmBase/Iex/.cvsignore
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/.cvsignore
@@ -0,0 +1,16 @@
+Makefile
+Makefile.in
+config.h.in
+config.h
+config.log
+config.status
+configure
+libtool
+stamp-h
+aclocal.m4
+OpenEXR.pc
+autom4te.cache
+ltmain.sh
+stamp-h.in
+depcomp
+.deps
--- a/cs440-acg/ext/openexr/IlmBase/Iex/CMakeLists.txt
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/CMakeLists.txt
@@ -0,0 +1,31 @@
+# yue.nicholas@gmail.com
+
+IF(ILMBASE_BUILD_SHARED_LIBS)
+    ADD_DEFINITIONS(-DIEX_EXPORTS)
+ENDIF()
+
+ADD_LIBRARY ( Iex ${LIB_TYPE}
+  IexBaseExc.cpp
+  IexThrowErrnoExc.cpp
+  )
+
+
+INSTALL ( TARGETS
+  Iex
+  DESTINATION
+  ${OPENEXR_INSTALL_LIB_DEST}
+)
+
+INSTALL ( FILES 
+  IexBaseExc.h
+  IexMathExc.h
+  IexThrowErrnoExc.h
+  IexErrnoExc.h
+  IexMacros.h
+  Iex.h
+  IexNamespace.h
+  IexExport.h
+  IexForward.h
+  DESTINATION
+  ${OPENEXR_INSTALL_HEADER_DEST}
+)
--- a/cs440-acg/ext/openexr/IlmBase/Iex/Iex.h
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/Iex.h
@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef INCLUDED_IEX_H
+#define INCLUDED_IEX_H
+
+
+//--------------------------------
+//
+//	Exception handling
+//
+//--------------------------------
+
+
+#include "IexMacros.h"
+#include "IexBaseExc.h"
+#include "IexMathExc.h"
+#include "IexThrowErrnoExc.h"
+
+// Note that we do not include file IexErrnoExc.h here.  That file
+// defines over 150 classes and significantly slows down compilation.
+// If you throw ErrnoExc exceptions using the throwErrnoExc() function,
+// you don't need IexErrnoExc.h.  You have to include IexErrnoExc.h
+// only if you want to catch specific subclasses of ErrnoExc.
+
+
+#endif
--- a/cs440-acg/ext/openexr/IlmBase/Iex/IexBaseExc.cpp
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/IexBaseExc.cpp
@@ -0,0 +1,156 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+//---------------------------------------------------------------------
+//
+//	Constructors and destructors for our exception base class.
+//
+//---------------------------------------------------------------------
+
+#include "IexExport.h"
+#include "IexBaseExc.h"
+#include "IexMacros.h"
+
+#ifdef PLATFORM_WINDOWS
+#include <windows.h>
+#endif
+
+#include <stdlib.h>
+
+IEX_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+
+namespace {
+
+StackTracer currentStackTracer = 0;
+
+} // namespace
+
+
+void	
+setStackTracer (StackTracer stackTracer)
+{
+    currentStackTracer = stackTracer;
+}
+
+
+StackTracer
+stackTracer ()
+{
+    return currentStackTracer;
+}
+
+
+BaseExc::BaseExc (const char* s) throw () :
+    std::string (s? s: ""),
+    _stackTrace (currentStackTracer? currentStackTracer(): "")
+{
+    // empty
+}
+
+
+BaseExc::BaseExc (const std::string &s) throw () :
+    std::string (s),
+    _stackTrace (currentStackTracer? currentStackTracer(): "")
+{
+    // empty
+}
+
+
+BaseExc::BaseExc (std::stringstream &s) throw () :
+    std::string (s.str()),
+    _stackTrace (currentStackTracer? currentStackTracer(): "")
+{
+    // empty
+}
+
+
+BaseExc::BaseExc (const BaseExc &be) throw () :
+    std::string (be),
+    _stackTrace (be._stackTrace)
+{
+    // empty
+}
+
+
+BaseExc::~BaseExc () throw ()
+{
+    // empty
+}
+
+
+const char *
+BaseExc::what () const throw ()
+{
+    return c_str();
+}
+
+
+BaseExc &
+BaseExc::assign (std::stringstream &s)
+{
+    std::string::assign (s.str());
+    return *this;
+}
+
+BaseExc &
+BaseExc::append (std::stringstream &s)
+{
+    std::string::append (s.str());
+    return *this;
+}
+
+IEX_INTERNAL_NAMESPACE_SOURCE_EXIT
+
+
+#ifdef PLATFORM_WINDOWS
+
+#pragma optimize("", off)
+void
+iex_debugTrap()
+{
+    if (0 != getenv("IEXDEBUGTHROW"))
+        ::DebugBreak();
+}
+#else
+void
+iex_debugTrap()
+{
+    // how to in Linux?
+    if (0 != ::getenv("IEXDEBUGTHROW"))
+        __builtin_trap();
+}
+#endif
--- a/cs440-acg/ext/openexr/IlmBase/Iex/IexBaseExc.h
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/IexBaseExc.h
@@ -0,0 +1,264 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+#ifndef INCLUDED_IEXBASEEXC_H
+#define INCLUDED_IEXBASEEXC_H
+
+#include "IexNamespace.h"
+#include "IexExport.h"
+
+//----------------------------------------------------------
+//
+//	A general exception base class, and a few
+//	useful exceptions derived from the base class.
+//
+//----------------------------------------------------------
+
+#include <string>
+#include <exception>
+#include <sstream>
+
+IEX_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+//-------------------------------
+// Our most basic exception class
+//-------------------------------
+
+class BaseExc: public std::string, public std::exception
+{
+  public:
+
+    //----------------------------
+    // Constructors and destructor
+    //----------------------------
+
+    IEX_EXPORT BaseExc (const char *s = 0) throw();     // std::string (s)
+    IEX_EXPORT BaseExc (const std::string &s) throw();  // std::string (s)
+    IEX_EXPORT BaseExc (std::stringstream &s) throw();  // std::string (s.str())
+
+    IEX_EXPORT BaseExc (const BaseExc &be) throw();
+    IEX_EXPORT virtual ~BaseExc () throw ();
+
+    //--------------------------------------------
+    // what() method -- e.what() returns e.c_str()
+    //--------------------------------------------
+
+    IEX_EXPORT virtual const char * what () const throw ();
+
+
+    //--------------------------------------------------
+    // Convenient methods to change the exception's text
+    //--------------------------------------------------
+
+    IEX_EXPORT BaseExc &            assign (std::stringstream &s);	// assign (s.str())
+    IEX_EXPORT BaseExc &            operator = (std::stringstream &s);
+
+    IEX_EXPORT BaseExc &            append (std::stringstream &s);	// append (s.str())
+    IEX_EXPORT BaseExc &            operator += (std::stringstream &s);
+
+
+    //--------------------------------------------------
+    // These methods from the base class get obscured by
+    // the definitions above.
+    //--------------------------------------------------
+
+    IEX_EXPORT BaseExc &            assign (const char *s);
+    IEX_EXPORT BaseExc &            operator = (const char *s);
+
+    IEX_EXPORT BaseExc &            append (const char *s);
+    IEX_EXPORT BaseExc &            operator += (const char *s);
+
+
+    //--------------------------------------------------
+    // Stack trace for the point at which the exception
+    // was thrown.  The stack trace will be an empty
+    // string unless a working stack-tracing routine
+    // has been installed (see below, setStackTracer()).
+    //--------------------------------------------------
+
+    IEX_EXPORT const std::string &  stackTrace () const;
+
+  private:
+
+    std::string                     _stackTrace;
+};
+
+
+//-----------------------------------------------------
+// A macro to save typing when declararing an exception
+// class derived directly or indirectly from BaseExc:
+//-----------------------------------------------------
+
+#define DEFINE_EXC_EXP(exp, name, base)                         \
+    class exp name: public base                                 \
+    {                                                           \
+      public:                                                   \
+        name()                         throw(): base (0)    {}  \
+        name (const char* text)        throw(): base (text) {}  \
+        name (const std::string &text) throw(): base (text) {}  \
+        name (std::stringstream &text) throw(): base (text) {}  \
+        ~name() throw() { }                                     \
+    };
+
+// For backward compatibility.
+#define DEFINE_EXC(name, base) DEFINE_EXC_EXP(, name, base)
+
+
+//--------------------------------------------------------
+// Some exceptions which should be useful in most programs
+//--------------------------------------------------------
+DEFINE_EXC_EXP (IEX_EXPORT, ArgExc, BaseExc)    // Invalid arguments to a function call
+
+DEFINE_EXC_EXP (IEX_EXPORT, LogicExc, BaseExc)  // General error in a program's logic,
+                                                // for example, a function was called
+                                                // in a context where the call does
+                                                // not make sense.
+
+DEFINE_EXC_EXP (IEX_EXPORT, InputExc, BaseExc)  // Invalid input data, e.g. from a file
+
+DEFINE_EXC_EXP (IEX_EXPORT, IoExc, BaseExc)     // Input or output operation failed
+
+DEFINE_EXC_EXP (IEX_EXPORT, MathExc, BaseExc) 	// Arithmetic exception; more specific
+                                                // exceptions derived from this class
+                                                // are defined in ExcMath.h
+
+DEFINE_EXC_EXP (IEX_EXPORT, ErrnoExc, BaseExc)  // Base class for exceptions corresponding
+                                                // to errno values (see errno.h); more
+                                                // specific exceptions derived from this
+                                                // class are defined in ExcErrno.h
+
+DEFINE_EXC_EXP (IEX_EXPORT, NoImplExc, BaseExc) // Missing method exception e.g. from a
+                                                // call to a method that is only partially
+                                                // or not at all implemented. A reminder
+                                                // to lazy software people to get back
+                                                // to work.
+
+DEFINE_EXC_EXP (IEX_EXPORT, NullExc, BaseExc)   // A pointer is inappropriately null.
+
+DEFINE_EXC_EXP (IEX_EXPORT, TypeExc, BaseExc)   // An object is an inappropriate type,
+                                                // i.e. a dynamnic_cast failed.
+
+
+//----------------------------------------------------------------------
+// Stack-tracing support:
+// 
+// setStackTracer(st)
+//
+//	installs a stack-tracing routine, st, which will be called from
+//	class BaseExc's constructor every time an exception derived from
+//	BaseExc is thrown.  The stack-tracing routine should return a
+//	string that contains a printable representation of the program's
+//	current call stack.  This string will be stored in the BaseExc
+//	object; the string is accesible via the BaseExc::stackTrace()
+//	method.
+//
+// setStackTracer(0)
+//
+//	removes the current stack tracing routine.  When an exception
+//	derived from BaseExc is thrown, the stack trace string stored
+//	in the BaseExc object will be empty.
+//
+// stackTracer()
+//
+//	returns a pointer to the current stack-tracing routine, or 0
+//	if there is no current stack stack-tracing routine.
+// 
+//----------------------------------------------------------------------
+
+typedef std::string (* StackTracer) ();
+
+IEX_EXPORT void        setStackTracer (StackTracer stackTracer);
+IEX_EXPORT StackTracer stackTracer ();
+
+
+//-----------------
+// Inline functions
+//-----------------
+
+inline BaseExc &
+BaseExc::operator = (std::stringstream &s)
+{
+    return assign (s);
+}
+
+
+inline BaseExc &
+BaseExc::operator += (std::stringstream &s)
+{
+    return append (s);
+}
+
+
+inline BaseExc &
+BaseExc::assign (const char *s)
+{
+    std::string::assign(s);
+    return *this;
+}
+
+
+inline BaseExc &
+BaseExc::operator = (const char *s)
+{
+    return assign(s);
+}
+
+
+inline BaseExc &
+BaseExc::append (const char *s)
+{
+    std::string::append(s);
+    return *this;
+}
+
+
+inline BaseExc &
+BaseExc::operator += (const char *s)
+{
+    return append(s);
+}
+
+
+inline const std::string &
+BaseExc::stackTrace () const
+{
+    return _stackTrace;
+}
+
+
+IEX_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif // INCLUDED_IEXBASEEXC_H
--- a/cs440-acg/ext/openexr/IlmBase/Iex/IexErrnoExc.h
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/IexErrnoExc.h
@@ -0,0 +1,208 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef INCLUDED_IEXERRNOEXC_H
+#define INCLUDED_IEXERRNOEXC_H
+
+//----------------------------------------------------------------
+//
+//	Exceptions which correspond to "errno" error codes.
+//
+//----------------------------------------------------------------
+
+#include "IexBaseExc.h"
+
+IEX_INTERNAL_NAMESPACE_HEADER_ENTER
+
+DEFINE_EXC (EpermExc, ErrnoExc)
+DEFINE_EXC (EnoentExc, ErrnoExc)
+DEFINE_EXC (EsrchExc, ErrnoExc)
+DEFINE_EXC (EintrExc, ErrnoExc)
+DEFINE_EXC (EioExc, ErrnoExc)
+DEFINE_EXC (EnxioExc, ErrnoExc)
+DEFINE_EXC (E2bigExc, ErrnoExc)
+DEFINE_EXC (EnoexecExc, ErrnoExc)
+DEFINE_EXC (EbadfExc, ErrnoExc)
+DEFINE_EXC (EchildExc, ErrnoExc)
+DEFINE_EXC (EagainExc, ErrnoExc)
+DEFINE_EXC (EnomemExc, ErrnoExc)
+DEFINE_EXC (EaccesExc, ErrnoExc)
+DEFINE_EXC (EfaultExc, ErrnoExc)
+DEFINE_EXC (EnotblkExc, ErrnoExc)
+DEFINE_EXC (EbusyExc, ErrnoExc)
+DEFINE_EXC (EexistExc, ErrnoExc)
+DEFINE_EXC (ExdevExc, ErrnoExc)
+DEFINE_EXC (EnodevExc, ErrnoExc)
+DEFINE_EXC (EnotdirExc, ErrnoExc)
+DEFINE_EXC (EisdirExc, ErrnoExc)
+DEFINE_EXC (EinvalExc, ErrnoExc)
+DEFINE_EXC (EnfileExc, ErrnoExc)
+DEFINE_EXC (EmfileExc, ErrnoExc)
+DEFINE_EXC (EnottyExc, ErrnoExc)
+DEFINE_EXC (EtxtbsyExc, ErrnoExc)
+DEFINE_EXC (EfbigExc, ErrnoExc)
+DEFINE_EXC (EnospcExc, ErrnoExc)
+DEFINE_EXC (EspipeExc, ErrnoExc)
+DEFINE_EXC (ErofsExc, ErrnoExc)
+DEFINE_EXC (EmlinkExc, ErrnoExc)
+DEFINE_EXC (EpipeExc, ErrnoExc)
+DEFINE_EXC (EdomExc, ErrnoExc)
+DEFINE_EXC (ErangeExc, ErrnoExc)
+DEFINE_EXC (EnomsgExc, ErrnoExc)
+DEFINE_EXC (EidrmExc, ErrnoExc)
+DEFINE_EXC (EchrngExc, ErrnoExc)
+DEFINE_EXC (El2nsyncExc, ErrnoExc)
+DEFINE_EXC (El3hltExc, ErrnoExc)
+DEFINE_EXC (El3rstExc, ErrnoExc)
+DEFINE_EXC (ElnrngExc, ErrnoExc)
+DEFINE_EXC (EunatchExc, ErrnoExc)
+DEFINE_EXC (EnocsiExc, ErrnoExc)
+DEFINE_EXC (El2hltExc, ErrnoExc)
+DEFINE_EXC (EdeadlkExc, ErrnoExc)
+DEFINE_EXC (EnolckExc, ErrnoExc)
+DEFINE_EXC (EbadeExc, ErrnoExc)
+DEFINE_EXC (EbadrExc, ErrnoExc)
+DEFINE_EXC (ExfullExc, ErrnoExc)
+DEFINE_EXC (EnoanoExc, ErrnoExc)
+DEFINE_EXC (EbadrqcExc, ErrnoExc)
+DEFINE_EXC (EbadsltExc, ErrnoExc)
+DEFINE_EXC (EdeadlockExc, ErrnoExc)
+DEFINE_EXC (EbfontExc, ErrnoExc)
+DEFINE_EXC (EnostrExc, ErrnoExc)
+DEFINE_EXC (EnodataExc, ErrnoExc)
+DEFINE_EXC (EtimeExc, ErrnoExc)
+DEFINE_EXC (EnosrExc, ErrnoExc)
+DEFINE_EXC (EnonetExc, ErrnoExc)
+DEFINE_EXC (EnopkgExc, ErrnoExc)
+DEFINE_EXC (EremoteExc, ErrnoExc)
+DEFINE_EXC (EnolinkExc, ErrnoExc)
+DEFINE_EXC (EadvExc, ErrnoExc)
+DEFINE_EXC (EsrmntExc, ErrnoExc)
+DEFINE_EXC (EcommExc, ErrnoExc)
+DEFINE_EXC (EprotoExc, ErrnoExc)
+DEFINE_EXC (EmultihopExc, ErrnoExc)
+DEFINE_EXC (EbadmsgExc, ErrnoExc)
+DEFINE_EXC (EnametoolongExc, ErrnoExc)
+DEFINE_EXC (EoverflowExc, ErrnoExc)
+DEFINE_EXC (EnotuniqExc, ErrnoExc)
+DEFINE_EXC (EbadfdExc, ErrnoExc)
+DEFINE_EXC (EremchgExc, ErrnoExc)
+DEFINE_EXC (ElibaccExc, ErrnoExc)
+DEFINE_EXC (ElibbadExc, ErrnoExc)
+DEFINE_EXC (ElibscnExc, ErrnoExc)
+DEFINE_EXC (ElibmaxExc, ErrnoExc)
+DEFINE_EXC (ElibexecExc, ErrnoExc)
+DEFINE_EXC (EilseqExc, ErrnoExc)
+DEFINE_EXC (EnosysExc, ErrnoExc)
+DEFINE_EXC (EloopExc, ErrnoExc)
+DEFINE_EXC (ErestartExc, ErrnoExc)
+DEFINE_EXC (EstrpipeExc, ErrnoExc)
+DEFINE_EXC (EnotemptyExc, ErrnoExc)
+DEFINE_EXC (EusersExc, ErrnoExc)
+DEFINE_EXC (EnotsockExc, ErrnoExc)
+DEFINE_EXC (EdestaddrreqExc, ErrnoExc)
+DEFINE_EXC (EmsgsizeExc, ErrnoExc)
+DEFINE_EXC (EprototypeExc, ErrnoExc)
+DEFINE_EXC (EnoprotooptExc, ErrnoExc)
+DEFINE_EXC (EprotonosupportExc, ErrnoExc)
+DEFINE_EXC (EsocktnosupportExc, ErrnoExc)
+DEFINE_EXC (EopnotsuppExc, ErrnoExc)
+DEFINE_EXC (EpfnosupportExc, ErrnoExc)
+DEFINE_EXC (EafnosupportExc, ErrnoExc)
+DEFINE_EXC (EaddrinuseExc, ErrnoExc)
+DEFINE_EXC (EaddrnotavailExc, ErrnoExc)
+DEFINE_EXC (EnetdownExc, ErrnoExc)
+DEFINE_EXC (EnetunreachExc, ErrnoExc)
+DEFINE_EXC (EnetresetExc, ErrnoExc)
+DEFINE_EXC (EconnabortedExc, ErrnoExc)
+DEFINE_EXC (EconnresetExc, ErrnoExc)
+DEFINE_EXC (EnobufsExc, ErrnoExc)
+DEFINE_EXC (EisconnExc, ErrnoExc)
+DEFINE_EXC (EnotconnExc, ErrnoExc)
+DEFINE_EXC (EshutdownExc, ErrnoExc)
+DEFINE_EXC (EtoomanyrefsExc, ErrnoExc)
+DEFINE_EXC (EtimedoutExc, ErrnoExc)
+DEFINE_EXC (EconnrefusedExc, ErrnoExc)
+DEFINE_EXC (EhostdownExc, ErrnoExc)
+DEFINE_EXC (EhostunreachExc, ErrnoExc)
+DEFINE_EXC (EalreadyExc, ErrnoExc)
+DEFINE_EXC (EinprogressExc, ErrnoExc)
+DEFINE_EXC (EstaleExc, ErrnoExc)
+DEFINE_EXC (EioresidExc, ErrnoExc)
+DEFINE_EXC (EucleanExc, ErrnoExc)
+DEFINE_EXC (EnotnamExc, ErrnoExc)
+DEFINE_EXC (EnavailExc, ErrnoExc)
+DEFINE_EXC (EisnamExc, ErrnoExc)
+DEFINE_EXC (EremoteioExc, ErrnoExc)
+DEFINE_EXC (EinitExc, ErrnoExc)
+DEFINE_EXC (EremdevExc, ErrnoExc)
+DEFINE_EXC (EcanceledExc, ErrnoExc)
+DEFINE_EXC (EnolimfileExc, ErrnoExc)
+DEFINE_EXC (EproclimExc, ErrnoExc)
+DEFINE_EXC (EdisjointExc, ErrnoExc)
+DEFINE_EXC (EnologinExc, ErrnoExc)
+DEFINE_EXC (EloginlimExc, ErrnoExc)
+DEFINE_EXC (EgrouploopExc, ErrnoExc)
+DEFINE_EXC (EnoattachExc, ErrnoExc)
+DEFINE_EXC (EnotsupExc, ErrnoExc)
+DEFINE_EXC (EnoattrExc, ErrnoExc)
+DEFINE_EXC (EdircorruptedExc, ErrnoExc)
+DEFINE_EXC (EdquotExc, ErrnoExc)
+DEFINE_EXC (EnfsremoteExc, ErrnoExc)
+DEFINE_EXC (EcontrollerExc, ErrnoExc)
+DEFINE_EXC (EnotcontrollerExc, ErrnoExc)
+DEFINE_EXC (EenqueuedExc, ErrnoExc)
+DEFINE_EXC (EnotenqueuedExc, ErrnoExc)
+DEFINE_EXC (EjoinedExc, ErrnoExc)
+DEFINE_EXC (EnotjoinedExc, ErrnoExc)
+DEFINE_EXC (EnoprocExc, ErrnoExc)
+DEFINE_EXC (EmustrunExc, ErrnoExc)
+DEFINE_EXC (EnotstoppedExc, ErrnoExc)
+DEFINE_EXC (EclockcpuExc, ErrnoExc)
+DEFINE_EXC (EinvalstateExc, ErrnoExc)
+DEFINE_EXC (EnoexistExc, ErrnoExc)
+DEFINE_EXC (EendofminorExc, ErrnoExc)
+DEFINE_EXC (EbufsizeExc, ErrnoExc)
+DEFINE_EXC (EemptyExc, ErrnoExc)
+DEFINE_EXC (EnointrgroupExc, ErrnoExc)
+DEFINE_EXC (EinvalmodeExc, ErrnoExc)
+DEFINE_EXC (EcantextentExc, ErrnoExc)
+DEFINE_EXC (EinvaltimeExc, ErrnoExc)
+DEFINE_EXC (EdestroyedExc, ErrnoExc)
+
+IEX_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif
--- a/cs440-acg/ext/openexr/IlmBase/Iex/IexExport.h
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/IexExport.h
@@ -0,0 +1,51 @@
+#ifndef IEXEXPORT_H
+#define IEXEXPORT_H
+
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#if defined(OPENEXR_DLL)
+    #if defined(IEX_EXPORTS)
+    #define IEX_EXPORT __declspec(dllexport)
+    #else
+    #define IEX_EXPORT __declspec(dllimport)
+    #endif
+    #define IEX_EXPORT_CONST
+#else
+    #define IEX_EXPORT
+    #define IEX_EXPORT_CONST const
+#endif
+
+#endif // #ifndef IEXEXPORT_H
+
--- a/cs440-acg/ext/openexr/IlmBase/Iex/IexForward.h
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/IexForward.h
@@ -0,0 +1,229 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDED_IEXFORWARD_H
+#define INCLUDED_IEXFORWARD_H
+
+#include "IexNamespace.h"
+
+IEX_INTERNAL_NAMESPACE_HEADER_ENTER
+
+//
+// Base exceptions.
+//
+
+class BaseExc;
+class ArgExc;
+class LogicExc;
+class InputExc;
+class IoExc;
+class MathExc;
+class ErrnoExc;
+class NoImplExc;
+class NullExc;
+class TypeExc;
+
+//
+// Math exceptions.
+//
+
+class OverflowExc;
+class UnderflowExc;
+class DivzeroExc;
+class InexactExc;
+class InvalidFpOpExc;
+
+//
+// Errno exceptions.
+//
+
+class EpermExc;
+class EnoentExc;
+class EsrchExc;
+class EintrExc;
+class EioExc;
+class EnxioExc;
+class E2bigExc;
+class EnoexecExc;
+class EbadfExc;
+class EchildExc;
+class EagainExc;
+class EnomemExc;
+class EaccesExc;
+class EfaultExc;
+class EnotblkExc;
+class EbusyExc;
+class EexistExc;
+class ExdevExc;
+class EnodevExc;
+class EnotdirExc;
+class EisdirExc;
+class EinvalExc;
+class EnfileExc;
+class EmfileExc;
+class EnottyExc;
+class EtxtbsyExc;
+class EfbigExc;
+class EnospcExc;
+class EspipeExc;
+class ErofsExc;
+class EmlinkExc;
+class EpipeExc;
+class EdomExc;
+class ErangeExc;
+class EnomsgExc;
+class EidrmExc;
+class EchrngExc;
+class El2nsyncExc;
+class El3hltExc;
+class El3rstExc;
+class ElnrngExc;
+class EunatchExc;
+class EnocsiExc;
+class El2hltExc;
+class EdeadlkExc;
+class EnolckExc;
+class EbadeExc;
+class EbadrExc;
+class ExfullExc;
+class EnoanoExc;
+class EbadrqcExc;
+class EbadsltExc;
+class EdeadlockExc;
+class EbfontExc;
+class EnostrExc;
+class EnodataExc;
+class EtimeExc;
+class EnosrExc;
+class EnonetExc;
+class EnopkgExc;
+class EremoteExc;
+class EnolinkExc;
+class EadvExc;
+class EsrmntExc;
+class EcommExc;
+class EprotoExc;
+class EmultihopExc;
+class EbadmsgExc;
+class EnametoolongExc;
+class EoverflowExc;
+class EnotuniqExc;
+class EbadfdExc;
+class EremchgExc;
+class ElibaccExc;
+class ElibbadExc;
+class ElibscnExc;
+class ElibmaxExc;
+class ElibexecExc;
+class EilseqExc;
+class EnosysExc;
+class EloopExc;
+class ErestartExc;
+class EstrpipeExc;
+class EnotemptyExc;
+class EusersExc;
+class EnotsockExc;
+class EdestaddrreqExc;
+class EmsgsizeExc;
+class EprototypeExc;
+class EnoprotooptExc;
+class EprotonosupportExc;
+class EsocktnosupportExc;
+class EopnotsuppExc;
+class EpfnosupportExc;
+class EafnosupportExc;
+class EaddrinuseExc;
+class EaddrnotavailExc;
+class EnetdownExc;
+class EnetunreachExc;
+class EnetresetExc;
+class EconnabortedExc;
+class EconnresetExc;
+class EnobufsExc;
+class EisconnExc;
+class EnotconnExc;
+class EshutdownExc;
+class EtoomanyrefsExc;
+class EtimedoutExc;
+class EconnrefusedExc;
+class EhostdownExc;
+class EhostunreachExc;
+class EalreadyExc;
+class EinprogressExc;
+class EstaleExc;
+class EioresidExc;
+class EucleanExc;
+class EnotnamExc;
+class EnavailExc;
+class EisnamExc;
+class EremoteioExc;
+class EinitExc;
+class EremdevExc;
+class EcanceledExc;
+class EnolimfileExc;
+class EproclimExc;
+class EdisjointExc;
+class EnologinExc;
+class EloginlimExc;
+class EgrouploopExc;
+class EnoattachExc;
+class EnotsupExc;
+class EnoattrExc;
+class EdircorruptedExc;
+class EdquotExc;
+class EnfsremoteExc;
+class EcontrollerExc;
+class EnotcontrollerExc;
+class EenqueuedExc;
+class EnotenqueuedExc;
+class EjoinedExc;
+class EnotjoinedExc;
+class EnoprocExc;
+class EmustrunExc;
+class EnotstoppedExc;
+class EclockcpuExc;
+class EinvalstateExc;
+class EnoexistExc;
+class EendofminorExc;
+class EbufsizeExc;
+class EemptyExc;
+class EnointrgroupExc;
+class EinvalmodeExc;
+class EcantextentExc;
+class EinvaltimeExc;
+class EdestroyedExc;
+
+IEX_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif // INCLUDED_IEXFORWARD_H
--- a/cs440-acg/ext/openexr/IlmBase/Iex/IexMacros.h
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/IexMacros.h
@@ -0,0 +1,170 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef INCLUDED_IEXMACROS_H
+#define INCLUDED_IEXMACROS_H
+
+//--------------------------------------------------------------------
+//
+//	Macros which make throwing exceptions more convenient
+//
+//--------------------------------------------------------------------
+
+#include <sstream>
+
+
+//----------------------------------------------------------------------------
+// A macro to throw exceptions whose text is assembled using stringstreams.
+//
+// Example:
+//
+//	THROW (InputExc, "Syntax error in line " << line ", " << file << ".");
+//	
+//----------------------------------------------------------------------------
+
+#include "IexExport.h"
+#include "IexForward.h"
+
+IEX_EXPORT void iex_debugTrap();
+
+#define THROW(type, text)       \
+    do                          \
+    {                           \
+        iex_debugTrap();        \
+        std::stringstream s;	\
+        s << text;              \
+        throw type (s);         \
+    }                           \
+    while (0)
+
+
+//----------------------------------------------------------------------------
+// Macros to add to or to replace the text of an exception.
+// The new text is assembled using stringstreams.
+//
+// Examples:
+//
+// Append to end of an exception's text:
+//
+//	catch (BaseExc &e)
+//	{
+//	    APPEND_EXC (e, " Directory " << name << " does not exist.");
+//	    throw;
+//	}
+//
+// Replace an exception's text:
+//
+//	catch (BaseExc &e)
+//	{
+//	    REPLACE_EXC (e, "Directory " << name << " does not exist. " << e);
+//	    throw;
+//	}
+//----------------------------------------------------------------------------
+
+#define APPEND_EXC(exc, text)   \
+    do                          \
+    {                           \
+        std::stringstream s;    \
+        s << text;              \
+        exc.append (s);         \
+    }                           \
+    while (0)
+
+#define REPLACE_EXC(exc, text)  \
+    do                          \
+    {                           \
+        std::stringstream s;    \
+        s << text;              \
+        exc.assign (s);         \
+    }                           \
+    while (0)
+
+
+//-------------------------------------------------------------
+// A macro to throw ErrnoExc exceptions whose text is assembled
+// using stringstreams:
+//
+// Example:
+//
+//	THROW_ERRNO ("Cannot open file " << name << " (%T).");
+//
+//-------------------------------------------------------------
+
+#define THROW_ERRNO(text)                         \
+    do                                            \
+    {                                             \
+        std::stringstream s;                      \
+        s << text;                                \
+        ::IEX_NAMESPACE::throwErrnoExc (s.str()); \
+    }                                             \
+    while (0)
+
+
+//-------------------------------------------------------------
+// A macro to throw exceptions if an assertion is false.
+//
+// Example:
+//
+//	ASSERT (ptr != 0, NullExc, "Null pointer" );
+//
+//-------------------------------------------------------------
+
+#define ASSERT(assertion, type, text)   \
+    do                                  \
+    {                                   \
+        if( (assertion) == false )      \
+        {                               \
+            THROW( type, text );        \
+        }                               \
+    }                                   \
+    while (0)
+
+//-------------------------------------------------------------
+// A macro to throw an IEX_NAMESPACE::LogicExc if an assertion is false,
+// with the text composed from the source code file, line number,
+// and assertion argument text.
+//
+// Example:
+//
+//      LOGIC_ASSERT (i < n);
+//
+//-------------------------------------------------------------
+#define LOGIC_ASSERT(assertion)           \
+    ASSERT(assertion,                     \
+           IEX_NAMESPACE::LogicExc,       \
+           __FILE__ << "(" << __LINE__ << "): logical assertion failed: " << #assertion )
+
+#endif
--- a/cs440-acg/ext/openexr/IlmBase/Iex/IexMathExc.h
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/IexMathExc.h
@@ -0,0 +1,57 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef INCLUDED_IEXMATHEXC_H
+#define INCLUDED_IEXMATHEXC_H
+
+#include "IexBaseExc.h"
+
+IEX_INTERNAL_NAMESPACE_HEADER_ENTER
+
+//---------------------------------------------------------
+// Exception classess which correspond to specific floating
+// point exceptions.
+//---------------------------------------------------------
+
+DEFINE_EXC (OverflowExc,    MathExc)	// Overflow
+DEFINE_EXC (UnderflowExc,   MathExc)	// Underflow
+DEFINE_EXC (DivzeroExc,     MathExc)	// Division by zero
+DEFINE_EXC (InexactExc,     MathExc)	// Inexact result
+DEFINE_EXC (InvalidFpOpExc, MathExc)	// Invalid operation
+
+IEX_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif // INCLUDED_IEXMATHEXC_H
--- a/cs440-acg/ext/openexr/IlmBase/Iex/IexNamespace.h
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/IexNamespace.h
@@ -0,0 +1,121 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDED_IEXNAMESPACE_H
+#define INCLUDED_IEXNAMESPACE_H
+
+//
+// The purpose of this file is to make it possible to specify an
+// IEX_INTERNAL_NAMESPACE as a preprocessor definition and have all of the
+// Iex symbols defined within that namespace rather than the standard
+// Iex namespace.  Those symbols are made available to client code through
+// the IEX_NAMESPACE in addition to the IEX_INTERNAL_NAMESPACE.
+//
+// To ensure source code compatibility, the IEX_NAMESPACE defaults to Iex
+// and then "using namespace IEX_INTERNAL_NAMESPACE;" brings all of the
+// declarations from the IEX_INTERNAL_NAMESPACE into the IEX_NAMESPACE.  This
+// means that client code can continue to use syntax like Iex::BaseExc, but
+// at link time it will resolve to a mangled symbol based on the
+// IEX_INTERNAL_NAMESPACE.
+//
+// As an example, if one needed to build against a newer version of Iex and
+// have it run alongside an older version in the same application, it is now
+// possible to use an internal namespace to prevent collisions between the
+// older versions of Iex symbols and the newer ones.  To do this, the
+// following could be defined at build time:
+//
+// IEX_INTERNAL_NAMESPACE = Iex_v2
+//
+// This means that declarations inside Iex headers look like this (after the
+// preprocessor has done its work):
+//
+// namespace Iex_v2 {
+//     ...
+//     class declarations
+//     ...
+// }
+//
+// namespace Iex {
+//     using namespace Iex_v2;
+// }
+//
+
+//
+// Open Source version of this file pulls in the IlmBaseConfig.h file
+// for the configure time options.
+//
+#include "IlmBaseConfig.h"
+
+#if defined(_MSC_VER)
+#  pragma warning(push)
+#  pragma warning(disable: 4515) //  warning C4515: 'Imf': namespace uses itself
+#endif
+
+#ifndef IEX_NAMESPACE
+#define IEX_NAMESPACE Iex
+#endif
+
+#ifndef IEX_INTERNAL_NAMESPACE
+#define IEX_INTERNAL_NAMESPACE IEX_NAMESPACE
+#endif
+
+//
+// We need to be sure that we import the internal namespace into the public one.
+// To do this, we use the small bit of code below which initially defines
+// IEX_INTERNAL_NAMESPACE (so it can be referenced) and then defines
+// IEX_NAMESPACE and pulls the internal symbols into the public namespace.
+//
+
+namespace IEX_INTERNAL_NAMESPACE {}
+namespace IEX_NAMESPACE {
+    using namespace IEX_INTERNAL_NAMESPACE;
+}
+
+//
+// There are identical pairs of HEADER/SOURCE ENTER/EXIT macros so that
+// future extension to the namespace mechanism is possible without changing
+// project source code.
+//
+
+#define IEX_INTERNAL_NAMESPACE_HEADER_ENTER namespace IEX_INTERNAL_NAMESPACE {
+#define IEX_INTERNAL_NAMESPACE_HEADER_EXIT }
+
+#define IEX_INTERNAL_NAMESPACE_SOURCE_ENTER namespace IEX_INTERNAL_NAMESPACE {
+#define IEX_INTERNAL_NAMESPACE_SOURCE_EXIT }
+
+#if defined(_MSC_VER)
+#  pragma warning(pop)
+#endif
+
+#endif // INCLUDED_IEXNAMESPACE_H
--- a/cs440-acg/ext/openexr/IlmBase/Iex/IexThrowErrnoExc.cpp
+++ b/cs440-acg/ext/openexr/IlmBase/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
--- a/cs440-acg/ext/openexr/IlmBase/Iex/IexThrowErrnoExc.h
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/IexThrowErrnoExc.h
@@ -0,0 +1,97 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef INCLUDED_IEXTHROWERRNOEXC_H
+#define INCLUDED_IEXTHROWERRNOEXC_H
+
+//----------------------------------------------------------
+//
+//	A function which throws ExcErrno exceptions
+//
+//----------------------------------------------------------
+
+#include "IexBaseExc.h"
+#include "IexExport.h"
+
+IEX_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+//--------------------------------------------------------------------------
+//
+// Function throwErrnoExc() throws an exception which corresponds to
+// error code errnum.  The exception text is initialized with a copy
+// of the string passed to throwErrnoExc(), where all occurrences of
+// "%T" have been replaced with the output of strerror(oserror()).
+//
+// Example:
+//   
+// If opening file /tmp/output failed with an ENOENT error code,
+// calling
+//
+//	throwErrnoExc ();
+//
+// or
+//
+//	throwErrnoExc ("%T.");
+//
+// will throw an EnoentExc whose text reads
+//
+//	No such file or directory.
+//
+// More detailed messages can be assembled using stringstreams:
+//
+//	std::stringstream s;
+//	s << "Cannot open file " << name << " (%T).";
+//	throwErrnoExc (s);
+//
+// The resulting exception contains the following text:
+//
+//	Cannot open file /tmp/output (No such file or directory).
+//
+// Alternatively, you may want to use the THROW_ERRNO macro defined
+// in IexMacros.h:
+//
+//	THROW_ERRNO ("Cannot open file " << name << " (%T).")
+//
+//--------------------------------------------------------------------------
+
+IEX_EXPORT void throwErrnoExc(const std::string &txt, int errnum);
+IEX_EXPORT void throwErrnoExc(const std::string &txt);
+IEX_EXPORT void throwErrnoExc();
+
+IEX_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif // INCLUDED_IEXTHROWERRNOEXC_H
--- a/cs440-acg/ext/openexr/IlmBase/Iex/Makefile.am
+++ b/cs440-acg/ext/openexr/IlmBase/Iex/Makefile.am
@@ -0,0 +1,22 @@
+## Process this file with automake to produce Makefile.in
+
+INCLUDES = -I$(top_srcdir)/config
+
+lib_LTLIBRARIES = libIex.la
+
+libIex_la_SOURCES = IexThrowErrnoExc.cpp IexBaseExc.cpp IexBaseExc.h \
+		    IexErrnoExc.h Iex.h IexMacros.h IexMathExc.h \
+		    IexThrowErrnoExc.h
+
+libIex_la_LDFLAGS = -version-info @LIBTOOL_VERSION@ -no-undefined
+if LIB_SUFFIX_EXISTS
+libIex_la_LDFLAGS += -release @LIB_SUFFIX@
+endif
+
+libIexincludedir = $(includedir)/OpenEXR
+
+libIexinclude_HEADERS = IexBaseExc.h IexMathExc.h IexThrowErrnoExc.h \
+			IexErrnoExc.h IexMacros.h Iex.h \
+                        IexForward.h IexNamespace.h IexExport.h
+
+EXTRA_DIST = CMakeLists.txt