initial import

git-svn-id: https://joinup.ec.europa.eu/svn/pdf-as/trunk@545 7b5415b0-85f9-ee4d-85bd-d5d0c3b42d1c

1 files changed, 759 insertions, 0 deletions

diff --git a/Adobe_SigHandler/Adobe.PDF-AS-SigHandler/sources/import/API/CorCalls.h b/Adobe_SigHandler/Adobe.PDF-AS-SigHandler/sources/import/API/CorCalls.h
new file mode 100644
index 0000000..95183bd
--- /dev/null
+++ b/Adobe_SigHandler/Adobe.PDF-AS-SigHandler/sources/import/API/CorCalls.h
@@ -0,0 +1,759 @@
+/*********************************************************************

+

+ ADOBE SYSTEMS INCORPORATED

+ Copyright (C) 1994-2006 Adobe Systems Incorporated

+ All rights reserved.

+

+ NOTICE: Adobe permits you to use, modify, and distribute this file

+ in accordance with the terms of the Adobe license agreement

+ accompanying it. If you have received this file from a source other

+ than Adobe, then your use, modification, or distribution of it

+ requires the prior written permission of Adobe.

+

+ ---------------------------------------------------------------------

+

+ CorCalls.h

+

+ - Exception handling methods (ASPushExceptionFrame and

+   ASPopExceptionFrame) should typically be accessed through the

+   DURING/HANDLER/END_HANDLER macros.

+

+ ******************************************************************************************

+                        **** Instructions for Plugin Developers **** 

+   (In the instructions below ~ is used to refer to the HFT this file is for.  For

+     example, this file would be called "~Calls.h")

+  

+   To use this file you must declare two global variables: g~HFT and g~Version.  You can

+   see them declared as extern about one page down from here.  Your plugin should set a 

+   #define of PI_~_VERSION to some non zero value.  Suggested values are given below in

+   the "for public use" section.  ~HFT_LATEST_VERSION is not recommended because you will 

+   not be able to support backwards compatible versions.  It is recommended that you use the lowest 

+   ~HFT_VERSION you require.  Later versions are compatible with earlier versions, so if 

+   you require ~HFT_VERSION_4, your plugin will work with ~HFT_VERSION_5, ~HFT_VERSION_6, and so on.

+  

+   You can support old versions and still use newer versions of this HFT by checking the 

+   value of g~Version.  If you use the standard PiMain.c supplied in the SDK, this will be

+   set to the actual version of the HFT returned to you (For example, if you require version 4,

+   you are returned version 7, which is compatible, and g~Version is set to 7).  You can write

+   code that looks something like this:

+     if (g~Version >= ~HFT_VERSION_5) 

+        CallNewSpeedyCode();

+     else {

+        assert(g~Version >= ~HFT_VERSION_4);  //PI_~_VERSION was defined as ~HFT_VERSION_4

+        CallOldSlowCode();

+     }

+ ******************************************************************************************

+                         **** Instructions for HFT Developer **** 

+   (In the instructions below ~ is used to refer to the HFT this file is for.  For

+     example, this file would be called "~Calls.h")

+

+   Important: routines that have been released can never be deleted or changed.

+   If you want to make a new version, create a new call, add it to the end of this file and

+   increment _~_LATEST_VERSION (note the leading underscore).  

+   

+   If this is the first new routine in a new version, change the _~_IS_BETA flag

+   to 1.  Next, create a new ~_VERSION_# for plugins to use and set it to 

+   ~HFT_LATEST_VERSION.  For example, suppose the last release of Acrobat was version 20, version 21

+   is under development, and you add a new routine for version 21.  Increment _~HFT_LATEST_VERSION 

+   to 0x00200001 and set _~_IS_BETA to 1.  Add "#define ~HFT_VERSION_21 ~HFT_LATEST_VERSION".  

+   Add your routine and assert that g~Version >= ~HFT_VERSION_21.  Leave 

+   _~_LAST_BETA_COMPATIBLE_VERSION unchanged (0x00200000 in this example).

+

+   If the ~_IS_BETA flag is set to 1, you may change or delete the beta routines at will.

+   Before checking in the modifications, however, increment the _~HFT_LATEST_VERSION number.

+   If the change is not compatible (delete, change, and so on) set _~_LAST_BETA_COMPATIBLE_VERSION equal

+   to the new _~HFT_LATEST_VERSION.  If the change is compatible, leave the LAST_BETA version

+   as is.

+

+   Plugins that require a BETA HFT will be refused unless they ask for a beta version greater than or equal to

+   (>=) LAST_BETA_COMPATIBLE_VERSION and less than or equal to (<=) HFT_LATEST_VERSION.

+   By incrementing the version number, you ensure the plugin will refuse to load until it

+   has been recompiled with your changes.  You also ensure plugins compiled with your changes

+   will not load on older versions of Acrobat.  In other words, it makes sure both sides are in sync.  

+

+   Important: Whenever you make a change to this file, you must increment _~HFT_LATEST_VERSION.

+  

+   Once the product reaches RC or a similar milestone, change the _~_IS_BETA flag to 0, jump

+   the _~HFT_LATEST_VERSION to the final version (0x00210000 in our example), do the same for

+   _~_LAST_BETA_COMPATIBLE_VERSION, and set the 

+   ~HFT_VERSION_# to the final version number (0x00210000 in this example).  Once the HFT

+   has left beta, the routines cannot be changed and a new beta must ensue (beta for version

+   22 in this example).

+

+*********************************************************************/

