Index: include/brlcad/Arb8.h
===================================================================
--- include/brlcad/Arb8.h	(revision 74453)
+++ include/brlcad/Arb8.h	(working copy)
@@ -39,22 +39,22 @@
 namespace BRLCAD {
     class BRLCAD_COREINTERFACE_EXPORT Arb8 : public Object {
     public:
-        Arb8(void) throw(bad_alloc);
+        Arb8(void);
         Arb8(const Vector3D& point1,
              const Vector3D& point2,
              const Vector3D& point3,
-             const Vector3D& point4) throw(bad_alloc); ///< arb4 constructor
+             const Vector3D& point4); ///< arb4 constructor
         Arb8(const Vector3D& point1,
              const Vector3D& point2,
              const Vector3D& point3,
              const Vector3D& point4,
-             const Vector3D& point5) throw(bad_alloc); ///< arb5 constructor
+             const Vector3D& point5); ///< arb5 constructor
         Arb8(const Vector3D& point1,
              const Vector3D& point2,
              const Vector3D& point3,
              const Vector3D& point4,
              const Vector3D& point5,
-             const Vector3D& point6) throw(bad_alloc); ///< arb6 constructor
+             const Vector3D& point6); ///< arb6 constructor
         Arb8(const Vector3D& point1,
              const Vector3D& point2,
              const Vector3D& point3,
@@ -61,7 +61,7 @@
              const Vector3D& point4,
              const Vector3D& point5,
              const Vector3D& point6,
-             const Vector3D& point7) throw(bad_alloc); ///< arb7 constructor
+             const Vector3D& point7); ///< arb7 constructor
         Arb8(const Vector3D& point1,
              const Vector3D& point2,
              const Vector3D& point3,
@@ -69,17 +69,17 @@
              const Vector3D& point5,
              const Vector3D& point6,
              const Vector3D& point7,
-             const Vector3D& point8) throw(bad_alloc); ///< arb8 constructor
+             const Vector3D& point8); ///< arb8 constructor
         Arb8(const Vector3D& point1,
-             const Vector3D& point2) throw(bad_alloc); ///< rectangular parallel piped constructor
-        Arb8(const Arb8& original) throw(bad_alloc);
-        virtual ~Arb8(void) throw();
+             const Vector3D& point2); ///< rectangular parallel piped constructor
+        Arb8(const Arb8& original);
+        virtual ~Arb8(void);
 
-        const Arb8&           operator=(const Arb8& original) throw(bad_alloc);
+        const Arb8&           operator=(const Arb8& original);
 
         /// number of effective vertices
         /** returns 0 in case of en error */
-        size_t                NumberOfVertices(void) const throw();
+        size_t                NumberOfVertices(void) const;
 
         /** The argument is the number (1..8) of the vertex as used in the documentation,
             not the index at the storage-structure of an arb8.
@@ -86,30 +86,30 @@
             E.g. with an arb4 "number = 3" returns the vertex with index 2
             and "number = 4" returns the vertex with index 4.
         */
-        Vector3D              Point(size_t number) const throw();
+        Vector3D              Point(size_t number) const;
         void                  SetPoint(size_t    number,
-                                       Vector3D& point) throw();
+                                       Vector3D& point);
 
         /** for convenience one can access the internal storage-structure too */
-        Vector3D              RawPoint(size_t index) const throw();
+        Vector3D              RawPoint(size_t index) const;
         void                  SetRawPoint(size_t    index,
-                                          Vector3D& point) throw();
+                                          Vector3D& point);
 
         void                  SetPoints(const Vector3D& point1,
                                         const Vector3D& point2,
                                         const Vector3D& point3,
-                                        const Vector3D& point4) throw(); ///< this becomes an arb4
+                                        const Vector3D& point4); ///< this becomes an arb4
         void                  SetPoints(const Vector3D& point1,
                                         const Vector3D& point2,
                                         const Vector3D& point3,
                                         const Vector3D& point4,
-                                        const Vector3D& point5) throw(); ///< this becomes an arb5
+                                        const Vector3D& point5); ///< this becomes an arb5
         void                  SetPoints(const Vector3D& point1,
                                         const Vector3D& point2,
                                         const Vector3D& point3,
                                         const Vector3D& point4,
                                         const Vector3D& point5,
-                                        const Vector3D& point6) throw(); ///< this becomes an arb6
+                                        const Vector3D& point6); ///< this becomes an arb6
         void                  SetPoints(const Vector3D& point1,
                                         const Vector3D& point2,
                                         const Vector3D& point3,
@@ -116,7 +116,7 @@
                                         const Vector3D& point4,
                                         const Vector3D& point5,
                                         const Vector3D& point6,
-                                        const Vector3D& point7) throw(); ///< this becomes an arb7
+                                        const Vector3D& point7); ///< this becomes an arb7
         void                  SetPoints(const Vector3D& point1,
                                         const Vector3D& point2,
                                         const Vector3D& point3,
@@ -124,22 +124,22 @@
                                         const Vector3D& point5,
                                         const Vector3D& point6,
                                         const Vector3D& point7,
-                                        const Vector3D& point8) throw(); ///< this becomes an arb8
+                                        const Vector3D& point8); ///< this becomes an arb8
         void                  SetPoints(const Vector3D& point1,
-                                        const Vector3D& point2) throw(); ///< this becomes an rectangular parallel piped
+                                        const Vector3D& point2); ///< this becomes an rectangular parallel piped
 
         // inherited from BRLCAD::Object
-        virtual const Object& operator=(const Object& original) throw(bad_alloc);
-        virtual Object*       Clone(void) const throw(bad_alloc, std::bad_alloc);
-        static const char*    ClassName(void) throw();
-        virtual const char*   Type(void) const throw();
-        virtual bool          IsValid(void) const throw(); ///< checks for planarity of faces and direction of face normals
+        virtual const Object& operator=(const Object& original);
+        virtual Object*       Clone(void) const;
+        static const char*    ClassName(void);
+        virtual const char*   Type(void) const;
+        virtual bool          IsValid(void) const; ///< checks for planarity of faces and direction of face normals
 
     protected:
         Arb8(resource*       resp,
              directory*      pDir,
              rt_db_internal* ip,
-             db_i*           dbip) throw();
+             db_i*           dbip);
 
         friend class ConstDatabase;
 
@@ -146,8 +146,8 @@
     private:
         rt_arb_internal* m_internalp;
 
-        rt_arb_internal*	Internal(void) throw();
-        const rt_arb_internal*	Internal(void) const throw();
+        rt_arb_internal*	Internal(void);
+        const rt_arb_internal*	Internal(void) const;
 
         friend class Database;
     };
Index: include/brlcad/BagOfTriangles.h
===================================================================
--- include/brlcad/BagOfTriangles.h	(revision 74453)
+++ include/brlcad/BagOfTriangles.h	(working copy)
@@ -48,19 +48,19 @@
             CounterClockWise
         };
 
-        BagOfTriangles(void) throw(bad_alloc);
-        BagOfTriangles(const BagOfTriangles& original) throw(bad_alloc);
-        virtual ~BagOfTriangles(void) throw();
+        BagOfTriangles(void);
+        BagOfTriangles(const BagOfTriangles& original);
+        virtual ~BagOfTriangles(void);
 
-        const BagOfTriangles& operator=(const BagOfTriangles& original) throw(bad_alloc);
+        const BagOfTriangles& operator=(const BagOfTriangles& original);
 
         class BRLCAD_COREINTERFACE_EXPORT Face {
         public:
-            Face(void) throw() : m_bot(0), m_faceIndex(0) {}
-            Face(const Face& original) throw() : m_bot(original.m_bot), m_faceIndex(original.m_faceIndex) {}
-            ~Face(void) throw() {}
+            Face(void): m_bot(0), m_faceIndex(0) {}
+            Face(const Face& original): m_bot(original.m_bot), m_faceIndex(original.m_faceIndex) {}
+            ~Face(void){}
 
-            const Face& operator=(const Face& original) throw() {
+            const Face& operator=(const Face& original){
                 m_bot       = original.m_bot;
                 m_faceIndex = original.m_faceIndex;
 
@@ -67,25 +67,25 @@
                 return *this;
             }
 
-            Vector3D    Point(size_t index) const throw();
+            Vector3D    Point(size_t index) const;
             void        SetPoint(size_t          index,
-                                 const Vector3D& point) throw(bad_alloc);
+                                 const Vector3D& point);
             void        SetPoints(const Vector3D& point1,
                                   const Vector3D& point2,
-                                  const Vector3D& point3) throw(bad_alloc);
+                                  const Vector3D& point3);
 
-            double      Thickness(void) const throw();
-            void        SetThickness(double value) throw();
+            double      Thickness(void) const;
+            void        SetThickness(double value);
 
-            bool        ApendThickness(void) const throw();
-            void        SetApendThickness(bool apendThickness) throw();
+            bool        ApendThickness(void) const;
+            void        SetApendThickness(bool apendThickness);
 
-            Vector3D    Normal(size_t index) const throw();
+            Vector3D    Normal(size_t index) const;
             void        SetNormal(size_t          index,
-                                  const Vector3D& normal) throw();
+                                  const Vector3D& normal);
             void        SetNormals(const Vector3D& normal1,
                                    const Vector3D& normal2,
-                                   const Vector3D& normal3) throw(bad_alloc);
+                                   const Vector3D& normal3);
 
                         operator void*(void) { ///< to test if the face is NULL
                 return m_bot;
@@ -93,7 +93,7 @@
 
         protected:
             Face(rt_bot_internal* original,
-                 size_t           originalIndex) throw() : m_bot(original), m_faceIndex(originalIndex) {}
+                 size_t           originalIndex): m_bot(original), m_faceIndex(originalIndex) {}
 
             friend BagOfTriangles;
 
@@ -102,49 +102,49 @@
             size_t           m_faceIndex;
         };
 
-        BotMode               Mode(void) const throw();
-        void                  SetMode(BotMode mode) throw(bad_alloc);
+        BotMode               Mode(void) const;
+        void                  SetMode(BotMode mode);
 
-        BotOrientation        Orientation(void) const throw();
-        void                  SetOrientation(BotOrientation orientation) throw();
+        BotOrientation        Orientation(void) const;
+        void                  SetOrientation(BotOrientation orientation);
 
-        bool                  FacesHaveNormals(void) const throw();
-        void                  SetFacesHaveNormals(bool facesHaveNormals) throw(bad_alloc);
+        bool                  FacesHaveNormals(void) const;
+        void                  SetFacesHaveNormals(bool facesHaveNormals);
 
-        bool                  UseFaceNormals(void) const throw();
-        void                  SetUseFaceNormals(bool useFaceNormals) throw();
+        bool                  UseFaceNormals(void) const;
+        void                  SetUseFaceNormals(bool useFaceNormals);
 
-        bool                  UseFloats(void) const throw();
-        void                  SetUseFloats(bool useFloats) throw();
+        bool                  UseFloats(void) const;
+        void                  SetUseFloats(bool useFloats);
 
-        size_t                NumberOfFaces(void) const throw();
+        size_t                NumberOfFaces(void) const;
 
-        Face                  GetFace(size_t index) throw();
+        Face                  GetFace(size_t index);
         Face                  AddFace(const Vector3D& point1,
                                       const Vector3D& point2,
-                                      const Vector3D& point3) throw(bad_alloc);
+                                      const Vector3D& point3);
 
-        void                  DeleteFace(size_t index) throw(bad_alloc);
+        void                  DeleteFace(size_t index);
 
         // inherited from BRLCAD::Object
-        virtual const Object& operator=(const Object& original) throw(bad_alloc);
-        virtual Object*       Clone(void) const throw(bad_alloc, std::bad_alloc);
-        static const char*    ClassName(void) throw();
-        virtual const char*   Type(void) const throw();
-        virtual bool          IsValid(void) const throw();
+        virtual const Object& operator=(const Object& original);
+        virtual Object*       Clone(void) const;
+        static const char*    ClassName(void);
+        virtual const char*   Type(void) const;
+        virtual bool          IsValid(void) const;
 
     protected:
         BagOfTriangles(resource*       resp,
                        directory*      pDir,
                        rt_db_internal* ip,
-                       db_i*           dbip = 0) throw();
+                       db_i*           dbip = 0);
 
         friend class ConstDatabase;
 
     private:
         struct rt_bot_internal *m_internalp;
-        const rt_bot_internal* Internal(void) const throw();
-        rt_bot_internal*       Internal(void) throw();
+        const rt_bot_internal* Internal(void) const;
+        rt_bot_internal*       Internal(void);
 
         friend class Database;
     };
