compiler/include/clib/alib_protos.h

   1 #ifndef  CLIB_ALIB_PROTOS_H
   2 #define  CLIB_ALIB_PROTOS_H
   3
   4 /*
   5     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   6     $Id$
   7
   8     Desc: Prototypes for amiga.lib
   9     Lang: english
  10 */
  11
  12 #if defined(RT_ENABLE) && RT_ENABLE
  13 #include <aros/rt.h>
  14 #endif
  15
  16 #include <aros/asmcall.h>
  17 #include <devices/inputevent.h>
  18 #include <devices/keymap.h>
  19 #include <intuition/classes.h>
  20 #include <intuition/classusr.h>
  21 #include <intuition/intuition.h>
  22 #include <intuition/screens.h>
  23 #include <libraries/commodities.h>
  24 #include <libraries/gadtools.h>
  25 #include <rexx/storage.h>
  26 #include <utility/hooks.h>
  27
  28 __BEGIN_DECLS
  29
  30 struct MsgPort;
  31 struct IORequest;
  32 struct Task;
  33 struct InputEvent;
  34 struct Locale;
  35 /*
  36     Prototypes
  37 */
  38 IPTR CallHookA (struct Hook * hook, APTR obj, APTR param);
  39 IPTR CallHook (struct Hook * hook, APTR obj, ...) __stackparm;
  40 UBYTE * ACrypt(UBYTE * buffer, const UBYTE * password, const UBYTE * user);
  41
  42 /* Dos support */
  43 BPTR ErrorOutput(void);
  44 BPTR SelectErrorOutput(BPTR fh);
  45
  46 /* Exec support */
  47 VOID BeginIO (struct IORequest *ioReq);
  48 struct IORequest * CreateExtIO (struct MsgPort * port, ULONG iosize);
  49 struct IOStdReq * CreateStdIO (struct MsgPort * port);
  50 void DeleteExtIO (struct IORequest * ioreq);
  51 void DeleteStdIO (struct IOStdReq * ioreq);
  52 struct Task * CreateTask (STRPTR name, LONG pri, APTR initpc, ULONG stacksize);
  53 void DeleteTask (struct Task * task);
  54 void NewList (struct List *);
  55 #if !defined(ENABLE_RT) || !ENABLE_RT
  56 struct MsgPort * CreatePort (STRPTR name, LONG pri);
  57 void DeletePort (struct MsgPort * mp);
  58 #endif
  59
  60 /* Extra */
  61 ULONG RangeRand (ULONG maxValue);
  62 ULONG FastRand (ULONG seed);
  63 LONG TimeDelay (LONG unit, ULONG secs, ULONG microsecs);
  64 void waitbeam (LONG pos);
  65 void __sprintf(UBYTE *buffer, const UBYTE *format, ...);
  66 STRPTR StrDup(CONST_STRPTR str);
  67
  68 void MergeSortList(struct MinList *l, int (*compare)(struct MinNode *n1, struct MinNode *n2, void *data), void *data);
  69
  70 /* Commodities */
  71 CxObj  *HotKey (STRPTR description, struct MsgPort *port, LONG id);
  72 VOID    FreeIEvents (volatile struct InputEvent *events);
  73 UBYTE **ArgArrayInit(ULONG argc, UBYTE **argv);
  74 VOID    ArgArrayDone(VOID);
  75 LONG    ArgInt(UBYTE **tt, STRPTR entry, LONG defaultVal);
  76 STRPTR  ArgString(UBYTE **tt, STRPTR entry, STRPTR defaultstring);
  77 struct  InputEvent *InvertString(STRPTR str, struct KeyMap *km);
  78 struct  InputEvent *InvertStringForwd(STRPTR str, struct KeyMap *km);
  79
  80 /* Graphics */
  81 #ifndef ObtainBestPen
  82 LONG ObtainBestPen( struct ColorMap * cm, LONG R, LONG G, LONG B, ULONG tag1, ...) __stackparm;
  83 #endif
  84
  85 #ifndef GetRPAttrs
  86 void GetRPAttrs( struct RastPort * rp, Tag tag1, ...) __stackparm;
  87 #endif
  88
  89 BOOL AndRectRect(struct Rectangle *rect1, struct Rectangle *rect2, struct Rectangle *intersect);
  90 struct Region *CopyRegion(struct Region *region);
  91 struct Region *NewRectRegion(WORD MinX, WORD MinY, WORD MaxX, WORD MaxY);
  92
  93 /* Intuition */
  94 #ifndef SetWindowPointer
  95 void SetWindowPointer( struct Window * window, ULONG tag1, ...) __stackparm;
  96 #endif
  97
  98 /* BOOPSI */
  99 IPTR DoMethodA (Object * obj, Msg message);
 100 IPTR DoMethod (Object * obj, STACKULONG MethodID, ...) __stackparm;
 101 IPTR DoSuperMethodA (Class * cl, Object * obj, Msg message);
 102 IPTR DoSuperMethod (Class * cl, Object * obj, STACKULONG MethodID, ...) __stackparm;
 103 IPTR CoerceMethodA (Class * cl, Object * obj, Msg message);
 104 IPTR CoerceMethod (Class * cl, Object * obj, STACKULONG MethodID, ...) __stackparm;
 105 IPTR DoSuperNewTagList(Class *CLASS, Object *object, struct GadgetInfo *gadgetInfo, struct TagItem *tags);
 106 IPTR DoSuperNewTags(Class *CLASS, Object *object, struct GadgetInfo *gadgetInfo, Tag tag1, ...) __stackparm;
 107 IPTR SetSuperAttrs (Class * cl, Object * obj, Tag tag1, ...) __stackparm;
 108
 109 /* Locale */
 110 #ifndef OpenCatalog
 111 struct Catalog *OpenCatalog(const struct Locale * locale,
 112                                 CONST_STRPTR name,
 113                                 Tag tag1,
 114                                 ...) __stackparm;
 115 #endif
 116
 117 /* Pools */
 118 APTR LibCreatePool (ULONG requirements, ULONG puddleSize, ULONG threshSize);
 119 void LibDeletePool (APTR poolHeader);
 120 APTR LibAllocPooled (APTR poolHeader, ULONG memSize);
 121 void LibFreePooled (APTR poolHeader, APTR memory, ULONG memSize);
 122
 123 /* Aligned */
 124 APTR LibAllocAligned (ULONG memSize, ULONG requirements, IPTR alignBytes);
 125
 126 /* Hook Support */
 127 AROS_UFP3(IPTR, HookEntry,
 128     AROS_UFPA(struct Hook *, hook,  A0),
 129     AROS_UFPA(APTR,          obj,   A2),
 130     AROS_UFPA(APTR,          param, A1)
 131 );
 132
 133 #ifndef AROS_METHODRETURNTYPE
 134 #   define AROS_METHODRETURNTYPE IPTR
 135 #endif
 136
 137 #ifdef AROS_SLOWSTACKMETHODS
 138     Msg  GetMsgFromStack  (IPTR MethodID, va_list args);
 139     void FreeMsgFromStack (Msg msg);
 140
 141 #   define AROS_NR_SLOWSTACKMETHODS_PRE(arg)    \
 142     va_list args;                               \
 143     Msg     msg;                                \
 144                                                 \
 145     va_start (args, arg);                       \
 146                                                 \
 147     if ((msg = GetMsgFromStack (arg, args)))    \
 148     {
 149
 150 #   define AROS_SLOWSTACKMETHODS_PRE_AS(arg, type) \
 151     type retval;                                \
 152                                                 \
 153     va_list args;                               \
 154     Msg     msg;                                \
 155                                                 \
 156     va_start (args, arg);                       \
 157                                                 \
 158     if ((msg = GetMsgFromStack (arg, args)))    \
 159     {
 160
 161 #   define AROS_SLOWSTACKMETHODS_PRE(arg)       \
 162         AROS_SLOWSTACKMETHODS_PRE_AS(arg, AROS_METHODRETURNTYPE)
 163
 164 #   define AROS_SLOWSTACKMETHODS_ARG(arg) msg
 165
 166 #   define AROS_SLOWSTACKMETHODS_POST           \
 167         FreeMsgFromStack (msg);                 \
 168     }                                           \
 169     else                                        \
 170         retval = (AROS_METHODRETURNTYPE)0L;     \
 171                                                 \
 172     va_end (args);                              \
 173                                                 \
 174     return retval;
 175
 176 #   define AROS_NR_SLOWSTACKMETHODS_POST        \
 177         FreeMsgFromStack (msg);                 \
 178     }                                           \
 179                                                 \
 180     va_end (args);
 181 #else
 182 #   define AROS_NR_SLOWSTACKMETHODS_PRE(arg)
 183 #   define AROS_SLOWSTACKMETHODS_PRE(arg)   AROS_METHODRETURNTYPE retval;
 184 #   define AROS_SLOWSTACKMETHODS_PRE_AS(arg, type)   type retval;
 185 #   define AROS_SLOWSTACKMETHODS_ARG(arg)   ((Msg)&(arg))
 186 #   define AROS_SLOWSTACKMETHODS_POST       return retval;
 187 #   define AROS_NR_SLOWSTACKMETHODS_POST
 188 #endif /* AROS_SLOWSTACKMETHODS */
 189
 190 #ifdef AROS_SLOWSTACKTAGS
 191     struct TagItem * GetTagsFromStack  (IPTR firstTag, va_list args);
 192     void             FreeTagsFromStack (struct TagItem * tags);
 193 #endif /* AROS_SLOWSTACKTAGS */
 194
 195 #ifndef AROS_HOOKRETURNTYPE
 196 #   define AROS_HOOKRETURNTYPE IPTR
 197 #endif
 198
 199 #ifdef AROS_SLOWSTACKHOOKS
 200     APTR  GetParamsFromStack  (va_list args);
 201     void FreeParamsFromStack (APTR params);
 202
 203 #   define AROS_NR_SLOWSTACKHOOKS_PRE(arg)    \
 204     va_list args;                               \
 205     APTR     params;                            \
 206                                                 \
 207     va_start (args, arg);                       \
 208                                                 \
 209     if ((params = GetParamsFromStack (args)))    \
 210     {
 211
 212 #   define AROS_SLOWSTACKHOOKS_PRE(arg)       \
 213     AROS_HOOKRETURNTYPE retval;         \
 214                                                 \
 215     va_list args;                               \
 216     APTR     params;                            \
 217                                                 \
 218     va_start (args, arg);                       \
 219                                                 \
 220     if ((params = GetParamsFromStack (args)))    \
 221     {
 222
 223 #   define AROS_SLOWSTACKHOOKS_ARG(arg) params
 224
 225 #   define AROS_SLOWSTACKHOOKS_POST             \
 226         FreeParamsFromStack (params);                 \
 227     }                                           \
 228     else                                        \
 229         retval = (AROS_HOOKRETURNTYPE)0L;     \
 230                                                 \
 231     va_end (args);                              \
 232                                                 \
 233     return retval;
 234
 235 #   define AROS_NR_SLOWSTACKHOOKS_POST  \
 236         FreeParamsFromStack (params);                 \
 237     }                                           \
 238                                                 \
 239     va_end (args);
 240 #else
 241 #   define AROS_NR_SLOWSTACKHOOKS_PRE(arg)
 242 #   define AROS_SLOWSTACKHOOKS_PRE(arg)   AROS_HOOKRETURNTYPE retval;
 243 #   define AROS_SLOWSTACKHOOKS_ARG(arg)   ((IPTR*)&(arg)+1)
 244 #   define AROS_SLOWSTACKHOOKS_POST         return retval;
 245 #   define AROS_NR_SLOWSTACKHOOKS_POST
 246 #endif /* AROS_SLOWSTACKHOOKS */
 247
 248 /* Rexx support */
 249 BOOL CheckRexxMsg(struct RexxMsg *);
 250 LONG SetRexxVar(struct RexxMsg *, CONST_STRPTR var, char *value, ULONG length);
 251 LONG GetRexxVar(struct RexxMsg *, CONST_STRPTR var, char **value);
 252
 253 /* Inline versions of varargs functions */
 254 #if !defined(ALIB_NO_INLINE_STDARG) && !defined(NO_INLINE_STDARG)
 255
 256 #    define SetSuperAttrsA(cl, object, attrs)             \
 257      ({                                                   \
 258          struct opSet __ops;                              \
 259                                                           \
 260          __ops.MethodID     = OM_SET;                     \
 261          __ops.ops_AttrList = (attrs);                    \
 262          __ops.ops_GInfo    = NULL;                       \
 263                                                           \
 264          DoSuperMethodA((cl), (object), (Msg) &__ops.MethodID); \
 265      })
 266 #    define SetSuperAttrs(cl, object, args...)                         \
 267      ({                                                                \
 268          IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(args) };         \
 269          SetSuperAttrsA((cl), (object), (struct TagItem *) __args);    \
 270      })
 271 #    define DoMethodA(object, message)                                 \
 272      ({                                                                \
 273          (object) != NULL ?                                            \
 274          ({                                                            \
 275              CALLHOOKPKT                                               \
 276              (                                                         \
 277                  (struct Hook *) OCLASS((object)), (object), (message) \
 278              );                                                        \
 279          })                                                            \
 280          :                                                             \
 281              0                                                         \
 282          ;                                                             \
 283     })
 284 #   define DoMethod(object, methodid, args...)                        \
 285     ({                                                                \
 286         IPTR __args[] = {methodid, AROS_PP_VARIADIC_CAST2IPTR(args)}; \
 287         DoMethodA((object), __args);                                  \
 288     })
 289
 290 #   define DoSuperMethodA(cl, object, message)                        \
 291     ({                                                                \
 292         ((cl) != NULL && (object) != NULL) ?                          \
 293             CALLHOOKPKT                                               \
 294             (                                                         \
 295                 (struct Hook *) ((Class *) (cl))->cl_Super,           \
 296                 (object), (message)                                   \
 297             )                                                         \
 298         :                                                             \
 299             0                                                         \
 300         ;                                                             \
 301     })
 302 #   define DoSuperMethod(cl, object, methodid, args...)               \
 303     ({                                                                \
 304         IPTR __args[] = {methodid, AROS_PP_VARIADIC_CAST2IPTR(args)}; \
 305         DoSuperMethodA((cl), (object), __args);                       \
 306     })
 307
 308 #   define CoerceMethodA(cl, object, message)                         \
 309     ({                                                                \
 310         ((cl) != NULL && (object) != NULL) ?                          \
 311             CALLHOOKPKT((struct Hook *) (cl), (object), (message))    \
 312         :                                                             \
 313             0                                                         \
 314         ;                                                             \
 315     })
 316 #   define CoerceMethod(cl, object, methodid, args...)                 \
 317     ({                                                                 \
 318          IPTR __args[] = {methodid, AROS_PP_VARIADIC_CAST2IPTR(args)}; \
 319          CoerceMethodA((cl), (object), __args);                        \
 320     })
 321 #   define DoSuperNewTagList(cl, object, gadgetinfo, tags)                 \
 322     ({                                                                     \
 323         struct opSet __ops;                                                \
 324                                                                            \
 325         __ops.MethodID     = OM_NEW;                                       \
 326         __ops.ops_AttrList = (tags);                                       \
 327         __ops.ops_GInfo    = (gadgetinfo);                                 \
 328                                                                            \
 329         (cl) != NULL && (object) != NULL ?                                 \
 330             DoSuperMethodA((cl), (object), (Msg)&__ops.MethodID)           \
 331         :                                                                  \
 332             0                                                              \
 333         ;                                                                  \
 334     })
 335 #   define DoSuperNewTags(cl, object, gadgetinfo, args...)                 \
 336     ({                                                                     \
 337         IPTR __args[] = {AROS_PP_VARIADIC_CAST2IPTR(args)};                \
 338         DoSuperNewTagList                                                  \
 339         (                                                                  \
 340             (cl), (object), (gadgetinfo), (struct TagItem *) __args        \
 341         );                                                                 \
 342     })
 343
 344 #define CallHook(hook, object, args...)                                 \
 345     ({                                                                  \
 346         IPTR __args[] = {AROS_PP_VARIADIC_CAST2IPTR(args)};             \
 347         CallHookA((hook), (object), __args);                            \
 348     })
 349
 350 #endif /* !ALIB_NO_INLINE_STDARG && !NO_INLINE_STDARG */
 351
 352 __END_DECLS
 353
 354 #endif /* CLIB_ALIB_PROTOS_H */