home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 August - Disc 3 / chip_20018103_hu.iso / amiga / chiputil / gg / libnixppc.lha / LibnixPPC-990408.lzx / os-include / powerup / ppcinline / macros.h
C/C++ Source or Header  |  1980-10-24  |  54KB  |  1,439 lines
  1. #ifndef __INLINE_MACROS_H
  2. #define __INLINE_MACROS_H
  3.  
  4. #include <powerup/gcclib/powerup_protos.h>
  5.  
  6. /* Use these macros to calculate cache flush start address and cache flush
  7. length. */
  8. #define __CACHE_START(start) ((void *) ((unsigned long int) (start) & ~31))
  9. #define __CACHE_LENGTH(start,length) ((((length) + (unsigned long int) (start) + 31) & ~31) - ((unsigned long int) (start) & ~31))
  10.  
  11. /*
  12.    General macros for Amiga function calls. Not all the possibilities have
  13.    been created - only the ones which exist in OS 3.1. Third party libraries
  14.    and future versions of AmigaOS will maybe need some new ones...
  15.  
  16.    LPX - functions that take X arguments.
  17.  
  18.    Modifiers (variations are possible):
  19.    NR - no return (void),
  20.    A4, A5 - "a4" or "a5" is used as one of the arguments,
  21.    UB - base will be given explicitly by user (see cia.resource).
  22.    FP - one of the parameters has type "pointer to function".
  23.  
  24.    "bt" arguments are not used - they are provided for backward compatibility
  25.    only.
  26.    Actually..the "bt" parameter is needed because otherwise the macro doesn`t
  27.    work for some reason i don`t know gcc puts an empty argument at the position
  28.    before the argument bn and without the placeholder "bt".
  29.    I think it has something to do with #define *_BASE_NAME
  30.  
  31.    the (cm1==IF_CACHEFLUSHAREA) conditional is optimized away
  32. */
  33.  
  34. #ifndef __INLINE_STUB_H
  35. #include <powerup/ppcinline/stubs.h>
  36. #endif
  37.  
  38. #ifndef POWERUP_PPCLIB_INTERFACE_H
  39. #include <powerup/ppclib/interface.h>
  40. #endif
  41.  
  42. #ifndef WARPUP /* PowerUp */
  43.  
  44. #define LP0(offs, rt, name, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  45. ({                                \
  46.    struct Caos *MyCaos;                        \
  47.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  48.    {                                \
  49.       rt _##name##_re;                        \
  50.       MyCaos->a6        = (ULONG) bn;            \
  51.       MyCaos->M68kCacheMode    =    cm1;            \
  52.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  53.       {                                \
  54.         MyCaos->M68kStart    =    cs1;            \
  55.         MyCaos->M68kLength    =    cl1;            \
  56.       }                                \
  57.       MyCaos->PPCCacheMode    =    cm2;            \
  58.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  59.       {                                \
  60.         MyCaos->PPCStart    =    cs2;            \
  61.         MyCaos->PPCLength    =    cl2;            \
  62.       }                                \
  63.       MyCaos->caos_Un.Offset    =    (-offs);        \
  64.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  65.       _##name##_re;                        \
  66.    }                                \
  67. })
  68.  
  69. #define LP0NR(offs, name, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  70. ({                                \
  71.    struct Caos *MyCaos;                        \
  72.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  73.    {                                \
  74.       MyCaos->a6        = (ULONG) bn;            \
  75.       MyCaos->M68kCacheMode    =    cm1;            \
  76.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  77.       {                                \
  78.         MyCaos->M68kStart    =    cs1;            \
  79.         MyCaos->M68kLength    =    cl1;            \
  80.       }                                \
  81.       MyCaos->PPCCacheMode    =    cm2;            \
  82.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  83.       {                                \
  84.         MyCaos->PPCStart    =    cs2;            \
  85.         MyCaos->PPCLength    =    cl2;            \
  86.       }                                \
  87.       MyCaos->caos_Un.Offset    =    (-offs);        \
  88.       PPCCallOS (MyCaos);                    \
  89.    }                                \
  90. })
  91.  
  92. #define LP1(offs, rt, name, t1, v1, r1, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  93. ({                                \
  94.    struct Caos *MyCaos;                        \
  95.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  96.    {                                \
  97.       rt _##name##_re;                        \
  98.       MyCaos->##r1        = (ULONG) v1;            \
  99.       MyCaos->a6        = (ULONG) bn;            \
  100.       MyCaos->M68kCacheMode    =    cm1;            \
  101.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  102.       {                                \
  103.         MyCaos->M68kStart    =    cs1;            \
  104.         MyCaos->M68kLength    =    cl1;            \
  105.       }                                \
  106.       MyCaos->PPCCacheMode    =    cm2;            \
  107.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  108.       {                                \
  109.         MyCaos->PPCStart    =    cs2;            \
  110.         MyCaos->PPCLength    =    cl2;            \
  111.       }                                \
  112.       MyCaos->caos_Un.Offset    =    (-offs);        \
  113.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  114.       _##name##_re;                        \
  115.    }                                \
  116. })
  117.  
  118. #define LP1NR(offs, name, t1, v1, r1, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  119. ({                                \
  120.    struct Caos *MyCaos;                        \
  121.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  122.    {                                \
  123.       MyCaos->##r1        = (ULONG) v1;            \
  124.       MyCaos->a6        = (ULONG) bn;            \
  125.       MyCaos->M68kCacheMode    =    cm1;            \
  126.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  127.       {                                \
  128.         MyCaos->M68kStart    =    cs1;            \
  129.         MyCaos->M68kLength    =    cl1;            \
  130.       }                                \
  131.       MyCaos->PPCCacheMode    =    cm2;            \
  132.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  133.       {                                \
  134.         MyCaos->PPCStart    =    cs2;            \
  135.         MyCaos->PPCLength    =    cl2;            \
  136.       }                                \
  137.       MyCaos->caos_Un.Offset    =    (-offs);        \
  138.       PPCCallOS (MyCaos);                    \
  139.    }                                \
  140. })
  141.  
  142. /* Only graphics.library/AttemptLockLayerRom() */
  143. #define LP1A5(offs, rt, name, t1, v1, r1, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  144. ({                                \
  145.    struct Caos *MyCaos;                        \
  146.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  147.    {                                \
  148.       rt _##name##_re;                        \
  149.       MyCaos->##r1        = (ULONG) v1;            \
  150.       MyCaos->a6        = (ULONG) bn;            \
  151.       MyCaos->M68kCacheMode    =    cm1;            \
  152.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  153.       {                                \
  154.         MyCaos->M68kStart    =    cs1;            \
  155.         MyCaos->M68kLength    =    cl1;            \
  156.       }                                \
  157.       MyCaos->PPCCacheMode    =    cm2;            \
  158.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  159.       {                                \
  160.         MyCaos->PPCStart    =    cs2;            \
  161.         MyCaos->PPCLength    =    cl2;            \
  162.       }                                \
  163.       MyCaos->caos_Un.Offset    =    (-offs);        \
  164.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  165.       _##name##_re;                        \
  166.    }                                \
  167. })
  168.  
  169. /* Only graphics.library/LockLayerRom() and graphics.library/UnlockLayerRom() */
  170. #define LP1NRA5(offs, name, t1, v1, r1, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  171. ({                                \
  172.    struct Caos *MyCaos;                        \
  173.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  174.    {                                \
  175.       MyCaos->##r1        = (ULONG) v1;            \
  176.       MyCaos->a6        = (ULONG) bn;            \
  177.       MyCaos->M68kCacheMode    =    cm1;            \
  178.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  179.       {                                \
  180.         MyCaos->M68kStart    =    cs1;            \
  181.         MyCaos->M68kLength    =    cl1;            \
  182.       }                                \
  183.       MyCaos->PPCCacheMode    =    cm2;            \
  184.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  185.       {                                \
  186.         MyCaos->PPCStart    =    cs2;            \
  187.         MyCaos->PPCLength    =    cl2;            \
  188.       }                                \
  189.       MyCaos->caos_Un.Offset    =    (-offs);        \
  190.       PPCCallOS (MyCaos);                    \
  191.    }                                \
  192. })
  193.  
  194. /* Only exec.library/Supervisor() */
  195. #define LP1A5FP(offs, rt, name, t1, v1, r1, bt, bn, fpt, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  196. ({                                \
  197.    typedef fpt;                            \
  198.    struct Caos *MyCaos;                        \
  199.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  200.    {                                \
  201.       rt _##name##_re;                        \
  202.       MyCaos->##r1        = (ULONG) v1;            \
  203.       MyCaos->a6        = (ULONG) bn;            \
  204.       MyCaos->M68kCacheMode    =    cm1;            \
  205.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  206.       {                                \
  207.         MyCaos->M68kStart    =    cs1;            \
  208.         MyCaos->M68kLength    =    cl1;            \
  209.       }                                \
  210.       MyCaos->PPCCacheMode    =    cm2;            \
  211.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  212.       {                                \
  213.         MyCaos->PPCStart    =    cs2;            \
  214.         MyCaos->PPCLength    =    cl2;            \
  215.       }                                \
  216.       MyCaos->caos_Un.Offset    =    (-offs);        \
  217.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  218.       _##name##_re;                        \
  219.    }                                \
  220. })
  221.  
  222.  
  223. #define LP2(offs, rt, name, t1, v1, r1, t2, v2, r2, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  224. ({                                \
  225.    struct Caos *MyCaos;                        \
  226.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  227.    {                                \
  228.       rt _##name##_re;                        \
  229.       MyCaos->##r1        = (ULONG) v1;            \
  230.       MyCaos->##r2        = (ULONG) v2;            \
  231.       MyCaos->a6        = (ULONG) bn;            \
  232.       MyCaos->M68kCacheMode    =    cm1;            \
  233.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  234.       {                                \
  235.         MyCaos->M68kStart    =    cs1;            \
  236.         MyCaos->M68kLength    =    cl1;            \
  237.       }                                \
  238.       MyCaos->PPCCacheMode    =    cm2;            \
  239.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  240.       {                                \
  241.         MyCaos->PPCStart    =    cs2;            \
  242.         MyCaos->PPCLength    =    cl2;            \
  243.       }                                \
  244.       MyCaos->caos_Un.Offset    =    (-offs);        \
  245.       _##name##_re = (rt) PPCCallOS (MyCaos);                      \
  246.       _##name##_re;                        \
  247.    }                                \
  248. })
  249.  
  250. #define LP2NR(offs, name, t1, v1, r1, t2, v2, r2, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  251. ({                                \
  252.    struct Caos *MyCaos;                        \
  253.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  254.    {                                \
  255.       MyCaos->##r1        = (ULONG) v1;            \
  256.       MyCaos->##r2        = (ULONG) v2;            \
  257.       MyCaos->a6        = (ULONG) bn;            \
  258.       MyCaos->M68kCacheMode    =    cm1;            \
  259.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  260.       {                                \
  261.         MyCaos->M68kStart    =    cs1;            \
  262.         MyCaos->M68kLength    =    cl1;            \
  263.       }                                \
  264.       MyCaos->PPCCacheMode    =    cm2;            \
  265.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  266.       {                                \
  267.         MyCaos->PPCStart    =    cs2;            \
  268.         MyCaos->PPCLength    =    cl2;            \
  269.       }                                \
  270.       MyCaos->caos_Un.Offset    =    (-offs);        \
  271.       PPCCallOS (MyCaos);                    \
  272.    }                                \
  273. })
  274.  
  275. /* Only cia.resource/AbleICR() and cia.resource/SetICR() */
  276. #define LP2UB(offs, rt, name, t1, v1, r1, t2, v2, r2, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  277. ({                                \
  278.    struct Caos *MyCaos;                        \
  279.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  280.    {                                \
  281.       rt _##name##_re;                        \
  282.       MyCaos->##r1        = (ULONG) v1;            \
  283.       MyCaos->##r2        = (ULONG) v2;            \
  284.       MyCaos->M68kCacheMode    =    cm1;            \
  285.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  286.       {                                \
  287.         MyCaos->M68kStart    =    cs1;            \
  288.         MyCaos->M68kLength    =    cl1;            \
  289.       }                                \
  290.       MyCaos->PPCCacheMode    =    cm2;            \
  291.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  292.       {                                \
  293.         MyCaos->PPCStart    =    cs2;            \
  294.         MyCaos->PPCLength    =    cl2;            \
  295.       }                                \
  296.       MyCaos->caos_Un.Offset    =    (-offs);        \
  297.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  298.       _##name##_re;                        \
  299.    }                                \
  300. })
  301.  
  302. /* Only dos.library/InternalUnLoadSeg() */
  303. #define LP2FP(offs, rt, name, t1, v1, r1, t2, v2, r2, bt, bn, fpt, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  304. ({                                \
  305.    typedef fpt;                            \
  306.    struct Caos *MyCaos;                        \
  307.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  308.    {                                \
  309.       rt _##name##_re;                        \
  310.       MyCaos->##r1        = (ULONG) v1;            \
  311.       MyCaos->##r2        = (ULONG) v2;            \
  312.       MyCaos->a6        = (ULONG) bn;            \
  313.       MyCaos->M68kCacheMode    =    cm1;            \
  314.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  315.       {                                \
  316.         MyCaos->M68kStart    =    cs1;            \
  317.         MyCaos->M68kLength    =    cl1;            \
  318.       }                                \
  319.       MyCaos->PPCCacheMode    =    cm2;            \
  320.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  321.       {                                \
  322.         MyCaos->PPCStart    =    cs2;            \
  323.         MyCaos->PPCLength    =    cl2;            \
  324.       }                                \
  325.       MyCaos->caos_Un.Offset    =    (-offs);        \
  326.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  327.       _##name##_re;                        \
  328.    }                                \
  329. })
  330.  
  331. #define LP3(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  332. ({                                \
  333.    struct Caos *MyCaos;                        \
  334.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  335.    {                                \
  336.       rt _##name##_re;                        \
  337.       MyCaos->##r1        = (ULONG) v1;            \
  338.       MyCaos->##r2        = (ULONG) v2;            \
  339.       MyCaos->##r3        = (ULONG) v3;            \
  340.       MyCaos->a6        = (ULONG) bn;            \
  341.       MyCaos->M68kCacheMode    =    cm1;            \
  342.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  343.       {                                \
  344.         MyCaos->M68kStart    =    cs1;            \
  345.         MyCaos->M68kLength    =    cl1;            \
  346.       }                                \
  347.       MyCaos->PPCCacheMode    =    cm2;            \
  348.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  349.       {                                \
  350.         MyCaos->PPCStart    =    cs2;            \
  351.         MyCaos->PPCLength    =    cl2;            \
  352.       }                                \
  353.       MyCaos->caos_Un.Offset    =    (-offs);        \
  354.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  355.       _##name##_re;                        \
  356.    }                                \
  357. })
  358.  
  359. #define LP3NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  360. ({                                \
  361.    struct Caos *MyCaos;                        \
  362.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  363.    {                                \
  364.       MyCaos->##r1        = (ULONG) v1;            \
  365.       MyCaos->##r2        = (ULONG) v2;            \
  366.       MyCaos->##r3        = (ULONG) v3;            \
  367.       MyCaos->a6        = (ULONG) bn;            \
  368.       MyCaos->M68kCacheMode    =    cm1;            \
  369.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  370.       {                                \
  371.         MyCaos->M68kStart    =    cs1;            \
  372.         MyCaos->M68kLength    =    cl1;            \
  373.       }                                \
  374.       MyCaos->PPCCacheMode    =    cm2;            \
  375.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  376.       {                                \
  377.         MyCaos->PPCStart    =    cs2;            \
  378.         MyCaos->PPCLength    =    cl2;            \
  379.       }                                \
  380.       MyCaos->caos_Un.Offset    =    (-offs);        \
  381.       PPCCallOS (MyCaos);                    \
  382.    }                                \
  383. })
  384.  
  385. /* Only cia.resource/AddICRVector() */
  386. #define LP3UB(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  387. ({                                \
  388.    struct Caos *MyCaos;                        \
  389.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  390.    {                                \
  391.       rt _##name##_re;                        \
  392.       MyCaos->##r1        = (ULONG) v1;            \
  393.       MyCaos->##r2        = (ULONG) v2;            \
  394.       MyCaos->##r3        = (ULONG) v3;            \
  395.       MyCaos->M68kCacheMode    =    cm1;            \
  396.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  397.       {                                \
  398.         MyCaos->M68kStart    =    cs1;            \
  399.         MyCaos->M68kLength    =    cl1;            \
  400.       }                                \
  401.       MyCaos->PPCCacheMode    =    cm2;            \
  402.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  403.       {                                \
  404.         MyCaos->PPCStart    =    cs2;            \
  405.         MyCaos->PPCLength    =    cl2;            \
  406.       }                                \
  407.       MyCaos->caos_Un.Offset    =    (-offs);        \
  408.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  409.       _##name##_re;                        \
  410.    }                                \
  411. })
  412.  
  413. /* Only cia.resource/RemICRVector() */
  414. #define LP3NRUB(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  415. ({                                \
  416.    struct Caos *MyCaos;                        \
  417.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  418.    {                                \
  419.       MyCaos->##r1        = (ULONG) v1;            \
  420.       MyCaos->##r2        = (ULONG) v2;            \
  421.       MyCaos->##r3        = (ULONG) v3;            \
  422.       MyCaos->M68kCacheMode    =    cm1;            \
  423.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  424.       {                                \
  425.         MyCaos->M68kStart    =    cs1;            \
  426.         MyCaos->M68kLength    =    cl1;            \
  427.       }                                \
  428.       MyCaos->PPCCacheMode    =    cm2;            \
  429.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  430.       {                                \
  431.         MyCaos->PPCStart    =    cs2;            \
  432.         MyCaos->PPCLength    =    cl2;            \
  433.       }                                \
  434.       MyCaos->caos_Un.Offset    =    (-offs);        \
  435.       PPCCallOS (MyCaos);                    \
  436.    }                                \
  437. })
  438.  
  439. /* Only exec.library/SetFunction() */
  440. #define LP3FP(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, bt, bn, fpt, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  441. ({                                \
  442.    typedef fpt;                            \
  443.    struct Caos *MyCaos;                        \
  444.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  445.    {                                \
  446.       rt _##name##_re;                        \
  447.       MyCaos->##r1        = (ULONG) v1;            \
  448.       MyCaos->##r2        = (ULONG) v2;            \
  449.       MyCaos->##r3        = (ULONG) v3;            \
  450.       MyCaos->a6        = (ULONG) bn;            \
  451.       MyCaos->M68kCacheMode    =    cm1;            \
  452.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  453.       {                                \
  454.         MyCaos->M68kStart    =    cs1;            \
  455.         MyCaos->M68kLength    =    cl1;            \
  456.       }                                \
  457.       MyCaos->PPCCacheMode    =    cm2;            \
  458.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  459.       {                                \
  460.         MyCaos->PPCStart    =    cs2;            \
  461.         MyCaos->PPCLength    =    cl2;            \
  462.       }                                \
  463.       MyCaos->caos_Un.Offset    =    (-offs);        \
  464.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  465.       _##name##_re;                        \
  466.    }                                \
  467. })
  468.  
  469. /* Only graphics.library/SetCollision() */
  470. #define LP3NRFP(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, bt, bn, fpt, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  471. ({                                \
  472.    typedef fpt;                            \
  473.    struct Caos *MyCaos;                        \
  474.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  475.    {                                \
  476.       MyCaos->##r1        = (ULONG) v1;            \
  477.       MyCaos->##r2        = (ULONG) v2;            \
  478.       MyCaos->##r3        = (ULONG) v3;            \
  479.       MyCaos->a6        = (ULONG) bn;            \
  480.       MyCaos->M68kCacheMode    =    cm1;            \
  481.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  482.       {                                \
  483.         MyCaos->M68kStart    =    cs1;            \
  484.         MyCaos->M68kLength    =    cl1;            \
  485.       }                                \
  486.       MyCaos->PPCCacheMode    =    cm2;            \
  487.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  488.       {                                \
  489.         MyCaos->PPCStart    =    cs2;            \
  490.         MyCaos->PPCLength    =    cl2;            \
  491.       }                                \
  492.       MyCaos->caos_Un.Offset    =    (-offs);        \
  493.       PPCCallOS (MyCaos);                    \
  494.    }                                \
  495. })
  496.  
  497. #define LP4(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  498. ({                                \
  499.    struct Caos *MyCaos;                        \
  500.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  501.    {                                \
  502.       rt _##name##_re;                        \
  503.       MyCaos->##r1        = (ULONG) v1;            \
  504.       MyCaos->##r2        = (ULONG) v2;            \
  505.       MyCaos->##r3        = (ULONG) v3;            \
  506.       MyCaos->##r4        = (ULONG) v4;            \
  507.       MyCaos->a6        = (ULONG) bn;            \
  508.       MyCaos->M68kCacheMode    =    cm1;            \
  509.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  510.       {                                \
  511.         MyCaos->M68kStart    =    cs1;            \
  512.         MyCaos->M68kLength    =    cl1;            \
  513.       }                                \
  514.       MyCaos->PPCCacheMode    =    cm2;            \
  515.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  516.       {                                \
  517.         MyCaos->PPCStart    =    cs2;            \
  518.         MyCaos->PPCLength    =    cl2;            \
  519.       }                                \
  520.       MyCaos->caos_Un.Offset    =    (-offs);        \
  521.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  522.       _##name##_re;                        \
  523.    }                                \
  524. })
  525.  
  526. #define LP4NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  527. ({                                \
  528.    struct Caos *MyCaos;                        \
  529.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  530.    {                                \
  531.       MyCaos->##r1        = (ULONG) v1;            \
  532.       MyCaos->##r2        = (ULONG) v2;            \
  533.       MyCaos->##r3        = (ULONG) v3;            \
  534.       MyCaos->##r4        = (ULONG) v4;            \
  535.       MyCaos->a6        = (ULONG) bn;            \
  536.       MyCaos->M68kCacheMode    =    cm1;            \
  537.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  538.       {                                \
  539.         MyCaos->M68kStart    =    cs1;            \
  540.         MyCaos->M68kLength    =    cl1;            \
  541.       }                                \
  542.       MyCaos->PPCCacheMode    =    cm2;            \
  543.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  544.       {                                \
  545.         MyCaos->PPCStart    =    cs2;            \
  546.         MyCaos->PPCLength    =    cl2;            \
  547.       }                                \
  548.       MyCaos->caos_Un.Offset    =    (-offs);        \
  549.       PPCCallOS (MyCaos);                    \
  550.    }                                \
  551. })
  552.  
  553. /* Only exec.library/RawDoFmt() */
  554. #define LP4FP(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, bt, bn, fpt, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  555. ({                                \
  556.    typedef fpt;                            \
  557.    struct Caos *MyCaos;                        \
  558.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  559.    {                                \
  560.       rt _##name##_re;                        \
  561.       MyCaos->##r1        = (ULONG) v1;            \
  562.       MyCaos->##r2        = (ULONG) v2;            \
  563.       MyCaos->##r3        = (ULONG) v3;            \
  564.       MyCaos->##r4        = (ULONG) v4;            \
  565.       MyCaos->a6        = (ULONG) bn;            \
  566.       MyCaos->M68kCacheMode    =    cm1;            \
  567.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  568.       {                                \
  569.         MyCaos->M68kStart    =    cs1;            \
  570.         MyCaos->M68kLength    =    cl1;            \
  571.       }                                \
  572.       MyCaos->PPCCacheMode    =    cm2;            \
  573.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  574.       {                                \
  575.         MyCaos->PPCStart    =    cs2;            \
  576.         MyCaos->PPCLength    =    cl2;            \
  577.       }                                \
  578.       MyCaos->caos_Un.Offset    =    (-offs);        \
  579.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  580.       _##name##_re;                        \
  581.    }                                \
  582. })
  583.  
  584. #define LP5(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  585. ({                                \
  586.    struct Caos *MyCaos;                        \
  587.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  588.    {                                \
  589.       rt _##name##_re;                        \
  590.       MyCaos->##r1        = (ULONG) v1;            \
  591.       MyCaos->##r2        = (ULONG) v2;            \
  592.       MyCaos->##r3        = (ULONG) v3;            \
  593.       MyCaos->##r4        = (ULONG) v4;            \
  594.       MyCaos->##r5        = (ULONG) v5;            \
  595.       MyCaos->a6        = (ULONG) bn;            \
  596.       MyCaos->M68kCacheMode    =    cm1;            \
  597.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  598.       {                                \
  599.         MyCaos->M68kStart    =    cs1;            \
  600.         MyCaos->M68kLength    =    cl1;            \
  601.       }                                \
  602.       MyCaos->PPCCacheMode    =    cm2;            \
  603.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  604.       {                                \
  605.         MyCaos->PPCStart    =    cs2;            \
  606.         MyCaos->PPCLength    =    cl2;            \
  607.       }                                \
  608.       MyCaos->caos_Un.Offset    =    (-offs);        \
  609.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  610.       _##name##_re;                        \
  611.    }                                \
  612. })
  613.  
  614. #define LP5NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  615. ({                                \
  616.    struct Caos *MyCaos;                        \
  617.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  618.    {                                \
  619.       MyCaos->##r1        = (ULONG) v1;            \
  620.       MyCaos->##r2        = (ULONG) v2;            \
  621.       MyCaos->##r3        = (ULONG) v3;            \
  622.       MyCaos->##r4        = (ULONG) v4;            \
  623.       MyCaos->##r5        = (ULONG) v5;            \
  624.       MyCaos->a6        = (ULONG) bn;            \
  625.       MyCaos->M68kCacheMode    =    cm1;            \
  626.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  627.       {                                \
  628.         MyCaos->M68kStart    =    cs1;            \
  629.         MyCaos->M68kLength    =    cl1;            \
  630.       }                                \
  631.       MyCaos->PPCCacheMode    =    cm2;            \
  632.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  633.       {                                \
  634.         MyCaos->PPCStart    =    cs2;            \
  635.         MyCaos->PPCLength    =    cl2;            \
  636.       }                                \
  637.       MyCaos->caos_Un.Offset    =    (-offs);        \
  638.       PPCCallOS (MyCaos);                    \
  639.    }                                \
  640. })
  641.  
  642. /* Only exec.library/MakeLibrary() */
  643. #define LP5FP(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, bt, bn, fpt, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  644. ({                                \
  645.    typedef fpt;                            \
  646.    struct Caos *MyCaos;                        \
  647.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  648.    {                                \
  649.       rt _##name##_re;                        \
  650.       MyCaos->##r1        = (ULONG) v1;            \
  651.       MyCaos->##r2        = (ULONG) v2;            \
  652.       MyCaos->##r3        = (ULONG) v3;            \
  653.       MyCaos->##r4        = (ULONG) v4;            \
  654.       MyCaos->##r5        = (ULONG) v5;            \
  655.       MyCaos->a6        = (ULONG) bn;            \
  656.       MyCaos->M68kCacheMode    =    cm1;            \
  657.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  658.       {                                \
  659.         MyCaos->M68kStart    =    cs1;            \
  660.         MyCaos->M68kLength    =    cl1;            \
  661.       }                                \
  662.       MyCaos->PPCCacheMode    =    cm2;            \
  663.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  664.       {                                \
  665.         MyCaos->PPCStart    =    cs2;            \
  666.         MyCaos->PPCLength    =    cl2;            \
  667.       }                                \
  668.       MyCaos->caos_Un.Offset    =    (-offs);        \
  669.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  670.       _##name##_re;                        \
  671.    }                                \
  672. })
  673.  
  674. #define LP6(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  675. ({                                \
  676.    struct Caos *MyCaos;                        \
  677.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  678.    {                                \
  679.       rt _##name##_re;                        \
  680.       MyCaos->##r1        = (ULONG) v1;            \
  681.       MyCaos->##r2        = (ULONG) v2;            \
  682.       MyCaos->##r3        = (ULONG) v3;            \
  683.       MyCaos->##r4        = (ULONG) v4;            \
  684.       MyCaos->##r5        = (ULONG) v5;            \
  685.       MyCaos->##r6        = (ULONG) v6;            \
  686.       MyCaos->a6        = (ULONG) bn;            \
  687.       MyCaos->M68kCacheMode    =    cm1;            \
  688.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  689.       {                                \
  690.         MyCaos->M68kStart    =    cs1;            \
  691.         MyCaos->M68kLength    =    cl1;            \
  692.       }                                \
  693.       MyCaos->PPCCacheMode    =    cm2;            \
  694.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  695.       {                                \
  696.         MyCaos->PPCStart    =    cs2;            \
  697.         MyCaos->PPCLength    =    cl2;            \
  698.       }                                \
  699.       MyCaos->caos_Un.Offset    =    (-offs);        \
  700.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  701.       _##name##_re;                        \
  702.    }                                \
  703. })
  704.  
  705. #define LP6NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  706. ({                                \
  707.    struct Caos *MyCaos;                        \
  708.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  709.    {                                \
  710.       MyCaos->##r1        = (ULONG) v1;            \
  711.       MyCaos->##r2        = (ULONG) v2;            \
  712.       MyCaos->##r3        = (ULONG) v3;            \
  713.       MyCaos->##r4        = (ULONG) v4;            \
  714.       MyCaos->##r5        = (ULONG) v5;            \
  715.       MyCaos->##r6        = (ULONG) v6;            \
  716.       MyCaos->a6        = (ULONG) bn;            \
  717.       MyCaos->M68kCacheMode    =    cm1;            \
  718.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  719.       {                                \
  720.         MyCaos->M68kStart    =    cs1;            \
  721.         MyCaos->M68kLength    =    cl1;            \
  722.       }                                \
  723.       MyCaos->PPCCacheMode    =    cm2;            \
  724.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  725.       {                                \
  726.         MyCaos->PPCStart    =    cs2;            \
  727.         MyCaos->PPCLength    =    cl2;            \
  728.       }                                \
  729.       MyCaos->caos_Un.Offset    =    (-offs);        \
  730.       PPCCallOS (MyCaos);                    \
  731.    }                                \
  732. })
  733.  
  734. #define LP7(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  735. ({                                \
  736.    struct Caos *MyCaos;                        \
  737.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  738.    {                                \
  739.       rt _##name##_re;                        \
  740.       MyCaos->##r1        = (ULONG) v1;            \
  741.       MyCaos->##r2        = (ULONG) v2;            \
  742.       MyCaos->##r3        = (ULONG) v3;            \
  743.       MyCaos->##r4        = (ULONG) v4;            \
  744.       MyCaos->##r5        = (ULONG) v5;            \
  745.       MyCaos->##r6        = (ULONG) v6;            \
  746.       MyCaos->##r7        = (ULONG) v7;            \
  747.       MyCaos->a6        = (ULONG) bn;            \
  748.       MyCaos->M68kCacheMode    =    cm1;            \
  749.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  750.       {                                \
  751.         MyCaos->M68kStart    =    cs1;            \
  752.         MyCaos->M68kLength    =    cl1;            \
  753.       }                                \
  754.       MyCaos->PPCCacheMode    =    cm2;            \
  755.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  756.       {                                \
  757.         MyCaos->PPCStart    =    cs2;            \
  758.         MyCaos->PPCLength    =    cl2;            \
  759.       }                                \
  760.       MyCaos->caos_Un.Offset    =    (-offs);        \
  761.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  762.       _##name##_re;                        \
  763.    }                                \
  764. })
  765.  
  766. #define LP7NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  767. ({                                \
  768.    struct Caos *MyCaos;                        \
  769.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  770.    {                                \
  771.       MyCaos->##r1        = (ULONG) v1;            \
  772.       MyCaos->##r2        = (ULONG) v2;            \
  773.       MyCaos->##r3        = (ULONG) v3;            \
  774.       MyCaos->##r4        = (ULONG) v4;            \
  775.       MyCaos->##r5        = (ULONG) v5;            \
  776.       MyCaos->##r6        = (ULONG) v6;            \
  777.       MyCaos->##r7        = (ULONG) v7;            \
  778.       MyCaos->a6        = (ULONG) bn;            \
  779.       MyCaos->M68kCacheMode    =    cm1;            \
  780.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  781.       {                                \
  782.         MyCaos->M68kStart    =    cs1;            \
  783.         MyCaos->M68kLength    =    cl1;            \
  784.       }                                \
  785.       MyCaos->PPCCacheMode    =    cm2;            \
  786.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  787.       {                                \
  788.         MyCaos->PPCStart    =    cs2;            \
  789.         MyCaos->PPCLength    =    cl2;            \
  790.       }                                \
  791.       MyCaos->caos_Un.Offset    =    (-offs);        \
  792.       PPCCallOS (MyCaos);                    \
  793.    }                                \
  794. })
  795.  
  796. /* Only workbench.library/AddAppIconA() */
  797. #define LP7A4(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  798. ({                                \
  799.    struct Caos *MyCaos;                        \
  800.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  801.    {                                \
  802.       rt _##name##_re;                        \
  803.       MyCaos->##r1        = (ULONG) v1;            \
  804.       MyCaos->##r2        = (ULONG) v2;            \
  805.       MyCaos->##r3        = (ULONG) v3;            \
  806.       MyCaos->##r4        = (ULONG) v4;            \
  807.       MyCaos->##r5        = (ULONG) v5;            \
  808.       MyCaos->##r6        = (ULONG) v6;            \
  809.       MyCaos->##r7        = (ULONG) v7;            \
  810.       MyCaos->a6        = (ULONG) bn;            \
  811.       MyCaos->M68kCacheMode    =    cm1;            \
  812.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  813.       {                                \
  814.         MyCaos->M68kStart    =    cs1;            \
  815.         MyCaos->M68kLength    =    cl1;            \
  816.       }                                \
  817.       MyCaos->PPCCacheMode    =    cm2;            \
  818.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  819.       {                                \
  820.         MyCaos->PPCStart    =    cs2;            \
  821.         MyCaos->PPCLength    =    cl2;            \
  822.       }                                \
  823.       MyCaos->caos_Un.Offset    =    (-offs);        \
  824.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  825.       _##name##_re;                        \
  826.    }                                \
  827. })
  828.  
  829. /* Would you believe that there really are beasts that need more than 7
  830.    arguments? :-) */
  831.  
  832. /* For example intuition.library/AutoRequest() */
  833. #define LP8(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  834. ({                                \
  835.    struct Caos *MyCaos;                        \
  836.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  837.    {                                \
  838.       rt _##name##_re;                        \
  839.       MyCaos->##r1        = (ULONG) v1;            \
  840.       MyCaos->##r2        = (ULONG) v2;            \
  841.       MyCaos->##r3        = (ULONG) v3;            \
  842.       MyCaos->##r4        = (ULONG) v4;            \
  843.       MyCaos->##r5        = (ULONG) v5;            \
  844.       MyCaos->##r6        = (ULONG) v6;            \
  845.       MyCaos->##r7        = (ULONG) v7;            \
  846.       MyCaos->##r8        = (ULONG) v8;            \
  847.       MyCaos->a6        = (ULONG) bn;            \
  848.       MyCaos->M68kCacheMode    =    cm1;            \
  849.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  850.       {                                \
  851.         MyCaos->M68kStart    =    cs1;            \
  852.         MyCaos->M68kLength    =    cl1;            \
  853.       }                                \
  854.       MyCaos->PPCCacheMode    =    cm2;            \
  855.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  856.       {                                \
  857.         MyCaos->PPCStart    =    cs2;            \
  858.         MyCaos->PPCLength    =    cl2;            \
  859.       }                                \
  860.       MyCaos->caos_Un.Offset    =    (-offs);        \
  861.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  862.       _##name##_re;                        \
  863.    }                                \
  864. })
  865.  
  866. /* For example intuition.library/ModifyProp() */
  867. #define LP8NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  868. ({                                \
  869.    struct Caos *MyCaos;                        \
  870.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  871.    {                                \
  872.       MyCaos->##r1        = (ULONG) v1;            \
  873.       MyCaos->##r2        = (ULONG) v2;            \
  874.       MyCaos->##r3        = (ULONG) v3;            \
  875.       MyCaos->##r4        = (ULONG) v4;            \
  876.       MyCaos->##r5        = (ULONG) v5;            \
  877.       MyCaos->##r6        = (ULONG) v6;            \
  878.       MyCaos->##r7        = (ULONG) v7;            \
  879.       MyCaos->##r8        = (ULONG) v8;            \
  880.       MyCaos->a6        = (ULONG) bn;            \
  881.       MyCaos->M68kCacheMode    =    cm1;            \
  882.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  883.       {                                \
  884.         MyCaos->M68kStart    =    cs1;            \
  885.         MyCaos->M68kLength    =    cl1;            \
  886.       }                                \
  887.       MyCaos->PPCCacheMode    =    cm2;            \
  888.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  889.       {                                \
  890.         MyCaos->PPCStart    =    cs2;            \
  891.         MyCaos->PPCLength    =    cl2;            \
  892.       }                                \
  893.       MyCaos->caos_Un.Offset    =    (-offs);        \
  894.       PPCCallOS (MyCaos);                    \
  895.    }                                \
  896. })
  897.  
  898. /* For example layers.library/CreateUpfrontHookLayer() */
  899. #define LP9(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  900. ({                                \
  901.    struct Caos *MyCaos;                        \
  902.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  903.    {                                \
  904.       rt _##name##_re;                        \
  905.       MyCaos->##r1        = (ULONG) v1;            \
  906.       MyCaos->##r2        = (ULONG) v2;            \
  907.       MyCaos->##r3        = (ULONG) v3;            \
  908.       MyCaos->##r4        = (ULONG) v4;            \
  909.       MyCaos->##r5        = (ULONG) v5;            \
  910.       MyCaos->##r6        = (ULONG) v6;            \
  911.       MyCaos->##r7        = (ULONG) v7;            \
  912.       MyCaos->##r8        = (ULONG) v8;            \
  913.       MyCaos->##r9        = (ULONG) v9;            \
  914.       MyCaos->a6        = (ULONG) bn;            \
  915.       MyCaos->M68kCacheMode    =    cm1;            \
  916.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  917.       {                                \
  918.         MyCaos->M68kStart    =    cs1;            \
  919.         MyCaos->M68kLength    =    cl1;            \
  920.       }                                \
  921.       MyCaos->PPCCacheMode    =    cm2;            \
  922.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  923.       {                                \
  924.         MyCaos->PPCStart    =    cs2;            \
  925.         MyCaos->PPCLength    =    cl2;            \
  926.       }                                \
  927.       MyCaos->caos_Un.Offset    =    (-offs);        \
  928.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  929.       _##name##_re;                        \
  930.    }                                \
  931. })
  932.  
  933. /* For example intuition.library/NewModifyProp() */
  934. #define LP9NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  935. ({                                \
  936.    struct Caos *MyCaos;                        \
  937.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  938.    {                                \
  939.       MyCaos->##r1        = (ULONG) v1;            \
  940.       MyCaos->##r2        = (ULONG) v2;            \
  941.       MyCaos->##r3        = (ULONG) v3;            \
  942.       MyCaos->##r4        = (ULONG) v4;            \
  943.       MyCaos->##r5        = (ULONG) v5;            \
  944.       MyCaos->##r6        = (ULONG) v6;            \
  945.       MyCaos->##r7        = (ULONG) v7;            \
  946.       MyCaos->##r8        = (ULONG) v8;            \
  947.       MyCaos->##r9        = (ULONG) v9;            \
  948.       MyCaos->a6        = (ULONG) bn;            \
  949.       MyCaos->M68kCacheMode    =    cm1;            \
  950.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  951.       {                                \
  952.         MyCaos->M68kStart    =    cs1;            \
  953.         MyCaos->M68kLength    =    cl1;            \
  954.       }                                \
  955.       MyCaos->PPCCacheMode    =    cm2;            \
  956.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  957.       {                                \
  958.         MyCaos->PPCStart    =    cs2;            \
  959.         MyCaos->PPCLength    =    cl2;            \
  960.       }                                \
  961.       MyCaos->caos_Un.Offset    =    (-offs);        \
  962.       PPCCallOS (MyCaos);                    \
  963.    }                                \
  964. })
  965.  
  966. /* LP10 not needed... */
  967.  
  968. /* Only graphics.library/BltMaskBitMapRastPort() */
  969. #define LP10NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, t10, v10, r10, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  970. ({                                \
  971.    struct Caos *MyCaos;                        \
  972.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  973.    {                                \
  974.       MyCaos->##r1        = (ULONG) v1;            \
  975.       MyCaos->##r2        = (ULONG) v2;            \
  976.       MyCaos->##r3        = (ULONG) v3;            \
  977.       MyCaos->##r4        = (ULONG) v4;            \
  978.       MyCaos->##r5        = (ULONG) v5;            \
  979.       MyCaos->##r6        = (ULONG) v6;            \
  980.       MyCaos->##r7        = (ULONG) v7;            \
  981.       MyCaos->##r8        = (ULONG) v8;            \
  982.       MyCaos->##r9        = (ULONG) v9;            \
  983.       MyCaos->##r10        = (ULONG) v10;            \
  984.       MyCaos->a6        = (ULONG) bn;            \
  985.       MyCaos->M68kCacheMode    =    cm1;            \
  986.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  987.       {                                \
  988.         MyCaos->M68kStart    =    cs1;            \
  989.         MyCaos->M68kLength    =    cl1;            \
  990.       }                                \
  991.       MyCaos->PPCCacheMode    =    cm2;            \
  992.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  993.       {                                \
  994.         MyCaos->PPCStart    =    cs2;            \
  995.         MyCaos->PPCLength    =    cl2;            \
  996.       }                                \
  997.       MyCaos->caos_Un.Offset    =    (-offs);        \
  998.       PPCCallOS (MyCaos);                    \
  999.    }                                \
  1000. })
  1001.  
  1002. /* Only graphics.library/BltBitMap() */
  1003. #define LP11(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, t10, v10, r10, t11, v11, r11, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1004. ({                                \
  1005.    struct Caos *MyCaos;                        \
  1006.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  1007.    {                                \
  1008.       rt _##name##_re;                        \
  1009.       MyCaos->##r1        = (ULONG) v1;            \
  1010.       MyCaos->##r2        = (ULONG) v2;            \
  1011.       MyCaos->##r3        = (ULONG) v3;            \
  1012.       MyCaos->##r4        = (ULONG) v4;            \
  1013.       MyCaos->##r5        = (ULONG) v5;            \
  1014.       MyCaos->##r6        = (ULONG) v6;            \
  1015.       MyCaos->##r7        = (ULONG) v7;            \
  1016.       MyCaos->##r8        = (ULONG) v8;            \
  1017.       MyCaos->##r9        = (ULONG) v9;            \
  1018.       MyCaos->##r10        = (ULONG) v10;            \
  1019.       MyCaos->##r11        = (ULONG) v11;            \
  1020.       MyCaos->a6        = (ULONG) bn;            \
  1021.       MyCaos->M68kCacheMode    =    cm1;            \
  1022.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  1023.       {                                \
  1024.         MyCaos->M68kStart    =    cs1;            \
  1025.         MyCaos->M68kLength    =    cl1;            \
  1026.       }                                \
  1027.       MyCaos->PPCCacheMode    =    cm2;            \
  1028.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  1029.       {                                \
  1030.         MyCaos->PPCStart    =    cs2;            \
  1031.         MyCaos->PPCLength    =    cl2;            \
  1032.       }                                \
  1033.       MyCaos->caos_Un.Offset    =    (-offs);        \
  1034.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  1035.       _##name##_re;                        \
  1036.    }                                \
  1037. })
  1038.  
  1039. #define LP10(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, t10, v10, r10, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1040. ({                                \
  1041.    struct Caos *MyCaos;                        \
  1042.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  1043.    {                                \
  1044.       rt _##name##_re;                        \
  1045.       MyCaos->##r1        = (ULONG) v1;            \
  1046.       MyCaos->##r2        = (ULONG) v2;            \
  1047.       MyCaos->##r3        = (ULONG) v3;            \
  1048.       MyCaos->##r4        = (ULONG) v4;            \
  1049.       MyCaos->##r5        = (ULONG) v5;            \
  1050.       MyCaos->##r6        = (ULONG) v6;            \
  1051.       MyCaos->##r7        = (ULONG) v7;            \
  1052.       MyCaos->##r8        = (ULONG) v8;            \
  1053.       MyCaos->##r9        = (ULONG) v9;            \
  1054.       MyCaos->##r10        = (ULONG) v10;            \
  1055.       MyCaos->a6        = (ULONG) bn;            \
  1056.       MyCaos->M68kCacheMode    =    cm1;            \
  1057.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))    \
  1058.       {                                \
  1059.         MyCaos->M68kStart    =    cs1;            \
  1060.         MyCaos->M68kLength    =    cl1;            \
  1061.       }                                \
  1062.       MyCaos->PPCCacheMode    =    cm2;            \
  1063.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))    \
  1064.       {                                \
  1065.         MyCaos->PPCStart    =    cs2;            \
  1066.         MyCaos->PPCLength    =    cl2;            \
  1067.       }                                \
  1068.       MyCaos->caos_Un.Offset    =    (-offs);        \
  1069.       _##name##_re = (rt) PPCCallOS (MyCaos);            \
  1070.       _##name##_re;                        \
  1071.    }                                \
  1072. })
  1073.  
  1074. #else /* WARPUP */
  1075.  
  1076. #include <powerpc/powerpc_protos.h>
  1077.  
  1078. struct PPCArgs2 {
  1079.         APTR  PP_Code;          /* Code Entry / Basevariable (OS Callback) */
  1080.         LONG  PP_Offset;        /* Offset into Library-Jumptable (OS Callback) */
  1081.         ULONG PP_Flags;         /* see below */
  1082.         APTR  PP_Stack;         /* Pointer to first argument to be copied or NULL */
  1083.         ULONG PP_StackSize;     /* Size of stack area to be copied or 0 */
  1084.         //ULONG PP_Regs[15];      /* Registervalues to be transferred */
  1085.         ULONG    d0;
  1086.         ULONG    d1;
  1087.         ULONG    d2;
  1088.         ULONG    d3;
  1089.         ULONG    d4;
  1090.         ULONG    d5;
  1091.         ULONG    d6;
  1092.         ULONG    d7;
  1093.         ULONG    a0;
  1094.         ULONG    a1;
  1095.         ULONG    a2;
  1096.         ULONG    a3;
  1097.         ULONG    a4;
  1098.         ULONG    a5;
  1099.         ULONG    a6;
  1100.         DOUBLE PP_FRegs[8];     /* FPU Registervalues to be transferred */
  1101. };
  1102.  
  1103. #define LP0NR(offs, name, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1104. ({                                \
  1105.    struct PPCArgs2 *MyArgs;                        \
  1106.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1107.    {                                \
  1108.       MyArgs->a6        = (ULONG) bn;            \
  1109.       MyArgs->PP_Offset        = (-offs);            \
  1110.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1111.       MyArgs->PP_Stack        = (APTR)0L;                \
  1112.       MyArgs->PP_StackSize    = 0L;                \
  1113.       MyArgs->PP_Flags        = 0L;                \
  1114.       Run68K((struct PPCArgs *)MyArgs);                        \
  1115.    }                                \
  1116. })
  1117.  
  1118. #define LP0(offs, rt, name, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1119. ({                                \
  1120.    struct PPCArgs2 *MyArgs;                        \
  1121.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1122.    {                                \
  1123.       rt _##name##_re;                        \
  1124.       MyArgs->a6        = (ULONG) bn;            \
  1125.       MyArgs->PP_Offset        = (-offs);            \
  1126.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1127.       MyArgs->PP_Stack        = (APTR)0L;                \
  1128.       MyArgs->PP_StackSize    = 0L;                \
  1129.       MyArgs->PP_Flags        = 0L;                \
  1130.       Run68K((struct PPCArgs *)MyArgs);                        \
  1131.       _##name##_re = (rt) MyArgs->d0;                  \
  1132.       _##name##_re;                        \
  1133.    }                                \
  1134. })
  1135.  
  1136. #define LP1(offs, rt, name, t1, v1, r1, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1137. ({                                \
  1138.    struct PPCArgs2 *MyArgs;                        \
  1139.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1140.    {                                \
  1141.       rt _##name##_re;                        \
  1142.       MyArgs->##r1        = (ULONG) v1;            \
  1143.       MyArgs->a6        = (ULONG) bn;            \
  1144.       MyArgs->PP_Offset        = (-offs);            \
  1145.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1146.       MyArgs->PP_Stack        = (APTR)0L;                \
  1147.       MyArgs->PP_StackSize    = 0L;                \
  1148.       MyArgs->PP_Flags        = 0L;                \
  1149.       Run68K((struct PPCArgs *)MyArgs);                        \
  1150.       _##name##_re = (rt) MyArgs->d0;                  \
  1151.       _##name##_re;                        \
  1152.    }                                \
  1153. })
  1154.  
  1155. #define LP1NR(offs, name, t1, v1, r1, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1156. ({                                \
  1157.    struct PPCArgs2 *MyArgs;                        \
  1158.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1159.    {                                \
  1160.       MyArgs->##r1        = (ULONG) v1;            \
  1161.       MyArgs->a6        = (ULONG) bn;            \
  1162.       MyArgs->PP_Offset        = (-offs);            \
  1163.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1164.       MyArgs->PP_Stack        = (APTR)0L;                \
  1165.       MyArgs->PP_StackSize    = 0L;                \
  1166.       MyArgs->PP_Flags        = 0L;                \
  1167.       Run68K((struct PPCArgs *)MyArgs);                        \
  1168.    }                                \
  1169. })
  1170.  
  1171. #define LP2(offs, rt, name, t1, v1, r1, t2, v2, r2, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1172. ({                                \
  1173.    struct PPCArgs2 *MyArgs;                        \
  1174.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1175.    {                                \
  1176.       rt _##name##_re;                        \
  1177.       MyArgs->##r1        = (ULONG) v1;            \
  1178.       MyArgs->##r2        = (ULONG) v2;            \
  1179.       MyArgs->a6        = (ULONG) bn;            \
  1180.       MyArgs->PP_Offset        = (-offs);            \
  1181.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1182.       MyArgs->PP_Stack        = (APTR)0L;                \
  1183.       MyArgs->PP_StackSize    = 0L;                \
  1184.       MyArgs->PP_Flags        = 0L;                \
  1185.       Run68K((struct PPCArgs *)MyArgs);                        \
  1186.       _##name##_re = (rt) MyArgs->d0;                  \
  1187.       _##name##_re;                        \
  1188.    }                                \
  1189. })
  1190.  
  1191. #define LP2NR(offs, name, t1, v1, r1, t2, v2, r2, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1192. ({                                \
  1193.    struct PPCArgs2 *MyArgs;                        \
  1194.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1195.    {                                \
  1196.       MyArgs->##r1        = (ULONG) v1;            \
  1197.       MyArgs->##r2        = (ULONG) v2;            \
  1198.       MyArgs->a6        = (ULONG) bn;            \
  1199.       MyArgs->PP_Offset        = (-offs);            \
  1200.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1201.       MyArgs->PP_Stack        = (APTR)0L;                \
  1202.       MyArgs->PP_StackSize    = 0L;                \
  1203.       MyArgs->PP_Flags        = 0L;                \
  1204.       Run68K((struct PPCArgs *)MyArgs);                        \
  1205.    }                                \
  1206. })
  1207.  
  1208. #define LP3(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1209. ({                                \
  1210.    struct PPCArgs2 *MyArgs;                        \
  1211.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1212.    {                                \
  1213.       rt _##name##_re;                        \
  1214.       MyArgs->##r1        = (ULONG) v1;            \
  1215.       MyArgs->##r2        = (ULONG) v2;            \
  1216.       MyArgs->##r3        = (ULONG) v3;            \
  1217.       MyArgs->a6        = (ULONG) bn;            \
  1218.       MyArgs->PP_Offset        = (-offs);            \
  1219.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1220.       MyArgs->PP_Stack        = (APTR)0L;                \
  1221.       MyArgs->PP_StackSize    = 0L;                \
  1222.       MyArgs->PP_Flags        = 0L;                \
  1223.       Run68K((struct PPCArgs *)MyArgs);                        \
  1224.       _##name##_re = (rt) MyArgs->d0;                  \
  1225.       _##name##_re;                        \
  1226.    }                                \
  1227. })
  1228.  
  1229. #define LP3NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1230. ({                                \
  1231.    struct PPCArgs2 *MyArgs;                        \
  1232.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1233.    {                                \
  1234.       MyArgs->##r1        = (ULONG) v1;            \
  1235.       MyArgs->##r2        = (ULONG) v2;            \
  1236.       MyArgs->##r3        = (ULONG) v3;            \
  1237.       MyArgs->a6        = (ULONG) bn;            \
  1238.       MyArgs->PP_Offset        = (-offs);            \
  1239.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1240.       MyArgs->PP_Stack        = (APTR)0L;                \
  1241.       MyArgs->PP_StackSize    = 0L;                \
  1242.       MyArgs->PP_Flags        = 0L;                \
  1243.       Run68K((struct PPCArgs *)MyArgs);                        \
  1244.    }                                \
  1245. })
  1246.  
  1247. #define LP4(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1248. ({                                \
  1249.    struct PPCArgs2 *MyArgs;                        \
  1250.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1251.    {                                \
  1252.       rt _##name##_re;                        \
  1253.       MyArgs->##r1        = (ULONG) v1;            \
  1254.       MyArgs->##r2        = (ULONG) v2;            \
  1255.       MyArgs->##r3        = (ULONG) v3;            \
  1256.       MyArgs->##r4        = (ULONG) v4;            \
  1257.       MyArgs->a6        = (ULONG) bn;            \
  1258.       MyArgs->PP_Offset        = (-offs);            \
  1259.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1260.       MyArgs->PP_Stack        = (APTR)0L;                \
  1261.       MyArgs->PP_StackSize    = 0L;                \
  1262.       MyArgs->PP_Flags        = 0L;                \
  1263.       Run68K((struct PPCArgs *)MyArgs);                        \
  1264.       _##name##_re = (rt) MyArgs->d0;                  \
  1265.       _##name##_re;                        \
  1266.    }                                \
  1267. })
  1268.  
  1269. #define LP4NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1270. ({                                \
  1271.    struct PPCArgs2 *MyArgs;                        \
  1272.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1273.    {                                \
  1274.       MyArgs->##r1        = (ULONG) v1;            \
  1275.       MyArgs->##r2        = (ULONG) v2;            \
  1276.       MyArgs->##r3        = (ULONG) v3;            \
  1277.       MyArgs->##r4        = (ULONG) v4;            \
  1278.       MyArgs->a6        = (ULONG) bn;            \
  1279.       MyArgs->PP_Offset        = (-offs);            \
  1280.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1281.       MyArgs->PP_Stack        = (APTR)0L;                \
  1282.       MyArgs->PP_StackSize    = 0L;                \
  1283.       MyArgs->PP_Flags        = 0L;                \
  1284.       Run68K((struct PPCArgs *)MyArgs);                        \
  1285.    }                                \
  1286. })
  1287.  
  1288. #define LP5(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1289. ({                                \
  1290.    struct PPCArgs2 *MyArgs;                        \
  1291.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1292.    {                                \
  1293.       rt _##name##_re;                        \
  1294.       MyArgs->##r1        = (ULONG) v1;            \
  1295.       MyArgs->##r2        = (ULONG) v2;            \
  1296.       MyArgs->##r3        = (ULONG) v3;            \
  1297.       MyArgs->##r4        = (ULONG) v4;            \
  1298.       MyArgs->##r5        = (ULONG) v5;            \
  1299.       MyArgs->a6        = (ULONG) bn;            \
  1300.       MyArgs->PP_Offset        = (-offs);            \
  1301.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1302.       MyArgs->PP_Stack        = (APTR)0L;                \
  1303.       MyArgs->PP_StackSize    = 0L;                \
  1304.       MyArgs->PP_Flags        = 0L;                \
  1305.       Run68K((struct PPCArgs *)MyArgs);                        \
  1306.       _##name##_re = (rt) MyArgs->d0;                  \
  1307.       _##name##_re;                        \
  1308.    }                                \
  1309. })
  1310.  
  1311. #define LP5NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1312. ({                                \
  1313.    struct PPCArgs2 *MyArgs;                        \
  1314.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1315.    {                                \
  1316.       MyArgs->##r1        = (ULONG) v1;            \
  1317.       MyArgs->##r2        = (ULONG) v2;            \
  1318.       MyArgs->##r3        = (ULONG) v3;            \
  1319.       MyArgs->##r4        = (ULONG) v4;            \
  1320.       MyArgs->##r5        = (ULONG) v5;            \
  1321.       MyArgs->a6        = (ULONG) bn;            \
  1322.       MyArgs->PP_Offset        = (-offs);            \
  1323.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1324.       MyArgs->PP_Stack        = (APTR)0L;                \
  1325.       MyArgs->PP_StackSize    = 0L;                \
  1326.       MyArgs->PP_Flags        = 0L;                \
  1327.       Run68K((struct PPCArgs *)MyArgs);                        \
  1328.    }                                \
  1329. })
  1330.  
  1331. #define LP6NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1332. ({                                \
  1333.    struct PPCArgs2 *MyArgs;                        \
  1334.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1335.    {                                \
  1336.       MyArgs->##r1        = (ULONG) v1;            \
  1337.       MyArgs->##r2        = (ULONG) v2;            \
  1338.       MyArgs->##r3        = (ULONG) v3;            \
  1339.       MyArgs->##r4        = (ULONG) v4;            \
  1340.       MyArgs->##r5        = (ULONG) v5;            \
  1341.       MyArgs->##r6        = (ULONG) v6;            \
  1342.       MyArgs->a6        = (ULONG) bn;            \
  1343.       MyArgs->PP_Offset        = (-offs);            \
  1344.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1345.       MyArgs->PP_Stack        = (APTR)0L;                \
  1346.       MyArgs->PP_StackSize    = 0L;                \
  1347.       MyArgs->PP_Flags        = 0L;                \
  1348.       Run68K((struct PPCArgs *)MyArgs);                        \
  1349.    }                                \
  1350. })
  1351.  
  1352. #define LP7(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1353. ({                                \
  1354.    struct PPCArgs2 *MyArgs;                        \
  1355.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1356.    {                                \
  1357.       rt _##name##_re;                        \
  1358.       MyArgs->##r1        = (ULONG) v1;            \
  1359.       MyArgs->##r2        = (ULONG) v2;            \
  1360.       MyArgs->##r3        = (ULONG) v3;            \
  1361.       MyArgs->##r4        = (ULONG) v4;            \
  1362.       MyArgs->##r5        = (ULONG) v5;            \
  1363.       MyArgs->##r6        = (ULONG) v6;            \
  1364.       MyArgs->##r7        = (ULONG) v7;            \
  1365.       MyArgs->a6        = (ULONG) bn;            \
  1366.       MyArgs->PP_Offset        = (-offs);            \
  1367.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1368.       MyArgs->PP_Stack        = (APTR)0L;                \
  1369.       MyArgs->PP_StackSize    = 0L;                \
  1370.       MyArgs->PP_Flags        = 0L;                \
  1371.       Run68K((struct PPCArgs *)MyArgs);                        \
  1372.       _##name##_re = (rt) MyArgs->d0;                  \
  1373.       _##name##_re;                        \
  1374.    }                                \
  1375. })
  1376.  
  1377. #define LP10(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, t10, v10, r10, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1378. ({                                \
  1379.    struct PPCArgs2 *MyArgs;                        \
  1380.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1381.    {                                \
  1382.       rt _##name##_re;                        \
  1383.       MyArgs->##r1        = (ULONG) v1;            \
  1384.       MyArgs->##r2        = (ULONG) v2;            \
  1385.       MyArgs->##r3        = (ULONG) v3;            \
  1386.       MyArgs->##r4        = (ULONG) v4;            \
  1387.       MyArgs->##r5        = (ULONG) v5;            \
  1388.       MyArgs->##r6        = (ULONG) v6;            \
  1389.       MyArgs->##r7        = (ULONG) v7;            \
  1390.       MyArgs->##r8        = (ULONG) v8;            \
  1391.       MyArgs->##r9        = (ULONG) v9;            \
  1392.       MyArgs->##r10        = (ULONG) v10;            \
  1393.       MyArgs->a6        = (ULONG) bn;            \
  1394.       MyArgs->PP_Offset        = (-offs);            \
  1395.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1396.       MyArgs->PP_Stack        = (APTR)0L;                \
  1397.       MyArgs->PP_StackSize    = 0L;                \
  1398.       MyArgs->PP_Flags        = 0L;                \
  1399.       Run68K((struct PPCArgs *)MyArgs);                        \
  1400.       _##name##_re = (rt) MyArgs->d0;                  \
  1401.       _##name##_re;                        \
  1402.    }                                \
  1403. })
  1404.  
  1405. #define LP11(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, t10, v10, r10, t11, v11, r11, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  1406. ({                                \
  1407.    struct PPCArgs2 *MyArgs;                        \
  1408.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1409.    {                                \
  1410.       rt _##name##_re;                        \
  1411.       MyArgs->##r1        = (ULONG) v1;            \
  1412.       MyArgs->##r2        = (ULONG) v2;            \
  1413.       MyArgs->##r3        = (ULONG) v3;            \
  1414.       MyArgs->##r4        = (ULONG) v4;            \
  1415.       MyArgs->##r5        = (ULONG) v5;            \
  1416.       MyArgs->##r6        = (ULONG) v6;            \
  1417.       MyArgs->##r7        = (ULONG) v7;            \
  1418.       MyArgs->##r8        = (ULONG) v8;            \
  1419.       MyArgs->##r9        = (ULONG) v9;            \
  1420.       MyArgs->##r10        = (ULONG) v10;            \
  1421.       MyArgs->##r11        = (ULONG) v11;            \
  1422.       MyArgs->a6        = (ULONG) bn;            \
  1423.       MyArgs->PP_Offset        = (-offs);            \
  1424.       MyArgs->PP_Code        = (APTR)MyArgs->a6;            \
  1425.       MyArgs->PP_Stack        = (APTR)0L;                \
  1426.       MyArgs->PP_StackSize    = 0L;                \
  1427.       MyArgs->PP_Flags        = 0L;                \
  1428.       Run68K((struct PPCArgs *)MyArgs);                        \
  1429.       _##name##_re = (rt) MyArgs->d0;                  \
  1430.       _##name##_re;                        \
  1431.    }                                \
  1432. })
  1433.  
  1434. #endif
  1435.  
  1436. #endif /* __INLINE_MACROS_H */
  1437.  
  1438.  
  1439.