Index: include/brlcad/Combination.h
===================================================================
--- include/brlcad/Combination.h	(revision 74453)
+++ include/brlcad/Combination.h	(working copy)
@@ -40,14 +40,14 @@
 namespace BRLCAD {
     class BRLCAD_COREINTERFACE_EXPORT Combination : public Object {
     public:
-        Combination(void) throw(bad_alloc);
-        Combination(const Combination& original) throw(bad_alloc);
-        virtual ~Combination(void) throw();
+        Combination(void);
+        Combination(const Combination& original);
+        virtual ~Combination(void);
 
-        const Combination&    operator=(const Combination& original) throw(bad_alloc);
-        
-        class TreeNode; // part 1/2 of a work-around a bug in i686-apple-darwin9-gcc-4.0.1 (GCC) 4.0.1 (Apple Inc. build 5465)
+        const Combination&    operator=(const Combination& original);
 
+        class TreeNode;       // part 1/2 of a work-around a bug in i686-apple-darwin9-gcc-4.0.1 (GCC) 4.0.1 (Apple Inc. build 5465)
+
         class BRLCAD_COREINTERFACE_EXPORT ConstTreeNode {
         public:
             enum Operator {
@@ -60,23 +60,23 @@
                 Leaf          ///< actually an operand
             };
 
-            ConstTreeNode(void) throw() : m_tree(0) {}
-            ConstTreeNode(const ConstTreeNode& original) throw() : m_tree(original.m_tree) {}
-            virtual ~ConstTreeNode(void) throw() {}
+            ConstTreeNode(void): m_tree(0) {}
+            ConstTreeNode(const ConstTreeNode& original): m_tree(original.m_tree) {}
+            virtual ~ConstTreeNode(void){}
 
-            const ConstTreeNode& operator=(const ConstTreeNode& original) throw() {
+            const ConstTreeNode& operator=(const ConstTreeNode& original){
                 m_tree = original.m_tree;
                 return *this;
             }
 
-            Operator             Operation(void) const throw();
-            ConstTreeNode        LeftOperand(void) const throw();  ///< the left operand of a binary operation
-            ConstTreeNode        RightOperand(void) const throw(); ///< the right operand of a binary operation
-            ConstTreeNode        Operand(void) const throw();      ///< the operand of a unary operation
-            const char*          Name(void) const throw();         ///< the name of the operand object in a leaf
-            const double*        Matrix(void) const throw();       ///< the transformation matrix of the operand object in a leaf
+            Operator             Operation(void) const;
+            ConstTreeNode        LeftOperand(void) const;           ///< the left operand of a binary operation
+            ConstTreeNode        RightOperand(void) const;          ///< the right operand of a binary operation
+            ConstTreeNode        Operand(void) const;               ///< the operand of a unary operation
+            const char*          Name(void) const;                  ///< the name of the operand object in a leaf
+            const double*        Matrix(void) const;                ///< the transformation matrix of the operand object in a leaf
 
-                                 operator void*(void) {            ///< to test if the node is NULL
+                                 operator void*(void) {             ///< to test if the node is NULL
                 return m_tree;
             }
 
@@ -83,7 +83,7 @@
         protected:
             tree* m_tree;
 
-            ConstTreeNode(tree* original) throw() : m_tree(original) {}
+            ConstTreeNode(tree* original): m_tree(original) {}
 
             friend class TreeNode; // part 2/2 of a work-around a bug in i686-apple-darwin9-gcc-4.0.1 (GCC) 4.0.1 (Apple Inc. build 5465)
             friend class Combination;
@@ -92,13 +92,13 @@
 
         class BRLCAD_COREINTERFACE_EXPORT TreeNode : public ConstTreeNode {
         public:
-            TreeNode(void) throw() : ConstTreeNode(), m_internalp(0), m_resp(0) {}
-            TreeNode(const TreeNode& original) throw() : ConstTreeNode(original),
+            TreeNode(void): ConstTreeNode(), m_internalp(0), m_resp(0) {}
+            TreeNode(const TreeNode& original): ConstTreeNode(original),
                                                          m_internalp(original.m_internalp),
                                                          m_resp(original.m_resp) {}
-            virtual ~TreeNode(void) throw() {}
+            virtual ~TreeNode(void){}
 
-            const TreeNode& operator=(const TreeNode& original) throw() {
+            const TreeNode& operator=(const TreeNode& original){
                 ConstTreeNode::operator=(original);
 
                 m_internalp = original.m_internalp;
@@ -107,11 +107,11 @@
                 return *this;
             }
 
-            TreeNode        LeftOperand(void) throw();                          ///< the left operand of a binary operation
-            TreeNode        RightOperand(void) throw();                         ///< the right operand of a binary operation
-            TreeNode        Operand(void) throw();                              ///< the operand of a unary operation
-            void            SetName(const char* value) const throw(bad_alloc);  ///< sets the name of the operand object in a leaf
-            void            SetMatrix(double value[16]) const throw(bad_alloc); ///< sets the transformation matrix of the operand object in a leaf
+            TreeNode        LeftOperand(void);                          ///< the left operand of a binary operation
+            TreeNode        RightOperand(void);                         ///< the right operand of a binary operation
+            TreeNode        Operand(void);                              ///< the operand of a unary operation
+            void            SetName(const char* value) const;           ///< sets the name of the operand object in a leaf
+            void            SetMatrix(double value[16]) const;          ///< sets the transformation matrix of the operand object in a leaf
 
             /// applies an operator to this node
             /** - it creates a new node
@@ -118,7 +118,7 @@
                 - the operator has to be unary, i.e. \a Not
                 - \return the new created operation node
             */
-            TreeNode        Apply(Operator op) throw(bad_alloc);
+            TreeNode        Apply(Operator op);
 
             /// creates a new node with "this op theOther"
             /** - the operator has to be binary
@@ -126,7 +126,7 @@
                 - \return the new created operation node
             */
             TreeNode        Apply(Operator             op,
-                                  const ConstTreeNode& theOther) throw(bad_alloc);
+                                  const ConstTreeNode& theOther);
 
             /// "this op leaf(\a leafName)"
             /** - creates two nodes
@@ -137,7 +137,7 @@
                 - \return the new created operation node
             */
             TreeNode        Apply(Operator    op,
-                                  const char* leafName) throw(bad_alloc);
+                                  const char* leafName);
 
             /// creates a new node with "theOther op this"
             /** - the operator has to be binary
@@ -145,7 +145,7 @@
                 - \return the new created operation node
             */
             TreeNode        Apply(const ConstTreeNode& theOther,
-                                  Operator             op) throw(bad_alloc);
+                                  Operator             op);
 
             /// "this op leaf(\a leafName)"
             /** - creates two nodes
@@ -156,7 +156,7 @@
                 - \return the new created operation node
             */
             TreeNode        Apply(const char* leafName,
-                                  Operator    op) throw(bad_alloc);
+                                  Operator    op);
 
             /// deletes this node and rewinds all parint nodes until a valid state is reached
             /** E.g. if this node is an operand of a binary operation, this operation will be removed too
@@ -164,7 +164,7 @@
 
                 This node becomes invalid (operator \a Null) during this procedure.
             */
-            void            Delete(void) throw();
+            void            Delete(void);
 
         private:
             rt_comb_internal* m_internalp;
@@ -172,21 +172,21 @@
 
             TreeNode(tree*             original,
                      rt_comb_internal* internalp,
-                     resource*         resp) throw() : ConstTreeNode(original), m_internalp(internalp), m_resp(resp) {}
+                     resource*         resp): ConstTreeNode(original), m_internalp(internalp), m_resp(resp) {}
 
             friend class Combination;
         };
 
 
-        ConstTreeNode         Tree(void) const throw();
-        TreeNode              Tree(void) throw();
+        ConstTreeNode         Tree(void) const;
+        TreeNode              Tree(void);
 
         /// adds a leaf to the tree
         /** If the tree's root node is not \a Null \a Tree().Apply(Union, leafName) will be performed */
-        void                  AddLeaf(const char* leafName) throw(bad_alloc);
+        void                  AddLeaf(const char* leafName);
 
-        bool                  IsRegion(void) const throw();
-        void                  SetIsRegion(bool value) throw();
+        bool                  IsRegion(void) const;
+        void                  SetIsRegion(bool value);
 
         enum FastgenType {
             Non,   ///< not a Fastgen region
@@ -194,45 +194,45 @@
             Volume
         };
 
-        FastgenType           FastgenRegion(void) const throw();
-        void                  SetFastgenRegion(FastgenType value) throw();
-        int                   RegionId(void) const throw();
-        void                  SetRegionId(int value) throw();
-        int                   Aircode(void) const throw();
-        void                  SetAircode(int value) throw();
-        int                   GiftMaterial(void) const throw();
-        void                  SetGiftMaterial(int value) throw();
-        int                   LineOfSight(void) const throw();
-        void                  SetLineOfSight(int value) throw();
-        bool                  HasColor(void) const throw();
-        void                  SetHasColor(bool value) throw();
-        double                Red(void) const throw();
-        void                  SetRed(double value) throw();
-        double                Green(void) const throw();
-        void                  SetGreen(double value) throw();
-        double                Blue(void) const throw();
-        void                  SetBlue(double value) throw();
-        const char*           Shader(void) const throw();
-        void                  SetShader(const char* value) throw(bad_alloc);
-        bool                  Inherit(void) const throw(); ///< override lower nodes color and shader
-        void                  SetInherit(bool value) throw();
-        const char*           Material(void) const throw();
-        void                  SetMaterial(const char* value) throw(bad_alloc);
-        double                Temperature(void) const throw();
-        void                  SetTemperature(double value) throw();
+        FastgenType           FastgenRegion(void) const;
+        void                  SetFastgenRegion(FastgenType value);
+        int                   RegionId(void) const;
+        void                  SetRegionId(int value);
+        int                   Aircode(void) const ;
+        void                  SetAircode(int value);
+        int                   GiftMaterial(void) const;
+        void                  SetGiftMaterial(int value);
+        int                   LineOfSight(void) const;
+        void                  SetLineOfSight(int value);
+        bool                  HasColor(void) const;
+        void                  SetHasColor(bool value);
+        double                Red(void) const;
+        void                  SetRed(double value);
+        double                Green(void) const;
+        void                  SetGreen(double value);
+        double                Blue(void) const;
+        void                  SetBlue(double value);
+        const char*           Shader(void) const;
+        void                  SetShader(const char* value);
+        bool                  Inherit(void) const;            ///< override lower nodes color and shader
+        void                  SetInherit(bool value);
+        const char*           Material(void) const;
+        void                  SetMaterial(const char* value);
+        double                Temperature(void) const;
+        void                  SetTemperature(double value);
 
         // inherited from BRLCAD::Object
-        virtual const Object& operator=(const Object& original) throw(bad_alloc);
-        virtual Object*       Clone(void) const throw(bad_alloc, std::bad_alloc);
-        static const char*    ClassName(void) throw();
-        virtual const char*   Type(void) const throw();
-        virtual bool          IsValid(void) const throw();
+        virtual const Object& operator=(const Object& original);
+        virtual Object*       Clone(void) const;
+        static const char*    ClassName(void);
+        virtual const char*   Type(void) const;
+        virtual bool          IsValid(void) const;
 
     protected:
         Combination(resource*       resp,
                     directory*      pDir,
                     rt_db_internal* ip,
-                    db_i*           dbip = 0) throw();
+                    db_i*           dbip = 0);
 
         friend class ConstDatabase;
 
@@ -240,8 +240,8 @@
         // holds Objects's content if not connected to a database
         rt_comb_internal* m_internalp;
 
-        const rt_comb_internal*   Internal(void) const throw();
-        virtual rt_comb_internal* Internal(void) throw();
+        const rt_comb_internal*   Internal(void) const;
+        virtual rt_comb_internal* Internal(void);
 
         friend class Database;
     };
Index: include/brlcad/Cone.h
===================================================================
--- include/brlcad/Cone.h	(revision 74453)
+++ include/brlcad/Cone.h	(working copy)
@@ -39,44 +39,44 @@
 namespace BRLCAD {
     class BRLCAD_COREINTERFACE_EXPORT Cone : public Object {
     public:
-        Cone(void) throw(bad_alloc);                               ///< constructs a cone at the origin with unit radius and unit height
+        Cone(void);                                   ///< constructs a cone at the origin with unit radius and unit height
         Cone(const Vector3D& basePoint,
              const Vector3D& height,
              const Vector3D& semiPrincipalAxisA,
              const Vector3D& semiPrincipalAxisB,
              double          ratioCtoA,
-             double          ratioDtoB) throw(bad_alloc);          ///< tgc: basePoint, height, two perpendicular semi principal axes of base face and two scalars for the semi principal axes of top face
+             double          ratioDtoB);              ///< tgc: basePoint, height, two perpendicular semi principal axes of base face and two scalars for the semi principal axes of top face
         Cone(const Vector3D& basePoint,
              const Vector3D& height,
              const Vector3D& semiPrincipalAxisA,
              const Vector3D& semiPrincipalAxisB,
-             double          scale) throw(bad_alloc);              ///< tec: basePoint, height, two perpendicular semi principal axes of base face and one ratio for scaling the semi principal axes of top face
+             double          scale);                  ///< tec: basePoint, height, two perpendicular semi principal axes of base face and one ratio for scaling the semi principal axes of top face
         Cone(const Vector3D& basePoint,
              const Vector3D& height,
              const Vector3D& semiPrincipalAxisA,
-             const Vector3D& semiPrincipalAxisB) throw(bad_alloc); ///< rec: basePoint, height, two perpendicular semi principal axes of base and top face
+             const Vector3D& semiPrincipalAxisB);     ///< rec: basePoint, height, two perpendicular semi principal axes of base and top face
         Cone(const Vector3D& basePoint,
              const Vector3D& height,
              double          radiusBase,
-             double          radiusTop) throw(bad_alloc);          ///< trc: basePoint, height and two radii for base and top face respectively
+             double          radiusTop);              ///< trc: basePoint, height and two radii for base and top face respectively
         Cone(const Vector3D& basePoint,
              const Vector3D& height,
-             double          radius) throw(bad_alloc);             ///< rcc: basePoint, height and one radius for base and top face
-        Cone(const Cone& original) throw(bad_alloc);
-        virtual ~Cone(void) throw();
+             double          radius);                 ///< rcc: basePoint, height and one radius for base and top face
+        Cone(const Cone& original);
+        virtual ~Cone(void);
 
-        const Cone&           operator=(const Cone& original) throw(bad_alloc);
+        const Cone&           operator=(const Cone& original);
 
-        Vector3D              BasePoint(void) const throw();
-        void                  SetBasePoint(const Vector3D& basePoint) throw();
+        Vector3D              BasePoint(void) const;
+        void                  SetBasePoint(const Vector3D& basePoint);
 
-        Vector3D              Height(void) const throw();
-        void                  SetHeight(const Vector3D& height) throw();
+        Vector3D              Height(void) const;
+        void                  SetHeight(const Vector3D& height);
 
         /// semi principal axes (base and top face) are accessed by their index (0/1/2/3 for the vectos a/b/c/d)
-        Vector3D              SemiPrincipalAxis(size_t index) const throw();
+        Vector3D              SemiPrincipalAxis(size_t index) const;
         void                  SetSemiPrincipalAxis(size_t          index,
-                                                   const Vector3D& semiPrincipalAxis) throw();
+                                                   const Vector3D& semiPrincipalAxis);
 
         void                  Set(const Vector3D& basePoint,
                                   const Vector3D& height,
@@ -83,36 +83,36 @@
                                   const Vector3D& semiPrincipalAxisA,
                                   const Vector3D& semiPrincipalAxisB,
                                   double          ratioCtoA,
-                                  double          ratioDtoB) throw();          ///< truncated general cone (tgc)
+                                  double          ratioDtoB);                 ///< truncated general cone (tgc)
         void                  Set(const Vector3D& basePoint,
                                   const Vector3D& height,
                                   const Vector3D& semiPrincipalAxisA,
                                   const Vector3D& semiPrincipalAxisB,
-                                  double          scale) throw();              ///< truncated elliptical cone (tec)
+                                  double          scale);                     ///< truncated elliptical cone (tec)
         void                  Set(const Vector3D& basePoint,
                                   const Vector3D& height,
                                   const Vector3D& semiPrincipalAxisA,
-                                  const Vector3D& semiPrincipalAxisB) throw(); ///< right elliptical cylinder (rec)
+                                  const Vector3D& semiPrincipalAxisB);        ///< right elliptical cylinder (rec)
         void                  Set(const Vector3D& basePoint,
                                   const Vector3D& height,
                                   double          radiusBase,
-                                  double          radiusTop) throw();          ///< truncated right cone (trc)
+                                  double          radiusTop);                 ///< truncated right cone (trc)
         void                  Set(const Vector3D& basePoint,
                                   const Vector3D& height,
-                                  double          radius) throw();             ///< right circular cylinder (rcc)
+                                  double          radius);                    ///< right circular cylinder (rcc)
 
         // inherited from BRLCAD::Object
-        virtual const Object& operator=(const Object& original) throw(bad_alloc);
-        virtual Object*       Clone(void) const throw(bad_alloc, std::bad_alloc);
-        static const char*    ClassName(void) throw();
-        virtual const char*   Type(void) const throw();
-        virtual bool          IsValid(void) const throw(); ///< checks if semi-principal axes are perpendicular, if the ones at the base have positive length, if height has positive length and is not in the plane of semi-principal axes and if corresponding base and top semi principal axes are parallel and pointing to the same direction
+        virtual const Object& operator=(const Object& original);
+        virtual Object*       Clone(void) const;
+        static const char*    ClassName(void);
+        virtual const char*   Type(void) const;
+        virtual bool          IsValid(void) const; ///< checks if semi-principal axes are perpendicular, if the ones at the base have positive length, if height has positive length and is not in the plane of semi-principal axes and if corresponding base and top semi principal axes are parallel and pointing to the same direction
 
     protected:
         Cone(resource*       resp,
              directory*      pDir,
              rt_db_internal* ip,
-             db_i*           dbip) throw();
+             db_i*           dbip);
 
         friend class ConstDatabase;
 
@@ -119,8 +119,8 @@
     private:
         rt_tgc_internal* m_internalp;
 
-        rt_tgc_internal*       Internal(void) throw();
-        const rt_tgc_internal* Internal(void) const throw();
+        rt_tgc_internal*       Internal(void);
+        const rt_tgc_internal* Internal(void) const;
 
         friend class Database;
     };
