home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / Apple Shared Library Manager / ASLM Developer Tools / Interfaces / PInterfaces / LibraryManagerUtilities.p < prev   
Encoding:
Text File  |  1996-11-19  |  20.3 KB  |  470 lines  |  [TEXT/MPS ]
  1. {
  2.     File:        LibraryManagerUtilities.p
  3.  
  4.     Contains:    Interfaces file for ASLM utilities
  5.  
  6.     Copyright:    © 1991-1994 by Apple Computer, Inc., all rights reserved.
  7.  
  8. }
  9.  
  10.  
  11. {$IFC UNDEFINED UsingIncludes}
  12. {$SETC UsingIncludes := 0}
  13. {$ENDC}
  14.  
  15. {$IFC NOT UsingIncludes}
  16.  UNIT LibraryManagerUtilities;
  17.  INTERFACE
  18. {$ENDC}
  19.  
  20. {$IFC UNDEFINED UsingLibraryManagerUtilities}
  21. {$SETC UsingLibraryManagerUtilities := 1}
  22.  
  23. {$I+}
  24. {$SETC LibraryManagerUtilitiesIncludes := UsingIncludes}
  25. {$SETC UsingIncludes := 1}
  26. {$IFC UNDEFINED UsingLibraryManager}
  27. {$I LibraryManager.p}
  28. {$ENDC}
  29. {$SETC UsingIncludes := LibraryManagerUtilitiesIncludes}
  30.  
  31. {******************************************************************************
  32. ** Forward class declarations
  33. *******************************************************************************}
  34.  
  35. TYPE
  36.     TNotifierPtr        = Ptr;
  37.     TLibraryFilePtr        = Ptr;
  38.     TLibraryPtr            = Ptr;
  39.     TFunctionSetInfoPtr    = Ptr;
  40.     TMemoryPoolPtr        = Ptr;
  41.  
  42. {******************************************************************************
  43. ** Routines for loading and unloading the ASLM.
  44. **
  45. ** UnloadLibraryManager and LoadLibraryManager can be bad for your health! 
  46. ** They should only be used for testing purposes.
  47. *******************************************************************************}
  48.  
  49. FUNCTION    IsLibraryManagerLoaded: Boolean; C;
  50. FUNCTION    LoadLibraryManager: Boolean; C;    { returns true if successful or already loaded }
  51. PROCEDURE    UnloadLibraryManager ; C;
  52.  
  53. {*******************************************************************************
  54. ** Routines for allocating memory out of TMemoryPools.
  55. **
  56. ** The following routines allow Pascal users to allocate memory from TMemoryPools.
  57. ** SLMNewOperator is used for doing allocations and SLMDeleteOperator is 
  58. ** used for freeing memory. SLMNewOperator will allocate memory out of
  59. ** the specified pool. If you pass in NULL for the pool then it will use
  60. ** default memory allocation. The default memory allocation is to allocate
  61. ** out of the the library's local pool if the library was built with
  62. ** memory=local, and out of the client's local pool if the library was built
  63. ** with memory=client. If you don't want to use default memory allocation then
  64. ** you can call GetLocalPool to get the library's local pool, and GetClientPool
  65. ** to get the current client's local pool.
  66. ********************************************************************************}
  67.  
  68. FUNCTION    SLMNewOperator(memsize : LONGINT; pool : TMemoryPoolPtr) : Ptr; C;
  69. PROCEDURE    SLMDeleteOperator(memory : Ptr); C;
  70.  
  71. {******************************************************************************
  72. ** GetSLMVersion
  73. **
  74. ** Returns the version of the installed ASLM in the 'vers'
  75. ** resource format (the first 4 bytes only). Returns 0 if the
  76. ** ASLM is not installed.
  77. *******************************************************************************}
  78.  
  79. FUNCTION GetSLMVersion: LONGINT; C;
  80.  
  81. {*******************************************************************************
  82. ** Trace
  83. **
  84. ** Used to send output to the Trace Montior's Window.
  85. ********************************************************************************}
  86.  
  87. PROCEDURE Trace(outString : StringPtr); C;
  88.  
  89. {******************************************************************************
  90. ** Utility functions for getting high and low bytes and words
  91. *******************************************************************************}
  92.  
  93. FUNCTION HighWord(l : LongInt): INTEGER; INLINE
  94.     $201F,            { move.l    (sp)+,d0    }
  95.     $4840,            { swap        d0            }
  96.     $3E80;            { move.w    d0,(sp)        }
  97.  
  98. FUNCTION LowWord(l : LongInt): INTEGER; INLINE
  99.     $201F,            { move.l    (sp)+,d0    }
  100.     $3E80;            { move.w    d0,(sp)        }
  101.  
  102. FUNCTION HighByte(i : INTEGER): Byte; INLINE
  103.     $301F,            { move.w    (sp)+,d0    }
  104.     $E048,            { lsr.w        #8,d0        }
  105.     $3E80;            { move.w    d0,(sp)        }
  106.  
  107. FUNCTION LowByte(i : INTEGER): Byte; INLINE
  108.     $301F,            { move.w    (sp)+,d0    }
  109.     $0240, $00FF,    { andi.w    #$0FF,d0    }
  110.     $3E80;            { move.w    d0,(sp)        }
  111.  
  112. {******************************************************************************
  113. ** Atomic Bit functions
  114. **
  115. ** These functions atomically set and clear bits, and return what value the
  116. ** bit previously had
  117. *******************************************************************************}
  118.  
  119. FUNCTION    SetBit(mem : Ptr; bitno : LONGINT): Boolean; C;
  120. FUNCTION    ClearBit(mem : Ptr; bitno : LONGINT): Boolean; C;
  121. FUNCTION    TestBit(mem : Ptr; bitno : LONGINT): Boolean; C;
  122.  
  123. {******************************************************************************
  124. ** Memory Functions
  125. **
  126. ** SLMmemcpy, SLMmemmove, and SLMmemset are equivalent to the C memcpy, memmove,
  127. ** and memset routines. They are exported by SLM and are faster then the C versions.
  128. *******************************************************************************}
  129.  
  130. PROCEDURE    ZeroMem(destPtr : Ptr; nBytes : LONGINT); C;
  131. FUNCTION    SLMmemcpy(destPtr : Ptr; src : Ptr; nBytes : LONGINT): Ptr; C;
  132. FUNCTION    SLMmemmove(destPtr : Ptr; src : Ptr; nBytes : LONGINT): Ptr; C;
  133. FUNCTION    SLMmemset(destPtr : Ptr; c : LONGINT; nBytes : LONGINT): Ptr; C;
  134.  
  135. {**********************************************************************
  136. ** TFileSpec
  137. **
  138. ** TFileSpec is a structure for specifying the location of a library
  139. ** file (TLibraryFile) in a file system or OS independent way. The 
  140. ** "subclasses" contain the details and the "base class" is used to compare
  141. ** them or to pass them around without worry about the contents.
  142. **
  143. ** Currently only the TMacFileSpec is supported since this is how the
  144. ** SLM tracks library files on the Mac OS. There is a chance that in the
  145. ** furture it may track files under System 7.0 using TFileIDFileSpec so
  146. ** you should write your 7.0 code to handle either type. The
  147. ** IsFileSpecTypeSupported() routine will tell you if the specified
  148. ** TFileSpec subclass is supported.
  149. **
  150. ** Generally you don't need to be concerned with with TFileSpecs unless
  151. ** you are going to call RegisterLibraryFile(), RegisterLibraryFileFolder(),
  152. ** or GetFileSpec().
  153. ***********************************************************************}
  154.  
  155. { Different types of TFileSpecs we can have. }
  156. TYPE FileSpecType =
  157. (
  158.     kUnknownType, kMacType, kFileIDType
  159. );
  160.  
  161. FUNCTION IsFileSpecTypeSupported(theType : FileSpecType): Boolean; C;
  162. FUNCTION CompareFileSpecs(f1 : Ptr; f2 : Ptr): Boolean; C;
  163.  
  164. TYPE TFileSpec = RECORD
  165.     fType:            FileSpecType;        { FileSpectype }
  166.     fSize:            Byte;                { size of struct }
  167. END;
  168. TYPE TFileSpecPtr = ^TFileSpec;
  169.  
  170. {**********************************************************************
  171. ** TMacFileSpec
  172. **
  173. ** TMacFileSpec keeps track of the file by using an file name, volume
  174. ** refNum, and directory id. You must use InitMacFileSpec to make
  175. ** sure that the length is set properly.
  176. ***********************************************************************}
  177.  
  178. TYPE TMacFileSpec = RECORD
  179.     fType:            FileSpecType;        { FileSpectype }
  180.     fSize:            Byte;                { size of struct }
  181.     fVRefNum:        INTEGER;            { volume refNum of volume file is on }
  182.     fParID:            LONGINT;            { dirID of the folder file is in }
  183.     fName:            Str63;                { name of the file }
  184. END;        
  185. TYPE TMacFileSpecPtr    = ^TMacFileSpec;
  186.     
  187. PROCEDURE InitMacFileSpec(spec : TMacFileSpecPtr; vRefNum : INTEGER;
  188.     parID : LONGINT; name : Str63); C;
  189.  
  190. {**********************************************************************
  191. ** TFileIDFileSpec
  192. **
  193. ** TFileIDFileSpec keeps track of library files by fileID and vRefNum.
  194. ** You must use InitFileIDFileSpec to make sure that the length is set
  195. ** properly.
  196. ***********************************************************************}
  197.  
  198. TYPE TFileIDFileSpec = RECORD
  199.     fType:            FileSpecType;        { FileSpectype }
  200.     fSize:            Byte;                { size of struct }
  201.     fVRefNum:        INTEGER;            { volume refNum }
  202.     fFileID:        LONGINT;            { FileID }
  203. END;
  204. TYPE TFileIDFileSpecPtr    = ^TFileIDFileSpec;
  205.  
  206. PROCEDURE InitFileIDFileSpec(spec : TFileIDFileSpecPtr; vRefNum : INTEGER; fileID : LONGINT); C;
  207.  
  208.  
  209. {*******************************************************************************
  210. ** RegisterLibraryFile/UnregisterLibraryFile
  211. **
  212. ** Used to register or unregister a library file. Currently only the
  213. ** TMacFileSpec is supported. You'll get a kASLMNotSupportedErr error for anything else.
  214. **
  215. ** RegisterLibraryFile returns kNoError if successful or kASLMFileNotFoundErr if
  216. ** an error ocurred while trying to access the file. Other error codes are also
  217. ** possible if there was trouble processing the file such as kASLMOutOfMemoryErr.
  218. **
  219. ** UnregisterLibraryFile accepts a "forceUnload" parameter. If true is passed
  220. ** then it will force all loaded libraries in the library file to be
  221. ** unloaded even if they are in use. Unless you are sure that loaded libraries
  222. ** can be safely unloaded you should pass false. In this case the library file
  223. ** will not be deleted until all of its libraries are unloaded.
  224. ** kNoError will be returned if successful and wil be returend kASLMNotSupportedErr if
  225. ** the folder was never registered.
  226. ********************************************************************************}
  227.  
  228. FUNCTION    RegisterLibraryFile(fileSpec : TFileSpecPtr; VAR libFile : TLibraryFilePtr): OSErr; C;
  229. FUNCTION    UnregisterLibraryFile(fileSpec : TFileSpecPtr; forceUnload : Boolean): OSErr; C;
  230. FUNCTION    UnregisterLibraryFileByFileSpec(libFile : TLibraryFilePtr;
  231.                                             forceUnload : Boolean): OSErr; C;
  232.  
  233. {******************************************************************************
  234. ** RegisterLibraryFileFolder/UnregisterLibraryFileFolder
  235. **
  236. ** Used to register a folder that contains library files in it. The SLM will keep
  237. ** track of library files dragged into and out of this folder. Currently only the
  238. ** TMacFileSpec is supported. You'll get a kASLMNotSupportedErr error for anything else.
  239. **
  240. ** RegisterLibraryFileFolder returns kNoError if successful or kASLMFileNotFoundErr if
  241. ** an error ocurred while trying to access the folder.
  242. **
  243. ** UnregisterLibraryFileFolder accepts a "forceUnload" parameter. If true is passed
  244. ** then it will unregister the folder and force all loaded libraries to be
  245. ** unloaded even if they are in use. Unless you are sure that loaded libraries
  246. ** can be safely unloaded you should pass false. kNoError will be returned if
  247. ** successful, kASLMFolderNotFoundErr if the folder was never registered, and
  248. ** kASLMFolderInUseErr if any libraries in the folder were loaded and false was passed
  249. ** in the forceUnload parameter.
  250. *******************************************************************************}
  251.  
  252. FUNCTION    RegisterLibraryFileFolder(fileSpec : TFileSpecPtr): OSErr; C;
  253. FUNCTION    UnregisterLibraryFileFolder(fileSpec : TFileSpecPtr; forceUnload : Boolean): OSErr; C;
  254.  
  255. {******************************************************************************
  256. ** EnterSystemMode/LeaveSystemMode
  257. **
  258. ** These functions should bracket calls that open files or get memory that needs
  259. ** to hang around after an application quits
  260. *******************************************************************************}
  261.  
  262. FUNCTION    EnterSystemMode: Ptr; C;
  263. PROCEDURE    LeaveSystemMode(saveRef : Ptr); C;
  264.  
  265. {******************************************************************************
  266. ** Death Notification
  267. *******************************************************************************}
  268.  
  269. FUNCTION InstallDeathWatcher(notifier : TNotifierPtr): Boolean; C;
  270. FUNCTION RemoveDeathWatcher(notifier : TNotifierPtr): Boolean; C;
  271.  
  272. {******************************************************************************
  273. ** EnterInterrupt/LeaveInterrupt
  274. **
  275. ** These functions should be called when you are in an interrupt service routine
  276. ** or a deferred task and you want to do something that will cause ASLM
  277. ** code to be executed such as allocating pool memory or newing an object. The
  278. ** ASLM needs to know that it is at interrupt time so it doesn't do
  279. ** anything stupid like try to allocate memory or load library code. This doesn't
  280. ** mean that all ASLM calls are safe at interrupt time, just that the
  281. ** ones that claim to be safe will only be safe if you do an EnterInterrupt call
  282. ** first.
  283. **
  284. ** You don't need to use these routines when your interrupt service routine is
  285. ** scheduling an operation on a TInterruptScheduler, when the operation gets
  286. ** executed at deferred task time, or when a TTimeScheduler operation gets
  287. ** executed. In the former case the ASLM is smart enough to realize
  288. ** that you are at interrupt time and in the later two cases the
  289. ** ASLM does an EnterInterrupt before calling your operation and a
  290. ** LeaveInterrupt when your operation returns.
  291. *******************************************************************************}
  292.  
  293. PROCEDURE    EnterInterrupt; C;
  294. PROCEDURE    LeaveInterrupt; C;
  295.  
  296. {******************************************************************************
  297. ** AtInterruptLevel
  298. **
  299. ** This function returns true if we are currently executing at non-system-task
  300. ** time.
  301. *******************************************************************************}
  302.  
  303. FUNCTION AtInterruptLevel: Boolean; C;
  304.  
  305. {******************************************************************************
  306. ** InInterruptScheduler
  307. **
  308. ** This function returns true if we are currently running an interrupt scheduler
  309. *******************************************************************************}
  310.  
  311. FUNCTION InInterruptScheduler: Boolean; C;
  312.  
  313. {*********************************************************************
  314. ** GlobalWorld routines
  315. **
  316. ** InitGlobalWorld will create and initialize the global world for
  317. ** standalone code on the MacOS such as INITs and CDEVs. It also does
  318. ** a SetCurrentGlobalWorld. FreeGlobalWorld will free the memory used
  319. ** by the global world created by InitGlobalWorld.
  320. **
  321. ** EnterCodeResource is also used by stand alone code resources. It is
  322. ** most useful when the code resource only calls InitLibraryManager once
  323. ** but may then be reentered multiple times before calling CleanupLibraryManager.
  324. ** EnterCodeResoruce will set the current global world to the code resources
  325. ** global world and set the code resource as the current client.
  326. ** LeaveCodeResource will undo what EnterCodeResource does. These routines
  327. ** are NOT reentrant. You must call InitCodeResource before calling
  328. ** EnterCodeResource. It will call InitGlobalWorld and save the global world
  329. ** pointer in a PC-relative location so EnterCodeResource can access it.
  330. **
  331. ** SetCurrentGlobalWorld and GetCurrentGlobalWorld used for getting and
  332. ** setting A5 on the MacOS.
  333. **
  334. ** GetGlobalWorld is used to get the global world pointer for a Library.
  335. ** OpenGlobalWorld will make the library's global world the current global
  336. ** world. It's the same as calling SetCurrentGlobalWorld(GetGlobalWorld).
  337. ** CloseGlobalWorld is used to revert back to the global world that was
  338. ** current before calling OpenGlobalWorld. It's the same as calling
  339. ** SetCurrentGlobalWorld(oldWorld) except that it doesn't return a
  340. ** global world.
  341. **
  342. ** Since libraries are always compiled with model far, it's
  343. ** not necessary to do an OpenGlobalWorld before accessing globals or
  344. ** making intersegment calls. Their only purpose is to make the library
  345. ** the current "Client" since the client is determined by the current
  346. ** value of A5 on the MacOS.
  347. **
  348. ** ONLY LIBRARIES AND MODEL FAR CLIENTS SHOULD CALL Get/Open/CloseGlobalWorld.
  349. *******************************************************************************}
  350.  
  351. FUNCTION SetCurrentGlobalWorld(world: GlobalWorld): GlobalWorld; INLINE
  352.     $2F4D,$0004,    { MOVE        A5,4(A7)    }
  353.     $2A5F;            { MOVE.A    A7+,A5        }
  354. FUNCTION GetCurrentGlobalWorld: GlobalWorld; INLINE
  355.     $200D;            { MOVE.l    A5,D0        }
  356.  
  357. FUNCTION    InitGlobalWorld: OSErr; C;    { called by standalone code only!!! }
  358. PROCEDURE    FreeGlobalWorld; C;            { called by standalone code only!!! }
  359.  
  360. FUNCTION    InitCodeResource: OSErr; C;    { called by standalone code only!!! }
  361. PROCEDURE    EnterCodeResource; C;        { called by standalone code only!!! }
  362. PROCEDURE    LeaveCodeResource; C;        { called by standalone code only!!! }
  363.     
  364. FUNCTION    GetCurrentClient: TLibraryManagerPtr; C;
  365. FUNCTION    SetCurrentClient(libMgr : TLibraryManagerPtr): TLibraryManagerPtr; C;
  366. FUNCTION    SetSelfAsClient: TLibraryManagerPtr; C;    { set owner of code making call as current client }
  367. FUNCTION    SetClientToWorld: TLibraryManagerPtr; C;    { set owner of current global world as current }
  368.     
  369.        
  370. FUNCTION    GetGlobalWorld: GlobalWorld; C;
  371. FUNCTION    OpenGlobalWorld: GlobalWorld; C;
  372. PROCEDURE    CloseGlobalWorld(newA5 : LONGINT); INLINE
  373.     $2A5F;            { MOVE.A    A7+,A5        }
  374.  
  375. {*********************************************************************
  376. ** TLibraryFile Pascal interface
  377. **
  378. ** The Pascal interface to the TLibraryFile class defined in 
  379. ** LibraryManagerClasses.h. Used mainly to get resources out of a library file.
  380. *******************************************************************************}
  381.  
  382. FUNCTION    GetLocalLibraryFile: TLibraryFilePtr; C;
  383.  
  384. FUNCTION    GetSharedResource(libFile : TLibraryFilePtr; theType : ResType;
  385.                             theID : INTEGER; VAR err : OSErr): Ptr; C;
  386. FUNCTION    GetSharedIndResource(libFile : TLibraryFilePtr; theType : ResType;
  387.                             index : INTEGER; VAR err : OSErr): Ptr; C;
  388. FUNCTION    GetSharedNamedResource(libFile : TLibraryFilePtr; theType : ResType;
  389.                             name : Str255; VAR err : OSErr): Ptr; C;
  390.  
  391. PROCEDURE    ReleaseSharedResource(libFile : TLibraryFilePtr; resource : Ptr); C;
  392. FUNCTION    CountSharedResources(libFile : TLibraryFilePtr; theType : ResType): LONGINT; C;
  393.  
  394. FUNCTION    GetSharedResourceUseCount(libFile : TLibraryFilePtr; resource : Ptr): LONGINT; C;
  395. FUNCTION    GetSharedResourceInfo(libFile : TLibraryFilePtr; resource : Ptr;
  396.                                   VAR theSize : LONGINT; VAR theID : INTEGER;
  397.                                   VAR theType : ResType; VAR theName : Str255): OSErr; C;
  398.  
  399. FUNCTION    GetFileSpec(libFile : TLibraryFilePtr): TFileSpecPtr; C;
  400. FUNCTION    GetRefNum(libFile : TLibraryFilePtr): LONGINT; C;
  401.  
  402. FUNCTION    OpenLibraryFile(libFile : TLibraryFilePtr): OSErr; C;
  403. FUNCTION    CloseLibraryFile(libFile : TLibraryFilePtr): OSErr; C;
  404.     
  405. FUNCTION    Preflight(libFile : TLibraryFilePtr; VAR savedRefNum : LONGINT): OSErr; C;
  406. FUNCTION    Postflight(libFile : TLibraryFilePtr; savedRefNum : LONGINT): OSErr; C;
  407.  
  408. {**********************************************************************
  409. ** TClassInfo Pascal interface
  410. **
  411. ** The C interface to the TClassInfo class. Used mainly to get information
  412. ** about function sets. It is most useful for iterating over all function sets
  413. ** with a common interface. This can be done by giving the functions sets the
  414. ** same "parent id" when exporting each function set.
  415. **
  416. ** Note, TClassInfo can also be used to iterate over function sets and
  417. ** the routines given below can also be used iterate over classes.
  418. ***********************************************************************}
  419.  
  420. FUNCTION    GetFunctionSetInfo(id : TFunctionSetID; VAR err : OSErr): TFunctionSetInfoPtr; C;
  421. PROCEDURE    FreeFunctionSetInfo(info : TFunctionSetInfoPtr); C;
  422.  
  423. PROCEDURE    FSInfoReset(info : TFunctionSetInfoPtr); C;
  424. FUNCTION    FSInfoNext(info : TFunctionSetInfoPtr): TFunctionSetID; C;
  425. FUNCTION    FSInfoIterationComplete(info : TFunctionSetInfoPtr): Boolean; C;
  426.  
  427. FUNCTION    FSInfoGetFunctionSetID(info : TFunctionSetInfoPtr): TFunctionSetID; C;
  428. FUNCTION    FSInfoGetInterfaceID(info : TFunctionSetInfoPtr; idx : LONGINT): TFunctionSetID; C;
  429. FUNCTION    FSInfoGetLibrary(info : TFunctionSetInfoPtr): TLibraryPtr; C;
  430. FUNCTION    FSInfoGetLibraryFile(info : TFunctionSetInfoPtr): TLibraryFilePtr; C;
  431. FUNCTION    FSInfoGetVersion(info : TFunctionSetInfoPtr): INTEGER; C;
  432. FUNCTION    FSInfoGetMinVersion(info : TFunctionSetInfoPtr): INTEGER; C;
  433.  
  434.  
  435. {*********************************************************************
  436. ** TLibrary Pascal interface
  437. **
  438. ** The Pascal interface to the TLibrary class. Used mainly to manipulate
  439. ** code segments in a library.
  440. **********************************************************************}
  441.  
  442. FUNCTION    GetLibraryFile(lib : TLibraryPtr): TLibraryFilePtr ; C;
  443. FUNCTION    LoadCodeSegmentByNumber(lib : TLibraryPtr; segmentNumber : INTEGER): OSErr; C;
  444. FUNCTION    LoadCodeSegmentByRoutine(lib : TLibraryPtr; routine : ProcPtr): OSErr; C;
  445. FUNCTION    UnloadCodeSegmentByNumber(lib : TLibraryPtr; segmentNumber : INTEGER): OSErr; C;
  446. FUNCTION    UnloadCodeSegmentByRoutine(lib : TLibraryPtr; routine : ProcPtr): OSErr; C;
  447.  
  448. {*********************************************************************
  449. ** Routines that will get a TLibrary object
  450. **********************************************************************}
  451.  
  452. FUNCTION    GetLocalLibrary: TLibraryPtr; C;
  453. FUNCTION    LookupLibrary(libraryID : TLibraryID): TLibraryPtr; C; 
  454. FUNCTION    LookupLibraryWithClassID(classID : TClassID): TLibraryPtr; C;
  455. FUNCTION    LookupLibraryWithFunctionSetID(functionSetID : TFunctionSetID): TLibraryPtr; C;
  456.  
  457. {*********************************************************************
  458. ** Per Client data routines
  459. **********************************************************************}
  460.  
  461. FUNCTION    GetClientData: Ptr; C;
  462. FUNCTION    GetLibraryClientData(library : TLibraryPtr): Ptr ; C;
  463.  
  464. {$ENDC}    { UsingLibraryManagerUtilities }
  465.  
  466. {$IFC NOT UsingIncludes}
  467.     END.
  468. {$ENDC}
  469.  
  470.