home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / AsyncIOPPCdev / PPCInclude / powerup / ppcpragmas / asyncio_pragmas.h
Encoding:
C/C++ Source or Header  |  2000-01-02  |  9.4 KB  |  326 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_ASYNCIO_H
  4. #define _PPCPRAGMA_ASYNCIO_H
  5.  
  6. #ifndef POWERUP_PPCLIB_INTERFACE_H
  7. #include <powerup/ppclib/interface.h>
  8. #endif
  9.  
  10. #ifndef POWERUP_GCCLIB_PROTOS_H
  11. #include <powerup/gcclib/powerup_protos.h>
  12. #endif
  13.  
  14. #ifndef NO_PPCINLINE_STDARG
  15. #define NO_PPCINLINE_STDARG
  16. #endif/* SAS C PPC inlines */
  17.  
  18. #ifndef ASYNCIO_BASE_NAME
  19. #define ASYNCIO_BASE_NAME AsyncIOBase
  20. #endif /* !ASYNCIO_BASE_NAME */
  21.  
  22. #ifdef ASIO_NOEXTERNALS
  23. #define    OpenAsync(fileName, mode, bufferSize, SysBase, DOSBase)    _OpenAsync(ASYNCIO_BASE_NAME, fileName, mode, bufferSize, SysBase, DOSBase)
  24.  
  25. static __inline AsyncFile *
  26. _OpenAsync(void *AsyncIOBase, const STRPTR fileName, OpenModes mode, LONG bufferSize, struct ExecBase *SysBase, struct DosLibrary *DOSBase)
  27. {
  28. struct Caos    MyCaos;
  29.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  30. //    MyCaos.M68kStart    =    NULL;
  31. //    MyCaos.M68kSize        =    0;
  32.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  33. //    MyCaos.PPCStart        =    NULL;
  34. //    MyCaos.PPCSize        =    0;
  35.     MyCaos.a0        =(ULONG) fileName;
  36.     MyCaos.d0        =(ULONG) mode;
  37.     MyCaos.d1        =(ULONG) bufferSize;
  38.     MyCaos.a1        =(ULONG) SysBase;
  39.     MyCaos.a2        =(ULONG) DOSBase;
  40.     MyCaos.caos_Un.Offset    =    (-30);
  41.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  42.     return((AsyncFile *)PPCCallOS(&MyCaos));
  43. }
  44.  
  45. #define    OpenAsyncFromFH(handle, mode, bufferSize, SysBase, DOSBase)    _OpenAsyncFromFH(ASYNCIO_BASE_NAME, handle, mode, bufferSize, SysBase, DOSBase)
  46.  
  47. static __inline AsyncFile *
  48. _OpenAsyncFromFH(void *AsyncIOBase, BPTR handle, OpenModes mode, LONG bufferSize, struct ExecBase *SysBase, struct DosLibrary *DOSBase)
  49. {
  50. struct Caos    MyCaos;
  51.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  52. //    MyCaos.M68kStart    =    NULL;
  53. //    MyCaos.M68kSize        =    0;
  54.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  55. //    MyCaos.PPCStart        =    NULL;
  56. //    MyCaos.PPCSize        =    0;
  57.     MyCaos.a0        =(ULONG) handle;
  58.     MyCaos.d0        =(ULONG) mode;
  59.     MyCaos.d1        =(ULONG) bufferSize;
  60.     MyCaos.a1        =(ULONG) SysBase;
  61.     MyCaos.a2        =(ULONG) DOSBase;
  62.     MyCaos.caos_Un.Offset    =    (-36);
  63.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  64.     return((AsyncFile *)PPCCallOS(&MyCaos));
  65. }
  66.  
  67. #else
  68.  
  69. #define    OpenAsync(fileName, mode, bufferSize)    _OpenAsync(ASYNCIO_BASE_NAME, fileName, mode, bufferSize)
  70.  
  71. static __inline AsyncFile *
  72. _OpenAsync(void *AsyncIOBase, const STRPTR fileName, OpenModes mode, LONG bufferSize)
  73. {
  74. struct Caos    MyCaos;
  75.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  76. //    MyCaos.M68kStart    =    NULL;
  77. //    MyCaos.M68kSize        =    0;
  78.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  79. //    MyCaos.PPCStart        =    NULL;
  80. //    MyCaos.PPCSize        =    0;
  81.     MyCaos.a0        =(ULONG) fileName;
  82.     MyCaos.d0        =(ULONG) mode;
  83.     MyCaos.d1        =(ULONG) bufferSize;
  84.     MyCaos.caos_Un.Offset    =    (-30);
  85.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  86.     return((AsyncFile *)PPCCallOS(&MyCaos));
  87. }
  88.  
  89. #define    OpenAsyncFromFH(handle, mode, bufferSize)    _OpenAsyncFromFH(ASYNCIO_BASE_NAME, handle, mode, bufferSize)
  90.  
  91. static __inline AsyncFile *
  92. _OpenAsyncFromFH(void *AsyncIOBase, BPTR handle, OpenModes mode, LONG bufferSize)
  93. {
  94. struct Caos    MyCaos;
  95.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  96. //    MyCaos.M68kStart    =    NULL;
  97. //    MyCaos.M68kSize        =    0;
  98.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  99. //    MyCaos.PPCStart        =    NULL;
  100. //    MyCaos.PPCSize        =    0;
  101.     MyCaos.a0        =(ULONG) handle;
  102.     MyCaos.d0        =(ULONG) mode;
  103.     MyCaos.d1        =(ULONG) bufferSize;
  104.     MyCaos.caos_Un.Offset    =    (-36);
  105.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  106.     return((AsyncFile *)PPCCallOS(&MyCaos));
  107. }
  108. #endif /* ASIO_NOEXTERNALS */
  109.  
  110. #define    CloseAsync(file)    _CloseAsync(ASYNCIO_BASE_NAME, file)
  111.  
  112. static __inline LONG
  113. _CloseAsync(void *AsyncIOBase, AsyncFile *file)
  114. {
  115. struct Caos    MyCaos;
  116.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  117. //    MyCaos.M68kStart    =    NULL;
  118. //    MyCaos.M68kSize        =    0;
  119.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  120. //    MyCaos.PPCStart        =    NULL;
  121. //    MyCaos.PPCSize        =    0;
  122.     MyCaos.a0        =(ULONG) file;
  123.     MyCaos.caos_Un.Offset    =    (-42);
  124.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  125.     return((LONG)PPCCallOS(&MyCaos));
  126. }
  127.  
  128. #define    PeekAsync(file, buffer, numBytes)    _PeekAsync(ASYNCIO_BASE_NAME, file, buffer, numBytes)
  129.  
  130. static __inline LONG
  131. _PeekAsync(void *AsyncIOBase, AsyncFile *file, APTR buffer, LONG numBytes)
  132. {
  133. struct Caos    MyCaos;
  134.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  135. //    MyCaos.M68kStart    =    NULL;
  136. //    MyCaos.M68kSize        =    0;
  137.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  138. //    MyCaos.PPCStart        =    NULL;
  139. //    MyCaos.PPCSize        =    0;
  140.     MyCaos.a0        =(ULONG) file;
  141.     MyCaos.a1        =(ULONG) buffer;
  142.     MyCaos.d0        =(ULONG) numBytes;
  143.     MyCaos.caos_Un.Offset    =    (-102);
  144.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  145.     return((LONG)PPCCallOS(&MyCaos));
  146. }
  147.  
  148. #define    ReadAsync(file, buffer, numBytes)    _ReadAsync(ASYNCIO_BASE_NAME, file, buffer, numBytes)
  149.  
  150. static __inline LONG
  151. _ReadAsync(void *AsyncIOBase, AsyncFile *file, APTR buffer, LONG numBytes)
  152. {
  153. struct Caos    MyCaos;
  154.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  155. //    MyCaos.M68kStart    =    NULL;
  156. //    MyCaos.M68kSize        =    0;
  157.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  158. //    MyCaos.PPCStart        =    NULL;
  159. //    MyCaos.PPCSize        =    0;
  160.     MyCaos.a0        =(ULONG) file;
  161.     MyCaos.a1        =(ULONG) buffer;
  162.     MyCaos.d0        =(ULONG) numBytes;
  163.     MyCaos.caos_Un.Offset    =    (-54);
  164.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  165.     return((LONG)PPCCallOS(&MyCaos));
  166. }
  167.  
  168. #define    ReadCharAsync(file)    _ReadCharAsync(ASYNCIO_BASE_NAME, file)
  169.  
  170. static __inline LONG
  171. _ReadCharAsync(void *AsyncIOBase, AsyncFile *file)
  172. {
  173. struct Caos    MyCaos;
  174.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  175. //    MyCaos.M68kStart    =    NULL;
  176. //    MyCaos.M68kSize        =    0;
  177.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  178. //    MyCaos.PPCStart        =    NULL;
  179. //    MyCaos.PPCSize        =    0;
  180.     MyCaos.a0        =(ULONG) file;
  181.     MyCaos.caos_Un.Offset    =    (-66);
  182.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  183.     return((LONG)PPCCallOS(&MyCaos));
  184. }
  185.  
  186. #define    ReadLineAsync(file, buffer, size)    _ReadLineAsync(ASYNCIO_BASE_NAME, file, buffer, size)
  187.  
  188. static __inline LONG
  189. _ReadLineAsync(void *AsyncIOBase, AsyncFile *file, APTR buffer, LONG size)
  190. {
  191. struct Caos    MyCaos;
  192.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  193. //    MyCaos.M68kStart    =    NULL;
  194. //    MyCaos.M68kSize        =    0;
  195.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  196. //    MyCaos.PPCStart        =    NULL;
  197. //    MyCaos.PPCSize        =    0;
  198.     MyCaos.a0        =(ULONG) file;
  199.     MyCaos.a1        =(ULONG) buffer;
  200.     MyCaos.d0        =(ULONG) size;
  201.     MyCaos.caos_Un.Offset    =    (-78);
  202.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  203.     return((LONG)PPCCallOS(&MyCaos));
  204. }
  205.  
  206. #define    FGetsAsync(file, buffer, size)    _FGetsAsync(ASYNCIO_BASE_NAME, file, buffer, size)
  207.  
  208. static __inline APTR
  209. _FGetsAsync(void *AsyncIOBase, AsyncFile *file, APTR buffer, LONG size)
  210. {
  211. struct Caos    MyCaos;
  212.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  213. //    MyCaos.M68kStart    =    NULL;
  214. //    MyCaos.M68kSize        =    0;
  215.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  216. //    MyCaos.PPCStart        =    NULL;
  217. //    MyCaos.PPCSize        =    0;
  218.     MyCaos.a0        =(ULONG) file;
  219.     MyCaos.a1        =(ULONG) buffer;
  220.     MyCaos.d0        =(ULONG) size;
  221.     MyCaos.caos_Un.Offset    =    (-90);
  222.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  223.     return((APTR)PPCCallOS(&MyCaos));
  224. }
  225.  
  226. #define    FGetsLenAsync(file, buffer, size, length)    _FGetsLenAsync(ASYNCIO_BASE_NAME, file, buffer, size, length)
  227.  
  228. static __inline APTR
  229. _FGetsLenAsync(void *AsyncIOBase, AsyncFile *file, APTR buffer, LONG size, LONG *length)
  230. {
  231. struct Caos    MyCaos;
  232.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  233. //    MyCaos.M68kStart    =    NULL;
  234. //    MyCaos.M68kSize        =    0;
  235.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  236. //    MyCaos.PPCStart        =    NULL;
  237. //    MyCaos.PPCSize        =    0;
  238.     MyCaos.a0        =(ULONG) file;
  239.     MyCaos.a1        =(ULONG) buffer;
  240.     MyCaos.d0        =(ULONG) size;
  241.     MyCaos.a2        =(ULONG) length;
  242.     MyCaos.caos_Un.Offset    =    (-96);
  243.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  244.     return((APTR)PPCCallOS(&MyCaos));
  245. }
  246.  
  247. #define    WriteAsync(file, buffer, numBytes)    _WriteAsync(ASYNCIO_BASE_NAME, file, buffer, numBytes)
  248.  
  249. static __inline LONG
  250. _WriteAsync(void *AsyncIOBase, AsyncFile *file, APTR buffer, LONG numBytes)
  251. {
  252. struct Caos    MyCaos;
  253.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  254. //    MyCaos.M68kStart    =    NULL;
  255. //    MyCaos.M68kSize        =    0;
  256.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  257. //    MyCaos.PPCStart        =    NULL;
  258. //    MyCaos.PPCSize        =    0;
  259.     MyCaos.a0        =(ULONG) file;
  260.     MyCaos.a1        =(ULONG) buffer;
  261.     MyCaos.d0        =(ULONG) numBytes;
  262.     MyCaos.caos_Un.Offset    =    (-60);
  263.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  264.     return((LONG)PPCCallOS(&MyCaos));
  265. }
  266.  
  267. #define    WriteCharAsync(file, ch)    _WriteCharAsync(ASYNCIO_BASE_NAME, file, ch)
  268.  
  269. static __inline LONG
  270. _WriteCharAsync(void *AsyncIOBase, AsyncFile *file, UBYTE ch)
  271. {
  272. struct Caos    MyCaos;
  273.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  274. //    MyCaos.M68kStart    =    NULL;
  275. //    MyCaos.M68kSize        =    0;
  276.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  277. //    MyCaos.PPCStart        =    NULL;
  278. //    MyCaos.PPCSize        =    0;
  279.     MyCaos.a0        =(ULONG) file;
  280.     MyCaos.d0        =(ULONG) ch;
  281.     MyCaos.caos_Un.Offset    =    (-72);
  282.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  283.     return((LONG)PPCCallOS(&MyCaos));
  284. }
  285.  
  286. #define    WriteLineAsync(file, line)    _WriteLineAsync(ASYNCIO_BASE_NAME, file, line)
  287.  
  288. static __inline LONG
  289. _WriteLineAsync(void *AsyncIOBase, AsyncFile *file, STRPTR line)
  290. {
  291. struct Caos    MyCaos;
  292.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  293. //    MyCaos.M68kStart    =    NULL;
  294. //    MyCaos.M68kSize        =    0;
  295.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  296. //    MyCaos.PPCStart        =    NULL;
  297. //    MyCaos.PPCSize        =    0;
  298.     MyCaos.a0        =(ULONG) file;
  299.     MyCaos.a1        =(ULONG) line;
  300.     MyCaos.caos_Un.Offset    =    (-84);
  301.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  302.     return((LONG)PPCCallOS(&MyCaos));
  303. }
  304.  
  305. #define    SeekAsync(file, position, mode)    _SeekAsync(ASYNCIO_BASE_NAME, file, position, mode)
  306.  
  307. static __inline LONG
  308. _SeekAsync(void *AsyncIOBase, AsyncFile *file, LONG position, SeekModes mode)
  309. {
  310. struct Caos    MyCaos;
  311.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  312. //    MyCaos.M68kStart    =    NULL;
  313. //    MyCaos.M68kSize        =    0;
  314.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  315. //    MyCaos.PPCStart        =    NULL;
  316. //    MyCaos.PPCSize        =    0;
  317.     MyCaos.a0        =(ULONG) file;
  318.     MyCaos.d0        =(ULONG) position;
  319.     MyCaos.d1        =(ULONG) mode;
  320.     MyCaos.caos_Un.Offset    =    (-48);
  321.     MyCaos.a6        =(ULONG) AsyncIOBase;    
  322.     return((LONG)PPCCallOS(&MyCaos));
  323. }
  324.  
  325. #endif /* !_PPCPRAGMA_ASYNCIO_H */
  326.