home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / GNU_C++ / LIB / MTLB49CF.LZH / include / osbind.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-05-29  |  67.3 KB  |  2,196 lines
  1. /*
  2.  * osbind.h    bindings for OS traps
  3.  *
  4.  *        ++jrb bammi@cadence.com
  5.  */
  6.  
  7. /*
  8.  * majorly re-hacked for gcc-1.36 and probably beyond
  9.  * all inlines changed to #defines, beacuse gcc is not
  10.  * handling clobbered reggies correctly when -mshort.
  11.  * We now use the Statement Exprs feature of GnuC
  12.  *
  13.  * 10/12/89
  14.  *    changed all "g" constraints to "r" that will force
  15.  *    all operands to be evaluated (or lea calculated)
  16.  *    before the __asm__. This is necessary because
  17.  *    if we had the (looser) "g" constraint, then sometimes
  18.  *    we are in the situation where stuff is in the stack,
  19.  *    and we are modifying the stack under Gcc (but eventually
  20.  *    restoring it before the end of the __asm__), and it does
  21.  *    not know about it (i believe there is no way to tell it
  22.  *    this either, but you can hardly expect that). by forcing
  23.  *    the stricter "r" constraint, we force the eval before using
  24.  *    the val (or lea as the case may be) and we dont get into
  25.  *    trouble.
  26.  *    (thanks to ers for finding this problem!)
  27.  *    [one side effect of this is that we may(depending on the
  28.  *      situation) actually end up with better code when the
  29.  *    values are already in reggies, or that value is used
  30.  *    later on (note that Gnu's reggie allocation notices the
  31.  *    clobbered reggie, and does'nt put the value/or uses
  32.  *    them from those reggies, nice huh!)
  33.  *
  34.  *  28/2/90
  35.  *    another major re-hack:
  36.  *    -- the basic reason: there was just no reliable
  37.  *    way to get the definitions (inline or not does'nt matter) to
  38.  *    fully evaluate the args before we changed the sp from under it.
  39.  *    (if -fomit-frame-pointer is *not* used, then most of the time
  40.  *     we dont need to do this, as things will just reference off of
  41.  *     a6, but this is not true all of the time).
  42.  *    my solution was to use local vars in the body of the statement
  43.  *    exprs, and initialize them from the args of the statement expr block.
  44.  *    to force the evaluation of the args before we change sp from
  45.  *    under gcc's feet, we make the local vars volatile. we use a
  46.  *    slight code optimization heuristic: if there are more than 4
  47.  *    args, only then we make the local volatile, and relax
  48.  *    the "r" constraint to "g". otherwise, we dont put the volatile
  49.  *    and force the evaluation by putting the "r" constaint. this
  50.  *    produces better code in most sitiations (when !__NO_INLINE__
  51.  *    especially), as either the args are already in a register or
  52.  *    there is good chance they will soon be reused, and in that
  53.  *    case it will already be in a register.
  54.  *      it may (the local vars, especially when no volatile)
  55.  *    look like overhead, but in 99% of the situations gcc will just
  56.  *    optimize that assignment right out. besides, this makes
  57.  *    these defines totally safe (from re-evaluation of the macro args).
  58.  *
  59.  *    -- as suggested by andreas schwab (thanks!)
  60.  *     (schwab@ls5.informatik.uni-dortmund.de) all the retvalues are now
  61.  *     local register vals (see the extentions section in the info file)
  62.  *     this really worked out great as all the silly "movl d0,%0" at
  63.  *     the end of each def can now be removed, and the value of
  64.  *     retvalue ends up in the correct register. it avoids all the
  65.  *     silly "mov d0,[d|a]n" type sequences from being generated. a real win.
  66.  *     (note in the outputs "=r"(retvalue) still has to be specified,
  67.  *     otherwise in certain situations you end up loosing the return
  68.  *     value in d0, as gcc sees no output, and correctly assumes that the
  69.  *     asm returns no value).
  70.  *
  71.  *    -- all the n's (the function #'s for the traps) are now given
  72.  *    the more relaxed "g". This again results in better code, as
  73.  *    it is always a constant, and gcc turns the movw %1,sp@- into
  74.  *    a movw #n,sp@-. we could have given them a "i" constraint too,
  75.  *    but "g" gives gcc more breathing room, and it does the right
  76.  *    thing. note: the n's still need to have "r" constraints in the
  77.  *    non-inline form (function form), as they are no longer constants
  78.  *    in the function, but a normal arg on the stack frame, and hence
  79.  *    we need to force evaluation before we change sp. (see osbind.c)
  80.  *
  81.  *    -- straps.cpp and traps.c are history. we dont need no stinking
  82.  *    non-reentrant bindings (straps) or incorrect ones (traps.c :-)
  83.  *
  84.  * 03/15/92 ++jrb
  85.  *    -- another re-hack needed for gcc-2.0: the optimization that we
  86.  *      used earlier for traps with more than 4 args, making them volatile
  87.  *    and using "g" constraints no longer works, because gcc has become
  88.  *    so smart! we now remove the volatile, and give "r" constraints
  89.  *    (just like traps with <= 4 args). that way the args are evaled
  90.  *    before we change the stack under gcc, and at appropriate times
  91.  *    put into reggies and pushed (or as in most cases, they are evaled
  92.  *    straight into reggies and pushed -- and in even more common cases
  93.  *    they are already in reggies, and they are just pushed). not doing
  94.  *    this with -fomit-frame-pointer was causing the temps (from evaluing
  95.  *    the args) to be created on the stack, but when we changed sp
  96.  *    from under gccs feet, the offsets  to the temps ended up being wrong.
  97.  *
  98.  * 10/28/93 ++jrb
  99.  *    relax the constraints on the inputs of trap_14_wwwwwww (only
  100.  *    Rsconf maps to this)  to "g" from "r", as these many "r" 's
  101.  *    give gcc 2.>3.X heartaches (understandably). note this is ok
  102.  *    since these args will never be expressions, and we never
  103.  *    have to constrain hard enough to force eval before we change
  104.  *    sp from underneath gcc.
  105.  *
  106.  */
  107.  
  108. #ifndef _OSBIND_H
  109. #define _OSBIND_H
  110.  
  111. #ifndef _COMPILER_H
  112. #include <compiler.h>
  113. #endif
  114.  
  115. #ifdef __cplusplus
  116. extern "C" {
  117. #endif
  118.  
  119. #ifndef _OSTRUCT_H
  120. #include <ostruct.h>
  121. #endif
  122.  
  123. #ifdef __TURBOC__
  124.  
  125. /* we supply a library of bindings for TurboC / PureC */
  126.  
  127. long    gemdos( short, ... );
  128. long    bios( short, ... );
  129. long    xbios( short, ... );
  130.  
  131. /* Gemdos prototypes */
  132.  
  133. void    Pterm0( void );
  134. long    Cconin( void );
  135. void    Cconout( int c );
  136. int     Cauxin( void );
  137. void    Cauxout( int c );
  138. int     Cprnout( int c );
  139. long    Crawio( int w );
  140. long    Crawcin( void );
  141. long    Cnecin( void );
  142. int     Cconws( const char *buf );
  143. void    Cconrs( LINE *buf );
  144. int     Cconis( void );
  145. long    Dsetdrv( int drv );
  146. int     Cconos( void );
  147. int     Cprnos( void );
  148. int     Cauxis( void );
  149. int     Cauxos( void );
  150. int     Dgetdrv( void );
  151. void    Fsetdta( _DTA *buf );
  152. long    Super( void *stack );
  153. unsigned int  Tgetdate( void );
  154. unsigned int  Tsetdate( unsigned int date );
  155. unsigned int  Tgettime( void );
  156. unsigned int  Tsettime( unsigned int time );
  157. _DTA    *Fgetdta( void );
  158. int     Sversion( void );
  159. void    Ptermres( long keepcnt, int retcode );
  160. int     Dfree( _DISKINFO *buf, int driveno );
  161. int     Dcreate( const char *path );
  162. int     Ddelete( const char *path );
  163. int     Dsetpath( const char *path );
  164. long    Fcreate( const char *filename, int attr );
  165. long    Fopen( const char *filename, int mode );
  166. int     Fclose( int handle );
  167. long    Fread( int handle, long count, void *buf );
  168. long    Fwrite( int handle, long count, void *buf );
  169. int     Fdelete( const char *filename );
  170. long    Fseek( long offset, int handle, int seekmode );
  171. int     Fattrib( const char *filename, int wflag, int attrib );
  172. long    Fdup( int handle );
  173. long    Fforce( int stch, int nonstdh );
  174. int     Dgetpath( char *path, int driveno );
  175. void    *Malloc( long number );
  176. int     Mfree( void *block );
  177. int     Mshrink( int zero, void *ptr, long size );
  178. #define Mshrink(ptr, size) Mshrink(0, ptr, size)
  179. long    Pexec( int mode, char *ptr1, void *ptr2, void *ptr3 );
  180. void    Pterm( int retcode );
  181. int     Fsfirst( const char *filename, int attr );
  182. int     Fsnext( void );
  183. int     Frename( int zero, const char *oldname, const char *newname );
  184. int     Fdatime( _DOSTIME *timeptr, int handle, int wflag );
  185.  
  186. /* J. Geiger's time package for MiNTlib defines this: */
  187.  
  188. int     Getcookie( long cookie, long *val);
  189.  
  190. /* GEMDOS extensions */
  191.  
  192. void    *Mxalloc( long number, int mode );
  193. long    Maddalt( void *start, long size );
  194.  
  195. /* Network Gemdos Extension */
  196.  
  197. long    Flock( int handle, int mode, long start, long length );
  198.  
  199. /* BIOS */
  200.  
  201. void    Getmpb( _MPB *ptr );
  202. int     Bconstat( int dev );
  203. long    Bconin( int dev );
  204. long    Bconout( int dev, int c );
  205. long    Rwabs( int rwflag, void *buf, int cnt, int recnr, int dev );
  206. void    (*Setexc( int number, void (*exchdlr)() )) ();
  207. #define Setexc(number, exchdlr)    Setexc(number, (void(*)())(exchdlr))
  208. long    Tickcal( void );
  209. _BPB    *Getbpb( int dev );
  210. long    Bcostat( int dev );
  211. long    Mediach( int dev );
  212. long    Drvmap( void );
  213. long    Kbshift( int mode );
  214. #define Getshift() Kbshift(-1)
  215.  
  216. /* XBios */
  217.  
  218. void    Initmous( int type, _PARAM *par, void (*mousevec)() );
  219. #define Initmous(type, par, mousevec) Initmous(type, par, (void(*)()) mousevec)
  220. void    *Ssbrk( int count );
  221. void    *Physbase( void );
  222. void    *Logbase( void );
  223. int     Getrez( void );
  224. void    Setscreen( void *laddr, void *paddr, int rez );
  225. void    Setpalette( void *pallptr );
  226. int     Setcolor( int colornum, int color );
  227. int     Floprd( void *buf, long filler, int devno, int sectno,
  228.                int trackno, int sideno, int count );
  229. int     Flopwr( void *buf, long filler, int devno, int sectno,
  230.                int trackno, int sideno, int count );
  231. int     Flopfmt( void *buf, long filler, int devno, int spt, int trackno,
  232.                 int sideno, int interlv, long magic, int virgin );
  233. void    Midiws( int cnt, void *ptr );
  234. void    Mfpint( int erno, void (*vector)() );
  235. _IOREC   *Iorec( int dev );
  236. long    Rsconf( int baud, int ctr, int ucr, int rsr, int tsr, int scr );
  237. _KEYTAB  *Keytbl( void *unshift, void *shift, void *capslock );
  238. long    Random( void );
  239. void    Protobt( void *buf, long serialno, int disktype, int execflag );
  240. int     Flopver( void *buf, long filler, int devno, int sectno,
  241.                 int trackno, int sideno, int count );
  242. void    Scrdmp( void );
  243. int     Cursconf( int func, int rate );
  244. void    Settime( unsigned long time );
  245. unsigned long  Gettime( void );
  246. void    Bioskeys( void );
  247. void    Ikbdws( int count, void *ptr );
  248. void    Jdisint( int number );
  249. void    Jenabint( int number );
  250. char    Giaccess( char data, int regno );
  251. void    Offgibit( int bitno );
  252. void    Ongibit( int bitno );
  253. void    Xbtimer( int timer, int control, int data, void (*vector)() );
  254. void    *Dosound( void *buf );
  255. int     Setprt( int config );
  256. _KBDVECS *Kbdvbase( void );
  257. int     Kbrate( int initial, int repeat );
  258. void    Prtblk( _PBDEF *par );
  259. void    Vsync( void );
  260. long    Supexec( long (*func)() );
  261. #define Supexec(func) Supexec((long (*) ()) func)
  262. void    Puntaes( void );
  263. int     Floprate( int devno, int newrate );
  264. int     Blitmode( int mode );
  265.  
  266. /* TOS030 XBios */
  267. int     DMAread( long sector, int count, void *buffer, int devno );
  268. int     DMAwrite( long sector, int count, void *buffer, int devno );
  269. int     NVMaccess( int opcode, int start, int count, void *buffer );
  270. long    Bconmap( int devno );
  271. int     Esetshift( int shftMode );
  272. #define EsetShift Esetshift
  273. int     Egetshift( void );
  274. #define EgetShift Egetshift
  275. int     EsetBank( int bankNum );
  276. int     EsetColor( int colorNum, int color );
  277. void    EsetPalette( int colorNum, int count, int *palettePtr );
  278. void    EgetPalette( int colorNum, int count, int *palettePtr );
  279. int     EsetGray( int swtch );
  280. int     EsetSmear( int swtch );
  281.  
  282. #else /* !__TURBOC__ */
  283.  
  284. #ifdef __LATTICE__
  285.  
  286. /*
  287. *
  288. * GEMDOS inline bindings for Lattice C.
  289. *
  290. */
  291. void _vgv(int);
  292. unsigned short _ugv(int);
  293. int _igv(int);
  294. long _lgv(int);
  295. _DTA *_Dgv(int);
  296.  
  297. void _vgs(int,int);
  298. void _vgL(int,_CCONLINE *);
  299. void _vgD(int,_DTA *);
  300. int _igs(int,int);
  301. int _igu(int,unsigned short);
  302. int _igp(int,void *);
  303. int _igC(int,const char *);
  304. long _lgs(int,int);
  305. void *_pgl(int,long);
  306. void *_pgp(int,void *);
  307.  
  308. void _vgls(int,long,int);
  309. int _igss(int,int,int);
  310. int _igcs(int,char *,int);
  311. int _igCs(int,const char *,int);
  312. int _igIs(int,_DISKINFO *,int);
  313. int _igpl(int,void *,long);
  314. long _lgCs(int,const char *,int);
  315. void *_pgls(int,long,int);
  316.  
  317. short _sgCss(int,const char *,int,int);
  318. int _igspl(int,int,void *,long);
  319. int _igsCC(int,int,const char *,const char *);
  320. long _lgspl(int,int,void *,long);
  321. long _lgslp(int,int,long,void *);
  322. long _lgslP(int,int,long,const void *);
  323. long _lglss(int,long,int,int);
  324. long _lgTss(int,_DOSTIME *,int,int);
  325.  
  326. int _igsCpp(int,int,const char *,void *,void *);
  327. long _lgssll(int,int,int,long,long);
  328.  
  329. #pragma inline _vgv((short)) {register d2,a2; "4e41";}
  330. #pragma inline _vgs((short),(short)) {register d2,a2; "4e41";}
  331. #pragma inline _vgL((short),) {register d2,a2; "4e41";}
  332. #pragma inline _vgD((short),) {register d2,a2; "4e41";}
  333. #pragma inline d0=_igv((short)) {register d2,a2; "4e41";}
  334. #pragma inline d0=_igs((short),(short)) {register d2,a2; "4e41";}
  335. #pragma inline d0=_igu((short),) {register d2,a2; "4e41";}
  336. #pragma inline d0=_igp((short),) {register d2,a2; "4e41";}
  337. #pragma inline d0=_igC((short),) {register d2,a2; "4e41";}
  338. #pragma inline d0=_ugv((short)) {register d2,a2; "4e41";}
  339. #pragma inline d0=_lgv((short)) {register d2,a2; "4e41";}
  340. #pragma inline d0=_lgs((short),(short)) {register d2,a2; "4e41";}
  341. #pragma inline d0=_Dgv((short)) {register d2,a2; "4e41";}
  342. #pragma inline d0=_pgl((short),) {register d2,a2; "4e41";}
  343. #pragma inline d0=_pgp((short),) {register d2,a2; "4e41";}
  344.  
  345. #pragma inline d0=_igss((short),(short),(short)) {register d2,a2; "4e41";}
  346. #pragma inline d0=_igcs((short),,(short)) {register d2,a2; "4e41";}
  347. #pragma inline d0=_igCs((short),,(short)) {register d2,a2; "4e41";}
  348. #pragma inline d0=_igIs((short),,(short)) {register d2,a2; "4e41";}
  349. #pragma inline d0=_igpl((short),,) {register d2,a2; "4e41";}
  350. #pragma inline d0=_lgCs((short),,(short)) {register d2,a2; "4e41";}
  351.  
  352. #pragma inline d0=_pgls((short),,(short)) {register d2,a2; "4e41";}
  353.  
  354. #pragma inline d0=_sgCss((short),,(short),(short)) {register d2,a2; "4e41";}
  355. #pragma inline d0=_lgslp((short),(short),,) {register d2,a2; "4e41";}
  356. #pragma inline d0=_lgslP((short),(short),,) {register d2,a2; "4e41";}
  357. #pragma inline d0=_lgspl((short),(short),,) {register d2,a2; "4e41";}
  358. #pragma inline d0=_lglss((short),,(short),(short)) {register d2,a2; "4e41";}
  359. #pragma inline d0=_lgTss((short),,(short),(short)) {register d2,a2; "4e41";}
  360. #pragma inline d0=_igsCC((short),(short),,) {register d2,a2; "4e41";}
  361.  
  362. #pragma inline d0=_igsCpp((short),(short),,,) {register d2,a2; "4e41";}
  363.  
  364.  
  365. #define Pterm0()    _vgv(0)
  366. #define Cconin()    _lgv(1)
  367. #define Cconout(a)    _vgs(2,a)
  368. #define Cauxin()    _igv(3)
  369. #define Cauxout(a)    _vgs(4,a)
  370. #define Cprnout(a)    _igs(5,a)
  371. #define Crawio(a)    _lgs(6,a)
  372. #define Crawcin()    _lgv(7)
  373. #define Cnecin()    _lgv(8)
  374. #define Cconws(a)    _igC(9,a)
  375. #define Cconrs(a)    _vgL(10,a)
  376. #define Cconis()    _igv(11)
  377. #define Dsetdrv(a)    _lgs(14,a)
  378. #define Cconos()    _igv(16)
  379. #define Cprnos()    _igv(17)
  380. #define Cauxis()    _igv(18)
  381. #define Cauxos()    _igv(19)
  382. #define Dgetdrv()    _igv(25)
  383. #define Fsetdta(a)    _vgD(26,a)
  384. #define Super(a)    _pgp(32,a)
  385. #define Tgetdate()    _ugv(42)
  386. #define Tsetdate(a)    _igu(43,a)
  387. #define Tgettime()    _ugv(44)
  388. #define Tsettime(a)    _igu(45,a)
  389. #define Fgetdta()    _Dgv(47)
  390. #define Sversion()    _Vgv(48)
  391. #define Ptermres(a,b)    _vgls(49,a,b)
  392. #define Dfree(a,b)    _igIs(54,a,b)
  393. #define Dcreate(a)    _igC(57,a)
  394. #define Ddelete(a)    _igC(58,a)
  395. #define Dsetpath(a)    _igC(59,a)
  396. #define Fcreate(a,b)    _lgCs(60,a,b)
  397. #define Fopen(a,b)    _lgCs(61,a,b)
  398. #define Fclose(a)    _igs(62,a)
  399. #define Fread(a,b,c)    _lgslp(63,a,b,c)
  400. #define Fwrite(a,b,c)    _lgslP(64,a,b,c)
  401. #define Fdelete(a)    _igC(65,a)
  402. #define Fseek(a,b,c)    _lglss(66,a,b,c)
  403. #define Fattrib(a,b,c)    _sgCss(67,a,b,c)
  404. #define Fdup(a)        _lgs(69,a)
  405. #define Fforce(a,b)    _igss(70,a,b)
  406. #define Dgetpath(a,b)    _igcs(71,a,b)
  407. #define Malloc(a)    _pgl(72,a)
  408. #define Mfree(a)    _igp(73,a)
  409. #define Mshrink(a,b)    _lgspl(74,0,a,b)
  410. #define Pexec(a,b,c,d)    _igsCpp(75,a,b,c,d)
  411. #define Pterm(a)    _vgs(76,a)
  412. #define Fsfirst(a,b)    _igCs(78,a,b)
  413. #define Fsnext()    _igv(79)
  414. #define Frename(a,b,c)    _igsCC(86,a,b,c)
  415. #define Fdatime(a,b,c)    _lgTss(87,a,b,c)
  416.  
  417. #define Maddalt(a,b)    _igpl(20,a,b)
  418. #define Mxalloc(a,b)    _pgls(68,a,b)
  419.  
  420. /*
  421. *
  422. * Network GEMDOS, don't know the function numbers yet.
  423. *
  424. */
  425. /*
  426. #define Nversion() _lgv()
  427. #define Frlock(a,b,c) _lgsll(,a,b,c)
  428. #define Frunlock(a,b) _lgsl(,a,b)
  429. #define Flock(a,b) _lgsl(,a,b)
  430. #define Funlock(a) _lgs(,a)
  431. #define Fflush(a) _lgs(,a)
  432. #define Unlock() _lgC(,a)
  433. #define Lock() _lgC(,a)
  434. */
  435.  
  436. /*
  437. *
  438. * BIOS inline bindings for Lattice.
  439. *
  440. */
  441. long _lbv(int);
  442. unsigned long _Ubv(int);
  443.  
  444. void _vbM(int,_MPB *);
  445. int _ibs(int,int);
  446. long _lbs(int,int);
  447. _BPB *_Bbs(int,int);
  448.  
  449. int _ibss(int,int,int);
  450. void (*_FbsF(int,int,void (*)(void)))(void);
  451.  
  452. int _ibspsss(int,int,void *,int,int,int);
  453. int _ibspssl(int,int,void *,int,int,long);
  454.  
  455.  
  456. #pragma inline d0=_lbv((short)) {register d2,a2; "4e4d";}
  457. #pragma inline d0=_Ubv((short)) {register d2,a2; "4e4d";}
  458.  
  459. #pragma inline _vbM((short),) {register d2,a2; "4e4d";}
  460. #pragma inline d0=_ibs((short),(short)) {register d2,a2; "4e4d";}
  461. #pragma inline d0=_lbs((short),(short)) {register d2,a2; "4e4d";}
  462. #pragma inline d0=_Bbs((short),(short)) {register d2,a2; "4e4d";}
  463.  
  464. #pragma inline d0=_ibss((short),(short),(short)) {register d2,a2; "4e4d";}
  465. #pragma inline d0=_FbsF((short),(short),) {register d2,a2; "4e4d";}
  466.  
  467. #pragma inline d0=_ibsss((short),,(short),(short),(short)) {register d2,a2; "4e4d";}
  468. #pragma inline d0=_ibssl((short),,(short),(short),) {register d2,a2; "4e4d";}
  469.  
  470.  
  471. #define Getmpb(a)    _vbM(0,a)
  472. #define Bconstat(a)    _ibs(1,a)
  473. #define Bconin(a)    _lbs(2,a)
  474. #define Bconout(a,b)    _ibss(3,a,b)
  475. #define Rwabs(a,b,c,d,e)    _ibspsss(4,a,b,c,d,e)
  476. #define Setexc(a,b)    _FbsF(5,a,b)
  477. #define Tickcal()    _lbv(6)
  478. #define Getbpb(a)    _Bbs(7,a)
  479. #define Bcostat(a)    _ibs(8,a)
  480. #define Mediach(a)    _ibs(9,a)
  481. #define Drvmap()    _Ubv(10)
  482. #define Kbshift(a)    _lbs(11,a)
  483. #define Lrwabs(a,b,c,d,e)    _ibspssl(12,a,b,c,d,e)
  484.  
  485. /*
  486. *
  487. * XBIOS inline bindings for Lattice.
  488. *
  489. */
  490. void _vxv(int);
  491. short _sxv(int);
  492. int _ixv(int);
  493. long _lxv(int);
  494. void *_pxv(int);
  495. _DOSTIME _Txv(int);
  496. _KBDVECS *_Vxv(int);
  497.  
  498. void _vxs(int,int);
  499. void _vxr(int,unsigned short);
  500. void _vxC(int,const char *);
  501. void _vxT(int,_DOSTIME);
  502. short _sxs(int,int);
  503. short _sxQ(int,_PBDEF *);
  504. int _ixs(int,int);
  505. long _lxG(int,long (*)(void));
  506. void *_pxs(int,int);
  507. _IOREC *_Ixs(int,int);
  508. long _Bxs(int,int);
  509.  
  510. void _vxsC(int,int,const char *);
  511. void _vxsF(int,int,void (*)(void));
  512. short _sxss(int,int,int);
  513. int _ixss(int,int,int);
  514.  
  515. void _vxsMF(int,int,_PARAM *,void (*)(void));
  516. void _vxpps(int,void *,void *,int);
  517. void _vxssq(int,int,int,short *);
  518. void _vxssQ(int,int,int,const short *);
  519. _KEYTAB *_KxCCC(int,const char *,const char *,const char *);
  520.  
  521. void _vxplss(int,void *,long,int,int);
  522. void _vxsssF(int,int,int,int,void (*)(void));
  523. int _ixsssc(int,int,int,int,char *);
  524. int _ixlsps(int,long,int,void *,int);
  525. int _ixlsPs(int,long,int,const void *,int);
  526.  
  527. long _lxssssss(int,int,int,int,int,int,int);
  528.  
  529. short _sxplsssss(int,void *,long,int,int,int,int,int);
  530. short _sxPlsssss(int,const void *,long,int,int,int,int,int);
  531.  
  532. short _sxprsssssls(int,void *,short *,int,int,int,int,int,long,int);
  533.  
  534.  
  535. #pragma inline _vxv((short)) {register d2,a2; "4e4e";}
  536. #pragma inline d0=_sxv((short)) {register d2,a2; "4e4e";}
  537. #pragma inline d0=_ixv((short)) {register d2,a2; "4e4e";}
  538. #pragma inline d0=_lxv((short)) {register d2,a2; "4e4e";}
  539. #pragma inline d0=_pxv((short)) {register d2,a2; "4e4e";}
  540. #pragma inline d0=_Txv((short)) {register d2,a2; "4e4e";}
  541. #pragma inline d0=_Vxv((short)) {register d2,a2; "4e4e";}
  542.  
  543. #pragma inline _vxs((short),(short)) {register d2,a2; "4e4e";}
  544. #pragma inline _vxr((short),) {register d2,a2; "4e4e";}
  545. #pragma inline _vxC((short),) {register d2,a2; "4e4e";}
  546. #pragma inline _vxT((short),) {register d2,a2; "4e4e";}
  547. #pragma inline d0=_sxs((short),(short)) {register d2,a2; "4e4e";}
  548. #pragma inline d0=_sxQ((short),) {register d2,a2; "4e4e";}
  549. #pragma inline d0=_ixs((short),(short)) {register d2,a2; "4e4e";}
  550. #pragma inline d0=_lxG((short),) {register d2,a2; "4e4e";}
  551. #pragma inline d0=_pxs((short),(short)) {register d2,a2; "4e4e";}
  552. #pragma inline d0=_Ixs((short),(short)) {register d2,a2; "4e4e";}
  553. #pragma inline d0=_Bxs((short),(short)) {register d2,a2; "4e4e";}
  554.  
  555. #pragma inline _vxsC((short),(short),) {register d2,a2; "4e4e";}
  556. #pragma inline _vxsF((short),(short),) {register d2,a2; "4e4e";}
  557. #pragma inline d0=_sxss((short),(short),(short)) {register d2,a2; "4e4e";}
  558. #pragma inline d0=_ixss((short),(short),(short)) {register d2,a2; "4e4e";}
  559.  
  560. #pragma inline _vxsMF((short),(short),,) {register d2,a2; "4e4e";}
  561. #pragma inline _vxpps((short),,,(short)) {register d2,a2; "4e4e";}
  562. #pragma inline _vxssq((short),(short),(short),) {register d2,a2; "4e4e";}
  563. #pragma inline _vxssQ((short),(short),(short),) {register d2,a2; "4e4e";}
  564. #pragma inline d0=_KxCCC((short),,,) {register d2,a2; "4e4e";}
  565.  
  566. #pragma inline _vxplss((short),,,(short),(short)) {register d2,a2; "4e4e";}
  567. #pragma inline _vxsssF((short),(short),(short),(short),) {register d2,a2; "4e4e";}
  568. #pragma inline d0=_ixsssc((short),(short),(short),(short),) {register d2,a2; "4e4e";}
  569. #pragma inline d0=_ixlsps((short),,(short),,(short)) {register d2,a2; "4e4e";}
  570. #pragma inline d0=_ixlsPs((short),,(short),,(short)) {register d2,a2; "4e4e";}
  571.  
  572. #pragma inline d0=_lxssssss((short),(short),(short),(short),(short),(short),(short)) {register d2,a2; "4e4e";}
  573.  
  574. #pragma inline d0=_sxplsssss((short),,,(short),(short),(short),(short),(short)) {register d2,a2; "4e4e";}
  575. #pragma inline d0=_sxPlsssss((short),,,(short),(short),(short),(short),(short)) {register d2,a2; "4e4e";}
  576.  
  577. #pragma inline d0=_sxprsssssls((short),,,(short),(short),(short),(short),(short),,(short)) {register d2,a2; "4e4e";}
  578.  
  579.  
  580. #define Initmous(a,b,c)    _vxsMF(0,a,b,c)
  581. #define Ssbrk(a)    _pxs(1,a)
  582. #define Physbase()    _pxv(2)
  583. #define Logbase()    _pxv(3)
  584. #define Getrez()    _sxv(4)
  585. #define Setscreen(a,b,c)    _vxpps(5,a,b,c)
  586. #define Setpallete(a)    _vxr(6,a)
  587. #define setcolor(a,b)    _sxss(7,a,b)
  588. #define Floprd(a,b,c,d,e,f,g)    _sxplsssss(8,a,b,c,d,e,f,g)
  589. #define Flopwr(a,b,c,d,e,f,g)    _sxPlsssss(9,a,b,c,d,e,f,g)
  590. #define Flopfmt(a,b,c,d,e,f,g,h,i)    _sxprsssssls(10,a,b,c,d,e,f,g,h,i)
  591. #define Midiws(a,b)    _vxsC(12,a,b)
  592. #define Mfpint(a,b)    _vxsF(13,a,b)
  593. #define Iorec(a)    _Ixs(14,a)
  594. #define Rsconf(a,b,c,d,e,f)    _lxssssss(15,a,b,c,d,e,f)
  595. #define Keytbl(a,b,c)    _KxCCC(16,a,b,c)
  596. #define Random()    _lxv(17)
  597. #define Protobt(a,b,c,d)    _vxplss(18,a,b,c,d)
  598. #define Flopver(a,b,c,d,e,f,g)    _sxplsssss(19,a,b,c,d,e,f,g)
  599. #define Scrdmp()    _vxv(20)
  600. #define Cursconf(a,b)    _sxss(21,a,b)
  601. #define Settime(a)    _vxT(22,a)
  602. #define Gettime()    _Txv(23)
  603. #define Bioskeys()    _vxv(24)
  604. #define Ikbdws(a,b)    _vxsC(25,a,b)
  605. #define Jdisint(a)    _vxs(26,a)
  606. #define Jenabint(a)    _vxs(27,a)
  607. #define Giaccess(a,b)    _sxss(28,a,b)
  608. #define Offgibit(a)    _vxs(29,a)
  609. #define Ongibit(a)    _vxs(30,a)
  610. #define Xbtimer(a,b,c,d)    _vxsssF(31,a,b,c,d)
  611. #define Dosound(a)    _vxC(32,a)
  612. #define Setprt(a)    _sxs(33,a)
  613. #define Kbdvbase()    _Vxv(34)
  614. #define Kbrate(a,b)    _sxss(35,a,b)
  615. #define Prtblk(a)    _sxQ(36,a)
  616. #define Vsync()    _vxv(37)
  617. #define Supexec(a)    _lxG(38,a)
  618. #define Puntaes()    _vxv(39)
  619.  
  620. #define Blitmode(a)    _sxs(64,a)
  621.  
  622. #define Floprate(a,b)    _sxss(41,a,b)
  623.  
  624. #define DMAread(a,b,c,d)    _ixlsps(42,a,b,c,d)
  625. #define DMAwrite(a,b,c,d)    _ixlsPs(43,a,b,c,d)
  626. #define Bconmap(a)    _Bxs(44,a)
  627. #define NVMaccess(a,b,c,d)    _ixsssc(46,a,b,c,d)
  628.  
  629. #define EsetShift(a)    _ixs(80,a)
  630. #define EgetShift()    _ixv(81)
  631. #define EsetBank(a)    _ixs(82,a)
  632. #define EsetColor(a,b)    _ixss(83,a,b)
  633. #define EsetPalette(a,b,c)    _vxssQ(84,a,b,c)
  634. #define EgetPalette(a,b,c)    _vxssq(85,a,b,c)
  635. #define EsetGray(a)    _ixs(86,a)
  636. #define EsetSmear(a)    _ixs(87,a)
  637.  
  638. #else /* !__LATTICE__ */
  639.  
  640. /* want to skip all the gory details of GNU C inlines??
  641.    search for the string "DEFINITIONS" */
  642.  
  643. #ifdef __GNUC_INLINE__
  644. /*
  645.  * GNU C (pseudo inline) Statement Exprs for traps
  646.  *
  647.  */
  648.  
  649. #if __GNUC__ > 2 || __GNUC_MINOR__ > 5
  650. #define AND_MEMORY , "memory"
  651. #else
  652. #define AND_MEMORY
  653. #define __extension__
  654. #endif
  655.  
  656. #define trap_1_w(n)                            \
  657. __extension__                                \
  658. ({                                    \
  659.     register long retvalue __asm__("d0");                \
  660.                                         \
  661.     __asm__ volatile                        \
  662.     ("\
  663.         movw    %1,sp@-; \
  664.         trap    #1;    \
  665.         addqw   #2,sp "                        \
  666.     : "=r"(retvalue)            /* outputs */        \
  667.     : "g"(n)                /* inputs  */        \
  668.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  669.       AND_MEMORY                            \
  670.     );                                \
  671.     retvalue;                            \
  672. })
  673.  
  674. #define trap_1_ww(n, a)                            \
  675. __extension__                                \
  676. ({                                    \
  677.     register long retvalue __asm__("d0");                \
  678.     short _a = (short)(a);                        \
  679.                                         \
  680.     __asm__ volatile                        \
  681.     ("\
  682.         movw    %2,sp@-; \
  683.         movw    %1,sp@-; \
  684.         trap    #1;    \
  685.         addqw   #4,sp "                        \
  686.     : "=r"(retvalue)            /* outputs */        \
  687.     : "g"(n), "r"(_a)            /* inputs  */        \
  688.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  689.       AND_MEMORY                            \
  690.     );                                \
  691.     retvalue;                            \
  692. })
  693.  
  694. #define trap_1_wl(n, a)                            \
  695. __extension__                                \
  696. ({                                    \
  697.     register long retvalue __asm__("d0");                \
  698.     long  _a = (long) (a);                        \
  699.                                         \
  700.     __asm__ volatile                        \
  701.     ("\
  702.         movl    %2,sp@-; \
  703.         movw    %1,sp@-; \
  704.         trap    #1;    \
  705.         addqw   #6,sp "                        \
  706.     : "=r"(retvalue)            /* outputs */        \
  707.     : "g"(n), "r"(_a)            /* inputs  */        \
  708.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  709.       AND_MEMORY                            \
  710.     );                                \
  711.     retvalue;                            \
  712. })
  713.  
  714. #define trap_1_wlw(n, a, b)                        \
  715. __extension__                                \
  716. ({                                    \
  717.     register long retvalue __asm__("d0");                \
  718.     long  _a = (long) (a);                        \
  719.     short _b = (short)(b);                        \
  720.                                         \
  721.     __asm__ volatile                        \
  722.     ("\
  723.         movw    %3,sp@-; \
  724.         movl    %2,sp@-; \
  725.         movw    %1,sp@-; \
  726.         trap    #1;    \
  727.         addqw   #8,sp "                        \
  728.     : "=r"(retvalue)            /* outputs */        \
  729.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  730.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  731.       AND_MEMORY                            \
  732.     );                                \
  733.     retvalue;                            \
  734. })
  735.  
  736. #define trap_1_wwll(n, a, b, c)                        \
  737. __extension__                                \
  738. ({                                    \
  739.     register long retvalue __asm__("d0");                \
  740.     short _a = (short)(a);                        \
  741.     long  _b = (long) (b);                        \
  742.     long  _c = (long) (c);                        \
  743.                                         \
  744.     __asm__ volatile                        \
  745.     ("\
  746.         movl    %4,sp@-; \
  747.         movl    %3,sp@-; \
  748.         movw    %2,sp@-; \
  749.         movw    %1,sp@-; \
  750.         trap    #1;    \
  751.         lea    sp@(12),sp "                    \
  752.     : "=r"(retvalue)            /* outputs */        \
  753.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  754.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  755.       AND_MEMORY                            \
  756.     );                                \
  757.     retvalue;                            \
  758. })
  759.  
  760. #define trap_1_wlww(n, a, b, c)                        \
  761. __extension__                                \
  762. ({                                    \
  763.     register long retvalue __asm__("d0");                \
  764.     long  _a = (long) (a);                        \
  765.     short _b = (short)(b);                        \
  766.     short _c = (short)(c);                        \
  767.                                         \
  768.     __asm__ volatile                        \
  769.     ("\
  770.         movw    %4,sp@-; \
  771.         movw    %3,sp@-; \
  772.         movl    %2,sp@-; \
  773.         movw    %1,sp@-; \
  774.         trap    #1;    \
  775.         lea    sp@(10),sp "                    \
  776.     : "=r"(retvalue)            /* outputs */        \
  777.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  778.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  779.       AND_MEMORY                            \
  780.     );                                \
  781.     retvalue;                            \
  782. })
  783.  
  784. #define trap_1_www(n, a, b)                        \
  785. __extension__                                \
  786. ({                                    \
  787.     register long retvalue __asm__("d0");                \
  788.     short _a = (short)(a);                        \
  789.     short _b = (short)(b);                        \
  790.                                         \
  791.     __asm__ volatile                        \
  792.     ("\
  793.         movw    %3,sp@-; \
  794.         movw    %2,sp@-; \
  795.         movw    %1,sp@-; \
  796.         trap    #1;    \
  797.         addqw   #6,sp "                        \
  798.     : "=r"(retvalue)            /* outputs */        \
  799.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  800.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  801.       AND_MEMORY                            \
  802.     );                                \
  803.     retvalue;                            \
  804. })
  805.  
  806. #define trap_1_wll(n, a, b)                        \
  807. __extension__                                \
  808. ({                                    \
  809.     register long retvalue __asm__("d0");                \
  810.     long  _a = (long) (a);                        \
  811.     long  _b = (long) (b);                        \
  812.                                         \
  813.     __asm__ volatile                        \
  814.     ("\
  815.         movl    %3,sp@-; \
  816.         movl    %2,sp@-; \
  817.         movw    %1,sp@-; \
  818.         trap    #1;    \
  819.         lea    sp@(10),sp "                    \
  820.     : "=r"(retvalue)            /* outputs */        \
  821.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  822.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  823.       AND_MEMORY                            \
  824.     );                                \
  825.     retvalue;                            \
  826. })
  827.  
  828. #if __GNUC__ > 1
  829. #define trap_1_wwlll(n, a, b, c, d)                    \
  830. __extension__                                \
  831. ({                                    \
  832.     register long retvalue __asm__("d0");                \
  833.     short _a = (short)(a);            \
  834.     long  _b = (long) (b);            \
  835.     long  _c = (long) (c);            \
  836.     long  _d = (long) (d);            \
  837.                                         \
  838.     __asm__ volatile                        \
  839.     ("\
  840.         movl    %5,sp@-; \
  841.         movl    %4,sp@-; \
  842.         movl    %3,sp@-; \
  843.         movw    %2,sp@-; \
  844.         movw    %1,sp@-; \
  845.         trap    #1;    \
  846.         lea    sp@(16),sp "                    \
  847.     : "=r"(retvalue)            /* outputs */        \
  848.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  849.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  850.     );                                \
  851.     retvalue;                            \
  852. })
  853.  
  854. #define trap_1_wwwll(n, a, b, c, d)                    \
  855. __extension__                                \
  856. ({                                    \
  857.     register long retvalue __asm__("d0");                \
  858.     short _a = (short)(a);                        \
  859.     short _b = (short)(b);                        \
  860.     long  _c = (long) (c);                        \
  861.     long  _d = (long) (d);                        \
  862.                                         \
  863.     __asm__ volatile                        \
  864.     ("\
  865.         movl    %5,sp@-; \
  866.         movl    %4,sp@-; \
  867.         movw    %3,sp@-; \
  868.         movw    %2,sp@-; \
  869.         movw    %1,sp@-; \
  870.         trap    #1;    \
  871.         lea    sp@(14),sp "                    \
  872.     : "=r"(retvalue)            /* outputs */        \
  873.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  874.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  875.     );                                \
  876.     retvalue;                            \
  877. })
  878. #else
  879. #define trap_1_wwlll(n, a, b, c, d)                    \
  880. ({                                    \
  881.     register long retvalue __asm__("d0");                \
  882.     short _a = (short)(a);            \
  883.     long  _b = (long) (b);            \
  884.     long  _c = (long) (c);            \
  885.     long  _d = (long) (d);            \
  886.                                         \
  887.     __asm__ volatile                        \
  888.     ("\
  889.         movl    %4,sp@-; \
  890.         movl    %3,sp@-; \
  891.         movl    %2,sp@-; \
  892.         movw    %1,sp@-; \
  893.         movw    %0,sp@- "                    \
  894.     :                         /* outputs */    \
  895.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  896.         );                                \
  897.   /* no more than 5 operand allowed in asm() -- therefore the split */  \
  898.                                     \
  899.     __asm__ volatile                        \
  900.     ("\
  901.         trap    #1;    \
  902.         lea    sp@(16),sp "                    \
  903.     : "=r"(retvalue)            /* outputs */        \
  904.     :                    /* inputs  */        \
  905.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  906.     );                                \
  907.     retvalue;                            \
  908. })
  909.  
  910. #define trap_1_wwwll(n, a, b, c, d)                    \
  911. ({                                    \
  912.     register long retvalue __asm__("d0");                \
  913.     short _a = (short)(a);                        \
  914.     short _b = (short)(b);                        \
  915.     long  _c = (long) (c);                        \
  916.     long  _d = (long) (d);                        \
  917.                                         \
  918.     __asm__ volatile                        \
  919.     ("\
  920.         movl    %4,sp@-; \
  921.         movl    %3,sp@-; \
  922.         movw    %2,sp@-; \
  923.         movw    %1,sp@-; \
  924.         movw    %0,sp@- "                    \
  925.     :                         /* outputs */    \
  926.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  927.         );                                \
  928.                                     \
  929.     __asm__ volatile                        \
  930.     ("\
  931.         trap    #1;    \
  932.         lea    sp@(14),sp "                    \
  933.     : "=r"(retvalue)            /* outputs */        \
  934.     :                    /* inputs  */        \
  935.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  936.     );                                \
  937.     retvalue;                            \
  938. })
  939. #endif
  940.  
  941. #define trap_13_wl(n, a)                        \
  942. __extension__                                \
  943. ({                                    \
  944.     register long retvalue __asm__("d0");                \
  945.     long  _a = (long) (a);                        \
  946.                                         \
  947.     __asm__ volatile                        \
  948.     ("\
  949.         movl    %2,sp@-; \
  950.         movw    %1,sp@-; \
  951.         trap    #13;    \
  952.         addqw   #6,sp "                        \
  953.     : "=r"(retvalue)            /* outputs */        \
  954.     : "g"(n), "r"(_a)            /* inputs  */        \
  955.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  956.       AND_MEMORY                            \
  957.     );                                \
  958.     retvalue;                            \
  959. })
  960.  
  961. #define trap_13_w(n)                            \
  962. __extension__                                \
  963. ({                                    \
  964.     register long retvalue __asm__("d0");                \
  965.                                         \
  966.     __asm__ volatile                        \
  967.     ("\
  968.         movw    %1,sp@-; \
  969.         trap    #13;    \
  970.         addqw   #2,sp "                        \
  971.     : "=r"(retvalue)            /* outputs */        \
  972.     : "g"(n)                /* inputs  */        \
  973.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  974.       AND_MEMORY                            \
  975.     );                                \
  976.     retvalue;                            \
  977. })
  978.  
  979. #define trap_13_ww(n, a)                        \
  980. __extension__                                \
  981. ({                                    \
  982.     register long retvalue __asm__("d0");                \
  983.     short _a = (short)(a);                        \
  984.                                         \
  985.     __asm__ volatile                        \
  986.     ("\
  987.         movw    %2,sp@-; \
  988.         movw    %1,sp@-; \
  989.         trap    #13;    \
  990.         addqw   #4,sp "                        \
  991.     : "=r"(retvalue)            /* outputs */        \
  992.     : "g"(n), "r"(_a)            /* inputs  */        \
  993.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  994.       AND_MEMORY                            \
  995.     );                                \
  996.     retvalue;                            \
  997. })
  998.  
  999. #define trap_13_www(n, a, b)                        \
  1000. __extension__                                \
  1001. ({                                    \
  1002.     register long retvalue __asm__("d0");                \
  1003.     short _a = (short)(a);                        \
  1004.     short _b = (short)(b);                        \
  1005.                                         \
  1006.     __asm__ volatile                        \
  1007.     ("\
  1008.         movw    %3,sp@-; \
  1009.         movw    %2,sp@-; \
  1010.         movw    %1,sp@-; \
  1011.         trap    #13;    \
  1012.         addqw   #6,sp "                        \
  1013.     : "=r"(retvalue)            /* outputs */        \
  1014.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  1015.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1016.       AND_MEMORY                            \
  1017.     );                                \
  1018.     retvalue;                            \
  1019. })
  1020.  
  1021. #if __GNUC__ > 1
  1022. #define trap_13_wwlwww(n, a, b, c, d, e)                \
  1023. __extension__                                \
  1024. ({                                    \
  1025.     register long retvalue __asm__("d0");                \
  1026.     short _a = (short)(a);            \
  1027.     long  _b = (long) (b);            \
  1028.     short _c = (short)(c);            \
  1029.     short _d = (short)(d);            \
  1030.     short _e = (short)(e);            \
  1031.                                         \
  1032.     __asm__ volatile                        \
  1033.     ("\
  1034.         movw    %6,sp@-; \
  1035.         movw    %5,sp@-; \
  1036.         movw    %4,sp@-; \
  1037.         movl    %3,sp@-; \
  1038.         movw    %2,sp@-; \
  1039.         movw    %1,sp@-; \
  1040.         trap    #13;    \
  1041.         lea    sp@(14),sp "                    \
  1042.     : "=r"(retvalue)            /* outputs */        \
  1043.     : "g"(n),                            \
  1044.       "r"(_a), "r"(_b), "r"(_c), "r"(_d), "r"(_e) /* inputs  */    \
  1045.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1046.     );                                \
  1047.     retvalue;                            \
  1048. })
  1049. #else
  1050. #define trap_13_wwlwww(n, a, b, c, d, e)                \
  1051. ({                                    \
  1052.     register long retvalue __asm__("d0");                \
  1053.     short _a = (short)(a);            \
  1054.     long  _b = (long) (b);            \
  1055.     short _c = (short)(c);            \
  1056.     short _d = (short)(d);            \
  1057.     short _e = (short)(e);            \
  1058.                                         \
  1059.     __asm__ volatile                        \
  1060.     ("\
  1061.         movw    %4,sp@-; \
  1062.         movw    %3,sp@-; \
  1063.         movw    %2,sp@-; \
  1064.         movl    %1,sp@-; \
  1065.         movw    %0,sp@-    "                    \
  1066.     :                          /* outputs */    \
  1067.     : "r"(_a), "r"(_b), "r"(_c), "r"(_d), "r"(_e) /* inputs  */    \
  1068.     );                                \
  1069.                                     \
  1070.     __asm__ volatile                        \
  1071.     ("\
  1072.         movw    %1,sp@-; \
  1073.         trap    #13;    \
  1074.         lea    sp@(14),sp "                    \
  1075.     : "=r"(retvalue)            /* outputs */        \
  1076.     : "g"(n)                /* inputs  */        \
  1077.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1078.     );                                \
  1079.     retvalue;                            \
  1080. })
  1081. #endif
  1082.  
  1083. #define trap_13_wwl(n, a, b)                        \
  1084. __extension__                                \
  1085. ({                                    \
  1086.     register long retvalue __asm__("d0");                \
  1087.     short _a = (short)(a);                        \
  1088.     long  _b = (long) (b);                        \
  1089.                                         \
  1090.     __asm__ volatile                        \
  1091.     ("\
  1092.         movl    %3,sp@-; \
  1093.         movw    %2,sp@-; \
  1094.         movw    %1,sp@-; \
  1095.         trap    #13;    \
  1096.         addqw   #8,sp "                        \
  1097.     : "=r"(retvalue)            /* outputs */        \
  1098.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  1099.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1100.       AND_MEMORY                            \
  1101.     );                                \
  1102.     retvalue;                            \
  1103. })
  1104.  
  1105. #define trap_14_wwl(n, a, b)                        \
  1106. __extension__                                \
  1107. ({                                    \
  1108.     register long retvalue __asm__("d0");                \
  1109.     short _a = (short)(a);                        \
  1110.     long  _b = (long) (b);                        \
  1111.                                         \
  1112.     __asm__ volatile                        \
  1113.     ("\
  1114.         movl    %3,sp@-; \
  1115.         movw    %2,sp@-; \
  1116.         movw    %1,sp@-; \
  1117.         trap    #14;    \
  1118.         addqw   #8,sp "                        \
  1119.     : "=r"(retvalue)            /* outputs */        \
  1120.     : "g"(n), "r"(_a), "r"(_b)              /* inputs  */        \
  1121.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1122.       AND_MEMORY                            \
  1123.     );                                \
  1124.     retvalue;                            \
  1125. })
  1126.  
  1127. #define trap_14_wwll(n, a, b, c)                    \
  1128. __extension__                                \
  1129. ({                                    \
  1130.     register long retvalue __asm__("d0");                \
  1131.     short _a = (short)(a);                        \
  1132.     long  _b = (long) (b);                        \
  1133.     long  _c = (long) (c);                        \
  1134.                                         \
  1135.     __asm__ volatile                        \
  1136.     ("\
  1137.         movl    %4,sp@-; \
  1138.         movl    %3,sp@-; \
  1139.         movw    %2,sp@-; \
  1140.         movw    %1,sp@-; \
  1141.         trap    #14;    \
  1142.         lea    sp@(12),sp "                    \
  1143.     : "=r"(retvalue)            /* outputs */        \
  1144.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  1145.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1146.       AND_MEMORY                            \
  1147.     );                                \
  1148.     retvalue;                            \
  1149. })
  1150.  
  1151. #define trap_14_ww(n, a)                        \
  1152. __extension__                                \
  1153. ({                                    \
  1154.     register long retvalue __asm__("d0");                \
  1155.     short _a = (short)(a);                        \
  1156.                                         \
  1157.     __asm__ volatile                        \
  1158.     ("\
  1159.         movw    %2,sp@-; \
  1160.         movw    %1,sp@-; \
  1161.         trap    #14;    \
  1162.         addqw   #4,sp "                        \
  1163.     : "=r"(retvalue)            /* outputs */        \
  1164.     : "g"(n), "r"(_a)            /* inputs  */        \
  1165.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1166.       AND_MEMORY                            \
  1167.     );                                \
  1168.     retvalue;                            \
  1169. })
  1170.  
  1171. #define trap_14_w(n)                            \
  1172. __extension__                                \
  1173. ({                                    \
  1174.     register long retvalue __asm__("d0");                \
  1175.                                         \
  1176.     __asm__ volatile                        \
  1177.     ("\
  1178.         movw    %1,sp@-; \
  1179.         trap    #14;    \
  1180.         addqw   #2,sp "                        \
  1181.     : "=r"(retvalue)            /* outputs */        \
  1182.     : "g"(n)                /* inputs  */        \
  1183.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1184.       AND_MEMORY                            \
  1185.     );                                \
  1186.     retvalue;                            \
  1187. })
  1188.  
  1189. #define trap_14_wllw(n, a, b, c)                    \
  1190. __extension__                                \
  1191. ({                                    \
  1192.     register long retvalue __asm__("d0");                \
  1193.     long  _a = (long) (a);                        \
  1194.     long  _b = (long) (b);                        \
  1195.     short _c = (short)(c);                        \
  1196.                                         \
  1197.     __asm__ volatile                        \
  1198.     ("\
  1199.         movw    %4,sp@-; \
  1200.         movl    %3,sp@-; \
  1201.         movl    %2,sp@-; \
  1202.         movw    %1,sp@-; \
  1203.         trap    #14;    \
  1204.         lea    sp@(12),sp "                    \
  1205.     : "=r"(retvalue)            /* outputs */        \
  1206.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)       /* inputs  */        \
  1207.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1208.       AND_MEMORY                            \
  1209.     );                                \
  1210.     retvalue;                            \
  1211. })
  1212.  
  1213. #define trap_14_wl(n, a)                        \
  1214. __extension__                                \
  1215. ({                                    \
  1216.     register long retvalue __asm__("d0");                \
  1217.     long  _a = (long) (a);                        \
  1218.                                         \
  1219.     __asm__ volatile                        \
  1220.     ("\
  1221.         movl    %2,sp@-; \
  1222.         movw    %1,sp@-; \
  1223.         trap    #14;    \
  1224.         addqw   #6,sp "                        \
  1225.     : "=r"(retvalue)            /* outputs */        \
  1226.     : "g"(n), "r"(_a)            /* inputs  */        \
  1227.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1228.       AND_MEMORY                            \
  1229.     );                                \
  1230.     retvalue;                            \
  1231. })
  1232.  
  1233. #define trap_14_www(n, a, b)                        \
  1234. __extension__                                \
  1235. ({                                    \
  1236.     register long retvalue __asm__("d0");                \
  1237.     short _a = (short)(a);                        \
  1238.     short _b = (short)(b);                        \
  1239.                                         \
  1240.     __asm__ volatile                        \
  1241.     ("\
  1242.         movw    %3,sp@-; \
  1243.         movw    %2,sp@-; \
  1244.         movw    %1,sp@-; \
  1245.         trap    #14;    \
  1246.         addqw   #6,sp "                        \
  1247.     : "=r"(retvalue)            /* outputs */        \
  1248.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  1249.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1250.       AND_MEMORY                            \
  1251.     );                                \
  1252.     retvalue;                            \
  1253. })
  1254.  
  1255. #if __GNUC__ > 1
  1256. #define trap_14_wllwwwww(n, a, b, c, d, e, f, g)            \
  1257. __extension__                                \
  1258. ({                                    \
  1259.     register long retvalue __asm__("d0");                \
  1260.     long  _a = (long) (a);                        \
  1261.     long  _b = (long) (b);                        \
  1262.     short _c = (short)(c);                        \
  1263.     short _d = (short)(d);                        \
  1264.     short _e = (short)(e);                        \
  1265.     short _f = (short)(f);                        \
  1266.     short _g = (short)(g);                        \
  1267.                                         \
  1268.     __asm__ volatile                        \
  1269.     ("\
  1270.         movw    %8,sp@-; \
  1271.         movw    %7,sp@-; \
  1272.         movw    %6,sp@-; \
  1273.         movw    %5,sp@-; \
  1274.         movw    %4,sp@-; \
  1275.         movl    %3,sp@-; \
  1276.         movl    %2,sp@-; \
  1277.         movw    %1,sp@-; \
  1278.         trap    #14;    \
  1279.         lea    sp@(20),sp "                    \
  1280.     : "=r"(retvalue)            /* outputs */        \
  1281.     : "g"(n), "r"(_a), "r"(_b),                    \
  1282.       "r"(_c), "r"(_d), "r"(_e), "r"(_f), "r"(_g) /* inputs  */    \
  1283.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1284.     );                                \
  1285.     retvalue;                            \
  1286. })
  1287.  
  1288. #define trap_14_wllwwwwlw(n, a, b, c, d, e, f, g, h)            \
  1289. __extension__                                \
  1290. ({                                    \
  1291.     register long retvalue __asm__("d0");                \
  1292.     long  _a = (long) (a);                        \
  1293.     long  _b = (long) (b);                        \
  1294.     short _c = (short)(c);                        \
  1295.     short _d = (short)(d);                        \
  1296.     short _e = (short)(e);                        \
  1297.     short _f = (short)(f);                        \
  1298.     long  _g = (long) (g);                        \
  1299.     short _h = (short)(h);                        \
  1300.                                         \
  1301.     __asm__ volatile                        \
  1302.     ("\
  1303.         movw    %9,sp@-; \
  1304.         movl    %8,sp@-; \
  1305.         movw    %7,sp@-; \
  1306.         movw    %6,sp@-; \
  1307.         movw    %5,sp@-; \
  1308.         movw    %4,sp@-; \
  1309.         movl    %3,sp@-; \
  1310.         movl    %2,sp@-; \
  1311.         movw    %1,sp@-; \
  1312.         trap    #14;    \
  1313.         lea    sp@(24),sp "                    \
  1314.     : "=r"(retvalue)               /* outputs */    \
  1315.     : "g"(n), "r"(_a), "r"(_b), "r"(_c),                \
  1316.       "r"(_d), "r"(_e), "r"(_f), "r"(_g), "r"(_h) /* inputs  */    \
  1317.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1318.     );                                \
  1319.     retvalue;                            \
  1320. })
  1321.  
  1322. #define trap_14_wllwwwwwlw(n, a, b, c, d, e, f, g, h, i)        \
  1323. __extension__                                \
  1324. ({                                    \
  1325.     register long retvalue __asm__("d0");                \
  1326.     long  _a = (long) (a);                        \
  1327.     long  _b = (long) (b);                        \
  1328.     short _c = (short)(c);                        \
  1329.     short _d = (short)(d);                        \
  1330.     short _e = (short)(e);                        \
  1331.     short _f = (short)(f);                        \
  1332.     short _g = (short)(g);                        \
  1333.     long  _h = (long) (h);                        \
  1334.     short _i = (short)(i);                        \
  1335.                                         \
  1336.     __asm__ volatile                        \
  1337.     ("\
  1338.         movw    %9,sp@-; \
  1339.         movl    %8,sp@-; \
  1340.         movw    %7,sp@-; \
  1341.         movw    %6,sp@-; \
  1342.         movw    %5,sp@-; \
  1343.         movw    %4,sp@-; \
  1344.         movw    %3,sp@-; \
  1345.         movl    %2,sp@-; \
  1346.         movl    %1,sp@-; \
  1347.                 movw    %0,sp@- "                    \
  1348.     :                          /* outputs */    \
  1349.     : "g"(n), "g"(_a), "g"(_b), "g"(_c), "g"(_d),            \
  1350.       "g"(_e), "g"(_f), "g"(_g), "g"(_h), "g"(_i) /* inputs  */    \
  1351.     );                                \
  1352.                                         \
  1353.     __asm__ volatile                        \
  1354.     ("\
  1355.         trap    #14;    \
  1356.         lea    sp@(26),sp "                    \
  1357.     : "=r"(retvalue)            /* outputs */        \
  1358.     :                     /* inputs  */        \
  1359.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1360.     );                                \
  1361.     retvalue;                            \
  1362. })
  1363.  
  1364.  
  1365. #define trap_14_wwwwwww(n, a, b, c, d, e, f)                \
  1366. __extension__                                \
  1367. ({                                    \
  1368.     register long retvalue __asm__("d0");                \
  1369.     short _a = (short)(a);                        \
  1370.     short _b = (short)(b);                        \
  1371.     short _c = (short)(c);                        \
  1372.     short _d = (short)(d);                        \
  1373.     short _e = (short)(e);                        \
  1374.     short _f = (short)(f);                        \
  1375.                                         \
  1376.     __asm__ volatile                        \
  1377.     ("\
  1378.         movw    %7,sp@-; \
  1379.         movw    %6,sp@-; \
  1380.         movw    %5,sp@-; \
  1381.         movw    %4,sp@-; \
  1382.         movw    %3,sp@-; \
  1383.         movw    %2,sp@-; \
  1384.         movw    %1,sp@-; \
  1385.         trap    #14;    \
  1386.         lea    sp@(14),sp "                    \
  1387.     : "=r"(retvalue)            /* outputs */        \
  1388.     : "g"(n), "g"(_a),                        \
  1389.       "g"(_b), "g"(_c), "g"(_d), "g"(_e), "g"(_f)    /* inputs  */    \
  1390.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1391.     );                                \
  1392.     retvalue;                            \
  1393. })
  1394. #else
  1395. #define trap_14_wllwwwww(n, a, b, c, d, e, f, g)            \
  1396. ({                                    \
  1397.     register long retvalue __asm__("d0");                \
  1398.     long  _a = (long) (a);                        \
  1399.     long  _b = (long) (b);                        \
  1400.     short _c = (short)(c);                        \
  1401.     short _d = (short)(d);                        \
  1402.     short _e = (short)(e);                        \
  1403.     short _f = (short)(f);                        \
  1404.     short _g = (short)(g);                        \
  1405.                                         \
  1406.     __asm__ volatile                        \
  1407.     ("\
  1408.         movw    %4,sp@-; \
  1409.         movw    %3,sp@-; \
  1410.         movw    %2,sp@-; \
  1411.         movw    %1,sp@-; \
  1412.         movw    %0,sp@-    "                    \
  1413.     :                          /* outputs */    \
  1414.     : "r"(_c), "r"(_d), "r"(_e), "r"(_f), "r"(_g) /* inputs  */    \
  1415.     );                                \
  1416.                                     \
  1417.     __asm__ volatile                        \
  1418.     ("\
  1419.         movl    %3,sp@-; \
  1420.         movl    %2,sp@-; \
  1421.         movw    %1,sp@-; \
  1422.         trap    #14;    \
  1423.         lea    sp@(20),sp "                    \
  1424.     : "=r"(retvalue)            /* outputs */        \
  1425.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  1426.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1427.     );                                \
  1428.     retvalue;                            \
  1429. })
  1430.  
  1431. #define trap_14_wllwwwwlw(n, a, b, c, d, e, f, g, h)            \
  1432. ({                                    \
  1433.     register long retvalue __asm__("d0");                \
  1434.     long  _a = (long) (a);                        \
  1435.     long  _b = (long) (b);                        \
  1436.     short _c = (short)(c);                        \
  1437.     short _d = (short)(d);                        \
  1438.     short _e = (short)(e);                        \
  1439.     short _f = (short)(f);                        \
  1440.     long  _g = (long) (g);                        \
  1441.     short _h = (short)(h);                        \
  1442.                                         \
  1443.     __asm__ volatile                        \
  1444.     ("\
  1445.         movw    %4,sp@-; \
  1446.         movl    %3,sp@-; \
  1447.         movw    %2,sp@-; \
  1448.         movw    %1,sp@-; \
  1449.         movw    %0,sp@- "                    \
  1450.     :                          /* outputs */    \
  1451.     : "r"(_d), "r"(_e), "r"(_f), "r"(_g), "r"(_h) /* inputs  */    \
  1452.     );                                \
  1453.                                         \
  1454.     __asm__ volatile                        \
  1455.     ("\
  1456.         movw    %4,sp@-; \
  1457.         movl    %3,sp@-; \
  1458.         movl    %2,sp@-; \
  1459.         movw    %1,sp@-; \
  1460.         trap    #14;    \
  1461.         lea    sp@(24),sp "                    \
  1462.     : "=r"(retvalue)               /* outputs */    \
  1463.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)        /* inputs  */    \
  1464.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1465.     );                                \
  1466.     retvalue;                            \
  1467. })
  1468.  
  1469. #define trap_14_wllwwwwwlw(n, a, b, c, d, e, f, g, h, i)        \
  1470. ({                                    \
  1471.     register long retvalue __asm__("d0");                \
  1472.     long  _a = (long) (a);                        \
  1473.     long  _b = (long) (b);                        \
  1474.     short _c = (short)(c);                        \
  1475.     short _d = (short)(d);                        \
  1476.     short _e = (short)(e);                        \
  1477.     short _f = (short)(f);                        \
  1478.     short _g = (short)(g);                        \
  1479.     long  _h = (long) (h);                        \
  1480.     short _i = (short)(i);                        \
  1481.                                         \
  1482.     __asm__ volatile                        \
  1483.     ("\
  1484.         movw    %4,sp@-; \
  1485.         movl    %3,sp@-; \
  1486.         movw    %2,sp@-; \
  1487.         movw    %1,sp@-; \
  1488.         movw    %0,sp@- "                    \
  1489.     :                          /* outputs */    \
  1490.     : "r"(_e), "r"(_f), "r"(_g), "r"(_h), "r"(_i) /* inputs  */    \
  1491.     );                                \
  1492.                                     \
  1493.     __asm__ volatile                        \
  1494.     ("\
  1495.         movw    %4,sp@-; \
  1496.         movw    %3,sp@-; \
  1497.         movl    %2,sp@-; \
  1498.         movl    %1,sp@-; \
  1499.                 movw    %0,sp@- "                    \
  1500.     :                         /* outputs */    \
  1501.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  1502.     );                                \
  1503.                                         \
  1504.     __asm__ volatile                        \
  1505.     ("\
  1506.         trap    #14;    \
  1507.         lea    sp@(26),sp "                    \
  1508.     : "=r"(retvalue)            /* outputs */        \
  1509.     :                     /* inputs  */        \
  1510.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1511.     );                                \
  1512.     retvalue;                            \
  1513. })
  1514.  
  1515.  
  1516. #define trap_14_wwwwwww(n, a, b, c, d, e, f)                \
  1517. ({                                    \
  1518.     register long retvalue __asm__("d0");                \
  1519.     short _a = (short)(a);                        \
  1520.     short _b = (short)(b);                        \
  1521.     short _c = (short)(c);                        \
  1522.     short _d = (short)(d);                        \
  1523.     short _e = (short)(e);                        \
  1524.     short _f = (short)(f);                        \
  1525.                                         \
  1526.     __asm__ volatile                        \
  1527.     ("\
  1528.         movw    %4,sp@-; \
  1529.         movw    %3,sp@-; \
  1530.         movw    %2,sp@-; \
  1531.         movw    %1,sp@-; \
  1532.         movw    %0,sp@- "                    \
  1533.     :                            /* outputs */    \
  1534.     : "r"(_b), "r"(_c), "r"(_d), "r"(_e), "r"(_f)    /* inputs  */    \
  1535.     );                                \
  1536.                                     \
  1537.     __asm__ volatile                        \
  1538.     ("\
  1539.         movw    %2,sp@-; \
  1540.         movw    %1,sp@-; \
  1541.         trap    #14;    \
  1542.         lea    sp@(14),sp "                    \
  1543.     : "=r"(retvalue)            /* outputs */        \
  1544.     : "g"(n), "r"(_a)            /* inputs  */        \
  1545.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1546.     );                                \
  1547.     retvalue;                            \
  1548. })
  1549. #endif
  1550.  
  1551. #define trap_14_wlll(n, a, b, c)                    \
  1552. __extension__                                \
  1553. ({                                    \
  1554.     register long retvalue __asm__("d0");                \
  1555.     long  _a = (long) (a);                        \
  1556.     long  _b = (long) (b);                        \
  1557.     long  _c = (long) (c);                        \
  1558.                                         \
  1559.     __asm__ volatile                        \
  1560.     ("\
  1561.         movl    %4,sp@-; \
  1562.         movl    %3,sp@-; \
  1563.         movl    %2,sp@-; \
  1564.         movw    %1,sp@-; \
  1565.         trap    #14;    \
  1566.         lea    sp@(14),sp "                    \
  1567.     : "=r"(retvalue)            /* outputs */        \
  1568.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  1569.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1570.       AND_MEMORY                            \
  1571.     );                                \
  1572.     retvalue;                            \
  1573. })
  1574.  
  1575. #if __GNUC__ > 1
  1576. #define trap_14_wllww(n, a, b, c, d)                    \
  1577. __extension__                                \
  1578. ({                                    \
  1579.     register long retvalue __asm__("d0");                \
  1580.     long  _a = (long) (a);                        \
  1581.     long  _b = (long) (b);                        \
  1582.     short _c = (short)(c);                        \
  1583.     short _d = (short)(d);                        \
  1584.                                         \
  1585.     __asm__ volatile                        \
  1586.     ("\
  1587.         movw    %5,sp@-; \
  1588.         movw    %4,sp@-; \
  1589.         movl    %3,sp@-; \
  1590.         movl    %2,sp@-; \
  1591.         movw    %1,sp@-; \
  1592.         trap    #14;    \
  1593.         lea    sp@(14),sp "                    \
  1594.     : "=r"(retvalue)            /* outputs */        \
  1595.     : "g"(n),                            \
  1596.       "r"(_a), "r"(_b), "r"(_c), "r"(_d)    /* inputs  */        \
  1597.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1598.     );                                \
  1599.     retvalue;                            \
  1600. })
  1601.  
  1602. #define trap_14_wwwwl(n, a, b, c, d)                    \
  1603. __extension__                                \
  1604. ({                                    \
  1605.     register long retvalue __asm__("d0");                \
  1606.     short _a = (short)(a);                        \
  1607.     short _b = (short)(b);                        \
  1608.     short _c = (short)(c);                        \
  1609.     long  _d = (long) (d);                        \
  1610.                                         \
  1611.     __asm__ volatile                        \
  1612.     ("\
  1613.         movl    %5,sp@-; \
  1614.         movw    %4,sp@-; \
  1615.         movw    %3,sp@-; \
  1616.         movw    %2,sp@-; \
  1617.         movw    %1,sp@-; \
  1618.         trap    #14;    \
  1619.         lea    sp@(12),sp "                    \
  1620.     : "=r"(retvalue)            /* outputs */        \
  1621.     : "g"(n),                            \
  1622.       "r"(_a), "r"(_b), "r"(_c), "r"(_d)        /* inputs  */    \
  1623.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1624.     );                                \
  1625.     retvalue;                            \
  1626. })
  1627. #else
  1628. #define trap_14_wllww(n, a, b, c, d)                    \
  1629. ({                                    \
  1630.     register long retvalue __asm__("d0");                \
  1631.     long  _a = (long) (a);                        \
  1632.     long  _b = (long) (b);                        \
  1633.     short _c = (short)(c);                        \
  1634.     short _d = (short)(d);                        \
  1635.                                         \
  1636.     __asm__ volatile                        \
  1637.     ("\
  1638.         movw    %3,sp@-; \
  1639.         movw    %2,sp@-; \
  1640.         movl    %1,sp@-; \
  1641.         movl    %0,sp@- "                    \
  1642.     :                    /* outputs */        \
  1643.     : "r"(_a), "r"(_b), "r"(_c), "r"(_d)    /* inputs  */        \
  1644.     );                                \
  1645.                                     \
  1646.     __asm__ volatile                        \
  1647.     ("\
  1648.         movw    %1,sp@-; \
  1649.         trap    #14;    \
  1650.         lea    sp@(14),sp "                    \
  1651.     : "=r"(retvalue)            /* outputs */        \
  1652.     : "g"(n)                /* inputs  */        \
  1653.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1654.     );                                \
  1655.     retvalue;                            \
  1656. })
  1657.  
  1658. #define trap_14_wwwwl(n, a, b, c, d)                    \
  1659. ({                                    \
  1660.     register long retvalue __asm__("d0");                \
  1661.     short _a = (short)(a);                        \
  1662.     short _b = (short)(b);                        \
  1663.     short _c = (short)(c);                        \
  1664.     long  _d = (long) (d);                        \
  1665.                                         \
  1666.     __asm__ volatile                        \
  1667.     ("\
  1668.         movl    %3,sp@-; \
  1669.         movw    %2,sp@-; \
  1670.         movw    %1,sp@-; \
  1671.         movw    %0,sp@- "                    \
  1672.     :                        /* outputs */    \
  1673.     : "r"(_a), "r"(_b), "r"(_c), "r"(_d)        /* inputs  */    \
  1674.     );                                \
  1675.                                     \
  1676.     __asm__ volatile                        \
  1677.     ("\
  1678.         movw    %1,sp@-; \
  1679.         trap    #14;    \
  1680.         lea    sp@(12),sp "                    \
  1681.     : "=r"(retvalue)            /* outputs */        \
  1682.     : "g"(n)                /* inputs  */        \
  1683.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1684.     );                                \
  1685.     retvalue;                            \
  1686. })
  1687. #endif
  1688.  
  1689. #define trap_14_wwwl(n, a, b, c)                    \
  1690. __extension__                                \
  1691. ({                                    \
  1692.     register long retvalue __asm__("d0");                \
  1693.     short _a = (short)(a);                        \
  1694.     short _b = (short)(b);                        \
  1695.     long  _c = (long)(c);                        \
  1696.                                         \
  1697.     __asm__ volatile                        \
  1698.     ("                                \
  1699.         movl    %4,sp@-;                    \
  1700.         movw    %3,sp@-;                    \
  1701.         movw    %2,sp@-;                    \
  1702.         movw    %1,sp@-;                    \
  1703.         trap    #14;                        \
  1704.         lea    sp@(10),sp "                    \
  1705.     : "=r"(retvalue)            /* outputs */        \
  1706.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)    /* inputs  */        \
  1707.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1708.       AND_MEMORY                            \
  1709.     );                                \
  1710.     retvalue;                            \
  1711. })
  1712.  
  1713. #if __GNUC__ > 1
  1714. #define trap_14_wlwlw(n, a, b, c, d)                    \
  1715. __extension__                                \
  1716. ({                                    \
  1717.     register long retvalue __asm__("d0");                \
  1718.     long  _a = (long) (a);                        \
  1719.     short _b = (short)(b);                        \
  1720.     long  _c = (long) (c);                        \
  1721.     short _d = (short)(d);                        \
  1722.                                         \
  1723.     __asm__ volatile                        \
  1724.     ("\
  1725.         movw    %5,sp@-; \
  1726.         movl    %4,sp@-; \
  1727.         movw    %3,sp@-; \
  1728.         movl    %2,sp@-; \
  1729.         movw    %1,sp@-; \
  1730.         trap    #14;    \
  1731.         lea    sp@(14),sp "                    \
  1732.     : "=r"(retvalue)            /* outputs */        \
  1733.     : "g"(n),                            \
  1734.       "r"(_a), "r"(_b), "r"(_c), "r"(_d)    /* inputs  */        \
  1735.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1736.     );                                \
  1737.     retvalue;                            \
  1738. })
  1739. #else
  1740. #define trap_14_wlwlw(n, a, b, c, d)                    \
  1741. ({                                    \
  1742.     register long retvalue __asm__("d0");                \
  1743.     long  _a = (long) (a);                        \
  1744.     short _b = (short)(b);                        \
  1745.     long  _c = (long) (c);                        \
  1746.     short _d = (short)(d);                        \
  1747.                                         \
  1748.     __asm__ volatile                        \
  1749.     ("\
  1750.         movw    %4,sp@-; \
  1751.         movl    %3,sp@-; \
  1752.         movw    %2,sp@-; \
  1753.         movl    %1,sp@-; \
  1754.         movw    %0,sp@-;" \
  1755.     :                    /* outputs */        \
  1756.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  1757.     );                                \
  1758.                                     \
  1759.     __asm__ volatile                        \
  1760.     ("\
  1761.         trap    #14;    \
  1762.         lea    sp@(14),sp "                    \
  1763.     : "=r"(retvalue)            /* outputs */        \
  1764.     :                    /* inputs  */        \
  1765.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1766.     );                                \
  1767.     retvalue;                            \
  1768. })
  1769. #endif
  1770.  
  1771. #else /* __GNUC_INLINE__ */
  1772.  
  1773. # ifndef __MSHORT__
  1774. #  define _TRAP_X_
  1775. # else
  1776. #  ifdef __GNUC__
  1777. #   ifndef __MINT__
  1778. #    define _TRAP_X_
  1779. #   endif
  1780. #  endif
  1781. # endif /* !__MSHORT__ */
  1782.  
  1783. # ifdef _TRAP_X_
  1784. /* if inlines are not allowed, then declare things external */
  1785. __EXTERN long trap_1_w __PROTO((short n));
  1786. __EXTERN long trap_1_ww __PROTO((short n, short a));
  1787. __EXTERN long trap_1_wl __PROTO((short n, long a));
  1788. __EXTERN long trap_1_wlw __PROTO((short n, long a, short b));
  1789. __EXTERN long trap_1_wwll __PROTO((short n, short a, long b, long c));
  1790. __EXTERN long trap_1_wlww __PROTO((short n, long a, short b, short c));
  1791. __EXTERN long trap_1_www __PROTO((short n, short a, short b));
  1792. __EXTERN long trap_1_wll __PROTO((short n, long a, long b));
  1793. __EXTERN long trap_1_wwlll __PROTO((short n, short a, long b, long c, long d));
  1794. __EXTERN long trap_1_wwwll __PROTO((short n, short a, short b, long c, long d));
  1795. __EXTERN long trap_13_wl __PROTO((short n, long a));
  1796. __EXTERN long trap_13_w __PROTO((short n));
  1797. __EXTERN long trap_13_ww __PROTO((short n, short a));
  1798. __EXTERN long trap_13_www __PROTO((short n, short a, short b));
  1799. __EXTERN long trap_13_wwlwww __PROTO((short n, short a, long b, short c, short d, short e));
  1800. __EXTERN long trap_13_wwl __PROTO((short n, short a, long b));
  1801. __EXTERN long trap_14_wwl __PROTO((short n, short a, long b));
  1802. __EXTERN long trap_14_wwll __PROTO((short n, short a, long b, long c));
  1803. __EXTERN long trap_14_ww __PROTO((short n, short a));
  1804. __EXTERN long trap_14_w __PROTO((short n));
  1805. __EXTERN long trap_14_wllw __PROTO((short n, long a, long b, short c));
  1806. __EXTERN long trap_14_wl __PROTO((short n, long a));
  1807. __EXTERN long trap_14_www __PROTO((short n, short a, short b));
  1808. __EXTERN long trap_14_wllwwwww __PROTO((short n, long a, long b, short c, short d, short e, short f, short g));
  1809. __EXTERN long trap_14_wllwwwwlw __PROTO((short n, long a, long b, short c, short d, short e, short f, long g, short h));
  1810. __EXTERN long trap_14_wllwwwwwlw __PROTO((short n, long a, long b, short c, short d, short e, short f, short g, long h, short i));
  1811. __EXTERN long trap_14_wwwwwww __PROTO((short n, short a, short b, short c, short d, short e, short f));
  1812. __EXTERN long trap_14_wlll __PROTO((short n, long a, long b, long c));
  1813. __EXTERN long trap_14_wllww __PROTO((short n, long a, long b, short c, short d));
  1814. __EXTERN long trap_14_wwwwl __PROTO((short n, short a, short b, short c, long d));
  1815. __EXTERN long trap_14_wwwl __PROTO((short n, short a, short b, long c));
  1816. __EXTERN long trap_14_wlwlw __PROTO((short n, long a, short b, long c, short d));
  1817.  
  1818. # else /* __TRAP_X__ */
  1819.  
  1820. __EXTERN long gemdos    __PROTO((short, ...));
  1821. __EXTERN long bios    __PROTO((short, ...));
  1822. __EXTERN long xbios    __PROTO((short, ...));
  1823.  
  1824. #define trap_1_w    gemdos
  1825. #define trap_1_ww    gemdos
  1826. #define trap_1_wl    gemdos
  1827. #define trap_1_wlw    gemdos
  1828. #define trap_1_www    gemdos
  1829. #define trap_1_wll    gemdos
  1830. #define trap_1_wwll    gemdos
  1831. #define trap_1_wlww    gemdos
  1832. #define trap_1_wwlll    gemdos
  1833. #define trap_1_wwwll    gemdos
  1834.  
  1835. #define trap_13_w    bios
  1836. #define trap_13_ww    bios
  1837. #define trap_13_wl    bios
  1838. #define trap_13_www    bios
  1839. #define trap_13_wwl    bios
  1840. #define trap_13_wwlwww    bios
  1841.  
  1842. #define trap_14_w    xbios
  1843. #define trap_14_ww    xbios
  1844. #define trap_14_wl    xbios
  1845. #define trap_14_www    xbios
  1846. #define trap_14_wwl    xbios
  1847. #define trap_14_wwll    xbios
  1848. #define trap_14_wllw    xbios
  1849. #define trap_14_wlll    xbios
  1850. #define trap_14_wwwl    xbios
  1851. #define trap_14_wwwwl    xbios
  1852. #define trap_14_wllww    xbios
  1853. #define trap_14_wwwwwww    xbios
  1854. #define trap_14_wllwwwww    xbios
  1855. #define trap_14_wllwwwwlw    xbios
  1856. #define trap_14_wllwwwwwlw    xbios
  1857. #define trap_14_wlwlw    xbios
  1858.  
  1859. # endif /* _TRAP_X_ */
  1860.  
  1861. #endif /* __GNUC_INLINE__ */
  1862.  
  1863.  
  1864. /* DEFINITIONS FOR OS FUNCTIONS */
  1865.  
  1866. /*
  1867.  *     GEMDOS  (trap1)
  1868.  */
  1869. #define           Pterm0()                                      \
  1870.        (void)trap_1_w((short)(0x00))
  1871. #define           Cconin()                               \
  1872.        (long)trap_1_w((short)(0x01))
  1873. #define           Cconout(c)                           \
  1874.        (void)trap_1_ww((short)(0x02),(short)(c))
  1875. #define           Cauxin()                               \
  1876.        (long)trap_1_w((short)(0x03))
  1877. #define           Cauxout(c)                           \
  1878.        (void)trap_1_ww((short)(0x04),(short)(c))
  1879. #define           Cprnout(c)                           \
  1880.        (void)trap_1_ww((short)(0x05),(short)(c))
  1881. #define           Crawio(data)                           \
  1882.        (long)trap_1_ww((short)(0x06),(short)(data))
  1883. #define           Crawcin()                           \
  1884.        (long)trap_1_w((short)(0x07))
  1885. #define           Cnecin()                               \
  1886.        (long)trap_1_w((short)(0x08))
  1887. #define           Cconws(s)                           \
  1888.        (void)trap_1_wl((short)(0x09),(long)(s))
  1889. #define           Cconrs(buf)                           \
  1890.        (void)trap_1_wl((short)(0x0A),(long)(buf))
  1891. #define           Cconis()                               \
  1892.        (short)trap_1_w((short)(0x0B))
  1893. #define           Dsetdrv(d)                           \
  1894.        (long)trap_1_ww((short)(0x0E),(short)(d))
  1895. #define           Cconos()                               \
  1896.        (short)trap_1_w((short)(0x10))
  1897. #define           Cprnos()                               \
  1898.        (short)trap_1_w((short)(0x11))
  1899. #define           Cauxis()                               \
  1900.        (short)trap_1_w((short)(0x12))
  1901. #define           Cauxos()                               \
  1902.        (short)trap_1_w((short)(0x13))
  1903. #define           Dgetdrv()                           \
  1904.        (short)trap_1_w((short)(0x19))
  1905. #define           Fsetdta(dta)                           \
  1906.        (void)trap_1_wl((short)(0x1A),(long)(dta))
  1907.  
  1908. /*
  1909.  * The next binding is not quite right if used in another than the usual ways:
  1910.  *    1. Super(1L) from either user or supervisor mode
  1911.  *    2. ret = Super(0L) from user mode and after this Super(ret) from
  1912.  *       supervisor mode
  1913.  * We get the following situations (usp, ssp relative to the start of Super):
  1914.  *    Parameter    Userstack    Superstack    Calling Mode    ret
  1915.  *       1L           usp           ssp            user     0L
  1916.  *       1L           usp           ssp         supervisor    -1L
  1917.  *       0L          usp-6           usp            user    ssp
  1918.  *       0L           ssp          ssp-6         supervisor   ssp-6
  1919.  *      ptr          usp-6          ptr+6            user    ssp
  1920.  *      ptr          usp+6           ptr         supervisor     sr
  1921.  * The usual C-bindings are safe only because the "unlk a6" is compensating
  1922.  * the errors when you invoke this function. In this binding the "unlk a6" at
  1923.  * the end of the calling function compensates the error made in sequence 2
  1924.  * above (the usp is 6 to low after the first call which is not corrected by
  1925.  * the second call).
  1926.  */
  1927. #define           Super(ptr)                           \
  1928.        (long)trap_1_wl((short)(0x20),(long)(ptr))
  1929.     /* Tos 1.4: Super(1L) : rets -1L if in super mode, 0L otherwise */
  1930. #define           Tgetdate()                           \
  1931.        (short)trap_1_w((short)(0x2A))
  1932. #define           Tsetdate(date)                           \
  1933.        (long)trap_1_ww((short)(0x2B),(short)(date))
  1934. #define           Tgettime()                           \
  1935.        (short)trap_1_w((short)(0x2C))
  1936. #define           Tsettime(time)                           \
  1937.        (long)trap_1_ww((short)(0x2D),(short)(time))
  1938. #define           Fgetdta()                           \
  1939.        (_DTA *)trap_1_w((short)(0x2F))
  1940. #define           Sversion()                           \
  1941.        (short)trap_1_w((short)(0x30))
  1942. #define           Ptermres(save,rv)                       \
  1943.        (void)trap_1_wlw((short)(0x31),(long)(save),(short)(rv))
  1944. #define           Dfree(buf,d)                           \
  1945.        (long)trap_1_wlw((short)(0x36),(long)(buf),(short)(d))
  1946. #define           Dcreate(path)                           \
  1947.        (short)trap_1_wl((short)(0x39),(long)(path))
  1948. #define           Ddelete(path)                           \
  1949.        (long)trap_1_wl((short)(0x3A),(long)(path))
  1950. #define           Dsetpath(path)                           \
  1951.        (long)trap_1_wl((short)(0x3B),(long)(path))
  1952. #define           Fcreate(fn,mode)                           \
  1953.        (long)trap_1_wlw((short)(0x3C),(long)(fn),(short)(mode))
  1954. #define           Fopen(fn,mode)                           \
  1955.        (long)trap_1_wlw((short)(0x3D),(long)(fn),(short)(mode))
  1956. #define           Fclose(handle)                           \
  1957.        (long)trap_1_ww((short)(0x3E),(short)(handle))
  1958. #define           Fread(handle,cnt,buf)                       \
  1959.        (long)trap_1_wwll((short)(0x3F),(short)(handle),           \
  1960.              (long)(cnt),(long)(buf))
  1961. #define           Fwrite(handle,cnt,buf)                       \
  1962.        (long)trap_1_wwll((short)(0x40),(short)(handle),           \
  1963.              (long)(cnt),(long)(buf))
  1964. #define           Fdelete(fn)                           \
  1965.        (long)trap_1_wl((short)(0x41),(long)(fn))
  1966. #define           Fseek(where,handle,how)                       \
  1967.        (long)trap_1_wlww((short)(0x42),(long)(where),           \
  1968.              (short)(handle),(short)(how))
  1969. #define           Fattrib(fn,rwflag,attr)                       \
  1970.        (short)trap_1_wlww((short)(0x43),(long)(fn),           \
  1971.               (short)(rwflag),(short)(attr))
  1972. #define           Fdup(handle)                           \
  1973.        (long)trap_1_ww((short)(0x45),(short)(handle))
  1974. #define           Fforce(Hstd,Hnew)                       \
  1975.        (long)trap_1_www((short)(0x46),(short)(Hstd),(short)(Hnew))
  1976. #define           Dgetpath(buf,d)                           \
  1977.        (long)trap_1_wlw((short)(0x47),(long)(buf),(short)(d))
  1978. #define           Malloc(size)                           \
  1979.        (long)trap_1_wl((short)(0x48),(long)(size))
  1980. #define           Mfree(ptr)                           \
  1981.        (long)trap_1_wl((short)(0x49),(long)(ptr))
  1982. #define           Mshrink(ptr,size)                       \
  1983.        (long)trap_1_wwll((short)(0x4A),(short)0,(long)(ptr),(long)(size))
  1984. #define           Pexec(mode,prog,tail,env)               \
  1985.        (long)trap_1_wwlll((short)(0x4B),(short)(mode),(long)(prog),   \
  1986.                (long)(tail),(long)(env))
  1987. #define           Pterm(rv)                           \
  1988.        (void)trap_1_ww((short)(0x4C),(short)(rv))
  1989. #define           Fsfirst(filespec,attr)                       \
  1990.        (long)trap_1_wlw((short)(0x4E),(long)(filespec),(short)(attr))
  1991. #define           Fsnext()                               \
  1992.        (long)trap_1_w((short)(0x4F))
  1993. #define           Frename(zero,old,new)                       \
  1994.        (short)trap_1_wwll((short)(0x56),(short)(zero),           \
  1995.               (long)(old),(long)(new))
  1996. #define           Fdatime(timeptr,handle,rwflag)                   \
  1997.        (long)trap_1_wlww((short)(0x57),(long)(timeptr),           \
  1998.              (short)(handle),(short)(rwflag))
  1999. #define           Flock(handle,mode,start,length)                   \
  2000.        (long)trap_1_wwwll((short)(0x5C),(short)(handle),       \
  2001.               (short)(mode),(long)(start),(long)(length))
  2002.  
  2003. /*
  2004.  *     BIOS    (trap13)
  2005.  */
  2006. #define Getmpb(ptr)                           \
  2007.        (void)trap_13_wl((short)(0x00),(long)(ptr))
  2008. #define           Bconstat(dev)                           \
  2009.        (short)trap_13_ww((short)(0x01),(short)(dev))
  2010. #define           Bconin(dev)                           \
  2011.        (long)trap_13_ww((short)(0x02),(short)(dev))
  2012. #define           Bconout(dev,c)                           \
  2013.        (long)trap_13_www((short)(0x03),(short)(dev),(short)((c) & 0xFF))
  2014. /* since AHDI 3.1 there is a new call to Rwabs with one more parameter */
  2015. #define           Rwabs(rwflag,buf,n,sector,d)            \
  2016.        (long)trap_13_wwlwww((short)(0x04),(short)(rwflag),(long)(buf), \
  2017.                  (short)(n),(short)(sector),(short)(d))
  2018. #define           Setexc(vnum,vptr)                       \
  2019.        (void (*) __PROTO((void)))trap_13_wwl((short)(0x05),(short)(vnum),(long)(vptr))
  2020. #define           Tickcal()                           \
  2021.        (long)trap_13_w((short)(0x06))
  2022. #define           Getbpb(d)                           \
  2023.        (void *)trap_13_ww((short)(0x07),(short)(d))
  2024. #define           Bcostat(dev)                           \
  2025.        (short)trap_13_ww((short)(0x08),(short)(dev))
  2026. #define           Mediach(dev)                           \
  2027.        (short)trap_13_ww((short)(0x09),(short)(dev))
  2028. #define           Drvmap()                               \
  2029.        (long)trap_13_w((short)(0x0A))
  2030. #define           Kbshift(data)                           \
  2031.        (long)trap_13_ww((short)(0x0B),(short)(data))
  2032. #define           Getshift()                           \
  2033.     Kbshift(-1)
  2034.  
  2035.  
  2036. /*
  2037.  *     XBIOS   (trap14)
  2038.  */
  2039.  
  2040. #define           Initmous(type,param,vptr)                   \
  2041.        (void)trap_14_wwll((short)(0x00),(short)(type),           \
  2042.               (long)(param),(long)(vptr))
  2043. #define Ssbrk(size)                           \
  2044.        (void *)trap_14_ww((short)(0x01),(short)(size))
  2045. #define           Physbase()                           \
  2046.        (void *)trap_14_w((short)(0x02))
  2047. #define           Logbase()                           \
  2048.        (void *)trap_14_w((short)(0x03))
  2049. #define           Getrez()                               \
  2050.        (short)trap_14_w((short)(0x04))
  2051. #define           Setscreen(lscrn,pscrn,rez)                   \
  2052.        (void)trap_14_wllw((short)(0x05),(long)(lscrn),(long)(pscrn), \
  2053.               (short)(rez))
  2054. #define           Setpalette(palptr)                       \
  2055.        (void)trap_14_wl((short)(0x06),(long)(palptr))
  2056. #define           Setcolor(colornum,mixture)                   \
  2057.        (short)trap_14_www((short)(0x07),(short)(colornum),(short)(mixture))
  2058. #define           Floprd(buf,x,d,sect,trk,side,n)                   \
  2059.        (short)trap_14_wllwwwww((short)(0x08),(long)(buf),(long)(x), \
  2060.      (short)(d),(short)(sect),(short)(trk),(short)(side),(short)(n))
  2061. #define           Flopwr(buf,x,d,sect,trk,side,n)                   \
  2062.        (short)trap_14_wllwwwww((short)(0x09),(long)(buf),(long)(x), \
  2063.            (short)(d),(short)(sect),(short)(trk),(short)(side),(short)(n))
  2064. #define           Flopfmt(buf,x,d,spt,t,sd,i,m,v)               \
  2065.        (short)trap_14_wllwwwwwlw((short)(0x0A),(long)(buf),(long)(x), \
  2066.       (short)(d),(short)(spt),(short)(t),(short)(sd),(short)(i),  \
  2067.       (long)(m),(short)(v))
  2068. #define           Midiws(cnt,ptr)                           \
  2069.        (void)trap_14_wwl((short)(0x0C),(short)(cnt),(long)(ptr))
  2070. #define           Mfpint(vnum,vptr)                       \
  2071.        (void)trap_14_wwl((short)(0x0D),(short)(vnum),(long)(vptr))
  2072. #define           Iorec(ioDEV)                           \
  2073.        (void *)trap_14_ww((short)(0x0E),(short)(ioDEV))
  2074. #define           Rsconf(baud,flow,uc,rs,ts,sc)                   \
  2075.        (long)trap_14_wwwwwww((short)(0x0F),(short)(baud),(short)(flow), \
  2076.               (short)(uc),(short)(rs),(short)(ts),(short)(sc))
  2077.     /* ret old val: MSB -> ucr:8, rsr:8, tsr:8, scr:8 <- LSB */
  2078. #define           Keytbl(nrml,shft,caps)                       \
  2079.        (void *)trap_14_wlll((short)(0x10),(long)(nrml), \
  2080.                 (long)(shft),(long)(caps))
  2081. #define           Random()                               \
  2082.        (long)trap_14_w((short)(0x11))
  2083. #define           Protobt(buf,serial,dsktyp,exec)                   \
  2084.        (void)trap_14_wllww((short)(0x12),(long)(buf),(long)(serial), \
  2085.                (short)(dsktyp),(short)(exec))
  2086. #define           Flopver(buf,x,d,sect,trk,sd,n)                   \
  2087.        (short)trap_14_wllwwwww((short)(0x13),(long)(buf),(long)(x),(short)(d),\
  2088.            (short)(sect),(short)(trk),(short)(sd),(short)(n))
  2089. #define           Scrdmp()                               \
  2090.        (void)trap_14_w((short)(0x14))
  2091. #define           Cursconf(rate,attr)                       \
  2092.        (short)trap_14_www((short)(0x15),(short)(rate),(short)(attr))
  2093. #define           Settime(time)                           \
  2094.        (void)trap_14_wl((short)(0x16),(long)(time))
  2095. #define           Gettime()                           \
  2096.        (long)trap_14_w((short)(0x17))
  2097. #define           Bioskeys()                           \
  2098.        (void)trap_14_w((short)(0x18))
  2099. #define           Ikbdws(len_minus1,ptr)                       \
  2100.        (void)trap_14_wwl((short)(0x19),(short)(len_minus1),(long)(ptr))
  2101. #define           Jdisint(vnum)                           \
  2102.        (void)trap_14_ww((short)(0x1A),(short)(vnum))
  2103. #define           Jenabint(vnum)                           \
  2104.        (void)trap_14_ww((short)(0x1B),(short)(vnum))
  2105. #define           Giaccess(data,reg)                       \
  2106.        (short)trap_14_www((short)(0x1C),(short)(data),(short)(reg))
  2107. #define           Offgibit(ormask)                           \
  2108.        (void)trap_14_ww((short)(0x1D),(short)(ormask))
  2109. #define           Ongibit(andmask)                           \
  2110.        (void)trap_14_ww((short)(0x1E),(short)(andmask))
  2111. #define           Xbtimer(timer,ctrl,data,vptr)                   \
  2112.        (void)trap_14_wwwwl((short)(0x1F),(short)(timer),(short)(ctrl), \
  2113.                (short)(data),(long)(vptr))
  2114. #define           Dosound(ptr)                           \
  2115.        (void)trap_14_wl((short)(0x20),(long)(ptr))
  2116. #define           Setprt(config)                           \
  2117.        (short)trap_14_ww((short)(0x21),(short)(config))
  2118. #define           Kbdvbase()                           \
  2119.        (_KBDVECS*)trap_14_w((short)(0x22))
  2120. #define           Kbrate(delay,reprate)                       \
  2121.        (short)trap_14_www((short)(0x23),(short)(delay),(short)(reprate))
  2122. #define           Prtblk(pblkptr)                           \
  2123.        (void)trap_14_wl((short)(0x24),(long)(pblkptr)) /* obsolete ? */
  2124. #define           Vsync()                               \
  2125.        (void)trap_14_w((short)(0x25))
  2126. #define           Supexec(funcptr)                           \
  2127.        (long)trap_14_wl((short)(0x26),(long)(funcptr))
  2128. #define           Floprate(drive,rate)                       \
  2129.        (short)trap_14_www((short)(0x29),(short)(drive),(short)(rate))
  2130. #define           Blitmode(flag)                           \
  2131.        (short)trap_14_ww((short)(0x40),(short)(flag))
  2132. /*
  2133.  * Flag:
  2134.  *  -1: get config
  2135.  * !-1: set config    previous config returned
  2136.  *    bit
  2137.  *     0    0 blit mode soft    1 blit mode hardware
  2138.  *     1    0 no blitter        1 blitter present
  2139.  *    2..14   reserved
  2140.  *     15    must be zero on set/returned as zero
  2141.  * blitmode (bit 0) forced to soft if no blitter(bit 1 == 0).
  2142.  */
  2143.  
  2144. /*
  2145.  * extensions for TT TOS
  2146.  */
  2147.  
  2148. #define         Mxalloc(amt,flag)                    \
  2149.     (long)trap_1_wlw((short)(0x44),(long)(amt),(short)(flag))
  2150. #define        Maddalt(start,size)                    \
  2151.     (long)trap_1_wll((short)(0x14),(long)(start),(long)(size))
  2152.  
  2153. #define         EsetShift(mode)                        \
  2154.     (void)trap_14_ww((short)(80),(short)mode)
  2155. #define         EgetShift()                        \
  2156.     (short)trap_14_w((short)(81))
  2157. #define         EsetBank(bank)                        \
  2158.     (short)trap_14_ww((short)(82),(short)bank)
  2159. #define         EsetColor(num,val)                    \
  2160.     (short)trap_14_www((short)(83),(short)num,(short)val)
  2161. #define         EsetPalette(start,count,ptr)                \
  2162.     (void)trap_14_wwwl((short)(84),(short)start,(short)count,(long)ptr)
  2163. #define         EgetPalette(start,count,ptr)                \
  2164.     (void)trap_14_wwwl((short)(85),(short)start,(short)count,(long)ptr)
  2165. #define         EsetGray(mode)                        \
  2166.     (short)trap_14_ww((short)(86),(short)mode)
  2167. #define         EsetSmear(mode)                        \
  2168.     (short)trap_14_ww((short)(87),(short)mode)
  2169.  
  2170. #define        DMAread(sector,count,buffer,devno)            \
  2171.     (long)trap_14_wlwlw((short)0x2a,(long)sector,(short)count,(long)buffer, \
  2172.                 (short)devno)
  2173. #define        DMAwrite(sector,count,buffer,devno)            \
  2174.     (long)trap_14_wlwlw((short)0x2b,(long)sector,(short)count,(long)buffer, \
  2175.             (short)devno)
  2176. #define        Bconmap(dev)                        \
  2177.     (long)trap_14_ww((short)0x2c,(short)(dev))
  2178. #define        NVMaccess(op,start,count,buf)                \
  2179.     (short)trap_14_wwwwl((short)0x2e,(short)op,(short)start,(short)count, \
  2180.             (long)buf)
  2181.  
  2182. /*  Wake-up call for ST BOOK -- takes date/time pair in DOS format. */
  2183.  
  2184. #define           Waketime(w_date, w_time)                    \
  2185.        (void)trap_14_www((short)(0x2f),(unsigned short)(w_date),    \
  2186.                        (unsigned short)(w_time))
  2187.  
  2188. #endif /* __LATTICE__ */
  2189. #endif /* __TURBOC__ */
  2190.  
  2191. #ifdef __cplusplus
  2192. }
  2193. #endif
  2194.  
  2195. #endif /* _OSBIND_H */
  2196.