home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 15 / AACD15.ISO / AACD / System / MorphOS / Developer / include / public / proto / libamiga / amiga_protos.h
Encoding:
C/C++ Source or Header  |  2000-11-02  |  5.8 KB  |  246 lines

  1. #ifndef    PUBLIC_PROTOS_QUARK_AMIGA_H
  2. #define    PUBLIC_PROTOS_QUARK_AMIGA_H
  3.  
  4. #ifndef  UTILITY_HOOKS_H
  5. #include <utility/hooks.h>
  6. #endif
  7. #ifndef  INTUITION_CLASSES_H
  8. #include <intuition/classes.h>
  9. #endif
  10. #ifndef  INTUITION_CLASSUSR_H
  11. #include <intuition/classusr.h>
  12. #endif
  13.  
  14.  
  15.  
  16. /*
  17.  * Debug Macros
  18.  */
  19.  
  20. #define kprintf(Fmt, args...) \
  21.     ({ULONG _args[] = { args }; RawDoFmt((Fmt), (void*) _args, (void(*)(void)) 0x1, NULL);})
  22.  
  23. /*
  24.  * Boopsi Macros
  25.  */
  26.  
  27. #define CallHook(MyHook, MyObject, tags...) \
  28.     ({ULONG _tags[] = { tags }; CallHookA((MyHook), (MyObject), (APTR)_tags);})
  29.  
  30. #define DoMethod(MyObject, tags...) \
  31.     ({ULONG _tags[] = { tags }; DoMethodA((MyObject), (APTR)_tags);})
  32.  
  33. #define DoSuperMethod(MyClass, MyObject, tags...) \
  34.     ({ULONG _tags[] = { tags }; DoSuperMethodA((MyClass), (MyObject), (APTR)_tags);})
  35.  
  36. #define CoerceMethod(MyClass, MyObject, tags...) \
  37.     ({ULONG _tags[] = { tags }; CoerceMethodA((MyClass), (MyObject), (APTR)_tags);})
  38.  
  39. #define SetSuperAttrs(Class, MyObject, tags...)                \
  40. ({                                    \
  41. ULONG        _tags[] = { tags };                     \
  42. struct opSet    MyopSet;                        \
  43.   MyopSet.MethodID    =    OM_SET;                    \
  44.   MyopSet.ops_AttrList    =(struct TagItem*) _tags;            \
  45.   MyopSet.ops_GInfo    =    NULL;                    \
  46.   DoSuperMethodA((Class), (MyObject), (APTR) &MyopSet);            \
  47. })
  48.  
  49. /*
  50.  * Replace the intuition.library SetAttrs
  51.  */
  52. #define SETATTRS(MyObject, tags...)                    \
  53. ({                                    \
  54. ULONG            _tags[] = { tags };                 \
  55. struct opSet        MyopSet;                    \
  56.   MyopSet.MethodID    =    OM_SET;                    \
  57.   MyopSet.ops_AttrList    =(struct TagItem*) _tags;            \
  58.   MyopSet.ops_GInfo    =    NULL;                    \
  59.   DoMethodA((MyObject), (APTR) &MyopSet);                \
  60. })
  61.  
  62. #define GETATTRS(MyObject, AttrID, Ptr)                    \
  63. ({                                    \
  64. struct opGet        MyopGet;                    \
  65.   MyopGet.MethodID    =    OM_GET;                    \
  66.   MyopGet.opg_AttrID    =    AttrID;                    \
  67.   MyopGet.opg_Storage    =    Ptr;                    \
  68.   DoMethodA((MyObject), (APTR) &MyopGet);                \
  69. })
  70.  
  71.  
  72. /*
  73.  * Memory macros
  74.  */
  75.  
  76. #define    ALLOCVECPOOLED(MyPool,MemSize,SysBase)            \
  77. ({                                \
  78. ULONG            *MyMemory;                \
  79. ULONG            Size=MemSize;                \
  80.   if (Size == 0)                        \
  81.   {                                \
  82.     MyMemory    =    NULL;                    \
  83.   }                                \
  84.   else                                \
  85.   {                                \
  86.     Size    +=4;                        \
  87.     if (MyMemory=(ULONG*) AllocPooled(MyPool,Size))        \
  88.     {                                \
  89.       *MyMemory++=Size;                        \
  90.     }                                \
  91.   }                                \
  92.   (void*) MyMemory;                        \
  93. })
  94.  
  95. #define    FREEVECPOOLED(MyPool,MyMemory,SysBase)            \
  96. ({                                \
  97.   if (MyMemory && MyPool)                    \
  98.   {                                \
  99.     ULONG    *MemPtr;                    \
  100.     ULONG    Size;                        \
  101.     MemPtr    =(ULONG*) MyMemory;                \
  102.     Size    =    *--MemPtr;                \
  103.     FreePooled(MyPool,MemPtr,Size);                \
  104.   }                                \
  105. })
  106.  
  107.  
  108.  
  109. /*
  110.  * List macros
  111.  */
  112.  
  113. #define    NEWLIST(MyList)                        \
  114. {                                \
  115.   (MyList)->lh_TailPred    =(struct Node*) (MyList);        \
  116.   (MyList)->lh_Tail    =(struct Node*) NULL;            \
  117.   (MyList)->lh_Head    =(struct Node*)    &(MyList)->lh_Tail;    \
  118. }
  119.  
  120. #define    REMHEAD(MyList)                            \
  121. ({                                    \
  122. struct Node    *RemovedNode;                        \
  123. struct Node    *Result;                        \
  124.   if ((RemovedNode=(MyList)->lh_Head)->ln_Succ)                \
  125.   {                                    \
  126.     (MyList)->lh_Head        =        RemovedNode->ln_Succ;    \
  127.     (MyList)->lh_Head->ln_Pred    =(struct Node*) &(MyList)->lh_Head;    \
  128.     Result    =    RemovedNode;                    \
  129.   }                                    \
  130.   else                                    \
  131.   {                                    \
  132.     Result    =    NULL;                        \
  133.   }                                    \
  134.   Result;                                \
  135. })
  136.  
  137.  
  138. #define    REMTAIL(MyList)                            \
  139. ({                                    \
  140. struct    Node    *RemovedNode;                        \
  141. struct Node    *Result;                        \
  142.   if ((RemovedNode=(MyList)->lh_TailPred)->ln_Pred)            \
  143.   {                                    \
  144.     (MyList)->lh_TailPred            =        RemovedNode->ln_Pred;                        \
  145.     (MyList)->lh_TailPred->ln_Succ    =(struct Node*)    &(MyList)->lh_Tail;                        \
  146.     Result    =    RemovedNode;                    \
  147.   }                                    \
  148.   else                                    \
  149.   {                                    \
  150.     Result    =    NULL;                        \
  151.   }                                    \
  152.   Result;                                \
  153. })
  154.  
  155. #define    ADDHEAD(MyList,MyNode)                        \
  156. {                                    \
  157. struct Node    *OldHeadNode;                        \
  158.   OldHeadNode            =        (MyList)->lh_Head;    \
  159.   (MyNode)->ln_Succ        =        OldHeadNode;        \
  160.   OldHeadNode->ln_Pred        =         (MyNode);        \
  161.   (MyNode)->ln_Pred        =(struct Node*) (MyList);        \
  162.   (MyList)->lh_Head        =        (MyNode);        \
  163. }
  164.  
  165. #define    ADDTAIL(MyList,MyNode)                        \
  166. {                                    \
  167. struct Node    *OldPredNode;                        \
  168.   OldPredNode        =    (MyList)->lh_TailPred;            \
  169.   (MyNode)->ln_Succ    =(struct Node*)    &(MyList)->lh_Tail;        \
  170.   (MyNode)->ln_Pred    =    OldPredNode;                \
  171.   OldPredNode->ln_Succ    =    (MyNode);                \
  172.   (MyList)->lh_TailPred    =    (MyNode);                \
  173. }
  174.  
  175.  
  176. #define    REMOVE(MyNode)                            \
  177. ({                                    \
  178. struct Node    *PredNode;                        \
  179. struct Node    *SuccNode;                        \
  180.   PredNode        =    (MyNode)->ln_Pred;            \
  181.   SuccNode        =    (MyNode)->ln_Succ;            \
  182.   PredNode->ln_Succ    =    SuccNode;                \
  183.   SuccNode->ln_Pred    =    PredNode;                \
  184.   MyNode;                                \
  185. })
  186.  
  187. /*
  188.  * Misc macros
  189.  */
  190.  
  191. #define    BeginIO(MyIORequest)                    \
  192. {                                \
  193. struct EmulCaos    MyCaos;                    \
  194.   MyCaos.caos_Un.Offset        =    -30;        \
  195.   MyCaos.reg_a1            =(ULONG) MyIORequest;    \
  196.   MyCaos.reg_a6            =(ULONG) ((struct IORequest*) MyIORequest)->io_Device;    \
  197.   (*MyEmulHandle->EmulCallOS)(&MyCaos);            \
  198. }
  199.  
  200. ULONG    CallHookA(struct Hook *hookPtr, Object *obj, APTR message);
  201.  
  202. ULONG    DoMethodA(Object*,
  203.                   Msg);
  204.  
  205. ULONG    DoSuperMethodA(Class*,
  206.                        Object*,
  207.                        Msg);
  208.  
  209. ULONG    CoerceMethodA(Class*,
  210.                       Object*,
  211.                       Msg);
  212.  
  213. ULONG    SetSuperAttrsA(Class*,
  214.                        Object*,
  215.                        Msg);
  216.  
  217. #ifdef AMIGA_ENABLE_NewList
  218. void    NewList(struct List    *MyList);
  219. #else
  220. #define    NewList(a)    NEWLIST(a)
  221. #endif
  222.  
  223. void*    AllocVecPooled(void    *MyPool,
  224.                        ULONG    Size);
  225.  
  226. void    FreeVecPooled(void    *MyPool,
  227.                       void    *MyMemory);
  228.  
  229. BOOL    CheckRexxMsg(struct Message    *rexxmsg);
  230. LONG    GetRexxVar(struct Message    *rexxmsg,
  231.                    UBYTE        *name,
  232.                    UBYTE        **result);
  233. LONG    SetRexxVar(struct Message    *rexxmsg,
  234.                    UBYTE        *name,
  235.                    UBYTE        *value,
  236.                    LONG            length);
  237.  
  238. struct MsgPort    *CreatePort(char        *MyName,
  239.                             LONG        MyPri);
  240.  
  241. void    DeletePort(struct MsgPort    *MyPort);
  242.  
  243.  
  244.  
  245. #endif
  246.