/packages/univint/src/CFMessagePort.pas

https://github.com/slibre/freepascal · Pascal · 239 lines · 40 code · 25 blank · 174 comment · 0 complexity · 539ef2856f1ce66408b7f6022c234f22 MD5 · raw file 

    

  1. {	CFMessagePort.h
    2. 

  2. 	Copyright (c) 1998-2012, Apple Inc. All rights reserved.
    3. 

  3. }
    4. 

  4. {	  Pascal Translation:  Peter N Lewis, <peter@stairways.com.au>, 2004 }
    5. 

  5. {	  Pascal Translation Updated:  Peter N Lewis, <peter@stairways.com.au>, September 2005 }
    6. 

  6. {	  Pascal Translation Updated:  Jonas Maebe, <jonas@freepascal.org>, October 2009 }
    7. 

  7. {	  Pascal Translation Updated:  Jonas Maebe <jonas@freepascal.org>, September 2012 }
    8. 

  8. {
    9. 

  9.     Modified for use with Free Pascal
    10. 

  10.     Version 308
    11. 

  11.     Please report any bugs to <gpc@microbizz.nl>
    12. 

  12. }
    13. 

  13. 

  14. {$ifc not defined MACOSALLINCLUDE or not MACOSALLINCLUDE}
    15. 

  15. {$mode macpas}
    16. 

  16. {$packenum 1}
    17. 

  17. {$macro on}
    18. 

  18. {$inline on}
    19. 

  19. {$calling mwpascal}
    20. 

  20. 

  21. unit CFMessagePort;
    22. 

  22. interface
    23. 

  23. {$setc UNIVERSAL_INTERFACES_VERSION := $0400}
    24. 

  24. {$setc GAP_INTERFACES_VERSION := $0308}
    25. 

  25. 

  26. {$ifc not defined USE_CFSTR_CONSTANT_MACROS}
    27. 

  27.     {$setc USE_CFSTR_CONSTANT_MACROS := TRUE}
    28. 

  28. {$endc}
    29. 

  29. 

  30. {$ifc defined CPUPOWERPC and defined CPUI386}
    31. 

  31. 	{$error Conflicting initial definitions for CPUPOWERPC and CPUI386}
    32. 

  32. {$endc}
    33. 

  33. {$ifc defined FPC_BIG_ENDIAN and defined FPC_LITTLE_ENDIAN}
    34. 

  34. 	{$error Conflicting initial definitions for FPC_BIG_ENDIAN and FPC_LITTLE_ENDIAN}
    35. 

  35. {$endc}
    36. 

  36. 

  37. {$ifc not defined __ppc__ and defined CPUPOWERPC32}
    38. 

  38. 	{$setc __ppc__ := 1}
    39. 

  39. {$elsec}
    40. 

  40. 	{$setc __ppc__ := 0}
    41. 

  41. {$endc}
    42. 

  42. {$ifc not defined __ppc64__ and defined CPUPOWERPC64}
    43. 

  43. 	{$setc __ppc64__ := 1}
    44. 

  44. {$elsec}
    45. 

  45. 	{$setc __ppc64__ := 0}
    46. 

  46. {$endc}
    47. 

  47. {$ifc not defined __i386__ and defined CPUI386}
    48. 

  48. 	{$setc __i386__ := 1}
    49. 

  49. {$elsec}
    50. 

  50. 	{$setc __i386__ := 0}
    51. 

  51. {$endc}
    52. 

  52. {$ifc not defined __x86_64__ and defined CPUX86_64}
    53. 

  53. 	{$setc __x86_64__ := 1}
    54. 

  54. {$elsec}
    55. 

  55. 	{$setc __x86_64__ := 0}
    56. 

  56. {$endc}
    57. 

  57. {$ifc not defined __arm__ and defined CPUARM}
    58. 

  58. 	{$setc __arm__ := 1}
    59. 

  59. {$elsec}
    60. 

  60. 	{$setc __arm__ := 0}
    61. 

  61. {$endc}
    62. 

  62. 

  63. {$ifc defined cpu64}
    64. 

  64.   {$setc __LP64__ := 1}
    65. 

  65. {$elsec}
    66. 

  66.   {$setc __LP64__ := 0}
    67. 

  67. {$endc}
    68. 

  68. 

  69. 

  70. {$ifc defined __ppc__ and __ppc__ and defined __i386__ and __i386__}
    71. 

  71. 	{$error Conflicting definitions for __ppc__ and __i386__}
    72. 

  72. {$endc}
    73. 

  73. 

  74. {$ifc defined __ppc__ and __ppc__}
    75. 

  75. 	{$setc TARGET_CPU_PPC := TRUE}
    76. 

  76. 	{$setc TARGET_CPU_PPC64 := FALSE}
    77. 

  77. 	{$setc TARGET_CPU_X86 := FALSE}
    78. 

  78. 	{$setc TARGET_CPU_X86_64 := FALSE}
    79. 

  79. 	{$setc TARGET_CPU_ARM := FALSE}
    80. 

  80. 	{$setc TARGET_OS_MAC := TRUE}
    81. 

  81. 	{$setc TARGET_OS_IPHONE := FALSE}
    82. 

  82. 	{$setc TARGET_IPHONE_SIMULATOR := FALSE}
    83. 

  83. 	{$setc TARGET_OS_EMBEDDED := FALSE}
    84. 

  84. {$elifc defined __ppc64__ and __ppc64__}
    85. 

  85. 	{$setc TARGET_CPU_PPC := FALSE}
    86. 

  86. 	{$setc TARGET_CPU_PPC64 := TRUE}
    87. 

  87. 	{$setc TARGET_CPU_X86 := FALSE}
    88. 

  88. 	{$setc TARGET_CPU_X86_64 := FALSE}
    89. 

  89. 	{$setc TARGET_CPU_ARM := FALSE}
    90. 

  90. 	{$setc TARGET_OS_MAC := TRUE}
    91. 

  91. 	{$setc TARGET_OS_IPHONE := FALSE}
    92. 

  92. 	{$setc TARGET_IPHONE_SIMULATOR := FALSE}
    93. 

  93. 	{$setc TARGET_OS_EMBEDDED := FALSE}
    94. 

  94. {$elifc defined __i386__ and __i386__}
    95. 

  95. 	{$setc TARGET_CPU_PPC := FALSE}
    96. 

  96. 	{$setc TARGET_CPU_PPC64 := FALSE}
    97. 

  97. 	{$setc TARGET_CPU_X86 := TRUE}
    98. 

  98. 	{$setc TARGET_CPU_X86_64 := FALSE}
    99. 

  99. 	{$setc TARGET_CPU_ARM := FALSE}
    100. 

  100. {$ifc defined(iphonesim)}
    101. 

  101.  	{$setc TARGET_OS_MAC := FALSE}
    102. 

  102. 	{$setc TARGET_OS_IPHONE := TRUE}
    103. 

  103. 	{$setc TARGET_IPHONE_SIMULATOR := TRUE}
    104. 

  104. {$elsec}
    105. 

  105. 	{$setc TARGET_OS_MAC := TRUE}
    106. 

  106. 	{$setc TARGET_OS_IPHONE := FALSE}
    107. 

  107. 	{$setc TARGET_IPHONE_SIMULATOR := FALSE}
    108. 

  108. {$endc}
    109. 

  109. 	{$setc TARGET_OS_EMBEDDED := FALSE}
    110. 

  110. {$elifc defined __x86_64__ and __x86_64__}
    111. 

  111. 	{$setc TARGET_CPU_PPC := FALSE}
    112. 

  112. 	{$setc TARGET_CPU_PPC64 := FALSE}
    113. 

  113. 	{$setc TARGET_CPU_X86 := FALSE}
    114. 

  114. 	{$setc TARGET_CPU_X86_64 := TRUE}
    115. 

  115. 	{$setc TARGET_CPU_ARM := FALSE}
    116. 

  116. 	{$setc TARGET_OS_MAC := TRUE}
    117. 

  117. 	{$setc TARGET_OS_IPHONE := FALSE}
    118. 

  118. 	{$setc TARGET_IPHONE_SIMULATOR := FALSE}
    119. 

  119. 	{$setc TARGET_OS_EMBEDDED := FALSE}
    120. 

  120. {$elifc defined __arm__ and __arm__}
    121. 

  121. 	{$setc TARGET_CPU_PPC := FALSE}
    122. 

  122. 	{$setc TARGET_CPU_PPC64 := FALSE}
    123. 

  123. 	{$setc TARGET_CPU_X86 := FALSE}
    124. 

  124. 	{$setc TARGET_CPU_X86_64 := FALSE}
    125. 

  125. 	{$setc TARGET_CPU_ARM := TRUE}
    126. 

  126. 	{ will require compiler define when/if other Apple devices with ARM cpus ship }
    127. 

  127. 	{$setc TARGET_OS_MAC := FALSE}
    128. 

  128. 	{$setc TARGET_OS_IPHONE := TRUE}
    129. 

  129. 	{$setc TARGET_IPHONE_SIMULATOR := FALSE}
    130. 

  130. 	{$setc TARGET_OS_EMBEDDED := TRUE}
    131. 

  131. {$elsec}
    132. 

  132. 	{$error __ppc__ nor __ppc64__ nor __i386__ nor __x86_64__ nor __arm__ is defined.}
    133. 

  133. {$endc}
    134. 

  134. 

  135. {$ifc defined __LP64__ and __LP64__ }
    136. 

  136.   {$setc TARGET_CPU_64 := TRUE}
    137. 

  137. {$elsec}
    138. 

  138.   {$setc TARGET_CPU_64 := FALSE}
    139. 

  139. {$endc}
    140. 

  140. 

  141. {$ifc defined FPC_BIG_ENDIAN}
    142. 

  142. 	{$setc TARGET_RT_BIG_ENDIAN := TRUE}
    143. 

  143. 	{$setc TARGET_RT_LITTLE_ENDIAN := FALSE}
    144. 

  144. {$elifc defined FPC_LITTLE_ENDIAN}
    145. 

  145. 	{$setc TARGET_RT_BIG_ENDIAN := FALSE}
    146. 

  146. 	{$setc TARGET_RT_LITTLE_ENDIAN := TRUE}
    147. 

  147. {$elsec}
    148. 

  148. 	{$error Neither FPC_BIG_ENDIAN nor FPC_LITTLE_ENDIAN are defined.}
    149. 

  149. {$endc}
    150. 

  150. {$setc ACCESSOR_CALLS_ARE_FUNCTIONS := TRUE}
    151. 

  151. {$setc CALL_NOT_IN_CARBON := FALSE}
    152. 

  152. {$setc OLDROUTINENAMES := FALSE}
    153. 

  153. {$setc OPAQUE_TOOLBOX_STRUCTS := TRUE}
    154. 

  154. {$setc OPAQUE_UPP_TYPES := TRUE}
    155. 

  155. {$setc OTCARBONAPPLICATION := TRUE}
    156. 

  156. {$setc OTKERNEL := FALSE}
    157. 

  157. {$setc PM_USE_SESSION_APIS := TRUE}
    158. 

  158. {$setc TARGET_API_MAC_CARBON := TRUE}
    159. 

  159. {$setc TARGET_API_MAC_OS8 := FALSE}
    160. 

  160. {$setc TARGET_API_MAC_OSX := TRUE}
    161. 

  161. {$setc TARGET_CARBON := TRUE}
    162. 

  162. {$setc TARGET_CPU_68K := FALSE}
    163. 

  163. {$setc TARGET_CPU_MIPS := FALSE}
    164. 

  164. {$setc TARGET_CPU_SPARC := FALSE}
    165. 

  165. {$setc TARGET_OS_UNIX := FALSE}
    166. 

  166. {$setc TARGET_OS_WIN32 := FALSE}
    167. 

  167. {$setc TARGET_RT_MAC_68881 := FALSE}
    168. 

  168. {$setc TARGET_RT_MAC_CFM := FALSE}
    169. 

  169. {$setc TARGET_RT_MAC_MACHO := TRUE}
    170. 

  170. {$setc TYPED_FUNCTION_POINTERS := TRUE}
    171. 

  171. {$setc TYPE_BOOL := FALSE}
    172. 

  172. {$setc TYPE_EXTENDED := FALSE}
    173. 

  173. {$setc TYPE_LONGLONG := TRUE}
    174. 

  174. uses MacTypes,CFBase,CFString,CFRunLoop,CFData,CFDate;
    175. 

  175. {$endc} {not MACOSALLINCLUDE}
    176. 

  176. 

  177. {$ALIGN POWER}
    178. 

  178. 

  179. 

  180. type
    181. 

  181. 	CFMessagePortRef = ^__CFMessagePort; { an opaque type }
    182. 

  182. 	__CFMessagePort = record end;
    183. 

  183. 

  184. const
    185. 

  185. 	kCFMessagePortSuccess = 0;
    186. 

  186. 	kCFMessagePortSendTimeout = -1;
    187. 

  187. 	kCFMessagePortReceiveTimeout = -2;
    188. 

  188. 	kCFMessagePortIsInvalid = -3;
    189. 

  189. 	kCFMessagePortTransportError = -4;
    190. 

  190. 	kCFMessagePortBecameInvalidError = -5;
    191. 

  191. 

  192. type
    193. 

  193. 	CFMessagePortContext = record
    194. 

  194. 		version: CFIndex;
    195. 

  195. 		info: UnivPtr;
    196. 

  196. 		retain: function( info: {const} UnivPtr ): UnivPtr;
    197. 

  197. 		release: procedure( info: {const} UnivPtr );
    198. 

  198. 		copyDescription: function( info: {const} UnivPtr ): CFStringRef;
    199. 

  199. 	end;
    200. 

  200. 	CFMessagePortContextPtr = ^CFMessagePortContext;
    201. 

  201. 

  202. type
    203. 

  203. 	CFMessagePortCallBack = function( local: CFMessagePortRef; msgid: SInt32; data: CFDataRef; info: UnivPtr ): CFDataRef;
    204. 

  204. { If callout wants to keep a hold of the data past the return of the callout, it must COPY the data. This includes the case where the data is given to some routine which _might_ keep a hold of it; System will release returned CFData. }
    205. 

  205. type
    206. 

  206. 	CFMessagePortInvalidationCallBack = procedure( ms: CFMessagePortRef; info: UnivPtr );
    207. 

  207. 

  208. function CFMessagePortGetTypeID: CFTypeID; external name '_CFMessagePortGetTypeID';
    209. 

  209. 

  210. function CFMessagePortCreateLocal( allocator: CFAllocatorRef; name: CFStringRef; callout: CFMessagePortCallBack; var context: CFMessagePortContext; var shouldFreeInfo: Boolean ): CFMessagePortRef; external name '_CFMessagePortCreateLocal';
    211. 

  211. function CFMessagePortCreateRemote( allocator: CFAllocatorRef; name: CFStringRef ): CFMessagePortRef; external name '_CFMessagePortCreateRemote';
    212. 

  212. 

  213. function CFMessagePortIsRemote( ms: CFMessagePortRef ): Boolean; external name '_CFMessagePortIsRemote';
    214. 

  214. function CFMessagePortGetName( ms: CFMessagePortRef ): CFStringRef; external name '_CFMessagePortGetName';
    215. 

  215. function CFMessagePortSetName( ms: CFMessagePortRef; newName: CFStringRef ): Boolean; external name '_CFMessagePortSetName';
    216. 

  216. procedure CFMessagePortGetContext( ms: CFMessagePortRef; var context: CFMessagePortContext ); external name '_CFMessagePortGetContext';
    217. 

  217. procedure CFMessagePortInvalidate( ms: CFMessagePortRef ); external name '_CFMessagePortInvalidate';
    218. 

  218. function CFMessagePortIsValid( ms: CFMessagePortRef ): Boolean; external name '_CFMessagePortIsValid';
    219. 

  219. function CFMessagePortGetInvalidationCallBack( ms: CFMessagePortRef ): CFMessagePortInvalidationCallBack; external name '_CFMessagePortGetInvalidationCallBack';
    220. 

  220. procedure CFMessagePortSetInvalidationCallBack( ms: CFMessagePortRef; callout: CFMessagePortInvalidationCallBack ); external name '_CFMessagePortSetInvalidationCallBack';
    221. 

  221. 

  222. { NULL replyMode argument means no return value expected, dont wait for it }
    223. 

  223. function CFMessagePortSendRequest( remote: CFMessagePortRef; msgid: SInt32; data: CFDataRef; sendTimeout: CFTimeInterval; rcvTimeout: CFTimeInterval; replyMode: CFStringRef; returnData: CFDataRefPtr ): SInt32; external name '_CFMessagePortSendRequest';
    224. 

  224. 

  225. function CFMessagePortCreateRunLoopSource( allocator: CFAllocatorRef; local: CFMessagePortRef; order: CFIndex ): CFRunLoopSourceRef; external name '_CFMessagePortCreateRunLoopSource';
    226. 

  226. 

  227. {#if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) || (TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)}
    228. 

  228. {
    229. 

  229. First requires translation of dispatch/dispatch.h and the files it includes
    230. 

  230. 

  231. procedure CFMessagePortSetDispatchQueue( ms: CFMessagePortRef; queue: dispatch_queue_t ); external name '_CFMessagePortSetDispatchQueue';
    232. 

  232. (* CF_AVAILABLE_STARTING(10_6, 4_0) *)
    233. 

  233. }
    234. 

  234. 

  235. {#endif}
    236. 

  236. {$ifc not defined MACOSALLINCLUDE or not MACOSALLINCLUDE}
    237. 

  237. 

  238. end.
    239. 

  239. {$endc} {not MACOSALLINCLUDE}
    240.