MixedMode.h

Go to the documentation of this file.

 
#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
 
  enum
  {
    kRoutineDescriptorVersion = 7
  };
 
  enum
  {
    _MixedModeMagic = 0xAAFE
  };
 
  enum
  {
    kCurrentMixedModeStateRecord = 1
  };
 
  typedef unsigned short CallingConventionType;
  enum
  {
    kPascalStackBased = 0,
    kCStackBased = 1,
    kRegisterBased = 2,
    kD0DispatchedPascalStackBased = 8,
    kD1DispatchedPascalStackBased = 12,
    kD0DispatchedCStackBased = 9,
    kStackDispatchedPascalStackBased = 14,
    kThinkCStackBased = 5
  };
 
  typedef SInt8 ISAType;
  enum
  {
    kM68kISA = 0,
    kPowerPCISA = 1
  };
 
  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
 
  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, 
    kCCRegisterCBit = 16,
    kCCRegisterVBit = 17,
    kCCRegisterZBit = 18,
    kCCRegisterNBit = 19,
    kCCRegisterXBit = 20
  };
 
  typedef unsigned short registerSelectorType;
  enum
  {
    kNoByteCode = 0,
    kOneByteCode = 1,
    kTwoByteCode = 2,
    kFourByteCode = 3
  };
 
  typedef unsigned long ProcInfoType;
  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;         
    SInt8 reserved1;               
    ISAType ISA;                   
    RoutineFlagsType routineFlags; 
    ProcPtr procDescriptor;        
    UInt32 reserved2;              
    UInt32 selector;               
  };
  typedef struct RoutineRecord RoutineRecord;
  typedef RoutineRecord *RoutineRecordPtr;
  typedef RoutineRecordPtr *RoutineRecordHandle;
  typedef UInt8 RDFlagsType;
  enum
  {
    kSelectorsAreNotIndexable = 0x00,
    kSelectorsAreIndexable = 0x01
  };
 
  struct RoutineDescriptor
  {
    UInt16 goMixedModeTrap;             
    SInt8 version;                      
    RDFlagsType routineDescriptorFlags; 
    UInt32 reserved1;                   
    UInt8 reserved2;                    
    UInt8 selectorInfo;                 
    UInt16 routineCount;                
    RoutineRecord routineRecords[1];    
  };
  typedef struct RoutineDescriptor RoutineDescriptor;
  typedef RoutineDescriptor *RoutineDescriptorPtr;
  typedef RoutineDescriptorPtr *RoutineDescriptorHandle;
  struct MixedModeStateRecord
  {
    UInt32 state1;
    UInt32 state2;
    UInt32 state3;
    UInt32 state4;
  };
  typedef struct MixedModeStateRecord MixedModeStateRecord;
#if CALL_NOT_IN_CARBON
#define BUILD_ROUTINE_DESCRIPTOR(procInfo, procedure)                      \
  {                                                                        \
    _MixedModeMagic,                               \
        kRoutineDescriptorVersion,                           \
        kSelectorsAreNotIndexable,         \
        0,                                                \
        0,                                                \
        0,                                             \
        0,                                        \
    {                                                 \
      {                                               \
        (procInfo),                                     \
            0,                                              \
            GetCurrentArchitecture(),                    \
            kProcDescriptorIsAbsolute |  \
                kFragmentIsPrepared |                 \
                kUseNativeISA,                 \
            (ProcPtr)(procedure),                      \
            0,                                              \
            0                                         \
      }                                                                    \
    }                                                                      \
  }
 
