compiler/alib/alib_util.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Internal utility functions.
   6 */
   7
   8 #include <aros/system.h>
   9 #include "alib_intern.h"
  10
  11 #ifdef AROS_SLOWSTACKMETHODS
  12 #include <intuition/classusr.h>
  13 #include <proto/exec.h>
  14 /******************************************************************************
  15
  16     NAME */
  17         Msg GetMsgFromStack (
  18
  19 /*  SYNOPSIS */
  20         IPTR    MethodID,
  21         va_list args)
  22
  23 /*  FUNCTION
  24         Builds a message structure with the parameters which are passed on
  25         the stack. This function is used on machines which have compilers
  26         which don't pass the arguments to a varargs function unlike the
  27         Amiga ones.
  28
  29     INPUTS
  30         MethodID - This is the ID of the message
  31         args - This has to be initialized by va_start()
  32         firstlocal - The address of the first local function of the
  33                 function which wants to call GetMsgFromStack()
  34
  35     RESULT
  36         A message which can be passed to any function which expects the
  37         structure which is defined for this MethodID or NULL if something
  38         failed. This call may fail for different reasons on different
  39         systems. On some systems, NULL indicates that there was not enough
  40         memory, on others that the MethodID is unknown.
  41
  42     NOTES
  43         This function fails for structures with more than 32 fields.
  44
  45     EXAMPLE
  46
  47     BUGS
  48
  49     SEE ALSO
  50         boopsi.library/NewObject(), boopsi.library/SetAttrs(), boopsi.library/GetAttr(),
  51         boopsi.library/DisposeObject(), DoMethodA(),
  52         DoSuperMethodA(), "Basic Object-Oriented Programming System for
  53         Intuition" and the "boopsi Class Reference" Dokument.
  54
  55     INTERNALS
  56         HPPA: Allocate a structure which can contain all IPTRs between
  57         the first argument of, for example, DoMethod() and its first local
  58         variable. This will copy a bit too much memory but in the end, it
  59         saves a lot of work, since it's not neccessary to register every
  60         structure.
  61
  62     HISTORY
  63         22.11.96 digulla created
  64
  65 ******************************************************************************/
  66 {
  67     ULONG size;
  68     Msg   msg;
  69
  70     size = 33;
  71
  72     if ((msg = AllocVec (size * sizeof (IPTR), MEMF_CLEAR)))
  73     {
  74         IPTR * ulptr = (IPTR *)msg;
  75
  76         *ulptr ++ = MethodID;
  77
  78         while (-- size)
  79         {
  80             *ulptr ++ = va_arg (args, IPTR);
  81         }
  82     }
  83
  84     return msg;
  85 } /* GetMsgFromStack */
  86
  87 /******************************************************************************
  88
  89     NAME */
  90         void FreeMsgFromStack (
  91
  92 /*  SYNOPSIS */
  93         Msg msg)
  94
  95 /*  FUNCTION
  96         Frees the memory occupied by the message which was created by
  97         GetMsgFromStack().
  98
  99     INPUTS
 100         msg - The return value of GetMsgFromStack(). May be NULL.
 101
 102     RESULT
 103         None.
 104
 105     NOTES
 106
 107     EXAMPLE
 108
 109     BUGS
 110
 111     SEE ALSO
 112         GetMsgFromStack()
 113
 114     HISTORY
 115         22.11.96 digulla created
 116
 117 ******************************************************************************/
 118 {
 119     if (msg)
 120         FreeVec (msg);
 121 } /* FreeMsgFromStack */
 122
 123 #endif /* AROS_SLOWSTACKMETHODS */
 124
 125 #ifdef AROS_SLOWSTACKTAGS
 126 #include <stdarg.h>
 127 #include <utility/tagitem.h>
 128 #include <exec/memory.h>
 129 #include <proto/exec.h>
 130 /******************************************************************************
 131
 132     NAME */
 133         struct TagItem * GetTagsFromStack (
 134
 135 /*  SYNOPSIS */
 136         IPTR    firstTag,
 137         va_list args)
 138
 139 /*  FUNCTION
 140         Builds a tagitem array with the tags on the stack. This function is
 141         used on machines which have compilers which don't pass the
 142         arguments to a varargs function unlike the Amiga ones.
 143
 144     INPUTS
 145         firstTag - This is the first tag passed to the function
 146         args - This has to be initialized by va_start()
 147
 148     RESULT
 149         A TagItem array which can be passed to any function which expects
 150         such an array or NULL if something failed. This call may fail for
 151         different reasons on different systems. On some systems, NULL
 152         indicates that there was not enough memory, on others that the
 153         MethodID is unknown.
 154
 155     NOTES
 156
 157     EXAMPLE
 158
 159     BUGS
 160
 161     SEE ALSO
 162         boopsi.library/NewObject(), boopsi.library/SetAttrs(), boopsi.library/GetAttr(),
 163         boopsi.library/DisposeObject(), DoMethodA(),
 164         DoSuperMethodA(), "Basic Object-Oriented Programming System for
 165         Intuition" and the "boopsi Class Reference" Dokument.
 166
 167     INTERNALS
 168         Allocate a structure which can contain all tags until the first
 169         TAG_END. This takes into account TAG_MORE and the like. The code
 170         will break if someone makes assumptions about the way taglists
 171         are built in memory, ie. if he looks for the next TAG_MORE and
 172         then simply skips it instead of following it.
 173
 174     HISTORY
 175         22.11.96 digulla created
 176
 177 ******************************************************************************/
 178 {
 179     struct TagItem * ti;
 180     IPTR             tag;
 181     ULONG            size;
 182     va_list          ap;
 183
 184     va_copy(ap, args);
 185     tag = firstTag;
 186
 187     for (size=0;;size++)
 188     {
 189         if (tag == TAG_END || tag == TAG_MORE)
 190         {
 191             size ++; /* Copy this tag, too */
 192             break;
 193         }
 194
 195         switch (tag)
 196         {
 197         case TAG_IGNORE:
 198         (void) va_arg(args, IPTR);
 199             size --; /* Don't copy this tag */
 200             break;
 201
 202         case TAG_SKIP: {
 203             ULONG skip;
 204
 205             skip = va_arg(args, IPTR);
 206
 207             while (skip --)
 208             {
 209                 (void) va_arg(args, IPTR);
 210                 (void) va_arg(args, IPTR);
 211             }
 212
 213             break; }
 214
 215         default:
 216             (void) va_arg(args, IPTR);
 217         }
 218
 219         tag = va_arg (args, IPTR);
 220     }
 221
 222     tag  = firstTag;
 223
 224     if ((ti = AllocVec (size*sizeof(struct TagItem), MEMF_ANY)))
 225     {
 226         for (size=0;;size++)
 227         {
 228             ti[size].ti_Tag = tag;
 229
 230             if (tag == TAG_END)
 231                 break;
 232             else if (tag == TAG_MORE)
 233             {
 234                 ti[size].ti_Data = (IPTR) va_arg (ap, struct TagItem *);
 235                 break;
 236             }
 237
 238             switch (tag)
 239             {
 240             case TAG_IGNORE:
 241         (void) va_arg(ap, IPTR);
 242                 size --; /* Don't copy this tag */
 243                 break;
 244
 245             case TAG_SKIP: {
 246                 ULONG skip;
 247
 248                 skip = va_arg(ap, IPTR);
 249
 250                 while (skip --)
 251                 {
 252                     (void) va_arg(ap, IPTR);
 253                     (void) va_arg(ap, IPTR);
 254                 }
 255
 256                 break; }
 257
 258             default:
 259                 ti[size].ti_Data = va_arg(ap, IPTR);
 260             }
 261
 262             tag = va_arg (ap, IPTR);
 263         }
 264     }
 265     va_end(ap);
 266     return ti;
 267 } /* GetTagsFromStack */
 268
 269 /******************************************************************************
 270
 271     NAME */
 272         void FreeTagsFromStack (
 273
 274 /*  SYNOPSIS */
 275         struct TagItem * tags)
 276
 277 /*  FUNCTION
 278         Frees the memory occupied by the tagitems which were created by
 279         GetTagsFromStack().
 280
 281     INPUTS
 282         tags - The return value of GetTagsFromStack(). May be NULL.
 283
 284     RESULT
 285         None.
 286
 287     NOTES
 288
 289     EXAMPLE
 290
 291     BUGS
 292
 293     SEE ALSO
 294         GetTagsFromStack()
 295
 296     HISTORY
 297         22.11.96 digulla created
 298
 299 ******************************************************************************/
 300 {
 301     if (tags)
 302         FreeVec (tags);
 303 } /* FreeTagsFromStack */
 304
 305 /******************************************************************************
 306
 307     NAME */
 308         APTR GetParamsFromStack (
 309
 310 /*  SYNOPSIS */
 311         va_list args)
 312
 313 /*  FUNCTION
 314         Builds an array of parameters which are passed on the stack.
 315         This function is used on machines which have compilers which
 316         don't pass the arguments to a varargs function unlike the
 317         Amiga ones.
 318
 319     INPUTS
 320         args - This has to be initialized by va_start()
 321
 322     RESULT
 323         An array which can be passed to any function which expects the
 324         structure or NULL if something failed. This call may fail for
 325         different reasons on different systems. On some systems, NULL
 326         indicates that there was not enough     memory.
 327
 328     NOTES
 329         This function fails for structures with more than 20 fields.
 330
 331     EXAMPLE
 332
 333     BUGS
 334
 335     SEE ALSO
 336         CallHook()
 337
 338     INTERNALS
 339         HPPA: Allocate a structure which can contain all APTRs between the
 340         first variadic parameter of, for example, CallHook() and its first
 341         local variable. This will copy a bit too much memory but in the end,
 342         it saves a lot of work, since it's not neccessary to register every
 343         structure.
 344
 345     HISTORY
 346         25.04.08 sszymczy adapted from GetMsgFromStack()
 347
 348 ******************************************************************************/
 349 {
 350     ULONG size;
 351     APTR params;
 352
 353     size = 21;
 354
 355     if ((params = AllocVec (size * sizeof (IPTR), MEMF_CLEAR)))
 356     {
 357         IPTR * ulptr = (IPTR *) params;
 358
 359         while (-- size)
 360         {
 361             *ulptr ++ = va_arg (args, IPTR);
 362         }
 363     }
 364
 365     return params;
 366 } /* GetParamsFromStack */
 367
 368 /******************************************************************************
 369
 370     NAME */
 371         void FreeParamsFromStack (
 372
 373 /*  SYNOPSIS */
 374         APTR params)
 375
 376 /*  FUNCTION
 377         Frees the memory occupied by the parameters array which was
 378         created by GetParamsFromStack().
 379
 380     INPUTS
 381         params - The return value of GetParamsFromStack(). May be NULL.
 382
 383     RESULT
 384         None.
 385
 386     NOTES
 387
 388     EXAMPLE
 389
 390     BUGS
 391
 392     SEE ALSO
 393         GetParamsFromStack()
 394
 395     HISTORY
 396     25.04.08 sszymczy adapted from FreeMsgFromStack()
 397
 398 ******************************************************************************/
 399 {
 400     if (params)
 401         FreeVec (params);
 402 } /* FreeParamsFromStack */
 403
 404 #endif /* AROS_SLOWSTACKTAGS */
 405
 406
 407