Index: include/brlcad/ConstDatabase.h
===================================================================
--- include/brlcad/ConstDatabase.h	(revision 74453)
+++ include/brlcad/ConstDatabase.h	(working copy)
@@ -45,29 +45,29 @@
 
     class BRLCAD_COREINTERFACE_EXPORT ConstDatabase {
     public:
-        ConstDatabase(void) throw(bad_alloc);
-        virtual ~ConstDatabase(void) throw();
+        ConstDatabase(void);
+        virtual ~ConstDatabase(void);
 
         /// associates the handle with a BRL-CAD database file (*.g)
         /** If the handle was already associated with a database file this association will be discarded.
             The file will be opened for reading only. */
-        virtual bool         Load(const char* fileName) throw();
+        virtual bool         Load(const char* fileName);
 
         /// @name Parsing the database
         //@{
         /// title string read from the database
-        const char*          Title(void) const throw();
+        const char*          Title(void) const;
 
 
         class BRLCAD_COREINTERFACE_EXPORT TopObjectIterator {
         public:
-            TopObjectIterator(const TopObjectIterator& original) throw() : m_hashTablePosition(original.m_hashTablePosition),
-                                                                           m_pDir(original.m_pDir),
-                                                                           m_rtip(original.m_rtip) {}
+            TopObjectIterator(const TopObjectIterator& original): m_hashTablePosition(original.m_hashTablePosition),
+                                                                  m_pDir(original.m_pDir),
+                                                                  m_rtip(original.m_rtip) {}
 
-            ~TopObjectIterator(void) throw() {}
+            ~TopObjectIterator(void) {}
 
-            const TopObjectIterator& operator=(const TopObjectIterator& original) throw() {
+            const TopObjectIterator& operator=(const TopObjectIterator& original) {
                 m_hashTablePosition = original.m_hashTablePosition;
                 m_pDir              = original.m_pDir;
                 m_rtip              = original.m_rtip;
@@ -75,9 +75,9 @@
                 return *this;
             }
 
-            const TopObjectIterator& operator++(void) throw();
-            bool                     Good(void) const throw();
-            const char*              Name(void) const throw();
+            const TopObjectIterator& operator++(void);
+            bool                     Good(void) const;
+            const char*              Name(void) const;
 
         private:
             size_t           m_hashTablePosition;
@@ -86,7 +86,7 @@
 
             TopObjectIterator(size_t           hashTablePosition,
                               const directory* pDir,
-                              const rt_i*      rtip) throw();
+                              const rt_i*      rtip);
 
             friend class ConstDatabase;
 
@@ -96,7 +96,7 @@
 
         /// returns the first of the top level objects via an iterator object
         /** To get a list of all top level objects you have to use the iterator returned by this function. */
-        TopObjectIterator    FirstTopObject(void) const throw();
+        TopObjectIterator    FirstTopObject(void) const;
         //@}
 
         /// @name Accessing objects
@@ -103,15 +103,15 @@
         //@{
         class ObjectCallback {
         public:
-            virtual ~ObjectCallback(void) throw() {}
+            virtual ~ObjectCallback(void) {}
 
             /// the user has to implement this object method to evaluate the object
             virtual void operator()(const Object& object) = 0;
 
         protected:
-            ObjectCallback(void) throw() {}
-            ObjectCallback(const ObjectCallback&) throw() {}
-            const ObjectCallback& operator=(const ObjectCallback&) throw() {return *this;}
+            ObjectCallback(void) {}
+            ObjectCallback(const ObjectCallback&) {}
+            const ObjectCallback& operator=(const ObjectCallback&) {return *this;}
         };
 
         /// selects a single object and hand it over to an ObjectCallback (read only)
@@ -120,11 +120,11 @@
 
         /// overloaded member function, provided for convenience: selects a single object and and returns a copy of it
         /** Do not forget to BRLCAD::Object::Destroy() the copy when you are finished with it! */
-        Object*              Get(const char* objectName) const throw(bad_alloc, std::bad_alloc);
+        Object*              Get(const char* objectName) const;
 
         /// facetizes a single object's tree and returns it as a non-manifold geometry
         /** Do not forget to BRLCAD::Object::Destroy() the non-manifold geometry when you are finished with it! */
-        NonManifoldGeometry* Facetize(const char* objectName) const throw(bad_alloc, std::bad_alloc);
+        NonManifoldGeometry* Facetize(const char* objectName) const;
         //@}
 
         /// @name Active set functions
@@ -132,41 +132,41 @@
         /// add the database object \a objectName to the active set
         /** The function accepts a space separated list of object names too,
             but it is not sure that this behaviour will be kept in future versions. */
-        void                 Select(const char* objectName) throw();
+        void                 Select(const char* objectName);
         /// clear the active set
-        void                 UnSelectAll(void) throw();
+        void                 UnSelectAll(void);
 
-        bool                 SelectionIsEmpty(void) const throw();
-        Vector3D             BoundingBoxMinima(void) const throw();
-        Vector3D             BoundingBoxMaxima(void) const throw();
+        bool                 SelectionIsEmpty(void) const;
+        Vector3D             BoundingBoxMinima(void) const;
+        Vector3D             BoundingBoxMaxima(void) const;
 
         /// ray trace
         class Hit {
         public:
-            virtual ~Hit(void) throw() {}
+            virtual ~Hit(void) {}
 
-            virtual const char* Name(void) const throw()                = 0;
-            virtual double      DistanceIn(void) const throw()          = 0;
-            virtual double      DistanceOut(void) const throw()         = 0;
-            virtual Vector3D    PointIn(void) const throw()             = 0;
-            virtual Vector3D    PointOut(void) const throw()            = 0;
-            virtual Vector3D    SurfaceNormalIn(void) const throw()     = 0;
-            virtual Vector3D    SurfaceNormalOut(void) const throw()    = 0;
-            virtual Curvature3D SurfaceCurvatureIn(void) const throw()  = 0;
-            virtual Curvature3D SurfaceCurvatureOut(void) const throw() = 0;
-            virtual Mapping2D   Surface2DMappingIn(void) const throw()  = 0;
-            virtual Mapping2D   Surface2DMappingOut(void) const throw() = 0;
+            virtual const char* Name(void) const                  = 0;
+            virtual double      DistanceIn(void) const            = 0;
+            virtual double      DistanceOut(void) const           = 0;
+            virtual Vector3D    PointIn(void) const               = 0;
+            virtual Vector3D    PointOut(void) const              = 0;
+            virtual Vector3D    SurfaceNormalIn(void) const       = 0;
+            virtual Vector3D    SurfaceNormalOut(void) const      = 0;
+            virtual Curvature3D SurfaceCurvatureIn(void) const    = 0;
+            virtual Curvature3D SurfaceCurvatureOut(void) const   = 0;
+            virtual Mapping2D   Surface2DMappingIn(void) const    = 0;
+            virtual Mapping2D   Surface2DMappingOut(void) const   = 0;
 
             /// some extracted data (originally from the region)
-            virtual bool        HasColor(void) const throw()            = 0;
-            virtual double      Red(void) const throw()                 = 0;
-            virtual double      Green(void) const throw()               = 0;
-            virtual double      Blue(void) const throw()                = 0;
+            virtual bool        HasColor(void) const              = 0;
+            virtual double      Red(void) const                   = 0;
+            virtual double      Green(void) const                 = 0;
+            virtual double      Blue(void) const                  = 0;
 
         protected:
-            Hit(void) throw() {}
-            Hit(const Hit&) throw() {}
-            const Hit& operator=(const Hit&) throw() {return *this;}
+            Hit(void) {}
+            Hit(const Hit&) {}
+            const Hit& operator=(const Hit&) {return *this;}
         };
 
 
@@ -180,12 +180,12 @@
             /** Do not throw en exception here.
                 This method will be called from deep inside the brlcad libraries.
                 The status of the program after an exception will be undetermined. */
-            virtual bool operator()(const Hit& hit) throw() = 0;
+            virtual bool operator()(const Hit& hit)              = 0;
 
         protected:
-            HitCallback(void) throw() {}
-            HitCallback(const HitCallback&) throw() {}
-            const HitCallback& operator=(const HitCallback&) throw() {return *this;}
+            HitCallback(void) {}
+            HitCallback(const HitCallback&) {}
+            const HitCallback& operator=(const HitCallback&) {return *this;}
         };
 
 
Index: include/brlcad/Database.h
===================================================================
--- include/brlcad/Database.h	(revision 74453)
+++ include/brlcad/Database.h	(working copy)
@@ -39,20 +39,20 @@
 namespace BRLCAD {
     class BRLCAD_COREINTERFACE_EXPORT Database : public ConstDatabase {
     public:
-        virtual ~Database(void) throw();
+        virtual ~Database(void);
 
         /// loads a BRL-CAD database file (*.g)
         /** The implementation will be determed by the subclasses. */
-        virtual bool Load(const char* fileName) throw() = 0;
+        virtual bool Load(const char* fileName) = 0;
 
-        void         SetTitle(const char* title) throw(bad_alloc);
+        void         SetTitle(const char* title);
 
         /// adds an object to the database
-        bool         Add(const Object& object) throw();
+        bool         Add(const Object& object);
 
         /// removes an object from the database
         /** The object but not its references are removed. */
-        void         Delete(const char* objectName) throw();
+        void         Delete(const char* objectName);
 
         /// @name Accessing objects
         //@{
@@ -60,15 +60,15 @@
 
         class ObjectCallback {
         public:
-            virtual ~ObjectCallback(void) throw() {}
+            virtual ~ObjectCallback(void) {}
 
             /// the user has to implement this object method to evaluate and modify the object
             virtual void operator()(Object& object) = 0;
 
         protected:
-            ObjectCallback(void) throw() {}
-            ObjectCallback(const ObjectCallback&) throw() {}
-            const ObjectCallback& operator=(const ObjectCallback&) throw() {return *this;}
+            ObjectCallback(void) {}
+            ObjectCallback(const ObjectCallback&) {}
+            const ObjectCallback& operator=(const ObjectCallback&) {return *this;}
         };
 
         /// selects a single object and hand it over to an ObjectCallback (for read and write)
@@ -77,13 +77,13 @@
 
         /// provided for convenience: selects a single object and sets it to \a object
         /** The type of the object in the database and \a object must match. */
-        void         Set(const Object& object) throw(bad_alloc);
+        void         Set(const Object& object);
         //@}
 
     protected:
         rt_wdb* m_wdbp;
 
-        Database(void) throw(bad_alloc);
+        Database(void);
 
     private:
         Database(const Database&);                  // not implemented
Index: include/brlcad/Ellipsoid.h
===================================================================
--- include/brlcad/Ellipsoid.h	(revision 74453)
+++ include/brlcad/Ellipsoid.h	(working copy)
@@ -39,54 +39,54 @@
 namespace BRLCAD {
     class BRLCAD_COREINTERFACE_EXPORT Ellipsoid : public Object {
     public:
-        Ellipsoid(void) throw(bad_alloc);                               ///< constructs the unit circle around the origin
+        Ellipsoid(void);                                    ///< constructs the unit circle around the origin
         Ellipsoid(const Vector3D& center,
                   const Vector3D& semiPrincipalAxisA,
                   const Vector3D& semiPrincipalAxisB,
-                  const Vector3D& semiPrincipalAxisC) throw(bad_alloc); ///< center and three perpendicular semi-principal-axes
+                  const Vector3D& semiPrincipalAxisC);      ///< center and three perpendicular semi-principal-axes
         Ellipsoid(const Vector3D& center,
                   const Vector3D& semiPrincipalAxis,
-                  double          radius) throw(bad_alloc);             ///< center, one semi-principal-axis and radius (body of revolution)
+                  double          radius);                  ///< center, one semi-principal-axis and radius (body of revolution)
         Ellipsoid(const Vector3D& center,
-                  double          radius) throw(bad_alloc);             ///< sphere with center and radius
-        Ellipsoid(const Ellipsoid& original) throw(bad_alloc);
-        virtual ~Ellipsoid(void) throw();
+                  double          radius);                  ///< sphere with center and radius
+        Ellipsoid(const Ellipsoid& original);
+        virtual ~Ellipsoid(void);
 
-        const Ellipsoid&      operator=(const Ellipsoid& original) throw(bad_alloc);
+        const Ellipsoid&      operator=(const Ellipsoid& original);
 
-        Vector3D              Center(void) const throw();
-        void                  SetCenter(const Vector3D& center) throw();
+        Vector3D              Center(void) const;
+        void                  SetCenter(const Vector3D& center);
 
         /// semi principal axes are accessed by their index (0/1/2 for the vectos a/b/c)*/
-        Vector3D              SemiPrincipalAxis(size_t index) const throw();
+        Vector3D              SemiPrincipalAxis(size_t index) const;
         void                  SetSemiPrincipalAxis(size_t          index,
-                                                   const Vector3D& semiPrincipalAxis) throw();
+                                                   const Vector3D& semiPrincipalAxis);
 
         void                  Set(const Vector3D& center,
                                   const Vector3D& semiPrincipalAxisA,
                                   const Vector3D& semiPrincipalAxisB,
-                                  const Vector3D& semiPrincipalAxisC) throw();
+                                  const Vector3D& semiPrincipalAxisC);
         void                  Set(const Vector3D& center,
                                   const Vector3D& semiPrincipalAxis,
-                                  double          radius) throw();
+                                  double          radius);
         void                  SetFocals(const Vector3D& focalA,
                                         const Vector3D& focalB,
-                                        double          majorAxisLength) throw();
+                                        double          majorAxisLength);
         void                  SetSphere(const Vector3D& center,
-                                        double          radius) throw();
+                                        double          radius);
 
         // inherited from BRLCAD::Object
-        virtual const Object& operator=(const Object& original) throw(bad_alloc);
-        virtual Object*       Clone(void) const throw(bad_alloc, std::bad_alloc);
-        static const char*    ClassName(void) throw();
-        virtual const char*   Type(void) const throw();
-        virtual bool          IsValid(void) const throw(); ///< checks if semi-principal axes are perpendicular and if they have positive length
+        virtual const Object& operator=(const Object& original);
+        virtual Object*       Clone(void) const;
+        static const char*    ClassName(void);
+        virtual const char*   Type(void) const;
+        virtual bool          IsValid(void) const;          ///< checks if semi-principal axes are perpendicular and if they have positive length
 
     protected:
         Ellipsoid(resource*       resp,
                   directory*      pDir,
                   rt_db_internal* ip,
-                  db_i*           dbip) throw();
+                  db_i*           dbip);
 
         friend class ConstDatabase;
 
@@ -93,8 +93,8 @@
     private:
         rt_ell_internal* m_internalp;
 
-        rt_ell_internal*       Internal(void) throw();
-        const rt_ell_internal* Internal(void) const throw();
+        rt_ell_internal*       Internal(void);
+        const rt_ell_internal* Internal(void) const;
 
         friend class Database;
     };
Index: include/brlcad/EllipticalTorus.h
===================================================================
--- include/brlcad/EllipticalTorus.h	(revision 74453)
+++ include/brlcad/EllipticalTorus.h	(working copy)
@@ -39,50 +39,50 @@
 namespace BRLCAD {
     class BRLCAD_COREINTERFACE_EXPORT EllipticalTorus : public Object {
     public:
-        EllipticalTorus(void) throw(bad_alloc);                                    ///< constructs a torus at origin with circular tube of unit radius, radius from center to tube-center of 2 and unit normal pointing in positive z direction
+        EllipticalTorus(void);                                        ///< constructs a torus at origin with circular tube of unit radius, radius from center to tube-center of 2 and unit normal pointing in positive z direction
         EllipticalTorus(const Vector3D& center,
                         const Vector3D& normalToTubeCenterLinePlane,
                         double          tubeCenterLineRadius,
                         const Vector3D& tubeSemiMajorAxis,
-                        double          tubeSemiMinorAxisLength) throw(bad_alloc); ///< center, normal of unit length (will be unitized of not of unit length), radius of revolution, semi-major axis of ellipse, length semi-minor axis of ellipse
-        EllipticalTorus(const EllipticalTorus& original) throw(bad_alloc);
-        virtual ~EllipticalTorus(void) throw();
+                        double          tubeSemiMinorAxisLength);     ///< center, normal of unit length (will be unitized of not of unit length), radius of revolution, semi-major axis of ellipse, length semi-minor axis of ellipse
+        EllipticalTorus(const EllipticalTorus& original);
+        virtual ~EllipticalTorus(void);
 
-        const EllipticalTorus& operator=(const EllipticalTorus& original) throw(bad_alloc);
+        const EllipticalTorus& operator=(const EllipticalTorus& original);
 
-        Vector3D               Center(void) const throw();
-        void                   SetCenter(const Vector3D& center) throw();
+        Vector3D               Center(void) const;
+        void                   SetCenter(const Vector3D& center);
 
-        Vector3D               Normal(void) const throw();
-        void                   SetNormal(const Vector3D& normal) throw();
+        Vector3D               Normal(void) const;
+        void                   SetNormal(const Vector3D& normal);
 
-        double                 TubeCenterLineRadius(void) const throw();
-        void                   SetTubeCenterLineRadius(double radius) throw();
+        double                 TubeCenterLineRadius(void) const;
+        void                   SetTubeCenterLineRadius(double radius);
 
-        Vector3D               TubeSemiMajorAxis(void) const throw();
-        void                   SetTubeSemiMajorAxis(const Vector3D& axis) throw();
+        Vector3D               TubeSemiMajorAxis(void) const;
+        void                   SetTubeSemiMajorAxis(const Vector3D& axis);
 
-        double                 TubeSemiMinorAxis(void) const throw();
-        void                   SetTubeSemiMinorAxis(double length) throw();
+        double                 TubeSemiMinorAxis(void) const;
+        void                   SetTubeSemiMinorAxis(double length);
 
         void                   Set(const Vector3D& center,
                                    const Vector3D& normalToTubeCenterLinePlane,
                                    double          tubeCenterLineRadius,
                                    const Vector3D& tubeSemiMajorAxis,
-                                   double          tubeSemiMinorAxisLength) throw();
+                                   double          tubeSemiMinorAxisLength);
 
         // inherited from BRLCAD::Object
-        virtual const Object&  operator=(const Object& original) throw(bad_alloc);
-        virtual Object*        Clone(void) const throw(bad_alloc, std::bad_alloc);
-        static const char*     ClassName(void) throw();
-        virtual const char*    Type(void) const throw();
-        virtual bool           IsValid(void) const throw(); ///< checks if normal has positive length, if radii are not 0 and if ellipse not overlap itself when revolved
+        virtual const Object&  operator=(const Object& original);
+        virtual Object*        Clone(void) const;
+        static const char*     ClassName(void);
+        virtual const char*    Type(void) const;
+        virtual bool           IsValid(void) const;                   ///< checks if normal has positive length, if radii are not 0 and if ellipse not overlap itself when revolved
 
     protected:
         EllipticalTorus(resource*       resp,
                         directory*      pDir,
                         rt_db_internal* ip,
-                        db_i*           dbip) throw();
+                        db_i*           dbip);
 
         friend class ConstDatabase;
 
@@ -89,8 +89,8 @@
     private:
         rt_eto_internal* m_internalp;
 
-        const rt_eto_internal* Internal(void) const throw();
-        rt_eto_internal*       Internal(void) throw();
+        const rt_eto_internal* Internal(void) const;
+        rt_eto_internal*       Internal(void);
 
         friend class Database;
     };
Index: include/brlcad/FileDatabase.h
===================================================================
--- include/brlcad/FileDatabase.h	(revision 74453)
+++ include/brlcad/FileDatabase.h	(working copy)
@@ -38,13 +38,13 @@
     public:
         /// creates a dysfunctional database
         /** Use Load() to enable this object. */
-        FileDatabase(void) throw(bad_alloc);
-        virtual ~FileDatabase(void) throw();
+        FileDatabase(void);
+        virtual ~FileDatabase(void);
 
         /// loads a BRL-CAD database file (*.g)
         /** If the file doesn't exist it will becreated
          *  All changes to the database will be immediately written to this file. */
-        virtual bool Load(const char* fileName) throw();
+        virtual bool Load(const char* fileName);
 
     private:
         FileDatabase(const FileDatabase&);                  // not implemented
Index: include/brlcad/Object.h
===================================================================
--- include/brlcad/Object.h	(revision 74453)
+++ include/brlcad/Object.h	(working copy)
@@ -45,37 +45,37 @@
 namespace BRLCAD {
     class BRLCAD_COREINTERFACE_EXPORT Object {
     public:
-        virtual ~Object(void) throw();
+        virtual ~Object(void);
 
         // works if both Objects are of the same derived class
-        virtual const Object& operator=(const Object& original) throw(bad_alloc) = 0;
+        virtual const Object& operator=(const Object& original)          = 0;
 
         // a virtual constructor which creates the right derived class
         // and the corresponding destructor
         // which keeps the memory management in a healthy state
-        virtual Object*       Clone(void) const throw(bad_alloc, std::bad_alloc) = 0;
-        void                  Destroy(void) throw();
+        virtual Object*       Clone(void) const                          = 0;
+        void                  Destroy(void);
 
         // these two functions can be used to determine the type of the object
-        static const char*    ClassName(void) throw();
-        virtual const char*   Type(void) const throw()                           = 0;
+        static const char*    ClassName(void);
+        virtual const char*   Type(void) const                           = 0;
 
         // Is this object functional?
-        virtual bool          IsValid(void) const throw()                        = 0;
+        virtual bool          IsValid(void) const                        = 0;
 
         // for all objects
-        const char*           Name(void) const throw();
-        void                  SetName(const char* name) throw(bad_alloc);
+        const char*           Name(void) const;
+        void                  SetName(const char* name);
 
 
         class BRLCAD_COREINTERFACE_EXPORT AttributeIterator {
         public:
-            AttributeIterator(const AttributeIterator& original) throw() : m_avs(original.m_avs),
-                                                                           m_searchKey(original.m_searchKey),
-                                                                           m_index(original.m_index) {}
-            ~AttributeIterator(void) throw() {}
+            AttributeIterator(const AttributeIterator& original): m_avs(original.m_avs),
+                                                                  m_searchKey(original.m_searchKey),
+                                                                  m_index(original.m_index) {}
+            ~AttributeIterator(void){}
 
-            const AttributeIterator& operator=(const AttributeIterator& original) throw() {
+            const AttributeIterator& operator=(const AttributeIterator& original){
                 m_avs       = original.m_avs;
                 m_searchKey = original.m_searchKey;
                 m_index     = original.m_index;
@@ -82,10 +82,10 @@
                 return *this;
             }
 
-            const AttributeIterator& operator++(void) throw();
-            bool                     Good(void) const throw();
-            const char*              Key(void) const throw();
-            const char*              Value(void) const throw();
+            const AttributeIterator& operator++(void);
+            bool                     Good(void) const;
+            const char*              Key(void) const;
+            const char*              Value(void) const;
 
         private:
             const bu_attribute_value_set* m_avs;
@@ -94,7 +94,7 @@
 
             AttributeIterator(const bu_attribute_value_set* avs,
                               const char*                   searchKey,
-                              size_t                        index) throw();
+                              size_t                        index);
 
             friend class Object;
 
@@ -102,16 +102,16 @@
         };
 
 
-        bool                  HasAttribute(const char* key) const throw();
-        AttributeIterator     FirstAttribute(void) const throw();                    ///> returns an iterator pointing on the first attribute
-        const char*           Attribute(const char* key) const throw();              ///> returns the value of the first attribute with this key
-        AttributeIterator     MultiAttribute(const char* key) const throw();         ///> returns an iterator pointing on the first attribute with this key
+        bool                  HasAttribute(const char* key) const;
+        AttributeIterator     FirstAttribute(void) const;                    ///> returns an iterator pointing on the first attribute
+        const char*           Attribute(const char* key) const;              ///> returns the value of the first attribute with this key
+        AttributeIterator     MultiAttribute(const char* key) const;         ///> returns an iterator pointing on the first attribute with this key
         void                  SetAttribute(const char* key,
-                                           const char* value) throw(bad_alloc);      ///> overwrites the attribute entry with this key or creates a new one if there is none
+                                           const char* value);               ///> overwrites the attribute entry with this key or creates a new one if there is none
         void                  AddMultiAttribute(const char* key,
-                                                const char* value) throw(bad_alloc); ///> creates an attribute entry with this values even if there exitsts already one with this key
-        void                  RemoveAttribute(const char* key) throw();              ///> removes the first attribute with this key
-        void                  ClearAttributes(void) throw();                         ///> removes all attributes
+                                                const char* value);          ///> creates an attribute entry with this values even if there exitsts already one with this key
+        void                  RemoveAttribute(const char* key);              ///> removes the first attribute with this key
+        void                  ClearAttributes(void);                         ///> removes all attributes
 
 
     protected:
@@ -120,15 +120,15 @@
         rt_db_internal* m_ip;
         db_i*           m_dbip;
 
-        Object(void) throw(bad_alloc);
+        Object(void);
         Object(resource*       resp,
                directory*      pDir,
                rt_db_internal* ip,
-               db_i*           dbip) throw();
-        Object(const Object& original) throw(bad_alloc);
+               db_i*           dbip);
+        Object(const Object& original);
 
-        void Copy(const Object& original) throw(bad_alloc);
-        bool Validate(void) const throw();
+        void Copy(const Object& original);
+        bool Validate(void) const;
 
     private:
         // holds Objects's name if not connected to a database
@@ -135,8 +135,8 @@
         char*                   m_name;
         bu_attribute_value_set* m_avs;
 
-        const bu_attribute_value_set* GetAvs(void) const throw();
-        bu_attribute_value_set*       GetAvs(bool create) throw();
+        const bu_attribute_value_set* GetAvs(void) const;
+        bu_attribute_value_set*       GetAvs(bool create);
 
         friend class Database;
     };
Index: include/brlcad/cicommon.h
===================================================================
--- include/brlcad/cicommon.h	(revision 74453)
+++ include/brlcad/cicommon.h	(working copy)
@@ -49,18 +49,18 @@
     struct Vector2D {
         double coordinates[2];
 
-        Vector2D(void) throw() {
+        Vector2D(void){
             coordinates[0] = 0.;
             coordinates[1] = 0.;
         }
 
-        Vector2D(const double vector[2]) throw() {
+        Vector2D(const double vector[2]){
             coordinates[0] = vector[0];
             coordinates[1] = vector[1];
         }
 
         Vector2D(double x,
-                 double y) throw() {
+                 double y){
             coordinates[0] = x;
             coordinates[1] = y;
         }
@@ -72,7 +72,7 @@
         Vector2D delta;
 
         Mapping2D(const Vector2D& pt,
-                  const Vector2D& dl) throw() : point(pt), delta(dl) {}
+                  const Vector2D& dl): point(pt), delta(dl) {}
     };
 
 
@@ -79,13 +79,13 @@
     struct Vector3D {
         double coordinates[3];
 
-        Vector3D(void) throw() {
+        Vector3D(void){
             coordinates[0] = 0.;
             coordinates[1] = 0.;
             coordinates[2] = 0.;
         }
 
-        Vector3D(const double vector[3]) throw() {
+        Vector3D(const double vector[3]){
             coordinates[0] = vector[0];
             coordinates[1] = vector[1];
             coordinates[2] = vector[2];
@@ -93,7 +93,7 @@
 
         Vector3D(double x,
                  double y,
-                 double z) throw() {
+                 double z){
             coordinates[0] = x;
             coordinates[1] = y;
             coordinates[2] = z;
@@ -114,13 +114,13 @@
 
         Curvature3D(const Vector3D& minDirection,
                     double          minCurvature,
-                    double          maxCurvature) throw() {
+                    double          maxCurvature){
             minPrincipalDirection = minDirection;
             minPrincipalCurvature = minCurvature;
             maxPrincipalCurvature = maxCurvature;
         }
 
-        Curvature3D(void) throw() : minPrincipalDirection(),
+        Curvature3D(void): minPrincipalDirection(),
                                     minPrincipalCurvature(0.),
                                     maxPrincipalCurvature(0.) {}
     };
@@ -128,11 +128,11 @@
 
     class bad_alloc : public std::bad_alloc {
     public:
-        bad_alloc(const char* hint) throw() : std::bad_alloc(), m_hint(hint) {}
+        bad_alloc(const char* hint): std::bad_alloc(), m_hint(hint) {}
 
-        bad_alloc(const bad_alloc& original) throw() : std::bad_alloc(original), m_hint(original.m_hint) {}
+        bad_alloc(const bad_alloc& original): std::bad_alloc(original), m_hint(original.m_hint) {}
 
-        virtual const bad_alloc& operator=(const bad_alloc& original) throw() {
+        virtual const bad_alloc& operator=(const bad_alloc& original){
             std::bad_alloc::operator=(original);
             m_hint = original.m_hint;
 
@@ -139,7 +139,7 @@
             return *this;
         }
 
-        virtual const char* what(void) const throw() {
+        virtual const char* what(void) const throw(){
             return m_hint;
         }
 
Index: src/coreInterface/Arb8.cpp
===================================================================
--- src/coreInterface/Arb8.cpp	(revision 74453)
+++ src/coreInterface/Arb8.cpp	(working copy)
@@ -49,7 +49,7 @@
 using namespace BRLCAD;
 
 
-Arb8::Arb8(void) throw(bad_alloc) : Object() {
+Arb8::Arb8(void): Object() {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_arb_internal);
         m_internalp->magic = RT_ARB_INTERNAL_MAGIC;
@@ -56,10 +56,8 @@
 
         SetPoints(Vector3D(0., 0., 0.), Vector3D(1., 1., 1.));
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Arb8::Arb8");
-    }
 
     BU_UNSETJUMP;
 }
@@ -71,7 +69,7 @@
     const Vector3D& point2,
     const Vector3D& point3,
     const Vector3D& point4
-) throw(bad_alloc) : Object() {
+): Object() {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_arb_internal);
         m_internalp->magic = RT_ARB_INTERNAL_MAGIC;
@@ -78,10 +76,8 @@
 
         SetPoints(point1, point2, point3, point4);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Arb8::Arb8");
-    }
 
     BU_UNSETJUMP;
 }
@@ -94,7 +90,7 @@
     const Vector3D& point3,
     const Vector3D& point4,
     const Vector3D& point5
-) throw(bad_alloc) : Object() {
+): Object() {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_arb_internal);
         m_internalp->magic = RT_ARB_INTERNAL_MAGIC;
@@ -101,10 +97,8 @@
 
         SetPoints(point1, point2, point3, point4, point5);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Arb8::Arb8");
-    }
 
     BU_UNSETJUMP;
 }
@@ -118,7 +112,7 @@
     const Vector3D& point4,
     const Vector3D& point5,
     const Vector3D& point6
-) throw(bad_alloc) : Object() {
+): Object() {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_arb_internal);
         m_internalp->magic = RT_ARB_INTERNAL_MAGIC;
@@ -125,10 +119,8 @@
 
         SetPoints(point1, point2, point3, point4, point5, point6);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Arb8::Arb8");
-    }
 
     BU_UNSETJUMP;
 }
@@ -143,7 +135,7 @@
     const Vector3D& point5,
     const Vector3D& point6,
     const Vector3D& point7
-) throw(bad_alloc) : Object() {
+): Object() {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_arb_internal);
         m_internalp->magic = RT_ARB_INTERNAL_MAGIC;
@@ -150,10 +142,8 @@
 
         SetPoints(point1, point2, point3, point4, point5, point6, point7);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Arb8::Arb8");
-    }
 
     BU_UNSETJUMP;
 }
@@ -169,7 +159,7 @@
     const Vector3D& point6,
     const Vector3D& point7,
     const Vector3D& point8
-) throw(bad_alloc) : Object() {
+): Object() {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_arb_internal);
         m_internalp->magic = RT_ARB_INTERNAL_MAGIC;
@@ -176,10 +166,8 @@
 
         SetPoints(point1, point2, point3, point4, point5, point6, point7, point8);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Arb8::Arb8");
-    }
 
     BU_UNSETJUMP;
 }
@@ -189,7 +177,7 @@
 (
     const Vector3D& point1,
     const Vector3D& point2
-) throw(bad_alloc) : Object() {
+): Object() {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_arb_internal);
         m_internalp->magic = RT_ARB_INTERNAL_MAGIC;
@@ -196,10 +184,8 @@
 
         SetPoints(point1, point2);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Arb8::Arb8");
-    }
 
     BU_UNSETJUMP;
 }
@@ -208,21 +194,19 @@
 Arb8::Arb8
 (
     const Arb8& original
-) throw(bad_alloc) : Object(original) {
+): Object(original) {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_arb_internal);
         memcpy(m_internalp, original.Internal(), sizeof(rt_arb_internal));
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Arb8::Arb8");
-    }
 
     BU_UNSETJUMP;
 }
 
 