#define BUILD_FAT_ROUTINE_DESCRIPTOR(m68kProcInfo, m68kProcPtr,            \
                                     powerPCProcInfo, powerPCProcPtr)      \
  {                                                                        \
    _MixedModeMagic,                               \
        kRoutineDescriptorVersion,                           \
        kSelectorsAreNotIndexable,         \
        0,                                                  \
        0,                                                  \
        0,                                                  \
        1,                                               \
    {                                                 \
      {                                                                    \
                                            \
          (m68kProcInfo),                               \
          0,                                                \
          kM68kISA |                                             \
              kOld68kRTA,                                        \
          kProcDescriptorIsAbsolute |    \
              kUseCurrentISA,                        \
          (ProcPtr)(m68kProcPtr),                      \
          0,                                                \
          0,                                                \
      },                                                                   \
      {                                               \
        (powerPCProcInfo),                              \
            0,                                              \
            GetCurrentArchitecture(),                    \
            kProcDescriptorIsAbsolute |  \
                kFragmentIsPrepared |                 \
                kUseCurrentISA,               \
            (ProcPtr)(powerPCProcPtr),                 \
            0,                                              \
            0                                               \
      }                                                                    \
    }                                                                      \
  }
#endif 
  enum
  {
    kCallingConventionWidth = 4,
    kCallingConventionPhase = 0,
    kCallingConventionMask = 0x0F, 
    kResultSizeWidth = 2,
    kResultSizePhase = kCallingConventionWidth,
    kResultSizeMask = 0x30, 
    kStackParameterWidth = 2,
    kStackParameterPhase = (kCallingConventionWidth + kResultSizeWidth),
    kStackParameterMask =
        (long)0xFFFFFFC0, 
    kRegisterResultLocationWidth = 5,
    kRegisterResultLocationPhase =
        (kCallingConventionWidth +
         kResultSizeWidth), 
    kRegisterParameterWidth = 5,
    kRegisterParameterPhase = (kCallingConventionWidth + kResultSizeWidth +
                               kRegisterResultLocationWidth),
    kRegisterParameterMask = 0x7FFFF800,
    kRegisterParameterSizePhase = 0,
    kRegisterParameterSizeWidth = 2,
    kRegisterParameterWhichPhase = kRegisterParameterSizeWidth,
    kRegisterParameterWhichWidth =
        3, 
    kDispatchedSelectorSizeWidth = 2,
    kDispatchedSelectorSizePhase =
        (kCallingConventionWidth +
         kResultSizeWidth), 
    kDispatchedParameterPhase =
        (kCallingConventionWidth + kResultSizeWidth +
         kDispatchedSelectorSizeWidth), 
    kSpecialCaseSelectorWidth = 6,
    kSpecialCaseSelectorPhase = kCallingConventionWidth,
    kSpecialCaseSelectorMask = 0x03F0
  };
 
  enum
  {
    kSpecialCase = 0x000F 
  };
 
  enum
  {
    kSpecialCaseHighHook = 0,
    kSpecialCaseCaretHook = 0, 
    kSpecialCaseEOLHook = 1,
    kSpecialCaseWidthHook = 2,
    kSpecialCaseTextWidthHook = 2, 
    kSpecialCaseNWidthHook = 3,
    kSpecialCaseDrawHook = 4,
    kSpecialCaseHitTestHook = 5,
    kSpecialCaseTEFindWord = 6,
    kSpecialCaseProtocolHandler = 7,
    kSpecialCaseSocketListener = 8,
    kSpecialCaseTERecalc = 9,
    kSpecialCaseTEDoText = 10,
    kSpecialCaseGNEFilterProc = 11,
    kSpecialCaseMBarHook = 12
  };
 
#if CALL_NOT_IN_CARBON
  UniversalProcPtr
  NewRoutineDescriptor(ProcPtr theProc, ProcInfoType theProcInfo, ISAType theISA);
#if !TARGET_OS_MAC || !TARGET_RT_MAC_CFM
#ifdef __cplusplus
  inline UniversalProcPtr NewRoutineDescriptor(ProcPtr theProc, ProcInfoType,
                                               ISAType)
  {
    return (UniversalProcPtr)theProc;
  }
#else
#define NewRoutineDescriptor(theProc, theProcInfo, theISA) \
  ((UniversalProcPtr)theProc)
