← Back to branch summary

~ubuntu-branches/debian/lenny/fpc/lenny

« back to all changes in this revision

Viewing changes to fpcsrc/packages/extra/univint/MacMemory.pas

  • Committer: Bazaar Package Importer
  • Author(s): Mazen Neifer, Torsten Werner, Mazen Neifer
  • Date: 2008-05-17 17:12:11 UTC
  • mfrom: (3.1.9 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080517171211-9qi33xhd9evfa0kg
Tags: 2.2.0-dfsg1-9
http://bugs.debian.org/477743
[ Torsten Werner ]
* Add Mazen Neifer to Uploaders field.

[ Mazen Neifer ]
* Moved FPC sources into a version dependent directory from /usr/share/fpcsrc
  to /usr/share/fpcsrc/${FPCVERSION}. This allow installing more than on FPC
  release.
* Fixed far call issue in compiler preventing building huge binearies.
  (closes: #477743)
* Updated building dependencies, recomennded and suggested packages.
* Moved fppkg to fp-utils as it is just a helper tool and is not required by
  compiler.

Show diffs side-by-side

added added

removed removed

Lines of Context:
fpcsrc/packages/extra/univint/MacMemory.pas
 
1
{
 
2
     File:       MacMemory.p
 
3
 
 
4
     Contains:   Memory Manager Interfaces.
 
5
 
 
6
     Version:    Technology: Mac OS 9
 
7
                 Release:    Universal Interfaces 3.4.2
 
8
 
 
9
     Copyright:  � 1985-2002 by Apple Computer, Inc., all rights reserved
 
10
 
 
11
     Bugs?:      For bug reports, consult the following page on
 
12
                 the World Wide Web:
 
13
 
 
14
                     http://www.freepascal.org/bugs.html
 
15
 
 
16
}
 
17
 
 
18
 
 
19
{
 
20
    Modified for use with Free Pascal
 
21
    Version 200
 
22
    Please report any bugs to <gpc@microbizz.nl>
 
23
}
 
24
 
 
25
{$mode macpas}
 
26
{$packenum 1}
 
27
{$macro on}
 
28
{$inline on}
 
29
{$CALLING MWPASCAL}
 
30
 
 
31
unit MacMemory;
 
32
interface
 
33
{$setc UNIVERSAL_INTERFACES_VERSION := $0342}
 
34
{$setc GAP_INTERFACES_VERSION := $0200}
 
35
 
 
36
{$ifc not defined USE_CFSTR_CONSTANT_MACROS}
 
37
    {$setc USE_CFSTR_CONSTANT_MACROS := TRUE}
 
38
{$endc}
 
39
 
 
40
{$ifc defined CPUPOWERPC and defined CPUI386}
 
41
        {$error Conflicting initial definitions for CPUPOWERPC and CPUI386}
 
42
{$endc}
 
43
{$ifc defined FPC_BIG_ENDIAN and defined FPC_LITTLE_ENDIAN}
 
44
        {$error Conflicting initial definitions for FPC_BIG_ENDIAN and FPC_LITTLE_ENDIAN}
 
45
{$endc}
 
46
 
 
47
{$ifc not defined __ppc__ and defined CPUPOWERPC}
 
48
        {$setc __ppc__ := 1}
 
49
{$elsec}
 
50
        {$setc __ppc__ := 0}
 
51
{$endc}
 
52
{$ifc not defined __i386__ and defined CPUI386}
 
53
        {$setc __i386__ := 1}
 
54
{$elsec}
 
55
        {$setc __i386__ := 0}
 
56
{$endc}
 
57
 
 
58
{$ifc defined __ppc__ and __ppc__ and defined __i386__ and __i386__}
 
59
        {$error Conflicting definitions for __ppc__ and __i386__}
 
60
{$endc}
 
61
 
 
62
{$ifc defined __ppc__ and __ppc__}
 
63
        {$setc TARGET_CPU_PPC := TRUE}
 
64
        {$setc TARGET_CPU_X86 := FALSE}
 
65
{$elifc defined __i386__ and __i386__}
 
66
        {$setc TARGET_CPU_PPC := FALSE}
 
67
        {$setc TARGET_CPU_X86 := TRUE}
 
68
{$elsec}
 
69
        {$error Neither __ppc__ nor __i386__ is defined.}
 
70
{$endc}
 
71
{$setc TARGET_CPU_PPC_64 := FALSE}
 
72
 
 
73
{$ifc defined FPC_BIG_ENDIAN}
 
74
        {$setc TARGET_RT_BIG_ENDIAN := TRUE}
 
75
        {$setc TARGET_RT_LITTLE_ENDIAN := FALSE}
 
76
{$elifc defined FPC_LITTLE_ENDIAN}
 
77
        {$setc TARGET_RT_BIG_ENDIAN := FALSE}
 
78
        {$setc TARGET_RT_LITTLE_ENDIAN := TRUE}
 
79
{$elsec}
 
80
        {$error Neither FPC_BIG_ENDIAN nor FPC_LITTLE_ENDIAN are defined.}
 
81
{$endc}
 
82
{$setc ACCESSOR_CALLS_ARE_FUNCTIONS := TRUE}
 
83
{$setc CALL_NOT_IN_CARBON := FALSE}
 
84
{$setc OLDROUTINENAMES := FALSE}
 
85
{$setc OPAQUE_TOOLBOX_STRUCTS := TRUE}
 
86
{$setc OPAQUE_UPP_TYPES := TRUE}
 
87
{$setc OTCARBONAPPLICATION := TRUE}
 
88
{$setc OTKERNEL := FALSE}
 
89
{$setc PM_USE_SESSION_APIS := TRUE}
 
90
{$setc TARGET_API_MAC_CARBON := TRUE}
 
91
{$setc TARGET_API_MAC_OS8 := FALSE}
 
92
{$setc TARGET_API_MAC_OSX := TRUE}
 
93
{$setc TARGET_CARBON := TRUE}
 
94
{$setc TARGET_CPU_68K := FALSE}
 
95
{$setc TARGET_CPU_MIPS := FALSE}
 
96
{$setc TARGET_CPU_SPARC := FALSE}
 
97
{$setc TARGET_OS_MAC := TRUE}
 
98
{$setc TARGET_OS_UNIX := FALSE}
 
99
{$setc TARGET_OS_WIN32 := FALSE}
 
100
{$setc TARGET_RT_MAC_68881 := FALSE}
 
101
{$setc TARGET_RT_MAC_CFM := FALSE}
 
102
{$setc TARGET_RT_MAC_MACHO := TRUE}
 
103
{$setc TYPED_FUNCTION_POINTERS := TRUE}
 
104
{$setc TYPE_BOOL := FALSE}
 
105
{$setc TYPE_EXTENDED := FALSE}
 
106
{$setc TYPE_LONGLONG := TRUE}
 
107
uses MacTypes,MixedMode;
 
108
 
 
109
 
 
110
{$ALIGN MAC68K}
 
111
 
 
112
 
 
113
const
 
114
        maxSize                                         = $7FFFFFF0;                                    { the largest block possible }
 
115
 
 
116
        defaultPhysicalEntryCount       = 8;
 
117
 
 
118
                                                                                                                                {  values returned from the GetPageState function  }
 
119
        kPageInMemory                           = 0;
 
120
        kPageOnDisk                                     = 1;
 
121
        kNotPaged                                       = 2;
 
122
 
 
123
                                                                                                                                {  masks for Zone->heapType field  }
 
124
        k32BitHeap                                      = 1;                                                    {  valid in all Memory Managers  }
 
125
        kNewStyleHeap                           = 2;                                                    {  true if new Heap Manager is present  }
 
126
        kNewDebugHeap                           = 4;                                                    {  true if new Heap Manager is running in debug mode on this heap  }
 
127
 
 
128
 
 
129
        {  bits for use with HGetState/HSetState }
 
130
        kHandleIsResourceBit            = 5;
 
131
        kHandlePurgeableBit                     = 6;
 
132
        kHandleLockedBit                        = 7;
 
133
 
 
134
        {  masks for use with HGetState/HSetState }
 
135
        kHandleIsResourceMask           = $20;
 
136
        kHandlePurgeableMask            = $40;
 
137
        kHandleLockedMask                       = $80;
 
138
 
 
139
 
 
140
type
 
141
{$ifc TYPED_FUNCTION_POINTERS}
 
142
        GrowZoneProcPtr = function(cbNeeded: Size): SInt32;
 
143
{$elsec}
 
144
        GrowZoneProcPtr = ProcPtr;
 
145
{$endc}
 
146
 
 
147
{$ifc TYPED_FUNCTION_POINTERS}
 
148
        PurgeProcPtr = procedure(blockToPurge: Handle);
 
149
{$elsec}
 
150
        PurgeProcPtr = ProcPtr;
 
151
{$endc}
 
152
 
 
153
{$ifc TYPED_FUNCTION_POINTERS}
 
154
        UserFnProcPtr = procedure(parameter: UnivPtr);
 
155
{$elsec}
 
156
        UserFnProcPtr = Register68kProcPtr;
 
157
{$endc}
 
158
 
 
159
{$ifc OPAQUE_UPP_TYPES}
 
160
        GrowZoneUPP = ^SInt32; { an opaque UPP }
 
161
{$elsec}
 
162
        GrowZoneUPP = UniversalProcPtr;
 
163
{$endc} 
 
164
{$ifc OPAQUE_UPP_TYPES}
 
165
        PurgeUPP = ^SInt32; { an opaque UPP }
 
166
{$elsec}
 
167
        PurgeUPP = UniversalProcPtr;
 
168
{$endc} 
 
169
{$ifc OPAQUE_UPP_TYPES}
 
170
        UserFnUPP = ^SInt32; { an opaque UPP }
 
171
{$elsec}
 
172
        UserFnUPP = UniversalProcPtr;
 
173
{$endc} 
 
174
        ZonePtr = ^Zone;
 
175
        Zone = record
 
176
                bkLim:                                  Ptr;
 
177
                purgePtr:                               Ptr;
 
178
                hFstFree:                               Ptr;
 
179
                zcbFree:                                SInt32;
 
180
                gzProc:                                 GrowZoneUPP;
 
181
                moreMast:                               SInt16;
 
182
                flags:                                  SInt16;
 
183
                cntRel:                                 SInt16;
 
184
                maxRel:                                 SInt16;
 
185
                cntNRel:                                SInt16;
 
186
                heapType:                               SInt8;                                                                  {  previously "maxNRel", now holds flags (e.g. k32BitHeap) }
 
187
                unused:                                 SInt8;
 
188
                cntEmpty:                               SInt16;
 
189
                cntHandles:                             SInt16;
 
190
                minCBFree:                              SInt32;
 
191
                purgeProc:                              PurgeUPP;
 
192
                sparePtr:                               Ptr;
 
193
                allocPtr:                               Ptr;
 
194
                heapData:                               SInt16;
 
195
        end;
 
196
 
 
197
        THz                                                                     = ^Zone;
 
198
        THzPtr                                                          = ^THz;
 
199
        MemoryBlockPtr = ^MemoryBlock;
 
200
        MemoryBlock = record
 
201
                address:                                Ptr;
 
202
                count:                                  UInt32;
 
203
        end;
 
204
 
 
205
        LogicalToPhysicalTablePtr = ^LogicalToPhysicalTable;
 
206
        LogicalToPhysicalTable = record
 
207
                logical:                                MemoryBlock;
 
208
                physical:                               array [0..7] of MemoryBlock;
 
209
        end;
 
210
 
 
211
        PageState                                                       = SInt16;
 
212
        StatusRegisterContents                          = SInt16;
 
213
 
 
214
const
 
215
        kVolumeVirtualMemoryInfoVersion1 = 1;                                           {  first version of VolumeVirtualMemoryInfo }
 
216
 
 
217
 
 
218
type
 
219
        VolumeVirtualMemoryInfoPtr = ^VolumeVirtualMemoryInfo;
 
220
        VolumeVirtualMemoryInfo = record
 
221
                version:                                PBVersion;                                                              {  Input: Version of the VolumeVirtualMemoryInfo structure }
 
222
                volumeRefNum:                   SInt16;                                                                 {  Input: volume reference number }
 
223
                inUse:                                  boolean;                                                                {  output: true if volume is currently used for file mapping }
 
224
                _fill:                                  SInt8;
 
225
                vmOptions:                              UInt32;                                                                 {  output: tells what volume can support (same as DriverGestaltVMOptionsResponse vmOptions bits in DriverGestalt) }
 
226
                                                                                                                                                {  end of kVolumeVirtualMemoryInfoVersion1 structure }
 
227
        end;
 
228
 
 
229
 
 
230
const
 
231
        uppGrowZoneProcInfo = $000000F0;
 
232
        uppPurgeProcInfo = $000000C0;
 
233
        uppUserFnProcInfo = $00009802;
 
234
        {
 
235
         *  NewGrowZoneUPP()
 
236
         *  
 
237
         *  Availability:
 
238
         *    Non-Carbon CFM:   available as macro/inline
 
239
         *    CarbonLib:        in CarbonLib 1.0 and later
 
240
         *    Mac OS X:         in version 10.0 and later
 
241
                }
 
242
function NewGrowZoneUPP(userRoutine: GrowZoneProcPtr): GrowZoneUPP; external name '_NewGrowZoneUPP'; { old name was NewGrowZoneProc }
 
243
{
 
244
 *  NewPurgeUPP()
 
245
 *  
 
246
 *  Availability:
 
247
 *    Non-Carbon CFM:   available as macro/inline
 
248
 *    CarbonLib:        in CarbonLib 1.0 and later
 
249
 *    Mac OS X:         in version 10.0 and later
 
250
 }
 
251
function NewPurgeUPP(userRoutine: PurgeProcPtr): PurgeUPP; external name '_NewPurgeUPP'; { old name was NewPurgeProc }
 
252
{
 
253
 *  NewUserFnUPP()
 
254
 *  
 
255
 *  Availability:
 
256
 *    Non-Carbon CFM:   available as macro/inline
 
257
 *    CarbonLib:        in CarbonLib 1.0 and later
 
258
 *    Mac OS X:         in version 10.0 and later
 
259
 }
 
260
function NewUserFnUPP(userRoutine: UserFnProcPtr): UserFnUPP; external name '_NewUserFnUPP'; { old name was NewUserFnProc }
 
261
{
 
262
 *  DisposeGrowZoneUPP()
 
263
 *  
 
264
 *  Availability:
 
265
 *    Non-Carbon CFM:   available as macro/inline
 
266
 *    CarbonLib:        in CarbonLib 1.0 and later
 
267
 *    Mac OS X:         in version 10.0 and later
 
268
 }
 
269
procedure DisposeGrowZoneUPP(userUPP: GrowZoneUPP); external name '_DisposeGrowZoneUPP';
 
270
{
 
271
 *  DisposePurgeUPP()
 
272
 *  
 
273
 *  Availability:
 
274
 *    Non-Carbon CFM:   available as macro/inline
 
275
 *    CarbonLib:        in CarbonLib 1.0 and later
 
276
 *    Mac OS X:         in version 10.0 and later
 
277
 }
 
278
procedure DisposePurgeUPP(userUPP: PurgeUPP); external name '_DisposePurgeUPP';
 
279
{
 
280
 *  DisposeUserFnUPP()
 
281
 *  
 
282
 *  Availability:
 
283
 *    Non-Carbon CFM:   available as macro/inline
 
284
 *    CarbonLib:        in CarbonLib 1.0 and later
 
285
 *    Mac OS X:         in version 10.0 and later
 
286
 }
 
287
procedure DisposeUserFnUPP(userUPP: UserFnUPP); external name '_DisposeUserFnUPP';
 
288
{
 
289
 *  InvokeGrowZoneUPP()
 
290
 *  
 
291
 *  Availability:
 
292
 *    Non-Carbon CFM:   available as macro/inline
 
293
 *    CarbonLib:        in CarbonLib 1.0 and later
 
294
 *    Mac OS X:         in version 10.0 and later
 
295
 }
 
296
function InvokeGrowZoneUPP(cbNeeded: Size; userRoutine: GrowZoneUPP): SInt32; external name '_InvokeGrowZoneUPP'; { old name was CallGrowZoneProc }
 
297
{
 
298
 *  InvokePurgeUPP()
 
299
 *  
 
300
 *  Availability:
 
301
 *    Non-Carbon CFM:   available as macro/inline
 
302
 *    CarbonLib:        in CarbonLib 1.0 and later
 
303
 *    Mac OS X:         in version 10.0 and later
 
304
 }
 
305
procedure InvokePurgeUPP(blockToPurge: Handle; userRoutine: PurgeUPP); external name '_InvokePurgeUPP'; { old name was CallPurgeProc }
 
306
{
 
307
 *  InvokeUserFnUPP()
 
308
 *  
 
309
 *  Availability:
 
310
 *    Non-Carbon CFM:   available as macro/inline
 
311
 *    CarbonLib:        in CarbonLib 1.0 and later
 
312
 *    Mac OS X:         in version 10.0 and later
 
313
 }
 
314
procedure InvokeUserFnUPP(parameter: UnivPtr; userRoutine: UserFnUPP); external name '_InvokeUserFnUPP'; { old name was CallUserFnProc }
 
315
{$ifc CALL_NOT_IN_CARBON}
 
316
{
 
317
 *  GetApplLimit()
 
318
 *  
 
319
 *  Availability:
 
320
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
321
 *    CarbonLib:        not available
 
322
 *    Mac OS X:         not available
 
323
 }
 
324
function GetApplLimit: Ptr; external name '_GetApplLimit';
 
325
{
 
326
 *  SystemZone()
 
327
 *  
 
328
 *  Availability:
 
329
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
330
 *    CarbonLib:        not available
 
331
 *    Mac OS X:         not available
 
332
 }
 
333
function SystemZone: THz; external name '_SystemZone';
 
334
{
 
335
 *  ApplicationZone()
 
336
 *  
 
337
 *  Availability:
 
338
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
339
 *    CarbonLib:        not available
 
340
 *    Mac OS X:         not available
 
341
 }
 
342
function ApplicationZone: THz; external name '_ApplicationZone';
 
343
{$endc}  {CALL_NOT_IN_CARBON}
 
344
 
 
345
{
 
346
 *  GZSaveHnd()
 
347
 *  
 
348
 *  Availability:
 
349
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
350
 *    CarbonLib:        in CarbonLib 1.0 and later
 
351
 *    Mac OS X:         in version 10.0 and later
 
352
 }
 
353
function GZSaveHnd: Handle; external name '_GZSaveHnd';
 
354
{
 
355
 *  TopMem()
 
356
 *  
 
357
 *  Availability:
 
358
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
359
 *    CarbonLib:        in CarbonLib 1.0 and later
 
360
 *    Mac OS X:         in version 10.0 and later
 
361
 }
 
362
function TopMem: Ptr; external name '_TopMem';
 
363
{
 
364
 *  MemError()
 
365
 *  
 
366
 *  Availability:
 
367
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
368
 *    CarbonLib:        in CarbonLib 1.0 and later
 
369
 *    Mac OS X:         in version 10.0 and later
 
370
 }
 
371
function MemError: OSErr; external name '_MemError';
 
372
{$ifc CALL_NOT_IN_CARBON}
 
373
{
 
374
 *  GetZone()
 
375
 *  
 
376
 *  Availability:
 
377
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
378
 *    CarbonLib:        not available
 
379
 *    Mac OS X:         not available
 
380
 }
 
381
function GetZone: THz; external name '_GetZone';
 
382
{$endc}  {CALL_NOT_IN_CARBON}
 
383
 
 
384
{
 
385
 *  NewHandle()
 
386
 *  
 
387
 *  Availability:
 
388
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
389
 *    CarbonLib:        in CarbonLib 1.0 and later
 
390
 *    Mac OS X:         in version 10.0 and later
 
391
 }
 
392
function NewHandle(byteCount: Size): Handle; external name '_NewHandle';
 
393
{$ifc CALL_NOT_IN_CARBON}
 
394
{
 
395
 *  NewHandleSys()
 
396
 *  
 
397
 *  Availability:
 
398
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
399
 *    CarbonLib:        not available
 
400
 *    Mac OS X:         not available
 
401
 }
 
402
function NewHandleSys(byteCount: Size): Handle; external name '_NewHandleSys';
 
403
{$endc}  {CALL_NOT_IN_CARBON}
 
404
 
 
405
{
 
406
 *  NewHandleClear()
 
407
 *  
 
408
 *  Availability:
 
409
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
410
 *    CarbonLib:        in CarbonLib 1.0 and later
 
411
 *    Mac OS X:         in version 10.0 and later
 
412
 }
 
413
function NewHandleClear(byteCount: Size): Handle; external name '_NewHandleClear';
 
414
{$ifc CALL_NOT_IN_CARBON}
 
415
{
 
416
 *  NewHandleSysClear()
 
417
 *  
 
418
 *  Availability:
 
419
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
420
 *    CarbonLib:        not available
 
421
 *    Mac OS X:         not available
 
422
 }
 
423
function NewHandleSysClear(byteCount: Size): Handle; external name '_NewHandleSysClear';
 
424
{
 
425
 *  HandleZone()
 
426
 *  
 
427
 *  Availability:
 
428
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
429
 *    CarbonLib:        not available
 
430
 *    Mac OS X:         not available
 
431
 }
 
432
function HandleZone(h: Handle): THz; external name '_HandleZone';
 
433
{$endc}  {CALL_NOT_IN_CARBON}
 
434
 
 
435
{
 
436
 *  RecoverHandle()
 
437
 *  
 
438
 *  Availability:
 
439
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
440
 *    CarbonLib:        in CarbonLib 1.0 and later
 
441
 *    Mac OS X:         in version 10.0 and later
 
442
 }
 
443
function RecoverHandle(p: Ptr): Handle; external name '_RecoverHandle';
 
444
{$ifc CALL_NOT_IN_CARBON}
 
445
{
 
446
 *  RecoverHandleSys()
 
447
 *  
 
448
 *  Availability:
 
449
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
450
 *    CarbonLib:        not available
 
451
 *    Mac OS X:         not available
 
452
 }
 
453
function RecoverHandleSys(p: Ptr): Handle; external name '_RecoverHandleSys';
 
454
{$endc}  {CALL_NOT_IN_CARBON}
 
455
 
 
456
{
 
457
 *  NewPtr()
 
458
 *  
 
459
 *  Availability:
 
460
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
461
 *    CarbonLib:        in CarbonLib 1.0 and later
 
462
 *    Mac OS X:         in version 10.0 and later
 
463
 }
 
464
function NewPtr(byteCount: Size): Ptr; external name '_NewPtr';
 
465
{$ifc CALL_NOT_IN_CARBON}
 
466
{
 
467
 *  NewPtrSys()
 
468
 *  
 
469
 *  Availability:
 
470
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
471
 *    CarbonLib:        not available
 
472
 *    Mac OS X:         not available
 
473
 }
 
474
function NewPtrSys(byteCount: Size): Ptr; external name '_NewPtrSys';
 
475
{$endc}  {CALL_NOT_IN_CARBON}
 
476
 
 
477
{
 
478
 *  NewPtrClear()
 
479
 *  
 
480
 *  Availability:
 
481
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
482
 *    CarbonLib:        in CarbonLib 1.0 and later
 
483
 *    Mac OS X:         in version 10.0 and later
 
484
 }
 
485
function NewPtrClear(byteCount: Size): Ptr; external name '_NewPtrClear';
 
486
{$ifc CALL_NOT_IN_CARBON}
 
487
{
 
488
 *  NewPtrSysClear()
 
489
 *  
 
490
 *  Availability:
 
491
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
492
 *    CarbonLib:        not available
 
493
 *    Mac OS X:         not available
 
494
 }
 
495
function NewPtrSysClear(byteCount: Size): Ptr; external name '_NewPtrSysClear';
 
496
{
 
497
 *  PtrZone()
 
498
 *  
 
499
 *  Availability:
 
500
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
501
 *    CarbonLib:        not available
 
502
 *    Mac OS X:         not available
 
503
 }
 
504
function PtrZone(p: Ptr): THz; external name '_PtrZone';
 
505
{$endc}  {CALL_NOT_IN_CARBON}
 
506
 
 
507
{
 
508
 *  MaxBlock()
 
509
 *  
 
510
 *  Availability:
 
511
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
512
 *    CarbonLib:        in CarbonLib 1.0 and later
 
513
 *    Mac OS X:         in version 10.0 and later
 
514
 }
 
515
function MaxBlock: SInt32; external name '_MaxBlock';
 
516
{$ifc CALL_NOT_IN_CARBON}
 
517
{
 
518
 *  MaxBlockSys()
 
519
 *  
 
520
 *  Availability:
 
521
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
522
 *    CarbonLib:        not available
 
523
 *    Mac OS X:         not available
 
524
 }
 
525
function MaxBlockSys: SInt32; external name '_MaxBlockSys';
 
526
{$endc}  {CALL_NOT_IN_CARBON}
 
527
 
 
528
{
 
529
 *  StackSpace()
 
530
 *  
 
531
 *  Availability:
 
532
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
533
 *    CarbonLib:        in CarbonLib 1.0 and later
 
534
 *    Mac OS X:         in version 10.0 and later
 
535
 }
 
536
function StackSpace: SInt32; external name '_StackSpace';
 
537
{
 
538
 *  NewEmptyHandle()
 
539
 *  
 
540
 *  Availability:
 
541
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
542
 *    CarbonLib:        in CarbonLib 1.0 and later
 
543
 *    Mac OS X:         in version 10.0 and later
 
544
 }
 
545
function NewEmptyHandle: Handle; external name '_NewEmptyHandle';
 
546
{$ifc CALL_NOT_IN_CARBON}
 
547
{
 
548
 *  NewEmptyHandleSys()
 
549
 *  
 
550
 *  Availability:
 
551
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
552
 *    CarbonLib:        not available
 
553
 *    Mac OS X:         not available
 
554
 }
 
555
function NewEmptyHandleSys: Handle; external name '_NewEmptyHandleSys';
 
556
{$endc}  {CALL_NOT_IN_CARBON}
 
557
 
 
558
{
 
559
 *  HLock()
 
560
 *  
 
561
 *  Availability:
 
562
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
563
 *    CarbonLib:        in CarbonLib 1.0 and later
 
564
 *    Mac OS X:         in version 10.0 and later
 
565
 }
 
566
procedure HLock(h: Handle); external name '_HLock';
 
567
{
 
568
 *  HUnlock()
 
569
 *  
 
570
 *  Availability:
 
571
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
572
 *    CarbonLib:        in CarbonLib 1.0 and later
 
573
 *    Mac OS X:         in version 10.0 and later
 
574
 }
 
575
procedure HUnlock(h: Handle); external name '_HUnlock';
 
576
{
 
577
 *  HPurge()
 
578
 *  
 
579
 *  Availability:
 
580
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
581
 *    CarbonLib:        in CarbonLib 1.0 and later
 
582
 *    Mac OS X:         in version 10.0 and later
 
583
 }
 
584
procedure HPurge(h: Handle); external name '_HPurge';
 
585
{
 
586
 *  HNoPurge()
 
587
 *  
 
588
 *  Availability:
 
589
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
590
 *    CarbonLib:        in CarbonLib 1.0 and later
 
591
 *    Mac OS X:         in version 10.0 and later
 
592
 }
 
593
procedure HNoPurge(h: Handle); external name '_HNoPurge';
 
594
{
 
595
 *  HLockHi()
 
596
 *  
 
597
 *  Availability:
 
598
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
599
 *    CarbonLib:        in CarbonLib 1.0 and later
 
600
 *    Mac OS X:         in version 10.0 and later
 
601
 }
 
602
procedure HLockHi(h: Handle); external name '_HLockHi';
 
603
{
 
604
 *  TempNewHandle()
 
605
 *  
 
606
 *  Availability:
 
607
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
608
 *    CarbonLib:        in CarbonLib 1.0 and later
 
609
 *    Mac OS X:         in version 10.0 and later
 
610
 }
 
611
function TempNewHandle(logicalSize: Size; var resultCode: OSErr): Handle; external name '_TempNewHandle';
 
612
{
 
613
 *  TempMaxMem()
 
614
 *  
 
615
 *  Availability:
 
616
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
617
 *    CarbonLib:        in CarbonLib 1.0 and later
 
618
 *    Mac OS X:         in version 10.0 and later
 
619
 }
 
620
function TempMaxMem(var grow: Size): Size; external name '_TempMaxMem';
 
621
{
 
622
 *  TempFreeMem()
 
623
 *  
 
624
 *  Availability:
 
625
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
626
 *    CarbonLib:        in CarbonLib 1.0 and later
 
627
 *    Mac OS X:         in version 10.0 and later
 
628
 }
 
629
function TempFreeMem: SInt32; external name '_TempFreeMem';
 
630
{$ifc CALL_NOT_IN_CARBON}
 
631
{
 
632
 *  InitZone()
 
633
 *  
 
634
 *  Availability:
 
635
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
636
 *    CarbonLib:        not available
 
637
 *    Mac OS X:         not available
 
638
 }
 
639
procedure InitZone(pgrowZone: GrowZoneUPP; cmoreMasters: SInt16; limitPtr: UnivPtr; startPtr: UnivPtr); external name '_InitZone';
 
640
 
 
641
{$endc}  {CALL_NOT_IN_CARBON}
 
642
 
 
643
{$ifc CALL_NOT_IN_CARBON}
 
644
{
 
645
 *  SetZone()
 
646
 *  
 
647
 *  Availability:
 
648
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
649
 *    CarbonLib:        not available
 
650
 *    Mac OS X:         not available
 
651
 }
 
652
procedure SetZone(hz: THz); external name '_SetZone';
 
653
{$endc}  {CALL_NOT_IN_CARBON}
 
654
 
 
655
{
 
656
 *  CompactMem()
 
657
 *  
 
658
 *  Availability:
 
659
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
660
 *    CarbonLib:        in CarbonLib 1.0 and later
 
661
 *    Mac OS X:         in version 10.0 and later
 
662
 }
 
663
function CompactMem(cbNeeded: Size): Size; external name '_CompactMem';
 
664
{$ifc CALL_NOT_IN_CARBON}
 
665
{
 
666
 *  CompactMemSys()
 
667
 *  
 
668
 *  Availability:
 
669
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
670
 *    CarbonLib:        not available
 
671
 *    Mac OS X:         not available
 
672
 }
 
673
function CompactMemSys(cbNeeded: Size): Size; external name '_CompactMemSys';
 
674
{$endc}  {CALL_NOT_IN_CARBON}
 
675
 
 
676
{
 
677
 *  PurgeMem()
 
678
 *  
 
679
 *  Availability:
 
680
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
681
 *    CarbonLib:        in CarbonLib 1.0 and later
 
682
 *    Mac OS X:         in version 10.0 and later
 
683
 }
 
684
procedure PurgeMem(cbNeeded: Size); external name '_PurgeMem';
 
685
{$ifc CALL_NOT_IN_CARBON}
 
686
{
 
687
 *  PurgeMemSys()
 
688
 *  
 
689
 *  Availability:
 
690
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
691
 *    CarbonLib:        not available
 
692
 *    Mac OS X:         not available
 
693
 }
 
694
procedure PurgeMemSys(cbNeeded: Size); external name '_PurgeMemSys';
 
695
{$endc}  {CALL_NOT_IN_CARBON}
 
696
 
 
697
{
 
698
 *  FreeMem()
 
699
 *  
 
700
 *  Availability:
 
701
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
702
 *    CarbonLib:        in CarbonLib 1.0 and later
 
703
 *    Mac OS X:         in version 10.0 and later
 
704
 }
 
705
function FreeMem: SInt32; external name '_FreeMem';
 
706
{$ifc CALL_NOT_IN_CARBON}
 
707
{
 
708
 *  FreeMemSys()
 
709
 *  
 
710
 *  Availability:
 
711
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
712
 *    CarbonLib:        not available
 
713
 *    Mac OS X:         not available
 
714
 }
 
715
function FreeMemSys: SInt32; external name '_FreeMemSys';
 
716
{$endc}  {CALL_NOT_IN_CARBON}
 
717
 
 
718
{
 
719
 *  ReserveMem()
 
720
 *  
 
721
 *  Availability:
 
722
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
723
 *    CarbonLib:        in CarbonLib 1.0 and later
 
724
 *    Mac OS X:         in version 10.0 and later
 
725
 }
 
726
procedure ReserveMem(cbNeeded: Size); external name '_ReserveMem';
 
727
{$ifc CALL_NOT_IN_CARBON}
 
728
{
 
729
 *  ReserveMemSys()
 
730
 *  
 
731
 *  Availability:
 
732
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
733
 *    CarbonLib:        not available
 
734
 *    Mac OS X:         not available
 
735
 }
 
736
procedure ReserveMemSys(cbNeeded: Size); external name '_ReserveMemSys';
 
737
{$endc}  {CALL_NOT_IN_CARBON}
 
738
 
 
739
{
 
740
 *  MaxMem()
 
741
 *  
 
742
 *  Availability:
 
743
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
744
 *    CarbonLib:        in CarbonLib 1.0 and later
 
745
 *    Mac OS X:         in version 10.0 and later
 
746
 }
 
747
function MaxMem(var grow: Size): Size; external name '_MaxMem';
 
748
{$ifc CALL_NOT_IN_CARBON}
 
749
{
 
750
 *  MaxMemSys()
 
751
 *  
 
752
 *  Availability:
 
753
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
754
 *    CarbonLib:        not available
 
755
 *    Mac OS X:         not available
 
756
 }
 
757
function MaxMemSys(var grow: Size): Size; external name '_MaxMemSys';
 
758
{$endc}  {CALL_NOT_IN_CARBON}
 
759
 
 
760
{
 
761
 *  SetGrowZone()
 
762
 *  
 
763
 *  Availability:
 
764
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
765
 *    CarbonLib:        in CarbonLib 1.0 and later
 
766
 *    Mac OS X:         in version 10.0 and later
 
767
 }
 
768
procedure SetGrowZone(growZone: GrowZoneUPP); external name '_SetGrowZone';
 
769
{
 
770
 *  GetGrowZone()
 
771
 *  
 
772
 *  Availability:
 
773
 *    Non-Carbon CFM:   not available
 
774
 *    CarbonLib:        in CarbonLib 1.1 and later
 
775
 *    Mac OS X:         in version 10.0 and later
 
776
 }
 
777
function GetGrowZone: GrowZoneUPP; external name '_GetGrowZone';
 
778
 
 
779
{
 
780
 *  MoveHHi()
 
781
 *  
 
782
 *  Availability:
 
783
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
784
 *    CarbonLib:        in CarbonLib 1.0 and later
 
785
 *    Mac OS X:         in version 10.0 and later
 
786
 }
 
787
procedure MoveHHi(h: Handle); external name '_MoveHHi';
 
788
{
 
789
 *  DisposePtr()
 
790
 *  
 
791
 *  Availability:
 
792
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
793
 *    CarbonLib:        in CarbonLib 1.0 and later
 
794
 *    Mac OS X:         in version 10.0 and later
 
795
 }
 
796
procedure DisposePtr(p: Ptr); external name '_DisposePtr';
 
797
{
 
798
 *  GetPtrSize()
 
799
 *  
 
800
 *  Availability:
 
801
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
802
 *    CarbonLib:        in CarbonLib 1.0 and later
 
803
 *    Mac OS X:         in version 10.0 and later
 
804
 }
 
805
function GetPtrSize(p: Ptr): Size; external name '_GetPtrSize';
 
806
 
 
807
{
 
808
 *  SetPtrSize()
 
809
 *  
 
810
 *  Availability:
 
811
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
812
 *    CarbonLib:        in CarbonLib 1.0 and later
 
813
 *    Mac OS X:         in version 10.0 and later
 
814
 }
 
815
procedure SetPtrSize(p: Ptr; newSize: Size); external name '_SetPtrSize';
 
816
{
 
817
 *  DisposeHandle()
 
818
 *  
 
819
 *  Availability:
 
820
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
821
 *    CarbonLib:        in CarbonLib 1.0 and later
 
822
 *    Mac OS X:         in version 10.0 and later
 
823
 }
 
824
procedure DisposeHandle(h: Handle); external name '_DisposeHandle';
 
825
{
 
826
 *  SetHandleSize()
 
827
 *  
 
828
 *  Availability:
 
829
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
830
 *    CarbonLib:        in CarbonLib 1.0 and later
 
831
 *    Mac OS X:         in version 10.0 and later
 
832
 }
 
833
procedure SetHandleSize(h: Handle; newSize: Size); external name '_SetHandleSize';
 
834
{ 
 
835
    NOTE
 
836
    
 
837
    GetHandleSize and GetPtrSize are documented in Inside Mac as returning 0 
 
838
    in case of an error, but the traps actually return an error code in D0.
 
839
    The glue sets D0 to 0 if an error occurred.
 
840
}
 
841
{
 
842
 *  GetHandleSize()
 
843
 *  
 
844
 *  Availability:
 
845
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
846
 *    CarbonLib:        in CarbonLib 1.0 and later
 
847
 *    Mac OS X:         in version 10.0 and later
 
848
 }
 
849
function GetHandleSize(h: Handle): Size; external name '_GetHandleSize';
 
850
 
 
851
{$ifc CALL_NOT_IN_CARBON}
 
852
{
 
853
 *  InlineGetHandleSize()
 
854
 *  
 
855
 *  Availability:
 
856
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
857
 *    CarbonLib:        not available
 
858
 *    Mac OS X:         not available
 
859
 }
 
860
function InlineGetHandleSize(h: Handle): Size; external name '_InlineGetHandleSize';
 
861
{$endc}  {CALL_NOT_IN_CARBON}
 
862
 
 
863
{
 
864
 *  ReallocateHandle()
 
865
 *  
 
866
 *  Availability:
 
867
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
868
 *    CarbonLib:        in CarbonLib 1.0 and later
 
869
 *    Mac OS X:         in version 10.0 and later
 
870
 }
 
871
procedure ReallocateHandle(h: Handle; byteCount: Size); external name '_ReallocateHandle';
 
872
{$ifc CALL_NOT_IN_CARBON}
 
873
{
 
874
 *  ReallocateHandleSys()
 
875
 *  
 
876
 *  Availability:
 
877
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
878
 *    CarbonLib:        not available
 
879
 *    Mac OS X:         not available
 
880
 }
 
881
procedure ReallocateHandleSys(h: Handle; byteCount: Size); external name '_ReallocateHandleSys';
 
882
{$endc}  {CALL_NOT_IN_CARBON}
 
883
 
 
884
{
 
885
 *  EmptyHandle()
 
886
 *  
 
887
 *  Availability:
 
888
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
889
 *    CarbonLib:        in CarbonLib 1.0 and later
 
890
 *    Mac OS X:         in version 10.0 and later
 
891
 }
 
892
procedure EmptyHandle(h: Handle); external name '_EmptyHandle';
 
893
{
 
894
 *  HSetRBit()
 
895
 *  
 
896
 *  Availability:
 
897
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
898
 *    CarbonLib:        in CarbonLib 1.0 and later
 
899
 *    Mac OS X:         in version 10.0 and later
 
900
 }
 
901
procedure HSetRBit(h: Handle); external name '_HSetRBit';
 
902
{
 
903
 *  HClrRBit()
 
904
 *  
 
905
 *  Availability:
 
906
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
907
 *    CarbonLib:        in CarbonLib 1.0 and later
 
908
 *    Mac OS X:         in version 10.0 and later
 
909
 }
 
910
procedure HClrRBit(h: Handle); external name '_HClrRBit';
 
911
{
 
912
 *  HGetState()
 
913
 *  
 
914
 *  Availability:
 
915
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
916
 *    CarbonLib:        in CarbonLib 1.0 and later
 
917
 *    Mac OS X:         in version 10.0 and later
 
918
 }
 
919
function HGetState(h: Handle): SInt8; external name '_HGetState';
 
920
{
 
921
 *  HSetState()
 
922
 *  
 
923
 *  Availability:
 
924
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
925
 *    CarbonLib:        in CarbonLib 1.0 and later
 
926
 *    Mac OS X:         in version 10.0 and later
 
927
 }
 
928
procedure HSetState(h: Handle; flags: SInt8); external name '_HSetState';
 
929
{
 
930
 *  PurgeSpace()
 
931
 *  
 
932
 *  Availability:
 
933
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
934
 *    CarbonLib:        in CarbonLib 1.0 and later
 
935
 *    Mac OS X:         in version 10.0 and later
 
936
 }
 
937
procedure PurgeSpace(var total: SInt32; var contig: SInt32); external name '_PurgeSpace';
 
938
 
 
939
{
 
940
    PurgeSpaceTotal and PurgeSpaceContiguous are currently only implement
 
941
    on classic 68K.  The are the same as PurgeSpace() but return just
 
942
    one value (either total space purgable or contiguous space purgable).
 
943
    Begining in Mac OS 8.5 they are available in InterfaceLib.
 
944
}
 
945
{
 
946
 *  PurgeSpaceTotal()
 
947
 *  
 
948
 *  Availability:
 
949
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
950
 *    CarbonLib:        in CarbonLib 1.0 and later
 
951
 *    Mac OS X:         in version 10.0 and later
 
952
 }
 
953
function PurgeSpaceTotal: SInt32; external name '_PurgeSpaceTotal';
 
954
{
 
955
 *  PurgeSpaceContiguous()
 
956
 *  
 
957
 *  Availability:
 
958
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
959
 *    CarbonLib:        in CarbonLib 1.0 and later
 
960
 *    Mac OS X:         in version 10.0 and later
 
961
 }
 
962
function PurgeSpaceContiguous: SInt32; external name '_PurgeSpaceContiguous';
 
963
{$ifc CALL_NOT_IN_CARBON}
 
964
{
 
965
 *  PurgeSpaceSysTotal()
 
966
 *  
 
967
 *  Availability:
 
968
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
969
 *    CarbonLib:        not available
 
970
 *    Mac OS X:         not available
 
971
 }
 
972
function PurgeSpaceSysTotal: SInt32; external name '_PurgeSpaceSysTotal';
 
973
{
 
974
 *  PurgeSpaceSysContiguous()
 
975
 *  
 
976
 *  Availability:
 
977
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
978
 *    CarbonLib:        not available
 
979
 *    Mac OS X:         not available
 
980
 }
 
981
function PurgeSpaceSysContiguous: SInt32; external name '_PurgeSpaceSysContiguous';
 
982
{****************************************************************************
 
983
 
 
984
    The routines: 
 
985
 
 
986
        BlockMoveUncached, BlockMoveDataUncached
 
987
        BlockZero, BlockZeroUncached
 
988
    
 
989
    were first created for developers writing drivers. Originally they only
 
990
    existed in DriverServicesLib.  Later they were added to InterfaceLib 
 
991
    in PCI based PowerMacs.  MacOS 8.5 provides these routines in InterfaceLib
 
992
    on all supported machines. 
 
993
    
 
994
****************************************************************************}
 
995
{$endc}  {CALL_NOT_IN_CARBON}
 
996
 
 
997
{
 
998
 *  BlockMove()
 
999
 *  
 
1000
 *  Availability:
 
1001
 *    Non-Carbon CFM:   in DriverServicesLib 1.0 and later
 
1002
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1003
 *    Mac OS X:         in version 10.0 and later
 
1004
 }
 
1005
procedure BlockMove(srcPtr: UnivPtr; destPtr: UnivPtr; byteCount: Size); external name '_BlockMove';
 
1006
{
 
1007
 *  BlockMoveData()
 
1008
 *  
 
1009
 *  Availability:
 
1010
 *    Non-Carbon CFM:   in DriverServicesLib 1.0 and later
 
1011
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1012
 *    Mac OS X:         in version 10.0 and later
 
1013
 }
 
1014
procedure BlockMoveData(srcPtr: UnivPtr; destPtr: UnivPtr; byteCount: Size); external name '_BlockMoveData';
 
1015
{
 
1016
 *  BlockMoveUncached()
 
1017
 *  
 
1018
 *  Availability:
 
1019
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
1020
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1021
 *    Mac OS X:         in version 10.0 and later
 
1022
 }
 
1023
procedure BlockMoveUncached(srcPtr: UnivPtr; destPtr: UnivPtr; byteCount: Size); external name '_BlockMoveUncached';
 
1024
 
 
1025
{
 
1026
 *  BlockMoveDataUncached()
 
1027
 *  
 
1028
 *  Availability:
 
1029
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
1030
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1031
 *    Mac OS X:         in version 10.0 and later
 
1032
 }
 
1033
procedure BlockMoveDataUncached(srcPtr: UnivPtr; destPtr: UnivPtr; byteCount: Size); external name '_BlockMoveDataUncached';
 
1034
 
 
1035
{
 
1036
 *  BlockZero()
 
1037
 *  
 
1038
 *  Availability:
 
1039
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
1040
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1041
 *    Mac OS X:         in version 10.0 and later
 
1042
 }
 
1043
procedure BlockZero(destPtr: UnivPtr; byteCount: Size); external name '_BlockZero';
 
1044
 
 
1045
{
 
1046
 *  BlockZeroUncached()
 
1047
 *  
 
1048
 *  Availability:
 
1049
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
1050
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1051
 *    Mac OS X:         in version 10.0 and later
 
1052
 }
 
1053
procedure BlockZeroUncached(destPtr: UnivPtr; byteCount: Size); external name '_BlockZeroUncached';
 
1054
 
 
1055
 
 
1056
{$ifc CALL_NOT_IN_CARBON}
 
1057
{
 
1058
 *  MaxApplZone()
 
1059
 *  
 
1060
 *  Availability:
 
1061
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1062
 *    CarbonLib:        not available
 
1063
 *    Mac OS X:         not available
 
1064
 }
 
1065
procedure MaxApplZone; external name '_MaxApplZone';
 
1066
{
 
1067
 *  SetApplBase()
 
1068
 *  
 
1069
 *  Availability:
 
1070
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1071
 *    CarbonLib:        not available
 
1072
 *    Mac OS X:         not available
 
1073
 }
 
1074
procedure SetApplBase(startPtr: UnivPtr); external name '_SetApplBase';
 
1075
{$endc}  {CALL_NOT_IN_CARBON}
 
1076
 
 
1077
{
 
1078
 *  MoreMasters()
 
1079
 *  
 
1080
 *  Availability:
 
1081
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1082
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1083
 *    Mac OS X:         in version 10.0 and later
 
1084
 }
 
1085
procedure MoreMasters; external name '_MoreMasters';
 
1086
{
 
1087
 *  MoreMasterPointers()
 
1088
 *  
 
1089
 *  Availability:
 
1090
 *    Non-Carbon CFM:   not available
 
1091
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1092
 *    Mac OS X:         in version 10.0 and later
 
1093
 }
 
1094
procedure MoreMasterPointers(inCount: UInt32); external name '_MoreMasterPointers';
 
1095
 
 
1096
{$ifc CALL_NOT_IN_CARBON}
 
1097
{
 
1098
 *  SetApplLimit()
 
1099
 *  
 
1100
 *  Availability:
 
1101
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1102
 *    CarbonLib:        not available
 
1103
 *    Mac OS X:         not available
 
1104
 }
 
1105
procedure SetApplLimit(zoneLimit: UnivPtr); external name '_SetApplLimit';
 
1106
{
 
1107
 *  InitApplZone()
 
1108
 *  
 
1109
 *  Availability:
 
1110
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1111
 *    CarbonLib:        not available
 
1112
 *    Mac OS X:         not available
 
1113
 }
 
1114
procedure InitApplZone; external name '_InitApplZone';
 
1115
{  Temporary Memory routines renamed, but obsolete, in System 7.0 and later.  }
 
1116
{$endc}  {CALL_NOT_IN_CARBON}
 
1117
 
 
1118
{
 
1119
 *  TempHLock()
 
1120
 *  
 
1121
 *  Availability:
 
1122
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1123
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1124
 *    Mac OS X:         in version 10.0 and later
 
1125
 }
 
1126
procedure TempHLock(h: Handle; var resultCode: OSErr); external name '_TempHLock';
 
1127
{
 
1128
 *  TempHUnlock()
 
1129
 *  
 
1130
 *  Availability:
 
1131
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1132
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1133
 *    Mac OS X:         in version 10.0 and later
 
1134
 }
 
1135
procedure TempHUnlock(h: Handle; var resultCode: OSErr); external name '_TempHUnlock';
 
1136
{
 
1137
 *  TempDisposeHandle()
 
1138
 *  
 
1139
 *  Availability:
 
1140
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1141
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1142
 *    Mac OS X:         in version 10.0 and later
 
1143
 }
 
1144
procedure TempDisposeHandle(h: Handle; var resultCode: OSErr); external name '_TempDisposeHandle';
 
1145
{
 
1146
 *  TempTopMem()
 
1147
 *  
 
1148
 *  Availability:
 
1149
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1150
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1151
 *    Mac OS X:         in version 10.0 and later
 
1152
 }
 
1153
function TempTopMem: Ptr; external name '_TempTopMem';
 
1154
{
 
1155
 *  HoldMemory()
 
1156
 *  
 
1157
 *  Availability:
 
1158
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1159
 *    CarbonLib:        in CarbonLib 1.1 and later
 
1160
 *    Mac OS X:         in version 10.0 and later
 
1161
 }
 
1162
function HoldMemory(address: UnivPtr; count: UInt32): OSErr; external name '_HoldMemory';
 
1163
{
 
1164
 *  UnholdMemory()
 
1165
 *  
 
1166
 *  Availability:
 
1167
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1168
 *    CarbonLib:        in CarbonLib 1.1 and later
 
1169
 *    Mac OS X:         in version 10.0 and later
 
1170
 }
 
1171
function UnholdMemory(address: UnivPtr; count: UInt32): OSErr; external name '_UnholdMemory';
 
1172
{$ifc CALL_NOT_IN_CARBON}
 
1173
{
 
1174
 *  LockMemory()
 
1175
 *  
 
1176
 *  Availability:
 
1177
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1178
 *    CarbonLib:        not available
 
1179
 *    Mac OS X:         not available
 
1180
 }
 
1181
function LockMemory(address: UnivPtr; count: UInt32): OSErr; external name '_LockMemory';
 
1182
{
 
1183
 *  LockMemoryForOutput()
 
1184
 *  
 
1185
 *  Availability:
 
1186
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
1187
 *    CarbonLib:        not available
 
1188
 *    Mac OS X:         not available
 
1189
 }
 
1190
function LockMemoryForOutput(address: UnivPtr; count: UInt32): OSErr; external name '_LockMemoryForOutput';
 
1191
{
 
1192
 *  LockMemoryContiguous()
 
1193
 *  
 
1194
 *  Availability:
 
1195
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1196
 *    CarbonLib:        not available
 
1197
 *    Mac OS X:         not available
 
1198
 }
 
1199
function LockMemoryContiguous(address: UnivPtr; count: UInt32): OSErr; external name '_LockMemoryContiguous';
 
1200
{
 
1201
 *  UnlockMemory()
 
1202
 *  
 
1203
 *  Availability:
 
1204
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1205
 *    CarbonLib:        not available
 
1206
 *    Mac OS X:         not available
 
1207
 }
 
1208
function UnlockMemory(address: UnivPtr; count: UInt32): OSErr; external name '_UnlockMemory';
 
1209
{$endc}  {CALL_NOT_IN_CARBON}
 
1210
 
 
1211
{
 
1212
 *  MakeMemoryResident()
 
1213
 *  
 
1214
 *  Availability:
 
1215
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
1216
 *    CarbonLib:        in CarbonLib 1.0.2 and later
 
1217
 *    Mac OS X:         in version 10.0 and later
 
1218
 }
 
1219
function MakeMemoryResident(address: UnivPtr; count: UInt32): OSErr; external name '_MakeMemoryResident';
 
1220
{
 
1221
 *  ReleaseMemoryData()
 
1222
 *  
 
1223
 *  Availability:
 
1224
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
1225
 *    CarbonLib:        in CarbonLib 1.0.2 and later
 
1226
 *    Mac OS X:         in version 10.0 and later
 
1227
 }
 
1228
function ReleaseMemoryData(address: UnivPtr; count: UInt32): OSErr; external name '_ReleaseMemoryData';
 
1229
{
 
1230
 *  MakeMemoryNonResident()
 
1231
 *  
 
1232
 *  Availability:
 
1233
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
1234
 *    CarbonLib:        in CarbonLib 1.0.2 and later
 
1235
 *    Mac OS X:         in version 10.0 and later
 
1236
 }
 
1237
function MakeMemoryNonResident(address: UnivPtr; count: UInt32): OSErr; external name '_MakeMemoryNonResident';
 
1238
{
 
1239
 *  FlushMemory()
 
1240
 *  
 
1241
 *  Availability:
 
1242
 *    Non-Carbon CFM:   in InterfaceLib 8.5 and later
 
1243
 *    CarbonLib:        in CarbonLib 1.0.2 and later
 
1244
 *    Mac OS X:         in version 10.0 and later
 
1245
 }
 
1246
function FlushMemory(address: UnivPtr; count: UInt32): OSErr; external name '_FlushMemory';
 
1247
{$ifc CALL_NOT_IN_CARBON}
 
1248
{
 
1249
 *  GetPhysical()
 
1250
 *  
 
1251
 *  Availability:
 
1252
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1253
 *    CarbonLib:        not available
 
1254
 *    Mac OS X:         not available
 
1255
 }
 
1256
function GetPhysical(var addresses: LogicalToPhysicalTable; var physicalEntryCount: UInt32): OSErr; external name '_GetPhysical';
 
1257
{$endc}  {CALL_NOT_IN_CARBON}
 
1258
 
 
1259
{$ifc CALL_NOT_IN_CARBON}
 
1260
{
 
1261
 *  GetVolumeVirtualMemoryInfo()
 
1262
 *  
 
1263
 *  Availability:
 
1264
 *    Non-Carbon CFM:   in InterfaceLib 9.0 and later
 
1265
 *    CarbonLib:        not available
 
1266
 *    Mac OS X:         not available
 
1267
 }
 
1268
function GetVolumeVirtualMemoryInfo(volVMInfo: VolumeVirtualMemoryInfoPtr): OSErr; external name '_GetVolumeVirtualMemoryInfo';
 
1269
{
 
1270
 *  DeferUserFn()
 
1271
 *  
 
1272
 *  Availability:
 
1273
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1274
 *    CarbonLib:        not available
 
1275
 *    Mac OS X:         not available
 
1276
 }
 
1277
function DeferUserFn(userFunction: UserFnUPP; argument: UnivPtr): OSErr; external name '_DeferUserFn';
 
1278
{
 
1279
 *  DebuggerGetMax()
 
1280
 *  
 
1281
 *  Availability:
 
1282
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1283
 *    CarbonLib:        not available
 
1284
 *    Mac OS X:         not available
 
1285
 }
 
1286
function DebuggerGetMax: SInt32; external name '_DebuggerGetMax';
 
1287
{
 
1288
 *  DebuggerEnter()
 
1289
 *  
 
1290
 *  Availability:
 
1291
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1292
 *    CarbonLib:        not available
 
1293
 *    Mac OS X:         not available
 
1294
 }
 
1295
procedure DebuggerEnter; external name '_DebuggerEnter';
 
1296
{
 
1297
 *  DebuggerExit()
 
1298
 *  
 
1299
 *  Availability:
 
1300
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1301
 *    CarbonLib:        not available
 
1302
 *    Mac OS X:         not available
 
1303
 }
 
1304
procedure DebuggerExit; external name '_DebuggerExit';
 
1305
{
 
1306
 *  DebuggerPoll()
 
1307
 *  
 
1308
 *  Availability:
 
1309
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1310
 *    CarbonLib:        not available
 
1311
 *    Mac OS X:         not available
 
1312
 }
 
1313
procedure DebuggerPoll; external name '_DebuggerPoll';
 
1314
{
 
1315
 *  GetPageState()
 
1316
 *  
 
1317
 *  Availability:
 
1318
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1319
 *    CarbonLib:        not available
 
1320
 *    Mac OS X:         not available
 
1321
 }
 
1322
function GetPageState(address: UnivPtr): PageState; external name '_GetPageState';
 
1323
{
 
1324
 *  PageFaultFatal()
 
1325
 *  
 
1326
 *  Availability:
 
1327
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1328
 *    CarbonLib:        not available
 
1329
 *    Mac OS X:         not available
 
1330
 }
 
1331
function PageFaultFatal: boolean; external name '_PageFaultFatal';
 
1332
{
 
1333
 *  DebuggerLockMemory()
 
1334
 *  
 
1335
 *  Availability:
 
1336
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1337
 *    CarbonLib:        not available
 
1338
 *    Mac OS X:         not available
 
1339
 }
 
1340
function DebuggerLockMemory(address: UnivPtr; count: UInt32): OSErr; external name '_DebuggerLockMemory';
 
1341
{
 
1342
 *  DebuggerUnlockMemory()
 
1343
 *  
 
1344
 *  Availability:
 
1345
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1346
 *    CarbonLib:        not available
 
1347
 *    Mac OS X:         not available
 
1348
 }
 
1349
function DebuggerUnlockMemory(address: UnivPtr; count: UInt32): OSErr; external name '_DebuggerUnlockMemory';
 
1350
{
 
1351
 *  EnterSupervisorMode()
 
1352
 *  
 
1353
 *  Availability:
 
1354
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1355
 *    CarbonLib:        not available
 
1356
 *    Mac OS X:         not available
 
1357
 }
 
1358
function EnterSupervisorMode: StatusRegisterContents; external name '_EnterSupervisorMode';
 
1359
{
 
1360
 *  StripAddress()
 
1361
 *  
 
1362
 *  Summary:
 
1363
 *    A trap on classic 68K, and the identity function for pre-carbon
 
1364
 *  
 
1365
 *  Availability:
 
1366
 *    Non-Carbon CFM:   available as macro/inline
 
1367
 *    CarbonLib:        not available
 
1368
 *    Mac OS X:         not available
 
1369
 }
 
1370
function StripAddress(theAddress: UnivPtr): Ptr; external name '_StripAddress';
 
1371
{
 
1372
 *  Translate24To32()
 
1373
 *  
 
1374
 *  Summary:
 
1375
 *    A trap on classic 68K, and the identity function for pre-carbon
 
1376
 *  
 
1377
 *  Availability:
 
1378
 *    Non-Carbon CFM:   available as macro/inline
 
1379
 *    CarbonLib:        not available
 
1380
 *    Mac OS X:         not available
 
1381
 }
 
1382
function Translate24To32(addr24: UnivPtr): Ptr; external name '_Translate24To32';
 
1383
{$endc}  {CALL_NOT_IN_CARBON}
 
1384
 
 
1385
{
 
1386
 *  HandToHand()
 
1387
 *  
 
1388
 *  Availability:
 
1389
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1390
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1391
 *    Mac OS X:         in version 10.0 and later
 
1392
 }
 
1393
function HandToHand(var theHndl: Handle): OSErr; external name '_HandToHand';
 
1394
 
 
1395
{
 
1396
 *  PtrToXHand()
 
1397
 *  
 
1398
 *  Availability:
 
1399
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1400
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1401
 *    Mac OS X:         in version 10.0 and later
 
1402
 }
 
1403
function PtrToXHand(srcPtr: UnivPtr; dstHndl: Handle; size: SInt32): OSErr; external name '_PtrToXHand';
 
1404
{
 
1405
 *  PtrToHand()
 
1406
 *  
 
1407
 *  Availability:
 
1408
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1409
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1410
 *    Mac OS X:         in version 10.0 and later
 
1411
 }
 
1412
function PtrToHand(srcPtr: UnivPtr; var dstHndl: Handle; size: SInt32): OSErr; external name '_PtrToHand';
 
1413
 
 
1414
{
 
1415
 *  HandAndHand()
 
1416
 *  
 
1417
 *  Availability:
 
1418
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1419
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1420
 *    Mac OS X:         in version 10.0 and later
 
1421
 }
 
1422
function HandAndHand(hand1: Handle; hand2: Handle): OSErr; external name '_HandAndHand';
 
1423
{
 
1424
 *  PtrAndHand()
 
1425
 *  
 
1426
 *  Availability:
 
1427
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 
1428
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1429
 *    Mac OS X:         in version 10.0 and later
 
1430
 }
 
1431
function PtrAndHand(ptr1: UnivPtr; hand2: Handle; size: SInt32): OSErr; external name '_PtrAndHand';
 
1432
{ Carbon routines to aid in debugging. }
 
1433
{ Checks all applicable heaps for validity }
 
1434
{
 
1435
 *  CheckAllHeaps()
 
1436
 *  
 
1437
 *  Availability:
 
1438
 *    Non-Carbon CFM:   not available
 
1439
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1440
 *    Mac OS X:         in version 10.0 and later
 
1441
 }
 
1442
function CheckAllHeaps: boolean; external name '_CheckAllHeaps';
 
1443
 
 
1444
{ Checks the application heap for validity }
 
1445
{
 
1446
 *  IsHeapValid()
 
1447
 *  
 
1448
 *  Availability:
 
1449
 *    Non-Carbon CFM:   not available
 
1450
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1451
 *    Mac OS X:         in version 10.0 and later
 
1452
 }
 
1453
function IsHeapValid: boolean; external name '_IsHeapValid';
 
1454
 
 
1455
{ It is invalid to pass a NULL or an empty Handle to IsHandleValid }
 
1456
{
 
1457
 *  IsHandleValid()
 
1458
 *  
 
1459
 *  Availability:
 
1460
 *    Non-Carbon CFM:   not available
 
1461
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1462
 *    Mac OS X:         in version 10.0 and later
 
1463
 }
 
1464
function IsHandleValid(h: Handle): boolean; external name '_IsHandleValid';
 
1465
 
 
1466
{ It is invalid to pass a NULL Pointer to IsPointerValid }
 
1467
{
 
1468
 *  IsPointerValid()
 
1469
 *  
 
1470
 *  Availability:
 
1471
 *    Non-Carbon CFM:   not available
 
1472
 *    CarbonLib:        in CarbonLib 1.0 and later
 
1473
 *    Mac OS X:         in version 10.0 and later
 
1474
 }
 
1475
function IsPointerValid(p: Ptr): boolean; external name '_IsPointerValid';
 
1476
 
 
1477
 
 
1478
{$ifc OLDROUTINENAMES}
 
1479
{$ifc CALL_NOT_IN_CARBON}
 
1480
{
 
1481
 *  ApplicZone()
 
1482
 *  
 
1483
 *  Availability:
 
1484
 *    Non-Carbon CFM:   not available
 
1485
 *    CarbonLib:        not available
 
1486
 *    Mac OS X:         not available
 
1487
 }
 
1488
function ApplicZone: THz; external name '_ApplicZone';
 
1489
{
 
1490
 *  MFTempNewHandle()
 
1491
 *  
 
1492
 *  Availability:
 
1493
 *    Non-Carbon CFM:   not available
 
1494
 *    CarbonLib:        not available
 
1495
 *    Mac OS X:         not available
 
1496
 }
 
1497
function MFTempNewHandle(logicalSize: Size; var resultCode: OSErr): Handle; external name '_MFTempNewHandle';
 
1498
{
 
1499
 *  MFMaxMem()
 
1500
 *  
 
1501
 *  Availability:
 
1502
 *    Non-Carbon CFM:   not available
 
1503
 *    CarbonLib:        not available
 
1504
 *    Mac OS X:         not available
 
1505
 }
 
1506
function MFMaxMem(var grow: Size): Size; external name '_MFMaxMem';
 
1507
{
 
1508
 *  MFFreeMem()
 
1509
 *  
 
1510
 *  Availability:
 
1511
 *    Non-Carbon CFM:   not available
 
1512
 *    CarbonLib:        not available
 
1513
 *    Mac OS X:         not available
 
1514
 }
 
1515
function MFFreeMem: SInt32; external name '_MFFreeMem';
 
1516
{
 
1517
 *  MFTempHLock()
 
1518
 *  
 
1519
 *  Availability:
 
1520
 *    Non-Carbon CFM:   not available
 
1521
 *    CarbonLib:        not available
 
1522
 *    Mac OS X:         not available
 
1523
 }
 
1524
procedure MFTempHLock(h: Handle; var resultCode: OSErr); external name '_MFTempHLock';
 
1525
{
 
1526
 *  MFTempHUnlock()
 
1527
 *  
 
1528
 *  Availability:
 
1529
 *    Non-Carbon CFM:   not available
 
1530
 *    CarbonLib:        not available
 
1531
 *    Mac OS X:         not available
 
1532
 }
 
1533
procedure MFTempHUnlock(h: Handle; var resultCode: OSErr); external name '_MFTempHUnlock';
 
1534
{
 
1535
 *  MFTempDisposHandle()
 
1536
 *  
 
1537
 *  Availability:
 
1538
 *    Non-Carbon CFM:   not available
 
1539
 *    CarbonLib:        not available
 
1540
 *    Mac OS X:         not available
 
1541
 }
 
1542
procedure MFTempDisposHandle(h: Handle; var resultCode: OSErr); external name '_MFTempDisposHandle';
 
1543
{
 
1544
 *  MFTopMem()
 
1545
 *  
 
1546
 *  Availability:
 
1547
 *    Non-Carbon CFM:   not available
 
1548
 *    CarbonLib:        not available
 
1549
 *    Mac OS X:         not available
 
1550
 }
 
1551
function MFTopMem: Ptr; external name '_MFTopMem';
 
1552
{
 
1553
 *  ResrvMem()
 
1554
 *  
 
1555
 *  Availability:
 
1556
 *    Non-Carbon CFM:   not available
 
1557
 *    CarbonLib:        not available
 
1558
 *    Mac OS X:         not available
 
1559
 }
 
1560
procedure ResrvMem(cbNeeded: Size); external name '_ResrvMem';
 
1561
{
 
1562
 *  DisposPtr()
 
1563
 *  
 
1564
 *  Availability:
 
1565
 *    Non-Carbon CFM:   not available
 
1566
 *    CarbonLib:        not available
 
1567
 *    Mac OS X:         not available
 
1568
 }
 
1569
procedure DisposPtr(p: Ptr); external name '_DisposPtr';
 
1570
{
 
1571
 *  DisposHandle()
 
1572
 *  
 
1573
 *  Availability:
 
1574
 *    Non-Carbon CFM:   not available
 
1575
 *    CarbonLib:        not available
 
1576
 *    Mac OS X:         not available
 
1577
 }
 
1578
procedure DisposHandle(h: Handle); external name '_DisposHandle';
 
1579
{
 
1580
 *  ReallocHandle()
 
1581
 *  
 
1582
 *  Availability:
 
1583
 *    Non-Carbon CFM:   not available
 
1584
 *    CarbonLib:        not available
 
1585
 *    Mac OS X:         not available
 
1586
 }
 
1587
procedure ReallocHandle(h: Handle; byteCount: Size); external name '_ReallocHandle';
 
1588
{$endc}  {CALL_NOT_IN_CARBON}
 
1589
{$endc}  {OLDROUTINENAMES}
 
1590
 
 
1591
{$ALIGN MAC68K}
 
1592
 
 
1593
 
 
1594
end.