1 files changed, 304 insertions, 0 deletions
diff --git a/libparted/exception.c b/libparted/exception.c
new file mode 100644
index 0000000..eb9086e
--- /dev/null
+++ b/libparted/exception.c
@@ -0,0 +1,304 @@
+/*
+    libparted - a library for manipulating disk partitions
+    Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+/** \file exception.c */
+
+/**
+ * \addtogroup PedException
+ *
+ * \brief Exception handling.
+ * 
+ * There are a few types of exceptions: PED_EXCEPTION_INFORMATION,
+ * PED_EXCEPTION_WARNING, PED_EXCEPTION_ERROR, PED_EXCEPTION_FATAL,
+ * PED_EXCEPTION_BUG.
+ *
+ * They are "thrown" when one of the above events occur while executing
+ * a libparted function. For example, if ped_device_open() fails
+ * because the device doesn't exist, an exception will be thrown.
+ * Exceptions contain text describing what the event was. It will give
+ * at least one option for resolving the exception: PED_EXCEPTION_FIX,
+ * PED_EXCEPTION_YES, PED_EXCEPTION_NO, PED_EXCEPTION_OK, PED_EXCEPTION_RETRY,
+ * PED_EXCEPTION_IGNORE, PED_EXCEPTION_CANCEL. After an exception is thrown,
+ * there are two things that can happen:
+ *
+ * -# an exception handler is called, which selects how the exception should be
+ *    resolved (usually by asking the user). Also note: an exception handler may
+ *    choose to return PED_EXCEPTION_UNHANDLED. In this case, a default action
+ *    will be taken by libparted (respectively the code that threw the
+ *    exception). In general, a default action will be "safe".
+ * -# the exception is not handled, because the caller of the function wants to
+ *    handle everything itself. In this case, PED_EXCEPTION_UNHANDLED is
+ *    returned.
+ *
+ * @{
+ */
+
+#include "config.h"
+
+#include <parted/parted.h>
+#include <parted/debug.h>
+
+#define N_(String) String
+#if ENABLE_NLS
+#  include <libintl.h>
+#  define _(String) dgettext (PACKAGE, String)
+#else
+#  define _(String) (String)
+#endif /* ENABLE_NLS */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+int				ped_exception = 0;
+
+static PedExceptionOption default_handler (PedException* ex);
+
+static PedExceptionHandler*	ex_handler = default_handler;
+static PedException*		ex = NULL;
+static int			ex_fetch_count = 0;
+
+static char*	type_strings [] = {
+	N_("Information"),
+	N_("Warning"),
+	N_("Error"),
+	N_("Fatal"),
+	N_("Bug"),
+	N_("No Implementation")
+};
+
+static char*	option_strings [] = {
+	N_("Fix"),
+	N_("Yes"),
+	N_("No"),
+	N_("OK"),
+	N_("Retry"),
+	N_("Ignore"),
+	N_("Cancel")
+};
+
+/**
+ *  Return a string describing an exception type.
+ */
+char*
+ped_exception_get_type_string (PedExceptionType ex_type)
+{
+	return type_strings [ex_type - 1];
+}
+
+/* FIXME: move this out to the prospective math.c */
+/* FIXME: this can probably be done more efficiently */
+static int
+ped_log2 (int n)
+{
+	int x;
+
+        PED_ASSERT (n > 0, return -1);
+
+	for (x=0; 1 << x <= n; x++);
+
+	return x - 1;
+}
+
+/**
+ * Return a string describing an exception option.
+ */
+char*
+ped_exception_get_option_string (PedExceptionOption ex_opt)
+{
+	return option_strings [ped_log2 (ex_opt)];
+}
+
+static PedExceptionOption
+default_handler (PedException* ex)
+{
+	if (ex->type == PED_EXCEPTION_BUG)
+		fprintf (stderr,
+			_("A bug has been detected in GNU Parted.  "
+			"Refer to the web site of parted "
+			"http://www.gnu.org/software/parted/parted.html "
+			"for more informations of what could be useful "
+			"for bug submitting!  "
+			"Please email a bug report to "
+			"bug-parted@gnu.org containing at least the "
+			"version (%s) and the following message:  "),
+			VERSION);
+	else
+		fprintf (stderr, "%s: ",
+			 ped_exception_get_type_string (ex->type));
+	fprintf (stderr, "%s\n", ex->message);
+
+	switch (ex->options) {
+		case PED_EXCEPTION_OK:
+		case PED_EXCEPTION_CANCEL:
+		case PED_EXCEPTION_IGNORE:
+			return ex->options;
+
+		default:
+			return PED_EXCEPTION_UNHANDLED;
+	}
+}
+
+/**
+ * Set the exception handler.
+ *
+ * The exception handler should return ONE of the options set in ex->options,
+ * indicating the way the event should be resolved.
+ */
+void
+ped_exception_set_handler (PedExceptionHandler* handler)
+{
+	if (handler)
+		ex_handler = handler;
+	else
+		ex_handler = default_handler;
+}
+
+/**
+ * Get the current exception handler.
+ */
+PedExceptionHandler *
+ped_exception_get_handler (void)
+{
+	if (ex_handler)
+		return ex_handler;
+	return default_handler;
+}
+
+/**
+ * Assert that the current exception has been resolved.
+ */
+void
+ped_exception_catch ()
+{
+	if (ped_exception) {
+		ped_exception = 0;
+
+		ped_free (ex->message);
+		ped_free (ex);
+		ex = NULL;
+	}
+}
+
+static PedExceptionOption
+do_throw ()
+{
+	PedExceptionOption	ex_opt;
+
+	ped_exception = 1;
+
+	if (ex_fetch_count) {
+		return PED_EXCEPTION_UNHANDLED;
+	} else {
+		ex_opt = ex_handler (ex);
+		ped_exception_catch ();
+		return ex_opt;
+	}
+}
+
+/**
+ * Throw an exception.
+ *
+ * You can also use this in a program using libparted.
+ * "message" is a printf-like format string, so you can do 
+ *
+ * \code
+ * ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_RETRY_CANCEL,
+ *      "Can't open %s", file_name);
+ * \endcode
+ *
+ * Returns the option selected to resolve the exception. If the exception was
+ * unhandled, PED_EXCEPTION_UNHANDLED is returned.
+ */
+PedExceptionOption
+ped_exception_throw (PedExceptionType ex_type,
+		     PedExceptionOption ex_opts, const char* message, ...)
+{
+	va_list		arg_list;
+
+	if (ex)
+		ped_exception_catch ();
+
+	ex = (PedException*) malloc (sizeof (PedException));
+	if (!ex)
+		goto no_memory;
+
+	ex->message = (char*) malloc (8192);
+	if (!ex->message)
+		goto no_memory;
+
+	ex->type = ex_type;
+	ex->options = ex_opts;
+
+	va_start (arg_list, message);
+	vsnprintf (ex->message, 8192, message, arg_list);
+	va_end (arg_list);
+
+	return do_throw ();
+
+no_memory:
+	fprintf (stderr, "Out of memory in exception handler!\n");
+
+	va_start (arg_list, message);
+	vfprintf (stderr, message, arg_list);
+	va_end (arg_list);
+
+	return PED_EXCEPTION_UNHANDLED;
+}
+
+/**
+ * Rethrow an unhandled exception.
+ * This means repeating the last ped_exception_throw() statement.
+ */
+PedExceptionOption
+ped_exception_rethrow ()
+{
+	return do_throw ();
+}
+
+/**
+ * Indicates that exceptions should not go to the exception handler, but
+ * passed up to the calling function(s).  All calls to
+ * ped_exception_throw() will return PED_EXCEPTION_UNHANDLED.
+ */
+void
+ped_exception_fetch_all ()
+{
+	ex_fetch_count++;
+}
+
+/**
+ * Indicates that the calling function does not want to accept any
+ * responsibility for exceptions any more.
+ *
+ * \note a caller of that function may still want responsibility, so
+ *      ped_exception_throw() may not invoke the exception handler.
+ *
+ * \warning every call to this function must have a preceding
+ *      ped_exception_fetch_all().
+ */
+void
+ped_exception_leave_all ()
+{
+	PED_ASSERT (ex_fetch_count > 0, return);
+	ex_fetch_count--;
+}
+
+/** @} */
+