/packages/amunits/src/otherlibs/amarquee.pas

https://github.com/slibre/freepascal · Pascal · 1155 lines · 890 code · 128 blank · 137 comment · 6 complexity · e307e5e17655eac8b49d5f477861b1f0 MD5 · raw file 

    

  1. {
    2. 

  2.     This file is part of the Free Pascal run time library.
    3. 

  3. 

  4.     A file in Amiga system run time library.
    5. 

  5.     Copyright (c) 1998-2000 by Nils Sjoholm
    6. 

  6.     member of the Amiga RTL development team.
    7. 

  7. 

  8.     See the file COPYING.FPC, included in this distribution,
    9. 

  9.     for details about the copyright.
    10. 

  10. 

  11.     This program is distributed in the hope that it will be useful,
    12. 

  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    13. 

  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    14. 

  14. 

  15.  **********************************************************************}
    16. 

  16. 

  17. {
    18. 

  18.   History:
    19. 

  19. 

  20.   First translation of AMarquee.h to FPC pascal.
    21. 

  21.   No testing has been done so there could be bugs
    22. 

  22.   in here. If you find any bugs please let me know.
    23. 

  23.   25 Aug 2000.
    24. 

  24. 

  25.   Added functions and procedures with array of const.
    26. 

  26.   For use with fpc 1.0.7
    27. 

  27.   30 Nov 2002.
    28. 

  28. 

  29.   Added the defines use_amiga_smartlink and
    30. 

  30.   use_auto_openlib.
    31. 

  31.   12 Jan 2003.
    32. 

  32. 

  33.   Changed startcode for unit.
    34. 

  34.   10 Feb 2003.
    35. 

  35. 

  36.   nils.sjoholm@mailbox.swipnet.se
    37. 

  37. 

  38. }
    39. 

  39. 

  40. {$mode objfpc}
    41. 

  41. {$I useamigasmartlink.inc}
    42. 

  42. {$ifdef use_amiga_smartlink}
    43. 

  43.     {$smartlink on}
    44. 

  44. {$endif use_amiga_smartlink}
    45. 

  45. unit amarquee;
    46. 

  46. 

  47. 

  48. interface
    49. 

  49. 

  50. 

  51. uses exec, utility;
    52. 

  52. 

  53. 

  54. 

  55.   { This library contains definitions and structures necessary to use amarquee.library.  }
    56. 

  56.   { Different error types that can be returned to the client in QMessages  }
    57. 

  57.   { Everything is okay  }
    58. 

  58. 

  59.   const
    60. 

  60.      AMARQUEENAME : PChar = 'amarquee.library';
    61. 

  61. 

  62.      QERROR_NO_ERROR = 0;
    63. 

  63.   { Don't know what the error was.  }
    64. 

  64.      QERROR_UNKNOWN = -(1);
    65. 

  65.   { Keystring could not be parsed or "dir" does not exist  }
    66. 

  66.      QERROR_MALFORMED_KEY = -(2);
    67. 

  67.   { Server did not have enough mem available to complete request  }
    68. 

  68.      QERROR_NO_SERVER_MEM = -(3);
    69. 

  69.   { The connection to the server went south  }
    70. 

  70.      QERROR_NO_CONNECTION = -(4);
    71. 

  71.   { You're not allowed to do that!  }
    72. 

  72.      QERROR_UNPRIVILEGED = -(5);
    73. 

  73.   { Feature you requested does not exist yet  }
    74. 

  74.      QERROR_UNIMPLEMENTED = -(6);
    75. 

  75.   { Your computer didn't have enough memory available to complete an action  }
    76. 

  76.      QERROR_NO_CLIENT_MEM = -(7);
    77. 

  77.   { This message is a "wall" text message from a server admin  }
    78. 

  78.      QERROR_SYS_MESSAGE = -(8);
    79. 

  79.   { This message is a "send done" notification from your client TCP thread (new for v47)  }
    80. 

  80.      QERROR_SEND_DONE = -(9);
    81. 

  81.   { These error types may be returned by QFreeSession() or set to the error code
    82. 

  82.   variable (set with the QSESSION_ERRORCODEPTR tag), after a QSession
    83. 

  83.   allocation attempt fails.  }
    84. 

  84.   { TCP stack wasn't running  }
    85. 

  85.      QERROR_NO_TCP_STACK = -(20);
    86. 

  86.   { Hostname lookup of server failed  }
    87. 

  87.      QERROR_HOSTNAME_LOOKUP = -(21);
    88. 

  88.   { TCP thread got a control-C  }
    89. 

  89.      QERROR_ABORTED = -(22);
    90. 

  90.   { No AMarquee server at requested host/port  }
    91. 

  91.      QERROR_NO_SERVER = -(23);
    92. 

  92.   { The program wasn't launched by inetd  }
    93. 

  93.      QERROR_NO_INETD = -(24);
    94. 

  94.   { The server wouldn't accept our connection  }
    95. 

  95.      QERROR_ACCESS_DENIED = -(25);
    96. 

  96.   { The client is out of memory  }
    97. 

  97.      QERROR_NO_MEMORY = -(26);
    98. 

  98.   { No server at requested host/port  }
    99. 

  99.      QERROR_NO_TCPSERVER = -(27);
    100. 

  100.   { Flags to use with QGo()  }
    101. 

  101.   { Request notification via sync packet when all has settled on the server side  }
    102. 

  102.      QGOF_SYNC = 1 shl 0;
    103. 

  103.   { Request notification via QERROR_SEND_DONE message when the TCP thread has finished sending this transaction (new for v47)  }
    104. 

  104.      QGOF_NOTIFY = 1 shl 1;
    105. 

  105.   { Flags representing special privileges; used with QRequestPrivileges(), etc  }
    106. 

  106.   { license to kill!  }
    107. 

  107.      QPRIV_KILLCLIENTS = 1 shl 0;
    108. 

  108.   { Ability to set env vars, etc, on the server  }
    109. 

  109.      QPRIV_ADMIN = 1 shl 1;
    110. 

  110.   { Ability to receive special sysadmin messages  }
    111. 

  111.      QPRIV_GETSYSMESSAGES = 1 shl 2;
    112. 

  112.   { Ability to send special sysadmin messages  }
    113. 

  113.      QPRIV_SENDSYSMESSAGES = 1 shl 3;
    114. 

  114.   { all possible QPRIV_  bits  }
    115. 

  115.      QPRIV_ALL = $0F;
    116. 

  116.   { Wait() on this for QMessages!  }
    117. 

  117.   {                                                                   }
    118. 

  118.   { Invisible, private info is here... don't trust sizeof(QSession)!  }
    119. 

  119.   {                                                                   }
    120. 

  120. 

  121.   type
    122. 

  122.      PQSession = ^TQSession;
    123. 

  123.      TQSession = record
    124. 

  124.           qMsgPort : PMsgPort;
    125. 

  125.        end;
    126. 

  126. 

  127.   { All events from AMarquee come in this package!  }
    128. 

  128.   { Don't directly use the contents of qm_Msg!  }
    129. 

  129.   { Message ID # of transaction related to this opCode, or -1 if no ID is applicable.  }
    130. 

  130.   { One of the QERROR_  codes defined in AMarquee headers.  }
    131. 

  131.   { Pathname of a node, or NULL if not applicable.  }
    132. 

  132.   { Pointer to beginning of data buffer, or NULL if not applicable.  }
    133. 

  133.   { Length of qm_Data buffer, or 0 if not applicable.  }
    134. 

  134.   { Length of the data buffer stored on the AMarquee server.  }
    135. 

  135.   { Line # of the server source code that generated the error.  Useful for debugging.  }
    136. 

  136.   { Private info used by FreeQMessage()  }
    137. 

  137.   { Added for v48; more private info used by FreeQMessage()  }
    138. 

  138.   { Added for v50. The session this message comes from. Necessary with shared msgports   }
    139. 

  139.      PQMessage = ^TQMessage;
    140. 

  140.      TQMessage = record
    141. 

  141.           qm_Msg : tMessage;
    142. 

  142.           qm_ID : LONG;
    143. 

  143.           qm_Status : longint;
    144. 

  144.           qm_Path : Pchar;
    145. 

  145.           qm_Data : pointer;
    146. 

  146.           qm_DataLen : ULONG;
    147. 

  147.           qm_ActualLen : ULONG;
    148. 

  148.           qm_ErrorLine : ULONG;
    149. 

  149.           qm_Private : pointer;
    150. 

  150.           qm_Private2 : pointer;
    151. 

  151.           qm_Session : PQSession;
    152. 

  152.        end;
    153. 

  153. 

  154.   { The theoretical maximum number of bytes your server may allocate.  }
    155. 

  155.   { The number of bytes currently allocated by your server.  }
    156. 

  156.   { The number of bytes that may actually be allocated by your server.  }
    157. 

  157.   { Bit-chord of QPRIV_  bits, showing what special privs you have.  }
    158. 

  158.   { Bit-chord of QPRIV_  bits, showing what special privs you could get if you asked.  }
    159. 

  159.      PQRunInfo = ^TQRunInfo;
    160. 

  160.      TQRunInfo = record
    161. 

  161.           qr_Allowed : LONG;
    162. 

  162.           qr_Alloced : LONG;
    163. 

  163.           qr_Avail : LONG;
    164. 

  164.           qr_CurrentPrivs : ULONG;
    165. 

  165.           qr_PossiblePrivs : ULONG;
    166. 

  166.        end;
    167. 

  167. 

  168.   { Used internally  }
    169. 

  169.   { the message port to listen on  }
    170. 

  170.      PQSharedMessagePort = ^TQSharedMessagePort;
    171. 

  171.      TQSharedMessagePort = record
    172. 

  172.           qs_private : tSignalSemaphore;
    173. 

  173.           qs_mp : PMsgPort;
    174. 

  174.        end;
    175. 

  175. 

  176.   { the QRAWSESSION_PROTOCOLSTOPHOOK Hook function receive a pointer to the Hook in A0, the QSession
    177. 

  177.   pointer in A2 and a pointer to a QProtocolStopMarkerMessage in A1. Return the length of the buffer
    178. 

  178.   to send to the client. Return a length of 0 if not enough data is present. With this function
    179. 

  179.   it's easy to make sure that no structs or other datatypes get stripped.  }
    180. 

  180.      PQProtocolStopMarkerMessage = ^TQProtocolStopMarkerMessage;
    181. 

  181.      TQProtocolStopMarkerMessage = record
    182. 

  182.           buffer : STRPTR;
    183. 

  183.           length : ULONG;
    184. 

  184.           userdata : ULONG;
    185. 

  185.           id : LONG;
    186. 

  186.        end;
    187. 

  187. 

  188.   { Tags to use with QNewSocketSession(Async)  }
    189. 

  189.   { (ULONG maxBufSize) The maximum buffer size to use (same as QSetMaxRawBufSize())  }
    190. 

  190. 

  191.   const
    192. 

  192.      QRAWSESSION_MAXBUFFERSIZE = $a0000001;
    193. 

  193.   { (struct Hook  stopmarkerfunc) A hook with the function which sets the stop marker for a block of data  }
    194. 

  194.      QRAWSESSION_PROTOCOLSTOPHOOK = $a0000002;
    195. 

  195.   { (BOOL b) default TRUE. Shall the last data before the connection is broken be sent to the client even though the PROTOCOLSTOPHOOK hook specify it shouldn't ? }
    196. 

  196.      QRAWSESSION_RECEIVE_EXCEEDING_DATA = $a0000003;
    197. 

  197.   { (ULONG u) The initial value of the userdata field in struct QProtocolStopMarkerMessage  }
    198. 

  198.      QRAWSESSION_PROTOCOLSTOPHOOK_USERDATA = $a0000004;
    199. 

  199.   { Tags to use with QNew Session(Async) and QNewSocket Session(Async)  }
    200. 

  200.   { (LONG  errorCode) A pointer to the variable that will hold the error code  }
    201. 

  201.      QSESSION_ERRORCODEPTR = $b0000001;
    202. 

  202.   { (struct QSharedMessagePort  mp) A shared message port created with QCreateSharedMessagePort()  }
    203. 

  203.      QSESSION_SHAREDMSGPORT = $b0000002;
    204. 

  204. 

  205. VAR AMarqueeBase : pLibrary;
    206. 

  206. 

  207. FUNCTION QFreeSession(session : pQSession) : LONGINT;
    208. 

  208. FUNCTION QDebugOp(session : pQSession; string_ : pCHar) : LONGINT;
    209. 

  209. FUNCTION QGetOp(session : pQSession; path : pCHar; maxBytes : LONGINT) : LONGINT;
    210. 

  210. FUNCTION QDeleteOp(session : pQSession; path : pCHar) : LONGINT;
    211. 

  211. FUNCTION QRenameOp(session : pQSession; path : pCHar; label_ : pCHar) : LONGINT;
    212. 

  212. FUNCTION QSubscribeOp(session : pQSession; path : pCHar; maxBytes : LONGINT) : LONGINT;
    213. 

  213. FUNCTION QSetOp(session : pQSession; path : pCHar; buf : POINTER; len : ULONG) : LONGINT;
    214. 

  214. FUNCTION QClearSubscriptionsOp(session : pQSession; which : LONGINT) : LONGINT;
    215. 

  215. FUNCTION QPingOp(session : pQSession) : LONGINT;
    216. 

  216. FUNCTION QInfoOp(session : pQSession) : LONGINT;
    217. 

  217. FUNCTION QSetAccessOp(session : pQSession; hosts : pCHar) : LONGINT;
    218. 

  218. PROCEDURE FreeQMessage(session : pQSession; qmsg : pQMessage);
    219. 

  219. FUNCTION QGo(session : pQSession; sync : ULONG) : LONGINT;
    220. 

  220. FUNCTION QStreamOp(session : pQSession; path : pCHar; buf : POINTER; len : ULONG) : LONGINT;
    221. 

  221. FUNCTION QSetMessageAccessOp(session : pQSession; access : pCHar; maxbytes : LONGINT) : LONGINT;
    222. 

  222. FUNCTION QMessageOp(session : pQSession; hosts : pCHar; buffer : POINTER; len : ULONG) : LONGINT;
    223. 

  223. FUNCTION QNumQueuedPackets(session : pQSession) : ULONG;
    224. 

  224. FUNCTION QNumQueuedBytes(session : pQSession) : ULONG;
    225. 

  225. FUNCTION QErrorName(session : LONGINT) : pCHar;
    226. 

  226. FUNCTION QRequestPrivilegesOp(session : pQSession; privBits : ULONG) : LONGINT;
    227. 

  227. FUNCTION QReleasePrivilegesOp(session : pQSession; privBits : ULONG) : LONGINT;
    228. 

  228. FUNCTION QKillClientsOp(session : pQSession; hosts : pCHar) : LONGINT;
    229. 

  229. FUNCTION QSetParameterOp(session : pQSession; paramName : pCHar; newValue : pCHar) : LONGINT;
    230. 

  230. FUNCTION QGetParameterOp(session : pQSession; paramName : pCHar) : LONGINT;
    231. 

  231. FUNCTION QSysMessageOp(session : pQSession; hosts : pCHar; message : pCHar) : LONGINT;
    232. 

  232. FUNCTION QGetAndSubscribeOp(session : pQSession; path : pCHar; maxBytes : LONGINT) : LONGINT;
    233. 

  233. FUNCTION QDetachSession(session : pQSession; flags : ULONG) : BOOLEAN;
    234. 

  234. FUNCTION QReattachSession(session : pQSession; flags : ULONG) : BOOLEAN;
    235. 

  235. FUNCTION QNewSocketSession(host : pCHar; port : LONGINT; tags : pTagItem) : pQSession;
    236. 

  236. FUNCTION QSendRawOp(session : pQSession; buf : POINTER; len : ULONG) : LONGINT;
    237. 

  237. FUNCTION QNewSocketSessionAsync(host : pCHar; port : LONGINT; tags : pTagItem) : pQSession;
    238. 

  238. FUNCTION QNewSocketServerSession( port : pLONGINT; tags : pTagItem) : pQSession;
    239. 

  239. FUNCTION QSetKeyAccessOp(session : pQSession; path : pCHar; hosts : pCHar) : LONGINT;
    240. 

  240. FUNCTION QGetHostName(session : pQSession) : pCHar;
    241. 

  241. FUNCTION QGetProgName(session : pQSession) : pCHar;
    242. 

  242. PROCEDURE QSetMaxRawBufSize(session : pQSession; maxBufSize : ULONG);
    243. 

  243. FUNCTION QNewSession(host : pCHar; port : LONGINT; name : pCHar; taglist : pTagItem) : pQSession;
    244. 

  244. FUNCTION QNewSessionAsync(host : pCHar; port : LONGINT; name : pCHar; taglist : pTagItem) : pQSession;
    245. 

  245. FUNCTION QNewHostSession(hostnames : pCHar; port : pLONGINT; names : pCHar; taglist : pTagItem) : pQSession;
    246. 

  246. FUNCTION QNewServerSession(hostNames : pCHar; progNames : pCHar; taglist : pTagItem) : pQSession;
    247. 

  247. FUNCTION QCreateSharedMessagePort : pQSharedMessagePort;
    248. 

  248. PROCEDURE QDeleteSharedMessagePort(mp : pQSharedMessagePort);
    249. 

  249. FUNCTION QGetLocalIP(session : pQSession) : pCHAR;
    250. 

  250. 

  251. {
    252. 

  252.      This is functions and procedures with array of const.
    253. 

  253.      For use with fpc 1.0 and above.
    254. 

  254. 

  255. }
    256. 

  256. FUNCTION QNewSocketSessiontags(host : pCHar; port : LONGINT; const argv : Array Of Const) : pQSession;
    257. 

  257. FUNCTION QNewSocketSessionAsyncTags(host : pCHar; port : LONGINT; const argv : Array Of Const) : pQSession;
    258. 

  258. FUNCTION QNewSocketServerSessionTags( port : pLONGINT; const argv : Array Of Const) : pQSession;
    259. 

  259. FUNCTION QNewSessionTags(host : pCHar; port : LONGINT; name : pCHar; const argv : Array Of Const) : pQSession;
    260. 

  260. FUNCTION QNewSessionAsyncTags(host : pCHar; port : LONGINT; name : pCHar; const argv : Array Of Const) : pQSession;
    261. 

  261. FUNCTION QNewHostSessionTags(hostnames : pCHar; port : pLONGINT; names : pCHar; const argv : Array Of Const) : pQSession;
    262. 

  262. FUNCTION QNewServerSessionTags(hostNames : pCHar; progNames : pCHar; const argv : Array Of Const) : pQSession;
    263. 

  263. 

  264. 

  265. FUNCTION QDebugOp(session : pQSession; string_ : string) : LONGINT;
    266. 

  266. FUNCTION QGetOp(session : pQSession; path : string; maxBytes : LONGINT) : LONGINT;
    267. 

  267. FUNCTION QDeleteOp(session : pQSession; path : string) : LONGINT;
    268. 

  268. FUNCTION QRenameOp(session : pQSession; path : string; label_ : string) : LONGINT;
    269. 

  269. FUNCTION QSubscribeOp(session : pQSession; path : string; maxBytes : LONGINT) : LONGINT;
    270. 

  270. FUNCTION QSetOp(session : pQSession; path : string; buf : POINTER; len : ULONG) : LONGINT;
    271. 

  271. FUNCTION QSetAccessOp(session : pQSession; hosts : string) : LONGINT;
    272. 

  272. FUNCTION QStreamOp(session : pQSession; path : string; buf : POINTER; len : ULONG) : LONGINT;
    273. 

  273. FUNCTION QSetMessageAccessOp(session : pQSession; access : string; maxbytes : LONGINT) : LONGINT;
    274. 

  274. FUNCTION QMessageOp(session : pQSession; hosts : string; buffer : POINTER; len : ULONG) : LONGINT;
    275. 

  275. FUNCTION QKillClientsOp(session : pQSession; hosts : string) : LONGINT;
    276. 

  276. FUNCTION QSetParameterOp(session : pQSession; paramName : string; newValue : string) : LONGINT;
    277. 

  277. FUNCTION QGetParameterOp(session : pQSession; paramName : string) : LONGINT;
    278. 

  278. FUNCTION QSysMessageOp(session : pQSession; hosts : string; message : string) : LONGINT;
    279. 

  279. FUNCTION QGetAndSubscribeOp(session : pQSession; path : string; maxBytes : LONGINT) : LONGINT;
    280. 

  280. FUNCTION QNewSocketSession(host : string; port : LONGINT; tags : pTagItem) : pQSession;
    281. 

  281. FUNCTION QNewSocketSessionAsync(host : string; port : LONGINT; tags : pTagItem) : pQSession;
    282. 

  282. FUNCTION QSetKeyAccessOp(session : pQSession; path : string; hosts : string) : LONGINT;
    283. 

  283. FUNCTION QNewSession(host : string; port : LONGINT; name : string; taglist : pTagItem) : pQSession;
    284. 

  284. FUNCTION QNewSessionAsync(host : string; port : LONGINT; name : string; taglist : pTagItem) : pQSession;
    285. 

  285. FUNCTION QNewHostSession(hostnames : string; port : pLONGINT; names : string; taglist : pTagItem) : pQSession;
    286. 

  286. FUNCTION QNewServerSession(hostNames : string; progNames : string; taglist : pTagItem) : pQSession;
    287. 

  287. 

  288. {
    289. 

  289.      This is functions and procedures with array of const.
    290. 

  290.      For use with fpc 1.0 and above.
    291. 

  291. }
    292. 

  292. 

  293. FUNCTION QNewSocketSessionTags(host : string; port : LONGINT; const argv : Array Of Const) : pQSession;
    294. 

  294. FUNCTION QNewSocketSessionAsyncTags(host : string; port : LONGINT; const argv : Array Of Const) : pQSession;
    295. 

  295. FUNCTION QNewSessionTags(host : string; port : LONGINT; name : string; const argv : Array Of Const) : pQSession;
    296. 

  296. FUNCTION QNewSessionAsyncTags(host : string; port : LONGINT; name : string; const argv : Array Of Const) : pQSession;
    297. 

  297. FUNCTION QNewHostSessionTags(hostnames : string; port : pLONGINT; names : string; const argv : Array Of Const) : pQSession;
    298. 

  298. FUNCTION QNewServerSessionTags(hostNames : string; progNames : string; const argv : Array Of Const) : pQSession;
    299. 

  299. 

  300. {You can remove this include and use a define instead}
    301. 

  301. {$I useautoopenlib.inc}
    302. 

  302. {$ifdef use_init_openlib}
    303. 

  303. procedure InitAMARQUEELibrary;
    304. 

  304. {$endif use_init_openlib}
    305. 

  305. 

  306. {This is a variable that knows how the unit is compiled}
    307. 

  307. var
    308. 

  308.     AMARQUEEIsCompiledHow : longint;
    309. 

  309. 

  310. IMPLEMENTATION
    311. 

  311. 

  312. uses
    313. 

  313. {$ifndef dont_use_openlib}
    314. 

  314. msgbox,
    315. 

  315. {$endif dont_use_openlib}
    316. 

  316. pastoc,tagsarray;
    317. 

  317. 

  318. 

  319. FUNCTION QFreeSession(session : pQSession) : LONGINT;
    320. 

  320. BEGIN
    321. 

  321.   ASM
    322. 

  322.         MOVE.L  A6,-(A7)
    323. 

  323.         MOVEA.L session,A0
    324. 

  324.         MOVEA.L AMarqueeBase,A6
    325. 

  325.         JSR     -036(A6)
    326. 

  326.         MOVEA.L (A7)+,A6
    327. 

  327.         MOVE.L  D0,@RESULT
    328. 

  328.   END;
    329. 

  329. END;
    330. 

  330. 

  331. FUNCTION QDebugOp(session : pQSession; string_ : pCHar) : LONGINT;
    332. 

  332. BEGIN
    333. 

  333.   ASM
    334. 

  334.         MOVE.L  A6,-(A7)
    335. 

  335.         MOVEA.L session,A0
    336. 

  336.         MOVEA.L string_,A1
    337. 

  337.         MOVEA.L AMarqueeBase,A6
    338. 

  338.         JSR     -042(A6)
    339. 

  339.         MOVEA.L (A7)+,A6
    340. 

  340.         MOVE.L  D0,@RESULT
    341. 

  341.   END;
    342. 

  342. END;
    343. 

  343. 

  344. FUNCTION QGetOp(session : pQSession; path : pCHar; maxBytes : LONGINT) : LONGINT;
    345. 

  345. BEGIN
    346. 

  346.   ASM
    347. 

  347.         MOVE.L  A6,-(A7)
    348. 

  348.         MOVEA.L session,A0
    349. 

  349.         MOVEA.L path,A1
    350. 

  350.         MOVE.L  maxBytes,D0
    351. 

  351.         MOVEA.L AMarqueeBase,A6
    352. 

  352.         JSR     -048(A6)
    353. 

  353.         MOVEA.L (A7)+,A6
    354. 

  354.         MOVE.L  D0,@RESULT
    355. 

  355.   END;
    356. 

  356. END;
    357. 

  357. 

  358. FUNCTION QDeleteOp(session : pQSession; path : pCHar) : LONGINT;
    359. 

  359. BEGIN
    360. 

  360.   ASM
    361. 

  361.         MOVE.L  A6,-(A7)
    362. 

  362.         MOVEA.L session,A0
    363. 

  363.         MOVEA.L path,A1
    364. 

  364.         MOVEA.L AMarqueeBase,A6
    365. 

  365.         JSR     -054(A6)
    366. 

  366.         MOVEA.L (A7)+,A6
    367. 

  367.         MOVE.L  D0,@RESULT
    368. 

  368.   END;
    369. 

  369. END;
    370. 

  370. 

  371. FUNCTION QRenameOp(session : pQSession; path : pCHar; label_ : pCHar) : LONGINT;
    372. 

  372. BEGIN
    373. 

  373.   ASM
    374. 

  374.         MOVE.L  A6,-(A7)
    375. 

  375.         MOVEA.L session,A0
    376. 

  376.         MOVEA.L path,A1
    377. 

  377.         MOVE.L  label_,D0
    378. 

  378.         MOVEA.L AMarqueeBase,A6
    379. 

  379.         JSR     -060(A6)
    380. 

  380.         MOVEA.L (A7)+,A6
    381. 

  381.         MOVE.L  D0,@RESULT
    382. 

  382.   END;
    383. 

  383. END;
    384. 

  384. 

  385. FUNCTION QSubscribeOp(session : pQSession; path : pCHar; maxBytes : LONGINT) : LONGINT;
    386. 

  386. BEGIN
    387. 

  387.   ASM
    388. 

  388.         MOVE.L  A6,-(A7)
    389. 

  389.         MOVEA.L session,A0
    390. 

  390.         MOVEA.L path,A1
    391. 

  391.         MOVE.L  maxBytes,D0
    392. 

  392.         MOVEA.L AMarqueeBase,A6
    393. 

  393.         JSR     -066(A6)
    394. 

  394.         MOVEA.L (A7)+,A6
    395. 

  395.         MOVE.L  D0,@RESULT
    396. 

  396.   END;
    397. 

  397. END;
    398. 

  398. 

  399. FUNCTION QSetOp(session : pQSession; path : pCHar; buf : POINTER; len : ULONG) : LONGINT;
    400. 

  400. BEGIN
    401. 

  401.   ASM
    402. 

  402.         MOVE.L  A6,-(A7)
    403. 

  403.         MOVEA.L session,A0
    404. 

  404.         MOVEA.L path,A1
    405. 

  405.         MOVE.L  buf,D0
    406. 

  406.         MOVE.L  len,D1
    407. 

  407.         MOVEA.L AMarqueeBase,A6
    408. 

  408.         JSR     -072(A6)
    409. 

  409.         MOVEA.L (A7)+,A6
    410. 

  410.         MOVE.L  D0,@RESULT
    411. 

  411.   END;
    412. 

  412. END;
    413. 

  413. 

  414. FUNCTION QClearSubscriptionsOp(session : pQSession; which : LONGINT) : LONGINT;
    415. 

  415. BEGIN
    416. 

  416.   ASM
    417. 

  417.         MOVE.L  A6,-(A7)
    418. 

  418.         MOVEA.L session,A0
    419. 

  419.         MOVE.L  which,D0
    420. 

  420.         MOVEA.L AMarqueeBase,A6
    421. 

  421.         JSR     -078(A6)
    422. 

  422.         MOVEA.L (A7)+,A6
    423. 

  423.         MOVE.L  D0,@RESULT
    424. 

  424.   END;
    425. 

  425. END;
    426. 

  426. 

  427. FUNCTION QPingOp(session : pQSession) : LONGINT;
    428. 

  428. BEGIN
    429. 

  429.   ASM
    430. 

  430.         MOVE.L  A6,-(A7)
    431. 

  431.         MOVEA.L session,A0
    432. 

  432.         MOVEA.L AMarqueeBase,A6
    433. 

  433.         JSR     -084(A6)
    434. 

  434.         MOVEA.L (A7)+,A6
    435. 

  435.         MOVE.L  D0,@RESULT
    436. 

  436.   END;
    437. 

  437. END;
    438. 

  438. 

  439. FUNCTION QInfoOp(session : pQSession) : LONGINT;
    440. 

  440. BEGIN
    441. 

  441.   ASM
    442. 

  442.         MOVE.L  A6,-(A7)
    443. 

  443.         MOVEA.L session,A0
    444. 

  444.         MOVEA.L AMarqueeBase,A6
    445. 

  445.         JSR     -090(A6)
    446. 

  446.         MOVEA.L (A7)+,A6
    447. 

  447.         MOVE.L  D0,@RESULT
    448. 

  448.   END;
    449. 

  449. END;
    450. 

  450. 

  451. FUNCTION QSetAccessOp(session : pQSession; hosts : pCHar) : LONGINT;
    452. 

  452. BEGIN
    453. 

  453.   ASM
    454. 

  454.         MOVE.L  A6,-(A7)
    455. 

  455.         MOVEA.L session,A0
    456. 

  456.         MOVEA.L hosts,A1
    457. 

  457.         MOVEA.L AMarqueeBase,A6
    458. 

  458.         JSR     -096(A6)
    459. 

  459.         MOVEA.L (A7)+,A6
    460. 

  460.         MOVE.L  D0,@RESULT
    461. 

  461.   END;
    462. 

  462. END;
    463. 

  463. 

  464. PROCEDURE FreeQMessage(session : pQSession; qmsg : pQMessage);
    465. 

  465. BEGIN
    466. 

  466.   ASM
    467. 

  467.         MOVE.L  A6,-(A7)
    468. 

  468.         MOVEA.L session,A0
    469. 

  469.         MOVEA.L qmsg,A1
    470. 

  470.         MOVEA.L AMarqueeBase,A6
    471. 

  471.         JSR     -102(A6)
    472. 

  472.         MOVEA.L (A7)+,A6
    473. 

  473.   END;
    474. 

  474. END;
    475. 

  475. 

  476. FUNCTION QGo(session : pQSession; sync : ULONG) : LONGINT;
    477. 

  477. BEGIN
    478. 

  478.   ASM
    479. 

  479.         MOVE.L  A6,-(A7)
    480. 

  480.         MOVEA.L session,A0
    481. 

  481.         MOVE.L  sync,D0
    482. 

  482.         MOVEA.L AMarqueeBase,A6
    483. 

  483.         JSR     -108(A6)
    484. 

  484.         MOVEA.L (A7)+,A6
    485. 

  485.         MOVE.L  D0,@RESULT
    486. 

  486.   END;
    487. 

  487. END;
    488. 

  488. 

  489. FUNCTION QStreamOp(session : pQSession; path : pCHar; buf : POINTER; len : ULONG) : LONGINT;
    490. 

  490. BEGIN
    491. 

  491.   ASM
    492. 

  492.         MOVE.L  A6,-(A7)
    493. 

  493.         MOVEA.L session,A0
    494. 

  494.         MOVEA.L path,A1
    495. 

  495.         MOVE.L  buf,D0
    496. 

  496.         MOVE.L  len,D1
    497. 

  497.         MOVEA.L AMarqueeBase,A6
    498. 

  498.         JSR     -120(A6)
    499. 

  499.         MOVEA.L (A7)+,A6
    500. 

  500.         MOVE.L  D0,@RESULT
    501. 

  501.   END;
    502. 

  502. END;
    503. 

  503. 

  504. FUNCTION QSetMessageAccessOp(session : pQSession; access : pCHar; maxbytes : LONGINT) : LONGINT;
    505. 

  505. BEGIN
    506. 

  506.   ASM
    507. 

  507.         MOVE.L  A6,-(A7)
    508. 

  508.         MOVEA.L session,A0
    509. 

  509.         MOVEA.L access,A1
    510. 

  510.         MOVE.L  maxbytes,D0
    511. 

  511.         MOVEA.L AMarqueeBase,A6
    512. 

  512.         JSR     -132(A6)
    513. 

  513.         MOVEA.L (A7)+,A6
    514. 

  514.         MOVE.L  D0,@RESULT
    515. 

  515.   END;
    516. 

  516. END;
    517. 

  517. 

  518. FUNCTION QMessageOp(session : pQSession; hosts : pCHar; buffer : POINTER; len : ULONG) : LONGINT;
    519. 

  519. BEGIN
    520. 

  520.   ASM
    521. 

  521.         MOVE.L  A6,-(A7)
    522. 

  522.         MOVEA.L session,A0
    523. 

  523.         MOVEA.L hosts,A1
    524. 

  524.         MOVE.L  buffer,D0
    525. 

  525.         MOVE.L  len,D1
    526. 

  526.         MOVEA.L AMarqueeBase,A6
    527. 

  527.         JSR     -138(A6)
    528. 

  528.         MOVEA.L (A7)+,A6
    529. 

  529.         MOVE.L  D0,@RESULT
    530. 

  530.   END;
    531. 

  531. END;
    532. 

  532. 

  533. FUNCTION QNumQueuedPackets(session : pQSession) : ULONG;
    534. 

  534. BEGIN
    535. 

  535.   ASM
    536. 

  536.         MOVE.L  A6,-(A7)
    537. 

  537.         MOVEA.L session,A0
    538. 

  538.         MOVEA.L AMarqueeBase,A6
    539. 

  539.         JSR     -150(A6)
    540. 

  540.         MOVEA.L (A7)+,A6
    541. 

  541.         MOVE.L  D0,@RESULT
    542. 

  542.   END;
    543. 

  543. END;
    544. 

  544. 

  545. FUNCTION QNumQueuedBytes(session : pQSession) : ULONG;
    546. 

  546. BEGIN
    547. 

  547.   ASM
    548. 

  548.         MOVE.L  A6,-(A7)
    549. 

  549.         MOVEA.L session,A0
    550. 

  550.         MOVEA.L AMarqueeBase,A6
    551. 

  551.         JSR     -156(A6)
    552. 

  552.         MOVEA.L (A7)+,A6
    553. 

  553.         MOVE.L  D0,@RESULT
    554. 

  554.   END;
    555. 

  555. END;
    556. 

  556. 

  557. FUNCTION QErrorName(session : LONGINT) : pCHar;
    558. 

  558. BEGIN
    559. 

  559.   ASM
    560. 

  560.         MOVE.L  A6,-(A7)
    561. 

  561.         MOVE.L  session,D0
    562. 

  562.         MOVEA.L AMarqueeBase,A6
    563. 

  563.         JSR     -162(A6)
    564. 

  564.         MOVEA.L (A7)+,A6
    565. 

  565.         MOVE.L  D0,@RESULT
    566. 

  566.   END;
    567. 

  567. END;
    568. 

  568. 

  569. FUNCTION QRequestPrivilegesOp(session : pQSession; privBits : ULONG) : LONGINT;
    570. 

  570. BEGIN
    571. 

  571.   ASM
    572. 

  572.         MOVE.L  A6,-(A7)
    573. 

  573.         MOVEA.L session,A0
    574. 

  574.         MOVE.L  privBits,D0
    575. 

  575.         MOVEA.L AMarqueeBase,A6
    576. 

  576.         JSR     -168(A6)
    577. 

  577.         MOVEA.L (A7)+,A6
    578. 

  578.         MOVE.L  D0,@RESULT
    579. 

  579.   END;
    580. 

  580. END;
    581. 

  581. 

  582. FUNCTION QReleasePrivilegesOp(session : pQSession; privBits : ULONG) : LONGINT;
    583. 

  583. BEGIN
    584. 

  584.   ASM
    585. 

  585.         MOVE.L  A6,-(A7)
    586. 

  586.         MOVEA.L session,A0
    587. 

  587.         MOVE.L  privBits,D0
    588. 

  588.         MOVEA.L AMarqueeBase,A6
    589. 

  589.         JSR     -174(A6)
    590. 

  590.         MOVEA.L (A7)+,A6
    591. 

  591.         MOVE.L  D0,@RESULT
    592. 

  592.   END;
    593. 

  593. END;
    594. 

  594. 

  595. FUNCTION QKillClientsOp(session : pQSession; hosts : pCHar) : LONGINT;
    596. 

  596. BEGIN
    597. 

  597.   ASM
    598. 

  598.         MOVE.L  A6,-(A7)
    599. 

  599.         MOVEA.L session,A0
    600. 

  600.         MOVEA.L hosts,A1
    601. 

  601.         MOVEA.L AMarqueeBase,A6
    602. 

  602.         JSR     -180(A6)
    603. 

  603.         MOVEA.L (A7)+,A6
    604. 

  604.         MOVE.L  D0,@RESULT
    605. 

  605.   END;
    606. 

  606. END;
    607. 

  607. 

  608. FUNCTION QSetParameterOp(session : pQSession; paramName : pCHar; newValue : pCHar) : LONGINT;
    609. 

  609. BEGIN
    610. 

  610.   ASM
    611. 

  611.         MOVE.L  A6,-(A7)
    612. 

  612.         MOVEA.L session,A0
    613. 

  613.         MOVEA.L paramName,A1
    614. 

  614.         MOVE.L  newValue,D0
    615. 

  615.         MOVEA.L AMarqueeBase,A6
    616. 

  616.         JSR     -186(A6)
    617. 

  617.         MOVEA.L (A7)+,A6
    618. 

  618.         MOVE.L  D0,@RESULT
    619. 

  619.   END;
    620. 

  620. END;
    621. 

  621. 

  622. FUNCTION QGetParameterOp(session : pQSession; paramName : pCHar) : LONGINT;
    623. 

  623. BEGIN
    624. 

  624.   ASM
    625. 

  625.         MOVE.L  A6,-(A7)
    626. 

  626.         MOVEA.L session,A0
    627. 

  627.         MOVEA.L paramName,A1
    628. 

  628.         MOVEA.L AMarqueeBase,A6
    629. 

  629.         JSR     -192(A6)
    630. 

  630.         MOVEA.L (A7)+,A6
    631. 

  631.         MOVE.L  D0,@RESULT
    632. 

  632.   END;
    633. 

  633. END;
    634. 

  634. 

  635. FUNCTION QSysMessageOp(session : pQSession; hosts : pCHar; message : pCHar) : LONGINT;
    636. 

  636. BEGIN
    637. 

  637.   ASM
    638. 

  638.         MOVE.L  A6,-(A7)
    639. 

  639.         MOVEA.L session,A0
    640. 

  640.         MOVEA.L hosts,A1
    641. 

  641.         MOVE.L  message,D0
    642. 

  642.         MOVEA.L AMarqueeBase,A6
    643. 

  643.         JSR     -198(A6)
    644. 

  644.         MOVEA.L (A7)+,A6
    645. 

  645.         MOVE.L  D0,@RESULT
    646. 

  646.   END;
    647. 

  647. END;
    648. 

  648. 

  649. FUNCTION QGetAndSubscribeOp(session : pQSession; path : pCHar; maxBytes : LONGINT) : LONGINT;
    650. 

  650. BEGIN
    651. 

  651.   ASM
    652. 

  652.         MOVE.L  A6,-(A7)
    653. 

  653.         MOVEA.L session,A0
    654. 

  654.         MOVEA.L path,A1
    655. 

  655.         MOVE.L  maxBytes,D0
    656. 

  656.         MOVEA.L AMarqueeBase,A6
    657. 

  657.         JSR     -210(A6)
    658. 

  658.         MOVEA.L (A7)+,A6
    659. 

  659.         MOVE.L  D0,@RESULT
    660. 

  660.   END;
    661. 

  661. END;
    662. 

  662. 

  663. FUNCTION QDetachSession(session : pQSession; flags : ULONG) : BOOLEAN;
    664. 

  664. BEGIN
    665. 

  665.   ASM
    666. 

  666.         MOVE.L  A6,-(A7)
    667. 

  667.         MOVEA.L session,A0
    668. 

  668.         MOVE.L  flags,D0
    669. 

  669.         MOVEA.L AMarqueeBase,A6
    670. 

  670.         JSR     -216(A6)
    671. 

  671.         MOVEA.L (A7)+,A6
    672. 

  672.         TST.W   D0
    673. 

  673.         BEQ.B   @end
    674. 

  674.         MOVEQ   #1,D0
    675. 

  675.   @end: MOVE.B  D0,@RESULT
    676. 

  676.   END;
    677. 

  677. END;
    678. 

  678. 

  679. FUNCTION QReattachSession(session : pQSession; flags : ULONG) : BOOLEAN;
    680. 

  680. BEGIN
    681. 

  681.   ASM
    682. 

  682.         MOVE.L  A6,-(A7)
    683. 

  683.         MOVEA.L session,A0
    684. 

  684.         MOVE.L  flags,D0
    685. 

  685.         MOVEA.L AMarqueeBase,A6
    686. 

  686.         JSR     -222(A6)
    687. 

  687.         MOVEA.L (A7)+,A6
    688. 

  688.         TST.W   D0
    689. 

  689.         BEQ.B   @end
    690. 

  690.         MOVEQ   #1,D0
    691. 

  691.   @end: MOVE.B  D0,@RESULT
    692. 

  692.   END;
    693. 

  693. END;
    694. 

  694. 

  695. FUNCTION QNewSocketSession(host : pCHar; port : LONGINT; tags : pTagItem) : pQSession;
    696. 

  696. BEGIN
    697. 

  697.   ASM
    698. 

  698.         MOVE.L  A6,-(A7)
    699. 

  699.         MOVEA.L host,A0
    700. 

  700.         MOVE.L  port,D0
    701. 

  701.         MOVEA.L tags,A1
    702. 

  702.         MOVEA.L AMarqueeBase,A6
    703. 

  703.         JSR     -228(A6)
    704. 

  704.         MOVEA.L (A7)+,A6
    705. 

  705.         MOVE.L  D0,@RESULT
    706. 

  706.   END;
    707. 

  707. END;
    708. 

  708. 

  709. FUNCTION QSendRawOp(session : pQSession; buf : POINTER; len : ULONG) : LONGINT;
    710. 

  710. BEGIN
    711. 

  711.   ASM
    712. 

  712.         MOVE.L  A6,-(A7)
    713. 

  713.         MOVEA.L session,A0
    714. 

  714.         MOVEA.L buf,A1
    715. 

  715.         MOVE.L  len,D0
    716. 

  716.         MOVEA.L AMarqueeBase,A6
    717. 

  717.         JSR     -234(A6)
    718. 

  718.         MOVEA.L (A7)+,A6
    719. 

  719.         MOVE.L  D0,@RESULT
    720. 

  720.   END;
    721. 

  721. END;
    722. 

  722. 

  723. FUNCTION QNewSocketSessionAsync(host : pCHar; port : LONGINT; tags : pTagItem) : pQSession;
    724. 

  724. BEGIN
    725. 

  725.   ASM
    726. 

  726.         MOVE.L  A6,-(A7)
    727. 

  727.         MOVEA.L host,A0
    728. 

  728.         MOVE.L  port,D0
    729. 

  729.         MOVEA.L tags,A1
    730. 

  730.         MOVEA.L AMarqueeBase,A6
    731. 

  731.         JSR     -240(A6)
    732. 

  732.         MOVEA.L (A7)+,A6
    733. 

  733.         MOVE.L  D0,@RESULT
    734. 

  734.   END;
    735. 

  735. END;
    736. 

  736. 

  737. FUNCTION QNewSocketServerSession(port : pLONGINT; tags : pTagItem) : pQSession;
    738. 

  738. BEGIN
    739. 

  739.   ASM
    740. 

  740.         MOVE.L  A6,-(A7)
    741. 

  741.         MOVEA.L port,A0
    742. 

  742.         MOVEA.L tags,A1
    743. 

  743.         MOVEA.L AMarqueeBase,A6
    744. 

  744.         JSR     -246(A6)
    745. 

  745.         MOVEA.L (A7)+,A6
    746. 

  746.         MOVE.L  D0,@RESULT
    747. 

  747.   END;
    748. 

  748. END;
    749. 

  749. 

  750. FUNCTION QSetKeyAccessOp(session : pQSession; path : pCHar; hosts : pCHar) : LONGINT;
    751. 

  751. BEGIN
    752. 

  752.   ASM
    753. 

  753.         MOVE.L  A6,-(A7)
    754. 

  754.         MOVEA.L session,A0
    755. 

  755.         MOVEA.L path,A1
    756. 

  756.         MOVE.L  hosts,D0
    757. 

  757.         MOVEA.L AMarqueeBase,A6
    758. 

  758.         JSR     -252(A6)
    759. 

  759.         MOVEA.L (A7)+,A6
    760. 

  760.         MOVE.L  D0,@RESULT
    761. 

  761.   END;
    762. 

  762. END;
    763. 

  763. 

  764. FUNCTION QGetHostName(session : pQSession) : pCHar;
    765. 

  765. BEGIN
    766. 

  766.   ASM
    767. 

  767.         MOVE.L  A6,-(A7)
    768. 

  768.         MOVEA.L session,A0
    769. 

  769.         MOVEA.L AMarqueeBase,A6
    770. 

  770.         JSR     -258(A6)
    771. 

  771.         MOVEA.L (A7)+,A6
    772. 

  772.         MOVE.L  D0,@RESULT
    773. 

  773.   END;
    774. 

  774. END;
    775. 

  775. 

  776. FUNCTION QGetProgName(session : pQSession) : pCHar;
    777. 

  777. BEGIN
    778. 

  778.   ASM
    779. 

  779.         MOVE.L  A6,-(A7)
    780. 

  780.         MOVEA.L session,A0
    781. 

  781.         MOVEA.L AMarqueeBase,A6
    782. 

  782.         JSR     -264(A6)
    783. 

  783.         MOVEA.L (A7)+,A6
    784. 

  784.         MOVE.L  D0,@RESULT
    785. 

  785.   END;
    786. 

  786. END;
    787. 

  787. 

  788. PROCEDURE QSetMaxRawBufSize(session : pQSession; maxBufSize : ULONG);
    789. 

  789. BEGIN
    790. 

  790.   ASM
    791. 

  791.         MOVE.L  A6,-(A7)
    792. 

  792.         MOVEA.L session,A0
    793. 

  793.         MOVE.L  maxBufSize,D0
    794. 

  794.         MOVEA.L AMarqueeBase,A6
    795. 

  795.         JSR     -270(A6)
    796. 

  796.         MOVEA.L (A7)+,A6
    797. 

  797.   END;
    798. 

  798. END;
    799. 

  799. 

  800. FUNCTION QNewSession(host : pCHar; port : LONGINT; name : pCHar; taglist : pTagItem) : pQSession;
    801. 

  801. BEGIN
    802. 

  802.   ASM
    803. 

  803.         MOVE.L  A6,-(A7)
    804. 

  804.         MOVEA.L host,A0
    805. 

  805.         MOVE.L  port,D0
    806. 

  806.         MOVEA.L name,A1
    807. 

  807.         MOVE.L  taglist,D1
    808. 

  808.         MOVEA.L AMarqueeBase,A6
    809. 

  809.         JSR     -276(A6)
    810. 

  810.         MOVEA.L (A7)+,A6
    811. 

  811.         MOVE.L  D0,@RESULT
    812. 

  812.   END;
    813. 

  813. END;
    814. 

  814. 

  815. FUNCTION QNewSessionAsync(host : pCHar; port : LONGINT; name : pCHar; taglist : pTagItem) : pQSession;
    816. 

  816. BEGIN
    817. 

  817.   ASM
    818. 

  818.         MOVE.L  A6,-(A7)
    819. 

  819.         MOVEA.L host,A0
    820. 

  820.         MOVE.L  port,D0
    821. 

  821.         MOVEA.L name,A1
    822. 

  822.         MOVE.L  taglist,D1
    823. 

  823.         MOVEA.L AMarqueeBase,A6
    824. 

  824.         JSR     -282(A6)
    825. 

  825.         MOVEA.L (A7)+,A6
    826. 

  826.         MOVE.L  D0,@RESULT
    827. 

  827.   END;
    828. 

  828. END;
    829. 

  829. 

  830. FUNCTION QNewHostSession(hostnames : pCHar; port : pLONGINT; names : pCHar; taglist : pTagItem) : pQSession;
    831. 

  831. BEGIN
    832. 

  832.   ASM
    833. 

  833.         MOVE.L  A6,-(A7)
    834. 

  834.         MOVEA.L hostnames,A0
    835. 

  835.         MOVEA.L port,A1
    836. 

  836.         MOVE.L  names,D0
    837. 

  837.         MOVE.L  taglist,D1
    838. 

  838.         MOVEA.L AMarqueeBase,A6
    839. 

  839.         JSR     -288(A6)
    840. 

  840.         MOVEA.L (A7)+,A6
    841. 

  841.         MOVE.L  D0,@RESULT
    842. 

  842.   END;
    843. 

  843. END;
    844. 

  844. 

  845. FUNCTION QNewServerSession(hostNames : pCHar; progNames : pCHar; taglist : pTagItem) : pQSession;
    846. 

  846. BEGIN
    847. 

  847.   ASM
    848. 

  848.         MOVE.L  A6,-(A7)
    849. 

  849.         MOVEA.L hostNames,A0
    850. 

  850.         MOVEA.L progNames,A1
    851. 

  851.         MOVE.L  taglist,D0
    852. 

  852.         MOVEA.L AMarqueeBase,A6
    853. 

  853.         JSR     -294(A6)
    854. 

  854.         MOVEA.L (A7)+,A6
    855. 

  855.         MOVE.L  D0,@RESULT
    856. 

  856.   END;
    857. 

  857. END;
    858. 

  858. 

  859. FUNCTION QCreateSharedMessagePort : pQSharedMessagePort;
    860. 

  860. BEGIN
    861. 

  861.   ASM
    862. 

  862.         MOVE.L  A6,-(A7)
    863. 

  863.         MOVEA.L AMarqueeBase,A6
    864. 

  864.         JSR     -300(A6)
    865. 

  865.         MOVEA.L (A7)+,A6
    866. 

  866.         MOVE.L  D0,@RESULT
    867. 

  867.   END;
    868. 

  868. END;
    869. 

  869. 

  870. PROCEDURE QDeleteSharedMessagePort(mp : pQSharedMessagePort);
    871. 

  871. BEGIN
    872. 

  872.   ASM
    873. 

  873.         MOVE.L  A6,-(A7)
    874. 

  874.         MOVEA.L mp,A0
    875. 

  875.         MOVEA.L AMarqueeBase,A6
    876. 

  876.         JSR     -306(A6)
    877. 

  877.         MOVEA.L (A7)+,A6
    878. 

  878.   END;
    879. 

  879. END;
    880. 

  880. 

  881. 

  882. FUNCTION QGetLocalIP(session : pQSession) : pCHAR;
    883. 

  883. BEGIN
    884. 

  884.   ASM
    885. 

  885.         MOVE.L  A6,-(A7)
    886. 

  886.         MOVEA.L session,A0
    887. 

  887.         MOVEA.L AMarqueeBase,A6
    888. 

  888.         JSR     -312(A6)
    889. 

  889.         MOVEA.L (A7)+,A6
    890. 

  890.         MOVE.L  D0,@RESULT
    891. 

  891.   END;
    892. 

  892. END;
    893. 

  893. 

  894. 

  895. FUNCTION QDebugOp(session : pQSession; string_ : string) : LONGINT;
    896. 

  896. begin
    897. 

  897.     QDebugOp := QDebugOp(session,pas2c(string_));
    898. 

  898. end;
    899. 

  899. 

  900. FUNCTION QGetOp(session : pQSession; path : string; maxBytes : LONGINT) : LONGINT;
    901. 

  901. begin
    902. 

  902.     QGetOp := QGetOp(session,pas2c(path),maxBytes);
    903. 

  903. end;
    904. 

  904. 

  905. FUNCTION QDeleteOp(session : pQSession; path : string) : LONGINT;
    906. 

  906. begin
    907. 

  907.     QDeleteOp := QDeleteOp(session,pas2c(path));
    908. 

  908. end;
    909. 

  909. 

  910. FUNCTION QRenameOp(session : pQSession; path : string; label_ : string) : LONGINT;
    911. 

  911. begin
    912. 

  912.     QRenameOp := QRenameOp(session,pas2c(path),pas2c(label_));
    913. 

  913. end;
    914. 

  914. 

  915. FUNCTION QSubscribeOp(session : pQSession; path : string; maxBytes : LONGINT) : LONGINT;
    916. 

  916. begin
    917. 

  917.     QSubscribeOp := QSubscribeOp(session,pas2c(path),maxBytes);
    918. 

  918. end;
    919. 

  919. 

  920. FUNCTION QSetOp(session : pQSession; path : string; buf : POINTER; len : ULONG) : LONGINT;
    921. 

  921. begin
    922. 

  922.     QSetOp := QSetOp(session,pas2c(path),buf,len);
    923. 

  923. end;
    924. 

  924. 

  925. FUNCTION QSetAccessOp(session : pQSession; hosts : string) : LONGINT;
    926. 

  926. begin
    927. 

  927.     QSetAccessOp := QSetAccessOp(session,pas2c(hosts));
    928. 

  928. end;
    929. 

  929. 

  930. FUNCTION QStreamOp(session : pQSession; path : string; buf : POINTER; len : ULONG) : LONGINT;
    931. 

  931. begin
    932. 

  932.     QStreamOp := QStreamOp(session,pas2c(path),buf,len);
    933. 

  933. end;
    934. 

  934. 

  935. FUNCTION QSetMessageAccessOp(session : pQSession; access : string; maxbytes : LONGINT) : LONGINT;
    936. 

  936. begin
    937. 

  937.     QSetMessageAccessOp := QSetMessageAccessOp(session,pas2c(access),maxBytes);
    938. 

  938. end;
    939. 

  939. 

  940. FUNCTION QMessageOp(session : pQSession; hosts : string; buffer : POINTER; len : ULONG) : LONGINT;
    941. 

  941. begin
    942. 

  942.     QMessageOp := QMessageOp(session,pas2c(hosts),buffer,len);
    943. 

  943. end;
    944. 

  944. 

  945. FUNCTION QKillClientsOp(session : pQSession; hosts : string) : LONGINT;
    946. 

  946. begin
    947. 

  947.     QKillClientsOp := QKillClientsOp(session,pas2c(hosts));
    948. 

  948. end;
    949. 

  949. 

  950. FUNCTION QSetParameterOp(session : pQSession; paramName : string; newValue : string) : LONGINT;
    951. 

  951. begin
    952. 

  952.     QSetParameterOp := QSetParameterOp(session,pas2c(paramName),pas2c(newValue));
    953. 

  953. end;
    954. 

  954. 

  955. FUNCTION QGetParameterOp(session : pQSession; paramName : string) : LONGINT;
    956. 

  956. begin
    957. 

  957.     QGetParameterOp := QGetParameterOp(session,pas2c(paramName));
    958. 

  958. end;
    959. 

  959. 

  960. FUNCTION QSysMessageOp(session : pQSession; hosts : string; message : string) : LONGINT;
    961. 

  961. begin
    962. 

  962.     QSysMessageOp := QSysMessageOp(session,pas2c(hosts),pas2c(message));
    963. 

  963. end;
    964. 

  964. 

  965. FUNCTION QGetAndSubscribeOp(session : pQSession; path : string; maxBytes : LONGINT) : LONGINT;
    966. 

  966. begin
    967. 

  967.     QGetAndSubscribeOp := QGetAndSubscribeOp(session,pas2c(path),maxBytes);
    968. 

  968. end;
    969. 

  969. 

  970. FUNCTION QNewSocketSession(host : string; port : LONGINT; tags : pTagItem) : pQSession;
    971. 

  971. begin
    972. 

  972.     QNewSocketSession := QNewSocketSession(pas2c(host),port,tags);
    973. 

  973. end;
    974. 

  974. 

  975. FUNCTION QNewSocketSessionAsync(host : string; port : LONGINT; tags : pTagItem) : pQSession;
    976. 

  976. begin
    977. 

  977.     QNewSocketSessionAsync := QNewSocketSessionAsync(pas2c(host),port,tags);
    978. 

  978. end;
    979. 

  979. 

  980. FUNCTION QSetKeyAccessOp(session : pQSession; path : string; hosts : string) : LONGINT;
    981. 

  981. begin
    982. 

  982.     QSetKeyAccessOp := QSetKeyAccessOp(session,pas2c(path),pas2c(hosts));
    983. 

  983. end;
    984. 

  984. 

  985. FUNCTION QNewSession(host : string; port : LONGINT; name : string; taglist : pTagItem) : pQSession;
    986. 

  986. begin
    987. 

  987.     QNewSession := QNewSession(pas2c(host),port,pas2c(name),taglist);
    988. 

  988. end;
    989. 

  989. 

  990. FUNCTION QNewSessionAsync(host : string; port : LONGINT; name : string; taglist : pTagItem) : pQSession;
    991. 

  991. begin
    992. 

  992.     QNewSessionAsync := QNewSessionAsync(pas2c(host),port,pas2c(name),taglist);
    993. 

  993. end;
    994. 

  994. 

  995. FUNCTION QNewHostSession(hostnames : string; port : pLONGINT; names : string; taglist : pTagItem) : pQSession;
    996. 

  996. begin
    997. 

  997.     QNewHostSession := QNewHostSession(pas2c(hostnames),port,pas2c(names),taglist);
    998. 

  998. end;
    999. 

  999. 

  1000. FUNCTION QNewServerSession(hostNames : string; progNames : string; taglist : pTagItem) : pQSession;
    1001. 

  1001. begin
    1002. 

  1002.     QNewServerSession := QNewServerSession(pas2c(hostnames),pas2c(prognames),taglist);
    1003. 

  1003. end;
    1004. 

  1004. 

  1005. FUNCTION QNewSocketSessiontags(host : pCHar; port : LONGINT; const argv : Array Of Const) : pQSession;
    1006. 

  1006. begin
    1007. 

  1007.     QNewSocketSessiontags := QNewSocketSession(host,port,readintags(argv));
    1008. 

  1008. end;
    1009. 

  1009. 

  1010. FUNCTION QNewSocketSessionAsyncTags(host : pCHar; port : LONGINT; const argv : Array Of Const) : pQSession;
    1011. 

  1011. begin
    1012. 

  1012.     QNewSocketSessionAsyncTags := QNewSocketSessionAsync(host,port,readintags(argv));
    1013. 

  1013. end;
    1014. 

  1014. 

  1015. FUNCTION QNewSocketServerSessionTags( port : pLONGINT; const argv : Array Of Const) : pQSession;
    1016. 

  1016. begin
    1017. 

  1017.     QNewSocketServerSessionTags := QNewSocketServerSession(port,readintags(argv));
    1018. 

  1018. end;
    1019. 

  1019. 

  1020. FUNCTION QNewSessionTags(host : pCHar; port : LONGINT; name : pCHar; const argv : Array Of Const) : pQSession;
    1021. 

  1021. begin
    1022. 

  1022.     QNewSessionTags := QNewSession(host,port,name,readintags(argv));
    1023. 

  1023. end;
    1024. 

  1024. 

  1025. FUNCTION QNewSessionAsyncTags(host : pCHar; port : LONGINT; name : pCHar; const argv : Array Of Const) : pQSession;
    1026. 

  1026. begin
    1027. 

  1027.     QNewSessionAsyncTags := QNewSessionAsync(host,port,name,readintags(argv));
    1028. 

  1028. end;
    1029. 

  1029. 

  1030. FUNCTION QNewHostSessionTags(hostnames : pCHar; port : pLONGINT; names : pCHar; const argv : Array Of Const) : pQSession;
    1031. 

  1031. begin
    1032. 

  1032.     QNewHostSessionTags := QNewHostSession(hostnames,port,names,readintags(argv));
    1033. 

  1033. end;
    1034. 

  1034. 

  1035. FUNCTION QNewServerSessionTags(hostNames : pCHar; progNames : pCHar; const argv : Array Of Const) : pQSession;
    1036. 

  1036. begin
    1037. 

  1037.     QNewServerSessionTags := QNewServerSession(hostnames,prognames,readintags(argv));
    1038. 

  1038. end;
    1039. 

  1039. 

  1040. 

  1041. FUNCTION QNewSocketSessionTags(host : string; port : LONGINT; const argv : Array Of Const) : pQSession;
    1042. 

  1042. begin
    1043. 

  1043.     QNewSocketSessionTags := QNewSocketSession(host,port,readintags(argv));
    1044. 

  1044. end;
    1045. 

  1045. 

  1046. FUNCTION QNewSocketSessionAsyncTags(host : string; port : LONGINT; const argv : Array Of Const) : pQSession;
    1047. 

  1047. begin
    1048. 

  1048.     QNewSocketSessionAsyncTags := QNewSocketSessionAsync(host,port,readintags(argv));
    1049. 

  1049. end;
    1050. 

  1050. 

  1051. FUNCTION QNewSessionTags(host : string; port : LONGINT; name : string; const argv : Array Of Const) : pQSession;
    1052. 

  1052. begin
    1053. 

  1053.     QNewSessionTags := QNewSession(host,port,name,readintags(argv));
    1054. 

  1054. end;
    1055. 

  1055. 

  1056. FUNCTION QNewSessionAsyncTags(host : string; port : LONGINT; name : string; const argv : Array Of Const) : pQSession;
    1057. 

  1057. begin
    1058. 

  1058.     QNewSessionAsyncTags := QNewSessionAsync(host,port,name,readintags(argv));
    1059. 

  1059. end;
    1060. 

  1060. 

  1061. FUNCTION QNewHostSessionTags(hostnames : string; port : pLONGINT; names : string; const argv : Array Of Const) : pQSession;
    1062. 

  1062. begin
    1063. 

  1063.     QNewHostSessionTags := QNewHostSession(hostnames,port,names,readintags(argv));
    1064. 

  1064. end;
    1065. 

  1065. 

  1066. FUNCTION QNewServerSessionTags(hostNames : string; progNames : string; const argv : Array Of Const) : pQSession;
    1067. 

  1067. begin
    1068. 

  1068.     QNewServerSessionTags := QNewServerSession(hostnames,prognames,readintags(argv));
    1069. 

  1069. end;
    1070. 

  1070. 

  1071. const
    1072. 

  1072.     { Change VERSION and LIBVERSION to proper values }
    1073. 

  1073. 

  1074.     VERSION : string[2] = '0';
    1075. 

  1075.     LIBVERSION : longword = 0;
    1076. 

  1076. 

  1077. {$ifdef use_init_openlib}
    1078. 

  1078.   {$Info Compiling initopening of amarquee.library}
    1079. 

  1079.   {$Info don't forget to use InitAMARQUEELibrary in the beginning of your program}
    1080. 

    1081. 

  1081. var
    1082. 

  1082.     amarquee_exit : Pointer;
    1083. 

  1083. 

  1084. procedure CloseamarqueeLibrary;
    1085. 

  1085. begin
    1086. 

  1086.     ExitProc := amarquee_exit;
    1087. 

  1087.     if AMarqueeBase <> nil then begin
    1088. 

  1088.         CloseLibrary(AMarqueeBase);
    1089. 

  1089.         AMarqueeBase := nil;
    1090. 

  1090.     end;
    1091. 

  1091. end;
    1092. 

  1092. 

  1093. procedure InitAMARQUEELibrary;
    1094. 

  1094. begin
    1095. 

  1095.     AMarqueeBase := nil;
    1096. 

  1096.     AMarqueeBase := OpenLibrary(AMARQUEENAME,LIBVERSION);
    1097. 

  1097.     if AMarqueeBase <> nil then begin
    1098. 

  1098.         amarquee_exit := ExitProc;
    1099. 

  1099.         ExitProc := @CloseamarqueeLibrary;
    1100. 

  1100.     end else begin
    1101. 

  1101.         MessageBox('FPC Pascal Error',
    1102. 

  1102.         'Can''t open amarquee.library version ' + VERSION + #10 +
    1103. 

  1103.         'Deallocating resources and closing down',
    1104. 

  1104.         'Oops');
    1105. 

  1105.         halt(20);
    1106. 

  1106.     end;
    1107. 

  1107. end;
    1108. 

  1108. 

  1109. begin
    1110. 

  1110.     AMARQUEEIsCompiledHow := 2;
    1111. 

  1111. {$endif use_init_openlib}
    1112. 

  1112. 

  1113. {$ifdef use_auto_openlib}
    1114. 

  1114.   {$Info Compiling autoopening of amarquee.library}
    1115. 

  1115. 

  1116. var
    1117. 

  1117.     amarquee_exit : Pointer;
    1118. 

  1118. 

  1119. procedure CloseamarqueeLibrary;
    1120. 

  1120. begin
    1121. 

  1121.     ExitProc := amarquee_exit;
    1122. 

  1122.     if AMarqueeBase <> nil then begin
    1123. 

  1123.         CloseLibrary(AMarqueeBase);
    1124. 

  1124.         AMarqueeBase := nil;
    1125. 

  1125.     end;
    1126. 

  1126. end;
    1127. 

  1127. 

  1128. begin
    1129. 

  1129.     AMarqueeBase := nil;
    1130. 

  1130.     AMarqueeBase := OpenLibrary(AMARQUEENAME,LIBVERSION);
    1131. 

  1131.     if AMarqueeBase <> nil then begin
    1132. 

  1132.         amarquee_exit := ExitProc;
    1133. 

  1133.         ExitProc := @CloseamarqueeLibrary;
    1134. 

  1134.         AMARQUEEIsCompiledHow := 1;
    1135. 

  1135.     end else begin
    1136. 

  1136.         MessageBox('FPC Pascal Error',
    1137. 

  1137.         'Can''t open amarquee.library version ' + VERSION + #10 +
    1138. 

  1138.         'Deallocating resources and closing down',
    1139. 

  1139.         'Oops');
    1140. 

  1140.         halt(20);
    1141. 

  1141.     end;
    1142. 

  1142. 

  1143. {$endif use_auto_openlib}
    1144. 

  1144. 

  1145. {$ifdef dont_use_openlib}
    1146. 

  1146. begin
    1147. 

  1147.     AMARQUEEIsCompiledHow := 3;
    1148. 

  1148.    {$Warning No autoopening of amarquee.library compiled}
    1149. 

  1149.    {$Warning Make sure you open amarquee.library yourself}
    1150. 

  1150. {$endif dont_use_openlib}
    1151. 

  1151. 

  1152. END. (* UNIT AMARQUEE *)
    1153.