URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [objc-obj-c++-shared/] [objc-test-suite-next-encode-assist-impl.h] - Blame information for rev 705

Details | Compare with Previous | View Log


#ifndef _OBJC_TEST_SUITE_NEXT_ENCODE_ASSIST_IMPL_H_
#define _OBJC_TEST_SUITE_NEXT_ENCODE_ASSIST_IMPL_H_
 
#ifdef __NEXT_RUNTIME__
 
/* Determine which API to use.  */
#include "next-abi.h"
#ifdef NEXT_OBJC_USE_NEW_INTERFACE
#include <objc/runtime.h>
#else
#include <objc/objc-runtime.h>
#endif
 
/* ---- */
 
#undef  MAX
#undef  MIN
#undef  ROUND
 
#ifdef __cplusplus
#  define MAX(X, Y) ((X > Y) ? X : Y)
#  define MIN(X, Y) ((X < Y) ? X : Y)
#  define ROUND(V, A) (A * ((V + A - 1) / A))
#else
#  define MAX(X, Y)                    \
  ({ typeof (X) __x = (X), __y = (Y); \
     (__x > __y ? __x : __y); })
#  define MIN(X, Y)                    \
  ({ typeof (X) __x = (X), __y = (Y); \
     (__x < __y ? __x : __y); })
#  define ROUND(V, A) \
  ({ typeof (V) __v = (V); typeof (A) __a = (A); \
     __a * ((__v+__a - 1)/__a); })
#endif
 
#define BITS_PER_UNIT __CHAR_BIT__
typedef struct{ char a; } __small_struct;
#define STRUCTURE_SIZE_BOUNDARY (BITS_PER_UNIT * sizeof (__small_struct))
 
/*
  return the size of an object specified by type
*/
 