+

+#ifndef _H_CorCalls

+#define _H_CorCalls

+

+#include "acroassert.h"

+

+/* This header includes templates and hence would not compile if 

+   included inside of a extern "C" block. Hence CorCalls.h must 

+   not be included inside of a extern "C" block */

+#include "EReturnValidator.h"

+

+/* for Adobe use only */

+#define _CoreHFT_LATEST_VERSION 0x00050000

+#define _CoreHFT_LAST_BETA_COMPATIBLE_VERSION 0x00050000

+#define _CoreHFT_IS_BETA 0

+

+/* for public use */

+#define CoreHFT_LATEST_VERSION (_CoreHFT_IS_BETA ? (kHFT_IN_BETA_FLAG | _CoreHFT_LATEST_VERSION) : _CoreHFT_LATEST_VERSION)

+

+#define CoreHFT_VERSION_2   0x00020000

+#define CoreHFT_VERSION_4   0x00040000

+#define CoreHFT_VERSION_5   0x00050000  /* note: version 5 is same as 4.  Provided to support old plugins that erroneously required 5 */

+

+#ifndef _CORVERSION_ID_ONLY

+#include "PIExcept.h"

+#include "CoreExpT.h"

+#include "ASExpT.h"

+

+#if PRAGMA_STRUCT_ALIGN

+	#pragma options align=power

+#endif

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+	

+#if !defined(USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS)

+	#if MAC_PLATFORM

+		#define USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS 1

+	#elif UNIX_PLATFORM

+		#define USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS 1

+	#else

+		#define USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS 0

+	#endif

+#endif

+	

+#if USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS

+#ifdef __cplusplus

+	

+	/* The C++ version of the exception frame structure contains only the

+	information necessary to execute a successful throw. The exception

+	error code and message are tracked in a separate class defined

+	here. */

+	

+	struct _miExceptionInfo {

+		_miExceptionInfo() {}

+		int dummy;

+	};

+	

+	/* This routine knows how to take an exception and 'throw' it to

+	a C++ DURING frame.

+	*/

+	extern void miThrowExceptionToHandler(void *asEnviron);

+	

+#endif /* __cplusplus */

+#endif /* USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS */

+

+#if ACROBAT_LIBRARY

+/* Toolkit specific Error-handling function prototypes */

+

+/* RestorePlugInFrame

+** This is a function that the plug-in must provide (if you are using the

+** standard government-issue PIMain.c, this function is implemented there.)

+** It takes a jmp_buf as registered through ASPushExceptionFrame and restores

+** state based on that jmp_buf, usually through using longjmp.

+*/

+extern ACCB1 void ACCB2 RestorePlugInFrame(void *environ);

