home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / PPCToolbox.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  14.5 KB  |  479 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        PPCToolbox.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT PPCToolbox;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __PPCTOOLBOX__}
  27. {$SETC __PPCTOOLBOX__ := 1}
  28.  
  29. {$I+}
  30. {$SETC PPCToolboxIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __APPLETALK__}
  35. {$I AppleTalk.p}
  36. {$ENDC}
  37. {    Types.p                                                        }
  38. {        ConditionalMacros.p                                        }
  39. {    OSUtils.p                                                    }
  40. {        MixedMode.p                                                }
  41. {        Memory.p                                                }
  42.  
  43. {$PUSH}
  44. {$ALIGN MAC68K}
  45. {$LibExport+}
  46.     
  47. TYPE
  48.     PPCServiceType = CHAR;
  49.  
  50.  
  51. CONST
  52.     ppcServiceRealTime            = 1;
  53.  
  54.     
  55. TYPE
  56.     PPCLocationKind = INTEGER;
  57.  
  58.  
  59. CONST
  60.     ppcNoLocation                = 0;                            { There is no PPCLocName }
  61.     ppcNBPLocation                = 1;                            { Use AppleTalk NBP      }
  62.     ppcNBPTypeLocation            = 2;                            { Used for specifying a location name type during PPCOpen only }
  63.  
  64.     
  65. TYPE
  66.     PPCPortKinds = INTEGER;
  67.  
  68.  
  69. CONST
  70.     ppcByCreatorAndType            = 1;                            { Port type is specified as colloquial Mac creator and type }
  71.     ppcByString                    = 2;                            { Port type is in pascal string format }
  72.  
  73. { Values returned for request field in PPCInform call }
  74.     
  75. TYPE
  76.     PPCSessionOrigin = CHAR;
  77.  
  78.  
  79. CONST
  80. { Values returned for requestType field in PPCInform call }
  81.     ppcLocalOrigin                = 1;                            { session originated from this machine }
  82.     ppcRemoteOrigin                = 2;                            { session originated from remote machine }
  83.  
  84.     
  85. TYPE
  86.     PPCPortRefNum = INTEGER;
  87.  
  88.     PPCSessRefNum = LONGINT;
  89.  
  90.     PPCPortRec = RECORD
  91.         nameScript:                ScriptCode;                                { script of name }
  92.         name:                    Str32;                                    { name of port as seen in browser }
  93.         portKindSelector:        PPCPortKinds;                            { which variant }
  94.         CASE INTEGER OF
  95.         0: (
  96.             portTypeStr:                Str32;                                { pascal type string }
  97.            );
  98.         1: (
  99.             portCreator:                OSType;
  100.             portType:                    OSType;
  101.            );
  102.     END;
  103.     PPCPortPtr = ^PPCPortRec;
  104.  
  105.     LocationNameRec = RECORD
  106.         locationKindSelector:    PPCLocationKind;                        { which variant }
  107.         CASE INTEGER OF
  108.         0: (
  109.             nbpEntity:                    EntityName;                            { NBP name entity }
  110.            );
  111.         1: (
  112.             nbpType:                    Str32;                                { just the NBP type string, for PPCOpen }
  113.            );
  114.     END;
  115.     LocationNamePtr = ^LocationNameRec;
  116.  
  117.     PortInfoRec = RECORD
  118.         filler1:                SInt8;
  119.         authRequired:            BOOLEAN;
  120.         name:                    PPCPortRec;
  121.     END;
  122.     PortInfoPtr = ^PortInfoRec;
  123.  
  124.     PortInfoArrayPtr = ^PortInfoRec;
  125.  
  126.     PPCParamBlockPtr = ^PPCParamBlockRec;
  127.  
  128.     PPCCompProcPtr = ProcPtr;  { PROCEDURE PPCComp(pb: PPCParamBlockPtr); }
  129.     PPCCompUPP = UniversalProcPtr;
  130.  
  131.     PPCOpenPBRec = PACKED RECORD
  132.         qLink:                    Ptr;
  133.         csCode:                    INTEGER;
  134.         intUse:                    INTEGER;
  135.         intUsePtr:                Ptr;
  136.         ioCompletion:            PPCCompUPP;
  137.         ioResult:                OSErr;
  138.         Reserved:                ARRAY [0..4] OF LONGINT;
  139.         portRefNum:                PPCPortRefNum;                            { 38 <--   Port Reference }
  140.         filler1:                LONGINT;
  141.         serviceType:            PPCServiceType;                            { 44 -->    Bit field describing the requested port service }
  142.         resFlag:                UInt8;                                    { Must be set to 0 }
  143.         portName:                PPCPortPtr;                                { 46 -->   PortName for PPC }
  144.         locationName:            LocationNamePtr;                        { 50 -->   If NBP Registration is required }
  145.         networkVisible:            BOOLEAN;                                { 54 -->   make this network visible on network }
  146.         nbpRegistered:            BOOLEAN;                                { 55 <--   The given location name was registered on the network }
  147.     END;
  148.     PPCOpenPBPtr = ^PPCOpenPBRec;
  149.  
  150.     PPCInformPBRec = PACKED RECORD
  151.         qLink:                    Ptr;
  152.         csCode:                    INTEGER;
  153.         intUse:                    INTEGER;
  154.         intUsePtr:                Ptr;
  155.         ioCompletion:            PPCCompUPP;
  156.         ioResult:                OSErr;
  157.         Reserved:                ARRAY [0..4] OF LONGINT;
  158.         portRefNum:                PPCPortRefNum;                            { 38 -->   Port Identifier }
  159.         sessRefNum:                PPCSessRefNum;                            { 40 <--   Session Reference }
  160.         serviceType:            PPCServiceType;                            { 44 <--   Status Flags for type of session, local, remote }
  161.         autoAccept:                BOOLEAN;                                { 45 -->   if true session will be accepted automatically }
  162.         portName:                PPCPortPtr;                                { 46 -->   Buffer for Source PPCPortRec }
  163.         locationName:            LocationNamePtr;                        { 50 -->   Buffer for Source LocationNameRec }
  164.         userName:                StringPtr;                                { 54 -->   Buffer for Soure user's name trying to link. }
  165.         userData:                LONGINT;                                { 58 <--   value included in PPCStart's userData }
  166.         requestType:            PPCSessionOrigin;                        { 62 <--   Local or Network }
  167.     END;
  168.     PPCInformPBPtr = ^PPCInformPBRec;
  169.  
  170.     PPCStartPBRec = PACKED RECORD
  171.         qLink:                    Ptr;
  172.         csCode:                    INTEGER;
  173.         intUse:                    INTEGER;
  174.         intUsePtr:                Ptr;
  175.         ioCompletion:            PPCCompUPP;
  176.         ioResult:                OSErr;
  177.         Reserved:                ARRAY [0..4] OF LONGINT;
  178.         portRefNum:                PPCPortRefNum;                            { 38 -->   Port Identifier }
  179.         sessRefNum:                PPCSessRefNum;                            { 40 <--   Session Reference }
  180.         serviceType:            PPCServiceType;                            { 44 <--   Actual service method (realTime) }
  181.         resFlag:                UInt8;                                    { 45 -->   Must be set to 0  }
  182.         portName:                PPCPortPtr;                                { 46 -->   Destination portName }
  183.         locationName:            LocationNamePtr;                        { 50 -->   NBP or NAS style service location name }
  184.         rejectInfo:                LONGINT;                                { 54 <--   reason for rejecting the session request }
  185.         userData:                LONGINT;                                { 58 -->   Copied to destination PPCInform parameter block }
  186.         userRefNum:                LONGINT;                                { 62 -->   userRefNum (obtained during login process)  }
  187.     END;
  188.     PPCStartPBPtr = ^PPCStartPBRec;
  189.  
  190.     PPCAcceptPBRec = RECORD
  191.         qLink:                    Ptr;
  192.         csCode:                    INTEGER;
  193.         intUse:                    INTEGER;
  194.         intUsePtr:                Ptr;
  195.         ioCompletion:            PPCCompUPP;
  196.         ioResult:                OSErr;
  197.         Reserved:                ARRAY [0..4] OF LONGINT;
  198.         filler1:                INTEGER;
  199.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  200.     END;
  201.     PPCAcceptPBPtr = ^PPCAcceptPBRec;
  202.  
  203.     PPCRejectPBRec = RECORD
  204.         qLink:                    Ptr;
  205.         csCode:                    INTEGER;
  206.         intUse:                    INTEGER;
  207.         intUsePtr:                Ptr;
  208.         ioCompletion:            PPCCompUPP;
  209.         ioResult:                OSErr;
  210.         Reserved:                ARRAY [0..4] OF LONGINT;
  211.         filler1:                INTEGER;
  212.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  213.         filler2:                INTEGER;
  214.         filler3:                LONGINT;
  215.         filler4:                LONGINT;
  216.         rejectInfo:                LONGINT;                                { 54 -->   reason for rejecting the session request  }
  217.     END;
  218.     PPCRejectPBPtr = ^PPCRejectPBRec;
  219.  
  220.     PPCWritePBRec = RECORD
  221.         qLink:                    Ptr;
  222.         csCode:                    INTEGER;
  223.         intUse:                    INTEGER;
  224.         intUsePtr:                Ptr;
  225.         ioCompletion:            PPCCompUPP;
  226.         ioResult:                OSErr;
  227.         Reserved:                ARRAY [0..4] OF LONGINT;
  228.         filler1:                INTEGER;
  229.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  230.         bufferLength:            Size;                                    { 44 -->   Length of the message buffer }
  231.         actualLength:            Size;                                    { 48 <--   Actual Length Written }
  232.         bufferPtr:                Ptr;                                    { 52 -->   Pointer to message buffer }
  233.         more:                    BOOLEAN;                                { 56 -->   if more data in this block will be written }
  234.         filler2:                SInt8;
  235.         userData:                LONGINT;                                { 58 -->   Message block userData Uninterpreted by PPC }
  236.         blockCreator:            OSType;                                    { 62 -->   Message block creator Uninterpreted by PPC }
  237.         blockType:                OSType;                                    { 66 -->   Message block type Uninterpreted by PPC }
  238.     END;
  239.     PPCWritePBPtr = ^PPCWritePBRec;
  240.  
  241.     PPCReadPBRec = RECORD
  242.         qLink:                    Ptr;
  243.         csCode:                    INTEGER;
  244.         intUse:                    INTEGER;
  245.         intUsePtr:                Ptr;
  246.         ioCompletion:            PPCCompUPP;
  247.         ioResult:                OSErr;
  248.         Reserved:                ARRAY [0..4] OF LONGINT;
  249.         filler1:                INTEGER;
  250.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  251.         bufferLength:            Size;                                    { 44 -->   Length of the message buffer }
  252.         actualLength:            Size;                                    { 48 <--   Actual length read }
  253.         bufferPtr:                Ptr;                                    { 52 -->   Pointer to message buffer }
  254.         more:                    BOOLEAN;                                { 56 <--   if true more data in this block to be read }
  255.         filler2:                SInt8;
  256.         userData:                LONGINT;                                { 58 <--   Message block userData Uninterpreted by PPC }
  257.         blockCreator:            OSType;                                    { 62 <--   Message block creator Uninterpreted by PPC }
  258.         blockType:                OSType;                                    { 66 <--   Message block type Uninterpreted by PPC }
  259.     END;
  260.     PPCReadPBPtr = ^PPCReadPBRec;
  261.  
  262.     PPCEndPBRec = RECORD
  263.         qLink:                    Ptr;
  264.         csCode:                    INTEGER;
  265.         intUse:                    INTEGER;
  266.         intUsePtr:                Ptr;
  267.         ioCompletion:            PPCCompUPP;
  268.         ioResult:                OSErr;
  269.         Reserved:                ARRAY [0..4] OF LONGINT;
  270.         filler1:                INTEGER;
  271.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  272.     END;
  273.     PPCEndPBPtr = ^PPCEndPBRec;
  274.  
  275.     PPCClosePBRec = RECORD
  276.         qLink:                    Ptr;
  277.         csCode:                    INTEGER;
  278.         intUse:                    INTEGER;
  279.         intUsePtr:                Ptr;
  280.         ioCompletion:            PPCCompUPP;
  281.         ioResult:                OSErr;
  282.         Reserved:                ARRAY [0..4] OF LONGINT;
  283.         portRefNum:                PPCPortRefNum;                            { 38 -->   Port Identifier }
  284.     END;
  285.     PPCClosePBPtr = ^PPCClosePBRec;
  286.  
  287.     IPCListPortsPBRec = RECORD
  288.         qLink:                    Ptr;
  289.         csCode:                    INTEGER;
  290.         intUse:                    INTEGER;
  291.         intUsePtr:                Ptr;
  292.         ioCompletion:            PPCCompUPP;
  293.         ioResult:                OSErr;
  294.         Reserved:                ARRAY [0..4] OF LONGINT;
  295.         filler1:                INTEGER;
  296.         startIndex:                INTEGER;                                { 40 -->   Start Index }
  297.         requestCount:            INTEGER;                                { 42 -->   Number of entries to be returned }
  298.         actualCount:            INTEGER;                                { 44 <--   Actual Number of entries to be returned }
  299.         portName:                PPCPortPtr;                                { 46 -->   PortName Match }
  300.         locationName:            LocationNamePtr;                        { 50 -->   NBP or NAS type name to locate the Port Location }
  301.         bufferPtr:                PortInfoArrayPtr;                        { 54 -->   Pointer to a buffer requestCount*sizeof(PortInfo) bytes big }
  302.     END;
  303.     IPCListPortsPBPtr = ^IPCListPortsPBRec;
  304.  
  305.     PPCParamBlockRec = RECORD
  306.         CASE INTEGER OF
  307.         0: (
  308.             openParam:                    PPCOpenPBRec;
  309.            );
  310.         1: (
  311.             informParam:                PPCInformPBRec;
  312.            );
  313.         2: (
  314.             startParam:                    PPCStartPBRec;
  315.            );
  316.         3: (
  317.             acceptParam:                PPCAcceptPBRec;
  318.            );
  319.         4: (
  320.             rejectParam:                PPCRejectPBRec;
  321.            );
  322.         5: (
  323.             writeParam:                    PPCWritePBRec;
  324.            );
  325.         6: (
  326.             readParam:                    PPCReadPBRec;
  327.            );
  328.         7: (
  329.             endParam:                    PPCEndPBRec;
  330.            );
  331.         8: (
  332.             closeParam:                    PPCClosePBRec;
  333.            );
  334.         9: (
  335.             listPortsParam:                IPCListPortsPBRec;
  336.            );
  337.     END;
  338.  
  339. FUNCTION PPCInit: OSErr;
  340.     {$IFC NOT GENERATINGCFM}
  341.     INLINE $7000, $A0DD, $3E80;
  342.     {$ENDC}
  343. FUNCTION PPCOpen(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  344. FUNCTION PPCOpenSync(pb: PPCOpenPBPtr): OSErr;
  345.     {$IFC NOT GENERATINGCFM}
  346.     INLINE $205F, $7001, $A0DD, $3E80;
  347.     {$ENDC}
  348. FUNCTION PPCOpenAsync(pb: PPCOpenPBPtr): OSErr;
  349.     {$IFC NOT GENERATINGCFM}
  350.     INLINE $205F, $7001, $A4DD, $3E80;
  351.     {$ENDC}
  352. FUNCTION PPCInform(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  353. FUNCTION PPCInformSync(pb: PPCInformPBPtr): OSErr;
  354.     {$IFC NOT GENERATINGCFM}
  355.     INLINE $205F, $7003, $A0DD, $3E80;
  356.     {$ENDC}
  357. FUNCTION PPCInformAsync(pb: PPCInformPBPtr): OSErr;
  358.     {$IFC NOT GENERATINGCFM}
  359.     INLINE $205F, $7003, $A4DD, $3E80;
  360.     {$ENDC}
  361. FUNCTION PPCStart(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  362. FUNCTION PPCStartSync(pb: PPCStartPBPtr): OSErr;
  363.     {$IFC NOT GENERATINGCFM}
  364.     INLINE $205F, $7002, $A0DD, $3E80;
  365.     {$ENDC}
  366. FUNCTION PPCStartAsync(pb: PPCStartPBPtr): OSErr;
  367.     {$IFC NOT GENERATINGCFM}
  368.     INLINE $205F, $7002, $A4DD, $3E80;
  369.     {$ENDC}
  370. FUNCTION PPCAccept(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  371. FUNCTION PPCAcceptSync(pb: PPCAcceptPBPtr): OSErr;
  372.     {$IFC NOT GENERATINGCFM}
  373.     INLINE $205F, $7004, $A0DD, $3E80;
  374.     {$ENDC}
  375. FUNCTION PPCAcceptAsync(pb: PPCAcceptPBPtr): OSErr;
  376.     {$IFC NOT GENERATINGCFM}
  377.     INLINE $205F, $7004, $A4DD, $3E80;
  378.     {$ENDC}
  379. FUNCTION PPCReject(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  380. FUNCTION PPCRejectSync(pb: PPCRejectPBPtr): OSErr;
  381.     {$IFC NOT GENERATINGCFM}
  382.     INLINE $205F, $7005, $A0DD, $3E80;
  383.     {$ENDC}
  384. FUNCTION PPCRejectAsync(pb: PPCRejectPBPtr): OSErr;
  385.     {$IFC NOT GENERATINGCFM}
  386.     INLINE $205F, $7005, $A4DD, $3E80;
  387.     {$ENDC}
  388. FUNCTION PPCWrite(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  389. FUNCTION PPCWriteSync(pb: PPCWritePBPtr): OSErr;
  390.     {$IFC NOT GENERATINGCFM}
  391.     INLINE $205F, $7006, $A0DD, $3E80;
  392.     {$ENDC}
  393. FUNCTION PPCWriteAsync(pb: PPCWritePBPtr): OSErr;
  394.     {$IFC NOT GENERATINGCFM}
  395.     INLINE $205F, $7006, $A4DD, $3E80;
  396.     {$ENDC}
  397. FUNCTION PPCRead(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  398. FUNCTION PPCReadSync(pb: PPCReadPBPtr): OSErr;
  399.     {$IFC NOT GENERATINGCFM}
  400.     INLINE $205F, $7007, $A0DD, $3E80;
  401.     {$ENDC}
  402. FUNCTION PPCReadAsync(pb: PPCReadPBPtr): OSErr;
  403.     {$IFC NOT GENERATINGCFM}
  404.     INLINE $205F, $7007, $A4DD, $3E80;
  405.     {$ENDC}
  406. FUNCTION PPCEnd(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  407. FUNCTION PPCEndSync(pb: PPCEndPBPtr): OSErr;
  408.     {$IFC NOT GENERATINGCFM}
  409.     INLINE $205F, $7008, $A0DD, $3E80;
  410.     {$ENDC}
  411. FUNCTION PPCEndAsync(pb: PPCEndPBPtr): OSErr;
  412.     {$IFC NOT GENERATINGCFM}
  413.     INLINE $205F, $7008, $A4DD, $3E80;
  414.     {$ENDC}
  415. FUNCTION PPCClose(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  416. FUNCTION PPCCloseSync(pb: PPCClosePBPtr): OSErr;
  417.     {$IFC NOT GENERATINGCFM}
  418.     INLINE $205F, $7009, $A0DD, $3E80;
  419.     {$ENDC}
  420. FUNCTION PPCCloseAsync(pb: PPCClosePBPtr): OSErr;
  421.     {$IFC NOT GENERATINGCFM}
  422.     INLINE $205F, $7009, $A4DD, $3E80;
  423.     {$ENDC}
  424. FUNCTION IPCListPorts(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  425. FUNCTION IPCListPortsSync(pb: IPCListPortsPBPtr): OSErr;
  426.     {$IFC NOT GENERATINGCFM}
  427.     INLINE $205F, $700A, $A0DD, $3E80;
  428.     {$ENDC}
  429. FUNCTION IPCListPortsAsync(pb: IPCListPortsPBPtr): OSErr;
  430.     {$IFC NOT GENERATINGCFM}
  431.     INLINE $205F, $700A, $A4DD, $3E80;
  432.     {$ENDC}
  433. FUNCTION DeleteUserIdentity(userRef: LONGINT): OSErr;
  434. FUNCTION GetDefaultUser(VAR userRef: LONGINT; VAR userName: Str32): OSErr;
  435. FUNCTION StartSecureSession(pb: PPCStartPBPtr; VAR userName: Str32; useDefault: BOOLEAN; allowGuest: BOOLEAN; VAR guestSelected: BOOLEAN; prompt: ConstStr255Param): OSErr;
  436. TYPE
  437.     PPCFilterProcPtr = ProcPtr;  { FUNCTION PPCFilter(name: LocationNamePtr; port: PortInfoPtr): BOOLEAN; }
  438.     PPCFilterUPP = UniversalProcPtr;
  439.  
  440. CONST
  441.     uppPPCCompProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  442.     uppPPCFilterProcInfo = $000003D0; { FUNCTION (4 byte param, 4 byte param): 1 byte result; }
  443.  
  444. FUNCTION NewPPCCompProc(userRoutine: PPCCompProcPtr): PPCCompUPP;
  445.     {$IFC NOT GENERATINGCFM }
  446.     INLINE $2E9F;
  447.     {$ENDC}
  448.  
  449. FUNCTION NewPPCFilterProc(userRoutine: PPCFilterProcPtr): PPCFilterUPP;
  450.     {$IFC NOT GENERATINGCFM }
  451.     INLINE $2E9F;
  452.     {$ENDC}
  453.  
  454. PROCEDURE CallPPCCompProc(pb: PPCParamBlockPtr; userRoutine: PPCCompUPP);
  455.     {$IFC NOT GENERATINGCFM}
  456.     INLINE $205F, $4E90;
  457.     {$ENDC}
  458.  
  459. FUNCTION CallPPCFilterProc(name: LocationNamePtr; port: PortInfoPtr; userRoutine: PPCFilterUPP): BOOLEAN;
  460.     {$IFC NOT GENERATINGCFM}
  461.     INLINE $205F, $4E90;
  462.     {$ENDC}
  463.  
  464. FUNCTION PPCBrowser(prompt: ConstStr255Param; applListLabel: ConstStr255Param; defaultSpecified: BOOLEAN; VAR theLocation: LocationNameRec; VAR thePortInfo: PortInfoRec; portFilter: PPCFilterUPP; theLocNBPType: ConstStr32Param): OSErr;
  465.     {$IFC NOT GENERATINGCFM}
  466.     INLINE $303C, $0D00, $A82B;
  467.     {$ENDC}
  468.  
  469. {$ALIGN RESET}
  470. {$POP}
  471.  
  472. {$SETC UsingIncludes := PPCToolboxIncludes}
  473.  
  474. {$ENDC} {__PPCTOOLBOX__}
  475.  
  476. {$IFC NOT UsingIncludes}
  477.  END.
  478. {$ENDC}
  479.