-Arb8::~Arb8(void) throw() {
+Arb8::~Arb8(void){
     if (m_internalp != 0)
         bu_free(m_internalp, "BRLCAD::Arb8::~Arb8::m_internalp");
 }
@@ -231,7 +215,7 @@
 const Arb8& Arb8::operator=
 (
     const Arb8& original
-) throw(bad_alloc) {
+){
     if (&original != this) {
         Copy(original);
         memcpy(Internal()->pt, original.Internal()->pt, 8 * sizeof(point_t));
@@ -241,7 +225,7 @@
 }
 
 
-size_t Arb8::NumberOfVertices(void) const throw() {
+size_t Arb8::NumberOfVertices(void) const{
     size_t ret = 0;
 
     rt_db_internal intern;
@@ -296,7 +280,7 @@
 Vector3D Arb8::Point
 (
     size_t number
-) const throw() {
+) const{
     Vector3D ret;
 
     assert((number > 0) && (number < 9));
@@ -319,7 +303,7 @@
 (
     size_t    number,
     Vector3D& point
-) throw() {
+){
     assert((number > 0) && (number < 9));
 
     if ((number > 0) && (number < 9)) {
@@ -357,7 +341,7 @@
 Vector3D Arb8::RawPoint
 (
     size_t index
-) const throw() {
+) const{
     Vector3D ret;
 
     assert(index < 8);
@@ -374,7 +358,7 @@
 (
     size_t    index,
     Vector3D& point
-) throw() {
+){
     assert(index < 8);
 
     if (index < 8) {
@@ -389,7 +373,7 @@
     const Vector3D& point2,
     const Vector3D& point3,
     const Vector3D& point4
-) throw() {
+){
     rt_arb_internal* internalp = Internal();
 
     VMOVE(internalp->pt[0], point1.coordinates);
@@ -410,7 +394,7 @@
     const Vector3D& point3,
     const Vector3D& point4,
     const Vector3D& point5
-) throw() {
+){
     rt_arb_internal* internalp = Internal();
 
     VMOVE(internalp->pt[0], point1.coordinates);
@@ -432,7 +416,7 @@
     const Vector3D& point4,
     const Vector3D& point5,
     const Vector3D& point6
-) throw() {
+){
     rt_arb_internal* internalp = Internal();
 
     VMOVE(internalp->pt[0], point1.coordinates);
@@ -455,7 +439,7 @@
     const Vector3D& point5,
     const Vector3D& point6,
     const Vector3D& point7
-) throw() {
+){
     rt_arb_internal* internalp = Internal();
 
     VMOVE(internalp->pt[0], point1.coordinates);
@@ -479,7 +463,7 @@
     const Vector3D& point6,
     const Vector3D& point7,
     const Vector3D& point8
-) throw() {
+){
     rt_arb_internal* internalp = Internal();
 
     VMOVE(internalp->pt[0], point1.coordinates);
@@ -497,7 +481,7 @@
 (
     const Vector3D& point1,
     const Vector3D& point2
-) throw() {
+){
     double           minX      = std::min(point1.coordinates[0], point2.coordinates[0]);
     double           minY      = std::min(point1.coordinates[1], point2.coordinates[1]);
     double           minZ      = std::min(point1.coordinates[2], point2.coordinates[2]);
@@ -520,7 +504,7 @@
 const Object& Arb8::operator=
 (
     const Object& original
-) throw(bad_alloc) {
+){
     const Arb8* arb8 = dynamic_cast<const Arb8*>(&original);
     assert(arb8 != 0);
 
@@ -531,22 +515,22 @@
 }
 
 
-Object* Arb8::Clone(void) const throw(bad_alloc, std::bad_alloc) {
+Object* Arb8::Clone(void) const{
     return new Arb8(*this);
 }
 
 
-const char* Arb8::ClassName(void) throw() {
+const char* Arb8::ClassName(void){
     return "Arb8";
 }
 
 
-const char* Arb8::Type(void) const throw() {
+const char* Arb8::Type(void) const{
     return ClassName();
 }
 
 
-bool Arb8::IsValid(void) const throw() {
+bool Arb8::IsValid(void) const{
     enum FaceType {FT_4Sided, FT_Triangle, FT_Degenerated};
 
     bool                   ret                = Validate();
@@ -658,10 +642,10 @@
     directory*      pDir,
     rt_db_internal* ip,
     db_i*           dbip
-) throw() : Object(resp, pDir, ip, dbip), m_internalp(0) {}
+): Object(resp, pDir, ip, dbip), m_internalp(0) {}
 
 
-const rt_arb_internal* Arb8::Internal(void) const throw() {
+const rt_arb_internal* Arb8::Internal(void) const{
     const rt_arb_internal* ret;
 
     if (m_ip != 0)
@@ -675,7 +659,7 @@
 }
 
 
-rt_arb_internal* Arb8::Internal(void) throw() {
+rt_arb_internal* Arb8::Internal(void){
     rt_arb_internal* ret;
 
     if (m_ip != 0)
Index: src/coreInterface/BagOfTriangles.cpp
===================================================================
--- src/coreInterface/BagOfTriangles.cpp	(revision 74453)
+++ src/coreInterface/BagOfTriangles.cpp	(working copy)
@@ -461,17 +461,13 @@
 
 
 BagOfTriangles::BagOfTriangles
-(
-    void
-) throw(bad_alloc) : Object() {
+(void): Object() {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_bot_internal);
         m_internalp->magic = RT_BOT_INTERNAL_MAGIC;
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::BagOfTriangles::BagOfTriangles()");
-    }
 
     BU_UNSETJUMP;
 }
@@ -480,13 +476,11 @@
 BagOfTriangles::BagOfTriangles
 (
     const BagOfTriangles& original
-) throw(bad_alloc) {
+){
     if (!BU_SETJUMP)
         m_internalp = CloneBotInternal(*original.Internal());
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::BagOfTriangles::BagOfTriangles()");
-    }
 
     BU_UNSETJUMP;
 }
@@ -495,7 +489,7 @@
 BagOfTriangles::~BagOfTriangles
 (
     void
-) throw() {
+){
     if (m_internalp != 0)
         FreeBotInternal(m_internalp);
 }
@@ -504,7 +498,7 @@
 const BagOfTriangles& BagOfTriangles::operator=
 (
     const BagOfTriangles& original
-) throw(bad_alloc) {
+){
     if (&original != this) {
         Copy(original);
 
@@ -514,10 +508,8 @@
 
             thisInternal = CloneBotInternal(*originalInternal);
         }
-        else {
+        else
             BU_UNSETJUMP;
-            throw bad_alloc("BRLAD::BagOfTriangles::operator=()");
-        }
 
         BU_UNSETJUMP;
     }
@@ -529,7 +521,7 @@
 Vector3D BagOfTriangles::Face::Point
 (
     size_t index
-) const throw() {
+) const{
     assert(index < 3);
     assert(m_bot != 0);
 
@@ -549,7 +541,7 @@
 (
     size_t          index,
     const Vector3D& point
-) throw(bad_alloc) {
+){
     assert(index < 3);
     assert(m_bot != 0);
 
@@ -566,7 +558,7 @@
     const Vector3D& point1,
     const Vector3D& point2,
     const Vector3D& point3
-) throw(bad_alloc) {
+){
     assert(m_bot != 0);
 
     if (m_bot != 0) {
@@ -577,7 +569,7 @@
 }
 
 
-double BagOfTriangles::Face::Thickness(void) const throw() {
+double BagOfTriangles::Face::Thickness(void) const{
     assert(m_bot != 0);
     assert(m_bot->thickness != 0);
     assert(m_bot->mode != RT_BOT_SOLID);
@@ -595,7 +587,7 @@
 void BagOfTriangles::Face::SetThickness
 (
     double value
-) throw() {
+){
     assert(m_bot != 0);
     assert(m_bot->thickness != 0);
     assert(m_bot->mode != RT_BOT_SOLID);
@@ -610,7 +602,7 @@
 }
 
 
-bool BagOfTriangles::Face::ApendThickness(void) const throw() {
+bool BagOfTriangles::Face::ApendThickness(void) const{
     assert(m_bot != 0);
 
     bool ret = false;
@@ -625,7 +617,7 @@
 void BagOfTriangles::Face::SetApendThickness
 (
     bool apendThickness
-) throw() {
+){
     assert(m_bot != 0);
 
     if (m_bot != 0) {
@@ -643,7 +635,7 @@
 Vector3D BagOfTriangles::Face::Normal
 (
     size_t index
-) const throw() {
+) const{
     assert(m_bot != 0);
 
     Vector3D ret;
@@ -664,7 +656,7 @@
 (
     size_t          index,
     const Vector3D& normal
-) throw() {
+){
     assert(index < 3);
     assert(m_bot != 0);
 
@@ -683,7 +675,7 @@
     const Vector3D& normal1,
     const Vector3D& normal2,
     const Vector3D& normal3
-) throw(bad_alloc) {
+){
     assert(m_bot != 0);
 
     if (m_bot != 0) {
@@ -694,7 +686,7 @@
 }
 
 
-BagOfTriangles::BotMode BagOfTriangles::Mode(void) const throw() {
+BagOfTriangles::BotMode BagOfTriangles::Mode(void) const{
     BagOfTriangles::BotMode ret;
 
     switch (Internal()->mode) {
@@ -721,7 +713,7 @@
 void BagOfTriangles::SetMode
 (
     BotMode mode
-) throw(bad_alloc) {
+){
     switch (mode) {
         case Surface:
             Internal()->mode = RT_BOT_SURFACE;
@@ -741,7 +733,7 @@
 }
 
 
-BagOfTriangles::BotOrientation BagOfTriangles::Orientation(void) const throw() {
+BagOfTriangles::BotOrientation BagOfTriangles::Orientation(void) const{
     BagOfTriangles::BotOrientation ret = BagOfTriangles::Unoriented;
 
     switch (Internal()->orientation) {
@@ -760,7 +752,7 @@
 void BagOfTriangles::SetOrientation
 (
     BotOrientation orientation
-) throw() {
+){
     switch (orientation) {
         case Unoriented:
             Internal()->orientation = RT_BOT_UNORIENTED;
@@ -776,7 +768,7 @@
 }
 
 
-bool BagOfTriangles::FacesHaveNormals(void) const throw() {
+bool BagOfTriangles::FacesHaveNormals(void) const{
     return Internal()->bot_flags & RT_BOT_HAS_SURFACE_NORMALS;
 }
 
@@ -784,7 +776,7 @@
 void BagOfTriangles::SetFacesHaveNormals
 (
     bool facesHaveNormals
-) throw(bad_alloc) {
+){
     if (facesHaveNormals)
         Internal()->bot_flags |= RT_BOT_HAS_SURFACE_NORMALS;
     else
@@ -792,7 +784,7 @@
 }
 
 
-bool BagOfTriangles::UseFaceNormals(void) const throw() {
+bool BagOfTriangles::UseFaceNormals(void) const{
     return (Internal()->bot_flags & RT_BOT_USE_NORMALS) != 0;
 }
 
@@ -800,7 +792,7 @@
 void BagOfTriangles::SetUseFaceNormals
 (
     bool useFaceNormals
-) throw() {
+){
     if (useFaceNormals)
         Internal()->bot_flags |= RT_BOT_USE_NORMALS;
     else
@@ -808,7 +800,7 @@
 }
 
 
-bool BagOfTriangles::UseFloats(void) const throw() {
+bool BagOfTriangles::UseFloats(void) const{
     return (Internal()->bot_flags & RT_BOT_USE_FLOATS) != 0;
 }
 
@@ -816,7 +808,7 @@
 void BagOfTriangles::SetUseFloats
 (
     bool useFloats
-) throw() {
+){
     if (useFloats)
         Internal()->bot_flags |= RT_BOT_USE_FLOATS;
     else
@@ -824,7 +816,7 @@
 }
 
 
-size_t BagOfTriangles::NumberOfFaces(void) const throw() {
+size_t BagOfTriangles::NumberOfFaces(void) const{
     return Internal()->num_faces;
 }
 
@@ -832,7 +824,7 @@
 BagOfTriangles::Face BagOfTriangles::GetFace
 (
     size_t index
-) throw() {
+){
     assert(index < Internal()->num_faces);
 
     Face ret;
@@ -849,7 +841,7 @@
     const Vector3D& point1,
     const Vector3D& point2,
     const Vector3D& point3
-) throw(bad_alloc) {
+){
     BagOfTriangles::Face ret;
 
     if (!BU_SETJUMP) {
@@ -899,10 +891,8 @@
 
         ret = Face(bot, bot->num_faces - 1);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::BagOfTriangles::InsertFace");
-    }
 
     BU_UNSETJUMP;
 
@@ -912,7 +902,7 @@
 
 void BagOfTriangles::DeleteFace(
     size_t index
-) throw(bad_alloc) {
+){
     assert(index < Internal()->num_faces);
 
     if (!BU_SETJUMP) {
@@ -927,7 +917,7 @@
 const Object& BagOfTriangles::operator=
 (
     const Object& original
-) throw(bad_alloc) {
+){
     const BagOfTriangles* bot = dynamic_cast<const BagOfTriangles*>(&original);
     assert(bot != 0);
 
@@ -938,22 +928,22 @@
 }
 
 
-Object* BagOfTriangles::Clone(void) const throw(bad_alloc, std::bad_alloc) {
+Object* BagOfTriangles::Clone(void) const{
     return new BagOfTriangles(*this);
 }
 
 
-const char* BagOfTriangles::ClassName(void) throw() {
+const char* BagOfTriangles::ClassName(void){
     return "BagOfTriangles";
 }
 
 
-const char* BagOfTriangles::Type(void) const throw() {
+const char* BagOfTriangles::Type(void) const{
     return ClassName();
 }
 
 
-bool BagOfTriangles::IsValid(void) const throw() {
+bool BagOfTriangles::IsValid(void) const{
     return true;
 }
 
@@ -964,11 +954,11 @@
     directory*      pDir,
     rt_db_internal* ip,
     db_i*           dbip
-) throw() : Object(resp, pDir, ip, dbip), m_internalp(0) {}
+): Object(resp, pDir, ip, dbip), m_internalp(0) {}
 
 
 
-rt_bot_internal* BagOfTriangles::Internal(void) throw() {
+rt_bot_internal* BagOfTriangles::Internal(void){
     rt_bot_internal* ret;
 
     if (m_ip != 0)
@@ -982,7 +972,7 @@
 }
 
 
-const rt_bot_internal* BagOfTriangles::Internal(void) const throw() {
+const rt_bot_internal* BagOfTriangles::Internal(void) const{
     const rt_bot_internal* ret;
 
     if (m_ip != 0)
Index: src/coreInterface/Combination.cpp
===================================================================
--- src/coreInterface/Combination.cpp	(revision 74453)
+++ src/coreInterface/Combination.cpp	(working copy)
@@ -42,7 +42,7 @@
 static Combination::ConstTreeNode::Operator ConvertOperator
 (
     tree* brlcadTree
-) throw() {
+){
     Combination::ConstTreeNode::Operator ret = Combination::ConstTreeNode::Null;
 
     if (brlcadTree != 0) {
@@ -83,7 +83,7 @@
 static int ConvertOperatorBack
 (
     Combination::ConstTreeNode::Operator op
-) throw() {
+){
     int ret = 0;
 
     switch (op) {
@@ -123,7 +123,7 @@
 (
     tree* searchTree,
     tree* rootTree
-) throw() {
+){
     tree* ret = 0;
 
     switch (ConvertOperator(rootTree)) {
@@ -162,12 +162,12 @@
 // class Combination::ConstTreeNode
 //
 
-Combination::ConstTreeNode::Operator Combination::ConstTreeNode::Operation(void) const throw() {
+Combination::ConstTreeNode::Operator Combination::ConstTreeNode::Operation(void) const{
     return ConvertOperator(m_tree);
 }
 
 
-Combination::ConstTreeNode Combination::ConstTreeNode::LeftOperand(void) const throw() {
+Combination::ConstTreeNode Combination::ConstTreeNode::LeftOperand(void) const{
     ConstTreeNode ret;
 
     switch (ConvertOperator(m_tree)) {
@@ -186,7 +186,7 @@
 }
 
 
-Combination::ConstTreeNode Combination::ConstTreeNode::RightOperand(void) const throw() {
+Combination::ConstTreeNode Combination::ConstTreeNode::RightOperand(void) const{
     ConstTreeNode ret;
 
     switch (ConvertOperator(m_tree)) {
@@ -205,7 +205,7 @@
 }
 
 
-Combination::ConstTreeNode Combination::ConstTreeNode::Operand(void) const throw() {
+Combination::ConstTreeNode Combination::ConstTreeNode::Operand(void) const{
     ConstTreeNode ret;
 
     switch (ConvertOperator(m_tree)) {
@@ -221,7 +221,7 @@
 }
 
 
-const char* Combination::ConstTreeNode::Name(void) const throw() {
+const char* Combination::ConstTreeNode::Name(void) const{
     const char* ret = 0;
 
     switch (ConvertOperator(m_tree)) {
@@ -237,7 +237,7 @@
 }
 
 
-const double* Combination::ConstTreeNode::Matrix(void) const throw() {
+const double* Combination::ConstTreeNode::Matrix(void) const{
     const double* ret = 0;
 
     switch (ConvertOperator(m_tree)) {
@@ -257,7 +257,7 @@
 // class Combination::TreeNode
 //
 
-Combination::TreeNode Combination::TreeNode::LeftOperand(void) throw() {
+Combination::TreeNode Combination::TreeNode::LeftOperand(void){
     TreeNode ret;
 
     switch (ConvertOperator(m_tree)) {
@@ -278,7 +278,7 @@
 }
 
 
-Combination::TreeNode Combination::TreeNode::RightOperand(void) throw() {
+Combination::TreeNode Combination::TreeNode::RightOperand(void){
     TreeNode ret;
 
     switch (ConvertOperator(m_tree)) {
@@ -299,7 +299,7 @@
 }
 
 
-Combination::TreeNode Combination::TreeNode::Operand(void) throw() {
+Combination::TreeNode Combination::TreeNode::Operand(void){
     TreeNode ret;
 
     switch (ConvertOperator(m_tree)) {
@@ -320,7 +320,7 @@
 void Combination::TreeNode::SetName
 (
     const char* value
-) const throw(bad_alloc) {
+) const{
     switch (ConvertOperator(m_tree)) {
     case Leaf:
         if (value != 0) {
@@ -337,7 +337,6 @@
             else {
                 BU_UNSETJUMP;
                 m_tree->tr_l.tl_name = 0;
-                throw bad_alloc("BRLCAD::Combination::TreeNode::SetName");
             }
 
             BU_UNSETJUMP;
@@ -357,7 +356,7 @@
 void Combination::TreeNode::SetMatrix
 (
     double value[16]
-) const throw(bad_alloc) {
+) const{
     if (m_tree->tr_l.tl_mat == 0) {
         if (!BU_SETJUMP)
             m_tree->tr_l.tl_mat = bn_mat_dup(value);
@@ -364,7 +363,6 @@
         else {
             BU_UNSETJUMP;
             m_tree->tr_l.tl_mat = 0;
-            throw bad_alloc("BRLCAD::Combination::TreeNode::SetMatrix");
         }
 
         BU_UNSETJUMP;
@@ -377,7 +375,7 @@
 Combination::TreeNode Combination::TreeNode::Apply
 (
     Combination::ConstTreeNode::Operator op
-) throw(bad_alloc) {
+){
     assert(m_tree != 0);
 
     TreeNode ret;
@@ -390,10 +388,8 @@
             if (!BU_SETJUMP) {
                 RT_GET_TREE(newNode, m_resp);
             }
-            else {
+            else
                 BU_UNSETJUMP;
-                throw bad_alloc("BRLCAD::Combination::TreeNode::Apply");
-            }
 
             BU_UNSETJUMP;
 
@@ -424,7 +420,7 @@
 (
     Combination::ConstTreeNode::Operator op,
     const Combination::ConstTreeNode&    theOther
-) throw(bad_alloc) {
+){
     assert(m_tree != 0);
     assert(theOther.m_tree != 0);
 
@@ -441,10 +437,8 @@
             if (!BU_SETJUMP) {
                 RT_GET_TREE(newNode, m_resp);
             }
-            else {
+            else
                 BU_UNSETJUMP;
-                throw bad_alloc("BRLCAD::Combination::TreeNode::Apply");
-            }
 
             BU_UNSETJUMP;
 
@@ -460,7 +454,6 @@
             else {
                 BU_UNSETJUMP;
                 RT_FREE_TREE(newNode, m_resp);
-                throw bad_alloc("BRLCAD::Combination::TreeNode::Apply") ;
             }
 
             BU_UNSETJUMP;
@@ -485,7 +478,7 @@
 (
     Combination::ConstTreeNode::Operator op,
     const char*                          leafName
-) throw(bad_alloc) {
+){
     assert(leafName != 0);
 
     TreeNode ret;
@@ -496,10 +489,8 @@
         if (!BU_SETJUMP) {
             RT_GET_TREE(newLeaf.m_tree, newLeaf.m_resp);
         }
-        else {
+        else
             BU_UNSETJUMP;
-            throw bad_alloc("BRLCAD::Combination::TreeNode::Apply");
-        }
 
         BU_UNSETJUMP;
 
@@ -509,10 +500,8 @@
 
         if (!BU_SETJUMP)
             newLeaf.m_tree->tr_l.tl_name = bu_strdup(leafName);
-        else {
+        else
             BU_UNSETJUMP;
-            throw bad_alloc("BRLCAD::Combination::TreeNode::Apply") ;
-        }
 
         BU_UNSETJUMP;
 
@@ -530,7 +519,7 @@
 (
     const Combination::ConstTreeNode&    theOther,
     Combination::ConstTreeNode::Operator op
-) throw(bad_alloc) {
+){
     assert(m_tree != 0);
     assert(theOther.m_tree != 0);
 
@@ -547,10 +536,8 @@
             if (!BU_SETJUMP) {
                 RT_GET_TREE(newNode, m_resp);
             }
-            else {
+            else
                 BU_UNSETJUMP;
-                throw bad_alloc("BRLCAD::Combination::TreeNode::Apply");
-            }
 
             BU_UNSETJUMP;
 
@@ -565,7 +552,6 @@
             else {
                 BU_UNSETJUMP;
                 RT_FREE_TREE(newNode, m_resp);
-                throw bad_alloc("BRLCAD::Combination::TreeNode::Apply") ;
             }
 
             BU_UNSETJUMP;
@@ -592,7 +578,7 @@
 (
     const char*                          leafName,
     Combination::ConstTreeNode::Operator op
-) throw(bad_alloc) {
+){
     assert(leafName != 0);
 
     TreeNode ret;
@@ -603,10 +589,8 @@
         if (!BU_SETJUMP) {
             RT_GET_TREE(newLeaf.m_tree, newLeaf.m_resp);
         }
-        else {
+        else
             BU_UNSETJUMP;
-            throw bad_alloc("BRLCAD::Combination::TreeNode::Apply");
-        }
 
         BU_UNSETJUMP;
 
@@ -616,10 +600,8 @@
 
         if (!BU_SETJUMP)
             newLeaf.m_tree->tr_l.tl_name = bu_strdup(leafName);
-        else {
+        else
             BU_UNSETJUMP;
-            throw bad_alloc("BRLCAD::Combination::TreeNode::Apply") ;
-        }
 
         BU_UNSETJUMP;
 
@@ -633,7 +615,7 @@
 }
 
 
-void Combination::TreeNode::Delete(void) throw() {
+void Combination::TreeNode::Delete(void){
     assert(m_tree != 0);
 
     TreeNode ret;
@@ -701,13 +683,11 @@
 // class Combination
 //
 
-Combination::Combination(void) throw(bad_alloc) : Object(), m_internalp(0) {
+Combination::Combination(void): Object(), m_internalp(0) {
     if (!BU_SETJUMP)
         m_internalp = static_cast<rt_comb_internal*>(bu_calloc(1, sizeof(rt_comb_internal), "BRLCAD::Combination::Combination::m_internalp"));
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Combination::Combination");
-    }
 
     BU_UNSETJUMP;
 
@@ -721,7 +701,7 @@
 Combination::Combination
 (
     const Combination& original
-) throw(bad_alloc) : Object(original), m_internalp(0) {
+): Object(original), m_internalp(0) {
     if (&original != this) {
         Copy(original);
 
@@ -767,8 +747,6 @@
 
                 bu_free(m_internalp, "BRLCAD::Combination::Combination::m_internalp");
             }
-
-            throw bad_alloc("BRLCAD::Combination::Combination");
         }
 
         BU_UNSETJUMP;
@@ -776,7 +754,7 @@
 }
 
 
-Combination::~Combination(void) throw() {
+Combination::~Combination(void){
     if (m_internalp != 0) {
         if (m_internalp->tree != 0)
             db_free_tree(m_internalp->tree, m_resp);
@@ -792,7 +770,7 @@
 const Combination& Combination::operator=
 (
     const Combination& original
-) throw(bad_alloc) {
+){
     if (&original != this) {
         Copy(original);
 
@@ -823,10 +801,8 @@
             bu_vls_strcpy(&internalTo->material, bu_vls_addr(&internalFrom->material));
             internalTo->inherit     = internalFrom->inherit;
         }
-        else {
+        else
             BU_UNSETJUMP;
-            throw bad_alloc("BRLCAD::Combination::Combination");
-        }
 
         BU_UNSETJUMP;
     }
@@ -835,12 +811,12 @@
 }
 
 
-Combination::ConstTreeNode Combination::Tree(void) const throw() {
+Combination::ConstTreeNode Combination::Tree(void) const{
     return ConstTreeNode(Internal()->tree);
 }
 
 
-Combination::TreeNode Combination::Tree(void) throw() {
+Combination::TreeNode Combination::Tree(void){
     return TreeNode(Internal()->tree, Internal(), m_resp);
 }
 
@@ -848,7 +824,7 @@
 void Combination::AddLeaf
 (
     const char* leafName
-) throw(bad_alloc) {
+){
     rt_comb_internal* internalp = Internal();
 
     if (internalp->tree == 0) {
@@ -855,10 +831,8 @@
         if (!BU_SETJUMP) {
             RT_GET_TREE(internalp->tree, m_resp);
         }
-        else {
+        else
             BU_UNSETJUMP;
-            throw bad_alloc("BRLCAD::Combination::AddLeaf");
-        }
 
         BU_UNSETJUMP;
 
@@ -872,8 +846,6 @@
             BU_UNSETJUMP;
             RT_FREE_TREE(internalp->tree, m_resp);
             internalp->tree = 0;
-
-            throw bad_alloc("BRLCAD::Combination::AddLeaf");
         }
 
         BU_UNSETJUMP;
@@ -884,7 +856,7 @@
 }
 
 
-bool Combination::IsRegion(void) const throw() {
+bool Combination::IsRegion(void) const{
     return Internal()->region_flag != 0;
 }
 
@@ -892,12 +864,12 @@
 void Combination::SetIsRegion
 (
     bool value
-) throw() {
+){
     Internal()->region_flag = (value) ? '\1' : '\0';
 }
 
 
-Combination::FastgenType Combination::FastgenRegion(void) const throw() {
+Combination::FastgenType Combination::FastgenRegion(void) const{
     Combination::FastgenType ret = Non;
 
     switch (Internal()->is_fastgen) {
@@ -924,7 +896,7 @@
 void Combination::SetFastgenRegion
 (
     Combination::FastgenType value
-) throw() {
+){
     switch (value) {
     case Non:
         Internal()->is_fastgen = REGION_NON_FASTGEN;
@@ -944,7 +916,7 @@
 }
 
 
-int Combination::RegionId(void) const throw() {
+int Combination::RegionId(void) const{
     return Internal()->region_id;
 }
 
@@ -952,12 +924,12 @@
 void Combination:: SetRegionId
 (
     int value
-) throw() {
+){
     Internal()->region_id = value;
 }
 
 
-int Combination::Aircode(void) const throw() {
+int Combination::Aircode(void) const{
     return Internal()->aircode;
 }
 
@@ -965,12 +937,12 @@
 void Combination::SetAircode
 (
     int value
-) throw() {
+){
     Internal()->aircode = value;
 }
 
 
-int Combination::GiftMaterial(void) const throw() {
+int Combination::GiftMaterial(void) const{
     return Internal()->GIFTmater;
 }
 
@@ -978,12 +950,12 @@
 void Combination::SetGiftMaterial
 (
     int value
-) throw() {
+){
     Internal()->GIFTmater = value;
 }
 
 
-int Combination::LineOfSight(void) const throw() {
+int Combination::LineOfSight(void) const{
     return Internal()->los;
 }
 
@@ -991,12 +963,12 @@
 void Combination::SetLineOfSight
 (
     int value
-) throw() {
+){
     Internal()->los = value;
 }
 
 
-bool Combination::HasColor(void) const throw() {
+bool Combination::HasColor(void) const{
     return Internal()->rgb_valid != 0;
 }
 
@@ -1004,12 +976,12 @@
 void Combination::SetHasColor
 (
     bool value
-) throw() {
+){
     Internal()->rgb_valid = (value) ? '\1' : '\0';
 }
 
 
-double Combination::Red(void) const throw() {
+double Combination::Red(void) const{
     return Internal()->rgb[0] / 255.;
 }
 
@@ -1017,7 +989,7 @@
 void Combination::SetRed
 (
     double value
-) throw() {
+){
     value = FMIN(FMAX(value, 0.), 1.);
 
     Internal()->rgb[0] = static_cast<unsigned char>(floor(value * 255 + 0.5));
@@ -1024,7 +996,7 @@
 }
 
 
-double Combination::Green(void) const throw() {
+double Combination::Green(void) const{
     return Internal()->rgb[1] / 255.;
 }
 
@@ -1032,7 +1004,7 @@
 void Combination::SetGreen
 (
     double value
-) throw() {
+){
     value = FMIN(FMAX(value, 0.), 1.);
 
     Internal()->rgb[1] = static_cast<unsigned char>(floor(value * 255 + 0.5));
@@ -1039,7 +1011,7 @@
 }
 
 
-double Combination::Blue(void) const throw() {
+double Combination::Blue(void) const{
     return Internal()->rgb[2] / 255.;
 }
 
@@ -1047,7 +1019,7 @@
 void Combination::SetBlue
 (
     double value
-) throw() {
+){
     value = FMIN(FMAX(value, 0.), 1.);
 
     Internal()->rgb[2] = static_cast<unsigned char>(floor(value * 255 + 0.5));
@@ -1054,7 +1026,7 @@
 }
 
 
-const char* Combination::Shader(void) const throw() {
+const char* Combination::Shader(void) const{
     return bu_vls_addr(&Internal()->shader);
 }
 
@@ -1062,19 +1034,17 @@
 void Combination::SetShader
 (
     const char* value
-) throw(bad_alloc) {
+){
     if (!BU_SETJUMP)
         bu_vls_strcpy(&Internal()->shader, value);
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Combination::SetShader");
-    }
 
     BU_UNSETJUMP;
 }
 
 
-bool Combination::Inherit(void) const throw() {
+bool Combination::Inherit(void) const{
     return Internal()->inherit != 0;
 }
 
@@ -1082,12 +1052,12 @@
 void Combination::SetInherit
 (
     bool value
-) throw() {
+){
     Internal()->inherit = (value) ? '\1' : '\0';
 }
 
 
-const char* Combination::Material(void) const throw() {
+const char* Combination::Material(void) const{
     return bu_vls_addr(&Internal()->material);
 }
 
@@ -1095,19 +1065,17 @@
 void Combination::SetMaterial
 (
     const char* value
-) throw(bad_alloc) {
+){
     if (!BU_SETJUMP)
         bu_vls_strcpy(&Internal()->material, value);
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Combination::SetMaterial");
-    }
 
     BU_UNSETJUMP;
 }
 
 
-double Combination::Temperature(void) const throw() {
+double Combination::Temperature(void) const{
     return Internal()->temperature;
 }
 
@@ -1115,7 +1083,7 @@
 void Combination::SetTemperature
 (
     double value
-) throw() {
+){
     Internal()->temperature = static_cast<float>(value);
 }
 
@@ -1123,7 +1091,7 @@
 const Object& Combination::operator=
 (
     const Object& original
-) throw(bad_alloc) {
+){
     const Combination* comb = dynamic_cast<const Combination*>(&original);
     assert(comb != 0);
 
@@ -1134,22 +1102,22 @@
 }
 
 
-Object* Combination::Clone(void) const throw(bad_alloc, std::bad_alloc) {
+Object* Combination::Clone(void) const{
     return new Combination(*this);
 }
 
 
-const char* Combination::ClassName(void) throw() {
+const char* Combination::ClassName(void){
     return "Combination";
 }
 
 
-const char* Combination::Type(void) const throw() {
+const char* Combination::Type(void) const{
     return ClassName();
 }
 
 
-bool Combination::IsValid(void) const throw() {
+bool Combination::IsValid(void) const{
     bool ret = Validate();
 
     if (ret) {
@@ -1175,10 +1143,10 @@
     directory*      pDir,
     rt_db_internal* ip,
     db_i*           dbip
-) throw() : Object(resp, pDir, ip, dbip), m_internalp(0) {}
+): Object(resp, pDir, ip, dbip), m_internalp(0) {}
 
 
-const rt_comb_internal* Combination::Internal(void) const throw() {
+const rt_comb_internal* Combination::Internal(void) const{
     const rt_comb_internal* ret;
 
     if (m_ip != 0)
@@ -1192,7 +1160,7 @@
 }
 
 
-rt_comb_internal* Combination::Internal(void) throw() {
+rt_comb_internal* Combination::Internal(void){
     rt_comb_internal* ret;
 
     if (m_ip != 0)
Index: src/coreInterface/Cone.cpp
===================================================================
--- src/coreInterface/Cone.cpp	(revision 74453)
+++ src/coreInterface/Cone.cpp	(working copy)
@@ -39,7 +39,7 @@
 using namespace BRLCAD;
 
 
-Cone::Cone(void) throw(bad_alloc) : Object () {
+Cone::Cone(void): Object () {
     if(!BU_SETJUMP){
         BU_GET(m_internalp, rt_tgc_internal);
         m_internalp->magic = RT_TGC_INTERNAL_MAGIC;
@@ -46,10 +46,8 @@
 
         Set(Vector3D(), Vector3D(0., 0., 1.), 1., 0.);
     }
-    else{
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Cone::Cone");
-    }
 
     BU_UNSETJUMP;
 }
@@ -63,8 +61,7 @@
     const Vector3D& semiPrincipalAxisB,
     double          ratioCtoA,
     double          ratioDtoB
-) throw(bad_alloc)
-{
+){
     if(!BU_SETJUMP){
         BU_GET(m_internalp, rt_tgc_internal);
         m_internalp->magic = RT_TGC_INTERNAL_MAGIC;
@@ -71,10 +68,8 @@
 
         Set(basePoint, height, semiPrincipalAxisA, semiPrincipalAxisB, ratioCtoA, ratioDtoB);
     }
-    else{
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Cone::Cone");
-    }
 
     BU_UNSETJUMP;
 
@@ -88,8 +83,7 @@
     const Vector3D& semiPrincipalAxisA,
     const Vector3D& semiPrincipalAxisB,
     double          scale
-) throw(bad_alloc)
-{
+){
     if(!BU_SETJUMP){
         BU_GET(m_internalp, rt_tgc_internal);
         m_internalp->magic = RT_TGC_INTERNAL_MAGIC;
@@ -96,10 +90,8 @@
 
         Set(basePoint, height, semiPrincipalAxisA, semiPrincipalAxisB, scale);
     }
-    else{
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Cone::Cone");
-    }
 
     BU_UNSETJUMP;
 
@@ -112,8 +104,7 @@
     const Vector3D& height,
     const Vector3D& semiPrincipalAxisA,
     const Vector3D& semiPrincipalAxisB
-) throw(bad_alloc)
-{
+){
     if(!BU_SETJUMP){
         BU_GET(m_internalp, rt_tgc_internal);
         m_internalp->magic = RT_TGC_INTERNAL_MAGIC;
@@ -120,10 +111,8 @@
 
         Set(basePoint, height, semiPrincipalAxisA, semiPrincipalAxisB);
     }
-    else{
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Cone::Cone");
-    }
 
     BU_UNSETJUMP;
 
@@ -136,8 +125,7 @@
     const Vector3D& height,
     double          radiusBase,
     double          radiusTop
-) throw(bad_alloc)
-{
+){
     if(!BU_SETJUMP){
         BU_GET(m_internalp, rt_tgc_internal);
         m_internalp->magic = RT_TGC_INTERNAL_MAGIC;
@@ -144,10 +132,8 @@
 
         Set(basePoint, height, radiusBase, radiusTop);
     }
-    else{
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Cone::Cone");
-    }
 
     BU_UNSETJUMP;
 
@@ -159,8 +145,7 @@
     const Vector3D& basePoint,
     const Vector3D& height,
     double          radius
-) throw(bad_alloc)
-{
+){
     if(!BU_SETJUMP){
         BU_GET(m_internalp, rt_tgc_internal);
         m_internalp->magic = RT_TGC_INTERNAL_MAGIC;
@@ -167,10 +152,8 @@
 
         Set(basePoint, height, radius);
     }
-    else{
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Cone::Cone");
-    }
 
     BU_UNSETJUMP;
 
@@ -180,21 +163,19 @@
 Cone::Cone
 (
     const Cone& original
-) throw(bad_alloc) : Object(original) {
+): Object(original) {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_tgc_internal);
         memcpy(m_internalp, original.Internal(), sizeof(rt_tgc_internal));
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Cone::Cone");
-    }
 
     BU_UNSETJUMP;
 }
 
 
-Cone::~Cone(void) throw() {
+Cone::~Cone(void){
     if (m_internalp != 0)
         bu_free(m_internalp, "BRLCAD::Cone::~Cone::m_internalp");
 }
@@ -203,7 +184,7 @@
 const Cone& Cone::operator=
 (
     const Cone& original
-) throw(bad_alloc) {
+){
     if(&original != this) {
         Copy(original);
         memcpy(Internal(), original.Internal(), sizeof(rt_tgc_internal));
@@ -213,7 +194,7 @@
 }
 
 
-Vector3D Cone::BasePoint(void) const throw() {
+Vector3D Cone::BasePoint(void) const{
     return Vector3D(Internal()->v);
 }
 
@@ -221,12 +202,12 @@
 void Cone::SetBasePoint
 (
     const Vector3D& basePoint
-) throw() {
+){
     VMOVE(Internal()->v, basePoint.coordinates);
 }
 
 
-Vector3D Cone::Height(void) const throw() {
+Vector3D Cone::Height(void) const{
     return Vector3D(Internal()->h);
 }
 
@@ -234,7 +215,7 @@
 void Cone::SetHeight
 (
     const Vector3D& height
-) throw() {
+){
     VMOVE(Internal()->h, height.coordinates);
 }
 
@@ -242,7 +223,7 @@
 Vector3D Cone::SemiPrincipalAxis
 (
     size_t index
-) const throw(){
+) const{
     Vector3D ret;
 
     assert(index < 4);
@@ -272,7 +253,7 @@
 (
     size_t          index,
     const Vector3D& semiPrincipalAxis
-) throw(){
+){
     assert(index < 4);
 
     switch (index) {
@@ -302,7 +283,7 @@
     const Vector3D& semiPrincipalAxisB,
     double          ratioCtoA,
     double          ratioDtoB
-) throw() {
+){
     rt_tgc_internal* internalp = Internal();
 
     VMOVE(internalp->v, basePoint.coordinates);
@@ -322,7 +303,7 @@
     const Vector3D& semiPrincipalAxisA,
     const Vector3D& semiPrincipalAxisB,
     double          scale
-) throw() {
+){
     rt_tgc_internal* internalp = Internal();
 
     VMOVE(internalp->v, basePoint.coordinates);
@@ -341,7 +322,7 @@
     const Vector3D& height,
     const Vector3D& semiPrincipalAxisA,
     const Vector3D& semiPrincipalAxisB
-) throw() {
+){
     rt_tgc_internal* internalp = Internal();
 
     VMOVE(internalp->v, basePoint.coordinates);
@@ -360,7 +341,7 @@
     const Vector3D& height,
     double          radiusBase,
     double          radiusTop
-) throw() {
+){
     rt_tgc_internal* internalp = Internal();
     vect_t           semiPrincipalAxisA = {0.};
     vect_t           semiPrincipalAxisB = {0.};
@@ -384,7 +365,7 @@
     const Vector3D& basePoint,
     const Vector3D& height,
     double          radius
-) throw() {
+){
     rt_tgc_internal* internalp = Internal();
     vect_t           semiPrincipalAxisA = {0.};
     vect_t           semiPrincipalAxisB = {0.};
@@ -406,7 +387,7 @@
 const Object& Cone::operator=
 (
     const Object& original
-) throw(bad_alloc) {
+){
     const Cone* tgc = dynamic_cast<const Cone*>(&original);
     assert(tgc != 0);
 
@@ -417,22 +398,22 @@
 }
 
 
-Object* Cone::Clone(void) const throw(bad_alloc, std::bad_alloc) {
+Object* Cone::Clone(void) const{
     return new Cone(*this);
 }
 
 
-const char* Cone::ClassName(void) throw() {
+const char* Cone::ClassName(void){
     return "Cone";
 }
 
 
-const char* Cone::Type(void) const throw() {
+const char* Cone::Type(void) const{
     return ClassName();
 }
 
 
-bool Cone::IsValid(void) const throw(){
+bool Cone::IsValid(void) const{
     bool                   ret       = false;
     const rt_tgc_internal* internalp = Internal();
         double magA = MAGNITUDE(internalp->a);
@@ -466,10 +447,10 @@
     directory*      pDir,
     rt_db_internal* ip,
     db_i*           dbip
-) throw() : Object(resp, pDir, ip, dbip), m_internalp(0) {}
+): Object(resp, pDir, ip, dbip), m_internalp(0) {}
 
 
-rt_tgc_internal* Cone::Internal(void) throw() {
+rt_tgc_internal* Cone::Internal(void){
     rt_tgc_internal* ret;
 
     if(m_ip != 0)
@@ -483,7 +464,7 @@
 }
 
 
-const rt_tgc_internal* Cone::Internal(void) const throw() {
+const rt_tgc_internal* Cone::Internal(void) const{
     const rt_tgc_internal* ret;
 
     if (m_ip != 0)
Index: src/coreInterface/ConstDatabase.cpp
===================================================================
--- src/coreInterface/ConstDatabase.cpp	(revision 74453)
+++ src/coreInterface/ConstDatabase.cpp	(working copy)
@@ -71,7 +71,7 @@
 }
 
 
-static void InitBrlCad(void) throw() {
+static void InitBrlCad(void) {
     static bool init = true;
 
     if (init) { // do it only once
@@ -89,7 +89,7 @@
 // class ConstDatabase
 //
 
-ConstDatabase::ConstDatabase(void) throw(bad_alloc) : m_rtip(0), m_resp(0) {
+ConstDatabase::ConstDatabase(void) : m_rtip(0), m_resp(0) {
     InitBrlCad();
 
     if (rt_uniresource.re_magic != RESOURCE_MAGIC)
@@ -99,16 +99,14 @@
         m_resp = static_cast<resource*>(bu_calloc(1, sizeof(resource), "BRLCAD::ConstDatabase::~ConstDatabase::m_resp"));
         rt_init_resource(m_resp, 0, NULL);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Object::Object");
-    }
 
     BU_UNSETJUMP;
 }
 
 
-ConstDatabase::~ConstDatabase(void) throw() {
+ConstDatabase::~ConstDatabase(void) {
     if (m_rtip != 0) {
         if (!BU_SETJUMP)
             rt_free_rti(m_rtip);
@@ -126,7 +124,7 @@
 bool ConstDatabase::Load
 (
     const char* fileName
-) throw() {
+) {
     if (m_resp != 0) {
         if (m_rtip != 0) {
             if (!BU_SETJUMP)
@@ -162,7 +160,7 @@
 }
 
 
-const char* ConstDatabase::Title(void) const throw() {
+const char* ConstDatabase::Title(void) const {
     const char* ret = 0;
 
     if (m_rtip != 0)
@@ -172,7 +170,7 @@
 }
 
 
-const ConstDatabase::TopObjectIterator& ConstDatabase::TopObjectIterator::operator++(void) throw() {
+const ConstDatabase::TopObjectIterator& ConstDatabase::TopObjectIterator::operator++(void) {
     if (m_pDir != 0) {
         const directory* oldPDir = m_pDir;
 
@@ -203,12 +201,12 @@
 }
 
 
-bool ConstDatabase::TopObjectIterator::Good(void) const throw() {
+bool ConstDatabase::TopObjectIterator::Good(void) const {
     return (m_pDir != 0);
 }
 
 
-const char* ConstDatabase::TopObjectIterator::Name(void) const throw() {
+const char* ConstDatabase::TopObjectIterator::Name(void) const {
     assert(m_pDir != 0);
 
     const char* ret = 0;
@@ -225,10 +223,10 @@
     size_t           hashTablePosition,
     const directory* pDir,
     const rt_i*      rtip
-) throw() : m_hashTablePosition(hashTablePosition), m_pDir(pDir), m_rtip(rtip) {}
+) : m_hashTablePosition(hashTablePosition), m_pDir(pDir), m_rtip(rtip) {}
 
 
-ConstDatabase::TopObjectIterator ConstDatabase::FirstTopObject(void) const throw() {
+ConstDatabase::TopObjectIterator ConstDatabase::FirstTopObject(void) const {
     size_t           hashTablePosition = 0;
     const directory* pDirectory        = 0;
 
@@ -337,7 +335,6 @@
                     catch(...) {
                         BU_UNSETJUMP;
                         rt_db_free_internal(&intern);
-                        throw;
                     }
 
                     rt_db_free_internal(&intern);
@@ -353,13 +350,13 @@
 Object* ConstDatabase::Get
 (
     const char* objectName
-) const throw(bad_alloc, std::bad_alloc) {
+) const {
     class ObjectCallbackIntern : public ObjectCallback {
     public:
         ObjectCallbackIntern(void) : ConstDatabase::ObjectCallback(),
                                      m_object(0) {}
 
-        virtual ~ObjectCallbackIntern(void) throw() {}
+        virtual ~ObjectCallbackIntern(void) {}
 
         virtual void operator()(const Object& object) {
             try {
@@ -368,7 +365,7 @@
             catch(std::bad_alloc&) {}
         }
 
-        Object*      GetObject(void) const throw() {
+        Object*      GetObject(void) const {
             return m_object;
         }
 
@@ -428,7 +425,7 @@
 NonManifoldGeometry* ConstDatabase::Facetize
 (
     const char* objectName
-) const throw(bad_alloc, std::bad_alloc) {
+) const {
     NonManifoldGeometry* ret          = new NonManifoldGeometry;
 
     if (m_rtip != 0) {
@@ -466,10 +463,8 @@
                 }
             }
         }
-        else {
+        else
             BU_UNSETJUMP;
-            throw bad_alloc("BRLCAD::Object::Facetize");
-        }
 
         BU_UNSETJUMP;
     }
@@ -481,7 +476,7 @@
 void ConstDatabase::Select
 (
     const char* objectName
-) throw() {
+) {
     if (m_rtip != 0) {
         if (!BU_SETJUMP)
             rt_gettree(m_rtip, objectName);
@@ -491,7 +486,7 @@
 }
 
 
-void ConstDatabase::UnSelectAll(void) throw() {
+void ConstDatabase::UnSelectAll(void) {
     if (m_rtip != 0) {
         if (!BU_SETJUMP)
             rt_clean(m_rtip);
@@ -501,7 +496,7 @@
 }
 
 
-bool ConstDatabase::SelectionIsEmpty(void) const throw() {
+bool ConstDatabase::SelectionIsEmpty(void) const {
     bool ret = true;
 
     if (m_rtip != 0)
@@ -511,7 +506,7 @@
 }
 
 
-Vector3D ConstDatabase::BoundingBoxMinima(void) const throw() {
+Vector3D ConstDatabase::BoundingBoxMinima(void) const {
     Vector3D ret;
 
     if (!SelectionIsEmpty()) {
@@ -529,7 +524,7 @@
 }
 
 
-Vector3D ConstDatabase::BoundingBoxMaxima(void) const throw() {
+Vector3D ConstDatabase::BoundingBoxMaxima(void) const {
     Vector3D ret;
 
     if (!SelectionIsEmpty()) {
@@ -551,50 +546,50 @@
 public:
     ConstDatabaseHit(application* ap,
                      partition*   part,
-                     region*      reg) throw() : ConstDatabase::Hit(),
-                                                  m_application(ap),
-                                                  m_partition(part),
-                                                  m_region(reg),
-                                                  m_inVectorsComputed(false),
-                                                  m_outVectorsComputed(false) {
+                     region*      reg) : ConstDatabase::Hit(),
+                                          m_application(ap),
+                                          m_partition(part),
+                                          m_region(reg),
+                                          m_inVectorsComputed(false),
+                                          m_outVectorsComputed(false) {
         assert(m_application != 0);
         assert(m_partition != 0);
         assert(m_region != 0);
    }
 
-    virtual const char* Name(void) const throw() {
+    virtual const char* Name(void) const {
         return m_region->reg_name;
     }
 
-    virtual double      DistanceIn(void) const throw() {
+    virtual double      DistanceIn(void) const {
         return m_partition->pt_inhit->hit_dist;
     }
 
-    virtual double      DistanceOut(void) const throw() {
+    virtual double      DistanceOut(void) const {
         return m_partition->pt_outhit->hit_dist;
     }
 
-    virtual Vector3D    PointIn(void) const throw() {
+    virtual Vector3D    PointIn(void) const {
         ComputeInVectors();
         return m_partition->pt_inhit->hit_point;
     }
 
-    virtual Vector3D    PointOut(void) const throw() {
+    virtual Vector3D    PointOut(void) const {
         ComputeOutVectors();
         return m_partition->pt_outhit->hit_point;
     }
 
-    virtual Vector3D    SurfaceNormalIn(void) const throw() {
+    virtual Vector3D    SurfaceNormalIn(void) const {
         ComputeInVectors();
         return m_partition->pt_inhit->hit_normal;
     }
 
-    virtual Vector3D    SurfaceNormalOut(void) const throw() {
+    virtual Vector3D    SurfaceNormalOut(void) const {
         ComputeOutVectors();
         return m_partition->pt_outhit->hit_normal;
     }
 
-    virtual Curvature3D SurfaceCurvatureIn(void) const throw() {
+    virtual Curvature3D SurfaceCurvatureIn(void) const {
         ComputeInVectors();
 
         curvature curv;
@@ -603,7 +598,7 @@
         return Curvature3D(curv.crv_pdir, curv.crv_c1, curv.crv_c2);
     }
 
-    virtual Curvature3D SurfaceCurvatureOut(void) const throw() {
+    virtual Curvature3D SurfaceCurvatureOut(void) const {
         ComputeOutVectors();
 
         curvature curv;
@@ -612,7 +607,7 @@
         return Curvature3D(curv.crv_pdir, curv.crv_c1, curv.crv_c2);
     }
 
-    virtual Mapping2D   Surface2DMappingIn(void) const throw() {
+    virtual Mapping2D   Surface2DMappingIn(void) const {
         uvcoord uv;
         RT_HIT_UVCOORD(m_application, m_partition->pt_inseg->seg_stp, m_partition->pt_inhit, &uv);
 
@@ -619,7 +614,7 @@
         return Mapping2D(Vector2D(uv.uv_u, uv.uv_v), Vector2D(uv.uv_du, uv.uv_dv));
     }
 
-    virtual Mapping2D   Surface2DMappingOut(void) const throw() {
+    virtual Mapping2D   Surface2DMappingOut(void) const {
         uvcoord uv;
         RT_HIT_UVCOORD(m_application, m_partition->pt_outseg->seg_stp, m_partition->pt_outhit, &uv);
 
@@ -626,19 +621,19 @@
         return Mapping2D(Vector2D(uv.uv_u, uv.uv_v), Vector2D(uv.uv_du, uv.uv_dv));
     }
 
-    virtual bool        HasColor(void) const throw() {
+    virtual bool        HasColor(void) const {
         return (m_region->reg_mater.ma_color_valid != 0);
     }
 
-    virtual double      Red(void) const throw() {
+    virtual double      Red(void) const {
         return m_region->reg_mater.ma_color[0];
     }
 
-    virtual double      Green(void) const throw() {
+    virtual double      Green(void) const {
         return m_region->reg_mater.ma_color[1];
     }
 
-    virtual double      Blue(void) const throw() {
+    virtual double      Blue(void) const {
         return m_region->reg_mater.ma_color[2];
     }
 
@@ -649,7 +644,7 @@
     mutable bool m_inVectorsComputed;
     mutable bool m_outVectorsComputed;
 
-    void ComputeInVectors(void) const throw() {
+    void ComputeInVectors(void) const {
         if (!m_inVectorsComputed) {
             hit* pHit = m_partition->pt_inhit;
 
@@ -658,7 +653,7 @@
         }
     }
 
-    void ComputeOutVectors(void) const throw() {
+    void ComputeOutVectors(void) const {
         if (!m_outVectorsComputed) {
             hit* pHit = m_partition->pt_outhit;
 
@@ -723,15 +718,13 @@
             }
             catch(...) {
                 BU_UNSETJUMP;
-                throw;
-            }
         }
 
         BU_UNSETJUMP;
-    }
+      }
+   }
 }
 
-
 static void MultioverlapDo
 (
     application* ap,
@@ -797,7 +790,6 @@
             }
             catch(...) {
                 BU_UNSETJUMP;
-                throw;
             }
         }
 
Index: src/coreInterface/Database.cpp
===================================================================
--- src/coreInterface/Database.cpp	(revision 74453)
+++ src/coreInterface/Database.cpp	(working copy)
@@ -62,7 +62,7 @@
 using namespace BRLCAD;
 
 
-Database::~Database(void) throw() {
+Database::~Database(void) {
     if (m_wdbp != 0) {
         if (!BU_SETJUMP)
             wdb_close(m_wdbp);
@@ -75,14 +75,12 @@
 void Database::SetTitle
 (
     const char* title
-) throw(bad_alloc) {
+) {
     if (m_wdbp != 0) {
         if (!BU_SETJUMP)
             db_update_ident(m_wdbp->dbip, title, m_wdbp->dbip->dbi_base2local);
-        else {
+        else
             BU_UNSETJUMP;
-            throw bad_alloc("BRLCAD::Database::SetTitle");
-        }
 
         BU_UNSETJUMP;
     }
@@ -92,7 +90,7 @@
 bool Database::Add
 (
     const Object& object
-) throw() {
+) {
     bool ret = false;
 
     if (m_wdbp != 0) {
@@ -301,7 +299,7 @@
 void Database::Delete
 (
     const char* objectName
-) throw() {
+) {
     if (m_wdbp != 0) {
         if (!BU_SETJUMP) {
             directory* pDir = db_lookup(m_rtip->rti_dbip, objectName, LOOKUP_NOISE);
@@ -327,7 +325,7 @@
         ObjectCallbackIntern(Database::ObjectCallback& cb) : ConstDatabase::ObjectCallback(),
                                                              m_callback(cb) {}
 
-        virtual ~ObjectCallbackIntern(void) throw() {}
+        virtual ~ObjectCallbackIntern(void) {}
 
         virtual void operator()(const Object& object) {
             Object& objectIntern = const_cast<Object&>(object);
@@ -354,13 +352,13 @@
 void Database::Set
 (
     const Object& object
-) throw(bad_alloc) {
+) {
     class ObjectCallbackIntern : public ObjectCallback {
     public:
         ObjectCallbackIntern(const Object& obj) : ObjectCallback(),
                                                   m_object(obj) {}
 
-        virtual ~ObjectCallbackIntern(void) throw() {}
+        virtual ~ObjectCallbackIntern(void) {}
 
         virtual void operator()(Object& obj) {
             obj = m_object;
@@ -374,4 +372,4 @@
 }
 
 
-Database::Database(void) throw(bad_alloc) : ConstDatabase(), m_wdbp(0) {}
+Database::Database(void) : ConstDatabase(), m_wdbp(0) {}
Index: src/coreInterface/Ellipsoid.cpp
===================================================================
--- src/coreInterface/Ellipsoid.cpp	(revision 74453)
+++ src/coreInterface/Ellipsoid.cpp	(working copy)
@@ -39,7 +39,7 @@
 using namespace BRLCAD;
 
 
-Ellipsoid::Ellipsoid(void) throw(bad_alloc) : Object() {
+Ellipsoid::Ellipsoid(void) : Object() {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_ell_internal);
         m_internalp->magic = RT_ELL_INTERNAL_MAGIC;
@@ -46,10 +46,8 @@
 
         SetSphere(Vector3D(), 1.);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Ellipsoid::Ellipsoid");
-    }
 
     BU_UNSETJUMP;
 }
@@ -61,7 +59,7 @@
     const Vector3D& semiPrincipalAxisA,
     const Vector3D& semiPrincipalAxisB,
     const Vector3D& semiPrincipalAxisC
-) throw(bad_alloc) {
+) {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_ell_internal);
         m_internalp->magic = RT_ELL_INTERNAL_MAGIC;
@@ -68,10 +66,8 @@
 
         Set(center, semiPrincipalAxisA, semiPrincipalAxisB, semiPrincipalAxisC);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Ellipsoid::Ellipsoid");
-    }
 
     BU_UNSETJUMP;
 }
@@ -82,7 +78,7 @@
     const Vector3D& center,
     const Vector3D& semiPrincipalAxis,
     double          radius
-) throw(bad_alloc) {
+) {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_ell_internal);
         m_internalp->magic = RT_ELL_INTERNAL_MAGIC;
@@ -89,10 +85,8 @@
 
         Set(center, semiPrincipalAxis, radius);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Ellipsoid::Ellipsoid");
-    }
 
     BU_UNSETJUMP;
 }
@@ -102,7 +96,7 @@
 (
     const Vector3D& center,
     double          radius
-) throw(bad_alloc) {
+) {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_ell_internal);
         m_internalp->magic = RT_ELL_INTERNAL_MAGIC;
@@ -109,10 +103,8 @@
 
         SetSphere(center, radius);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Ellipsoid::Ellipsoid");
-    }
 
     BU_UNSETJUMP;
 }
@@ -121,21 +113,19 @@
 Ellipsoid::Ellipsoid
 (
     const Ellipsoid& original
-) throw(bad_alloc) : Object(original) {
+) : Object(original) {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_ell_internal);
         memcpy(m_internalp, original.Internal(), sizeof(rt_ell_internal));
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Ellipsoid::Ellipsoid");
-    }
 
     BU_UNSETJUMP;
 }
 
 
-Ellipsoid::~Ellipsoid(void) throw() {
+Ellipsoid::~Ellipsoid(void) {
     if (m_internalp != 0)
         bu_free(m_internalp, "BRLCAD::Ellipsoid::~Ellipsoid::m_internalp");
 }
@@ -144,7 +134,7 @@
 const Ellipsoid& Ellipsoid::operator=
 (
     const Ellipsoid& original
-) throw(bad_alloc) {
+) {
     if(&original != this) {
         Copy(original);
         memcpy(Internal(), original.Internal(), sizeof(rt_ell_internal));
@@ -154,7 +144,7 @@
 }
 
 
-Vector3D Ellipsoid::Center(void) const throw() {
+Vector3D Ellipsoid::Center(void) const {
     return Vector3D(Internal()->v);
 }
 
@@ -162,7 +152,7 @@
 void Ellipsoid::SetCenter
 (
     const Vector3D& center
-) throw(){
+) {
     VMOVE(Internal()->v, center.coordinates);
 }
 
@@ -170,7 +160,7 @@
 Vector3D Ellipsoid::SemiPrincipalAxis
 (
     size_t index
-) const throw(){
+) const {
     Vector3D ret;
 
     assert(index < 3);
@@ -196,7 +186,7 @@
 (
     size_t          index,
     const Vector3D& semiPrincipalAxis
-) throw(){
+) {
     assert(index < 3);
 
     switch (index) {
@@ -220,7 +210,7 @@
     const Vector3D& semiPrincipalAxisA,
     const Vector3D& semiPrincipalAxisB,
     const Vector3D& semiPrincipalAxisC
-) throw(){
+) {
     rt_ell_internal* internalp = Internal();
 
     VMOVE(internalp->v, center.coordinates);
@@ -235,7 +225,7 @@
     const Vector3D& center,
     const Vector3D& semiPrincipalAxis,
     double          radius
-) throw() {
+) {
     double length = MAGNITUDE(semiPrincipalAxis.coordinates);
 
     assert(length > SMALL_FASTF);
@@ -261,7 +251,7 @@
     const Vector3D& focalA,
     const Vector3D& focalB,
     double          majorAxisLength
-) throw(){
+) {
     assert(majorAxisLength > SMALL_FASTF);
 
     if (majorAxisLength > SMALL_FASTF) {
@@ -305,7 +295,7 @@
 (
     const Vector3D& center,
     double          radius
-) throw() {
+) {
     assert(radius > SMALL_FASTF);
 
     if (!NEAR_ZERO(radius, SMALL_FASTF)) {
@@ -322,7 +312,7 @@
 const Object& Ellipsoid::operator=
 (
     const Object& original
-) throw(bad_alloc) {
+) {
     const Ellipsoid* ell = dynamic_cast<const Ellipsoid*>(&original);
     assert(ell != 0);
 
@@ -333,22 +323,22 @@
 }
 
 
-Object* Ellipsoid::Clone(void) const throw(bad_alloc, std::bad_alloc) {
+Object* Ellipsoid::Clone(void) const {
     return new Ellipsoid(*this);
 }
 
 
-const char* Ellipsoid::ClassName(void) throw() {
+const char* Ellipsoid::ClassName(void) {
     return "Ellipsoid";
 }
 
 
-const char* Ellipsoid::Type(void) const throw() {
+const char* Ellipsoid::Type(void) const {
     return ClassName();
 }
 
 
-bool Ellipsoid::IsValid(void) const throw() {
+bool Ellipsoid::IsValid(void) const {
     bool                   ret       = false;
     const rt_ell_internal* internalp = Internal();
 
@@ -370,10 +360,10 @@
     directory*      pDir,
     rt_db_internal* ip,
     db_i*           dbip
-) throw() : Object(resp, pDir, ip, dbip), m_internalp(0) {}
+) : Object(resp, pDir, ip, dbip), m_internalp(0) {}
 
 
-rt_ell_internal* Ellipsoid::Internal(void) throw() {
+rt_ell_internal* Ellipsoid::Internal(void) {
     rt_ell_internal* ret;
 
     if (m_ip != 0)
@@ -387,7 +377,7 @@
 }
 
 
-const rt_ell_internal* Ellipsoid::Internal(void) const throw() {
+const rt_ell_internal* Ellipsoid::Internal(void) const {
     const rt_ell_internal* ret;
 
     if (m_ip != 0)
Index: src/coreInterface/EllipticalTorus.cpp
===================================================================
--- src/coreInterface/EllipticalTorus.cpp	(revision 74453)
+++ src/coreInterface/EllipticalTorus.cpp	(working copy)
@@ -39,7 +39,7 @@
 using namespace BRLCAD;
 
 
-EllipticalTorus::EllipticalTorus(void) throw(bad_alloc) : Object() {
+EllipticalTorus::EllipticalTorus(void) : Object() {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_eto_internal);
         m_internalp->eto_magic = RT_ETO_INTERNAL_MAGIC;
@@ -46,10 +46,8 @@
 
         Set(Vector3D(), Vector3D(0., 0., 1.), 2., Vector3D(1., 0., 0.), 1.);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::EllipticalTorus::EllipticalTorus");
-    }
 
     BU_UNSETJUMP;
 }
@@ -62,7 +60,7 @@
     double          tubeCenterLineRadius,
     const Vector3D& tubeSemiMajorAxis,
     double          tubeSemiMinorAxisLength
-) throw(bad_alloc) {
+) {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_eto_internal);
         m_internalp->eto_magic = RT_ETO_INTERNAL_MAGIC;
@@ -69,10 +67,8 @@
 
         Set(center, normalToTubeCenterLinePlane, tubeCenterLineRadius, tubeSemiMajorAxis, tubeSemiMinorAxisLength);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::EllipticalTorus::EllipticalTorus");
-    }
 
     BU_UNSETJUMP;
 }
@@ -81,21 +77,19 @@
 EllipticalTorus::EllipticalTorus
 (
     const EllipticalTorus& original
-) throw(bad_alloc) : Object(original) {
+) : Object(original) {
     if (!BU_SETJUMP) {
         BU_GET(m_internalp, rt_eto_internal);
         memcpy(m_internalp, original.Internal(), sizeof(rt_eto_internal));
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::EllipticalTorus::EllipticalTorus");
-    }
 
     BU_UNSETJUMP;
 }
 
 
-EllipticalTorus::~EllipticalTorus(void) throw() {
+EllipticalTorus::~EllipticalTorus(void) {
     if (m_internalp != 0)
         bu_free(m_internalp, "BRLCAD::EllipticalTorus::~EllipticalTorus::m_internalp");
 }
@@ -104,7 +98,7 @@
 const EllipticalTorus& EllipticalTorus::operator =
 (
     const EllipticalTorus& original
-) throw(bad_alloc) {
+) {
     if(&original != this) {
         Copy(original);
         memcpy(Internal(), original.Internal(), sizeof(rt_eto_internal));
@@ -114,7 +108,7 @@
 }
 
 
-Vector3D EllipticalTorus::Center(void) const throw() {
+Vector3D EllipticalTorus::Center(void) const {
     return Vector3D(Internal()->eto_V);
 }
 
@@ -122,12 +116,12 @@
 void EllipticalTorus::SetCenter
 (
     const Vector3D& center
-) throw() {
+) {
     VMOVE(Internal()->eto_V, center.coordinates);
 }
 
 
-Vector3D EllipticalTorus::Normal(void) const throw() {
+Vector3D EllipticalTorus::Normal(void) const {
     return Vector3D(Internal()->eto_N);
 }
 
@@ -135,7 +129,7 @@
 void EllipticalTorus::SetNormal
 (
     const Vector3D& normal
-) throw() {
+) {
     assert(!VNEAR_ZERO(normal.coordinates, SMALL_FASTF));
 
     VMOVE(Internal()->eto_N, normal.coordinates);
@@ -143,7 +137,7 @@
 }
 
 
-double EllipticalTorus::TubeCenterLineRadius(void) const throw() {
+double EllipticalTorus::TubeCenterLineRadius(void) const {
     return Internal()->eto_r;
 }
 
@@ -151,12 +145,12 @@
 void EllipticalTorus::SetTubeCenterLineRadius
 (
     double radius
-) throw() {
+) {
     Internal()->eto_r = radius;
 }
 
 
-Vector3D EllipticalTorus::TubeSemiMajorAxis(void) const throw() {
+Vector3D EllipticalTorus::TubeSemiMajorAxis(void) const {
     return Vector3D(Internal()->eto_C);
 }
 
@@ -164,12 +158,12 @@
 void EllipticalTorus::SetTubeSemiMajorAxis
 (
     const Vector3D& axis
-) throw() {
+) {
     VMOVE(Internal()->eto_C, axis.coordinates);
 }
 
 
-double EllipticalTorus::TubeSemiMinorAxis(void) const throw() {
+double EllipticalTorus::TubeSemiMinorAxis(void) const {
     return Internal()->eto_rd;
 }
 
@@ -177,7 +171,7 @@
 void EllipticalTorus::SetTubeSemiMinorAxis
 (
     double length
-) throw() {
+) {
     Internal()->eto_rd = length;
 }
 
@@ -189,7 +183,7 @@
     double          tubeCenterLineRadius,
     const Vector3D& tubeSemiMajorAxis,
     double          tubeSemiMinorAxisLength
-) throw(){
+) {
      rt_eto_internal* internalp = Internal();
 
     VMOVE(internalp->eto_V, center.coordinates);
@@ -207,7 +201,7 @@
 const Object& EllipticalTorus::operator=
 (
     const Object& original
-) throw(bad_alloc) {
+) {
     const EllipticalTorus* eto = dynamic_cast<const EllipticalTorus*>(&original);
     assert(eto != 0);
 
@@ -218,22 +212,22 @@
 }
 
 
-Object* EllipticalTorus::Clone(void) const throw(bad_alloc, std::bad_alloc) {
+Object* EllipticalTorus::Clone(void) const {
     return new EllipticalTorus(*this);
 }
 
 
-const char* EllipticalTorus::ClassName(void) throw() {
+const char* EllipticalTorus::ClassName(void) {
     return "EllipticalTorus";
 }
 
 
-const char* EllipticalTorus::Type(void) const throw() {
+const char* EllipticalTorus::Type(void) const {
     return ClassName();
 }
 
 
-bool EllipticalTorus::IsValid(void) const throw(){
+bool EllipticalTorus::IsValid(void) const {
     bool                   ret       = false;
     const rt_eto_internal* internalp = Internal();
     double                 rc        = MAGNITUDE(internalp->eto_C);
@@ -271,10 +265,10 @@
     directory*      pDir,
     rt_db_internal* ip,
     db_i*           dbip
-) throw() : Object(resp, pDir, ip, dbip), m_internalp(0) {}
+) : Object(resp, pDir, ip, dbip), m_internalp(0) {}
 
 
-const rt_eto_internal* EllipticalTorus::Internal(void) const throw() {
+const rt_eto_internal* EllipticalTorus::Internal(void) const {
     const rt_eto_internal* ret;
 
     if (m_ip != 0)
@@ -288,7 +282,7 @@
 }
 
 
-rt_eto_internal* EllipticalTorus::Internal(void) throw() {
+rt_eto_internal* EllipticalTorus::Internal(void) {
     rt_eto_internal* ret;
 
     if(m_ip != 0)
Index: src/coreInterface/FileDatabase.cpp
===================================================================
--- src/coreInterface/FileDatabase.cpp	(revision 74453)
+++ src/coreInterface/FileDatabase.cpp	(working copy)
@@ -36,16 +36,16 @@
 using namespace BRLCAD;
 
 
-FileDatabase::FileDatabase(void) throw(bad_alloc) : Database() {}
+FileDatabase::FileDatabase(void) : Database() {}
 
 
-FileDatabase::~FileDatabase(void) throw() {}
+FileDatabase::~FileDatabase(void) {}
 
 
 bool FileDatabase::Load
 (
     const char* fileName
-) throw() {
+) {
     bool ret = false;
 
     if (m_resp != 0) {
Index: src/coreInterface/Object.cpp
===================================================================
--- src/coreInterface/Object.cpp	(revision 74453)
+++ src/coreInterface/Object.cpp	(working copy)
@@ -43,7 +43,7 @@
 // class Object::AttributeIterator
 //
 
-const Object::AttributeIterator& Object::AttributeIterator::operator++(void) throw() {
+const Object::AttributeIterator& Object::AttributeIterator::operator++(void){
     if (m_avs != 0) {
         if (m_index > 0) {
             --m_index;
@@ -54,7 +54,7 @@
                         m_avs = 0;
                         break;
                     }
-                    
+
                     --m_index;
                 }
             }
@@ -67,12 +67,12 @@
 }
 
 
-bool Object::AttributeIterator::Good(void) const throw() {
+bool Object::AttributeIterator::Good(void) const{
     return (m_avs != 0);
 }
 
 
-const char* Object::AttributeIterator::Key(void) const throw() {
+const char* Object::AttributeIterator::Key(void) const{
     const char* ret = 0;
 
     assert(m_avs != 0);
@@ -84,7 +84,7 @@
 }
 
 
-const char* Object::AttributeIterator::Value(void) const throw() {
+const char* Object::AttributeIterator::Value(void) const{
     const char* ret = 0;
 
     assert(m_avs != 0);
@@ -101,7 +101,7 @@
     const bu_attribute_value_set* avs,
     const char*                   searchKey,
     size_t                        index
-) throw() : m_avs(avs), m_searchKey(searchKey), m_index(index) {}
+): m_avs(avs), m_searchKey(searchKey), m_index(index) {}
 
 
 //
@@ -108,7 +108,7 @@
 // class Object
 //
 
-Object::~Object(void) throw() {
+Object::~Object(void){
     if (m_name != 0)
         bu_free(m_name, "BRLCAD::Object::~Object::m_name");
 
@@ -124,17 +124,17 @@
 }
 
 
-void Object::Destroy(void) throw() {
+void Object::Destroy(void){
     delete this;
 }
 
 
-const char* Object::ClassName(void) throw() {
+const char* Object::ClassName(void){
     return "Object";
 }
 
 
-const char* Object::Name(void) const throw() {
+const char* Object::Name(void) const{
     const char* ret = 0;
 
     assert(!((m_pDir != RT_DIR_NULL) && (m_name != 0)));
@@ -151,7 +151,7 @@
 void Object::SetName
 (
     const char* name
-) throw(bad_alloc) {
+){
     assert(!((m_pDir != RT_DIR_NULL) && (m_name != 0)));
 
     // not connected with a non-writable database
@@ -174,7 +174,6 @@
             else {
                 BU_UNSETJUMP;
                 m_name = 0;
-                throw bad_alloc("BRLCAD::Object::SetName");
             }
 
             BU_UNSETJUMP;
@@ -191,12 +190,12 @@
 bool Object::HasAttribute
 (
     const char* key
-) const throw() {
+) const{
     return (Attribute(key) != 0);
 }
 
 
-Object::AttributeIterator Object::FirstAttribute(void) const throw() {
+Object::AttributeIterator Object::FirstAttribute(void) const{
     const bu_attribute_value_set* avs    = GetAvs();
     const bu_attribute_value_set* avsRet = 0;
     size_t                        index  = 0;
@@ -213,7 +212,7 @@
 const char* Object::Attribute
 (
     const char* key
-) const throw() {
+) const{
     const char*                   ret = 0;
     const bu_attribute_value_set* avs = GetAvs();
 
@@ -237,7 +236,7 @@
 Object::AttributeIterator Object::MultiAttribute
 (
     const char* key
-) const throw() {
+) const{
     const bu_attribute_value_set* avs       = GetAvs();
     const bu_attribute_value_set* avsRet    = 0;
     const char*                   keyIntern = 0;
@@ -265,7 +264,7 @@
 (
     const char* key,
     const char* value
-) throw(bad_alloc) {
+){
     if (!BU_SETJUMP) {
         bu_attribute_value_set* avs = GetAvs(true);
 
@@ -272,10 +271,8 @@
         if (avs != 0)
             bu_avs_add(avs, key, value);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Object::SetMultiAttribute");
-    }
 
     BU_UNSETJUMP;
 }
@@ -285,7 +282,7 @@
 (
     const char* key,
     const char* value
-) throw(bad_alloc) {
+){
     if (!BU_SETJUMP) {
         bu_attribute_value_set* avs = GetAvs(true);
 
@@ -292,10 +289,8 @@
         if (avs != 0)
             bu_avs_add_nonunique(avs, key, value);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Object::SetMultiAttribute");
-    }
 
     BU_UNSETJUMP;
 }
@@ -304,7 +299,7 @@
 void Object::RemoveAttribute
 (
     const char* key
-) throw() {
+){
     bu_attribute_value_set* avs = GetAvs(false);
 
     if (avs != 0)
@@ -312,7 +307,7 @@
 }
 
 
-void Object::ClearAttributes(void) throw() {
+void Object::ClearAttributes(void){
     bu_attribute_value_set* avs = GetAvs(false);
 
     if (avs != 0)
@@ -320,15 +315,13 @@
 }
 
 
-Object::Object(void) throw(bad_alloc) : m_pDir(0), m_ip(0), m_dbip(0), m_name(0), m_avs(0) {
+Object::Object(void): m_pDir(0), m_ip(0), m_dbip(0), m_name(0), m_avs(0) {
     if (!BU_SETJUMP) {
         m_resp = static_cast<resource*>(bu_calloc(1, sizeof(resource), "BRLCAD::Object::Object::m_resp"));
         rt_init_resource(m_resp, 0, NULL);
     }
-    else {
+    else
         BU_UNSETJUMP;
-        throw bad_alloc("BRLCAD::Object::Object");
-    }
 
     BU_UNSETJUMP;
 }
@@ -340,7 +333,7 @@
     directory*      pDir,
     rt_db_internal* ip,
     db_i*           dbip
-) throw() : m_resp(resp), m_pDir(pDir), m_ip(ip), m_dbip(dbip), m_name(0), m_avs(0) {
+): m_resp(resp), m_pDir(pDir), m_ip(ip), m_dbip(dbip), m_name(0), m_avs(0) {
     assert(m_pDir != 0);
 }
 
@@ -348,7 +341,7 @@
 Object::Object
 (
     const Object& original
-) throw(bad_alloc) : m_resp(0), m_pDir(0), m_ip(0), m_dbip(0), m_name(0), m_avs(0) {
+): m_resp(0), m_pDir(0), m_ip(0), m_dbip(0), m_name(0), m_avs(0) {
     if (!BU_SETJUMP) {
         m_resp = static_cast<resource*>(bu_calloc(1, sizeof(resource), "BRLCAD::Object::Object::m_resp"));
         rt_init_resource(m_resp, 0, NULL);
@@ -359,7 +352,6 @@
         if (m_resp != 0)
             bu_free(m_resp, "BRLCAD::Object::Object::m_resp");
 
-        throw bad_alloc("BRLCAD::Object::Object");
     }
 
     BU_UNSETJUMP;
@@ -371,7 +363,7 @@
 void Object::Copy
 (
     const Object& original
-) throw(bad_alloc) {
+){
     if (&original != this) {
         SetName(original.Name());
 
@@ -396,10 +388,8 @@
                     for (size_t i = 0; i < origAvs->count; ++i)
                         bu_avs_add_nonunique(avs, origAvs->avp->name, origAvs->avp->value);
                 }
-                else {
+                else
                     BU_UNSETJUMP;
-                    throw bad_alloc("BRLCAD::Object::Copy");
-                }
 
                 BU_UNSETJUMP;
             }
@@ -410,13 +400,13 @@
 }
 
 
-bool Object::Validate(void) const throw() {
+bool Object::Validate(void) const{
     const char* name = Name();
 
     return (name != 0) && (strlen(name) > 0);
 }
 
-const bu_attribute_value_set* Object::GetAvs(void) const throw() {
+const bu_attribute_value_set* Object::GetAvs(void) const{
     const bu_attribute_value_set* ret = 0;
 
     assert(!((m_pDir != RT_DIR_NULL) && (m_avs != 0)));
@@ -433,7 +423,7 @@
 bu_attribute_value_set* Object::GetAvs
 (
     bool create
-) throw() {
+){
     bu_attribute_value_set* ret = 0;
 
     assert(!((m_pDir != RT_DIR_NULL) && (m_avs != 0)));