+typedef ACCBPROTO1 void (ACCBPROTO2 *ACRestoreEnvironProc)(void *excEnviron);

+

+extern ACCB1 void ACCB2 ACPushExceptionFrame(void *excEnviron, ACRestoreEnvironProc restoreFunc);

+extern ACCB1 void ACCB2 ACPopExceptionFrame(void);

+extern ACCB1 ASInt32 ACCB2 ACGetExceptionErrorCode(void);

+

+#if USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS

+#ifdef __cplusplus

+

+struct _miExceptionPushPop {

+	_miExceptionPushPop() { ACPushExceptionFrame(NULL, (ACRestoreEnvironProc)&miThrowExceptionToHandler); }

+	~_miExceptionPushPop() { ACPopExceptionFrame(); }

+};

+

+/**

+	Begins the section of code where Acrobat APIs may throw an exception. After calling an Acrobat API method, execution may jump into the <code>HANDLER</code> clause. 

+	This macro is similar to the <code>try</code> clause in the C++ language.

+

+	@see END_HANDLER

+	@see E_RETURN

+	@see E_RTRN_VOID

+	@see HANDLER

+*/

+#define	DURING {											\

+	try {													\

+		_miExceptionPushPop __exceptionPushPop;

+	

+#define _E_RESTORE /*int _E_RESTORE__BogusLocalDoesNothing = 0*/

+#define _E_HANDLER } catch (_miExceptionInfo Exception) { 

+

+/**

+	Follows a <code>DURING</code> macro. Code inserted between <code>HANDLER</code> and <code>END_HANDLER</code> macros will be executed only if an Acrobat function or other function 

+	throws an exception. This macro is similar to the <code>catch</code> clause in the C++ language.

+

+	@see END_HANDLER

+	@see DURING

+	@see E_RTRN_VOID

+	@see E_RETURN

+*/

+#define	HANDLER	_E_RESTORE; _E_HANDLER _E_RESTORE;

+/**

+	Ends a <code>DURING/HANDLER/END_HANDLER</code> clause.

+

+	@see DURING

+	@see END_HANDLER

+	@see E_RETURN

+	@see HANDLER

+*/

+#define	END_HANDLER }}

+

+#else /* __cplusplus */

+

+#define DURING		DURING usage must be compiled with C++

+#define HANDLER		HANDLER usage must be compiled with C++

+#define END_HANDLER	END_HANDLER usage must be compiled with C++

+

+#endif /* __cplusplus */

+#else	/* USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS */

+

+#if MAC_PLATFORM

+#error Mac Xcode should no longer use this

+#endif

+

+#if UNIX_PLATFORM

+#error Unix should no longer use this

+#endif

+		

+/**

+	Begins the section of code where Acrobat APIs may throw an exception. After calling an Acrobat API method, execution may jump into the <code>HANDLER</code> clause. 

+	This macro is similar to the <code>try</code> clause in the C++ language.

+

+	@see END_HANDLER

+	@see E_RETURN

+	@see E_RTRN_VOID

+	@see HANDLER

+*/

+#define DURING {												\

+	ACROjmp_buf ASException;										\

+	ACPushExceptionFrame(&ASException, (ACRestoreEnvironProc)&RestorePlugInFrame);		\

+	if (!ACROsetjmp(ASException)) {

+

+#define _E_RESTORE      ACPopExceptionFrame()

+

+/**

+	Follows a <code>DURING</code> macro. Code inserted between <code>HANDLER</code> and <code>END_HANDLER</code> macros will be executed only if an Acrobat function or other function 

+	throws an exception. This macro is similar to the <code>catch</code> clause in the C++ language.

+

+	@see END_HANDLER

+	@see DURING

+	@see E_RTRN_VOID

+	@see E_RETURN

+*/

+#define HANDLER _E_RESTORE; } else { _E_RESTORE;

+/**

+	Ends a <code>DURING/HANDLER/END_HANDLER</code> clause.

+

+	@see DURING

+	@see END_HANDLER

+	@see E_RETURN

+	@see HANDLER

+*/

+#define END_HANDLER }}

+

+#endif	/* USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS */

+

+/**

+	A macro defined to call ASGetExceptionErrorCode(). It returns an ASInt32 object containing an exception error code.

+

+	@see DURING

+	@see END_HANDLER

+	@see E_RTRN_VOID

+	@see HANDLER

+*/

+#define ERRORCODE	(ACGetExceptionErrorCode())

+

+/**

+	Returns a value from an enclosing function when nested inside a DURING/HANDLER clause.

+

+	@see DURING

+	@see END_HANDLER

+	@see E_RTRN_VOID

+	@see HANDLER

+*/

+#define E_RETURN(x) { _E_RESTORE; return(x); }

+

+/**

+	Returns from an enclosing function when nested inside a DURING/HANDLER clause, without returning a value.

+

+	@see ErrGetCode

+	@see ErrGetSeverity

+	@see ErrGetSignedCode

+	@see ErrGetSystem

+*/

+#define E_RTRN_VOID { _E_RESTORE; return; }

+

+#else /* ACROBAT_LIBRARY */

+

+#define ACRestoreEnvironProc restoreEnvironProc

+

+#if !STATIC_HFT

+#define ACPushExceptionFrame ASPushExceptionFrame

+#define ACPopExceptionFrame  ASPopExceptionFrame

+#define ACGetExceptionErrorCode ASGetExceptionErrorCode

+#endif /* STATIC_HFT */

+

+#endif /* ACROBAT_LIBRARY */

+

+#ifdef NPROC /* may be defined in sys/procs.h */

+#undef NPROC

+#endif /* NPROC */

+	

+#if !PLUGIN

+	/* Static link */

+	#define NPROC(returnType, name, params)		\

+		ACEX1 returnType ACEX2 name params;

+	#define SPROC(returnType, name, params, stubProc) \

+  		extern ACEX1 returnType ACEX2 stubProc params;

+   #define ANPROC NPROC

+

+   #include "CorProcs.h"

+

+   #undef NPROC

+   #undef ANPROC

+   #undef SPROC	

+

+   #define ASCallbackCreateProto(proto, proc) (proc)

+   #define ASCallbackCreate(proc) (proc)

+   #define ASCallbackDestroy(proc) 

+

+	/* These functions have a different name internally */

+	#define ASPushExceptionFrame ACPushExceptionFrame

+	#define ASPopExceptionFrame ACPopExceptionFrame

+	#define ASGetExceptionErrorCode ACGetExceptionErrorCode

+	#define ASExtensionMgrGetHFT ASGetHFTByNameAndVersion

+#endif /* !PLUGIN */

+

+#if PLUGIN

+	/* HFT version */

+	#include "PIRequir.h"

+	

+	/* Enumerate the selectors */

+	#define NPROC(returnType, name, params)			\

+		name##SEL,

+	#define SPROC(returnType, name, params, stubProc) \

+		name##SEL,

+	

+   #define ANPROC NPROC	

+	enum {

+		CoreBAD_SELECTOR,

+		#include "CorProcs.h"

+		CoreNUMSELECTORSplusOne

+	};

+	

+	#define CoreNUMSELECTORS (CoreNUMSELECTORSplusOne - 1)

+	

+	/* Create the prototypes */

+	#undef NPROC

+   #undef ANPROC

+   #undef SPROC	

+	#define NPROC(returnType, name, params)		\

+		typedef ACCBPROTO1 returnType (ACCBPROTO2 *name##SELPROTO)params;

+	#define SPROC(returnType, name, params, stubProc) \

+		typedef ACCBPROTO1 returnType (ACCBPROTO2 *name##SELPROTO)params;

+	

+   #define ANPROC NPROC	

+		#include "CorProcs.h"

+	#undef NPROC

+   #undef ANPROC

+   #undef SPROC

+

+#if PI_CORE_VERSION != 0

+

+#ifdef THREAD_SAFE_PDFL

+	#define gCoreHFT (GetHFTLocations()->coreHFT)

+	#define gCoreVersion (GetHFTLocations()->coreVersion)

+#include "PDFLInitHFT.h"

+#else

+	extern HFT gCoreHFT;

+	extern ASUns32 gCoreVersion;

+#endif

+

+#include "PICommon.h"

+#include "PIExcept.h"

+

+#if !STATIC_HFT

+

+/* Exception-handling functions */

+

+/* ASRaise

+** Raises an exception.  Subsequent calls to ASGetExceptionErrorCode() will

+** return the error value passed in to this function.

+** This function is called directly by the macro RERAISE().

+*/

+#define ASRaise (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_2), *((ASRaiseSELPROTO)(gCoreHFT[ASRaiseSEL])))

+

+/* ASPushExceptionFrame

+**

+** Push an exception frame buffer and a frame-restoration callback onto the stack.

+** The restoreFunc should be a function matching the following prototype:

+**

+** ACCB1 void ACCB2 RestorePlugInFrame(void *asEnviron);

+**

+** You will probably never call ASPushExceptionFrame() directly; use the DURING

+** macro instead.

+*/

+#define ASPushExceptionFrame (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_2), *((ASPushExceptionFrameSELPROTO)(gCoreHFT[ASPushExceptionFrameSEL])))

+

+/* ASPopExceptionFrame

+** Pop and exception frame off the stack.

+** You will probably never call ASPopExceptionFrame() directly; it is called for

+** you as appropriate from within the HANDLER, E_RETURN and E_RTRN_VOID macros.

+*/

+#define ASPopExceptionFrame (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_2), *((ASPopExceptionFrameSELPROTO)(gCoreHFT[ASPopExceptionFrameSEL])))

+

+/* ASGetExceptionErrorCode

+** Returns the value of the error parameter as passed in to the most

+** recent call to ASRaise().  You might then pass this value to ASGetErrorString()

+** in order to report the exception to the user.

+*/

+#define ASGetExceptionErrorCode (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_2), *((ASGetExceptionErrorCodeSELPROTO)(gCoreHFT[ASGetExceptionErrorCodeSEL])))

+

+/* ASAtom management */

+

+/* ASAtomFromString

+** Returns the ASAtom associated with the given string.  You can compare

+** ASAtoms directly, rather than passing their associated strings to

+** strcmp().

+*/

+#define ASAtomFromString (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_2), *((ASAtomFromStringSELPROTO)(gCoreHFT[ASAtomFromStringSEL])))

+

+/* ASAtomExistsForString

+** Returns true if and only if there already exists an ASAtom for the

+** given string.  You might use this to prevent capricious overpopulation

+** of the internal ASAtom table (a non-renewable resource!)

+*/

+#define ASAtomExistsForString (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_2), *((ASAtomExistsForStringSELPROTO)(gCoreHFT[ASAtomExistsForStringSEL])))

+

+/* ASAtomGetString

+** Returns the char * associated with the given ASAtom.  This routine

+** permanently allocates storage for new strings, so don't call this function

+** unnecessarily!

+*/

+#define ASAtomGetString (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_2), *((ASAtomGetStringSELPROTO)(gCoreHFT[ASAtomGetStringSEL])))

+

+/* ASCallbackCreate

+** Takes a pointer to a function and returns an ASCallback--a universally

+** entrant function pointer which can be called from any globals context.

+*/

+/**

+	Deprecated in Acrobat 8.0.

+*/

+#define ASCallbackCreate(x) (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_2), *((ASCallbackCreateSELPROTO)(gCoreHFT[ASCallbackCreateSEL])))(gExtensionID, (void *)(x))

+

+/* ASCallbackCreateProto

+** Type-checking callback creation.  Will cause a compiler error if the

+** proc is not of the given function-type.  DEBUG must be on for checking to occur.

+** Requires four bytes of scratch global space in which to make a bogus

+** assignment; this is declared in PIMain.c.

+*/

+/**

+	Deprecated in Acrobat 8.0.

+*/

+#if DEBUG

+#define ASCallbackCreateProto(funcType, proc)				\

+	((funcType)ASCallbackCreate((CHECKTYPE(funcType, proc))))

+#else

+#define ASCallbackCreateProto(funcType, proc)				\

+	((funcType)ASCallbackCreate(((void*)proc)))

+#endif

+

+/* ASCallbackDestroy

+** De-allocates memory associated with an ASCallback.  Use this if you're

+** sure you're completely done with an ASCallback.

+*/

+/**

+	Deprecated in Acrobat 8.0.

+*/

+#define ASCallbackDestroy (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_2), *((ASCallbackDestroySELPROTO)(gCoreHFT[ASCallbackDestroySEL])))

+

+/* ASExtensionMgrGetHFT

+** Get an HFT object with the given name and version number.

+*/

+#define ASExtensionMgrGetHFT (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_2), *((ASExtensionMgrGetHFTSELPROTO)(gCoreHFT[ASExtensionMgrGetHFTSEL])))

+

+/* ASGetConfiguration

+** Returns a void * based on the ASAtom passed in.  The void *

+** may be cast to a meaningful value based on the input parameter:

+**

+** key                 result   	                 return type

+** Product             Name of product type 	     const char *

+**                       (Exchange, Reader, etc.)

+** CanEdit             Whether or not editing   	 ASBool

+**                       is allowed

+** <<anything else>>   UNDEFINED_CONFIGURATION_SELECTOR

+*/

+#define ASGetConfiguration (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_2), *((ASGetConfigurationSELPROTO)(gCoreHFT[ASGetConfigurationSEL])))

+

+

+/* begin PI_CORE_VERSION >= 0x00040000 */

+

+/* ASEnumExtensions */

+#define ASEnumExtensions (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_4), *((ASEnumExtensionsSELPROTO)(gCoreHFT[ASEnumExtensionsSEL])))

+

+/* ASExtensionGetFileName */

+#define ASExtensionGetFileName (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_4), *((ASExtensionGetFileNameSELPROTO) (gCoreHFT[ASExtensionGetFileNameSEL])))

+

+/* ASExtensionGetRegisteredName */

+#define ASExtensionGetRegisteredName (ACROASSERT(gCoreVersion >=CoreHFT_VERSION_4), *((ASExtensionGetRegisteredNameSELPROTO) (gCoreHFT[ASExtensionGetRegisteredNameSEL])))

+

+/* end PI_CORE_VERSION >= 0x00040000 */

+

+/* If you add, delete, or modify procs listed in this file please read the instructions at the top about how to properly change the version number */

+

+#endif /* !STATIC_HFT */

+

+/* Exception-handling macros */

+/**

+	Re-raises the most recently raised exception and passes it to the next exception handler in the stack.

+

+	@see ErrGetCode

+	@see ErrGetSeverity

+	@see ErrGetSignedCode

+	@see ErrGetSystem

+	@see ASRaise

+*/

+#define RERAISE() ASRaise(ERRORCODE)

+

+#if USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS

+#ifdef __cplusplus

+

+struct _miExceptionPushPop {

+	_miExceptionPushPop() { ACPushExceptionFrame(NULL, (ACRestoreEnvironProc)&miThrowExceptionToHandler); }

+	~_miExceptionPushPop() { ACPopExceptionFrame(); }

+};

+

+#endif /* __cplusplus */

+#else /* USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS */

+

+#if MAC_PLATFORM

+#error Mac Xcode should no longer use this

+#elif UNIX_PLATFORM

+#error Unix should no longer use this

+#endif

+		/* RestorePlugInFrame

+** This is a function that the plug-in must provide (if you are using the

+** standard government-issue PIMain.c, this function is implemented there.)

+** It takes a jmp_buf as registered through ASPushExceptionFrame and restores

+** state based on that jmp_buf, usually through using longjmp.

+*/

+extern ACCB1 void ACCB2 RestorePlugInFrame(void *asEnviron);

+

+#define _E_RESTORE      ASPopExceptionFrame()

+

+#endif /* USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS */

+

+#if DEBUG

+

+/* **ER - 11/29/1997

+

+   For debug builds, the macros below enable compile-time checking of common problems

+   with DURING and HANDLER blocks (in order of frequency):

+

+        1. "normal" return statements inside DURING blocks

+        2. E_RETURN or E_RTRN_VOID statements outside any DURING block

+        3. E_RETURN or E_RTRN_VOID statements in HANDLER blocks

+        4. HANDLER without matching DURING 

+        5. HANDLER without matching END_HANDLER 

+*/

+

+/* Declaration of global integer used below.  This variable needs to be defined

+   somewhere in the plug-in.  If you are using the standard government-issue PIMain.c,

+   it will already be defined there. */

+extern int gBadReturnCatcher;

+

+struct _BadReturnCatcherStruct {

+	int E_RETURNOutsideDURINGBlock;		/* This name chosen so it rings a bell if you

+										   see it in the compiler output */

+};

+

+/* What's the point of this? Since E_RETURN and E_RTRN_VOID need to actually

+   call return, we need to redefine gBadReturnCatcher as an integer in the

+   scope around the actual call to return so our macro-replaced version of

+   return will work.  Otherwise, when the "return" in the E_RETURN macro 

+   (for example), was replaced by our redefined macro, it'd fail to compile

+   just as if return was placed inside the DURING block */ 

+#define DO_RETURN(x)			{ int gBadReturnCatcher; return(x); }

+#define DO_RETURN_NO_ARGS		{ int gBadReturnCatcher; return; }

+

+#if USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS

+#ifdef __cplusplus

+

+#define DURING {											\

+	try {													\

+	_miExceptionPushPop __exceptionPushPop;					\

+	struct _BadReturnCatcherStruct gBadReturnCatcher;

+

+#define _E_RESTORE /*int _E_RESTORE__BogusLocalDoesNothing = 0*/

+#define _E_HANDLER } catch (_miExceptionInfo Exception) {

+

+#else /* __cplusplus */

+

+#define DURING		DURING usage must be compiled with C++

+#define _E_RESTORE	HANDLER usage must be compiled with C++

+#define _E_HANDLER	HANDLER usage must be compiled with C++

+

+#endif /* __cplusplus */

+#else /* USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS */

+

+#if MAC_PLATFORM

+#error Mac Xcode should no longer use this

+#elif UNIX_PLATFORM

+#error Unix should no longer use this

+#endif

+

+/* This definition of DURING includes a struct with the same name as the global 

+   integer above.  The struct must be declared inside the inner scope of the DURING

+   so it is NOT defined in the HANDLER! */

+#define DURING {												\

+			   ACROjmp_buf ASException;										\

+			   ASPushExceptionFrame(&ASException, &RestorePlugInFrame);		\

+			   if (!ACROsetjmp(ASException)) {								   \

+			   struct _BadReturnCatcherStruct gBadReturnCatcher;			   

+

+#define _E_HANDLER } else {

+

+#endif	/* USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS */

+				   

+#if DO_ADDITIONAL_RAISEAWARE_CHECKS

+

+/* Make sure that ASRaiseAware classes are not returned as part of the E_RETURN

+   mechanism as it leaves the wrong handler on the top of the exception stack.*/

+#define E_RETURN(x) { IsNotRaiseAwareClassHelperFunction( x ); gBadReturnCatcher.E_RETURNOutsideDURINGBlock = 1; _E_RESTORE; DO_RETURN(x); }

+

+#else

+

+/* Return calls which are legal inside a DURING block attempt

+   to modify the member field of the gBadReturnCatcher struct in the local 

+   scope.  This will cause a compile-time error if there is no such struct 

+   (and thus, the return call is not enclosed by a DURING block) */

+#define E_RETURN(x) { gBadReturnCatcher.E_RETURNOutsideDURINGBlock = 1; _E_RESTORE; DO_RETURN(x); }

+

+#endif

+

+#define E_RTRN_VOID { gBadReturnCatcher.E_RETURNOutsideDURINGBlock = 1; _E_RESTORE; DO_RETURN_NO_ARGS; }

+

+/* returns which are illegal inside a DURING block attempt

+   to modify the global integer gBadReturnCatcher.  This will cause a 

+   compile-time error if the return is inside a DURING block because

+   it will actually be an attempt to modify the local-scope struct of the

+   same name.  The = operator is not defined for assigning constant integers to structs.

+

+   Why are we using a for loop? Here are the considerations involved in choosing

+   this macro:

+

+   1. It must support return statements of the forms "return;", "return <expr>;", and

+      "return( <expr> );".  This is why "return" is present at the end of the macro

+   2. We must use only 1 statement in replacing return.  Why? Consider this code:

+

+	  if ( <expr> ) 

+		  return; 

+	  else {

+		  ...

+	  }

+

+	  In order to support this case, we must not replace the "return" statement with

+	  more than one statement, because this will cause the "else" statement to become

+	  untied from the "if" statement.  The following code snippet is an example of

+	  the above code snippet after a macro expansion where return is defined as multiple

+	  statements.  

+

+	  if ( <expr> )

+	       gBadReturnCatcher = 1;

+		   return;

+	  else {

+		...

+	  }

+	3. If we are constrained to replace the "return" statement with only one statement,

+	   there may only be one path of control, and it must reach the return statement

+	   at the end of the macro (so that it can pick up its arguments, if there are any)

+

+    The do-nothing for loop below meets these criteria.   

+*/

+#define return for( gBadReturnCatcher = 1;; ) return

+

+/* Why is HANDLER redefined? 

+   1. So you can't put a HANDLER in without a matching DURING.  This would likely be caught

+   by the compiler anyhow, since there'd likely be an "else" without a matching "if"

+   2. To facilitate catching END_HANDLERs without matching HANDLERs

+   3) To get rid of pesky "unreferenced local variable" warnings stemming from 

+   DURING blocks which don't contain E_RETURN or E_RTRN_VOID and thus don't 

+   reference the local gBadReturnCatcher structure. */

+#define HANDLER _E_RESTORE; gBadReturnCatcher.E_RETURNOutsideDURINGBlock = 1; _E_HANDLER int ENDHANDLEROutsideHANDLER; _E_RESTORE;

+

+/* END_HANDLER is redefined to modify the BadEndHandlerCatcher variable defined by the HANDLER

+   macro.  This will prevent END_HANDLERs without matching HANDLERs (unless, of course, 

+   multiple END_HANDLER statements are found inside the same HANDLER, END_HANDLER block */

+#define END_HANDLER ENDHANDLEROutsideHANDLER = 1; }}

+

+#else	/* !DEBUG */

+

+#if USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS

+#ifdef __cplusplus

+

+#define	DURING {											\

+	try {													\

+		_miExceptionPushPop __exceptionPushPop;

+			

+#define _E_RESTORE /*int _E_RESTORE__BogusLocalDoesNothing = 0*/

+#define _E_HANDLER } catch (_miExceptionInfo Exception) { 

+	

+#define	HANDLER	_E_RESTORE; _E_HANDLER _E_RESTORE;

+#define	END_HANDLER }}

+

+#else /* __cplusplus */

+

+#define DURING		DURING usage must be compiled with C++

+#define HANDLER		HANDLER usage must be compiled with C++

+#define END_HANDLER	END_HANDLER usage must be compiled with C++

+

+#endif /* __cplusplus */

+#else	/* USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS */

+

+#if MAC_PLATFORM

+#error Mac Xcode should no longer use this

+#elif UNIX_PLATFORM

+#error Unix should no longer use this

+#endif

+

+#define DURING {												\

+	ACROjmp_buf ASException;										\

+	ASPushExceptionFrame(&ASException, &RestorePlugInFrame);		\

+	if (!ACROsetjmp(ASException)) {

+

+#define HANDLER _E_RESTORE; } else { _E_RESTORE;

+#define END_HANDLER }}

+

+#endif /* USE_CPLUSPLUS_EXCEPTIONS_FOR_ASEXCEPTIONS */

+

+#define E_RETURN(x) { _E_RESTORE; return(x); }

+#define E_RTRN_VOID { _E_RESTORE; return; }

+

+#endif /* DEBUG */

+

+#define ERRORCODE	(ASGetExceptionErrorCode())

+

+#endif /* PI_CORE_VERSION != 0 */

+

+#endif /* PLUGIN */

+

+#if PRAGMA_STRUCT_ALIGN

+	#pragma options align=reset

+#endif

+

+#ifdef __cplusplus

+}

+#endif

+#endif /* _CORVERSION_ID_ONLY */

+#endif /* !defined(_H_CorCalls) */

+