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 /* Aligned */
 125 APTR LibAllocAligned (ULONG memSize, ULONG requirements, IPTR alignBytes);
 126
 127 /* Hook Support */
 128 AROS_UFP3(IPTR, HookEntry,
 129     AROS_UFPA(struct Hook *, hook,  A0),
 130     AROS_UFPA(APTR,          obj,   A2),
 131     AROS_UFPA(APTR,          param, A1)
 132 );
 133
 134 #ifndef AROS_METHODRETURNTYPE
 135 #   define AROS_METHODRETURNTYPE IPTR
 136 #endif
 137
 138 #ifdef AROS_SLOWSTACKMETHODS
 139     Msg  GetMsgFromStack  (IPTR MethodID, va_list args);
 140     void FreeMsgFromStack (Msg msg);
 141
 142 #   define AROS_NR_SLOWSTACKMETHODS_PRE(arg)    \
 143     va_list args;                               \
 144     Msg     msg;                                \
 145                                                 \
 146     va_start (args, arg);                       \
 147                                                 \
 148     if ((msg = GetMsgFromStack (arg, args)))    \
 149     {
 150
 151 #   define AROS_SLOWSTACKMETHODS_PRE_AS(arg, type) \
 152     type retval;                                \
 153                                                 \
 154     va_list args;                               \
 155     Msg     msg;                                \
 156                                                 \
 157     va_start (args, arg);                       \
 158                                                 \
 159     if ((msg = GetMsgFromStack (arg, args)))    \
 160     {
 161
 162 #   define AROS_SLOWSTACKMETHODS_PRE(arg)       \
 163         AROS_SLOWSTACKMETHODS_PRE_AS(arg, AROS_METHODRETURNTYPE)
 164
 165 #   define AROS_SLOWSTACKMETHODS_ARG(arg) msg
 166
 167 #   define AROS_SLOWSTACKMETHODS_POST           \
 168         FreeMsgFromStack (msg);                 \
 169     }                                           \
 170     else                                        \
 171         retval = (AROS_METHODRETURNTYPE)0L;     \
 172                                                 \
 173     va_end (args);                              \
 174                                                 \
 175     return retval;
 176
 177 #   define AROS_NR_SLOWSTACKMETHODS_POST        \
 178         FreeMsgFromStack (msg);                 \
 179     }                                           \
 180                                                 \
 181     va_end (args);
 182 #else
 183 #   define AROS_NR_SLOWSTACKMETHODS_PRE(arg)
 184 #   define AROS_SLOWSTACKMETHODS_PRE(arg)   AROS_METHODRETURNTYPE retval;
 185 #   define AROS_SLOWSTACKMETHODS_PRE_AS(arg, type)   type retval;
 186 #   define AROS_SLOWSTACKMETHODS_ARG(arg)   ((Msg)&(arg))
 187 #   define AROS_SLOWSTACKMETHODS_POST       return retval;
 188 #   define AROS_NR_SLOWSTACKMETHODS_POST
 189 #endif /* AROS_SLOWSTACKMETHODS */
 190
 191 #ifdef AROS_SLOWSTACKTAGS
 192     struct TagItem * GetTagsFromStack  (IPTR firstTag, va_list args);
 193     void             FreeTagsFromStack (struct TagItem * tags);
 194 #endif /* AROS_SLOWSTACKTAGS */
 195
 196 #ifndef AROS_HOOKRETURNTYPE
 197 #   define AROS_HOOKRETURNTYPE IPTR
 198 #endif
 199
 200 #ifdef AROS_SLOWSTACKHOOKS
 201     APTR  GetParamsFromStack  (va_list args);
 202     void FreeParamsFromStack (APTR params);
 203
 204 #   define AROS_NR_SLOWSTACKHOOKS_PRE(arg)    \
 205     va_list args;                               \
 206     APTR     params;                            \
 207                                                 \
 208     va_start (args, arg);                       \
 209                                                 \
 210     if ((params = GetParamsFromStack (args)))    \
 211     {
 212
 213 #   define AROS_SLOWSTACKHOOKS_PRE(arg)       \
 214     AROS_HOOKRETURNTYPE retval;         \
 215                                                 \
 216     va_list args;                               \
 217     APTR     params;                            \
 218                                                 \
 219     va_start (args, arg);                       \
 220                                                 \
 221     if ((params = GetParamsFromStack (args)))    \
 222     {
 223
 224 #   define AROS_SLOWSTACKHOOKS_ARG(arg) params
 225
 226 #   define AROS_SLOWSTACKHOOKS_POST             \
 227         FreeParamsFromStack (params);                 \
 228     }                                           \
 229     else                                        \
 230         retval = (AROS_HOOKRETURNTYPE)0L;     \
 231                                                 \
 232     va_end (args);                              \
 233                                                 \
 234     return retval;
 235
 236 #   define AROS_NR_SLOWSTACKHOOKS_POST  \
 237         FreeParamsFromStack (params);                 \
 238     }                                           \
 239                                                 \
 240     va_end (args);
 241 #else
 242 #   define AROS_NR_SLOWSTACKHOOKS_PRE(arg)
 243 #   define AROS_SLOWSTACKHOOKS_PRE(arg)   AROS_HOOKRETURNTYPE retval;
 244 #   define AROS_SLOWSTACKHOOKS_ARG(arg)   ((IPTR*)&(arg)+1)
 245 #   define AROS_SLOWSTACKHOOKS_POST         return retval;
 246 #   define AROS_NR_SLOWSTACKHOOKS_POST
 247 #endif /* AROS_SLOWSTACKHOOKS */
 248
 249 /* Rexx support */
 250 BOOL CheckRexxMsg(struct RexxMsg *);
 251 LONG SetRexxVar(struct RexxMsg *, CONST_STRPTR var, char *value, ULONG length);
 252 LONG GetRexxVar(struct RexxMsg *, CONST_STRPTR var, char **value);
 253
 254 /* Inline versions of varargs functions */
 255 #if !defined(ALIB_NO_INLINE_STDARG) && !defined(NO_INLINE_STDARG)
 256
 257 #    define SetSuperAttrsA(cl, object, attrs)             \
 258      ({                                                   \
 259          struct opSet __ops;                              \
 260                                                           \
 261          __ops.MethodID     = OM_SET;                     \
 262          __ops.ops_AttrList = (attrs);                    \
 263          __ops.ops_GInfo    = NULL;                       \
 264                                                           \
 265          DoSuperMethodA((cl), (object), (Msg) &__ops.MethodID); \
 266      })
 267 #    define SetSuperAttrs(cl, object, args...)                         \
 268      ({                                                                \
 269          IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(args) };         \
 270          SetSuperAttrsA((cl), (object), (struct TagItem *) __args);    \
 271      })
 272 #    define DoMethodA(object, message)                                 \
 273      ({                                                                \
 274          (object) != NULL ?                                            \
 275          ({                                                            \
 276              CALLHOOKPKT                                               \
 277              (                                                         \
 278                  (struct Hook *) OCLASS((object)), (object), (message) \
 279              );                                                        \
 280          })                                                            \
 281          :                                                             \
 282              0                                                         \
 283          ;                                                             \
 284     })
 285 #   define DoMethod(object, methodid, args...)                        \
 286     ({                                                                \
 287         IPTR __args[] = {methodid, AROS_PP_VARIADIC_CAST2IPTR(args)}; \
 288         DoMethodA((object), __args);                                  \
 289     })
 290
 291 #   define DoSuperMethodA(cl, object, message)                        \
 292     ({                                                                \
 293         ((cl) != NULL && (object) != NULL) ?                          \
 294             CALLHOOKPKT                                               \
 295             (                                                         \
 296                 (struct Hook *) ((Class *) (cl))->cl_Super,           \
 297                 (object), (message)                                   \
 298             )                                                         \
 299         :                                                             \
 300             0                                                         \
 301         ;                                                             \
 302     })
 303 #   define DoSuperMethod(cl, object, methodid, args...)               \
 304     ({                                                                \
 305         IPTR __args[] = {methodid, AROS_PP_VARIADIC_CAST2IPTR(args)}; \
 306         DoSuperMethodA((cl), (object), __args);                       \
 307     })
 308
 309 #   define CoerceMethodA(cl, object, message)                         \
 310     ({                                                                \
 311         ((cl) != NULL && (object) != NULL) ?                          \
 312             CALLHOOKPKT((struct Hook *) (cl), (object), (message))    \
 313         :                                                             \
 314             0                                                         \
 315         ;                                                             \
 316     })
 317 #   define CoerceMethod(cl, object, methodid, args...)                 \
 318     ({                                                                 \
 319          IPTR __args[] = {methodid, AROS_PP_VARIADIC_CAST2IPTR(args)}; \
 320          CoerceMethodA((cl), (object), __args);                        \
 321     })
 322 #   define DoSuperNewTagList(cl, object, gadgetinfo, tags)                 \
 323     ({                                                                     \
 324         struct opSet __ops;                                                \
 325                                                                            \
 326         __ops.MethodID     = OM_NEW;                                       \
 327         __ops.ops_AttrList = (tags);                                       \
 328         __ops.ops_GInfo    = (gadgetinfo);                                 \
 329                                                                            \
 330         (cl) != NULL && (object) != NULL ?                                 \
 331             DoSuperMethodA((cl), (object), (Msg)&__ops.MethodID)           \
 332         :                                                                  \
 333             0                                                              \
 334         ;                                                                  \
 335     })
 336 #   define DoSuperNewTags(cl, object, gadgetinfo, args...)                 \
 337     ({                                                                     \
 338         IPTR __args[] = {AROS_PP_VARIADIC_CAST2IPTR(args)};                \
 339         DoSuperNewTagList                                                  \
 340         (                                                                  \
 341             (cl), (object), (gadgetinfo), (struct TagItem *) __args        \
 342         );                                                                 \
 343     })
 344
 345 #define CallHook(hook, object, args...)                                 \
 346     ({                                                                  \
 347         IPTR __args[] = {AROS_PP_VARIADIC_CAST2IPTR(args)};             \
 348         CallHookA((hook), (object), __args);                            \
 349     })
 350
 351 #endif /* !ALIB_NO_INLINE_STDARG && !NO_INLINE_STDARG */
 352
 353 __END_DECLS
 354
 355 #endif /* CLIB_ALIB_PROTOS_H */