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 APTR ReAllocVec(APTR oldmem, ULONG size, ULONG requirements);
  68
  69 void MergeSortList(struct MinList *l, int (*compare)(struct MinNode *n1, struct MinNode *n2, void *data), void *data);
  70
  71 /* Commodities */
  72 CxObj  *HotKey (STRPTR description, struct MsgPort *port, LONG id);
  73 VOID    FreeIEvents (volatile struct InputEvent *events);
  74 UBYTE **ArgArrayInit(ULONG argc, UBYTE **argv);
  75 VOID    ArgArrayDone(VOID);
  76 LONG    ArgInt(UBYTE **tt, STRPTR entry, LONG defaultVal);
  77 STRPTR  ArgString(UBYTE **tt, STRPTR entry, STRPTR defaultstring);
  78 struct  InputEvent *InvertString(STRPTR str, struct KeyMap *km);
  79 struct  InputEvent *InvertStringForwd(STRPTR str, struct KeyMap *km);
  80
  81 /* Graphics */
  82 #ifndef ObtainBestPen
  83 LONG ObtainBestPen( struct ColorMap * cm, LONG R, LONG G, LONG B, ULONG tag1, ...) __stackparm;
  84 #endif
  85
  86 #ifndef GetRPAttrs
  87 void GetRPAttrs( struct RastPort * rp, Tag tag1, ...) __stackparm;
  88 #endif
  89
  90 BOOL AndRectRect(struct Rectangle *rect1, struct Rectangle *rect2, struct Rectangle *intersect);
  91 struct Region *CopyRegion(struct Region *region);
  92 struct Region *NewRectRegion(WORD MinX, WORD MinY, WORD MaxX, WORD MaxY);
  93
  94 /* Intuition */
  95 #ifndef SetWindowPointer
  96 void SetWindowPointer( struct Window * window, ULONG tag1, ...) __stackparm;
  97 #endif
  98
  99 /* BOOPSI */
 100 IPTR DoMethodA (Object * obj, Msg message);
 101 IPTR DoMethod (Object * obj, STACKULONG MethodID, ...) __stackparm;
 102 IPTR DoSuperMethodA (Class * cl, Object * obj, Msg message);
 103 IPTR DoSuperMethod (Class * cl, Object * obj, STACKULONG MethodID, ...) __stackparm;
 104 IPTR CoerceMethodA (Class * cl, Object * obj, Msg message);
 105 IPTR CoerceMethod (Class * cl, Object * obj, STACKULONG MethodID, ...) __stackparm;
 106 IPTR DoSuperNewTagList(Class *CLASS, Object *object, struct GadgetInfo *gadgetInfo, struct TagItem *tags);
 107 IPTR DoSuperNewTags(Class *CLASS, Object *object, struct GadgetInfo *gadgetInfo, Tag tag1, ...) __stackparm;
 108 IPTR SetSuperAttrs (Class * cl, Object * obj, Tag tag1, ...) __stackparm;
 109
 110 /* Locale */
 111 #ifndef OpenCatalog
 112 struct Catalog *OpenCatalog(const struct Locale * locale,
 113                                 CONST_STRPTR name,
 114                                 Tag tag1,
 115                                 ...) __stackparm;
 116 #endif
 117
 118 /* Pools */
 119 APTR LibCreatePool (ULONG requirements, ULONG puddleSize, ULONG threshSize);
 120 void LibDeletePool (APTR poolHeader);
 121 APTR LibAllocPooled (APTR poolHeader, ULONG memSize);
 122 void LibFreePooled (APTR poolHeader, APTR memory, ULONG memSize);
 123
 124 /* Hook Support */
 125 AROS_UFP3(IPTR, HookEntry,
 126     AROS_UFPA(struct Hook *, hook,  A0),
 127     AROS_UFPA(APTR,          obj,   A2),
 128     AROS_UFPA(APTR,          param, A1)
 129 );
 130
 131 #ifndef AROS_METHODRETURNTYPE
 132 #   define AROS_METHODRETURNTYPE IPTR
 133 #endif
 134
 135 #ifdef AROS_SLOWSTACKMETHODS
 136     Msg  GetMsgFromStack  (IPTR MethodID, va_list args);
 137     void FreeMsgFromStack (Msg msg);
 138
 139 #   define AROS_NR_SLOWSTACKMETHODS_PRE(arg)    \
 140     va_list args;                               \
 141     Msg     msg;                                \
 142                                                 \
 143     va_start (args, arg);                       \
 144                                                 \
 145     if ((msg = GetMsgFromStack (arg, args)))    \
 146     {
 147
 148 #   define AROS_SLOWSTACKMETHODS_PRE_AS(arg, type) \
 149     type retval;                                \
 150                                                 \
 151     va_list args;                               \
 152     Msg     msg;                                \
 153                                                 \
 154     va_start (args, arg);                       \
 155                                                 \
 156     if ((msg = GetMsgFromStack (arg, args)))    \
 157     {
 158
 159 #   define AROS_SLOWSTACKMETHODS_PRE(arg)       \
 160         AROS_SLOWSTACKMETHODS_PRE_AS(arg, AROS_METHODRETURNTYPE)
 161
 162 #   define AROS_SLOWSTACKMETHODS_ARG(arg) msg
 163
 164 #   define AROS_SLOWSTACKMETHODS_POST           \
 165         FreeMsgFromStack (msg);                 \
 166     }                                           \
 167     else                                        \
 168         retval = (AROS_METHODRETURNTYPE)0L;     \
 169                                                 \
 170     va_end (args);                              \
 171                                                 \
 172     return retval;
 173
 174 #   define AROS_NR_SLOWSTACKMETHODS_POST        \
 175         FreeMsgFromStack (msg);                 \
 176     }                                           \
 177                                                 \
 178     va_end (args);
 179 #else
 180 #   define AROS_NR_SLOWSTACKMETHODS_PRE(arg)
 181 #   define AROS_SLOWSTACKMETHODS_PRE(arg)   AROS_METHODRETURNTYPE retval;
 182 #   define AROS_SLOWSTACKMETHODS_PRE_AS(arg, type)   type retval;
 183 #   define AROS_SLOWSTACKMETHODS_ARG(arg)   ((Msg)&(arg))
 184 #   define AROS_SLOWSTACKMETHODS_POST       return retval;
 185 #   define AROS_NR_SLOWSTACKMETHODS_POST
 186 #endif /* AROS_SLOWSTACKMETHODS */
 187
 188 #ifdef AROS_SLOWSTACKTAGS
 189     struct TagItem * GetTagsFromStack  (IPTR firstTag, va_list args);
 190     void             FreeTagsFromStack (struct TagItem * tags);
 191 #endif /* AROS_SLOWSTACKTAGS */
 192
 193 #ifndef AROS_HOOKRETURNTYPE
 194 #   define AROS_HOOKRETURNTYPE IPTR
 195 #endif
 196
 197 #ifdef AROS_SLOWSTACKHOOKS
 198     APTR  GetParamsFromStack  (va_list args);
 199     void FreeParamsFromStack (APTR params);
 200
 201 #   define AROS_NR_SLOWSTACKHOOKS_PRE(arg)    \
 202     va_list args;                               \
 203     APTR     params;                            \
 204                                                 \
 205     va_start (args, arg);                       \
 206                                                 \
 207     if ((params = GetParamsFromStack (args)))    \
 208     {
 209
 210 #   define AROS_SLOWSTACKHOOKS_PRE(arg)       \
 211     AROS_HOOKRETURNTYPE retval;         \
 212                                                 \
 213     va_list args;                               \
 214     APTR     params;                            \
 215                                                 \
 216     va_start (args, arg);                       \
 217                                                 \
 218     if ((params = GetParamsFromStack (args)))    \
 219     {
 220
 221 #   define AROS_SLOWSTACKHOOKS_ARG(arg) params
 222
 223 #   define AROS_SLOWSTACKHOOKS_POST             \
 224         FreeParamsFromStack (params);                 \
 225     }                                           \
 226     else                                        \
 227         retval = (AROS_HOOKRETURNTYPE)0L;     \
 228                                                 \
 229     va_end (args);                              \
 230                                                 \
 231     return retval;
 232
 233 #   define AROS_NR_SLOWSTACKHOOKS_POST  \
 234         FreeParamsFromStack (params);                 \
 235     }                                           \
 236                                                 \
 237     va_end (args);
 238 #else
 239 #   define AROS_NR_SLOWSTACKHOOKS_PRE(arg)
 240 #   define AROS_SLOWSTACKHOOKS_PRE(arg)   AROS_HOOKRETURNTYPE retval;
 241 #   define AROS_SLOWSTACKHOOKS_ARG(arg)   ((IPTR*)&(arg)+1)
 242 #   define AROS_SLOWSTACKHOOKS_POST         return retval;
 243 #   define AROS_NR_SLOWSTACKHOOKS_POST
 244 #endif /* AROS_SLOWSTACKHOOKS */
 245
 246 /* Rexx support */
 247 BOOL CheckRexxMsg(struct RexxMsg *);
 248 LONG SetRexxVar(struct RexxMsg *, CONST_STRPTR var, char *value, ULONG length);
 249 LONG GetRexxVar(struct RexxMsg *, CONST_STRPTR var, char **value);
 250
 251 /* Inline versions of varargs functions */
 252 #if !defined(ALIB_NO_INLINE_STDARG) && !defined(NO_INLINE_STDARG)
 253
 254 #    define SetSuperAttrsA(cl, object, attrs)             \
 255      ({                                                   \
 256          struct opSet __ops;                              \
 257                                                           \
 258          __ops.MethodID     = OM_SET;                     \
 259          __ops.ops_AttrList = (attrs);                    \
 260          __ops.ops_GInfo    = NULL;                       \
 261                                                           \
 262          DoSuperMethodA((cl), (object), (Msg) &__ops.MethodID); \
 263      })
 264 #    define SetSuperAttrs(cl, object, args...)                         \
 265      ({                                                                \
 266          IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(args) };         \
 267          SetSuperAttrsA((cl), (object), (struct TagItem *) __args);    \
 268      })
 269 #    define DoMethodA(object, message)                                 \
 270      ({                                                                \
 271          (object) != NULL ?                                            \
 272          ({                                                            \
 273              CALLHOOKPKT                                               \
 274              (                                                         \
 275                  (struct Hook *) OCLASS((object)), (object), (message) \
 276              );                                                        \
 277          })                                                            \
 278          :                                                             \
 279              0                                                         \
 280          ;                                                             \
 281     })
 282 #   define DoMethod(object, methodid, args...)                        \
 283     ({                                                                \
 284         IPTR __args[] = {methodid, AROS_PP_VARIADIC_CAST2IPTR(args)}; \
 285         DoMethodA((object), __args);                                  \
 286     })
 287
 288 #   define DoSuperMethodA(cl, object, message)                        \
 289     ({                                                                \
 290         ((cl) != NULL && (object) != NULL) ?                          \
 291             CALLHOOKPKT                                               \
 292             (                                                         \
 293                 (struct Hook *) ((Class *) (cl))->cl_Super,           \
 294                 (object), (message)                                   \
 295             )                                                         \
 296         :                                                             \
 297             0                                                         \
 298         ;                                                             \
 299     })
 300 #   define DoSuperMethod(cl, object, methodid, args...)               \
 301     ({                                                                \
 302         IPTR __args[] = {methodid, AROS_PP_VARIADIC_CAST2IPTR(args)}; \
 303         DoSuperMethodA((cl), (object), __args);                       \
 304     })
 305
 306 #   define CoerceMethodA(cl, object, message)                         \
 307     ({                                                                \
 308         ((cl) != NULL && (object) != NULL) ?                          \
 309             CALLHOOKPKT((struct Hook *) (cl), (object), (message))    \
 310         :                                                             \
 311             0                                                         \
 312         ;                                                             \
 313     })
 314 #   define CoerceMethod(cl, object, methodid, args...)                 \
 315     ({                                                                 \
 316          IPTR __args[] = {methodid, AROS_PP_VARIADIC_CAST2IPTR(args)}; \
 317          CoerceMethodA((cl), (object), __args);                        \
 318     })
 319 #   define DoSuperNewTagList(cl, object, gadgetinfo, tags)                 \
 320     ({                                                                     \
 321         struct opSet __ops;                                                \
 322                                                                            \
 323         __ops.MethodID     = OM_NEW;                                       \
 324         __ops.ops_AttrList = (tags);                                       \
 325         __ops.ops_GInfo    = (gadgetinfo);                                 \
 326                                                                            \
 327         (cl) != NULL && (object) != NULL ?                                 \
 328             DoSuperMethodA((cl), (object), (Msg)&__ops.MethodID)           \
 329         :                                                                  \
 330             0                                                              \
 331         ;                                                                  \
 332     })
 333 #   define DoSuperNewTags(cl, object, gadgetinfo, args...)                 \
 334     ({                                                                     \
 335         IPTR __args[] = {AROS_PP_VARIADIC_CAST2IPTR(args)};                \
 336         DoSuperNewTagList                                                  \
 337         (                                                                  \
 338             (cl), (object), (gadgetinfo), (struct TagItem *) __args        \
 339         );                                                                 \
 340     })
 341
 342 #define CallHook(hook, object, args...)                                 \
 343     ({                                                                  \
 344         IPTR __args[] = {AROS_PP_VARIADIC_CAST2IPTR(args)};             \
 345         CallHookA((hook), (object), __args);                            \
 346     })
 347
 348 #endif /* !ALIB_NO_INLINE_STDARG && !NO_INLINE_STDARG */
 349
 350 __END_DECLS
 351
 352 #endif /* CLIB_ALIB_PROTOS_H */