Devices.h

Go to the documentation of this file.

 
#ifndef __DEVICES__
#define __DEVICES__
 
#ifndef __OSUTILS__
#include <OSUtils.h>
#endif
 
#ifndef __FILES__
#include <Files.h>
#endif
 
#ifndef __QUICKDRAW__
#include <Quickdraw.h>
#endif
 
#ifndef __NAMEREGISTRY__
#include <NameRegistry.h>
#endif
 
#ifndef __CODEFRAGMENTS__
#include <CodeFragments.h>
#endif
 
#ifndef __MULTIPROCESSING__
#include <Multiprocessing.h>
#endif
 
#ifndef __DRIVERFAMILYMATCHING__
#include <DriverFamilyMatching.h>
#endif
 
#ifndef __DISKS__
#include <Disks.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
 
  /* Values of the 'message' parameter to a Chooser device package */
  enum
  {
    chooserInitMsg = 11, /* the user selected this device package */
    newSelMsg = 12,      /* the user made new device selections */
    fillListMsg = 13,    /* fill the device list with choices */
    getSelMsg = 14,      /* mark one or more choices as selected */
    selectMsg = 15,      /* the user made a selection */
    deselectMsg = 16,    /* the user canceled a selection */
    terminateMsg = 17,   /* allows device package to clean up */
    buttonMsg = 19       /* the user selected a button */
  };
 
  /* Values of the 'caller' parameter to a Chooser device package */
  enum
  {
    chooserID = 1
  };
 
  /* Values of the 'message' parameter to a Monitor 'mntr' */
  enum
  {
    initMsg = 1,       /*initialization*/
    okMsg = 2,         /*user clicked OK button*/
    cancelMsg = 3,     /*user clicked Cancel button*/
    hitMsg = 4,        /*user clicked control in Options dialog*/
    nulMsg = 5,        /*periodic event*/
    updateMsg = 6,     /*update event*/
    activateMsg = 7,   /*not used*/
    deactivateMsg = 8, /*not used*/
    keyEvtMsg = 9,     /*keyboard event*/
    superMsg = 10,     /*show superuser controls*/
    normalMsg = 11,    /*show only normal controls*/
    startupMsg = 12    /*code has been loaded*/
  };
 
  /* control codes for DeskAccessories */
  enum
  {
    goodbye = -1,   /* heap being reinitialized */
    killCode = 1,   /* KillIO requested */
    accEvent = 64,  /* handle an event */
    accRun = 65,    /* time for periodic action */
    accCursor = 66, /* change cursor shape */
    accMenu = 67,   /* handle menu item */
    accUndo = 68,   /* handle undo command */
    accCut = 70,    /* handle cut command */
    accCopy = 71,   /* handle copy command */
    accPaste = 72,  /* handle paste command */
    accClear = 73   /* handle clear command */
  };
 
  /* Control/Status Call Codes */
  /* drvStsCode, ejectCode and tgBuffCode are now defined in Disks.h/p/a */
 
  /* miscellaneous Device Manager constants */
  enum
  {
    ioInProgress = 1, /* predefined value of ioResult while I/O is pending */
    aRdCmd = 2,       /* low byte of ioTrap for Read calls */
    aWrCmd = 3,       /* low byte of ioTrap for Write calls */
    asyncTrpBit = 10, /* trap word modifier */
    noQueueBit = 9    /* trap word modifier */
  };
 
  /* flags used in the driver header and device control entry */
  enum
  {
    dReadEnable = 0,  /* set if driver responds to read requests */
    dWritEnable = 1,  /* set if driver responds to write requests */
    dCtlEnable = 2,   /* set if driver responds to control requests */
    dStatEnable = 3,  /* set if driver responds to status requests */
    dNeedGoodBye = 4, /* set if driver needs time for performing periodic tasks */
    dNeedTime = 5,    /* set if driver needs time for performing periodic tasks */
    dNeedLock =
        6 /* set if driver must be locked in memory as soon as it is opened */
  };
 
  enum
  {
    dNeedLockMask = 0x4000, /* set if driver must be locked in memory as soon as
                               it is opened */
    dNeedTimeMask =
        0x2000,                /* set if driver needs time for performing periodic tasks */
    dNeedGoodByeMask = 0x1000, /* set if driver needs to be called before the
                                  application heap is initialized */
    dStatEnableMask = 0x0800,  /* set if driver responds to status requests */
    dCtlEnableMask = 0x0400,   /* set if driver responds to control requests */
    dWritEnableMask = 0x0200,  /* set if driver responds to write requests */
    dReadEnableMask = 0x0100   /* set if driver responds to read requests */
  };
 
  /* run-time flags used in the device control entry */
  enum
  {
    dVMImmuneBit = 0, /* driver does not need VM protection */
    dOpened = 5,      /* driver is open */
    dRAMBased = 6,    /* dCtlDriver is a handle (1) or pointer (0) */
    drvrActive = 7    /* driver is currently processing a request */
  };
 
  enum
  {
    dVMImmuneMask = 0x0001, /* driver does not need VM protection */
    dOpenedMask = 0x0020,   /* driver is open */
    dRAMBasedMask = 0x0040, /* dCtlDriver is a handle (1) or pointer (0) */
    drvrActiveMask = 0x0080 /* driver is currently processing a request */
  };
 
  struct DRVRHeader
  {
    short drvrFlags;
    short drvrDelay;
    short drvrEMask;
    short drvrMenu;
    short drvrOpen;
    short drvrPrime;
    short drvrCtl;
    short drvrStatus;
    short drvrClose;
    unsigned char drvrName[1];
  };
  typedef struct DRVRHeader DRVRHeader;
  typedef DRVRHeader *DRVRHeaderPtr;
  typedef DRVRHeaderPtr *DRVRHeaderHandle;
  struct DCtlEntry
  {
    Ptr dCtlDriver;
    volatile short dCtlFlags;
    QHdr dCtlQHdr;
    volatile long dCtlPosition;
    Handle dCtlStorage;
    short dCtlRefNum;
    long dCtlCurTicks;
    GrafPtr dCtlWindow;
    short dCtlDelay;
    short dCtlEMask;
    short dCtlMenu;
  };
  typedef struct DCtlEntry DCtlEntry;
  typedef DCtlEntry *DCtlPtr;
  typedef DCtlPtr *DCtlHandle;
  struct AuxDCE
  {
    Ptr dCtlDriver;
    volatile short dCtlFlags;
    QHdr dCtlQHdr;
    long dCtlPosition;
    Handle dCtlStorage;
    short dCtlRefNum;
    long dCtlCurTicks;
    GrafPtr dCtlWindow;
    short dCtlDelay;
    short dCtlEMask;
    short dCtlMenu;
    SInt8 dCtlSlot;
    SInt8 dCtlSlotId;
    long dCtlDevBase;
    Ptr dCtlOwner;
    SInt8 dCtlExtDev;
    SInt8 fillByte;
    UInt32 dCtlNodeID;
  };
  typedef struct AuxDCE AuxDCE;
  typedef AuxDCE *AuxDCEPtr;
  typedef AuxDCEPtr *AuxDCEHandle;
  //  The NDRV Driver IO Entry Point and Commands
  typedef UInt16 UnitNumber;
  typedef UInt32 DriverOpenCount;
  typedef SInt16 DriverRefNum;
  typedef SInt16 DriverFlags;
  typedef UInt32 IOCommandCode;
  enum
  {
    kOpenCommand = 0,
    kCloseCommand = 1,
    kReadCommand = 2,
    kWriteCommand = 3,
    kControlCommand = 4,
    kStatusCommand = 5,
    kKillIOCommand = 6,
    kInitializeCommand = 7,  /* init driver and device*/
    kFinalizeCommand = 8,    /* shutdown driver and device*/
    kReplaceCommand = 9,     /* replace an old driver*/
    kSupersededCommand = 10, /* prepare to be replaced by a new driver*/
    kSuspendCommand = 11,    /* prepare driver to go to sleep*/
    kResumeCommand = 12      /* wake up sleeping driver*/
  };
 
  enum
  {
    /* one more IOCommandCode*/
    kPowerManagementCommand = 13 /* power management command, supercedes
                                    kSuspendCommand and kResumeCommand*/
  };
 
  typedef MPAddressSpaceID AddressSpaceID;
  typedef struct OpaqueIOCommandID *IOCommandID;
  typedef UInt32 IOCommandKind;
  enum
  {
    kSynchronousIOCommandKind = 0x00000001,
    kAsynchronousIOCommandKind = 0x00000002,
    kImmediateIOCommandKind = 0x00000004
  };
 
  struct DriverInitInfo
  {
    DriverRefNum refNum;
    RegEntryID deviceEntry;
  };
  typedef struct DriverInitInfo DriverInitInfo;
  typedef DriverInitInfo *DriverInitInfoPtr;
  typedef DriverInitInfo DriverReplaceInfo;
  typedef DriverInitInfo *DriverReplaceInfoPtr;
  struct DriverFinalInfo
  {
    DriverRefNum refNum;
    RegEntryID deviceEntry;
  };
  typedef struct DriverFinalInfo DriverFinalInfo;
  typedef DriverFinalInfo *DriverFinalInfoPtr;
  typedef DriverFinalInfo DriverSupersededInfo;
  typedef DriverFinalInfo *DriverSupersededInfoPtr;
 
  /* Contents are command specific*/
 
  union IOCommandContents
  {
    ParmBlkPtr pb;
    DriverInitInfoPtr initialInfo;
    DriverFinalInfoPtr finalInfo;
    DriverReplaceInfoPtr replaceInfo;
    DriverSupersededInfoPtr supersededInfo;
  };
  typedef union IOCommandContents IOCommandContents;
  typedef CALLBACK_API_C(OSErr, DriverEntryPointPtr)(AddressSpaceID SpaceID,
                                                     IOCommandID CommandID,
                                                     IOCommandContents Contents,
                                                     IOCommandCode Code,
                                                     IOCommandKind Kind);
  /* Record to describe a file-based driver candidate */
  struct FileBasedDriverRecord
  {
    FSSpec theSpec;         /* file specification*/
    MacDriverType theType;  /* nameInfoStr + version number*/
    Boolean compatibleProp; /* true if matched using a compatible name*/
    UInt8 pad[3];           /* alignment*/
  };
  typedef struct FileBasedDriverRecord FileBasedDriverRecord;
  typedef FileBasedDriverRecord *FileBasedDriverRecordPtr;
  /* Detailed Record to describe a file-based driver candidate. Includes fragment
   * name */
  struct FileBasedDriverDetailed
  {
    FileBasedDriverRecord fileBasedDriver;
    Str63 fragName;
  };
  typedef struct FileBasedDriverDetailed FileBasedDriverDetailed;
  typedef FileBasedDriverDetailed *FileBasedDriverDetailedPtr;
