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      {	objc_error (nil, OBJC_ERR_BAD_TYPE, "bad array type %s\n", type);	return 0;      }  case _C_BFLD:    /* The new encoding of bitfields is: b 'position' 'type' 'size' */    while (isdigit ((unsigned char)*++type))      ;	/* skip position */    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);  default:    {      objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);      return 0;    }  }}/*  Skip an offset as part of a method encoding.  This is prepended by a  '+' if the argument is passed in registers.*/inline 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;}/*  Return the number of arguments that the method MTH expects.  Note that all methods need two implicit arguments `self' and  `_cmd'.*/intmethod_get_number_of_arguments (struct objc_method *mth){  int i = 0;  const char *type = mth->method_types;  while (*type)    {      type = objc_skip_argspec (type);      i += 1;    }  return i - 1;}/*  Return the size of the argument block needed on the stack to invoke  the method MTH.  This may be zero, if all arguments are passed in  registers.*/intmethod_get_sizeof_arguments (struct objc_method *mth){  const char *type = objc_skip_typespec (mth->method_types);  return atoi (type);}/*  Return a pointer to the next argument of ARGFRAME.  type points to  the last argument.  Typical use of this look like:  {    char *datum, *type;    for (datum = method_get_first_argument (method, argframe, &type);         datum; datum = method_get_next_argument (argframe, &type))      {        unsigned flags = objc_get_type_qualifiers (type);        type = objc_skip_type_qualifiers (type);	if (*type != _C_PTR)          [portal encodeData: datum ofType: type];	else	  {	    if ((flags & _F_IN) == _F_IN)              [portal encodeData: *(char **) datum ofType: ++type];	  }      }  }*/char *method_get_next_argument (arglist_t argframe, const char **type){  const char *t = objc_skip_argspec (*type);  if (*t == '\0')    return 0;  *type = t;  t = objc_skip_typespec (t);  if (*t == '+')    return argframe->arg_regs + atoi (++t);  else    return argframe->arg_ptr + atoi (t);}/*  Return a pointer to the value of the first argument of the method  described in M with the given argumentframe ARGFRAME.  The type  is returned in TYPE.  type must be passed to successive calls of  method_get_next_argument.*/char *method_get_first_argument (struct objc_method *m,			   arglist_t argframe,			   const char **type){  *type = m->method_types;  return method_get_next_argument (argframe, type);}/*   Return a pointer to the ARGth argument of the method   M from the frame ARGFRAME.  The type of the argument   is returned in the value-result argument TYPE*/char *method_get_nth_argument (struct objc_method *m,			 arglist_t argframe, int arg,			 const char **type){  const char *t = objc_skip_argspec (m->method_types);  if (arg > method_get_number_of_arguments (m))    return 0;  while (arg--)    t = objc_skip_argspec (t);  *type = t;  t = objc_skip_typespec (t);  if (*t == '+')    return argframe->arg_regs + atoi (++t);  else    return argframe->arg_ptr + atoi (t);}unsignedobjc_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. */voidobjc_layout_structure (const char *type,                           struct objc_struct_layout *layout){  const char *ntype;  if (*type++ != _C_STRUCT_B)    {      objc_error (nil, OBJC_ERR_BAD_TYPE,                 "record type expected in objc_layout_structure, got %s\n",                 type);    }  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 the name */  if (*(ntype - 1) == '=')    type = ntype;  layout->type = type;  layout->prev_type = NULL;  layout->record_size = 0;  layout->record_align = BITS_PER_UNIT;  layout->record_align = MAX (layout->record_align, STRUCTURE_SIZE_BOUNDARY);}BOOLobjc_layout_structure_next_member (struct objc_struct_layout *layout){  register int desired_align = 0;  /* The following are used only if the field is a bitfield */  register const char *bfld_type = 0;  register int bfld_type_size, bfld_type_align = 0, bfld_field_size = 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 {        /* Get the bitfield's type */        for (bfld_type = type + 1;             isdigit ((unsigned char)*bfld_type);             bfld_type++)          /* do nothing */;        bfld_type_size = objc_sizeof_type (bfld_type) * BITS_PER_UNIT;        bfld_type_align = objc_alignof_type (bfld_type) * BITS_PER_UNIT;        bfld_field_size = atoi (objc_skip_typespec (bfld_type));        layout->record_size += bfld_field_size;      }    }  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);  if (*type != _C_BFLD)    desired_align = objc_alignof_type (type) * BITS_PER_UNIT;  else    {      desired_align = 1;      /* Skip the bitfield's offset */      for (bfld_type = type + 1;           isdigit ((unsigned char) *bfld_type);           bfld_type++)        /* do nothing */;      bfld_type_size = objc_sizeof_type (bfld_type) * BITS_PER_UNIT;      bfld_type_align = objc_alignof_type (bfld_type) * BITS_PER_UNIT;      bfld_field_size = atoi (objc_skip_typespec (bfld_type));    }#ifdef BIGGEST_FIELD_ALIGNMENT  desired_align = MIN (desired_align, BIGGEST_FIELD_ALIGNMENT);#endif#ifdef ADJUST_FIELD_ALIGN  desired_align = ADJUST_FIELD_ALIGN (type, desired_align);#endif  /* Record must have at least as much alignment as any field.     Otherwise, the alignment of the field within the record     is meaningless.  */#ifndef PCC_BITFIELD_TYPE_MATTERS  layout->record_align = MAX (layout->record_align, desired_align);#else	/* PCC_BITFIELD_TYPE_MATTERS */  if (*type == _C_BFLD)    {      /* For these machines, a zero-length field does not         affect the alignment of the structure as a whole.         It does, however, affect the alignment of the next field         within the structure.  */      if (bfld_field_size)        layout->record_align = MAX (layout->record_align, desired_align);      else        desired_align = objc_alignof_type (bfld_type) * BITS_PER_UNIT;      /* A named bit field of declared type `int'         forces the entire structure to have `int' alignment.         Q1: How is encoded this thing and how to check for it?         Q2: How to determine maximum_field_alignment at runtime? *//*	  if (DECL_NAME (field) != 0) */      {        int type_align = bfld_type_align;#if 0        if (maximum_field_alignment != 0)          type_align = MIN (type_align, maximum_field_alignment);        else if (DECL_PACKED (field))          type_align = MIN (type_align, BITS_PER_UNIT);#endif        layout->record_align = MAX (layout->record_align, type_align);      }    }  else    layout->record_align = MAX (layout->record_align, desired_align);#endif	/* PCC_BITFIELD_TYPE_MATTERS */  /* Does this field automatically have alignment it needs     by virtue of the fields that precede it and the record's     own alignment?  */  if (*type == _C_BFLD)    layout->record_size = atoi (type + 1);  else if (layout->record_size % desired_align != 0)    {      /* No, 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)    {      /* Work out the alignment of the record as one expression and store         in the record type.  Round it up to a multiple of the record's         alignment. */#if defined (ROUND_TYPE_ALIGN) && ! defined (__sparc__)      layout->record_align = ROUND_TYPE_ALIGN (layout->original_type,                                               1,                                               layout->record_align);#else      layout->record_align = MAX (1, layout->record_align);#endif#ifdef ROUND_TYPE_SIZE      layout->record_size = ROUND_TYPE_SIZE (layout->original_type,                                             layout->record_size,                                             layout->record_align);#else      /* Round the size up to be a multiple of the required alignment */      layout->record_size = ROUND (layout->record_size, layout->record_align);#endif      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;}