diff options
Diffstat (limited to 'common/quicktime_win32/MixedMode.h')
| -rw-r--r-- | common/quicktime_win32/MixedMode.h | 818 |
1 files changed, 818 insertions, 0 deletions
diff --git a/common/quicktime_win32/MixedMode.h b/common/quicktime_win32/MixedMode.h new file mode 100644 index 0000000..1bf0907 --- /dev/null +++ b/common/quicktime_win32/MixedMode.h @@ -0,0 +1,818 @@ +/* + File: MixedMode.h + + Contains: Mixed Mode Manager Interfaces. + + Version: QuickTime 7.3 + + Copyright: (c) 2007 (c) 1992-2001 by Apple Computer, Inc., all rights reserved. + + Bugs?: For bug reports, consult the following page on + the World Wide Web: + + http://developer.apple.com/bugreporter/ + +*/ +#ifndef __MIXEDMODE__ +#define __MIXEDMODE__ + +#ifndef __MACTYPES__ +#include <MacTypes.h> +#endif + + + + +#if PRAGMA_ONCE +#pragma once +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#if PRAGMA_IMPORT +#pragma import on +#endif + +#if PRAGMA_STRUCT_ALIGN + #pragma options align=mac68k +#elif PRAGMA_STRUCT_PACKPUSH + #pragma pack(push, 2) +#elif PRAGMA_STRUCT_PACK + #pragma pack(2) +#endif + +/* Mixed Mode constants */ +/* Current Routine Descriptor Version */ +enum { + kRoutineDescriptorVersion = 7 +}; + +/* MixedModeMagic Magic Cookie/Trap number */ +enum { + _MixedModeMagic = 0xAAFE +}; + +/* MixedModeState Version for CFM68K Mixed Mode */ +enum { + kCurrentMixedModeStateRecord = 1 +}; + +/* Calling Conventions */ +typedef unsigned short CallingConventionType; +enum { + kPascalStackBased = 0, + kCStackBased = 1, + kRegisterBased = 2, + kD0DispatchedPascalStackBased = 8, + kD1DispatchedPascalStackBased = 12, + kD0DispatchedCStackBased = 9, + kStackDispatchedPascalStackBased = 14, + kThinkCStackBased = 5 +}; + +/* ISA Types */ +typedef SInt8 ISAType; +enum { + kM68kISA = 0, + kPowerPCISA = 1 +}; + +/* RTA Types */ +typedef SInt8 RTAType; +enum { + kOld68kRTA = 0 << 4, + kPowerPCRTA = 0 << 4, + kCFM68kRTA = 1 << 4 +}; + + +#if TARGET_OS_MAC + #if TARGET_CPU_PPC + #define GetCurrentISA() ((ISAType) kPowerPCISA) + #define GetCurrentRTA() ((RTAType) kPowerPCRTA) + #elif TARGET_CPU_68K + #define GetCurrentISA() ((ISAType) kM68kISA) + #if TARGET_RT_MAC_CFM + #define GetCurrentRTA() ((RTAType) kCFM68kRTA) + #else + #define GetCurrentRTA() ((RTAType) kOld68kRTA) + #endif + + #endif + #define GetCurrentArchitecture() (GetCurrentISA() | GetCurrentRTA()) +#else + #define GetCurrentArchitecture() 0 +#endif + +/* Constants for specifing 68k registers */ +enum { + kRegisterD0 = 0, + kRegisterD1 = 1, + kRegisterD2 = 2, + kRegisterD3 = 3, + kRegisterD4 = 8, + kRegisterD5 = 9, + kRegisterD6 = 10, + kRegisterD7 = 11, + kRegisterA0 = 4, + kRegisterA1 = 5, + kRegisterA2 = 6, + kRegisterA3 = 7, + kRegisterA4 = 12, + kRegisterA5 = 13, + kRegisterA6 = 14, /* A7 is the same as the PowerPC SP */ + kCCRegisterCBit = 16, + kCCRegisterVBit = 17, + kCCRegisterZBit = 18, + kCCRegisterNBit = 19, + kCCRegisterXBit = 20 +}; + +typedef unsigned short registerSelectorType; +/* SizeCodes we use everywhere */ +enum { + kNoByteCode = 0, + kOneByteCode = 1, + kTwoByteCode = 2, + kFourByteCode = 3 +}; + +/* Mixed Mode Routine Records */ +typedef unsigned long ProcInfoType; +/* Routine Flag Bits */ +typedef unsigned short RoutineFlagsType; +enum { + kProcDescriptorIsAbsolute = 0x00, + kProcDescriptorIsRelative = 0x01 +}; + +enum { + kFragmentIsPrepared = 0x00, + kFragmentNeedsPreparing = 0x02 +}; + +enum { + kUseCurrentISA = 0x00, + kUseNativeISA = 0x04 +}; + +enum { + kPassSelector = 0x00, + kDontPassSelector = 0x08 +}; + +enum { + kRoutineIsNotDispatchedDefaultRoutine = 0x00, + kRoutineIsDispatchedDefaultRoutine = 0x10 +}; + +enum { + kProcDescriptorIsProcPtr = 0x00, + kProcDescriptorIsIndex = 0x20 +}; + +struct RoutineRecord { + ProcInfoType procInfo; /* calling conventions */ + SInt8 reserved1; /* Must be 0 */ + ISAType ISA; /* Instruction Set Architecture */ + RoutineFlagsType routineFlags; /* Flags for each routine */ + ProcPtr procDescriptor; /* Where is the thing we're calling? */ + UInt32 reserved2; /* Must be 0 */ + UInt32 selector; /* For dispatched routines, the selector */ +}; +typedef struct RoutineRecord RoutineRecord; +typedef RoutineRecord * RoutineRecordPtr; +typedef RoutineRecordPtr * RoutineRecordHandle; +/* Mixed Mode Routine Descriptors */ +/* Definitions of the Routine Descriptor Flag Bits */ +typedef UInt8 RDFlagsType; +enum { + kSelectorsAreNotIndexable = 0x00, + kSelectorsAreIndexable = 0x01 +}; + +/* Routine Descriptor Structure */ +struct RoutineDescriptor { + UInt16 goMixedModeTrap; /* Our A-Trap */ + SInt8 version; /* Current Routine Descriptor version */ + RDFlagsType routineDescriptorFlags; /* Routine Descriptor Flags */ + UInt32 reserved1; /* Unused, must be zero */ + UInt8 reserved2; /* Unused, must be zero */ + UInt8 selectorInfo; /* If a dispatched routine, calling convention, else 0 */ + UInt16 routineCount; /* Number of routines in this RD */ + RoutineRecord routineRecords[1]; /* The individual routines */ +}; +typedef struct RoutineDescriptor RoutineDescriptor; +typedef RoutineDescriptor * RoutineDescriptorPtr; +typedef RoutineDescriptorPtr * RoutineDescriptorHandle; +/* 68K MixedModeStateRecord */ +struct MixedModeStateRecord { + UInt32 state1; + UInt32 state2; + UInt32 state3; + UInt32 state4; +}; +typedef struct MixedModeStateRecord MixedModeStateRecord; +#if CALL_NOT_IN_CARBON +/* Macros for building static Routine Descriptors (not available in Carbon) */ + +/* A macro which creates a static instance of a non-dispatched routine descriptor */ +#define BUILD_ROUTINE_DESCRIPTOR(procInfo, procedure) \ + { \ + _MixedModeMagic, /* Mixed Mode A-Trap */ \ + kRoutineDescriptorVersion, /* version */ \ + kSelectorsAreNotIndexable, /* RD Flags - not dispatched */ \ + 0, /* reserved 1 */ \ + 0, /* reserved 2 */ \ + 0, /* selector info */ \ + 0, /* number of routines */ \ + { /* It�s an array */ \ + { /* It�s a struct */ \ + (procInfo), /* the ProcInfo */ \ + 0, /* reserved */ \ + GetCurrentArchitecture(), /* ISA and RTA */ \ + kProcDescriptorIsAbsolute | /* Flags - it�s absolute addr */\ + kFragmentIsPrepared | /* It�s prepared */ \ + kUseNativeISA, /* Always use native ISA */ \ + (ProcPtr)(procedure), /* the procedure */ \ + 0, /* reserved */ \ + 0 /* Not dispatched */ \ + } \ + } \ + } + +/* a macro which creates a static instance of a fat routine descriptor */ +#define BUILD_FAT_ROUTINE_DESCRIPTOR(m68kProcInfo, m68kProcPtr, powerPCProcInfo, powerPCProcPtr) \ + { \ + _MixedModeMagic, /* Mixed Mode A-Trap */ \ + kRoutineDescriptorVersion, /* version */ \ + kSelectorsAreNotIndexable, /* RD Flags - not dispatched */ \ + 0, /* reserved */ \ + 0, /* reserved */ \ + 0, /* reserved */ \ + 1, /* Array count */ \ + { /* It�s an array */ \ + { /* It�s a struct */ \ + (m68kProcInfo), /* the ProcInfo */ \ + 0, /* reserved */ \ + kM68kISA | /* ISA */ \ + kOld68kRTA, /* RTA */ \ + kProcDescriptorIsAbsolute | /* Flags - it�s absolute addr */\ + kUseCurrentISA, /* Use current ISA */ \ + (ProcPtr)(m68kProcPtr), /* the procedure */ \ + 0, /* reserved */ \ + 0, /* reserved */ \ + }, \ + { /* It�s a struct */ \ + (powerPCProcInfo), /* the ProcInfo */ \ + 0, /* reserved */ \ + GetCurrentArchitecture(), /* ISA and RTA */ \ + kProcDescriptorIsAbsolute | /* Flags - it�s absolute addr */\ + kFragmentIsPrepared | /* It�s prepared */ \ + kUseCurrentISA, /* Always use current ISA */ \ + (ProcPtr)(powerPCProcPtr), /* the procedure */ \ + 0, /* reserved */ \ + 0 /* reserved */ \ + } \ + } \ + } +#endif /* CALL_NOT_IN_CARBON */ + +/* Mixed Mode ProcInfos */ +enum { + /* Calling Convention Offsets */ + kCallingConventionWidth = 4, + kCallingConventionPhase = 0, + kCallingConventionMask = 0x0F, /* Result Offsets */ + kResultSizeWidth = 2, + kResultSizePhase = kCallingConventionWidth, + kResultSizeMask = 0x30, /* Parameter offsets & widths */ + kStackParameterWidth = 2, + kStackParameterPhase = (kCallingConventionWidth + kResultSizeWidth), + kStackParameterMask = (long)0xFFFFFFC0, /* Register Result Location offsets & widths */ + kRegisterResultLocationWidth = 5, + kRegisterResultLocationPhase = (kCallingConventionWidth + kResultSizeWidth), /* Register Parameter offsets & widths */ + kRegisterParameterWidth = 5, + kRegisterParameterPhase = (kCallingConventionWidth + kResultSizeWidth + kRegisterResultLocationWidth), + kRegisterParameterMask = 0x7FFFF800, + kRegisterParameterSizePhase = 0, + kRegisterParameterSizeWidth = 2, + kRegisterParameterWhichPhase = kRegisterParameterSizeWidth, + kRegisterParameterWhichWidth = 3, /* Dispatched Stack Routine Selector offsets & widths */ + kDispatchedSelectorSizeWidth = 2, + kDispatchedSelectorSizePhase = (kCallingConventionWidth + kResultSizeWidth), /* Dispatched Stack Routine Parameter offsets */ + kDispatchedParameterPhase = (kCallingConventionWidth + kResultSizeWidth + kDispatchedSelectorSizeWidth), /* Special Case offsets & widths */ + kSpecialCaseSelectorWidth = 6, + kSpecialCaseSelectorPhase = kCallingConventionWidth, + kSpecialCaseSelectorMask = 0x03F0 +}; + +enum { + kSpecialCase = 0x000F /* (CallingConventionType) */ +}; + +enum { + /* all of the special cases enumerated. The selector field is 6 bits wide */ + kSpecialCaseHighHook = 0, + kSpecialCaseCaretHook = 0, /* same as kSpecialCaseHighHook */ + kSpecialCaseEOLHook = 1, + kSpecialCaseWidthHook = 2, + kSpecialCaseTextWidthHook = 2, /* same as kSpecialCaseWidthHook */ + kSpecialCaseNWidthHook = 3, + kSpecialCaseDrawHook = 4, + kSpecialCaseHitTestHook = 5, + kSpecialCaseTEFindWord = 6, + kSpecialCaseProtocolHandler = 7, + kSpecialCaseSocketListener = 8, + kSpecialCaseTERecalc = 9, + kSpecialCaseTEDoText = 10, + kSpecialCaseGNEFilterProc = 11, + kSpecialCaseMBarHook = 12 +}; + + +/* + NOTES ON USING ROUTINE DESCRIPTOR FUNCTIONS + + When calling these routine from classic 68k code there are two possible intentions. + + The first is source compatibility with code ported to CFM (either PowerPC or 68k CFM). When + the code is compiled for CFM the functions create routine descriptors that can be used by + the mixed mode manager operating on that machine. When the code is compiled for classic 68k + these functions do nothing so that the code will run on Macintoshes that do not have a + mixed mode manager. The dual nature of these functions is achieved by turning the CFM calls + into "no-op" macros for classic 68k: You can put "NewRoutineDescriptor" in your source, + compile it for any runtime or instruction set architecture, and it will run correctly on the + intended runtime/instruction platform. All without source changes and/or conditional source. + + The other intention is for code that "knows" that it is executing as classic 68k runtime + and is specifically trying to call code of another architecture using mixed mode. Since the + routines were designed with classic <-> CFM source compatibility in mind this second case + is treated special. For classic 68k code to create routines descriptors for use by mixed mode + it must call the "Trap" versions of the routines (NewRoutineDescriptorTrap). These versions + are only available to classic 68k callers: rigging the interfaces to allow calling them + from CFM code will result in runtime failure because no shared library implements or exports + the functions. + + + This almost appears seamless until you consider "fat" routine descriptors and the advent of + CFM-68K. What does "fat" mean? CFM-68K is not emulated on PowerPC and PowerPC is not emulated + on CFM-68K. It makes no sense to create a routine descriptor having both a CFM-68K routine + and a PowerPC native routine pointer. Therefore "fat" is defined to be a mix of classic and + CFM for the hardware's native instruction set: on PowerPC fat is classic and PowerPC native, + on a 68k machine with CFM-68K installed fat is classic and CFM-68K. + + By definition fat routine descriptors are only constructed by code that is aware of the + architecture it is executing as and that another architecture exists. Source compatibility + between code intented as pure classic and pure CFM is not an issue and so NewFatRoutineDescriptor + is not available when building pure classic code. + + NewFatRoutineDescriptorTrap is available to classic code on both PowerPC and CFM-68K. The + classic code can use the code fragment manager routine "FindSymbol" to obtain the address of + a routine in a shared library and then construct a routine descriptor with both the CFM routine + and classic routine. +*/ + +#if CALL_NOT_IN_CARBON +/* + * NewRoutineDescriptor() + * + * Availability: + * Non-Carbon CFM: in InterfaceLib 7.1 and later or as macro/inline + * CarbonLib: not available + * Mac OS X: not available + */ +EXTERN_API_C( UniversalProcPtr ) +NewRoutineDescriptor( + ProcPtr theProc, + ProcInfoType theProcInfo, + ISAType theISA); +#if !TARGET_OS_MAC || !TARGET_RT_MAC_CFM + #ifdef __cplusplus + inline DEFINE_API_C(UniversalProcPtr ) NewRoutineDescriptor(ProcPtr theProc, ProcInfoType , ISAType ) { return (UniversalProcPtr)theProc; } + #else + #define NewRoutineDescriptor(theProc, theProcInfo, theISA) ((UniversalProcPtr)theProc) + #endif +#endif + + + + #if TARGET_OS_MAC && TARGET_RT_MAC_CFM + #define NewRoutineDescriptor(theProc, procInfo, isa) ((UniversalProcPtr) theProc) + #endif + + +/* + * DisposeRoutineDescriptor() + * + * Availability: + * Non-Carbon CFM: in InterfaceLib 7.1 and later or as macro/inline + * CarbonLib: not available + * Mac OS X: not available + */ +EXTERN_API_C( void ) +DisposeRoutineDescriptor(UniversalProcPtr theUPP); +#if !TARGET_OS_MAC || !TARGET_RT_MAC_CFM + #ifdef __cplusplus + inline DEFINE_API_C(void) DisposeRoutineDescriptor(UniversalProcPtr ) {} + #else + #define DisposeRoutineDescriptor(theUPP) + #endif +#endif + + + + #if TARGET_OS_MAC && TARGET_RT_MAC_CFM + #define DisposeRoutineDescriptor(upp) + #endif + +#endif /* CALL_NOT_IN_CARBON */ + +#if CALL_NOT_IN_CARBON +/* + * NewFatRoutineDescriptor() + * + * Availability: + * Non-Carbon CFM: in InterfaceLib 7.1 and later + * CarbonLib: not available + * Mac OS X: not available + */ +EXTERN_API( UniversalProcPtr ) +NewFatRoutineDescriptor( + ProcPtr theM68kProc, + ProcPtr thePowerPCProc, + ProcInfoType theProcInfo); + + + +#endif /* CALL_NOT_IN_CARBON */ + +#if TARGET_CPU_68K && !TARGET_RT_MAC_CFM +/* + The "Trap" versions of the MixedMode calls are only for classic 68K clients that + want to load and use CFM based code. +*/ +#if CALL_NOT_IN_CARBON +/* + * NewRoutineDescriptorTrap() + * + * Availability: + * Non-Carbon CFM: not available + * CarbonLib: not available + * Mac OS X: not available + */ +EXTERN_API( UniversalProcPtr ) +NewRoutineDescriptorTrap( + ProcPtr theProc, + ProcInfoType theProcInfo, + ISAType theISA) TWOWORDINLINE(0x7000, 0xAA59); + + +/* + * DisposeRoutineDescriptorTrap() + * + * Availability: + * Non-Carbon CFM: not available + * CarbonLib: not available + * Mac OS X: not available + */ +EXTERN_API( void ) +DisposeRoutineDescriptorTrap(UniversalProcPtr theProcPtr) TWOWORDINLINE(0x7001, 0xAA59); + + +/* + * NewFatRoutineDescriptorTrap() + * + * Availability: + * Non-Carbon CFM: not available + * CarbonLib: not available + * Mac OS X: not available + */ +EXTERN_API( UniversalProcPtr ) +NewFatRoutineDescriptorTrap( + ProcPtr theM68kProc, + ProcPtr thePowerPCProc, + ProcInfoType theProcInfo) TWOWORDINLINE(0x7002, 0xAA59); + + +#endif /* CALL_NOT_IN_CARBON */ + +#endif /* TARGET_CPU_68K && !TARGET_RT_MAC_CFM */ + +#if !TARGET_CPU_68K || TARGET_RT_MAC_CFM +/* + CallUniversalProc is defined for all targets except classic 68k code. This will + catch accidental calls from classic 68K code that previously only showed up as + linker errors. +*/ +#if CALL_NOT_IN_CARBON +/* + * CallUniversalProc() + * + * Availability: + * Non-Carbon CFM: in InterfaceLib 7.1 and later + * CarbonLib: not available + * Mac OS X: not available + */ +EXTERN_API_C( long ) +CallUniversalProc( + UniversalProcPtr theProcPtr, + ProcInfoType procInfo, + ...); + + +/* + * CallOSTrapUniversalProc() + * + * Availability: + * Non-Carbon CFM: in InterfaceLib 7.1 and later + * CarbonLib: not available + * Mac OS X: not available + */ +EXTERN_API_C( long ) +CallOSTrapUniversalProc( + UniversalProcPtr theProcPtr, + ProcInfoType procInfo, + ...); + + +#endif /* CALL_NOT_IN_CARBON */ + +#endif /* !TARGET_CPU_68K || TARGET_RT_MAC_CFM */ + +#if TARGET_CPU_68K +#if CALL_NOT_IN_CARBON +/* + * SaveMixedModeState() + * + * Availability: + * Non-Carbon CFM: not available + * CarbonLib: not available + * Mac OS X: not available + */ +EXTERN_API( OSErr ) +SaveMixedModeState( + MixedModeStateRecord * stateStorage, + UInt32 stateVersion) TWOWORDINLINE(0x7003, 0xAA59); + + +/* + * RestoreMixedModeState() + * + * Availability: + * Non-Carbon CFM: not available + * CarbonLib: not available + * Mac OS X: not available + */ +EXTERN_API( OSErr ) +RestoreMixedModeState( + MixedModeStateRecord * stateStorage, + UInt32 stateVersion) TWOWORDINLINE(0x7004, 0xAA59); + + +#endif /* CALL_NOT_IN_CARBON */ + +#endif /* TARGET_CPU_68K */ + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * + * Macros for building ProcInfos. Examples: + * + * + * uppModalFilterProcInfo = kPascalStackBased + * | RESULT_SIZE(SIZE_CODE(sizeof(Boolean))) + * | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DialogRef))) + * | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(EventRecord*))) + * | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(short*))), + * + * uppDeskHookProcInfo = kRegisterBased + * | REGISTER_ROUTINE_PARAMETER(1, kRegisterD0, SIZE_CODE(sizeof(Boolean))) + * | REGISTER_ROUTINE_PARAMETER(2, kRegisterA0, SIZE_CODE(sizeof(EventRecord*))) + * + * uppGXSpoolResourceProcInfo = kCStackBased + * | RESULT_SIZE(SIZE_CODE(sizeof(OSErr))) + * | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(gxSpoolFile))) + * | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Handle))) + * | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(ResType))) + * | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long))) + * + * uppTEFindWordProcInfo = SPECIAL_CASE_PROCINFO( 6 ), + * + */ + + +/* * * * * * * * * * * * * * + * SIZE_CODE - Return the size code for an object, given its size in bytes. + * size - size of an object in bytes + */ +#define SIZE_CODE(size) \ + (((size) == 4) ? kFourByteCode : (((size) == 2) ? kTwoByteCode : (((size) == 1) ? kOneByteCode : 0))) + + +/* * * * * * * * * * * * * * + * RESULT_SIZE - Return the result field of a ProcInfo, given the return object�s size. + * This is the same for all ProcInfos + * sizeCode - size code + */ +#define RESULT_SIZE(sizeCode) \ + ((ProcInfoType)(sizeCode) << kResultSizePhase) + + +/* * * * * * * * * * * * * * + * STACK_ROUTINE_PARAMETER - Return a parameter field of a ProcInfo, for a simple, + * non-dispatched, stack based routine. + * whichParam - which parameter + * sizeCode - size code + */ +#define STACK_ROUTINE_PARAMETER(whichParam, sizeCode) \ + ((ProcInfoType)(sizeCode) << (kStackParameterPhase + (((whichParam) - 1) * kStackParameterWidth))) + + +/* * * * * * * * * * * * * * + * DISPATCHED_STACK_ROUTINE_PARAMETER - Return a parameter field of a ProcInfo, for + * a dispatched, stack based routine. The same + * macro is used regardless of the type of + * dispatching. + * whichParam - which parameter + * sizeCode - size code + */ +#define DISPATCHED_STACK_ROUTINE_PARAMETER(whichParam, sizeCode) \ + ((ProcInfoType)(sizeCode) << (kDispatchedParameterPhase + (((whichParam) - 1) * kStackParameterWidth))) + + +/* * * * * * * * * * * * * * + * DISPATCHED_STACK_ROUTINE_SELECTOR_SIZE - Return a the selector size field of a ProcInfo + * for a dispatched, stack based routine. The + * same macro is used regardless of the type of + * dispatching. + * sizeCode - size code + */ +#define DISPATCHED_STACK_ROUTINE_SELECTOR_SIZE(sizeCode) \ + ((ProcInfoType)(sizeCode) << kDispatchedSelectorSizePhase) + + +/* * * * * * * * * * * * * * + * REGISTER_RESULT_LOCATION - Return the Result Location field of a ProcInfo, + * given the location. + * whichReg - which register + */ +#define REGISTER_RESULT_LOCATION(whichReg) \ + ((ProcInfoType)(whichReg) << kRegisterResultLocationPhase) + + +/* * * * * * * * * * * * * * + * REGISTER_ROUTINE_PARAMETER - Return a parameter field of a ProcInfo for a + * register based routine. + */ +#define REGISTER_ROUTINE_PARAMETER(whichParam, whichReg, sizeCode) \ + ((((ProcInfoType)(sizeCode) << kRegisterParameterSizePhase) | ((ProcInfoType)(whichReg) << kRegisterParameterWhichPhase)) << \ + (kRegisterParameterPhase + (((whichParam) - 1) * kRegisterParameterWidth))) + + +/* * * * * * * * * * * * * * + * + * SPECIAL_CASE_PROCINFO - Returns the procInfo constant for the following special cases: + * + * High Hook & Caret Hook - (see I-379) + * C calling conventions, Rect on stack, pointer in A3, no return value + * EOL Hook - (see VI-15-26) + * Register-based; inputs in D0, A3, A4; + * output is Z flag of status register + * Width Hook - (see VI-15-27) + * Register-based; inputs in D0, D1, A0, A3, A4; output in D1 + * NWidth Hook - (see VI-15-27) + * Register-based; inputs in D0, D1, D2, A0, A2, A3, A4; output in D1 + * TextWidthHook - (see VI-15-28) + * Register-based; inputs in D0, D1, A0, A3, A4; output in D1 + * DrawHook - (see VI-15-28) + * Register-based; inputs in D0, D1, A0, A3, A4; no output + * HitTestHook - (See VI-15-29) + * Register-based; inputs in D0, D1, D2, A0, A3, A4; outputs in D0, D1, D2 + * FindWord - (see VI-15-30) + * Register-based; inputs in D0, D2, A3, A4; outputs in D0, D1 + * ADBRoutines - (see V-371) + * Register-based; inputs in A0, A1, A2, D0; no outputs + * ProtocolHandler - (see II-326) + * Register-based; inputs in A0, A1, A2, A3, A4, D1.w; output in Z + * SocketListener - (see II-329) + * Register-based; inputs in A0, A1, A2, A3, A4, D0.b, D1.w; output in Z + * Reclac - (see I-391) + * Register-based; inputs in A3, D7; outputs in D2, D3, D4 + * DoText - (see I-391) + * Register-based; inputs in A3, D3, D4, D7; outputs in A0, D0 + * GNEFilterProc - (see tech note 85) + * Register & Stack Based; inputs in A1, D0 & on the stack; outputs on the stack + * MenuBarHook - (see I-356) + * Register & Stack Based; input on the stack; output in D0 +*/ +#define SPECIAL_CASE_PROCINFO(specialCaseCode) \ + (kSpecialCase | ((ProcInfoType)(specialCaseCode) << 4)) + + +/* * * * * * * * * * * * * * * + * STACK_UPP_TYPE - used in typedefs to create �UPP type + * REGISTER_UPP_TYPE - used in typedefs to create �UPP type + * TVECTOR_UPP_TYPE - used in typedefs to create �UPP type + * + * Example: + * + * typedef STACK_UPP_TYPE(ModalFilterProcPtr) ModalFilterUPP; + * typedef REGISTER_UPP_TYPE(IOCompletionProcPtr) IOCompletionUPP; + * + */ +#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM + /* classic 68k runtime */ + #define STACK_UPP_TYPE(name) name + #define REGISTER_UPP_TYPE(name) Register68kProcPtr + #define TVECTOR_UPP_TYPE(name) name +#elif TARGET_OS_MAC && TARGET_RT_MAC_CFM + /* PowerPC and CFM68K runtime */ + #if OPAQUE_UPP_TYPES + #define STACK_UPP_TYPE(name) struct Opaque##name##* + #define REGISTER_UPP_TYPE(name) struct Opaque##name##* + #define TVECTOR_UPP_TYPE(name) struct Opaque##name##* + #else + #define STACK_UPP_TYPE(name) UniversalProcPtr + #define REGISTER_UPP_TYPE(name) UniversalProcPtr + #define TVECTOR_UPP_TYPE(name) name + #endif +#elif TARGET_OS_MAC && TARGET_RT_MAC_MACHO + /* Mac OS X runtime */ + #define STACK_UPP_TYPE(name) name + #define REGISTER_UPP_TYPE(name) name + #define TVECTOR_UPP_TYPE(name) name +#else + /* other runtimes */ + #define STACK_UPP_TYPE(name) name + #define REGISTER_UPP_TYPE(name) name + #define TVECTOR_UPP_TYPE(name) name +#endif + + +/* * * * * * * * * * * * * * * + * CALL_�_PARAMETER_UPP - used in Call�Proc macros + * + * Example: + * + * #define CallIOCompletionProc(userRoutine, paramBlock) \ + * CALL_TWO_PARAMETER_UPP((userRoutine), uppIOCompletionProcInfo, (paramBlock)) + * + */ +#if TARGET_OS_MAC && TARGET_RT_MAC_CFM + #define CALL_ZERO_PARAMETER_UPP( upp, procInfo) CallUniversalProc(upp, procInfo) + #define CALL_ONE_PARAMETER_UPP( upp, procInfo, p1) CallUniversalProc(upp, procInfo, (p1)) + #define CALL_TWO_PARAMETER_UPP( upp, procInfo, p1, p2) CallUniversalProc(upp, procInfo, (p1), (p2)) + #define CALL_THREE_PARAMETER_UPP( upp, procInfo, p1, p2, p3) CallUniversalProc(upp, procInfo, (p1), (p2), (p3)) + #define CALL_FOUR_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4) CallUniversalProc(upp, procInfo, (p1), (p2), (p3), (p4)) + #define CALL_FIVE_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5) CallUniversalProc(upp, procInfo, (p1), (p2), (p3), (p4), (p5)) + #define CALL_SIX_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6) CallUniversalProc(upp, procInfo, (p1), (p2), (p3), (p4), (p5), (p6)) + #define CALL_SEVEN_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6, p7) CallUniversalProc(upp, procInfo, (p1), (p2), (p3), (p4), (p5), (p6), (p7)) + #define CALL_EIGHT_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6, p7, p8) CallUniversalProc(upp, procInfo, (p1), (p2), (p3), (p4), (p5), (p6), (p7), (p8)) + #define CALL_NINE_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6, p7, p8, p9) CallUniversalProc(upp, procInfo, (p1), (p2), (p3), (p4), (p5), (p6), (p7), (p8), (p9)) + #define CALL_TEN_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) CallUniversalProc(upp, procInfo, (p1), (p2), (p3), (p4), (p5), (p6), (p7), (p8), (p9), (p10)) + #define CALL_ELEVEN_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) CallUniversalProc(upp, procInfo, (p1), (p2), (p3), (p4), (p5), (p6), (p7), (p8), (p9), (p10), (p11)) + #define CALL_TWELVE_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) CallUniversalProc(upp, procInfo, (p1), (p2), (p3), (p4), (p5), (p6), (p7), (p8), (p9), (p10), (p11), (p12)) + #define CALL_THIRTEEN_PARAMETER_UPP(upp, procInfo, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) CallUniversalProc(upp, procInfo, (p1), (p2), (p3), (p4), (p5), (p6), (p7), (p8), (p9), (p10), (p11), (p12), (p13)) +#else + #define CALL_ZERO_PARAMETER_UPP( upp, procInfo) (*(upp))() + #define CALL_ONE_PARAMETER_UPP( upp, procInfo, p1) (*(upp))((p1)) + #define CALL_TWO_PARAMETER_UPP( upp, procInfo, p1, p2) (*(upp))((p1), (p2)) + #define CALL_THREE_PARAMETER_UPP( upp, procInfo, p1, p2, p3) (*(upp))((p1), (p2), (p3)) + #define CALL_FOUR_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4) (*(upp))((p1), (p2), (p3), (p4)) + #define CALL_FIVE_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5) (*(upp))((p1), (p2), (p3), (p4), (p5)) + #define CALL_SIX_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6) (*(upp))((p1), (p2), (p3), (p4), (p5), (p6)) + #define CALL_SEVEN_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6, p7) (*(upp))((p1), (p2), (p3), (p4), (p5), (p6), (p7)) + #define CALL_EIGHT_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6, p7, p8) (*(upp))((p1), (p2), (p3), (p4), (p5), (p6), (p7), (p8)) + #define CALL_NINE_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6, p7, p8, p9) (*(upp))((p1), (p2), (p3), (p4), (p5), (p6), (p7), (p8), (p9)) + #define CALL_TEN_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) (*(upp))((p1), (p2), (p3), (p4), (p5), (p6), (p7), (p8), (p9), (p10)) + #define CALL_ELEVEN_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) (*(upp))((p1), (p2), (p3), (p4), (p5), (p6), (p7), (p8), (p9), (p10), (p11)) + #define CALL_TWELVE_PARAMETER_UPP( upp, procInfo, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) (*(upp))((p1), (p2), (p3), (p4), (p5), (p6), (p7), (p8), (p9), (p10), (p11), (p12)) + #define CALL_THIRTEEN_PARAMETER_UPP(upp, procInfo, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) (*(upp))((p1), (p2), (p3), (p4), (p5), (p6), (p7), (p8), (p9), (p10), (p11), (p12), (p13)) +#endif + + + + + +#if PRAGMA_STRUCT_ALIGN + #pragma options align=reset +#elif PRAGMA_STRUCT_PACKPUSH + #pragma pack(pop) +#elif PRAGMA_STRUCT_PACK + #pragma pack() +#endif + +#ifdef PRAGMA_IMPORT_OFF +#pragma import off +#elif PRAGMA_IMPORT +#pragma import reset +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* __MIXEDMODE__ */ + |