int
objc_sizeof_type (const char *type)
{
  /* Skip the variable name if any */
  if (*type == '"')
    {
      for (type++; *type++ != '"';)
        /* do nothing */;
    }
 
  switch (*type) {
  case _C_ID:
    return sizeof (id);
    break;
 
  case _C_CLASS:
    return sizeof (Class);
    break;
 
  case _C_SEL:
    return sizeof (SEL);
    break;
 
  case _C_CHR:
    return sizeof (char);
    break;
 
  case _C_UCHR:
    return sizeof (unsigned char);
    break;
 
  case _C_SHT:
    return sizeof (short);
    break;
 
  case _C_USHT:
    return sizeof (unsigned short);
    break;
 
  case _C_INT:
    return sizeof (int);
    break;
 
  case _C_UINT:
    return sizeof (unsigned int);
    break;
 
  case _C_LNG:
    return sizeof (long);
    break;
 
  case _C_ULNG:
    return sizeof (unsigned long);
    break;
 
  case _C_LNG_LNG:
    return sizeof (long long);
    break;
 
  case _C_ULNG_LNG:
    return sizeof (unsigned long long);
    break;
 
  case _C_FLT:
    return sizeof (float);
    break;
 
  case _C_DBL:
    return sizeof (double);
    break;
 
  case _C_PTR:
  case _C_ATOM:
  case _C_CHARPTR:
    return sizeof (char *);
    break;
 
  case _C_ARY_B:
    {
      int len = atoi (type + 1);
      while (isdigit ((unsigned char)*++type))
        ;
      return len * objc_aligned_size (type);
    }
    break;
 
  case _C_BFLD:
    {
      /* The NeXT encoding of bitfields is _still_: b 'size' */
      int size = atoi (type + 1);
      /* Return an upper bound on byte size */
      return (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
    }
 
  case _C_STRUCT_B:
    {
      struct objc_struct_layout layout;
      unsigned int size;
 
      objc_layout_structure (type, &layout);
      while (objc_layout_structure_next_member (&layout))
        /* do nothing */ ;
      objc_layout_finish_structure (&layout, &size, NULL);
 
      return size;
    }
 
  case _C_UNION_B:
    {
      int max_size = 0;
      while (*type != _C_UNION_E && *type++ != '=')
        /* do nothing */;
      while (*type != _C_UNION_E)
        {
          /* Skip the variable name if any */
          if (*type == '"')
            {
              for (type++; *type++ != '"';)
                /* do nothing */;
            }
          max_size = MAX (max_size, objc_sizeof_type (type));
          type = objc_skip_typespec (type);
        }
      return max_size;
    }
  }
  return 0; /* error */
}
 
 
/*
  Return the alignment of an object specified by type
*/
 
int
objc_alignof_type (const char *type)
{
  /* Skip the variable name if any */
  if (*type == '"')
    {
      for (type++; *type++ != '"';)
        /* do nothing */;
    }
  switch (*type) {
  case _C_ID:
    return __alignof__ (id);
    break;
 
  case _C_CLASS:
    return __alignof__ (Class);
    break;
 
  case _C_SEL:
    return __alignof__ (SEL);
    break;
 
  case _C_CHR:
    return __alignof__ (char);
    break;
 
  case _C_UCHR:
    return __alignof__ (unsigned char);
    break;
 
  case _C_SHT:
    return __alignof__ (short);
    break;
 
  case _C_USHT:
    return __alignof__ (unsigned short);
    break;
 
  case _C_INT:
  case _C_BFLD: /* This is for the NeXT only */
    return __alignof__ (int);
    break;
 
  case _C_UINT:
    return __alignof__ (unsigned int);
    break;
 
  case _C_LNG:
    return __alignof__ (long);
    break;
 
  case _C_ULNG:
    return __alignof__ (unsigned long);
    break;
 
  case _C_LNG_LNG:
    return __alignof__ (long long);
    break;
 
  case _C_ULNG_LNG:
    return __alignof__ (unsigned long long);
    break;
 
  case _C_FLT:
    return __alignof__ (float);
    break;
 
  case _C_DBL:
    return __alignof__ (double);
    break;
 
  case _C_PTR:
  case _C_ATOM:
  case _C_CHARPTR:
    return __alignof__ (char *);
    break;
 
  case _C_ARY_B:
    while (isdigit ((unsigned char)*++type))
      /* do nothing */;
    return objc_alignof_type (type);
 
  case _C_STRUCT_B:
    {
      struct objc_struct_layout layout;
      unsigned int align;
 
      objc_layout_structure (type, &layout);
      while (objc_layout_structure_next_member (&layout))
        /* do nothing */;
      objc_layout_finish_structure (&layout, NULL, &align);
 
      return align;
    }
 
  case _C_UNION_B:
    {
      int maxalign = 0;
      while (*type != _C_UNION_E && *type++ != '=')
        /* do nothing */;
      while (*type != _C_UNION_E)
        {
          /* Skip the variable name if any */
          if (*type == '"')
            {
              for (type++; *type++ != '"';)
                /* do nothing */;
            }
          maxalign = MAX (maxalign, objc_alignof_type (type));
          type = objc_skip_typespec (type);
        }
      return maxalign;
    }
  }
  return 0; /* error */
}
 
/*
  The aligned size if the size rounded up to the nearest alignment.
*/
 
int
objc_aligned_size (const char *type)
{
  int size, align;
 
  /* Skip the variable name */
  if (*type == '"')
    {
      for (type++; *type++ != '"';)
        /* do nothing */;
    }
 
  size = objc_sizeof_type (type);
  align = objc_alignof_type (type);
 
  return ROUND (size, align);
}
 
/*
  The size rounded up to the nearest integral of the wordsize, taken
  to be the size of a void *.
*/
 
int
objc_promoted_size (const char *type)
{
  int size, wordsize;
 
  /* Skip the variable name */
  if (*type == '"')
    {
      for (type++; *type++ != '"';)
        /* do nothing */;
    }
 
  size = objc_sizeof_type (type);
  wordsize = sizeof (void *);
 
  return ROUND (size, wordsize);
}
 
/*
  Skip type qualifiers.  These may eventually precede typespecs
  occurring in method prototype encodings.
*/
 
const char *
objc_skip_type_qualifiers (const char *type)
{
  while (*type == _C_CONST
         || *type == _C_IN
         || *type == _C_INOUT
         || *type == _C_OUT
         || *type == _C_BYCOPY
         || *type == _C_BYREF
         || *type == _C_ONEWAY
         || *type == _C_GCINVISIBLE)
    {
      type += 1;
    }
  return type;
}
 
/*
  Skip one typespec element.  If the typespec is prepended by type
  qualifiers, these are skipped as well.
*/
 
const char *
objc_skip_typespec (const char *type)
{
  /* Skip the variable name if any */
  if (*type == '"')
    {
      for (type++; *type++ != '"';)
        /* do nothing */;
    }
 
  type = objc_skip_type_qualifiers (type);
 
  switch (*type) {
 
  case _C_ID:
    /* An id may be annotated by the actual type if it is known
       with the @"ClassName" syntax */
 
    if (*++type != '"')
      return type;
    else
      {
        while (*++type != '"')
          /* do nothing */;
        return type + 1;
      }
 
    /* The following are one character type codes */
  case _C_CLASS:
  case _C_SEL:
  case _C_CHR:
  case _C_UCHR:
  case _C_CHARPTR:
  case _C_ATOM:
  case _C_SHT:
  case _C_USHT:
  case _C_INT:
  case _C_UINT:
  case _C_LNG:
  case _C_ULNG:
  case _C_LNG_LNG:
  case _C_ULNG_LNG:
  case _C_FLT:
  case _C_DBL:
  case _C_VOID:
  case _C_UNDEF:
    return ++type;
    break;
 
  case _C_ARY_B:
    /* skip digits, typespec and closing ']' */
 
    while (isdigit ((unsigned char)*++type))
      ;
    type = objc_skip_typespec (type);
    if (*type == _C_ARY_E)
      return ++type;
    else
      break; /* error */
 
  case _C_BFLD:
      /* The NeXT encoding for bitfields is _still_: b 'size' */
    while (isdigit ((unsigned char)*++type))
      ; /* skip type and size */
    return type;
 
  case _C_STRUCT_B:
    /* skip name, and elements until closing '}'  */
 
    while (*type != _C_STRUCT_E && *type++ != '=')
      ;
    while (*type != _C_STRUCT_E)
      {
        type = objc_skip_typespec (type);
      }
    return ++type;
 
  case _C_UNION_B:
    /* skip name, and elements until closing ')'  */
 
    while (*type != _C_UNION_E && *type++ != '=')
      ;
    while (*type != _C_UNION_E)
      {
        type = objc_skip_typespec (type);
      }
    return ++type;
 
  case _C_PTR:
    /* Just skip the following typespec */
 
    return objc_skip_typespec (++type);
  }
  return 0; /* error */
}
 
/*
  Skip an offset as part of a method encoding.  This is prepended by a
  '+' if the argument is passed in registers.
*/
const char *
objc_skip_offset (const char *type)
{
  if (*type == '+')
    type++;
  while (isdigit ((unsigned char) *++type))
    ;
  return type;
}
 
/*
  Skip an argument specification of a method encoding.
*/
const char *
objc_skip_argspec (const char *type)
{
  type = objc_skip_typespec (type);
  type = objc_skip_offset (type);
  return type;
}
 
unsigned
objc_get_type_qualifiers (const char *type)
{
  unsigned res = 0;
  BOOL flag = YES;
 
  while (flag)
    switch (*type++)
      {
      case _C_CONST:    res |= _F_CONST; break;
      case _C_IN:       res |= _F_IN; break;
      case _C_INOUT:    res |= _F_INOUT; break;
      case _C_OUT:      res |= _F_OUT; break;
      case _C_BYCOPY:   res |= _F_BYCOPY; break;
      case _C_BYREF:  res |= _F_BYREF; break;
      case _C_ONEWAY:   res |= _F_ONEWAY; break;
      case _C_GCINVISIBLE: res |= _F_GCINVISIBLE; break;
      default: flag = NO;
    }
 
  return res;
}
 
 
/* The following three functions can be used to determine how a
   structure is laid out by the compiler. For example:
 
  struct objc_struct_layout layout;
  int i;
 
  objc_layout_structure (type, &layout);
  while (objc_layout_structure_next_member (&layout))
    {
      int position, align;
      const char *type;
 
      objc_layout_structure_get_info (&layout, &position, &align, &type);
      printf ("element %d has offset %d, alignment %d\n",
              i++, position, align);
    }
 
  These functions are used by objc_sizeof_type and objc_alignof_type
  functions to compute the size and alignment of structures. The
  previous method of computing the size and alignment of a structure
  was not working on some architectures, particulary on AIX, and in
  the presence of bitfields inside the structure. */
void
objc_layout_structure (const char *type,
                           struct objc_struct_layout *layout)
{
  const char *ntype;
 
  layout->original_type = ++type;
 
  /* Skip "<name>=" if any. Avoid embedded structures and unions. */
  ntype = type;
  while (*ntype != _C_STRUCT_E && *ntype != _C_STRUCT_B && *ntype != _C_UNION_B
         && *ntype++ != '=')
    /* do nothing */;
 
  /* If there's a "<name>=", ntype - 1 points to '='; skip the name */
  if (*(ntype - 1) == '=')
    type = ntype;
 
  layout->type = type;
  layout->prev_type = NULL;
  layout->record_size = 0;
  layout->record_align = MAX (BITS_PER_UNIT, STRUCTURE_SIZE_BOUNDARY);
}
 
BOOL
objc_layout_structure_next_member (struct objc_struct_layout *layout)
{
  register int desired_align = 0;
 
  /* The current type without the type qualifiers */
  const char *type;
 
  /* Add the size of the previous field to the size of the record.  */
  if (layout->prev_type)
    {
      type = objc_skip_type_qualifiers (layout->prev_type);
 
      if (*type != _C_BFLD)
        layout->record_size += objc_sizeof_type (type) * BITS_PER_UNIT;
      else
        layout->record_size += atoi (++type);
    }
 
  if (*layout->type == _C_STRUCT_E)
    return NO;
 
  /* Skip the variable name if any */
  if (*layout->type == '"')
    {
      for (layout->type++; *layout->type++ != '"';)
        /* do nothing */;
    }
 
  type = objc_skip_type_qualifiers (layout->type);
 
  desired_align = objc_alignof_type (type) * BITS_PER_UNIT;
 
  /* Record must have at least as much alignment as any field.
     Otherwise, the alignment of the field within the record
     is meaningless.  */
  layout->record_align = MAX (layout->record_align, desired_align);
 
  if (*type == _C_BFLD)
    {
      int bfld_size = atoi (++type);
      int int_align = __alignof__ (int) * BITS_PER_UNIT;
      /* If this bitfield would traverse a word alignment boundary, push it out
         to that boundary instead.  */
      if (layout->record_size % int_align
          && (layout->record_size / int_align
              < (layout->record_size + bfld_size - 1) / int_align))
        layout->record_size = ROUND (layout->record_size, int_align);
    }
  else if (layout->record_size % desired_align != 0)
    {
      /* We need to skip space before this field.
         Bump the cumulative size to multiple of field alignment.  */
      layout->record_size = ROUND (layout->record_size, desired_align);
    }
 
  /* Jump to the next field in record. */
 
  layout->prev_type = layout->type;
  layout->type = objc_skip_typespec (layout->type);      /* skip component */
 
  return YES;
}
 
 
void objc_layout_finish_structure (struct objc_struct_layout *layout,
                                   unsigned int *size,
                                   unsigned int *align)
{
  if (layout->type && *layout->type == _C_STRUCT_E)
    {
      /* Round the size up to be a multiple of the required alignment */
      layout->record_size = ROUND (layout->record_size, layout->record_align);
      layout->type = NULL;
    }
  if (size)
    *size = layout->record_size / BITS_PER_UNIT;
  if (align)
    *align = layout->record_align / BITS_PER_UNIT;
}
 
 
void objc_layout_structure_get_info (struct objc_struct_layout *layout,
                                     unsigned int *offset,
                                     unsigned int *align,
                                     const char **type)
{
  if (offset)
    *offset = layout->record_size / BITS_PER_UNIT;
  if (align)
    *align = layout->record_align / BITS_PER_UNIT;
  if (type)
    *type = layout->prev_type;
}
 
#endif /* __NEXT_RUNTIME__ */
#endif /* _OBJC_TEST_SUITE_NEXT_ENCODE_ASSIST_IMPL_H_ */

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [objc-obj-c++-shared/] [objc-test-suite-next-encode-assist-impl.h] - Blame information for rev 705

Line No.	Rev	Author	Line
1	705	jeremybenn	`#ifndef _OBJC_TEST_SUITE_NEXT_ENCODE_ASSIST_IMPL_H_`
2			`#define _OBJC_TEST_SUITE_NEXT_ENCODE_ASSIST_IMPL_H_`
3
4			`#ifdef __NEXT_RUNTIME__`
5
6			`/* Determine which API to use. */`
7			`#include "next-abi.h"`
8			`#ifdef NEXT_OBJC_USE_NEW_INTERFACE`
9			`#include <objc/runtime.h>`
10			`#else`
11			`#include <objc/objc-runtime.h>`
12			`#endif`
13
14			`/* ---- */`
15
16			`#undef MAX`
17			`#undef MIN`
18			`#undef ROUND`
19
20			`#ifdef __cplusplus`
21			`# define MAX(X, Y) ((X > Y) ? X : Y)`
22			`# define MIN(X, Y) ((X < Y) ? X : Y)`
23			`# define ROUND(V, A) (A * ((V + A - 1) / A))`
24			`#else`
25			`# define MAX(X, Y) \`
26			`({ typeof (X) __x = (X), __y = (Y); \`
27			`(__x > __y ? __x : __y); })`
28			`# define MIN(X, Y) \`
29			`({ typeof (X) __x = (X), __y = (Y); \`
30			`(__x < __y ? __x : __y); })`
31			`# define ROUND(V, A) \`
32			`({ typeof (V) __v = (V); typeof (A) __a = (A); \`
33			`__a * ((__v+__a - 1)/__a); })`
34			`#endif`
35
36			`#define BITS_PER_UNIT __CHAR_BIT__`
37			`typedef struct{ char a; } __small_struct;`
38			`#define STRUCTURE_SIZE_BOUNDARY (BITS_PER_UNIT * sizeof (__small_struct))`
39
40			`/*`
41			`return the size of an object specified by type`
42			`*/`
43
44			`int`
45			`objc_sizeof_type (const char *type)`
46			`{`
47			`/* Skip the variable name if any */`
48			`if (*type == '"')`
49			`{`
50			`for (type++; *type++ != '"';)`
51			`/* do nothing */;`
52			`}`
53
54			`switch (*type) {`
55			`case _C_ID:`
56			`return sizeof (id);`
57			`break;`
58
59			`case _C_CLASS:`
60			`return sizeof (Class);`
61			`break;`
62
63			`case _C_SEL:`
64			`return sizeof (SEL);`
65			`break;`
66
67			`case _C_CHR:`
68			`return sizeof (char);`
69			`break;`
70
71			`case _C_UCHR:`
72			`return sizeof (unsigned char);`
73			`break;`
74
75			`case _C_SHT:`
76			`return sizeof (short);`
77			`break;`
78
79			`case _C_USHT:`
80			`return sizeof (unsigned short);`
81			`break;`
82
83			`case _C_INT:`
84			`return sizeof (int);`
85			`break;`
86
87			`case _C_UINT:`
88			`return sizeof (unsigned int);`
89			`break;`
90
91			`case _C_LNG:`
92			`return sizeof (long);`
93			`break;`
94
95			`case _C_ULNG:`
96			`return sizeof (unsigned long);`
97			`break;`
98
99			`case _C_LNG_LNG:`
100			`return sizeof (long long);`
101			`break;`
102
103			`case _C_ULNG_LNG:`
104			`return sizeof (unsigned long long);`
105			`break;`
106
107			`case _C_FLT:`
108			`return sizeof (float);`
109			`break;`
110
111			`case _C_DBL:`
112			`return sizeof (double);`
113			`break;`
114
115			`case _C_PTR:`
116			`case _C_ATOM:`
117			`case _C_CHARPTR:`
118			`return sizeof (char *);`
119			`break;`
120
121			`case _C_ARY_B:`
122			`{`
123			`int len = atoi (type + 1);`
124			`while (isdigit ((unsigned char)*++type))`
125			`;`
126			`return len * objc_aligned_size (type);`
127			`}`
128			`break;`
129
130			`case _C_BFLD:`
131			`{`
132			`/* The NeXT encoding of bitfields is _still_: b 'size' */`
133			`int size = atoi (type + 1);`
134			`/* Return an upper bound on byte size */`
135			`return (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;`
136			`}`
137
138			`case _C_STRUCT_B:`
139			`{`
140			`struct objc_struct_layout layout;`
141			`unsigned int size;`
142
143			`objc_layout_structure (type, &layout);`
144			`while (objc_layout_structure_next_member (&layout))`
145			`/* do nothing */ ;`
146			`objc_layout_finish_structure (&layout, &size, NULL);`
147
148			`return size;`
149			`}`
150
151			`case _C_UNION_B:`
152			`{`
153			`int max_size = 0;`
154			`while (type != _C_UNION_E && type++ != '=')`
155			`/* do nothing */;`
156			`while (*type != _C_UNION_E)`
157			`{`
158			`/* Skip the variable name if any */`
159			`if (*type == '"')`
160			`{`
161			`for (type++; *type++ != '"';)`
162			`/* do nothing */;`
163			`}`
164			`max_size = MAX (max_size, objc_sizeof_type (type));`
165			`type = objc_skip_typespec (type);`
166			`}`
167			`return max_size;`
168			`}`
169			`}`
170			`return 0; /* error */`
171			`}`
172
173
174			`/*`
175			`Return the alignment of an object specified by type`
176			`*/`
177
178			`int`
179			`objc_alignof_type (const char *type)`
180			`{`
181			`/* Skip the variable name if any */`
182			`if (*type == '"')`
183			`{`
184			`for (type++; *type++ != '"';)`
185			`/* do nothing */;`
186			`}`
187			`switch (*type) {`
188			`case _C_ID:`
189			`return __alignof__ (id);`
190			`break;`
191
192			`case _C_CLASS:`
193			`return __alignof__ (Class);`
194			`break;`
195
196			`case _C_SEL:`
197			`return __alignof__ (SEL);`
198			`break;`
199
200			`case _C_CHR:`
201			`return __alignof__ (char);`
202			`break;`
203
204			`case _C_UCHR:`
205			`return __alignof__ (unsigned char);`
206			`break;`
207
208			`case _C_SHT:`
209			`return __alignof__ (short);`
210			`break;`
211
212			`case _C_USHT:`
213			`return __alignof__ (unsigned short);`
214			`break;`
215
216			`case _C_INT:`
217			`case _C_BFLD: /* This is for the NeXT only */`
218			`return __alignof__ (int);`
219			`break;`
220
221			`case _C_UINT:`
222			`return __alignof__ (unsigned int);`
223			`break;`
224
225			`case _C_LNG:`
226			`return __alignof__ (long);`
227			`break;`
228
229			`case _C_ULNG:`
230			`return __alignof__ (unsigned long);`
231			`break;`
232
233			`case _C_LNG_LNG:`
234			`return __alignof__ (long long);`
235			`break;`
236
237			`case _C_ULNG_LNG:`
238			`return __alignof__ (unsigned long long);`
239			`break;`
240
241			`case _C_FLT:`
242			`return __alignof__ (float);`
243			`break;`
244
245			`case _C_DBL:`
246			`return __alignof__ (double);`
247			`break;`
248
249			`case _C_PTR:`
250			`case _C_ATOM:`
251			`case _C_CHARPTR:`
252			`return __alignof__ (char *);`
253			`break;`
254
255			`case _C_ARY_B:`
256			`while (isdigit ((unsigned char)*++type))`
257			`/* do nothing */;`
258			`return objc_alignof_type (type);`
259
260			`case _C_STRUCT_B:`
261			`{`
262			`struct objc_struct_layout layout;`
263			`unsigned int align;`
264
265			`objc_layout_structure (type, &layout);`
266			`while (objc_layout_structure_next_member (&layout))`
267			`/* do nothing */;`
268			`objc_layout_finish_structure (&layout, NULL, &align);`
269
270			`return align;`
271			`}`
272
273			`case _C_UNION_B:`
274			`{`
275			`int maxalign = 0;`
276			`while (type != _C_UNION_E && type++ != '=')`
277			`/* do nothing */;`
278			`while (*type != _C_UNION_E)`
279			`{`
280			`/* Skip the variable name if any */`
281			`if (*type == '"')`
282			`{`
283			`for (type++; *type++ != '"';)`
284			`/* do nothing */;`
285			`}`
286			`maxalign = MAX (maxalign, objc_alignof_type (type));`
287			`type = objc_skip_typespec (type);`
288			`}`
289			`return maxalign;`
290			`}`
291			`}`
292			`return 0; /* error */`
293			`}`
294
295			`/*`
296			`The aligned size if the size rounded up to the nearest alignment.`
297			`*/`
298
299			`int`
300			`objc_aligned_size (const char *type)`
301			`{`
302			`int size, align;`
303
304			`/* Skip the variable name */`
305			`if (*type == '"')`
306			`{`
307			`for (type++; *type++ != '"';)`
308			`/* do nothing */;`
309			`}`
310
311			`size = objc_sizeof_type (type);`
312			`align = objc_alignof_type (type);`
313
314			`return ROUND (size, align);`
315			`}`
316
317			`/*`
318			`The size rounded up to the nearest integral of the wordsize, taken`
319			`to be the size of a void *.`
320			`*/`
321
322			`int`
323			`objc_promoted_size (const char *type)`
324			`{`
325			`int size, wordsize;`
326
327			`/* Skip the variable name */`
328			`if (*type == '"')`
329			`{`
330			`for (type++; *type++ != '"';)`
331			`/* do nothing */;`
332			`}`
333
334			`size = objc_sizeof_type (type);`
335			`wordsize = sizeof (void *);`
336
337			`return ROUND (size, wordsize);`
338			`}`
339
340			`/*`
341			`Skip type qualifiers. These may eventually precede typespecs`
342			`occurring in method prototype encodings.`
343			`*/`
344
345			`const char *`
346			`objc_skip_type_qualifiers (const char *type)`
347			`{`
348			`while (*type == _C_CONST`
349			`\|\| *type == _C_IN`
350			`\|\| *type == _C_INOUT`
351			`\|\| *type == _C_OUT`
352			`\|\| *type == _C_BYCOPY`
353			`\|\| *type == _C_BYREF`
354			`\|\| *type == _C_ONEWAY`
355			`\|\| *type == _C_GCINVISIBLE)`
356			`{`
357			`type += 1;`
358			`}`
359			`return type;`
360			`}`
361
362			`/*`
363			`Skip one typespec element. If the typespec is prepended by type`
364			`qualifiers, these are skipped as well.`
365			`*/`
366
367			`const char *`
368			`objc_skip_typespec (const char *type)`
369			`{`
370			`/* Skip the variable name if any */`
371			`if (*type == '"')`
372			`{`
373			`for (type++; *type++ != '"';)`
374			`/* do nothing */;`
375			`}`
376
377			`type = objc_skip_type_qualifiers (type);`
378
379			`switch (*type) {`
380
381			`case _C_ID:`
382			`/* An id may be annotated by the actual type if it is known`
383			`with the @"ClassName" syntax */`
384
385			`if (*++type != '"')`
386			`return type;`
387			`else`
388			`{`
389			`while (*++type != '"')`
390			`/* do nothing */;`
391			`return type + 1;`
392			`}`
393
394			`/* The following are one character type codes */`
395			`case _C_CLASS:`
396			`case _C_SEL:`
397			`case _C_CHR:`
398			`case _C_UCHR:`
399			`case _C_CHARPTR:`
400			`case _C_ATOM:`
401			`case _C_SHT:`
402			`case _C_USHT:`
403			`case _C_INT:`
404			`case _C_UINT:`
405			`case _C_LNG:`
406			`case _C_ULNG:`
407			`case _C_LNG_LNG:`
408			`case _C_ULNG_LNG:`
409			`case _C_FLT:`
410			`case _C_DBL:`
411			`case _C_VOID:`
412			`case _C_UNDEF:`
413			`return ++type;`
414			`break;`
415
416			`case _C_ARY_B:`
417			`/* skip digits, typespec and closing ']' */`
418
419			`while (isdigit ((unsigned char)*++type))`
420			`;`
421			`type = objc_skip_typespec (type);`
422			`if (*type == _C_ARY_E)`
423			`return ++type;`
424			`else`
425			`break; /* error */`
426
427			`case _C_BFLD:`
428			`/* The NeXT encoding for bitfields is _still_: b 'size' */`
429			`while (isdigit ((unsigned char)*++type))`
430			`; /* skip type and size */`
431			`return type;`
432
433			`case _C_STRUCT_B:`
434			`/* skip name, and elements until closing '}' */`
435
436			`while (type != _C_STRUCT_E && type++ != '=')`
437			`;`
438			`while (*type != _C_STRUCT_E)`
439			`{`
440			`type = objc_skip_typespec (type);`
441			`}`
442			`return ++type;`
443
444			`case _C_UNION_B:`
445			`/* skip name, and elements until closing ')' */`
446
447			`while (type != _C_UNION_E && type++ != '=')`
448			`;`
449			`while (*type != _C_UNION_E)`
450			`{`
451			`type = objc_skip_typespec (type);`
452			`}`
453			`return ++type;`
454
455			`case _C_PTR:`
456			`/* Just skip the following typespec */`
457
458			`return objc_skip_typespec (++type);`
459			`}`
460			`return 0; /* error */`
461			`}`
462
463			`/*`
464			`Skip an offset as part of a method encoding. This is prepended by a`
465			`'+' if the argument is passed in registers.`
466			`*/`
467			`const char *`
468			`objc_skip_offset (const char *type)`
469			`{`
470			`if (*type == '+')`
471			`type++;`
472			`while (isdigit ((unsigned char) *++type))`
473			`;`
474			`return type;`
475			`}`
476
477			`/*`
478			`Skip an argument specification of a method encoding.`
479			`*/`
480			`const char *`
481			`objc_skip_argspec (const char *type)`
482			`{`
483			`type = objc_skip_typespec (type);`
484			`type = objc_skip_offset (type);`
485			`return type;`
486			`}`
487
488			`unsigned`
489			`objc_get_type_qualifiers (const char *type)`
490			`{`
491			`unsigned res = 0;`
492			`BOOL flag = YES;`
493
494			`while (flag)`
495			`switch (*type++)`
496			`{`
497			`case _C_CONST: res \|= _F_CONST; break;`
498			`case _C_IN: res \|= _F_IN; break;`
499			`case _C_INOUT: res \|= _F_INOUT; break;`
500			`case _C_OUT: res \|= _F_OUT; break;`
501			`case _C_BYCOPY: res \|= _F_BYCOPY; break;`
502			`case _C_BYREF: res \|= _F_BYREF; break;`
503			`case _C_ONEWAY: res \|= _F_ONEWAY; break;`
504			`case _C_GCINVISIBLE: res \|= _F_GCINVISIBLE; break;`
505			`default: flag = NO;`
506			`}`
507
508			`return res;`
509			`}`
510
511
512			`/* The following three functions can be used to determine how a`
513			`structure is laid out by the compiler. For example:`
514
515			`struct objc_struct_layout layout;`
516			`int i;`
517
518			`objc_layout_structure (type, &layout);`
519			`while (objc_layout_structure_next_member (&layout))`
520			`{`
521			`int position, align;`
522			`const char *type;`
523
524			`objc_layout_structure_get_info (&layout, &position, &align, &type);`
525			`printf ("element %d has offset %d, alignment %d\n",`
526			`i++, position, align);`
527			`}`
528
529			`These functions are used by objc_sizeof_type and objc_alignof_type`
530			`functions to compute the size and alignment of structures. The`
531			`previous method of computing the size and alignment of a structure`
532			`was not working on some architectures, particulary on AIX, and in`
533			`the presence of bitfields inside the structure. */`
534			`void`
535			`objc_layout_structure (const char *type,`
536			`struct objc_struct_layout *layout)`
537			`{`
538			`const char *ntype;`
539
540			`layout->original_type = ++type;`
541
542			`/* Skip "<name>=" if any. Avoid embedded structures and unions. */`
543			`ntype = type;`
544			`while (ntype != _C_STRUCT_E && ntype != _C_STRUCT_B && *ntype != _C_UNION_B`
545			`&& *ntype++ != '=')`
546			`/* do nothing */;`
547
548			`/* If there's a "<name>=", ntype - 1 points to '='; skip the name */`
549			`if (*(ntype - 1) == '=')`
550			`type = ntype;`
551
552			`layout->type = type;`
553			`layout->prev_type = NULL;`
554			`layout->record_size = 0;`
555			`layout->record_align = MAX (BITS_PER_UNIT, STRUCTURE_SIZE_BOUNDARY);`
556			`}`
557
558			`BOOL`
559			`objc_layout_structure_next_member (struct objc_struct_layout *layout)`
560			`{`
561			`register int desired_align = 0;`
562
563			`/* The current type without the type qualifiers */`
564			`const char *type;`
565
566			`/* Add the size of the previous field to the size of the record. */`
567			`if (layout->prev_type)`
568			`{`
569			`type = objc_skip_type_qualifiers (layout->prev_type);`
570
571			`if (*type != _C_BFLD)`
572			`layout->record_size += objc_sizeof_type (type) * BITS_PER_UNIT;`
573			`else`
574			`layout->record_size += atoi (++type);`
575			`}`
576
577			`if (*layout->type == _C_STRUCT_E)`
578			`return NO;`
579
580			`/* Skip the variable name if any */`
581			`if (*layout->type == '"')`
582			`{`
583			`for (layout->type++; *layout->type++ != '"';)`
584			`/* do nothing */;`
585			`}`
586
587			`type = objc_skip_type_qualifiers (layout->type);`
588
589			`desired_align = objc_alignof_type (type) * BITS_PER_UNIT;`
590
591			`/* Record must have at least as much alignment as any field.`
592			`Otherwise, the alignment of the field within the record`
593			`is meaningless. */`
594			`layout->record_align = MAX (layout->record_align, desired_align);`
595
596			`if (*type == _C_BFLD)`
597			`{`
598			`int bfld_size = atoi (++type);`
599			`int int_align = __alignof__ (int) * BITS_PER_UNIT;`
600			`/* If this bitfield would traverse a word alignment boundary, push it out`
601			`to that boundary instead. */`
602			`if (layout->record_size % int_align`
603			`&& (layout->record_size / int_align`
604			`< (layout->record_size + bfld_size - 1) / int_align))`
605			`layout->record_size = ROUND (layout->record_size, int_align);`
606			`}`
607			`else if (layout->record_size % desired_align != 0)`
608			`{`
609			`/* We need to skip space before this field.`
610			`Bump the cumulative size to multiple of field alignment. */`
611			`layout->record_size = ROUND (layout->record_size, desired_align);`
612			`}`
613
614			`/* Jump to the next field in record. */`
615
616			`layout->prev_type = layout->type;`
617			`layout->type = objc_skip_typespec (layout->type); /* skip component */`
618
619			`return YES;`
620			`}`
621
622
623			`void objc_layout_finish_structure (struct objc_struct_layout *layout,`
624			`unsigned int *size,`
625			`unsigned int *align)`
626			`{`
627			`if (layout->type && *layout->type == _C_STRUCT_E)`
628			`{`
629			`/* Round the size up to be a multiple of the required alignment */`
630			`layout->record_size = ROUND (layout->record_size, layout->record_align);`
631			`layout->type = NULL;`
632			`}`
633			`if (size)`
634			`*size = layout->record_size / BITS_PER_UNIT;`
635			`if (align)`
636			`*align = layout->record_align / BITS_PER_UNIT;`
637			`}`
638
639
640			`void objc_layout_structure_get_info (struct objc_struct_layout *layout,`
641			`unsigned int *offset,`
642			`unsigned int *align,`
643			`const char **type)`
644			`{`
645			`if (offset)`
646			`*offset = layout->record_size / BITS_PER_UNIT;`
647			`if (align)`
648			`*align = layout->record_align / BITS_PER_UNIT;`
649			`if (type)`
650			`*type = layout->prev_type;`
651			`}`
652
653			`#endif /* __NEXT_RUNTIME__ */`
654			`#endif /* _OBJC_TEST_SUITE_NEXT_ENCODE_ASSIST_IMPL_H_ */`