#undef MAX
#define MAX(X, Y) \
- ({ typeof(X) __x = (X), __y = (Y); \
+ ({ typeof (X) __x = (X), __y = (Y); \
(__x > __y ? __x : __y); })
#undef MIN
#define MIN(X, Y) \
- ({ typeof(X) __x = (X), __y = (Y); \
+ ({ typeof (X) __x = (X), __y = (Y); \
(__x < __y ? __x : __y); })
#undef ROUND
#define ROUND(V, A) \
- ({ typeof(V) __v=(V); typeof(A) __a=(A); \
- __a*((__v+__a-1)/__a); })
+ ({ typeof (V) __v = (V); typeof (A) __a = (A); \
+ __a * ((__v+__a - 1)/__a); })
/* Various hacks for objc_layout_record. These are used by the target
*/
int
-objc_sizeof_type (const char* type)
+objc_sizeof_type (const char *type)
{
/* Skip the variable name if any */
if (*type == '"')
/* do nothing */;
}
- switch(*type) {
+ switch (*type) {
case _C_ID:
- return sizeof(id);
+ return sizeof (id);
break;
case _C_CLASS:
- return sizeof(Class);
+ return sizeof (Class);
break;
case _C_SEL:
- return sizeof(SEL);
+ return sizeof (SEL);
break;
case _C_CHR:
- return sizeof(char);
+ return sizeof (char);
break;
case _C_UCHR:
- return sizeof(unsigned char);
+ return sizeof (unsigned char);
break;
case _C_SHT:
- return sizeof(short);
+ return sizeof (short);
break;
case _C_USHT:
- return sizeof(unsigned short);
+ return sizeof (unsigned short);
break;
case _C_INT:
- return sizeof(int);
+ return sizeof (int);
break;
case _C_UINT:
- return sizeof(unsigned int);
+ return sizeof (unsigned int);
break;
case _C_LNG:
- return sizeof(long);
+ return sizeof (long);
break;
case _C_ULNG:
- return sizeof(unsigned long);
+ return sizeof (unsigned long);
break;
case _C_LNG_LNG:
- return sizeof(long long);
+ return sizeof (long long);
break;
case _C_ULNG_LNG:
- return sizeof(unsigned long long);
+ return sizeof (unsigned long long);
break;
case _C_FLT:
- return sizeof(float);
+ return sizeof (float);
break;
case _C_DBL:
- return sizeof(double);
+ return sizeof (double);
break;
case _C_VOID:
- return sizeof(void);
+ return sizeof (void);
break;
+
case _C_PTR:
case _C_ATOM:
case _C_CHARPTR:
- return sizeof(char*);
+ return sizeof (char *);
break;
case _C_ARY_B:
{
- int len = atoi(type+1);
- while (isdigit((unsigned char)*++type));
- return len*objc_aligned_size (type);
+ int len = atoi (type + 1);
+ while (isdigit ((unsigned char)*++type))
+ ;
+ return len * objc_aligned_size (type);
}
break;
int startByte, endByte;
position = atoi (type + 1);
- while (isdigit ((unsigned char)*++type));
+ while (isdigit ((unsigned char)*++type))
+ ;
size = atoi (type + 1);
startByte = position / BITS_PER_UNIT;
case _C_UNION_B:
{
int max_size = 0;
- while (*type != _C_UNION_E && *type++ != '=') /* do nothing */;
+ while (*type != _C_UNION_E && *type++ != '=')
+ /* do nothing */;
while (*type != _C_UNION_E)
{
/* Skip the variable name if any */
default:
{
- objc_error(nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
+ objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
return 0;
}
}
*/
int
-objc_alignof_type(const char* type)
+objc_alignof_type (const char *type)
{
/* Skip the variable name if any */
if (*type == '"')
for (type++; *type++ != '"';)
/* do nothing */;
}
- switch(*type) {
+ switch (*type) {
case _C_ID:
- return __alignof__(id);
+ return __alignof__ (id);
break;
case _C_CLASS:
- return __alignof__(Class);
+ return __alignof__ (Class);
break;
case _C_SEL:
- return __alignof__(SEL);
+ return __alignof__ (SEL);
break;
case _C_CHR:
- return __alignof__(char);
+ return __alignof__ (char);
break;
case _C_UCHR:
- return __alignof__(unsigned char);
+ return __alignof__ (unsigned char);
break;
case _C_SHT:
- return __alignof__(short);
+ return __alignof__ (short);
break;
case _C_USHT:
- return __alignof__(unsigned short);
+ return __alignof__ (unsigned short);
break;
case _C_INT:
- return __alignof__(int);
+ return __alignof__ (int);
break;
case _C_UINT:
- return __alignof__(unsigned int);
+ return __alignof__ (unsigned int);
break;
case _C_LNG:
- return __alignof__(long);
+ return __alignof__ (long);
break;
case _C_ULNG:
- return __alignof__(unsigned long);
+ return __alignof__ (unsigned long);
break;
case _C_LNG_LNG:
- return __alignof__(long long);
+ return __alignof__ (long long);
break;
case _C_ULNG_LNG:
- return __alignof__(unsigned long long);
+ return __alignof__ (unsigned long long);
break;
case _C_FLT:
- return __alignof__(float);
+ return __alignof__ (float);
break;
case _C_DBL:
- return __alignof__(double);
+ return __alignof__ (double);
break;
case _C_PTR:
case _C_ATOM:
case _C_CHARPTR:
- return __alignof__(char*);
+ return __alignof__ (char *);
break;
case _C_ARY_B:
- while (isdigit((unsigned char)*++type)) /* do nothing */;
+ while (isdigit ((unsigned char)*++type))
+ /* do nothing */;
return objc_alignof_type (type);
case _C_STRUCT_B:
case _C_UNION_B:
{
int maxalign = 0;
- while (*type != _C_UNION_E && *type++ != '=') /* do nothing */;
+ while (*type != _C_UNION_E && *type++ != '=')
+ /* do nothing */;
while (*type != _C_UNION_E)
{
/* Skip the variable name if any */
default:
{
- objc_error(nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
+ objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
return 0;
}
}
*/
int
-objc_aligned_size (const char* type)
+objc_aligned_size (const char *type)
{
int size, align;
/*
The size rounded up to the nearest integral of the wordsize, taken
- to be the size of a void*.
+ to be the size of a void *.
*/
int
-objc_promoted_size (const char* type)
+objc_promoted_size (const char *type)
{
int size, wordsize;
}
size = objc_sizeof_type (type);
- wordsize = sizeof (void*);
+ wordsize = sizeof (void *);
return ROUND (size, wordsize);
}
occurring in method prototype encodings.
*/
-inline const char*
-objc_skip_type_qualifiers (const char* type)
+inline const char *
+objc_skip_type_qualifiers (const char *type)
{
while (*type == _C_CONST
|| *type == _C_IN
qualifiers, these are skipped as well.
*/
-const char*
-objc_skip_typespec (const char* type)
+const char *
+objc_skip_typespec (const char *type)
{
/* Skip the variable name if any */
if (*type == '"')
return type;
else
{
- while (*++type != '"') /* do nothing */;
+ while (*++type != '"')
+ /* do nothing */;
return type + 1;
}
case _C_ARY_B:
/* skip digits, typespec and closing ']' */
- while(isdigit((unsigned char)*++type));
- type = objc_skip_typespec(type);
+ 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);
+ 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 */
+ 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); }
+ 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); }
+ while (*type != _C_UNION_E && *type++ != '=')
+ ;
+ while (*type != _C_UNION_E)
+ {
+ type = objc_skip_typespec (type);
+ }
return ++type;
case _C_PTR:
default:
{
- objc_error(nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
+ 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)
+inline const char *
+objc_skip_offset (const char *type)
{
- if (*type == '+') type++;
- while(isdigit((unsigned 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)
+const char *
+objc_skip_argspec (const char *type)
{
type = objc_skip_typespec (type);
type = objc_skip_offset (type);
`_cmd'.
*/
int
-method_get_number_of_arguments (struct objc_method* mth)
+method_get_number_of_arguments (struct objc_method *mth)
{
int i = 0;
- const char* type = mth->method_types;
+ const char *type = mth->method_types;
while (*type)
{
type = objc_skip_argspec (type);
*/
int
-method_get_sizeof_arguments (struct objc_method* mth)
+method_get_sizeof_arguments (struct objc_method *mth)
{
- const char* type = objc_skip_typespec (mth->method_types);
+ const char *type = objc_skip_typespec (mth->method_types);
return atoi (type);
}
else
{
if ((flags & _F_IN) == _F_IN)
- [portal encodeData: *(char**)datum ofType: ++type];
+ [portal encodeData: *(char **) datum ofType: ++type];
}
}
}
*/
-char*
-method_get_next_argument (arglist_t argframe,
- const char **type)
+char *
+method_get_next_argument (arglist_t argframe, const char **type)
{
const char *t = objc_skip_argspec (*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,
+char *
+method_get_first_argument (struct objc_method *m,
arglist_t argframe,
- const char** type)
+ const char **type)
{
*type = m->method_types;
return method_get_next_argument (argframe, type);
is returned in the value-result argument TYPE
*/
-char*
-method_get_nth_argument (struct objc_method* m,
+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);
+ const char *t = objc_skip_argspec (m->method_types);
if (arg > method_get_number_of_arguments (m))
return 0;
}
unsigned
-objc_get_type_qualifiers (const char* type)
+objc_get_type_qualifiers (const char *type)
{
unsigned res = 0;
BOOL flag = YES;
if (*type++ != _C_STRUCT_B)
{
- objc_error(nil, OBJC_ERR_BAD_TYPE,
+ objc_error (nil, OBJC_ERR_BAD_TYPE,
"record type expected in objc_layout_structure, got %s\n",
type);
}
else {
/* Get the bitfield's type */
for (bfld_type = type + 1;
- isdigit((unsigned char)*bfld_type);
+ isdigit ((unsigned char)*bfld_type);
bfld_type++)
/* do nothing */;
type = objc_skip_type_qualifiers (layout->type);
if (*type != _C_BFLD)
- desired_align = objc_alignof_type(type) * BITS_PER_UNIT;
+ 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++)
+ 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;
is meaningless. */
#ifndef PCC_BITFIELD_TYPE_MATTERS
layout->record_align = MAX (layout->record_align, desired_align);
-#else
+#else /* PCC_BITFIELD_TYPE_MATTERS */
if (*type == _C_BFLD)
{
/* For these machines, a zero-length field does not
}
else
layout->record_align = MAX (layout->record_align, desired_align);
-#endif
+#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
in the record type. Round it up to a multiple of the record's
alignment. */
-#if defined(ROUND_TYPE_ALIGN) && !defined(__sparc__)
+#if defined (ROUND_TYPE_ALIGN) && ! defined (__sparc__)
layout->record_align = ROUND_TYPE_ALIGN (layout->original_type,
1,
layout->record_align);
projects / thirdparty / gcc.git / blobdiff