Initial import of the CDE 2.1.30 sources from the Open Group.

cde/programs/dtinfo/DtMmdb/dti_excs/Exception.C

@@ -0,0 +1,235 @@
+// $XConsortium: Exception.C /main/4 1996/10/04 09:40:25 drk $
+#ifndef NATIVE_EXCEPTIONS
+#include "Exceptions.hh"
+#include <memory.h>
+
+Exception *Exception::g_current_exception;
+
+#ifdef C_API
+char*  Exception::g_temp_space = 0;
+char *Exception::g_next_avail = 0;
+#else
+char  Exception::g_temp_space[G_TEMP_SPACE_SIZE];
+char *Exception::g_next_avail = Exception::g_temp_space;
+#endif
+
+// /////////////////////////////////////////////////////////////////
+// class constructor
+// /////////////////////////////////////////////////////////////////
+
+Exception::Exception()
+: f_line(0), f_thrown_as_pointer(1), f_thrown(0), f_temporary(0)
+{
+  PRINTF (("Constructed Exception obj @ %p\n", this));
+}
+
+
+// /////////////////////////////////////////////////////////////////
+// operator delete
+// /////////////////////////////////////////////////////////////////
+
+void
+Exception::operator delete (void *place)
+{
+  // Move pointer back if it's in our temp space, else just free it. 
+  if (place >= g_temp_space && place < g_temp_space + G_TEMP_SPACE_SIZE)
+    {
+      g_next_avail = (char *) place;
+      PRINTF (("De-alloc EXC @ %p\n", place));
+    }
+  else
+    {
+      free ((char *) place);
+    }
+}
+
+
+// /////////////////////////////////////////////////////////////////
+// operator new
+// /////////////////////////////////////////////////////////////////
+
+// int arg is only used for type matching to insure that our version
+//  of new gets called to make temporaries. 
+
+void *
+Exception::operator new (size_t size, int)
+{
+  if (g_next_avail + size <= g_temp_space + G_TEMP_SPACE_SIZE)
+    {
+      void *p = g_next_avail;
+      g_next_avail += size;
+      PRINTF (("Allocate EXC @ %p, size = %ld\n", p, (long)size));
+      return (p);
+    }
+  else
+    {
+      Exceptions::error (Exceptions::f_msg_out_of_exception_memory,
+			 Exceptions::INTERNAL_ERROR);
+      terminate();
+    }
+}
+
+
+// /////////////////////////////////////////////////////////////////
+// throw_it
+// /////////////////////////////////////////////////////////////////
+
+// According to ARM, 15.2c temporary object thrown is of the static
+// type of the operand to throw, so this method must be non-virtual.
+// A non-virtual version of this function is created with macros in
+// each subclass of the Exception object.  See Exception.hh. 
+
+void
+Exception::throw_it (unsigned int line, const char *file, int dbg)
+{
+  // NOTE: This is the only place we can detect a throw of a pointer
+  // to a stack based object.
+
+  Exception *temp;
+  PRINTF (("Preparing to throw Exception object at %p:\n", this));
+
+  // Only make a temporary if the exception object is on the stack.
+  if (in_stack())
+    {
+      PRINTF (("  Exception is on the stack - copying it\n"));
+      // Use the special new operator which allocates the exception
+      // in reserved storage if there's no memory available.
+      temp = new (0) Exception (*this);
+      // We created it, so we should delete it. 
+      temp->f_temporary = 1;
+    }
+  else
+    {
+      PRINTF (("  Exception is on the heap\n"));
+      temp = this;
+    }
+
+  temp->do_throw (line, file, dbg);
+}
+
+
+// /////////////////////////////////////////////////////////////////
+// throw - throw the current exception
+// /////////////////////////////////////////////////////////////////
+
+void
+Exception::do_throw (unsigned int line, const char *file, int debugging)
+{
+#ifdef EXC_DEBUG
+  if (f_line == 0)
+    {
+      PRINTF (("========== Throwing exception ==========\n"));
+    }
+  else // must be a rethrow 
+    {
+      PRINTF (("========== Re-throwing exception ==========\n"));
+    }
+#endif
+  
+  // Save line and file if we don't already have it.
+  if (f_line == 0)
+    {
+      f_line = line;
+      f_file = file;
+    }
+
+  f_thrown = 1;
+  Jump_Environment::unwind_and_jump (this, debugging);
+}
+
+
+// /////////////////////////////////////////////////////////////////
+// current_exception - return the current exception
+// /////////////////////////////////////////////////////////////////
+
+Exception &
+Exception::current_exception()
+{
+  if (g_current_exception == NULL)
+    {
+      Exceptions::error (Exceptions::f_msg_no_current_exception,
+			 Exceptions::APPLICATION_ERROR);
+      terminate();
+    }
+
+  return (*g_current_exception);
+}
+
+
+// /////////////////////////////////////////////////////////////////
+// (un)make_current - (un)make this exception the current one
+// /////////////////////////////////////////////////////////////////
+
+void
+Exception::unmake_current()
+{
+  PRINTF (("Current Exc POP %p <-- %p\n",
+	   g_current_exception, f_previous_exception));
+  if (this != g_current_exception)
+    {
+      Exceptions::error ("Popped exception is the current one!",
+			 Exceptions::INTERNAL_ERROR);
+      terminate();
+    }
+
+  // Called when a catch clause is exited. 
+  g_current_exception = f_previous_exception;
+}
+
+
+void
+Exception::make_current()
+{
+  PRINTF (("Current Exc PUSH --> %p\n", this));
+  f_previous_exception = g_current_exception;
+  g_current_exception = this;
+}
+
+
+// /////////////////////////////////////////////////////////////////
+// relocate - move this exception to the current top of stack
+// /////////////////////////////////////////////////////////////////
+
+void
+Exception::relocate (Exception **exception, int length)
+{
+  PRINTF (("Moving %p --> %p (%d bytes)\n",
+	   *exception, g_next_avail, length));
+  // Slide the specified exception down to fill the hole below it.
+  if (g_next_avail >= (char *) *exception)
+    abort();
+  memcpy (g_next_avail, *exception, length);
+  *exception = (Exception *) g_next_avail;
+  g_next_avail = ((char *) *exception) + length;
+}
+
+
+// /////////////////////////////////////////////////////////////////
+// is - return true this class is of type TYPE
+// /////////////////////////////////////////////////////////////////
+
+int
+Exception::is (const char *type, const char *this_class)
+{
+  PRINTF (("Type specified is <%s>\n", type));
+  
+  while (isalnum (*type) && isalnum (*this_class) &&
+	 *type++ == *this_class++);
+  if (isalnum (*type) || isalnum (*this_class))
+    return (0);
+
+  // Check for pointer types
+  while (isspace (*type))
+    {
+      type++;
+    }
+  PRINTF (("  var part is <%s>\n", type));
+
+  // See if one's a pointer and the other isn't. 
+  if (*type == '*' && !f_thrown_as_pointer ||
+      *type != '*' &&  f_thrown_as_pointer)
+    return (0);
+  // Otherwise they are either both pointers or both objects/references.
+  return (1);
+}
+#endif /* NATIVE_EXCEPTIONS */