/* Driver Loader API */
#define DECLARE_DRIVERDESCRIPTION(N_ADDITIONAL_SERVICES)             \
  struct                                                             \
  {                                                                  \
    DriverDescription fixed;                                         \
    DriverServiceInfo additional_service[N_ADDITIONAL_SERVICES - 1]; \
  };
 
#if CALL_NOT_IN_CARBON
  SInt16
  HigherDriverVersion(const NumVersion *driverVersion1,
                      const NumVersion *driverVersion2);
 
  OSErr
  VerifyFragmentAsDriver(CFragConnectionID fragmentConnID,
                         DriverEntryPointPtr *fragmentMain,
                         DriverDescriptionPtr *driverDesc);
 
  OSErr
  GetDriverMemoryFragment(Ptr memAddr, long length, ConstStr63Param fragName,
                          CFragConnectionID *fragmentConnID,
                          DriverEntryPointPtr *fragmentMain,
                          DriverDescriptionPtr *driverDesc);
 
  OSErr
  GetDriverDiskFragment(FSSpecPtr fragmentSpec, CFragConnectionID *fragmentConnID,
                        DriverEntryPointPtr *fragmentMain,
                        DriverDescriptionPtr *driverDesc);
 
  OSErr
  GetNamedDriverDiskFragment(FSSpecPtr fragmentSpec, ConstStr63Param fragName,
                             CFragConnectionID *fragmentConnID,
                             DriverEntryPointPtr *fragmentMain,
                             DriverDescriptionPtr *driverDesc);
 
  OSErr
  InstallDriverFromFragment(CFragConnectionID fragmentConnID, RegEntryID *device,
                            UnitNumber beginningUnit, UnitNumber endingUnit,
                            DriverRefNum *refNum);
 
  OSErr
  InstallDriverFromFile(FSSpecPtr fragmentSpec, RegEntryID *device,
                        UnitNumber beginningUnit, UnitNumber endingUnit,
                        DriverRefNum *refNum);
 
  OSErr
  InstallDriverFromMemory(Ptr memory, long length, ConstStr63Param fragName,
                          RegEntryID *device, UnitNumber beginningUnit,
                          UnitNumber endingUnit, DriverRefNum *refNum);
 
  OSErr
  InstallDriverFromResource(SInt16 theRsrcID, ConstStr255Param theRsrcName,
                            RegEntryIDPtr theDevice, UnitNumber theBeginningUnit,
                            UnitNumber theEndingUnit, DriverRefNum *theRefNum);
 
  OSErr
  InstallDriverFromDisk(Ptr theDriverName, RegEntryID *theDevice,
                        UnitNumber theBeginningUnit, UnitNumber theEndingUnit,
                        DriverRefNum *theRefNum);
 
  OSErr
  FindDriversForDevice(RegEntryID *device, FSSpec *fragmentSpec,
                       DriverDescription *fileDriverDesc, Ptr *memAddr,
                       long *length, StringPtr fragName,
                       DriverDescription *memDriverDesc);
 
  OSErr
  FindDriverForDeviceFromFile(RegEntryID *device, FSSpec *fragmentSpec,
                              DriverDescription *driverDesc, StringPtr fragName);
 
  OSErr
  FindDriverCandidates(RegEntryID *deviceID, Ptr *propBasedDriver,
                       RegPropertyValueSize *propBasedDriverSize,
                       StringPtr deviceName, MacDriverType *propBasedDriverType,
                       Boolean *gotPropBasedDriver,
                       FileBasedDriverRecordPtr fileBasedDrivers,
                       ItemCount *nFileBasedDrivers);
 
  OSErr
  FindDriverCandidatesDetailed(RegEntryIDPtr deviceID, Ptr *propBasedDriver,
                               RegPropertyValueSize *propBasedDriverSize,
                               StringPtr deviceName,
                               MacDriverType *propBasedDriverType,
                               Boolean *gotPropBasedDriver,
                               FileBasedDriverDetailedPtr fileBasedDrivers,
                               ItemCount *nFileBasedDrivers);
 
  OSErr
  ScanDriverCandidates(RegEntryID *deviceID,
                       FileBasedDriverRecordPtr fileBasedDrivers,
                       ItemCount nFileBasedDrivers,
                       FileBasedDriverRecordPtr matchingDrivers,
                       ItemCount *nMatchingDrivers);
 
  OSErr
  ScanDriverCandidatesDetailed(RegEntryID *deviceID,
                               FileBasedDriverDetailedPtr fileBasedDrivers,
                               ItemCount nFileBasedDrivers,
                               FileBasedDriverDetailedPtr matchingDrivers,
                               ItemCount *nMatchingDrivers);
 
  SInt16
  CompareFileCandToPropCand(RegEntryID *device, StringPtr deviceName,
                            DriverTypePtr propBasedCandidate,
                            FileBasedDriverRecordPtr fileBasedCandidate);
 
  void
  GetCompatibleProperty(RegEntryID *device, StringPtr *compatibleNames,
                        ItemCount *nCompatibleNames);
 
  Boolean
  CompatibleDriverNames(StringPtr nameInfoStr, StringPtr compatibleNames,
                        ItemCount nCompatibleNames, long *nameCount);
 
  OSErr
  GetDriverForDevice(RegEntryID *device, CFragConnectionID *fragmentConnID,
                     DriverEntryPointPtr *fragmentMain,
                     DriverDescriptionPtr *driverDesc);
 
  OSErr
  InstallDriverForDevice(RegEntryID *device, UnitNumber beginningUnit,
                         UnitNumber endingUnit, DriverRefNum *refNum);
 
  OSErr
  GetDriverInformation(DriverRefNum refNum, UnitNumber *unitNum,
                       DriverFlags *flags, DriverOpenCount *count, StringPtr name,
                       RegEntryID *device,
                       CFragSystem7Locator *driverLoadLocation,
                       CFragConnectionID *fragmentConnID,
                       DriverEntryPointPtr *fragmentMain,
                       DriverDescription *driverDesc);
 
  OSErr
  GetDriverDescription(LogicalAddress fragmentPtr,
                       DriverDescriptionPtr *theDriverDesc);
 
  OSStatus
  GetNamedDriverDescFromFSSpec(FSSpecPtr fragmentSpec, StringPtr fragName,
                               DriverDescriptionPtr *driverDesc);
 
  OSErr
  SetDriverClosureMemory(CFragConnectionID fragmentConnID,
                         Boolean holdDriverMemory);
 
  OSErr
  ReplaceDriverWithFragment(DriverRefNum theRefNum,
                            CFragConnectionID fragmentConnID);
 
  OSErr
  OpenInstalledDriver(DriverRefNum refNum, SInt8 ioPermission);
 
  OSErr
  RenameDriver(DriverRefNum refNum, StringPtr newDriverName);
 
  OSErr
  RemoveDriver(DriverRefNum refNum, Boolean immediate);
 
  OSErr
  LookupDrivers(UnitNumber beginningUnit, UnitNumber endingUnit,
                Boolean emptyUnits, ItemCount *returnedRefNums,
                DriverRefNum *refNums);
 
  UnitNumber
  HighestUnitNumber(void);
 
  OSErr
  DriverGestaltOn(DriverRefNum refNum);
 
  OSErr
  DriverGestaltOff(DriverRefNum refNum);
 
  Boolean
  DriverGestaltIsOn(DriverFlags flags);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBOpenSync(__A0)
