home *** CD-ROM | disk | FTP | other *** search
/ Computer Club Elmshorn Atari PD / CCE_PD.iso / pc / 0400 / CCE_0423.ZIP / CCE_0423.PD / INCLUD83.ZOO / osbind.h < prev    next >
C/C++ Source or Header  |  1992-07-20  |  40KB  |  1,247 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.  
  99. #ifndef _OSBIND_H
  100. #define _OSBIND_H
  101.  
  102. #ifndef _COMPILER_H
  103. #include <compiler.h>
  104. #endif
  105.  
  106. #ifdef __cplusplus
  107. extern "C" {
  108. #endif
  109.  
  110. #ifndef _OSTRUCT_H
  111. #include <ostruct.h>
  112. #endif
  113.  
  114. /* want to skip all the gory details of GNU C inlines??
  115.    search for the string "DEFINITIONS" */
  116.  
  117. #ifdef __GNUC_INLINE__
  118. /*
  119.  * GNU C (pseudo inline) Statement Exprs for traps
  120.  *
  121.  */
  122.  
  123. #define trap_1_w(n)                            \
  124. ({                                    \
  125.     register long retvalue __asm__("d0");                \
  126.                                         \
  127.     __asm__ volatile                        \
  128.     ("\
  129.         movw    %1,sp@-; \
  130.         trap    #1;    \
  131.         addqw   #2,sp "                        \
  132.     : "=r"(retvalue)            /* outputs */        \
  133.     : "g"(n)                /* inputs  */        \
  134.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  135.     );                                \
  136.     retvalue;                            \
  137. })
  138.  
  139. #define trap_1_ww(n, a)                            \
  140. ({                                    \
  141.     register long retvalue __asm__("d0");                \
  142.     short _a = (short)(a);                        \
  143.                                         \
  144.     __asm__ volatile                        \
  145.     ("\
  146.         movw    %2,sp@-; \
  147.         movw    %1,sp@-; \
  148.         trap    #1;    \
  149.         addqw   #4,sp "                        \
  150.     : "=r"(retvalue)            /* outputs */        \
  151.     : "g"(n), "r"(_a)            /* inputs  */        \
  152.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  153.     );                                \
  154.     retvalue;                            \
  155. })
  156.  
  157. #define trap_1_wl(n, a)                            \
  158. ({                                    \
  159.     register long retvalue __asm__("d0");                \
  160.     long  _a = (long) (a);                        \
  161.                                         \
  162.     __asm__ volatile                        \
  163.     ("\
  164.         movl    %2,sp@-; \
  165.         movw    %1,sp@-; \
  166.         trap    #1;    \
  167.         addqw   #6,sp "                        \
  168.     : "=r"(retvalue)            /* outputs */        \
  169.     : "g"(n), "r"(_a)            /* inputs  */        \
  170.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  171.     );                                \
  172.     retvalue;                            \
  173. })
  174.  
  175. #define trap_1_wlw(n, a, b)                        \
  176. ({                                    \
  177.     register long retvalue __asm__("d0");                \
  178.     long  _a = (long) (a);                        \
  179.     short _b = (short)(b);                        \
  180.                                         \
  181.     __asm__ volatile                        \
  182.     ("\
  183.         movw    %3,sp@-; \
  184.         movl    %2,sp@-; \
  185.         movw    %1,sp@-; \
  186.         trap    #1;    \
  187.         addqw   #8,sp "                        \
  188.     : "=r"(retvalue)            /* outputs */        \
  189.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  190.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  191.     );                                \
  192.     retvalue;                            \
  193. })
  194.  
  195. #define trap_1_wwll(n, a, b, c)                        \
  196. ({                                    \
  197.     register long retvalue __asm__("d0");                \
  198.     short _a = (short)(a);                        \
  199.     long  _b = (long) (b);                        \
  200.     long  _c = (long) (c);                        \
  201.                                         \
  202.     __asm__ volatile                        \
  203.     ("\
  204.         movl    %4,sp@-; \
  205.         movl    %3,sp@-; \
  206.         movw    %2,sp@-; \
  207.         movw    %1,sp@-; \
  208.         trap    #1;    \
  209.         addw    #12,sp "                    \
  210.     : "=r"(retvalue)            /* outputs */        \
  211.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  212.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  213.     );                                \
  214.     retvalue;                            \
  215. })
  216.  
  217. #define trap_1_wlww(n, a, b, c)                        \
  218. ({                                    \
  219.     register long retvalue __asm__("d0");                \
  220.     long  _a = (long) (a);                        \
  221.     short _b = (short)(b);                        \
  222.     short _c = (short)(c);                        \
  223.                                         \
  224.     __asm__ volatile                        \
  225.     ("\
  226.         movw    %4,sp@-; \
  227.         movw    %3,sp@-; \
  228.         movl    %2,sp@-; \
  229.         movw    %1,sp@-; \
  230.         trap    #1;    \
  231.         addw    #10,sp "                    \
  232.     : "=r"(retvalue)            /* outputs */        \
  233.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  234.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  235.     );                                \
  236.     retvalue;                            \
  237. })
  238.  
  239. #define trap_1_www(n, a, b)                        \
  240. ({                                    \
  241.     register long retvalue __asm__("d0");                \
  242.     short _a = (short)(a);                        \
  243.     short _b = (short)(b);                        \
  244.                                         \
  245.     __asm__ volatile                        \
  246.     ("\
  247.         movw    %3,sp@-; \
  248.         movw    %2,sp@-; \
  249.         movw    %1,sp@-; \
  250.         trap    #1;    \
  251.         addqw   #6,sp "                        \
  252.     : "=r"(retvalue)            /* outputs */        \
  253.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  254.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  255.     );                                \
  256.     retvalue;                            \
  257. })
  258.  
  259. #define trap_1_wll(n, a, b)                        \
  260. ({                                    \
  261.     register long retvalue __asm__("d0");                \
  262.     long  _a = (long) (a);                        \
  263.     long  _b = (long) (b);                        \
  264.                                         \
  265.     __asm__ volatile                        \
  266.     ("\
  267.         movl    %3,sp@-; \
  268.         movl    %2,sp@-; \
  269.         movw    %1,sp@-; \
  270.         trap    #1;    \
  271.         addw    #10,sp "                    \
  272.     : "=r"(retvalue)            /* outputs */        \
  273.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  274.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  275.     );                                \
  276.     retvalue;                            \
  277. })
  278.  
  279. #define trap_1_wwlll(n, a, b, c, d)                    \
  280. ({                                    \
  281.     register long retvalue __asm__("d0");                \
  282.     short _a = (short)(a);            \
  283.     long  _b = (long) (b);            \
  284.     long  _c = (long) (c);            \
  285.     long  _d = (long) (d);            \
  286.                                         \
  287.     __asm__ volatile                        \
  288.     ("\
  289.         movl    %4,sp@-; \
  290.         movl    %3,sp@-; \
  291.         movl    %2,sp@-; \
  292.         movw    %1,sp@-; \
  293.         movw    %0,sp@- "                    \
  294.     :                         /* outputs */    \
  295.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  296.         );                                \
  297.   /* no more than 5 operand allowed in asm() -- therefore the split */  \
  298.                                     \
  299.     __asm__ volatile                        \
  300.     ("\
  301.         trap    #1;    \
  302.         addw    #16,sp "                    \
  303.     : "=r"(retvalue)            /* outputs */        \
  304.     :                    /* inputs  */        \
  305.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  306.     );                                \
  307.     retvalue;                            \
  308. })
  309.  
  310. #define trap_13_wl(n, a)                        \
  311. ({                                    \
  312.     register long retvalue __asm__("d0");                \
  313.     long  _a = (long) (a);                        \
  314.                                         \
  315.     __asm__ volatile                        \
  316.     ("\
  317.         movl    %2,sp@-; \
  318.         movw    %1,sp@-; \
  319.         trap    #13;    \
  320.         addqw   #6,sp "                        \
  321.     : "=r"(retvalue)            /* outputs */        \
  322.     : "g"(n), "r"(_a)            /* inputs  */        \
  323.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  324.     );                                \
  325.     retvalue;                            \
  326. })
  327.  
  328. #define trap_13_w(n)                            \
  329. ({                                    \
  330.     register long retvalue __asm__("d0");                \
  331.                                         \
  332.     __asm__ volatile                        \
  333.     ("\
  334.         movw    %1,sp@-; \
  335.         trap    #13;    \
  336.         addqw   #2,sp "                        \
  337.     : "=r"(retvalue)            /* outputs */        \
  338.     : "g"(n)                /* inputs  */        \
  339.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  340.     );                                \
  341.     retvalue;                            \
  342. })
  343.  
  344. #define trap_13_ww(n, a)                        \
  345. ({                                    \
  346.     register long retvalue __asm__("d0");                \
  347.     short _a = (short)(a);                        \
  348.                                         \
  349.     __asm__ volatile                        \
  350.     ("\
  351.         movw    %2,sp@-; \
  352.         movw    %1,sp@-; \
  353.         trap    #13;    \
  354.         addqw   #4,sp "                        \
  355.     : "=r"(retvalue)            /* outputs */        \
  356.     : "g"(n), "r"(_a)            /* inputs  */        \
  357.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  358.     );                                \
  359.     retvalue;                            \
  360. })
  361.  
  362. #define trap_13_www(n, a, b)                        \
  363. ({                                    \
  364.     register long retvalue __asm__("d0");                \
  365.     short _a = (short)(a);                        \
  366.     short _b = (short)(b);                        \
  367.                                         \
  368.     __asm__ volatile                        \
  369.     ("\
  370.         movw    %3,sp@-; \
  371.         movw    %2,sp@-; \
  372.         movw    %1,sp@-; \
  373.         trap    #13;    \
  374.         addqw   #6,sp "                        \
  375.     : "=r"(retvalue)            /* outputs */        \
  376.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  377.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  378.     );                                \
  379.     retvalue;                            \
  380. })
  381.  
  382. #define trap_13_wwlwww(n, a, b, c, d, e)                \
  383. ({                                    \
  384.     register long retvalue __asm__("d0");                \
  385.     short _a = (short)(a);            \
  386.     long  _b = (long) (b);            \
  387.     short _c = (short)(c);            \
  388.     short _d = (short)(d);            \
  389.     short _e = (short)(e);            \
  390.                                         \
  391.     __asm__ volatile                        \
  392.     ("\
  393.         movw    %4,sp@-; \
  394.         movw    %3,sp@-; \
  395.         movw    %2,sp@-; \
  396.         movl    %1,sp@-; \
  397.         movw    %0,sp@-    "                    \
  398.     :                          /* outputs */    \
  399.     : "r"(_a), "r"(_b), "r"(_c), "r"(_d), "r"(_e) /* inputs  */    \
  400.     );                                \
  401.                                     \
  402.     __asm__ volatile                        \
  403.     ("\
  404.         movw    %1,sp@-; \
  405.         trap    #13;    \
  406.         addw    #14,sp "                    \
  407.     : "=r"(retvalue)            /* outputs */        \
  408.     : "g"(n)                /* inputs  */        \
  409.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  410.     );                                \
  411.     retvalue;                            \
  412. })
  413.  
  414. #define trap_13_wwl(n, a, b)                        \
  415. ({                                    \
  416.     register long retvalue __asm__("d0");                \
  417.     short _a = (short)(a);                        \
  418.     long  _b = (long) (b);                        \
  419.                                         \
  420.     __asm__ volatile                        \
  421.     ("\
  422.         movl    %3,sp@-; \
  423.         movw    %2,sp@-; \
  424.         movw    %1,sp@-; \
  425.         trap    #13;    \
  426.         addqw   #8,sp "                        \
  427.     : "=r"(retvalue)            /* outputs */        \
  428.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  429.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  430.     );                                \
  431.     retvalue;                            \
  432. })
  433.  
  434. #define trap_14_wwl(n, a, b)                        \
  435. ({                                    \
  436.     register long retvalue __asm__("d0");                \
  437.     short _a = (short)(a);                        \
  438.     long  _b = (long) (b);                        \
  439.                                         \
  440.     __asm__ volatile                        \
  441.     ("\
  442.         movl    %3,sp@-; \
  443.         movw    %2,sp@-; \
  444.         movw    %1,sp@-; \
  445.         trap    #14;    \
  446.         addqw   #8,sp "                        \
  447.     : "=r"(retvalue)            /* outputs */        \
  448.     : "g"(n), "r"(_a), "r"(_b)              /* inputs  */        \
  449.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  450.     );                                \
  451.     retvalue;                            \
  452. })
  453.  
  454. #define trap_14_wwll(n, a, b, c)                    \
  455. ({                                    \
  456.     register long retvalue __asm__("d0");                \
  457.     short _a = (short)(a);                        \
  458.     long  _b = (long) (b);                        \
  459.     long  _c = (long) (c);                        \
  460.                                         \
  461.     __asm__ volatile                        \
  462.     ("\
  463.         movl    %4,sp@-; \
  464.         movl    %3,sp@-; \
  465.         movw    %2,sp@-; \
  466.         movw    %1,sp@-; \
  467.         trap    #14;    \
  468.         addw    #12,sp "                    \
  469.     : "=r"(retvalue)            /* outputs */        \
  470.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  471.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  472.     );                                \
  473.     retvalue;                            \
  474. })
  475.  
  476. #define trap_14_ww(n, a)                        \
  477. ({                                    \
  478.     register long retvalue __asm__("d0");                \
  479.     short _a = (short)(a);                        \
  480.                                         \
  481.     __asm__ volatile                        \
  482.     ("\
  483.         movw    %2,sp@-; \
  484.         movw    %1,sp@-; \
  485.         trap    #14;    \
  486.         addqw   #4,sp "                        \
  487.     : "=r"(retvalue)            /* outputs */        \
  488.     : "g"(n), "r"(_a)            /* inputs  */        \
  489.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  490.     );                                \
  491.     retvalue;                            \
  492. })
  493.  
  494. #define trap_14_w(n)                            \
  495. ({                                    \
  496.     register long retvalue __asm__("d0");                \
  497.                                         \
  498.     __asm__ volatile                        \
  499.     ("\
  500.         movw    %1,sp@-; \
  501.         trap    #14;    \
  502.         addqw   #2,sp "                        \
  503.     : "=r"(retvalue)            /* outputs */        \
  504.     : "g"(n)                /* inputs  */        \
  505.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  506.     );                                \
  507.     retvalue;                            \
  508. })
  509.  
  510. #define trap_14_wllw(n, a, b, c)                    \
  511. ({                                    \
  512.     register long retvalue __asm__("d0");                \
  513.     long  _a = (long) (a);                        \
  514.     long  _b = (long) (b);                        \
  515.     short _c = (short)(c);                        \
  516.                                         \
  517.     __asm__ volatile                        \
  518.     ("\
  519.         movw    %4,sp@-; \
  520.         movl    %3,sp@-; \
  521.         movl    %2,sp@-; \
  522.         movw    %1,sp@-; \
  523.         trap    #14;    \
  524.         addw    #12,sp "                    \
  525.     : "=r"(retvalue)            /* outputs */        \
  526.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)       /* inputs  */        \
  527.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  528.     );                                \
  529.     retvalue;                            \
  530. })
  531.  
  532. #define trap_14_wl(n, a)                        \
  533. ({                                    \
  534.     register long retvalue __asm__("d0");                \
  535.     long  _a = (long) (a);                        \
  536.                                         \
  537.     __asm__ volatile                        \
  538.     ("\
  539.         movl    %2,sp@-; \
  540.         movw    %1,sp@-; \
  541.         trap    #14;    \
  542.         addqw   #6,sp "                        \
  543.     : "=r"(retvalue)            /* outputs */        \
  544.     : "g"(n), "r"(_a)            /* inputs  */        \
  545.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  546.     );                                \
  547.     retvalue;                            \
  548. })
  549.  
  550. #define trap_14_www(n, a, b)                        \
  551. ({                                    \
  552.     register long retvalue __asm__("d0");                \
  553.     short _a = (short)(a);                        \
  554.     short _b = (short)(b);                        \
  555.                                         \
  556.     __asm__ volatile                        \
  557.     ("\
  558.         movw    %3,sp@-; \
  559.         movw    %2,sp@-; \
  560.         movw    %1,sp@-; \
  561.         trap    #14;    \
  562.         addqw   #6,sp "                        \
  563.     : "=r"(retvalue)            /* outputs */        \
  564.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  565.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  566.     );                                \
  567.     retvalue;                            \
  568. })
  569.  
  570. #define trap_14_wllwwwww(n, a, b, c, d, e, f, g)            \
  571. ({                                    \
  572.     register long retvalue __asm__("d0");                \
  573.     long  _a = (long) (a);                        \
  574.     long  _b = (long) (b);                        \
  575.     short _c = (short)(c);                        \
  576.     short _d = (short)(d);                        \
  577.     short _e = (short)(e);                        \
  578.     short _f = (short)(f);                        \
  579.     short _g = (short)(g);                        \
  580.                                         \
  581.     __asm__ volatile                        \
  582.     ("\
  583.         movw    %4,sp@-; \
  584.         movw    %3,sp@-; \
  585.         movw    %2,sp@-; \
  586.         movw    %1,sp@-; \
  587.         movw    %0,sp@-    "                    \
  588.     :                          /* outputs */    \
  589.     : "r"(_c), "r"(_d), "r"(_e), "r"(_f), "r"(_g) /* inputs  */    \
  590.     );                                \
  591.                                     \
  592.     __asm__ volatile                        \
  593.     ("\
  594.         movl    %3,sp@-; \
  595.         movl    %2,sp@-; \
  596.         movw    %1,sp@-; \
  597.         trap    #14;    \
  598.         addw    #20,sp "                    \
  599.     : "=r"(retvalue)            /* outputs */        \
  600.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  601.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  602.     );                                \
  603.     retvalue;                            \
  604. })
  605.  
  606. #define trap_14_wllwwwwlw(n, a, b, c, d, e, f, g, h)            \
  607. ({                                    \
  608.     register long retvalue __asm__("d0");                \
  609.     long  _a = (long) (a);                        \
  610.     long  _b = (long) (b);                        \
  611.     short _c = (short)(c);                        \
  612.     short _d = (short)(d);                        \
  613.     short _e = (short)(e);                        \
  614.     short _f = (short)(f);                        \
  615.     long  _g = (long) (g);                        \
  616.     short _h = (short)(h);                        \
  617.                                         \
  618.     __asm__ volatile                        \
  619.     ("\
  620.         movw    %4,sp@-; \
  621.         movl    %3,sp@-; \
  622.         movw    %2,sp@-; \
  623.         movw    %1,sp@-; \
  624.         movw    %0,sp@- "                    \
  625.     :                          /* outputs */    \
  626.     : "r"(_d), "r"(_e), "r"(_f), "r"(_g), "r"(_h) /* inputs  */    \
  627.     );                                \
  628.                                         \
  629.     __asm__ volatile                        \
  630.     ("\
  631.         movw    %4,sp@-; \
  632.         movl    %3,sp@-; \
  633.         movl    %2,sp@-; \
  634.         movw    %1,sp@-; \
  635.         trap    #14;    \
  636.         addw    #24,sp "                    \
  637.     : "=r"(retvalue)               /* outputs */    \
  638.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)        /* inputs  */    \
  639.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  640.     );                                \
  641.     retvalue;                            \
  642. })
  643.  
  644. #define trap_14_wllwwwwwlw(n, a, b, c, d, e, f, g, h, i)        \
  645. ({                                    \
  646.     register long retvalue __asm__("d0");                \
  647.     long  _a = (long) (a);                        \
  648.     long  _b = (long) (b);                        \
  649.     short _c = (short)(c);                        \
  650.     short _d = (short)(d);                        \
  651.     short _e = (short)(e);                        \
  652.     short _f = (short)(f);                        \
  653.     short _g = (short)(g);                        \
  654.     long  _h = (long) (h);                        \
  655.     short _i = (short)(i);                        \
  656.                                         \
  657.     __asm__ volatile                        \
  658.     ("\
  659.         movw    %4,sp@-; \
  660.         movl    %3,sp@-; \
  661.         movw    %2,sp@-; \
  662.         movw    %1,sp@-; \
  663.         movw    %0,sp@- "                    \
  664.     :                          /* outputs */    \
  665.     : "r"(_e), "r"(_f), "r"(_g), "r"(_h), "r"(_i) /* inputs  */    \
  666.     );                                \
  667.                                     \
  668.     __asm__ volatile                        \
  669.     ("\
  670.         movw    %4,sp@-; \
  671.         movw    %3,sp@-; \
  672.         movl    %2,sp@-; \
  673.         movl    %1,sp@-; \
  674.                 movw    %0,sp@- "                    \
  675.     :                         /* outputs */    \
  676.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  677.     );                                \
  678.                                         \
  679.     __asm__ volatile                        \
  680.     ("\
  681.         trap    #14;    \
  682.         addw    #26,sp "                    \
  683.     : "=r"(retvalue)            /* outputs */        \
  684.     :                     /* inputs  */        \
  685.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  686.     );                                \
  687.     retvalue;                            \
  688. })
  689.  
  690.  
  691. #define trap_14_wwwwwww(n, a, b, c, d, e, f)                \
  692. ({                                    \
  693.     register long retvalue __asm__("d0");                \
  694.     short _a = (short)(a);                        \
  695.     short _b = (short)(b);                        \
  696.     short _c = (short)(c);                        \
  697.     short _d = (short)(d);                        \
  698.     short _e = (short)(e);                        \
  699.     short _f = (short)(f);                        \
  700.                                         \
  701.     __asm__ volatile                        \
  702.     ("\
  703.         movw    %4,sp@-; \
  704.         movw    %3,sp@-; \
  705.         movw    %2,sp@-; \
  706.         movw    %1,sp@-; \
  707.         movw    %0,sp@- "                    \
  708.     :                            /* outputs */    \
  709.     : "r"(_b), "r"(_c), "r"(_d), "r"(_e), "r"(_f)    /* inputs  */    \
  710.     );                                \
  711.                                     \
  712.     __asm__ volatile                        \
  713.     ("\
  714.         movw    %2,sp@-; \
  715.         movw    %1,sp@-; \
  716.         trap    #14;    \
  717.         addw    #14,sp "                    \
  718.     : "=r"(retvalue)            /* outputs */        \
  719.     : "g"(n), "r"(_a)            /* inputs  */        \
  720.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  721.     );                                \
  722.     retvalue;                            \
  723. })
  724.  
  725. #define trap_14_wlll(n, a, b, c)                    \
  726. ({                                    \
  727.     register long retvalue __asm__("d0");                \
  728.     long  _a = (long) (a);                        \
  729.     long  _b = (long) (b);                        \
  730.     long  _c = (long) (c);                        \
  731.                                         \
  732.     __asm__ volatile                        \
  733.     ("\
  734.         movl    %4,sp@-; \
  735.         movl    %3,sp@-; \
  736.         movl    %2,sp@-; \
  737.         movw    %1,sp@-; \
  738.         trap    #14;    \
  739.         addw    #14,sp "                    \
  740.     : "=r"(retvalue)            /* outputs */        \
  741.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  742.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  743.     );                                \
  744.     retvalue;                            \
  745. })
  746.  
  747. #define trap_14_wllww(n, a, b, c, d)                    \
  748. ({                                    \
  749.     register long retvalue __asm__("d0");                \
  750.     long  _a = (long) (a);                        \
  751.     long  _b = (long) (b);                        \
  752.     short _c = (short)(c);                        \
  753.     short _d = (short)(d);                        \
  754.                                         \
  755.     __asm__ volatile                        \
  756.     ("\
  757.         movw    %3,sp@-; \
  758.         movw    %2,sp@-; \
  759.         movl    %1,sp@-; \
  760.         movl    %0,sp@- "                    \
  761.     :                    /* outputs */        \
  762.     : "r"(_a), "r"(_b), "r"(_c), "r"(_d)    /* inputs  */        \
  763.     );                                \
  764.                                     \
  765.     __asm__ volatile                        \
  766.     ("\
  767.         movw    %1,sp@-; \
  768.         trap    #14;    \
  769.         addw    #14,sp "                    \
  770.     : "=r"(retvalue)            /* outputs */        \
  771.     : "g"(n)                /* inputs  */        \
  772.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  773.     );                                \
  774.     retvalue;                            \
  775. })
  776.  
  777. #define trap_14_wwwwl(n, a, b, c, d)                    \
  778. ({                                    \
  779.     register long retvalue __asm__("d0");                \
  780.     short _a = (short)(a);                        \
  781.     short _b = (short)(b);                        \
  782.     short _c = (short)(c);                        \
  783.     long  _d = (long) (d);                        \
  784.                                         \
  785.     __asm__ volatile                        \
  786.     ("\
  787.         movl    %3,sp@-; \
  788.         movw    %2,sp@-; \
  789.         movw    %1,sp@-; \
  790.         movw    %0,sp@- "                    \
  791.     :                        /* outputs */    \
  792.     : "r"(_a), "r"(_b), "r"(_c), "r"(_d)        /* inputs  */    \
  793.     );                                \
  794.                                     \
  795.     __asm__ volatile                        \
  796.     ("\
  797.         movw    %1,sp@-; \
  798.         trap    #14;    \
  799.         addw    #12,sp "                    \
  800.     : "=r"(retvalue)            /* outputs */        \
  801.     : "g"(n)                /* inputs  */        \
  802.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  803.     );                                \
  804.     retvalue;                            \
  805. })
  806.  
  807. #define trap_14_wwwl(n, a, b, c)                    \
  808. ({                                    \
  809.     register long retvalue __asm__("d0");                \
  810.     short _a = (short)(a);                        \
  811.     short _b = (short)(b);                        \
  812.     long  _c = (long)(c);                        \
  813.                                         \
  814.     __asm__ volatile                        \
  815.     ("                                \
  816.         movl    %4,sp@-;                    \
  817.         movw    %3,sp@-;                    \
  818.         movw    %2,sp@-;                    \
  819.         movw    %1,sp@-;                    \
  820.         trap    #14;                        \
  821.         addqw   #6,sp "                        \
  822.     : "=r"(retvalue)            /* outputs */        \
  823.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)    /* inputs  */        \
  824.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  825.     );                                \
  826.     retvalue;                            \
  827. })
  828.  
  829. #else /* __GNUC_INLINE__ */
  830.  
  831. # ifndef __MSHORT__
  832. #  define _TRAP_X_
  833. # else
  834. #  ifdef __GNUC__
  835. #   ifndef __MINT__
  836. #    define _TRAP_X_
  837. #   endif
  838. #  endif
  839. # endif /* !__MSHORT__ */
  840.  
  841. # ifdef _TRAP_X_
  842. /* if inlines are not allowed, then declare things external */
  843. __EXTERN long trap_1_w __PROTO((short n));
  844. __EXTERN long trap_1_ww __PROTO((short n, short a));
  845. __EXTERN long trap_1_wl __PROTO((short n, long a));
  846. __EXTERN long trap_1_wlw __PROTO((short n, long a, short b));
  847. __EXTERN long trap_1_wwll __PROTO((short n, short a, long b, long c));
  848. __EXTERN long trap_1_wlww __PROTO((short n, long a, short b, short c));
  849. __EXTERN long trap_1_www __PROTO((short n, short a, short b));
  850. __EXTERN long trap_1_wll __PROTO((short n, long a, long b));
  851. __EXTERN long trap_1_wwlll __PROTO((short n, short a, long b, long c, long d));
  852. __EXTERN long trap_13_wl __PROTO((short n, long a));
  853. __EXTERN long trap_13_w __PROTO((short n));
  854. __EXTERN long trap_13_ww __PROTO((short n, short a));
  855. __EXTERN long trap_13_www __PROTO((short n, short a, short b));
  856. __EXTERN long trap_13_wwlwww __PROTO((short n, short a, long b, short c, short d, short e));
  857. __EXTERN long trap_13_wwl __PROTO((short n, short a, long b));
  858. __EXTERN long trap_14_wwl __PROTO((short n, short a, long b));
  859. __EXTERN long trap_14_wwll __PROTO((short n, short a, long b, long c));
  860. __EXTERN long trap_14_ww __PROTO((short n, short a));
  861. __EXTERN long trap_14_w __PROTO((short n));
  862. __EXTERN long trap_14_wllw __PROTO((short n, long a, long b, short c));
  863. __EXTERN long trap_14_wl __PROTO((short n, long a));
  864. __EXTERN long trap_14_www __PROTO((short n, short a, short b));
  865. __EXTERN long trap_14_wllwwwww __PROTO((short n, long a, long b, short c, short d, short e, short f, short g));
  866. __EXTERN long trap_14_wllwwwwlw __PROTO((short n, long a, long b, short c, short d, short e, short f, long g, short h));
  867. __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));
  868. __EXTERN long trap_14_wwwwwww __PROTO((short n, short a, short b, short c, short d, short e, short f));
  869. __EXTERN long trap_14_wlll __PROTO((short n, long a, long b, long c));
  870. __EXTERN long trap_14_wllww __PROTO((short n, long a, long b, short c, short d));
  871. __EXTERN long trap_14_wwwwl __PROTO((short n, short a, short b, short c, long d));
  872. __EXTERN long trap_14_wwwl __PROTO((short n, short a, short b, long c));
  873.  
  874. # else /* __TRAP_X__ */
  875.  
  876. __EXTERN long gemdos    __PROTO((short, ...));
  877. __EXTERN long bios    __PROTO((short, ...));
  878. __EXTERN long xbios    __PROTO((short, ...));
  879.  
  880. #define trap_1_w    gemdos
  881. #define trap_1_ww    gemdos
  882. #define trap_1_wl    gemdos
  883. #define trap_1_wlw    gemdos
  884. #define trap_1_www    gemdos
  885. #define trap_1_wll    gemdos
  886. #define trap_1_wwll    gemdos
  887. #define trap_1_wlww    gemdos
  888. #define trap_1_wwlll    gemdos
  889.  
  890. #define trap_13_w    bios
  891. #define trap_13_ww    bios
  892. #define trap_13_wl    bios
  893. #define trap_13_www    bios
  894. #define trap_13_wwl    bios
  895. #define trap_13_wwlwww    bios
  896.  
  897. #define trap_14_w    xbios
  898. #define trap_14_ww    xbios
  899. #define trap_14_wl    xbios
  900. #define trap_14_www    xbios
  901. #define trap_14_wwl    xbios
  902. #define trap_14_wwll    xbios
  903. #define trap_14_wllw    xbios
  904. #define trap_14_wlll    xbios
  905. #define trap_14_wwwl    xbios
  906. #define trap_14_wwwwl    xbios
  907. #define trap_14_wllww    xbios
  908. #define trap_14_wwwwwww    xbios
  909. #define trap_14_wllwwwww    xbios
  910. #define trap_14_wllwwwwlw    xbios
  911. #define trap_14_wllwwwwwlw    xbios
  912.  
  913. # endif /* _TRAP_X_ */
  914.  
  915. #endif /* __GNUC_INLINE__ */
  916.  
  917.  
  918. /* DEFINITIONS FOR OS FUNCTIONS */
  919.  
  920. /*
  921.  *     GEMDOS  (trap1)
  922.  */
  923. #define           Pterm0()                                      \
  924.        (void)trap_1_w((short)(0x00))
  925. #define           Cconin()                               \
  926.        (long)trap_1_w((short)(0x01))
  927. #define           Cconout(c)                           \
  928.        (void)trap_1_ww((short)(0x02),(short)(c))
  929. #define           Cauxin()                               \
  930.        (long)trap_1_w((short)(0x03))
  931. #define           Cauxout(c)                           \
  932.        (void)trap_1_ww((short)(0x04),(short)(c))
  933. #define           Cprnout(c)                           \
  934.        (void)trap_1_ww((short)(0x05),(short)(c))
  935. #define           Crawio(data)                           \
  936.        (long)trap_1_ww((short)(0x06),(short)(data))
  937. #define           Crawcin()                           \
  938.        (long)trap_1_w((short)(0x07))
  939. #define           Cnecin()                               \
  940.        (long)trap_1_w((short)(0x08))
  941. #define           Cconws(s)                           \
  942.        (void)trap_1_wl((short)(0x09),(long)(s))
  943. #define           Cconrs(buf)                           \
  944.        (void)trap_1_wl((short)(0x0A),(long)(buf))
  945. #define           Cconis()                               \
  946.        (short)trap_1_w((short)(0x0B))
  947. #define           Dsetdrv(d)                           \
  948.        (long)trap_1_ww((short)(0x0E),(short)(d))
  949. #define           Cconos()                               \
  950.        (short)trap_1_w((short)(0x10))
  951. #define           Cprnos()                               \
  952.        (short)trap_1_w((short)(0x11))
  953. #define           Cauxis()                               \
  954.        (short)trap_1_w((short)(0x12))
  955. #define           Cauxos()                               \
  956.        (short)trap_1_w((short)(0x13))
  957. #define           Dgetdrv()                           \
  958.        (short)trap_1_w((short)(0x19))
  959. #define           Fsetdta(dta)                           \
  960.        (void)trap_1_wl((short)(0x1A),(long)(dta))
  961.  
  962. /*
  963.  * The next binding is not quite right if used in another than the usual ways:
  964.  *    1. Super(1L) from either user or supervisor mode
  965.  *    2. ret = Super(0L) from user mode and after this Super(ret) from
  966.  *       supervisor mode
  967.  * We get the following situations (usp, ssp relative to the start of Super):
  968.  *    Parameter    Userstack    Superstack    Calling Mode    ret
  969.  *       1L           usp           ssp            user     0L
  970.  *       1L           usp           ssp         supervisor    -1L
  971.  *       0L          usp-6           usp            user    ssp
  972.  *       0L           ssp          ssp-6         supervisor   ssp-6
  973.  *      ptr          usp-6          ptr+6            user    ssp
  974.  *      ptr          usp+6           ptr         supervisor     sr
  975.  * The usual C-bindings are safe only because the "unlk a6" is compensating
  976.  * the errors when you invoke this function. In this binding the "unlk a6" at
  977.  * the end of the calling function compensates the error made in sequence 2
  978.  * above (the usp is 6 to low after the first call which is not corrected by
  979.  * the second call).
  980.  */
  981. #define           Super(ptr)                           \
  982.        (long)trap_1_wl((short)(0x20),(long)(ptr))
  983.     /* Tos 1.4: Super(1L) : rets -1L if in super mode, 0L otherwise */
  984. #define           Tgetdate()                           \
  985.        (short)trap_1_w((short)(0x2A))
  986. #define           Tsetdate(date)                           \
  987.        (long)trap_1_ww((short)(0x2B),(short)(date))
  988. #define           Tgettime()                           \
  989.        (short)trap_1_w((short)(0x2C))
  990. #define           Tsettime(time)                           \
  991.        (long)trap_1_ww((short)(0x2D),(short)(time))
  992. #define           Fgetdta()                           \
  993.        (long)trap_1_w((short)(0x2F))
  994. #define           Sversion()                           \
  995.        (short)trap_1_w((short)(0x30))
  996. #define           Ptermres(save,rv)                       \
  997.        (void)trap_1_wlw((short)(0x31),(long)(save),(short)(rv))
  998. #define           Dfree(buf,d)                           \
  999.        (long)trap_1_wlw((short)(0x36),(long)(buf),(short)(d))
  1000. #define           Dcreate(path)                           \
  1001.        (short)trap_1_wl((short)(0x39),(long)(path))
  1002. #define           Ddelete(path)                           \
  1003.        (long)trap_1_wl((short)(0x3A),(long)(path))
  1004. #define           Dsetpath(path)                           \
  1005.        (long)trap_1_wl((short)(0x3B),(long)(path))
  1006. #define           Fcreate(fn,mode)                           \
  1007.        (long)trap_1_wlw((short)(0x3C),(long)(fn),(short)(mode))
  1008. #define           Fopen(fn,mode)                           \
  1009.        (long)trap_1_wlw((short)(0x3D),(long)(fn),(short)(mode))
  1010. #define           Fclose(handle)                           \
  1011.        (long)trap_1_ww((short)(0x3E),(short)(handle))
  1012. #define           Fread(handle,cnt,buf)                       \
  1013.        (long)trap_1_wwll((short)(0x3F),(short)(handle),           \
  1014.              (long)(cnt),(long)(buf))
  1015. #define           Fwrite(handle,cnt,buf)                       \
  1016.        (long)trap_1_wwll((short)(0x40),(short)(handle),           \
  1017.              (long)(cnt),(long)(buf))
  1018. #define           Fdelete(fn)                           \
  1019.        (long)trap_1_wl((short)(0x41),(long)(fn))
  1020. #define           Fseek(where,handle,how)                       \
  1021.        (long)trap_1_wlww((short)(0x42),(long)(where),           \
  1022.              (short)(handle),(short)(how))
  1023. #define           Fattrib(fn,rwflag,attr)                       \
  1024.        (short)trap_1_wlww((short)(0x43),(long)(fn),           \
  1025.               (short)(rwflag),(short)(attr))
  1026. #define           Fdup(handle)                           \
  1027.        (long)trap_1_ww((short)(0x45),(short)(handle))
  1028. #define           Fforce(Hstd,Hnew)                       \
  1029.        (long)trap_1_www((short)(0x46),(short)(Hstd),(short)(Hnew))
  1030. #define           Dgetpath(buf,d)                           \
  1031.        (long)trap_1_wlw((short)(0x47),(long)(buf),(short)(d))
  1032. #define           Malloc(size)                           \
  1033.        (long)trap_1_wl((short)(0x48),(long)(size))
  1034. #define           Mfree(ptr)                           \
  1035.        (long)trap_1_wl((short)(0x49),(long)(ptr))
  1036. #define           Mshrink(ptr,size)                       \
  1037.        (long)trap_1_wwll((short)(0x4A),(short)0,(long)(ptr),(long)(size))
  1038. #define           Pexec(mode,prog,tail,env)               \
  1039.        (long)trap_1_wwlll((short)(0x4B),(short)(mode),(long)(prog),   \
  1040.                (long)(tail),(long)(env))
  1041. #define           Pterm(rv)                           \
  1042.        (void)trap_1_ww((short)(0x4C),(short)(rv))
  1043. #define           Fsfirst(filespec,attr)                       \
  1044.        (long)trap_1_wlw((short)(0x4E),(long)(filespec),(short)(attr))
  1045. #define           Fsnext()                               \
  1046.        (long)trap_1_w((short)(0x4F))
  1047. #define           Frename(zero,old,new)                       \
  1048.        (short)trap_1_wwll((short)(0x56),(short)(zero),           \
  1049.               (long)(old),(long)(new))
  1050. #define           Fdatime(timeptr,handle,rwflag)                   \
  1051.        (long)trap_1_wlww((short)(0x57),(long)(timeptr),           \
  1052.              (short)(handle),(short)(rwflag))
  1053.  
  1054.  
  1055.  
  1056. /*
  1057.  *     BIOS    (trap13)
  1058.  */
  1059. #define Getmpb(ptr)                           \
  1060.        (void)trap_13_wl((short)(0x00),(long)(ptr))
  1061. #define           Bconstat(dev)                           \
  1062.        (short)trap_13_ww((short)(0x01),(short)(dev))
  1063. #define           Bconin(dev)                           \
  1064.        (long)trap_13_ww((short)(0x02),(short)(dev))
  1065. #define           Bconout(dev,c)                           \
  1066.        (long)trap_13_www((short)(0x03),(short)(dev),(short)((c) & 0xFF))
  1067. /* since AHDI 3.1 there is a new call to Rwabs with one more parameter */
  1068. #define           Rwabs(rwflag,buf,n,sector,d)            \
  1069.        (long)trap_13_wwlwww((short)(0x04),(short)(rwflag),(long)(buf), \
  1070.                  (short)(n),(short)(sector),(short)(d))
  1071. #define           Setexc(vnum,vptr)                       \
  1072.        (void (*) __PROTO((void)))trap_13_wwl((short)(0x05),(short)(vnum),(long)(vptr))
  1073. #define           Tickcal()                           \
  1074.        (long)trap_13_w((short)(0x06))
  1075. #define           Getbpb(d)                           \
  1076.        (void *)trap_13_ww((short)(0x07),(short)(d))
  1077. #define           Bcostat(dev)                           \
  1078.        (short)trap_13_ww((short)(0x08),(short)(dev))
  1079. #define           Mediach(dev)                           \
  1080.        (short)trap_13_ww((short)(0x09),(short)(dev))
  1081. #define           Drvmap()                               \
  1082.        (long)trap_13_w((short)(0x0A))
  1083. #define           Kbshift(data)                           \
  1084.        (long)trap_13_ww((short)(0x0B),(short)(data))
  1085. #define           Getshift()                           \
  1086.     Kbshift(-1)
  1087.  
  1088.  
  1089. /*
  1090.  *     XBIOS   (trap14)
  1091.  */
  1092.  
  1093. #define           Initmous(type,param,vptr)                   \
  1094.        (void)trap_14_wwll((short)(0x00),(short)(type),           \
  1095.               (long)(param),(long)(vptr))
  1096. #define Ssbrk(size)                           \
  1097.        (void *)trap_14_ww((short)(0x01),(short)(size))
  1098. #define           Physbase()                           \
  1099.        (void *)trap_14_w((short)(0x02))
  1100. #define           Logbase()                           \
  1101.        (void *)trap_14_w((short)(0x03))
  1102. #define           Getrez()                               \
  1103.        (short)trap_14_w((short)(0x04))
  1104. #define           Setscreen(lscrn,pscrn,rez)                   \
  1105.        (void)trap_14_wllw((short)(0x05),(long)(lscrn),(long)(pscrn), \
  1106.               (short)(rez))
  1107. #define           Setpallete(palptr)                       \
  1108.        (void)trap_14_wl((short)(0x06),(long)(palptr))
  1109. #define           Setcolor(colornum,mixture)                   \
  1110.        (short)trap_14_www((short)(0x07),(short)(colornum),(short)(mixture))
  1111. #define           Floprd(buf,x,d,sect,trk,side,n)                   \
  1112.        (short)trap_14_wllwwwww((short)(0x08),(long)(buf),(long)(x), \
  1113.      (short)(d),(short)(sect),(short)(trk),(short)(side),(short)(n))
  1114. #define           Flopwr(buf,x,d,sect,trk,side,n)                   \
  1115.        (short)trap_14_wllwwwww((short)(0x09),(long)(buf),(long)(x), \
  1116.            (short)(d),(short)(sect),(short)(trk),(short)(side),(short)(n))
  1117. #define           Flopfmt(buf,x,d,spt,t,sd,i,m,v)               \
  1118.        (short)trap_14_wllwwwwwlw((short)(0x0A),(long)(buf),(long)(x), \
  1119.       (short)(d),(short)(spt),(short)(t),(short)(sd),(short)(i),  \
  1120.       (long)(m),(short)(v))
  1121. #define           Midiws(cnt,ptr)                           \
  1122.        (void)trap_14_wwl((short)(0x0C),(short)(cnt),(long)(ptr))
  1123. #define           Mfpint(vnum,vptr)                       \
  1124.        (void)trap_14_wwl((short)(0x0D),(short)(vnum),(long)(vptr))
  1125. #define           Iorec(ioDEV)                           \
  1126.        (void *)trap_14_ww((short)(0x0E),(short)(ioDEV))
  1127. #define           Rsconf(baud,flow,uc,rs,ts,sc)                   \
  1128.        (long)trap_14_wwwwwww((short)(0x0F),(short)(baud),(short)(flow), \
  1129.               (short)(uc),(short)(rs),(short)(ts),(short)(sc))
  1130.     /* ret old val: MSB -> ucr:8, rsr:8, tsr:8, scr:8 <- LSB */
  1131. #define           Keytbl(nrml,shft,caps)                       \
  1132.        (void *)trap_14_wlll((short)(0x10),(long)(nrml), \
  1133.                 (long)(shft),(long)(caps))
  1134. #define           Random()                               \
  1135.        (long)trap_14_w((short)(0x11))
  1136. #define           Protobt(buf,serial,dsktyp,exec)                   \
  1137.        (void)trap_14_wllww((short)(0x12),(long)(buf),(long)(serial), \
  1138.                (short)(dsktyp),(short)(exec))
  1139. #define           Flopver(buf,x,d,sect,trk,sd,n)                   \
  1140.        (short)trap_14_wllwwwww((short)(0x13),(long)(buf),(long)(x),(short)(d),\
  1141.            (short)(sect),(short)(trk),(short)(sd),(short)(n))
  1142. #define           Scrdmp()                               \
  1143.        (void)trap_14_w((short)(0x14))
  1144. #define           Cursconf(rate,attr)                       \
  1145.        (short)trap_14_www((short)(0x15),(short)(rate),(short)(attr))
  1146. #define           Settime(time)                           \
  1147.        (void)trap_14_wl((short)(0x16),(long)(time))
  1148. #define           Gettime()                           \
  1149.        (long)trap_14_w((short)(0x17))
  1150. #define           Bioskeys()                           \
  1151.        (void)trap_14_w((short)(0x18))
  1152. #define           Ikbdws(len_minus1,ptr)                       \
  1153.        (void)trap_14_wwl((short)(0x19),(short)(len_minus1),(long)(ptr))
  1154. #define           Jdisint(vnum)                           \
  1155.        (void)trap_14_ww((short)(0x1A),(short)(vnum))
  1156. #define           Jenabint(vnum)                           \
  1157.        (void)trap_14_ww((short)(0x1B),(short)(vnum))
  1158. #define           Giaccess(data,reg)                       \
  1159.        (short)trap_14_www((short)(0x1C),(short)(data),(short)(reg))
  1160. #define           Offgibit(ormask)                           \
  1161.        (void)trap_14_ww((short)(0x1D),(short)(ormask))
  1162. #define           Ongibit(andmask)                           \
  1163.        (void)trap_14_ww((short)(0x1E),(short)(andmask))
  1164. #define           Xbtimer(timer,ctrl,data,vptr)                   \
  1165.        (void)trap_14_wwwwl((short)(0x1F),(short)(timer),(short)(ctrl), \
  1166.                (short)(data),(long)(vptr))
  1167. #define           Dosound(ptr)                           \
  1168.        (void)trap_14_wl((short)(0x20),(long)(ptr))
  1169. #define           Setprt(config)                           \
  1170.        (short)trap_14_ww((short)(0x21),(short)(config))
  1171. #define           Kbdvbase()                           \
  1172.        (_KBDVECS*)trap_14_w((short)(0x22))
  1173. #define           Kbrate(delay,reprate)                       \
  1174.        (short)trap_14_www((short)(0x23),(short)(delay),(short)(reprate))
  1175. #define           Prtblk(pblkptr)                           \
  1176.        (void)trap_14_wl((short)(0x24),(long)(pblkptr)) /* obsolete ? */
  1177. #define           Vsync()                               \
  1178.        (void)trap_14_w((short)(0x25))
  1179. #define           Supexec(funcptr)                           \
  1180.        (long)trap_14_wl((short)(0x26),(long)(funcptr))
  1181. #define           Blitmode(flag)                           \
  1182.        (short)trap_14_ww((short)(0x40),(short)(flag))
  1183. /*
  1184.  * Flag:
  1185.  *  -1: get config
  1186.  * !-1: set config    previous config returned
  1187.  *    bit
  1188.  *     0    0 blit mode soft    1 blit mode hardware
  1189.  *     1    0 no blitter        1 blitter present
  1190.  *    2..14   reserved
  1191.  *     15    must be zero on set/returned as zero
  1192.  * blitmode (bit 0) forced to soft if no blitter(bit 1 == 0).
  1193.  */
  1194.  
  1195. /*
  1196.  * extensions for TT TOS
  1197.  */
  1198.  
  1199. #define         Mxalloc(amt,flag)                    \
  1200.     (long)trap_1_wlw((short)(0x44),(long)(amt),(short)(flag))
  1201. #define        Maddalt(start,size)                    \
  1202.     (long)trap_1_wll((short)(0x14),(long)(start),(long)(size))
  1203.  
  1204. #define            Setpalette(palptr)                    \
  1205.     (void)trap_14_wl((short)(0x06),(long)(palptr))
  1206. #define         EsetShift(mode)                        \
  1207.     (void)trap_14_ww((short)(80),(short)mode)
  1208. #define         EgetShift()                        \
  1209.     (short)trap_14_w((short)(81))
  1210. #define         EsetBank(bank)                        \
  1211.     (short)trap_14_ww((short)(82),(short)bank)
  1212. #define         EsetColor(num,val)                    \
  1213.     (short)trap_14_www((short)(83),(short)num,(short)val)
  1214. #define         EsetPalette(start,count,ptr)                \
  1215.     (void)trap_14_wwwl((short)(84),(short)start,(short)count,(long)ptr)
  1216. #define         EgetPalette(start,count,ptr)                \
  1217.     (void)trap_14_wwwl((short)(85),(short)start,(short)count,(long)ptr)
  1218. #define         EsetGray(mode)                        \
  1219.     (short)trap_14_ww((short)(86),(short)mode)
  1220. #define         EsetSmear(mode)                        \
  1221.     (short)trap_14_ww((short)(87),(short)mode)
  1222.  
  1223. #define        DMAread(sector,count,buffer,devno)            \
  1224.     (long)trap_14_wlwlw((short)0x2a,(long)sector,(short)count,(long)buffer, \
  1225.                 (short)devno)
  1226. #define        DMAwrite(sector,count,buffer,devno)            \
  1227.     (long)trap_14_wlwlw((short)0x2b,(long)sector,(short)count,(long)buffer, \
  1228.             (short)devno)
  1229. #define        Bconmap(dev)                        \
  1230.     (long)trap_14_ww((short)0x2c,(short)(dev))
  1231. #define        NVMaccess(op,start,count,buf)                \
  1232.     (short)trap_14_wwwwl((short)0x2e,(short)op,(short)start,(short)count, \
  1233.             (long)buf)
  1234.  
  1235. /*  Wake-up call for ST BOOK -- takes date/time pair in DOS format. */
  1236.  
  1237. #define           Waketime(w_date, w_time)                    \
  1238.        (void)trap_14_www((short)(0x2f),(unsigned short)(w_date),    \
  1239.                        (unsigned short)(w_time))
  1240.  
  1241.  
  1242. #ifdef __cplusplus
  1243. }
  1244. #endif
  1245.  
  1246. #endif /* _OSBIND_H */
  1247.