#endif
#endif
 
  void
  DisposeRoutineDescriptor(UniversalProcPtr theUPP);
#if !TARGET_OS_MAC || !TARGET_RT_MAC_CFM
#ifdef __cplusplus
  inline void DisposeRoutineDescriptor(UniversalProcPtr) {}
#else
#define DisposeRoutineDescriptor(theUPP)
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON
  UniversalProcPtr
  NewFatRoutineDescriptor(ProcPtr theM68kProc, ProcPtr thePowerPCProc,
                          ProcInfoType theProcInfo);
 
#endif 
#if TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#if CALL_NOT_IN_CARBON
  UniversalProcPtr
  NewRoutineDescriptorTrap(ProcPtr theProc, ProcInfoType theProcInfo,
                           ISAType theISA);
 
  void
  DisposeRoutineDescriptorTrap(UniversalProcPtr theProcPtr);
 
  UniversalProcPtr
  NewFatRoutineDescriptorTrap(ProcPtr theM68kProc, ProcPtr thePowerPCProc,
                              ProcInfoType theProcInfo);
 
#endif 
#endif 
#if !TARGET_CPU_68K || TARGET_RT_MAC_CFM
#if CALL_NOT_IN_CARBON
  long
  CallUniversalProc(UniversalProcPtr theProcPtr, ProcInfoType procInfo, ...);
 
  long
  CallOSTrapUniversalProc(UniversalProcPtr theProcPtr, ProcInfoType procInfo,
                          ...);
 
#endif 
#endif 
#if TARGET_CPU_68K
#if CALL_NOT_IN_CARBON
  OSErr
  SaveMixedModeState(MixedModeStateRecord *stateStorage, UInt32 stateVersion);
 
  OSErr
  RestoreMixedModeState(MixedModeStateRecord *stateStorage, UInt32 stateVersion);
 
#endif 
#endif 
#define SIZE_CODE(size) \
  (((size) == 4)        \
       ? kFourByteCode  \
       : (((size) == 2) ? kTwoByteCode : (((size) == 1) ? kOneByteCode : 0)))
 
#define RESULT_SIZE(sizeCode) ((ProcInfoType)(sizeCode) << kResultSizePhase)
 
#define STACK_ROUTINE_PARAMETER(whichParam, sizeCode) \
  ((ProcInfoType)(sizeCode)                           \
   << (kStackParameterPhase + (((whichParam)-1) * kStackParameterWidth)))
 
#define DISPATCHED_STACK_ROUTINE_PARAMETER(whichParam, sizeCode) \
  ((ProcInfoType)(sizeCode)                                      \
   << (kDispatchedParameterPhase + (((whichParam)-1) * kStackParameterWidth)))
 
#define DISPATCHED_STACK_ROUTINE_SELECTOR_SIZE(sizeCode) \
  ((ProcInfoType)(sizeCode) << kDispatchedSelectorSizePhase)
 
#define REGISTER_RESULT_LOCATION(whichReg) \
  ((ProcInfoType)(whichReg) << kRegisterResultLocationPhase)
 
#define REGISTER_ROUTINE_PARAMETER(whichParam, whichReg, sizeCode) \
  ((((ProcInfoType)(sizeCode) << kRegisterParameterSizePhase) |    \
    ((ProcInfoType)(whichReg) << kRegisterParameterWhichPhase))    \
   << (kRegisterParameterPhase +                                   \
       (((whichParam)-1) * kRegisterParameterWidth)))
 
#define SPECIAL_CASE_PROCINFO(specialCaseCode) \
  (kSpecialCase | ((ProcInfoType)(specialCaseCode) << 4))
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#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
#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
#define STACK_UPP_TYPE(name) name
#define REGISTER_UPP_TYPE(name) name
#define TVECTOR_UPP_TYPE(name) name
#else
#define STACK_UPP_TYPE(name) name
#define REGISTER_UPP_TYPE(name) name
#define TVECTOR_UPP_TYPE(name) name
#endif
 
#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