#endif
  OSErr
  PBOpenSync(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBOpenAsync(__A0)
#endif
  OSErr
  PBOpenAsync(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBOpenImmed(__A0)
#endif
  OSErr
  PBOpenImmed(ParmBlkPtr paramBlock);
 
#endif /* CALL_NOT_IN_CARBON */
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBCloseSync(__A0)
#endif
  OSErr
  PBCloseSync(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBCloseAsync(__A0)
#endif
  OSErr
  PBCloseAsync(ParmBlkPtr paramBlock);
 
#if CALL_NOT_IN_CARBON
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBCloseImmed(__A0)
#endif
  OSErr
  PBCloseImmed(ParmBlkPtr paramBlock);
 
#endif /* CALL_NOT_IN_CARBON */
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBReadSync(__A0)
#endif
  OSErr
  PBReadSync(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBReadAsync(__A0)
#endif
  OSErr
  PBReadAsync(ParmBlkPtr paramBlock);
 
#if CALL_NOT_IN_CARBON
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBReadImmed(__A0)
#endif
  OSErr
  PBReadImmed(ParmBlkPtr paramBlock);
 
#endif /* CALL_NOT_IN_CARBON */
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBWriteSync(__A0)
#endif
  OSErr
  PBWriteSync(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBWriteAsync(__A0)
#endif
  OSErr
  PBWriteAsync(ParmBlkPtr paramBlock);
 
#if CALL_NOT_IN_CARBON
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBWriteImmed(__A0)
#endif
  OSErr
  PBWriteImmed(ParmBlkPtr paramBlock);
 
#endif /* CALL_NOT_IN_CARBON */
 
  OSErr
  PBWaitIOComplete(ParmBlkPtr paramBlock, Duration timeout);
 
  /* AddDrive and GetDrvQHdr are now defined in Disks.h/p/a */
 
#if CALL_NOT_IN_CARBON
  DCtlHandle
  GetDCtlEntry(short refNum);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 DriverInstall(__A0, __D0)
#endif
  OSErr
  DriverInstall(DRVRHeaderPtr drvrPtr, short refNum);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 DriverInstallReserveMem(__A0, __D0)
#endif
  OSErr
  DriverInstallReserveMem(DRVRHeaderPtr drvrPtr, short refNum);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 DrvrRemove(__D0)
#endif
  OSErr
  DrvrRemove(short refNum);
 
#endif /* CALL_NOT_IN_CARBON */
 
#define DriverRemove(refNum) DrvrRemove(refNum)
 
#if CALL_NOT_IN_CARBON
#if TARGET_OS_MAC
#define MacOpenDriver OpenDriver
#endif
  OSErr
  MacOpenDriver(ConstStr255Param name, short *drvrRefNum);
 
#if TARGET_OS_MAC
#define MacCloseDriver CloseDriver
#endif
  OSErr
  MacCloseDriver(short refNum);
 
  OSErr
  Control(short refNum, short csCode, const void *csParamPtr);
 
  OSErr
  Status(short refNum, short csCode, void *csParamPtr);
 
  OSErr
  KillIO(short refNum);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 Fetch(__A1)
#endif
  long
  Fetch(DCtlPtr dce);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 Stash(__A1, __D0)
#endif
  long
  Stash(DCtlPtr dce, char data);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter IODone(__A1, __D0)
#endif
  void
  IODone(DCtlPtr dce, OSErr ioResult);
 
#endif /* CALL_NOT_IN_CARBON */
 
#if CALL_NOT_IN_CARBON
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBControlSync(__A0)
#endif
  OSErr
  PBControlSync(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBControlAsync(__A0)
#endif
  OSErr
  PBControlAsync(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBControlImmed(__A0)
#endif
  OSErr
  PBControlImmed(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBStatusSync(__A0)
#endif
  OSErr
  PBStatusSync(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBStatusAsync(__A0)
#endif
  OSErr
  PBStatusAsync(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBStatusImmed(__A0)
#endif
  OSErr
  PBStatusImmed(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBKillIOSync(__A0)
#endif
  OSErr
  PBKillIOSync(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBKillIOAsync(__A0)
#endif
  OSErr
  PBKillIOAsync(ParmBlkPtr paramBlock);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PBKillIOImmed(__A0)
#endif
  OSErr
  PBKillIOImmed(ParmBlkPtr paramBlock);
 
  short
  OpenDeskAcc(ConstStr255Param deskAccName);
 
  if (HiWord(mr) == FILE_MENU)
  { /* in File menu? */
    if (LoWord(mr) == CLOSE_ITM)
    { /* Close Item ? */
      if (isMyWindow(FrontWindow()))
      {
        /* if it's mine */
        /* ... close one of my application's windows ..*/
      }
      else
      { /* must be a DA window */
        wPeek = (WindowPeek)FrontWindow();
        CloseDeskAcc(wPeek->windowKind);
      }
    }
    </ pre>
                * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
                                                          *    \non_carbon_cfm in InterfaceLib 7.1 and
        later
                *    \carbon_lib not available *    \mac_os_x not available *
            /
            void
            CloseDeskAcc(short refNum);
 
#endif /* CALL_NOT_IN_CARBON */
 
#if CALL_NOT_IN_CARBON
    short
    opendeskacc(const char *deskAccName);
 
    OSErr
    opendriver(const char *driverName, short *refNum);
 
#endif /* CALL_NOT_IN_CARBON */
 
#define PBControl(pb, async) ((async) ? PBControlAsync(pb) : PBControlSync(pb))
#define PBStatus(pb, async) ((async) ? PBStatusAsync(pb) : PBStatusSync(pb))
#define PBKillIO(pb, async) ((async) ? PBKillIOAsync(pb) : PBKillIOSync(pb))
 
#define PBOpen(pb, async) ((async) ? PBOpenAsync(pb) : PBOpenSync(pb))
#define PBClose(pb, async) ((async) ? PBCloseAsync(pb) : PBCloseSync(pb))
#define PBRead(pb, async) ((async) ? PBReadAsync(pb) : PBReadSync(pb))
#define PBWrite(pb, async) ((async) ? PBWriteAsync(pb) : PBWriteSync(pb))
 
#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 /* __DEVICES__ */
  */*/