![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to codefragments.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvUSBCMD|
Return to codefragments.h CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvUSBCMD |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: File: CodeFragments.h
27:
28: Contains: Public Code Fragment Manager Interfaces.
29:
30: Version: Mac OS 8.1
31:
32: DRI: Alan Lillich
33:
34: Copyright: � 1992-1998 by Apple Computer, Inc., all rights reserved.
35:
36: Warning: *** APPLE INTERNAL USE ONLY ***
37: This file may contain unreleased API's
38:
39: BuildInfo: Built by: Naga Pappireddi
40: With Interfacer: 3.0d9 (PowerPC native)
41: From: CodeFragments.i
42: Revision: 68
43: Dated: 7/17/98
44: Last change by: ngk
45: Last comment: Change cfrg version fields to DeRez using hex
46:
47: Bugs: Report bugs to Radar component "System Interfaces", "Latest"
48: List the version information (from above) in the Problem Description.
49:
50: */
51: /*
52: �
53: ===========================================================================================
54: The Code Fragment Manager API
55: =============================
56: */
57:
58:
59: #ifndef __CODEFRAGMENTS__
60: #define __CODEFRAGMENTS__
61:
62: #ifndef __MACTYPES__
63: #include "mactypes.h"
64: #endif
65: #ifndef __FILES__
66: #include "files.h"
67: #endif
68:
69:
70:
71: #if PRAGMA_ONCE
72: #pragma once
73: #endif
74:
75: #ifdef __cplusplus
76: extern "C" {
77: #endif
78:
79: #if PRAGMA_IMPORT
80: #pragma import on
81: #endif
82:
83: #if PRAGMA_STRUCT_ALIGN
84: #pragma options align=mac68k
85: #elif PRAGMA_STRUCT_PACKPUSH
86: #pragma pack(push, 2)
87: #elif PRAGMA_STRUCT_PACK
88: #pragma pack(2)
89: #endif
90:
91: /*
92: �
93: ===========================================================================================
94: General Types and Constants
95: ===========================
96: */
97:
98:
99:
100: enum {
101: kCFragResourceType = FOUR_CHAR_CODE('cfrg'),
102: kCFragResourceID = 0,
103: kCFragLibraryFileType = FOUR_CHAR_CODE('shlb'),
104: kCFragAllFileTypes = (long)0xFFFFFFFF
105: };
106:
107:
108: typedef OSType CFragArchitecture;
109:
110: enum {
111: kPowerPCCFragArch = FOUR_CHAR_CODE('pwpc'),
112: kMotorola68KCFragArch = FOUR_CHAR_CODE('m68k'),
113: kAnyCFragArch = 0x3F3F3F3F
114: };
115:
116: #if TARGET_CPU_PPC
117:
118: enum {
119: kCompiledCFragArch = kPowerPCCFragArch
120: };
121:
122: #endif /* TARGET_CPU_PPC */
123:
124: #if TARGET_CPU_68K
125:
126: enum {
127: kCompiledCFragArch = kMotorola68KCFragArch
128: };
129:
130: #endif /* TARGET_CPU_68K */
131:
132: typedef UInt32 CFragVersionNumber;
133:
134: enum {
135: kNullCFragVersion = 0,
136: kWildcardCFragVersion = (long)0xFFFFFFFF
137: };
138:
139:
140: typedef UInt8 CFragUsage;
141:
142: enum {
143: kImportLibraryCFrag = 0, /* Standard CFM import library.*/
144: kApplicationCFrag = 1, /* MacOS application.*/
145: kDropInAdditionCFrag = 2, /* Application or library private extension/plug-in*/
146: kStubLibraryCFrag = 3, /* Import library used for linking only*/
147: kWeakStubLibraryCFrag = 4 /* Import library used for linking only and will be automatically weak linked*/
148: };
149:
150:
151:
152: enum {
153: kIsCompleteCFrag = 0, /* A "base" fragment, not an update.*/
154: kFirstCFragUpdate = 1 /* The first update, others are numbered 2, 3, ...*/
155: };
156:
157:
158:
159: enum {
160: kCFragGoesToEOF = 0
161: };
162:
163:
164:
165:
166: typedef UInt8 CFragLocatorKind;
167:
168: enum {
169: kMemoryCFragLocator = 0, /* Container is already addressable.*/
170: kDataForkCFragLocator = 1, /* Container is in a file's data fork.*/
171: kResourceCFragLocator = 2, /* Container is in a file's resource fork.*/
172: kByteStreamCFragLocator = 3, /* ! Reserved for possible future use!*/
173: kNamedFragmentCFragLocator = 4 /* ! Reserved for possible future use!*/
174: };
175:
176:
177: /*
178: --------------------------------------------------------------------------------------
179: A 'cfrg' resource consists of a header followed by a sequence of variable length
180: members. The constant kDefaultCFragNameLen only provides for a legal ANSI declaration
181: and for a reasonable display in a debugger. The actual name field is cut to fit.
182: There may be "extensions" after the name, the memberSize field includes them. The
183: general form of an extension is a 16 bit type code followed by a 16 bit size in bytes.
184: Only one standard extension type is defined at present, it is used by SOM's searching
185: mechanism.
186: */
187:
188:
189:
190: union CFragUsage1Union { /* ! Meaning differs depending on value of "usage".*/
191: UInt32 appStackSize; /* If the fragment is an application. (Not used by CFM!)*/
192: };
193: typedef union CFragUsage1Union CFragUsage1Union;
194:
195: union CFragUsage2Union { /* ! Meaning differs depending on value of "usage".*/
196: SInt16 appSubdirID; /* If the fragment is an application.*/
197: UInt16 libFlags; /* If the fragment is an import library.*/
198: };
199: typedef union CFragUsage2Union CFragUsage2Union;
200:
201: enum {
202: /* Bit masks for the CFragUsage2Union libFlags variant.*/
203: kCFragLibUsageMapPrivatelyMask = 0x0001 /* Put container in app heap if necessary.*/
204: };
205:
206:
207: union CFragWhere1Union { /* ! Meaning differs depending on value of "where".*/
208: UInt32 spaceID; /* If the fragment is in memory. (Actually an AddressSpaceID.)*/
209: OSType forkKind; /* If the fragment is in an arbitrary byte stream fork.*/
210: };
211: typedef union CFragWhere1Union CFragWhere1Union;
212:
213: union CFragWhere2Union { /* ! Meaning differs depending on value of "where".*/
214: UInt16 forkInstance; /* If the fragment is in an arbitrary byte stream fork.*/
215: };
216: typedef union CFragWhere2Union CFragWhere2Union;
217:
218: enum {
219: kDefaultCFragNameLen = 16
220: };
221:
222:
223:
224: struct CFragResourceMember {
225: CFragArchitecture architecture;
226: UInt16 reservedA; /* ! Must be zero!*/
227: UInt8 reservedB; /* ! Must be zero!*/
228: UInt8 updateLevel;
229: CFragVersionNumber currentVersion;
230: CFragVersionNumber oldDefVersion;
231: CFragUsage1Union uUsage1;
232: CFragUsage2Union uUsage2;
233: CFragUsage usage;
234: CFragLocatorKind where;
235: UInt32 offset;
236: UInt32 length;
237: CFragWhere1Union uWhere1;
238: CFragWhere2Union uWhere2;
239: UInt16 extensionCount; /* The number of extensions beyond the name.*/
240: UInt16 memberSize; /* Size in bytes, includes all extensions.*/
241: unsigned char name[16]; /* ! Actually a sized PString.*/
242: };
243: typedef struct CFragResourceMember CFragResourceMember;
244: typedef CFragResourceMember * CFragResourceMemberPtr;
245:
246: struct CFragResourceExtensionHeader {
247: UInt16 extensionKind;
248: UInt16 extensionSize;
249: };
250: typedef struct CFragResourceExtensionHeader CFragResourceExtensionHeader;
251: typedef CFragResourceExtensionHeader * CFragResourceExtensionHeaderPtr;
252:
253: struct CFragResourceSearchExtension {
254: CFragResourceExtensionHeader header;
255: OSType libKind;
256: unsigned char qualifiers[1]; /* ! Actually four PStrings.*/
257: };
258: typedef struct CFragResourceSearchExtension CFragResourceSearchExtension;
259: typedef CFragResourceSearchExtension * CFragResourceSearchExtensionPtr;
260:
261: enum {
262: kCFragResourceSearchExtensionKind = 0x30EE
263: };
264:
265:
266:
267: struct CFragResource {
268: UInt32 reservedA; /* ! Must be zero!*/
269: UInt32 reservedB; /* ! Must be zero!*/
270: UInt16 reservedC; /* ! Must be zero!*/
271: UInt16 version;
272: UInt32 reservedD; /* ! Must be zero!*/
273: UInt32 reservedE; /* ! Must be zero!*/
274: UInt32 reservedF; /* ! Must be zero!*/
275: UInt32 reservedG; /* ! Must be zero!*/
276: UInt16 reservedH; /* ! Must be zero!*/
277: UInt16 memberCount;
278: CFragResourceMember firstMember;
279: };
280: typedef struct CFragResource CFragResource;
281: typedef CFragResource * CFragResourcePtr;
282: typedef CFragResourcePtr * CFragResourceHandle;
283:
284: enum {
285: kCurrCFragResourceVersion = 1
286: };
287:
288:
289: #define AlignToFour(aValue) (((aValue) + 3) & ~3)
290: #define kBaseCFragResourceMemberSize (offsetof ( CFragResourceMember, name ) )
291: #define kBaseCFragResourceSize (offsetof ( CFragResource, firstMember.name ) )
292: #define NextCFragResourceMemberPtr(aMemberPtr) \
293: ((CFragResourceMemberPtr) ((BytePtr)aMemberPtr + aMemberPtr->memberSize))
294: #define FirstCFragResourceExtensionPtr(aMemberPtr) \
295: ((CFragResourceExtensionHeaderPtr) ((BytePtr)aMemberPtr + \
296: AlignToFour ( kBaseCFragResourceMemberSize + \
297: aMemberPtr->name[0] + 1 ) ))
298: #define NextCFragResourceExtensionPtr(anExtensionPtr) \
299: ((CFragResourceExtensionHeaderPtr) ((BytePtr)anExtensionPtr + \
300: ((CFragResourceExtensionHeaderPtr)anExtensionPtr)->extensionSize ))
301: #define FirstCFragResourceSearchQualifier(searchExtensionPtr) \
302: ((StringPtr) ((BytePtr)searchExtensionPtr + \
303: offsetof ( CFragResourceSearchExtension, qualifiers ) ))
304: #define NextCFragResourceSearchQualifier(searchQualifierPtr) \
305: ((StringPtr) ((BytePtr)searchQualifierPtr + searchQualifierPtr[0] + 1))
306:
307: typedef struct OpaqueCFragConnectionID* CFragConnectionID;
308: typedef struct OpaqueCFragClosureID* CFragClosureID;
309: typedef struct OpaqueCFragContainerID* CFragContainerID;
310: typedef struct OpaqueCFragContextID* CFragContextID;
311:
312: typedef UInt32 CFragLoadOptions;
313:
314: enum {
315: kReferenceCFrag = 0x0001, /* Try to use existing copy, increment reference counts.*/
316: kFindCFrag = 0x0002, /* Try find an existing copy, do not increment reference counts.*/
317: kPrivateCFragCopy = 0x0005 /* Prepare a new private copy. (kReferenceCFrag | 0x0004)*/
318: };
319:
320:
321:
322: enum {
323: kUnresolvedCFragSymbolAddress = 0
324: };
325:
326:
327: typedef UInt8 CFragSymbolClass;
328:
329: enum {
330: kCodeCFragSymbol = 0,
331: kDataCFragSymbol = 1,
332: kTVectorCFragSymbol = 2,
333: kTOCCFragSymbol = 3,
334: kGlueCFragSymbol = 4
335: };
336:
337:
338: /*
339: �
340: ===========================================================================================
341: Macros and Functions
342: ====================
343: */
344:
345:
346: #define CFragHasFileLocation(where) \
347: ( ((where) == kDataForkCFragLocator) || ((where) == kResourceCFragLocator) )
348:
349: EXTERN_API( OSErr )
350: GetSharedLibrary (ConstStr63Param libName,
351: CFragArchitecture archType,
352: CFragLoadOptions loadFlags,
353: CFragConnectionID * connID,
354: Ptr * mainAddr,
355: Str255 errMessage) THREEWORDINLINE(0x3F3C, 0x0001, 0xAA5A);
356:
357: EXTERN_API( OSErr )
358: GetDiskFragment (const FSSpec * fileSpec,
359: UInt32 offset,
360: UInt32 length,
361: ConstStr63Param fragName,
362: CFragLoadOptions loadFlags,
363: CFragConnectionID * connID,
364: Ptr * mainAddr,
365: Str255 errMessage) THREEWORDINLINE(0x3F3C, 0x0002, 0xAA5A);
366:
367: EXTERN_API( OSErr )
368: GetMemFragment (void * memAddr,
369: UInt32 length,
370: ConstStr63Param fragName,
371: CFragLoadOptions loadFlags,
372: CFragConnectionID * connID,
373: Ptr * mainAddr,
374: Str255 errMessage) THREEWORDINLINE(0x3F3C, 0x0003, 0xAA5A);
375:
376: EXTERN_API( OSErr )
377: CloseConnection (CFragConnectionID * connID) THREEWORDINLINE(0x3F3C, 0x0004, 0xAA5A);
378:
379: EXTERN_API( OSErr )
380: FindSymbol (CFragConnectionID connID,
381: ConstStr255Param symName,
382: Ptr * symAddr,
383: CFragSymbolClass * symClass) THREEWORDINLINE(0x3F3C, 0x0005, 0xAA5A);
384:
385: EXTERN_API( OSErr )
386: CountSymbols (CFragConnectionID connID,
387: long * symCount) THREEWORDINLINE(0x3F3C, 0x0006, 0xAA5A);
388:
389: EXTERN_API( OSErr )
390: GetIndSymbol (CFragConnectionID connID,
391: long symIndex,
392: Str255 symName,
393: Ptr * symAddr,
394: CFragSymbolClass * symClass) THREEWORDINLINE(0x3F3C, 0x0007, 0xAA5A);
395:
396:
397: /*
398: �
399: ===========================================================================================
400: Initialization & Termination Routines
401: =====================================
402: */
403:
404:
405: /*
406: -----------------------------------------------------------------------------------------
407: A fragment's initialization and termination routines are called when a new incarnation of
408: the fragment is created or destroyed, respectively. Exactly when this occurs depends on
409: what kinds of section sharing the fragment has and how the fragment is prepared. Import
410: libraries have at most one incarnation per process. Fragments prepared with option
411: kPrivateCFragCopy may have many incarnations per process.
412: The initialization function is passed a pointer to an initialization information structure
413: and returns an OSErr. If an initialization function returns a non-zero value the entire
414: closure of which it is a part fails. The C prototype for an initialization function is:
415: OSErr CFragInitFunction ( const CFragInitBlock * initBlock );
416: The termination procedure takes no parameters and returns nothing. The C prototype for a
417: termination procedure is:
418: void CFragTermProcedure ( void );
419: Note that since the initialization and termination routines are themselves "CFM"-style
420: routines whether or not they have the "pascal" keyword is irrelevant.
421: */
422:
423:
424: /*
425: -----------------------------------------------------------------------------------------
426: ! Note:
427: ! The "System7" portion of these type names was introduced during the evolution towards
428: ! the now defunct Copland version of Mac OS. Copland was to be called System 8 and there
429: ! were slightly different types for System 7 and System 8. The "generic" type names were
430: ! conditionally defined for the desired target system.
431: ! Always use the generic types, e.g. CFragInitBlock! The "System7" names have been kept
432: ! only to avoid perturbing code that (improperly) used the target specific type.
433: */
434:
435:
436:
437: struct CFragSystem7MemoryLocator {
438: LogicalAddress address;
439: UInt32 length;
440: Boolean inPlace;
441: UInt8 reservedA; /* ! Must be zero!*/
442: UInt16 reservedB; /* ! Must be zero!*/
443: };
444: typedef struct CFragSystem7MemoryLocator CFragSystem7MemoryLocator;
445:
446: struct CFragSystem7DiskFlatLocator {
447: FSSpecPtr fileSpec;
448: UInt32 offset;
449: UInt32 length;
450: };
451: typedef struct CFragSystem7DiskFlatLocator CFragSystem7DiskFlatLocator;
452: /* ! This must have a file specification at the same offset as a disk flat locator!*/
453:
454: struct CFragSystem7SegmentedLocator {
455: FSSpecPtr fileSpec;
456: OSType rsrcType;
457: SInt16 rsrcID;
458: UInt16 reservedA; /* ! Must be zero!*/
459: };
460: typedef struct CFragSystem7SegmentedLocator CFragSystem7SegmentedLocator;
461:
462: struct CFragSystem7Locator {
463: SInt32 where;
464: union {
465: CFragSystem7DiskFlatLocator onDisk;
466: CFragSystem7MemoryLocator inMem;
467: CFragSystem7SegmentedLocator inSegs;
468: } u;
469: };
470: typedef struct CFragSystem7Locator CFragSystem7Locator;
471: typedef CFragSystem7Locator * CFragSystem7LocatorPtr;
472:
473: struct CFragSystem7InitBlock {
474: CFragContextID contextID;
475: CFragClosureID closureID;
476: CFragConnectionID connectionID;
477: CFragSystem7Locator fragLocator;
478: StringPtr libName;
479: UInt32 reservedA; /* ! Must be zero!*/
480: };
481: typedef struct CFragSystem7InitBlock CFragSystem7InitBlock;
482: typedef CFragSystem7InitBlock * CFragSystem7InitBlockPtr;
483:
484: typedef CFragSystem7InitBlock CFragInitBlock;
485: typedef CFragSystem7InitBlockPtr CFragInitBlockPtr;
486: /* These init/term routine types are only of value to CFM itself.*/
487: typedef CALLBACK_API_C( OSErr , CFragInitFunction )(const CFragInitBlock *initBlock);
488: typedef CALLBACK_API_C( void , CFragTermProcedure )(void );
489: /*
490: �
491: ===========================================================================================
492: Old Name Spellings
493: ==================
494: */
495:
496:
497: /*
498: -------------------------------------------------------------------------------------------
499: We've tried to reduce the risk of name collisions in the future by introducing the phrase
500: "CFrag" into constant and type names. The old names are defined below in terms of the new.
501: */
502:
503:
504:
505: enum {
506: kLoadCFrag = kReferenceCFrag
507: };
508:
509:
510: #if OLDROUTINENAMES
511: #define IsFileLocation CFragHasFileLocation
512: typedef CFragConnectionID ConnectionID;
513: typedef CFragLoadOptions LoadFlags;
514: typedef CFragSymbolClass SymClass;
515: typedef CFragInitBlock InitBlock;
516: typedef CFragInitBlockPtr InitBlockPtr;
517: typedef CFragSystem7MemoryLocator MemFragment;
518: typedef CFragSystem7DiskFlatLocator DiskFragment;
519: typedef CFragSystem7SegmentedLocator SegmentedFragment;
520: typedef CFragSystem7Locator FragmentLocator;
521: typedef CFragSystem7LocatorPtr FragmentLocatorPtr;
522: typedef CFragSystem7MemoryLocator CFragHFSMemoryLocator;
523: typedef CFragSystem7DiskFlatLocator CFragHFSDiskFlatLocator;
524: typedef CFragSystem7SegmentedLocator CFragHFSSegmentedLocator;
525: typedef CFragSystem7Locator CFragHFSLocator;
526: typedef CFragSystem7LocatorPtr CFragHFSLocatorPtr;
527:
528: enum {
529: kPowerPCArch = kPowerPCCFragArch,
530: kMotorola68KArch = kMotorola68KCFragArch,
531: kAnyArchType = kAnyCFragArch,
532: kNoLibName = 0,
533: kNoConnectionID = 0,
534: kLoadLib = kLoadCFrag,
535: kFindLib = kFindCFrag,
536: kNewCFragCopy = kPrivateCFragCopy,
537: kLoadNewCopy = kPrivateCFragCopy,
538: kUseInPlace = 0x80,
539: kCodeSym = kCodeCFragSymbol,
540: kDataSym = kDataCFragSymbol,
541: kTVectSym = kTVectorCFragSymbol,
542: kTOCSym = kTOCCFragSymbol,
543: kGlueSym = kGlueCFragSymbol,
544: kInMem = kMemoryCFragLocator,
545: kOnDiskFlat = kDataForkCFragLocator,
546: kOnDiskSegmented = kResourceCFragLocator,
547: kIsLib = kImportLibraryCFrag,
548: kIsApp = kApplicationCFrag,
549: kIsDropIn = kDropInAdditionCFrag,
550: kFullLib = kIsCompleteCFrag,
551: kUpdateLib = kFirstCFragUpdate,
552: kWholeFork = kCFragGoesToEOF,
553: kCFMRsrcType = kCFragResourceType,
554: kCFMRsrcID = kCFragResourceID,
555: kSHLBFileType = kCFragLibraryFileType,
556: kUnresolvedSymbolAddress = kUnresolvedCFragSymbolAddress
557: };
558:
559:
560: enum {
561: kPowerPC = kPowerPCCFragArch,
562: kMotorola68K = kMotorola68KCFragArch
563: };
564:
565: #endif /* OLDROUTINENAMES */
566:
567:
568:
569:
570:
571:
572: #if PRAGMA_STRUCT_ALIGN
573: #pragma options align=reset
574: #elif PRAGMA_STRUCT_PACKPUSH
575: #pragma pack(pop)
576: #elif PRAGMA_STRUCT_PACK
577: #pragma pack()
578: #endif
579:
580: #ifdef PRAGMA_IMPORT_OFF
581: #pragma import off
582: #elif PRAGMA_IMPORT
583: #pragma import reset
584: #endif
585:
586: #ifdef __cplusplus
587: }
588: #endif
589:
590: #endif /* __CODEFRAGMENTS__ */
591:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.