home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / mntinc16 / osbind.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-29  |  39.6 KB  |  1,267 lines
  1. /*
  2.  * osbind.h,v
  3.  *
  4.  * See Changelog for prev history
  5.  */
  6.  
  7. /*
  8.  *     OSBIND.H        Mnemonic names for operating system calls
  9.  *
  10.  * Adapted from Dale Schumacher's version to Mark Johnson C by Eric Gisin.
  11.  * hacked by jrd for GNU
  12.  *
  13.  * more hacks
  14.  *     inline the traps
  15.  *
  16.  *        ++jrb bammi@dsrgsun.ces.cwru.edu
  17.  */
  18.  
  19. /*
  20.  * majorly re-hacked for gcc-1.36 and probably beyond
  21.  * all inlines changed to #defines, beacuse gcc is not
  22.  * handling clobbered reggies correctly when -mshort.
  23.  * We now use the Statement Exprs feature of GnuC
  24.  *
  25.  * 10/12/89
  26.  *    changed all "g" constraints to "r" that will force
  27.  *    all operands to be evaluated (or lea calculated)
  28.  *    before the __asm__. This is necessary because
  29.  *    if we had the (looser) "g" constraint, then sometimes
  30.  *    we are in the situation where stuff is in the stack,
  31.  *    and we are modifying the stack under Gcc (but eventually
  32.  *    restoring it before the end of the __asm__), and it does
  33.  *    not know about it (i believe there is no way to tell it
  34.  *    this either, but you can hardly expect that). by forcing
  35.  *    the stricter "r" constraint, we force the eval before using
  36.  *    the val (or lea as the case may be) and we dont get into
  37.  *    trouble.
  38.  *    (thanks to ers for finding this problem!)
  39.  *    [one side effect of this is that we may(depending on the
  40.  *      situation) actually end up with better code when the
  41.  *    values are already in reggies, or that value is used
  42.  *    later on (note that Gnu's reggie allocation notices the
  43.  *    clobbered reggie, and does'nt put the value/or uses
  44.  *    them from those reggies, nice huh!)
  45.  *
  46.  *  28/2/90
  47.  *    another major re-hack:
  48.  *    -- the basic reason: there was just no reliable
  49.  *    way to get the definitions (inline or not does'nt matter) to
  50.  *    fully evaluate the args before we changed the sp from under it.
  51.  *    (if -fomit-frame-pointer is *not* used, then most of the time
  52.  *     we dont need to do this, as things will just reference off of
  53.  *     a6, but this is not true all of the time).
  54.  *    my solution was to use local vars in the body of the statement
  55.  *    exprs, and initialize them from the args of the statement expr block.
  56.  *    to force the evaluation of the args before we change sp from
  57.  *    under gcc's feet, we make the local vars volatile. we use a
  58.  *    slight code optimization heuristic: if there are more than 4
  59.  *    args, only then we make the local volatile, and relax
  60.  *    the "r" constraint to "g". otherwise, we dont put the volatile
  61.  *    and force the evaluation by putting the "r" constaint. this
  62.  *    produces better code in most sitiations (when !__NO_INLINE__
  63.  *    especially), as either the args are already in a register or
  64.  *    there is good chance they will soon be reused, and in that
  65.  *    case it will already be in a register.
  66.  *      it may (the local vars, especially when no volatile)
  67.  *    look like overhead, but in 99% of the situations gcc will just
  68.  *    optimize that assignment right out. besides, this makes
  69.  *    these defines totally safe (from re-evaluation of the macro args).
  70.  *
  71.  *    -- as suggested by andreas schwab (thanks!)
  72.  *     (schwab@ls5.informatik.uni-dortmund.de) all the retvalues are now
  73.  *     local register vals (see the extentions section in the info file)
  74.  *     this really worked out great as all the silly "movl d0,%0" at
  75.  *     the end of each def can now be removed, and the value of
  76.  *     retvalue ends up in the correct register. it avoids all the
  77.  *     silly "mov d0,[d|a]n" type sequences from being generated. a real win.
  78.  *     (note in the outputs "=r"(retvalue) still has to be specified,
  79.  *     otherwise in certain situations you end up loosing the return
  80.  *     value in d0, as gcc sees no output, and correctly assumes that the
  81.  *     asm returns no value).
  82.  *
  83.  *    -- all the n's (the function #'s for the traps) are now given
  84.  *    the more relaxed "g". This again results in better code, as
  85.  *    it is always a constant, and gcc turns the movw %1,sp@- into
  86.  *    a movw #n,sp@-. we could have given them a "i" constraint too,
  87.  *    but "g" gives gcc more breathing room, and it does the right
  88.  *    thing. note: the n's still need to have "r" constraints in the
  89.  *    non-inline form (function form), as they are no longer constants
  90.  *    in the function, but a normal arg on the stack frame, and hence
  91.  *    we need to force evaluation before we change sp. (see osbind.c)
  92.  *
  93.  *    -- straps.cpp and traps.c are history. we dont need no stinking
  94.  *    non-reentrant bindings (straps) or incorrect ones (traps.c :-)
  95.  */
  96.  
  97. #ifndef _OSBIND_H
  98. #define _OSBIND_H
  99.  
  100. #ifndef _COMPILER_H
  101. #include <compiler.h>
  102. #endif
  103.  
  104. /* want to skip all the gory details of GNU C inlines??
  105.    search for the string "DEFINITIONS" */
  106.  
  107. #ifdef __GNUC_INLINE__
  108. /*
  109.  * GNU C (pseudo inline) Statement Exprs for traps
  110.  *
  111.  */
  112.  
  113. #define trap_1_w(n)                            \
  114. ({                                    \
  115.     register long retvalue __asm__("d0");                \
  116.                                         \
  117.     __asm__ volatile                        \
  118.     ("\
  119.         movw    %1,sp@-; \
  120.         trap    #1;    \
  121.         addqw   #2,sp "                        \
  122.     : "=r"(retvalue)            /* outputs */        \
  123.     : "g"(n)                /* inputs  */        \
  124.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  125.     );                                \
  126.     retvalue;                            \
  127. })
  128.  
  129. #define trap_1_ww(n, a)                            \
  130. ({                                    \
  131.     register long retvalue __asm__("d0");                \
  132.     short _a = (short)(a);                        \
  133.                                         \
  134.     __asm__ volatile                        \
  135.     ("\
  136.         movw    %2,sp@-; \
  137.         movw    %1,sp@-; \
  138.         trap    #1;    \
  139.         addqw   #4,sp "                        \
  140.     : "=r"(retvalue)            /* outputs */        \
  141.     : "g"(n), "r"(_a)            /* inputs  */        \
  142.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  143.     );                                \
  144.     retvalue;                            \
  145. })
  146.  
  147. #define trap_1_wl(n, a)                            \
  148. ({                                    \
  149.     register long retvalue __asm__("d0");                \
  150.     long  _a = (long) (a);                        \
  151.                                         \
  152.     __asm__ volatile                        \
  153.     ("\
  154.         movl    %2,sp@-; \
  155.         movw    %1,sp@-; \
  156.         trap    #1;    \
  157.         addqw   #6,sp "                        \
  158.     : "=r"(retvalue)            /* outputs */        \
  159.     : "g"(n), "r"(_a)            /* inputs  */        \
  160.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  161.     );                                \
  162.     retvalue;                            \
  163. })
  164.  
  165. #define trap_1_wlw(n, a, b)                        \
  166. ({                                    \
  167.     register long retvalue __asm__("d0");                \
  168.     long  _a = (long) (a);                        \
  169.     short _b = (short)(b);                        \
  170.                                         \
  171.     __asm__ volatile                        \
  172.     ("\
  173.         movw    %3,sp@-; \
  174.         movl    %2,sp@-; \
  175.         movw    %1,sp@-; \
  176.         trap    #1;    \
  177.         addqw   #8,sp "                        \
  178.     : "=r"(retvalue)            /* outputs */        \
  179.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  180.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  181.     );                                \
  182.     retvalue;                            \
  183. })
  184.  
  185. #define trap_1_wwll(n, a, b, c)                        \
  186. ({                                    \
  187.     register long retvalue __asm__("d0");                \
  188.     short _a = (short)(a);                        \
  189.     long  _b = (long) (b);                        \
  190.     long  _c = (long) (c);                        \
  191.                                         \
  192.     __asm__ volatile                        \
  193.     ("\
  194.         movl    %4,sp@-; \
  195.         movl    %3,sp@-; \
  196.         movw    %2,sp@-; \
  197.         movw    %1,sp@-; \
  198.         trap    #1;    \
  199.         addw    #12,sp "                    \
  200.     : "=r"(retvalue)            /* outputs */        \
  201.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  202.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  203.     );                                \
  204.     retvalue;                            \
  205. })
  206.  
  207. #define trap_1_wlww(n, a, b, c)                        \
  208. ({                                    \
  209.     register long retvalue __asm__("d0");                \
  210.     long  _a = (long) (a);                        \
  211.     short _b = (short)(b);                        \
  212.     short _c = (short)(c);                        \
  213.                                         \
  214.     __asm__ volatile                        \
  215.     ("\
  216.         movw    %4,sp@-; \
  217.         movw    %3,sp@-; \
  218.         movl    %2,sp@-; \
  219.         movw    %1,sp@-; \
  220.         trap    #1;    \
  221.         addw    #10,sp "                    \
  222.     : "=r"(retvalue)            /* outputs */        \
  223.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  224.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  225.     );                                \
  226.     retvalue;                            \
  227. })
  228.  
  229. #define trap_1_www(n, a, b)                        \
  230. ({                                    \
  231.     register long retvalue __asm__("d0");                \
  232.     short _a = (short)(a);                        \
  233.     short _b = (short)(b);                        \
  234.                                         \
  235.     __asm__ volatile                        \
  236.     ("\
  237.         movw    %3,sp@-; \
  238.         movw    %2,sp@-; \
  239.         movw    %1,sp@-; \
  240.         trap    #1;    \
  241.         addqw   #6,sp "                        \
  242.     : "=r"(retvalue)            /* outputs */        \
  243.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  244.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  245.     );                                \
  246.     retvalue;                            \
  247. })
  248.  
  249. #define trap_1_wll(n, a, b)                        \
  250. ({                                    \
  251.     register long retvalue __asm__("d0");                \
  252.     long  _a = (long) (a);                        \
  253.     long  _b = (long) (b);                        \
  254.                                         \
  255.     __asm__ volatile                        \
  256.     ("\
  257.         movl    %3,sp@-; \
  258.         movl    %2,sp@-; \
  259.         movw    %1,sp@-; \
  260.         trap    #1;    \
  261.         addw    #10,sp "                    \
  262.     : "=r"(retvalue)            /* outputs */        \
  263.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  264.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  265.     );                                \
  266.     retvalue;                            \
  267. })
  268.  
  269. #define trap_1_wwlll(n, a, b, c, d)                    \
  270. ({                                    \
  271.     register long retvalue __asm__("d0");                \
  272.     volatile short _a = (volatile short)(a);            \
  273.     volatile long  _b = (volatile long) (b);            \
  274.     volatile long  _c = (volatile long) (c);            \
  275.     volatile long  _d = (volatile long) (d);            \
  276.                                         \
  277.     __asm__ volatile                        \
  278.     ("\
  279.         movl    %4,sp@-; \
  280.         movl    %3,sp@-; \
  281.         movl    %2,sp@-; \
  282.         movw    %1,sp@-; \
  283.         movw    %0,sp@- "                    \
  284.     :                         /* outputs */    \
  285.     : "g"(n), "g"(_a), "g"(_b), "g"(_c), "g"(_d) /* inputs  */    \
  286.     );                                \
  287.   /* no more than 5 operand allowed in asm() -- therefore the split */  \
  288.                                     \
  289.     __asm__ volatile                        \
  290.     ("\
  291.         trap    #1;    \
  292.         addw    #16,sp "                    \
  293.     : "=r"(retvalue)            /* outputs */        \
  294.     :                    /* inputs  */        \
  295.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  296.     );                                \
  297.     retvalue;                            \
  298. })
  299.  
  300. #define trap_13_wl(n, a)                        \
  301. ({                                    \
  302.     register long retvalue __asm__("d0");                \
  303.     long  _a = (long) (a);                        \
  304.                                         \
  305.     __asm__ volatile                        \
  306.     ("\
  307.         movl    %2,sp@-; \
  308.         movw    %1,sp@-; \
  309.         trap    #13;    \
  310.         addqw   #6,sp "                        \
  311.     : "=r"(retvalue)            /* outputs */        \
  312.     : "g"(n), "r"(_a)            /* inputs  */        \
  313.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  314.     );                                \
  315.     retvalue;                            \
  316. })
  317.  
  318. #define trap_13_w(n)                            \
  319. ({                                    \
  320.     register long retvalue __asm__("d0");                \
  321.                                         \
  322.     __asm__ volatile                        \
  323.     ("\
  324.         movw    %1,sp@-; \
  325.         trap    #13;    \
  326.         addqw   #2,sp "                        \
  327.     : "=r"(retvalue)            /* outputs */        \
  328.     : "g"(n)                /* inputs  */        \
  329.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  330.     );                                \
  331.     retvalue;                            \
  332. })
  333.  
  334. #define trap_13_ww(n, a)                        \
  335. ({                                    \
  336.     register long retvalue __asm__("d0");                \
  337.     short _a = (short)(a);                        \
  338.                                         \
  339.     __asm__ volatile                        \
  340.     ("\
  341.         movw    %2,sp@-; \
  342.         movw    %1,sp@-; \
  343.         trap    #13;    \
  344.         addqw   #4,sp "                        \
  345.     : "=r"(retvalue)            /* outputs */        \
  346.     : "g"(n), "r"(_a)            /* inputs  */        \
  347.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  348.     );                                \
  349.     retvalue;                            \
  350. })
  351.  
  352. #define trap_13_www(n, a, b)                        \
  353. ({                                    \
  354.     register long retvalue __asm__("d0");                \
  355.     short _a = (short)(a);                        \
  356.     short _b = (short)(b);                        \
  357.                                         \
  358.     __asm__ volatile                        \
  359.     ("\
  360.         movw    %3,sp@-; \
  361.         movw    %2,sp@-; \
  362.         movw    %1,sp@-; \
  363.         trap    #13;    \
  364.         addqw   #6,sp "                        \
  365.     : "=r"(retvalue)            /* outputs */        \
  366.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  367.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  368.     );                                \
  369.     retvalue;                            \
  370. })
  371.  
  372. #define trap_13_wwlwww(n, a, b, c, d, e)                \
  373. ({                                    \
  374.     register long retvalue __asm__("d0");                \
  375.     volatile short _a = (volatile short)(a);            \
  376.     volatile long  _b = (volatile long) (b);            \
  377.     volatile short _c = (volatile short)(c);            \
  378.     volatile short _d = (volatile short)(d);            \
  379.     volatile short _e = (volatile short)(e);            \
  380.                                         \
  381.     __asm__ volatile                        \
  382.     ("\
  383.         movw    %4,sp@-; \
  384.         movw    %3,sp@-; \
  385.         movw    %2,sp@-; \
  386.         movl    %1,sp@-; \
  387.         movw    %0,sp@-    "                    \
  388.     :                          /* outputs */    \
  389.     : "g"(_a), "g"(_b), "g"(_c), "g"(_d), "g"(_e) /* inputs  */    \
  390.     );                                \
  391.                                     \
  392.     __asm__ volatile                        \
  393.     ("\
  394.         movw    %1,sp@-; \
  395.         trap    #13;    \
  396.         addw    #14,sp "                    \
  397.     : "=r"(retvalue)            /* outputs */        \
  398.     : "g"(n)                /* inputs  */        \
  399.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  400.     );                                \
  401.     retvalue;                            \
  402. })
  403.  
  404. #define trap_13_wwl(n, a, b)                        \
  405. ({                                    \
  406.     register long retvalue __asm__("d0");                \
  407.     short _a = (short)(a);                        \
  408.     long  _b = (long) (b);                        \
  409.                                         \
  410.     __asm__ volatile                        \
  411.     ("\
  412.         movl    %3,sp@-; \
  413.         movw    %2,sp@-; \
  414.         movw    %1,sp@-; \
  415.         trap    #13;    \
  416.         addqw   #8,sp "                        \
  417.     : "=r"(retvalue)            /* outputs */        \
  418.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  419.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  420.     );                                \
  421.     retvalue;                            \
  422. })
  423.  
  424. #define trap_14_wwl(n, a, b)                        \
  425. ({                                    \
  426.     register long retvalue __asm__("d0");                \
  427.     short _a = (short)(a);                        \
  428.     long  _b = (long) (b);                        \
  429.                                         \
  430.     __asm__ volatile                        \
  431.     ("\
  432.         movl    %3,sp@-; \
  433.         movw    %2,sp@-; \
  434.         movw    %1,sp@-; \
  435.         trap    #14;    \
  436.         addqw   #8,sp "                        \
  437.     : "=r"(retvalue)            /* outputs */        \
  438.     : "g"(n), "r"(_a), "r"(_b)              /* inputs  */        \
  439.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  440.     );                                \
  441.     retvalue;                            \
  442. })
  443.  
  444. #define trap_14_wwll(n, a, b, c)                    \
  445. ({                                    \
  446.     register long retvalue __asm__("d0");                \
  447.     short _a = (short)(a);                        \
  448.     long  _b = (long) (b);                        \
  449.     long  _c = (long) (c);                        \
  450.                                         \
  451.     __asm__ volatile                        \
  452.     ("\
  453.         movl    %4,sp@-; \
  454.         movl    %3,sp@-; \
  455.         movw    %2,sp@-; \
  456.         movw    %1,sp@-; \
  457.         trap    #14;    \
  458.         addw    #12,sp "                    \
  459.     : "=r"(retvalue)            /* outputs */        \
  460.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  461.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  462.     );                                \
  463.     retvalue;                            \
  464. })
  465.  
  466. #define trap_14_ww(n, a)                        \
  467. ({                                    \
  468.     register long retvalue __asm__("d0");                \
  469.     short _a = (short)(a);                        \
  470.                                         \
  471.     __asm__ volatile                        \
  472.     ("\
  473.         movw    %2,sp@-; \
  474.         movw    %1,sp@-; \
  475.         trap    #14;    \
  476.         addqw   #4,sp "                        \
  477.     : "=r"(retvalue)            /* outputs */        \
  478.     : "g"(n), "r"(_a)            /* inputs  */        \
  479.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  480.     );                                \
  481.     retvalue;                            \
  482. })
  483.  
  484. #define trap_14_w(n)                            \
  485. ({                                    \
  486.     register long retvalue __asm__("d0");                \
  487.                                         \
  488.     __asm__ volatile                        \
  489.     ("\
  490.         movw    %1,sp@-; \
  491.         trap    #14;    \
  492.         addqw   #2,sp "                        \
  493.     : "=r"(retvalue)            /* outputs */        \
  494.     : "g"(n)                /* inputs  */        \
  495.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  496.     );                                \
  497.     retvalue;                            \
  498. })
  499.  
  500. #define trap_14_wllw(n, a, b, c)                    \
  501. ({                                    \
  502.     register long retvalue __asm__("d0");                \
  503.     long  _a = (long) (a);                        \
  504.     long  _b = (long) (b);                        \
  505.     short _c = (short)(c);                        \
  506.                                         \
  507.     __asm__ volatile                        \
  508.     ("\
  509.         movw    %4,sp@-; \
  510.         movl    %3,sp@-; \
  511.         movl    %2,sp@-; \
  512.         movw    %1,sp@-; \
  513.         trap    #14;    \
  514.         addw    #12,sp "                    \
  515.     : "=r"(retvalue)            /* outputs */        \
  516.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)       /* inputs  */        \
  517.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  518.     );                                \
  519.     retvalue;                            \
  520. })
  521.  
  522. #define trap_14_wl(n, a)                        \
  523. ({                                    \
  524.     register long retvalue __asm__("d0");                \
  525.     long  _a = (long) (a);                        \
  526.                                         \
  527.     __asm__ volatile                        \
  528.     ("\
  529.         movl    %2,sp@-; \
  530.         movw    %1,sp@-; \
  531.         trap    #14;    \
  532.         addqw   #6,sp "                        \
  533.     : "=r"(retvalue)            /* outputs */        \
  534.     : "g"(n), "r"(_a)            /* inputs  */        \
  535.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  536.     );                                \
  537.     retvalue;                            \
  538. })
  539.  
  540. #define trap_14_www(n, a, b)                        \
  541. ({                                    \
  542.     register long retvalue __asm__("d0");                \
  543.     short _a = (short)(a);                        \
  544.     short _b = (short)(b);                        \
  545.                                         \
  546.     __asm__ volatile                        \
  547.     ("\
  548.         movw    %3,sp@-; \
  549.         movw    %2,sp@-; \
  550.         movw    %1,sp@-; \
  551.         trap    #14;    \
  552.         addqw   #6,sp "                        \
  553.     : "=r"(retvalue)            /* outputs */        \
  554.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  555.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  556.     );                                \
  557.     retvalue;                            \
  558. })
  559.  
  560. #define trap_14_wllwwwww(n, a, b, c, d, e, f, g)            \
  561. ({                                    \
  562.     register long retvalue __asm__("d0");                \
  563.     volatile long  _a = (volatile long) (a);            \
  564.     volatile long  _b = (volatile long) (b);            \
  565.     short _c = (short)(c);                        \
  566.     short _d = (short)(d);                        \
  567.     short _e = (short)(e);                        \
  568.     short _f = (short)(f);                        \
  569.     short _g = (short)(g);                        \
  570.                                         \
  571.     __asm__ volatile                        \
  572.     ("\
  573.         movw    %4,sp@-; \
  574.         movw    %3,sp@-; \
  575.         movw    %2,sp@-; \
  576.         movw    %1,sp@-; \
  577.         movw    %0,sp@-    "                    \
  578.     :                          /* outputs */    \
  579.     : "g"(_c), "g"(_d), "g"(_e), "g"(_f), "g"(_g) /* inputs  */    \
  580.     );                                \
  581.                                     \
  582.     __asm__ volatile                        \
  583.     ("\
  584.         movl    %3,sp@-; \
  585.         movl    %2,sp@-; \
  586.         movw    %1,sp@-; \
  587.         trap    #14;    \
  588.         addw    #20,sp "                    \
  589.     : "=r"(retvalue)            /* outputs */        \
  590.     : "g"(n), "g"(_a), "g"(_b)        /* inputs  */        \
  591.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  592.     );                                \
  593.     retvalue;                            \
  594. })
  595.  
  596. #define trap_14_wllwwwwlw(n, a, b, c, d, e, f, g, h)            \
  597. ({                                    \
  598.     register long retvalue __asm__("d0");                \
  599.     volatile long  _a = (volatile long) (a);            \
  600.     volatile long  _b = (volatile long) (b);            \
  601.     volatile short _c = (volatile short)(c);            \
  602.     short _d = (short)(d);                        \
  603.     short _e = (short)(e);                        \
  604.     short _f = (short)(f);                        \
  605.     long  _g = (long) (g);                        \
  606.     short _h = (short)(h);                        \
  607.                                         \
  608.     __asm__ volatile                        \
  609.     ("\
  610.         movw    %4,sp@-; \
  611.         movl    %3,sp@-; \
  612.         movw    %2,sp@-; \
  613.         movw    %1,sp@-; \
  614.         movw    %0,sp@- "                    \
  615.     :                          /* outputs */    \
  616.     : "g"(_d), "g"(_e), "g"(_f), "g"(_g), "g"(_h) /* inputs  */    \
  617.     );                                \
  618.                                         \
  619.     __asm__ volatile                        \
  620.     ("\
  621.         movw    %4,sp@-; \
  622.         movl    %3,sp@-; \
  623.         movl    %2,sp@-; \
  624.         movw    %1,sp@-; \
  625.         trap    #14;    \
  626.         addw    #24,sp "                    \
  627.     : "=r"(retvalue)               /* outputs */    \
  628.     : "g"(n), "g"(_a), "g"(_b), "g"(_c)        /* inputs  */    \
  629.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  630.     );                                \
  631.     retvalue;                            \
  632. })
  633.  
  634. #define trap_14_wllwwwwwlw(n, a, b, c, d, e, f, g, h, i)        \
  635. ({                                    \
  636.     register long retvalue __asm__("d0");                \
  637.     volatile long  _a = (volatile long) (a);            \
  638.     volatile long  _b = (volatile long) (b);            \
  639.     volatile short _c = (volatile short)(c);            \
  640.     volatile short _d = (volatile short)(d);            \
  641.     short _e = (short)(e);                        \
  642.     short _f = (short)(f);                        \
  643.     short _g = (short)(g);                        \
  644.     long  _h = (long) (h);                        \
  645.     short _i = (short)(i);                        \
  646.                                         \
  647.     __asm__ volatile                        \
  648.     ("\
  649.         movw    %4,sp@-; \
  650.         movl    %3,sp@-; \
  651.         movw    %2,sp@-; \
  652.         movw    %1,sp@-; \
  653.         movw    %0,sp@- "                    \
  654.     :                          /* outputs */    \
  655.     : "g"(_e), "g"(_f), "g"(_g), "g"(_h), "g"(_i) /* inputs  */    \
  656.     );                                \
  657.                                     \
  658.     __asm__ volatile                        \
  659.     ("\
  660.         movw    %4,sp@-; \
  661.         movw    %3,sp@-; \
  662.         movl    %2,sp@-; \
  663.         movl    %1,sp@-; \
  664.                 movw    %0,sp@- "                    \
  665.     :                         /* outputs */    \
  666.     : "g"(n), "g"(_a), "g"(_b), "g"(_c), "g"(_d) /* inputs  */    \
  667.     );                                \
  668.                                         \
  669.     __asm__ volatile                        \
  670.     ("\
  671.         trap    #14;    \
  672.         addw    #26,sp "                    \
  673.     : "=r"(retvalue)            /* outputs */        \
  674.     :                     /* inputs  */        \
  675.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  676.     );                                \
  677.     retvalue;                            \
  678. })
  679.  
  680.  
  681. #define trap_14_wwwwwww(n, a, b, c, d, e, f)                \
  682. ({                                    \
  683.     register long retvalue __asm__("d0");                \
  684.     volatile short _a = (volatile short)(a);            \
  685.     short _b = (short)(b);                        \
  686.     short _c = (short)(c);                        \
  687.     short _d = (short)(d);                        \
  688.     short _e = (short)(e);                        \
  689.     short _f = (short)(f);                        \
  690.                                         \
  691.     __asm__ volatile                        \
  692.     ("\
  693.         movw    %4,sp@-; \
  694.         movw    %3,sp@-; \
  695.         movw    %2,sp@-; \
  696.         movw    %1,sp@-; \
  697.         movw    %0,sp@- "                    \
  698.     :                            /* outputs */    \
  699.     : "g"(_b), "g"(_c), "g"(_d), "g"(_e), "g"(_f)    /* inputs  */    \
  700.     );                                \
  701.                                     \
  702.     __asm__ volatile                        \
  703.     ("\
  704.         movw    %2,sp@-; \
  705.         movw    %1,sp@-; \
  706.         trap    #14;    \
  707.         addw    #14,sp "                    \
  708.     : "=r"(retvalue)            /* outputs */        \
  709.     : "g"(n), "g"(_a)            /* inputs  */        \
  710.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  711.     );                                \
  712.     retvalue;                            \
  713. })
  714.  
  715. #define trap_14_wlll(n, a, b, c)                    \
  716. ({                                    \
  717.     register long retvalue __asm__("d0");                \
  718.     long  _a = (long) (a);                        \
  719.     long  _b = (long) (b);                        \
  720.     long  _c = (long) (c);                        \
  721.                                         \
  722.     __asm__ volatile                        \
  723.     ("\
  724.         movl    %4,sp@-; \
  725.         movl    %3,sp@-; \
  726.         movl    %2,sp@-; \
  727.         movw    %1,sp@-; \
  728.         trap    #14;    \
  729.         addw    #14,sp "                    \
  730.     : "=r"(retvalue)            /* outputs */        \
  731.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  732.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  733.     );                                \
  734.     retvalue;                            \
  735. })
  736.  
  737. #define trap_14_wllww(n, a, b, c, d)                    \
  738. ({                                    \
  739.     register long retvalue __asm__("d0");                \
  740.     volatile long  _a = (volatile long) (a);            \
  741.     volatile long  _b = (volatile long) (b);            \
  742.     volatile short _c = (volatile short)(c);            \
  743.     volatile short _d = (volatile short)(d);            \
  744.                                         \
  745.     __asm__ volatile                        \
  746.     ("\
  747.         movw    %3,sp@-; \
  748.         movw    %2,sp@-; \
  749.         movl    %1,sp@-; \
  750.         movl    %0,sp@- "                    \
  751.     :                    /* outputs */        \
  752.     : "g"(_a), "g"(_b), "g"(_c), "g"(_d)    /* inputs  */        \
  753.     );                                \
  754.                                     \
  755.     __asm__ volatile                        \
  756.     ("\
  757.         movw    %1,sp@-; \
  758.         trap    #14;    \
  759.         addw    #14,sp "                    \
  760.     : "=r"(retvalue)            /* outputs */        \
  761.     : "g"(n)                /* inputs  */        \
  762.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  763.     );                                \
  764.     retvalue;                            \
  765. })
  766.  
  767. #define trap_14_wwwwl(n, a, b, c, d)                    \
  768. ({                                    \
  769.     register long retvalue __asm__("d0");                \
  770.     volatile short _a = (volatile short)(a);            \
  771.     volatile short _b = (volatile short)(b);            \
  772.     volatile short _c = (volatile short)(c);            \
  773.     volatile long  _d = (volatile long) (d);            \
  774.                                         \
  775.     __asm__ volatile                        \
  776.     ("\
  777.         movl    %3,sp@-; \
  778.         movw    %2,sp@-; \
  779.         movw    %1,sp@-; \
  780.         movw    %0,sp@- "                    \
  781.     :                        /* outputs */    \
  782.     : "g"(_a), "g"(_b), "g"(_c), "g"(_d)        /* inputs  */    \
  783.     );                                \
  784.                                     \
  785.     __asm__ volatile                        \
  786.     ("\
  787.         movw    %1,sp@-; \
  788.         trap    #14;    \
  789.         addw    #12,sp "                    \
  790.     : "=r"(retvalue)            /* outputs */        \
  791.     : "g"(n)                /* inputs  */        \
  792.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  793.     );                                \
  794.     retvalue;                            \
  795. })
  796.  
  797. #define trap_14_wwwl(n, a, b, c)                    \
  798. ({                                    \
  799.     register long retvalue __asm__("d0");                \
  800.     short _a = (short)(a);                        \
  801.     short _b = (short)(b);                        \
  802.     long  _c = (long)(c);                        \
  803.                                         \
  804.     __asm__ volatile                        \
  805.     ("                                \
  806.         movl    %4,sp@-;                    \
  807.         movw    %3,sp@-;                    \
  808.         movw    %2,sp@-;                    \
  809.         movw    %1,sp@-;                    \
  810.         trap    #14;                        \
  811.         addqw   #6,sp "                        \
  812.     : "=r"(retvalue)            /* outputs */        \
  813.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)    /* inputs  */        \
  814.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  815.     );                                \
  816.     retvalue;                            \
  817. })
  818.  
  819. #else /* __GNUC__ && !__NO_INLINE__ */
  820. #  ifdef __MSHORT__
  821.  
  822. /* compilers with 16 bit integers, including gcc -mshort */
  823. extern long gemdos(), bios(), xbios();
  824.  
  825. #define trap_1_w    gemdos
  826. #define trap_1_ww    gemdos
  827. #define trap_1_wl    gemdos
  828. #define trap_1_wlw    gemdos
  829. #define trap_1_www    gemdos
  830. #define trap_1_wll    gemdos
  831. #define trap_1_wwll    gemdos
  832. #define trap_1_wlww    gemdos
  833. #define trap_1_wwlll    gemdos
  834.  
  835. #define trap_13_w    bios
  836. #define trap_13_ww    bios
  837. #define trap_13_wl    bios
  838. #define trap_13_www    bios
  839. #define trap_13_wwl    bios
  840. #define trap_13_wwlwww    bios
  841.  
  842. #define trap_14_w    xbios
  843. #define trap_14_ww    xbios
  844. #define trap_14_wl    xbios
  845. #define trap_14_www    xbios
  846. #define trap_14_wwl    xbios
  847. #define trap_14_wwll    xbios
  848. #define trap_14_wllw    xbios
  849. #define trap_14_wlll    xbios
  850. #define trap_14_wwwl    xbios
  851. #define trap_14_wwwwl    xbios
  852. #define trap_14_wllww    xbios
  853. #define trap_14_wwwwwww    xbios
  854. #define trap_14_wllwwwww    xbios
  855. #define trap_14_wllwwwwlw    xbios
  856. #define trap_14_wllwwwwwlw    xbios
  857.  
  858. #  endif /* __MSHORT__ */
  859.  
  860. #endif /* __GNUC_INLINE__ */
  861.  
  862.  
  863. /* DEFINITIONS FOR OS FUNCTIONS */
  864.  
  865. /*
  866.  *     GEMDOS  (trap1)
  867.  */
  868. #define           Pterm0()                                      \
  869.        (void)trap_1_w((short)(0x00))
  870. #define           Cconin()                               \
  871.        (long)trap_1_w((short)(0x01))
  872. #define           Cconout(c)                           \
  873.        (void)trap_1_ww((short)(0x02),(short)(c))
  874. #define           Cauxin()                               \
  875.        (long)trap_1_w((short)(0x03))
  876. #define           Cauxout(c)                           \
  877.        (void)trap_1_ww((short)(0x04),(short)(c))
  878. #define           Cprnout(c)                           \
  879.        (void)trap_1_ww((short)(0x05),(short)(c))
  880. #define           Crawio(data)                           \
  881.        (long)trap_1_ww((short)(0x06),(short)(data))
  882. #define           Crawcin()                           \
  883.        (long)trap_1_w((short)(0x07))
  884. #define           Cnecin()                               \
  885.        (long)trap_1_w((short)(0x08))
  886. #define           Cconws(s)                           \
  887.        (void)trap_1_wl((short)(0x09),(long)(s))
  888. #define           Cconrs(buf)                           \
  889.        (void)trap_1_wl((short)(0x0A),(long)(buf))
  890. #define           Cconis()                               \
  891.        (short)trap_1_w((short)(0x0B))
  892. #define           Dsetdrv(d)                           \
  893.        (long)trap_1_ww((short)(0x0E),(short)(d))
  894. #define           Cconos()                               \
  895.        (short)trap_1_w((short)(0x10))
  896. #define           Cprnos()                               \
  897.        (short)trap_1_w((short)(0x11))
  898. #define           Cauxis()                               \
  899.        (short)trap_1_w((short)(0x12))
  900. #define           Cauxos()                               \
  901.        (short)trap_1_w((short)(0x13))
  902. #define           Dgetdrv()                           \
  903.        (short)trap_1_w((short)(0x19))
  904. #define           Fsetdta(dta)                           \
  905.        (void)trap_1_wl((short)(0x1A),(long)(dta))
  906.  
  907. /*
  908.  * The next binding is not quite right if used in another than the usual ways:
  909.  *    1. Super(1L) from either user or supervisor mode
  910.  *    2. ret = Super(0L) from user mode and after this Super(ret) from
  911.  *       supervisor mode
  912.  * We get the following situations (usp, ssp relative to the start of Super):
  913.  *    Parameter    Userstack    Superstack    Calling Mode    ret
  914.  *       1L           usp           ssp            user     0L
  915.  *       1L           usp           ssp         supervisor    -1L
  916.  *       0L          usp-6           usp            user    ssp
  917.  *       0L           ssp          ssp-6         supervisor   ssp-6
  918.  *      ptr          usp-6          ptr+6            user    ssp
  919.  *      ptr          usp+6           ptr         supervisor     sr
  920.  * The usual C-bindings are safe only because the "unlk a6" is compensating
  921.  * the errors when you invoke this function. In this binding the "unlk a6" at
  922.  * the end of the calling function compensates the error made in sequence 2
  923.  * above (the usp is 6 to low after the first call which is not corrected by
  924.  * the second call).
  925.  */
  926. #define           Super(ptr)                           \
  927.        (long)trap_1_wl((short)(0x20),(long)(ptr))
  928.     /* Tos 1.4: Super(1L) : rets -1L if in super mode, 0L otherwise */
  929. #define           Tgetdate()                           \
  930.        (short)trap_1_w((short)(0x2A))
  931. #define           Tsetdate(date)                           \
  932.        (long)trap_1_ww((short)(0x2B),(short)(date))
  933. #define           Tgettime()                           \
  934.        (short)trap_1_w((short)(0x2C))
  935. #define           Tsettime(time)                           \
  936.        (long)trap_1_ww((short)(0x2D),(short)(time))
  937. #define           Fgetdta()                           \
  938.        (long)trap_1_w((short)(0x2F))
  939. #define           Sversion()                           \
  940.        (short)trap_1_w((short)(0x30))
  941. #define           Ptermres(save,rv)                       \
  942.        (void)trap_1_wlw((short)(0x31),(long)(save),(short)(rv))
  943. #define           Dfree(buf,d)                           \
  944.        (long)trap_1_wlw((short)(0x36),(long)(buf),(short)(d))
  945. #define           Dcreate(path)                           \
  946.        (short)trap_1_wl((short)(0x39),(long)(path))
  947. #define           Ddelete(path)                           \
  948.        (long)trap_1_wl((short)(0x3A),(long)(path))
  949. #define           Dsetpath(path)                           \
  950.        (long)trap_1_wl((short)(0x3B),(long)(path))
  951. #define           Fcreate(fn,mode)                           \
  952.        (long)trap_1_wlw((short)(0x3C),(long)(fn),(short)(mode))
  953. #define           Fopen(fn,mode)                           \
  954.        (long)trap_1_wlw((short)(0x3D),(long)(fn),(short)(mode))
  955. #define           Fclose(handle)                           \
  956.        (long)trap_1_ww((short)(0x3E),(short)(handle))
  957. #define           Fread(handle,cnt,buf)                       \
  958.        (long)trap_1_wwll((short)(0x3F),(short)(handle),           \
  959.              (long)(cnt),(long)(buf))
  960. #define           Fwrite(handle,cnt,buf)                       \
  961.        (long)trap_1_wwll((short)(0x40),(short)(handle),           \
  962.              (long)(cnt),(long)(buf))
  963. #define           Fdelete(fn)                           \
  964.        (long)trap_1_wl((short)(0x41),(long)(fn))
  965. #define           Fseek(where,handle,how)                       \
  966.        (long)trap_1_wlww((short)(0x42),(long)(where),           \
  967.              (short)(handle),(short)(how))
  968. #define           Fattrib(fn,rwflag,attr)                       \
  969.        (short)trap_1_wlww((short)(0x43),(long)(fn),           \
  970.               (short)(rwflag),(short)(attr))
  971. #define           Fdup(handle)                           \
  972.        (long)trap_1_ww((short)(0x45),(short)(handle))
  973. #define           Fforce(Hstd,Hnew)                       \
  974.        (long)trap_1_www((short)(0x46),(short)(Hstd),(short)(Hnew))
  975. #define           Dgetpath(buf,d)                           \
  976.        (long)trap_1_wlw((short)(0x47),(long)(buf),(short)(d))
  977. #define           Malloc(size)                           \
  978.        (long)trap_1_wl((short)(0x48),(long)(size))
  979. #define           Mfree(ptr)                           \
  980.        (long)trap_1_wl((short)(0x49),(long)(ptr))
  981. #define           Mshrink(ptr,size)                       \
  982.        (long)trap_1_wwll((short)(0x4A),(short)0,(long)(ptr),(long)(size))
  983. #define           Pexec(mode,prog,tail,env)               \
  984.        (long)trap_1_wwlll((short)(0x4B),(short)(mode),(long)(prog),   \
  985.                (long)(tail),(long)(env))
  986. #define           Pterm(rv)                           \
  987.        (void)trap_1_ww((short)(0x4C),(short)(rv))
  988. #define           Fsfirst(filespec,attr)                       \
  989.        (long)trap_1_wlw((short)(0x4E),(long)(filespec),(short)(attr))
  990. #define           Fsnext()                               \
  991.        (long)trap_1_w((short)(0x4F))
  992. #define           Frename(zero,old,new)                       \
  993.        (short)trap_1_wwll((short)(0x56),(short)(zero),           \
  994.               (long)(old),(long)(new))
  995. #define           Fdatime(timeptr,handle,rwflag)                   \
  996.        (long)trap_1_wlww((short)(0x57),(long)(timeptr),           \
  997.              (short)(handle),(short)(rwflag))
  998.  
  999.  
  1000.  
  1001. /*
  1002.  *     BIOS    (trap13)
  1003.  */
  1004. #define Getmpb(ptr)                           \
  1005.        (void)trap_13_wl((short)(0x00),(long)(ptr))
  1006. #define           Bconstat(dev)                           \
  1007.        (short)trap_13_ww((short)(0x01),(short)(dev))
  1008. #define           Bconin(dev)                           \
  1009.        (long)trap_13_ww((short)(0x02),(short)(dev))
  1010. #define           Bconout(dev,c)                           \
  1011.        (long)trap_13_www((short)(0x03),(short)(dev),(short)((c) & 0xFF))
  1012. /* since AHDI 3.1 there is a new call to Rwabs with one more parameter */
  1013. #define           Rwabs(rwflag,buf,n,sector,d)            \
  1014.        (long)trap_13_wwlwww((short)(0x04),(short)(rwflag),(long)(buf), \
  1015.                  (short)(n),(short)(sector),(short)(d))
  1016. #define           Setexc(vnum,vptr)                       \
  1017.        (void (*)())trap_13_wwl((short)(0x05),(short)(vnum),(long)(vptr))
  1018. #define           Tickcal()                           \
  1019.        (long)trap_13_w((short)(0x06))
  1020. #define           Getbpb(d)                           \
  1021.        (void *)trap_13_ww((short)(0x07),(short)(d))
  1022. #define           Bcostat(dev)                           \
  1023.        (short)trap_13_ww((short)(0x08),(short)(dev))
  1024. #define           Mediach(dev)                           \
  1025.        (short)trap_13_ww((short)(0x09),(short)(dev))
  1026. #define           Drvmap()                               \
  1027.        (long)trap_13_w((short)(0x0A))
  1028. #define           Kbshift(data)                           \
  1029.        (long)trap_13_ww((short)(0x0B),(short)(data))
  1030. #define           Getshift()                           \
  1031.     Kbshift(-1)
  1032.  
  1033.  
  1034. /*
  1035.  *     XBIOS   (trap14)
  1036.  */
  1037.  
  1038. #define           Initmous(type,param,vptr)                   \
  1039.        (void)trap_14_wwll((short)(0x00),(short)(type),           \
  1040.               (long)(param),(long)(vptr))
  1041. #define Ssbrk(size)                           \
  1042.        (void *)trap_14_ww((short)(0x01),(short)(size))
  1043. #define           Physbase()                           \
  1044.        (void *)trap_14_w((short)(0x02))
  1045. #define           Logbase()                           \
  1046.        (void *)trap_14_w((short)(0x03))
  1047. #define           Getrez()                               \
  1048.        (short)trap_14_w((short)(0x04))
  1049. #define           Setscreen(lscrn,pscrn,rez)                   \
  1050.        (void)trap_14_wllw((short)(0x05),(long)(lscrn),(long)(pscrn), \
  1051.               (short)(rez))
  1052. #define           Setpallete(palptr)                       \
  1053.        (void)trap_14_wl((short)(0x06),(long)(palptr))
  1054. #define           Setcolor(colornum,mixture)                   \
  1055.        (short)trap_14_www((short)(0x07),(short)(colornum),(short)(mixture))
  1056. #define           Floprd(buf,x,d,sect,trk,side,n)                   \
  1057.        (short)trap_14_wllwwwww((short)(0x08),(long)(buf),(long)(x), \
  1058.      (short)(d),(short)(sect),(short)(trk),(short)(side),(short)(n))
  1059. #define           Flopwr(buf,x,d,sect,trk,side,n)                   \
  1060.        (short)trap_14_wllwwwww((short)(0x09),(long)(buf),(long)(x), \
  1061.            (short)(d),(short)(sect),(short)(trk),(short)(side),(short)(n))
  1062. #define           Flopfmt(buf,x,d,spt,t,sd,i,m,v)               \
  1063.        (short)trap_14_wllwwwwwlw((short)(0x0A),(long)(buf),(long)(x), \
  1064.       (short)(d),(short)(spt),(short)(t),(short)(sd),(short)(i),  \
  1065.       (long)(m),(short)(v))
  1066. #define           Midiws(cnt,ptr)                           \
  1067.        (void)trap_14_wwl((short)(0x0C),(short)(cnt),(long)(ptr))
  1068. #define           Mfpint(vnum,vptr)                       \
  1069.        (void)trap_14_wwl((short)(0x0D),(short)(vnum),(long)(vptr))
  1070. #define           Iorec(ioDEV)                           \
  1071.        (void *)trap_14_ww((short)(0x0E),(short)(ioDEV))
  1072. #define           Rsconf(baud,flow,uc,rs,ts,sc)                   \
  1073.        (long)trap_14_wwwwwww((short)(0x0F),(short)(baud),(short)(flow), \
  1074.               (short)(uc),(short)(rs),(short)(ts),(short)(sc))
  1075.     /* ret old val: MSB -> ucr:8, rsr:8, tsr:8, scr:8 <- LSB */
  1076. #define           Keytbl(nrml,shft,caps)                       \
  1077.        (void *)trap_14_wlll((short)(0x10),(long)(nrml), \
  1078.                 (long)(shft),(long)(caps))
  1079. #define           Random()                               \
  1080.        (long)trap_14_w((short)(0x11))
  1081. #define           Protobt(buf,serial,dsktyp,exec)                   \
  1082.        (void)trap_14_wllww((short)(0x12),(long)(buf),(long)(serial), \
  1083.                (short)(dsktyp),(short)(exec))
  1084. #define           Flopver(buf,x,d,sect,trk,sd,n)                   \
  1085.        (short)trap_14_wllwwwww((short)(0x13),(long)(buf),(long)(x),(short)(d),\
  1086.            (short)(sect),(short)(trk),(short)(sd),(short)(n))
  1087. #define           Scrdmp()                               \
  1088.        (void)trap_14_w((short)(0x14))
  1089. #define           Cursconf(rate,attr)                       \
  1090.        (short)trap_14_www((short)(0x15),(short)(rate),(short)(attr))
  1091. #define           Settime(time)                           \
  1092.        (void)trap_14_wl((short)(0x16),(long)(time))
  1093. #define           Gettime()                           \
  1094.        (long)trap_14_w((short)(0x17))
  1095. #define           Bioskeys()                           \
  1096.        (void)trap_14_w((short)(0x18))
  1097. #define           Ikbdws(len_minus1,ptr)                       \
  1098.        (void)trap_14_wwl((short)(0x19),(short)(len_minus1),(long)(ptr))
  1099. #define           Jdisint(vnum)                           \
  1100.        (void)trap_14_ww((short)(0x1A),(short)(vnum))
  1101. #define           Jenabint(vnum)                           \
  1102.        (void)trap_14_ww((short)(0x1B),(short)(vnum))
  1103. #define           Giaccess(data,reg)                       \
  1104.        (short)trap_14_www((short)(0x1C),(short)(data),(short)(reg))
  1105. #define           Offgibit(ormask)                           \
  1106.        (void)trap_14_ww((short)(0x1D),(short)(ormask))
  1107. #define           Ongibit(andmask)                           \
  1108.        (void)trap_14_ww((short)(0x1E),(short)(andmask))
  1109. #define           Xbtimer(timer,ctrl,data,vptr)                   \
  1110.        (void)trap_14_wwwwl((short)(0x1E),(short)(timer),(short)(ctrl), \
  1111.                (short)(data),(long)(vptr))
  1112. #define           Dosound(ptr)                           \
  1113.        (void)trap_14_wl((short)(0x20),(long)(ptr))
  1114. #define           Setprt(config)                           \
  1115.        (short)trap_14_ww((short)(0x21),(short)(config))
  1116. #define           Kbdvbase()                           \
  1117.        (void (**)())trap_14_w((short)(0x22))
  1118. #define           Kbrate(delay,reprate)                       \
  1119.        (short)trap_14_www((short)(0x23),(short)(delay),(short)(reprate))
  1120. #define           Prtblk(pblkptr)                           \
  1121.        (void)trap_14_wl((short)(0x24),(long)(pblkptr)) /* obsolete ? */
  1122. #define           Vsync()                               \
  1123.        (void)trap_14_w((short)(0x25))
  1124. #define           Supexec(funcptr)                           \
  1125.        (long)trap_14_wl((short)(0x26),(long)(funcptr))
  1126. #define           Blitmode(flag)                           \
  1127.        (short)trap_14_ww((short)(0x40),(short)(flag))
  1128. /*
  1129.  * Flag:
  1130.  *  -1: get config
  1131.  * !-1: set config    previous config returned
  1132.  *    bit
  1133.  *     0    0 blit mode soft    1 blit mode hardware
  1134.  *     1    0 no blitter        1 blitter present
  1135.  *    2..14   reserved
  1136.  *     15    must be zero on set/returned as zero
  1137.  * blitmode (bit 0) forced to soft if no blitter(bit 1 == 0).
  1138.  */
  1139.  
  1140. /*
  1141.  * extensions for TT TOS
  1142.  */
  1143.  
  1144. #define         Mxalloc(amt,flag)                    \
  1145.     (long)trap_1_wlw((short)(0x44),(long)(amt),(short)(flag))
  1146. #define        Maddalt(start,size)                    \
  1147.     (long)trap_1_wll((short)(0x14),(long)(start),(long)(size))
  1148.  
  1149. #define            Setpalette(palptr)                    \
  1150.     (void)trap_14_wl((short)(0x06),(long)(palptr))
  1151. #define         EsetShift(mode)                        \
  1152.     (void)trap_14_ww((short)(80),(short)mode)
  1153. #define         EgetShift()                        \
  1154.     (short)trap_14_w((short)(81))
  1155. #define         EsetBank(bank)                        \
  1156.     (short)trap_14_ww((short)(82),(short)bank)
  1157. #define         EsetColor(num,val)                    \
  1158.     (short)trap_14_www((short)(83),(short)num,(short)val)
  1159. #define         EsetPalette(start,count,ptr)                \
  1160.     (void)trap_14_wwwl((short)(84),(short)start,(short)count,(long)ptr)
  1161. #define         EgetPalette(start,count,ptr)                \
  1162.     (void)trap_14_wwwl((short)(85),(short)start,(short)count,(long)ptr)
  1163. #define         EsetGray(mode)                        \
  1164.     (short)trap_14_ww((short)(86),(short)mode)
  1165. #define         EsetSmear(mode)                        \
  1166.     (short)trap_14_ww((short)(87),(short)mode)
  1167. #define           Bconmap(dev)                           \
  1168.        (long)trap_14_ww((short)(0x2b),(short)(dev))
  1169. #define           Bconctl(opcode,operand)                                 \
  1170.        (long)trap_14_wwl((short)(0x2d),(short)(opcode),(long)(operand))
  1171.  
  1172. /*
  1173.  * General OS specific codes here
  1174.  *
  1175.  */
  1176.  
  1177. /* codes for Pexec */
  1178.  
  1179. #define           PE_LOADGO           0           /* load & go */
  1180. #define           PE_LOAD               3           /* just load */
  1181. #define           PE_GO               4           /* just go */
  1182. #define           PE_CBASEPAGE           5           /* just create basepage */
  1183. /* Tos 1.4: like 4, but memory ownership changed to child, and freed
  1184.    on exit
  1185.  */
  1186. #define           PE_GO_FREE           6           /* just go, then free */
  1187.  
  1188. /* codes for file access */
  1189.  
  1190. #define           FA_RDONLY           0x01
  1191. #define           FA_HIDDEN           0x02
  1192. #define           FA_SYSTEM           0x04
  1193. #define           FA_LABEL               0x08
  1194. #define           FA_DIR               0x10
  1195. #define           FA_CHANGED           0x20
  1196.  
  1197. /* struct used by Fsfirst/Fsnext */
  1198. typedef struct _dta {
  1199.     char        dta_buf[21];
  1200.     char        dta_attribute;
  1201.     unsigned short    dta_time;
  1202.     unsigned short    dta_date;
  1203.     long        dta_size;
  1204.     char        dta_name[14];
  1205. } _DTA;
  1206.  
  1207. /* structure returned by Fdatime */
  1208. typedef struct {
  1209.   short    time;
  1210.   short date;
  1211. } _DOSTIME;
  1212.  
  1213. /* device codes for Bconin/Bconout/Bcostat/Bconstat */
  1214. #define _PRT    0
  1215. #define _AUX    1
  1216. #define _CON    2
  1217. #define _MIDI    3
  1218. #define _IKBD    4
  1219. #define _RAWCON    5
  1220.  
  1221. /* struct returned by Getbpb */
  1222. typedef struct {
  1223.   short    recsiz;            /* bytes per sector */
  1224.   short    clsiz;            /* sectors per cluster */
  1225.   short clsizb;            /* bytes per cluster */
  1226.   short rdlen;            /* root directory size */
  1227.   short fsiz;            /* size of file allocation table */
  1228.   short fatrec;            /* startsector of second FAT */
  1229.   short datrec;            /* first data sector */
  1230.   short numcl;            /* total number of clusters */
  1231.   short bflags;            /* some flags */
  1232. } _BPB;
  1233.  
  1234. /* struct returned by Iorec */
  1235. typedef struct {
  1236.     char    *ibuf;
  1237.     short    ibufsiz;
  1238.     short    ibufhd;
  1239.     short    ibuftl;
  1240.     short    ibuflow;
  1241.     short    ibufhi;
  1242. } _IOREC;
  1243.  
  1244. /* parameters for Cursconf */
  1245. #define CURS_HIDE    0
  1246. #define CURS_SHOW    1
  1247. #define CURS_BLINK    2
  1248. #define CURS_NOBLINK    3
  1249. #define CURS_SETRATE    4
  1250. #define CURS_GETRATE    5
  1251.  
  1252. /* struct returned by Kbdvbase */
  1253. typedef struct {
  1254.     void    (*midivec)();
  1255.     void    (*vkbderr)();
  1256.     void    (*vmiderr)();
  1257.     void    (*statvec)();
  1258.     void    (*mousevec)();
  1259.     void    (*clockvec)();
  1260.     void    (*joyvec)();
  1261.     long    (*midisys)();
  1262.     long    (*ikbdsys)();
  1263.     char    kbstate;
  1264. } _KBDVECS;
  1265.  
  1266. #endif /* _OSBIND_H */
  1267.