aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/include/DPS/dpsexcept.h
diff options
context:
space:
mode:
authorReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
committerReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
commitf4092abdf94af6a99aff944d6264bc1284e8bdd4 (patch)
tree2ac1c9cc16ceb93edb2c4382c088dac5aeafdf0f /nx-X11/include/DPS/dpsexcept.h
parenta840692edc9c6d19cd7c057f68e39c7d95eb767d (diff)
downloadnx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.gz
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.bz2
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.zip
Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1
Summary: Imported nx-X11-3.1.0-1.tar.gz Keywords: Imported nx-X11-3.1.0-1.tar.gz into Git repository
Diffstat (limited to 'nx-X11/include/DPS/dpsexcept.h')
-rw-r--r--nx-X11/include/DPS/dpsexcept.h257
1 files changed, 257 insertions, 0 deletions
diff --git a/nx-X11/include/DPS/dpsexcept.h b/nx-X11/include/DPS/dpsexcept.h
new file mode 100644
index 000000000..7daf70195
--- /dev/null
+++ b/nx-X11/include/DPS/dpsexcept.h
@@ -0,0 +1,257 @@
+/*
+ * dpsexcept.h -- exception handling for the DPS client library
+ *
+ * (c) Copyright 1984-1994 Adobe Systems Incorporated.
+ * All rights reserved.
+ *
+ * Permission to use, copy, modify, distribute, and sublicense this software
+ * and its documentation for any purpose and without fee is hereby granted,
+ * provided that the above copyright notices appear in all copies and that
+ * both those copyright notices and this permission notice appear in
+ * supporting documentation and that the name of Adobe Systems Incorporated
+ * not be used in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission. No trademark license
+ * to use the Adobe trademarks is hereby granted. If the Adobe trademark
+ * "Display PostScript"(tm) is used to describe this software, its
+ * functionality or for any other purpose, such use shall be limited to a
+ * statement that this software works in conjunction with the Display
+ * PostScript system. Proper trademark attribution to reflect Adobe's
+ * ownership of the trademark shall be given whenever any such reference to
+ * the Display PostScript system is made.
+ *
+ * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR
+ * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
+ * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE
+ * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT
+ * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE.
+ *
+ * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems
+ * Incorporated which may be registered in certain jurisdictions
+ *
+ * Author: Adobe Systems Incorporated
+ */
+/* $XFree86$ */
+
+/*
+Original version: Jeffrey Mogul, Stanford, 18 February 1983
+*/
+
+#ifndef DPSEXCEPT_H
+#define DPSEXCEPT_H
+
+/* If the macro setjmp_h is defined, it is the #include path to be used
+ instead of <setjmp.h>
+ */
+#ifdef setjmp_h
+#include setjmp_h
+#else /* setjmp_h */
+#ifdef VAXC
+#include setjmp
+#else /* VAXC */
+#include <setjmp.h>
+#endif /* VAXC */
+#endif /* setjmp_h */
+
+/*
+ This interface defines a machine-independent exception handling
+ facility. It depends only on the availability of setjmp and longjmp.
+ Note that we depend on native setjmp and longjmp facilities; it's
+ not possible to interpose a veneer due to the way setjmp works.
+ (In fact, in ANSI C, setjmp is a macro, not a procedure.)
+
+ The exception handler is largely defined by a collection of macros
+ that provide some additional "syntax". A stretch of code that needs
+ to handle exceptions is written thus:
+
+ DURING
+ statement1;
+ statement2;
+ ...
+ HANDLER
+ statement3
+ statement4;
+ ...
+ END_HANDLER
+
+ The meaning of this is as follows. Normally, the statements between
+ DURING and HANDLER are executed. If no exception occurs, the statements
+ between HANDLER and END_HANDLER are bypassed; execution resumes at the
+ statement after END_HANDLER.
+
+ If an exception is raised while executing the statements between
+ DURING and HANDLER (including any procedure called from those statements),
+ execution of those statements is aborted and control passes to the
+ statements between HANDLER and END_HANDLER. These statements
+ comprise the "exception handler" for exceptions occurring between
+ the DURING and the HANDLER.
+
+ The exception handler has available to it two local variables,
+ Exception.Code and Exception.Message, which are the values passed
+ to the call to RAISE that generated the exception (see below).
+ These variables have valid contents only between HANDLER and
+ END_HANDLER.
+
+ If the exception handler simply falls off the end (or returns, or
+ whatever), propagation of the exception ceases. However, if the
+ exception handler executes RERAISE, the exception is propagated to
+ the next outer dynamically enclosing occurrence of DURING ... HANDLER.
+
+ There are two usual reasons for wanting to handle exceptions:
+
+ 1. To clean up any local state (e.g., deallocate dynamically allocated
+ storage), then allow the exception to propagate further. In this
+ case, the handler should perform its cleanup, then execute RERAISE.
+
+ 2. To recover from certain exceptions that might occur, then continue
+ normal execution. In this case, the handler should perform a
+ "switch" on Exception.Code to determine whether the exception
+ is one it is prepared to recover from. If so, it should perform
+ the recovery and just fall through; if not, it should execute
+ RERAISE to propagate the exception to a higher-level handler.
+
+ It is ILLEGAL to execute a statement between DURING and HANDLER
+ that would transfer control outside of those statements. In particular,
+ "return" is illegal (an unspecified malfunction will occur).
+ To perform a "return", execute E_RETURN_VOID; to perform a "return(x)",
+ execute E_RETURN(x). This restriction does not apply to the statements
+ between HANDLER and END_HANDLER.
+
+ Note that in an environment with multiple contexts (i.e., multiple
+ coroutines), each context has its own stack of nested exception
+ handlers. An exception is raised within the currently executing
+ context and transfers control to a handler in the same context; the
+ exception does not propagate across context boundaries.
+ */
+
+
+/* Data structures */
+
+typedef struct _Exc_buf_x {
+ struct _Exc_buf_x *Prev; /* exception chain back-pointer */
+ jmp_buf Environ; /* saved environment */
+ char *Message; /* Human-readable cause */
+ int Code; /* Exception code */
+} _Exc_Buf;
+
+extern _Exc_Buf *_Exc_Header; /* global exception chain header */
+
+
+/* Macros defining the exception handler "syntax":
+ DURING statements HANDLER statements END_HANDLER
+ (see the description above)
+ */
+
+#define _E_RESTORE _Exc_Header = Exception.Prev
+
+#define DURING {_Exc_Buf Exception;\
+ Exception.Prev=_Exc_Header;\
+ _Exc_Header= &Exception;\
+ if (! setjmp(Exception.Environ)) {
+
+#define HANDLER _E_RESTORE;} else {
+
+#define END_HANDLER }}
+
+#define E_RETURN(x) {_E_RESTORE; return(x);}
+
+#define E_RTRN_VOID {_E_RESTORE; return;}
+
+
+/* Exported Procedures */
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+extern void DPSRaise(int Code, char *Message);
+/* Initiates an exception; always called via the RAISE macro.
+ This procedure never returns; instead, the stack is unwound and
+ control passes to the beginning of the exception handler statements
+ for the innermost dynamically enclosing occurrence of
+ DURING ... HANDLER. The Code and Message arguments are passed to
+ that handler as described above.
+
+ It is legal to call DPSRaise from within a "signal" handler for a
+ synchronous event such as floating point overflow. It is not reasonable
+ to do so from within a "signal" handler for an asynchronous event
+ (e.g., interrupt), since the exception handler's data structures
+ are not updated atomically with respect to asynchronous events.
+
+ If there is no dynamically enclosing exception handler, DPSRaise
+ writes an error message to os_stderr and aborts with DPSCantHappen.
+ */
+
+extern void DPSCantHappen(void);
+/* Calls abort. This is used only to handle "impossible" errors;
+ there is no recovery, and DPSCantHappen does not return.
+ */
+
+
+/* The following two operations are invoked only from the exception
+ handler macros and from the DPSRaise procedure. Note that they are
+ not actually declared here but in <setjmp.h> (or a substitute
+ specified by the macro SETJMP, above).
+
+ Note that the exception handler facility uses setjmp/longjmp in
+ a stylized way that may not require the full generality of the
+ standard setjmp/longjmp mechanism. In particular, setjmp is never
+ called during execution of a signal handler; thus, the signal
+ mask saved by setjmp can be constant rather than obtained from
+ the operating system on each call. This can have considerable
+ performance consequences.
+ */
+
+#if 0
+extern int setjmp(jmp_buf buf);
+/* Saves the caller's environment in the buffer (which is an array
+ type and therefore passed by pointer), then returns the value zero.
+ It may return again if longjmp is executed subsequently (see below).
+ */
+
+extern void longjmp(jmp_buf buf, int value);
+/* Restores the environment saved by an earlier call to setjmp,
+ unwinding the stack and causing setjmp to return again with
+ value as its return value (which must be non-zero).
+ The procedure that called setjmp must not have returned or
+ otherwise terminated. The saved environment must be at an earlier
+ place on the same stack as the call to longjmp (in other words,
+ it must not be in a different coroutine). It is legal to call
+ longjmp in a signal handler and to restore an environment
+ outside the signal handler; longjmp must be able to unwind
+ the signal cleanly in such a case.
+ */
+#endif /* 0 */
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+/* In-line Procedures */
+
+#define RAISE DPSRaise
+/* See DPSRaise above; defined as a macro simply for consistency */
+
+#define RERAISE RAISE(Exception.Code, Exception.Message)
+/* Called from within an exception handler (between HANDLER and
+ END_HANDLER), propagates the same exception to the next outer
+ dynamically enclosing exception handler; does not return.
+ */
+
+/*
+ Error code enumerations
+
+ By convention, error codes are divided into blocks belonging to
+ different components of the Display PostScript system.
+
+ Negative error codes and the codes between 0 and 999 (inclusive) are
+ reserved for use by the Display PostScript system.
+ */
+
+#define dps_err_base 1000
+
+#endif /* DPSEXCEPT_H */