| #ifndef __CTYPES__ |
| #define __CTYPES__ |
| |
| typedef enum { red, green, blue } Color; |
| |
| enum Tribool { |
| True, False, Indeterminate |
| }; |
| |
| enum { |
| AnonConst1 = 0x700000000, |
| AnonConst2 |
| }; |
| |
| enum { |
| AnonConstSmall1 = 16, |
| AnonConstSmall2 |
| }; |
| |
| struct Point { |
| float x; |
| float y; |
| }; |
| |
| typedef struct { |
| struct { |
| int a; |
| float b; |
| struct { |
| double c; |
| }; |
| }; |
| } AnonStructs; |
| |
| typedef struct { |
| struct { |
| int a; |
| float b; |
| } x; |
| struct { |
| float a; |
| int b; |
| struct { |
| int c; |
| } z; |
| } y; |
| } UnnamedStructs; |
| |
| typedef void const *HWND; |
| |
| typedef struct { |
| unsigned a; |
| unsigned b[]; |
| } StructWithFlexibleArray; |
| |
| #include <stdarg.h> |
| extern void hasVaList(va_list args); |
| |
| //===--- |
| // Tag decls and typedefs. |
| //===--- |
| /*! |
| @keyword Foo1, Struct1 |
| */ |
| struct FooStruct1 { |
| /*! |
| @keyword x, Struct1 |
| @recommended y |
| */ |
| int x; |
| /*! |
| @keyword y, Struct1 |
| @recommendedover x |
| */ |
| double y; |
| }; |
| |
| /*! |
| @keyword Foo2 |
| */ |
| typedef struct FooStruct2 { |
| int x; |
| double y; |
| } FooStructTypedef1; |
| |
| typedef struct { |
| int x; |
| double y; |
| } FooStructTypedef2; |
| |
| /*! |
| @recommended Foo2, Foo1 |
| */ |
| typedef struct FooStruct3 { |
| int x; |
| double y; |
| } FooStruct3; |
| |
| /*! |
| @recommendedover Foo3, Foo2 |
| */ |
| struct FooStruct4 { |
| int x; |
| double y; |
| }; |
| typedef struct FooStruct4 FooStruct4; |
| |
| struct FooStruct5; |
| typedef struct FooStruct5 FooStruct5; |
| struct FooStruct5 { |
| int x; |
| double y; |
| }; |
| |
| typedef struct FooStruct6 FooStruct6; |
| /*! |
| @recommendedover ro1, ro2, ro3, ro4 |
| @recommended r1, r2, r3 |
| @keyword k1, k2, k3, k4 |
| */ |
| struct FooStruct6 { |
| int x; |
| double y; |
| }; |
| |
| struct StructWithForwardDeclaredStruct { |
| struct ForwardDeclaredStruct *ptr; |
| }; |
| |
| //===--- |
| // Typedefs. |
| //===--- |
| |
| typedef void MyVoid; |
| MyVoid returnsMyVoid(void); |
| |
| // Function and struct with same name. |
| int funcOrStruct(void); |
| struct funcOrStruct { int i; }; |
| |
| // Names from MacTypes.h that conflict with swift's library types. |
| // rdar://14175675 |
| #define STDLIB_TEST(TYPE, NAME) extern NAME NAME##_test |
| #define STDLIB_TYPEDEF(TYPE, NAME) \ |
| typedef TYPE NAME; \ |
| STDLIB_TEST(TYPE, NAME) |
| STDLIB_TYPEDEF(__UINT8_TYPE__, UInt8); |
| STDLIB_TYPEDEF(__UINT16_TYPE__, UInt16); |
| STDLIB_TYPEDEF(__UINT32_TYPE__, UInt32); |
| STDLIB_TYPEDEF(__UINT64_TYPE__, UInt64); |
| STDLIB_TYPEDEF(float, Float32); |
| STDLIB_TYPEDEF(double, Float64); |
| STDLIB_TYPEDEF(long double, Float80); |
| |
| // Other types from MacTypes.h. |
| STDLIB_TYPEDEF(__INT8_TYPE__, SInt8); |
| STDLIB_TYPEDEF(__INT16_TYPE__, SInt16); |
| STDLIB_TYPEDEF(__INT32_TYPE__, SInt32); |
| STDLIB_TYPEDEF(__INT64_TYPE__, SInt64); |
| |
| typedef SInt32 OSStatus; |
| |
| // Types from stdint.h. |
| #include <stdint.h> |
| STDLIB_TEST(__UINT8_TYPE__, uint8_t); |
| STDLIB_TEST(__UINT16_TYPE__, uint16_t); |
| STDLIB_TEST(__UINT32_TYPE__, uint32_t); |
| STDLIB_TEST(__UINT64_TYPE__, uint64_t); |
| STDLIB_TEST(__INT8_TYPE__, int8_t); |
| STDLIB_TEST(__INT16_TYPE__, int16_t); |
| STDLIB_TEST(__INT32_TYPE__, int32_t); |
| STDLIB_TEST(__INT64_TYPE__, int64_t); |
| STDLIB_TEST(__INTPTR_TYPE__, intptr_t); |
| STDLIB_TEST(__UINTPTR_TYPE__, uintptr_t); |
| |
| // Types from stddef.h. |
| STDLIB_TYPEDEF(__PTRDIFF_TYPE__, ptrdiff_t); |
| STDLIB_TYPEDEF(__SIZE_TYPE__, size_t); |
| STDLIB_TYPEDEF(__SIZE_TYPE__, rsize_t); |
| |
| // Types from sys/types.h (POSIX). |
| STDLIB_TYPEDEF(long, ssize_t); |
| STDLIB_TYPEDEF(__UINT8_TYPE__, u_int8_t); |
| STDLIB_TYPEDEF(__UINT16_TYPE__, u_int16_t); |
| STDLIB_TYPEDEF(__UINT32_TYPE__, u_int32_t); |
| STDLIB_TYPEDEF(__UINT64_TYPE__, u_int64_t); |
| |
| // Types from libkern/OSTypes.h. |
| STDLIB_TYPEDEF(signed int, SInt); |
| STDLIB_TYPEDEF(unsigned int, UInt); |
| |
| void noreturnFunction() __attribute__((noreturn)); |
| void couldReturnFunction() __attribute__((noreturn)); |
| |
| |
| //===--- |
| // Function pointers |
| //===--- |
| |
| typedef int (*fptr)(int); |
| fptr getFunctionPointer(void); |
| void useFunctionPointer(fptr); |
| |
| struct FunctionPointerWrapper { |
| fptr a; |
| fptr b; |
| }; |
| |
| typedef void (*fptr2)(int, long, void *); |
| fptr2 getFunctionPointer2(void); |
| void useFunctionPointer2(fptr2); |
| |
| //===--- |
| // Unions |
| //===--- |
| |
| union _GLKVector4 { |
| struct { float x, y, z, w; }; |
| struct { float r, g, b, a; }; |
| struct { float s, t, p, q; }; |
| float v[4]; |
| } __attribute__((aligned(16))); |
| typedef union _GLKVector4 GLKVector4; |
| |
| typedef union IntOrFloat { |
| int i; |
| float f; |
| } IntOrFloat; |
| |
| typedef struct NamedUnion { |
| int a; |
| int b; |
| IntOrFloat intfloat; |
| } NamedUnion; |
| |
| typedef struct AnonUnion { |
| union { |
| float a; |
| float b; |
| float c; |
| float d; |
| }; |
| int x; |
| } AnonUnion; |
| |
| struct UnnamedUnion { |
| union { |
| int i; |
| float f; |
| } u; |
| }; |
| |
| //===--- |
| // Bitfields |
| //===--- |
| |
| struct StructWithBitfields { |
| unsigned First; |
| unsigned Second : 17; |
| unsigned Third : 5; |
| unsigned : 11; |
| }; |
| |
| typedef struct ModRM { |
| unsigned rm: 3; |
| unsigned reg: 3; |
| unsigned mod: 2; |
| unsigned opcode; |
| } ModRM; |
| |
| //===--- |
| // Arrays |
| //===--- |
| void useArray(char x[4], char y[], char z[][8]); |
| void staticBoundsArray(const char x[static 4]); |
| |
| void useBigArray(char max_size[4096], char max_size_plus_one[4097]); |
| void useBigArray2d(char max_size[][4096], char max_size_plus_one[][4097]); |
| |
| struct StructWithBigArray { |
| char max_size[4096]; |
| char max_size_plus_one[4097]; |
| }; |
| |
| typedef const int FourConstInts[4]; |
| void nonnullArrayParameters(const char x[_Nonnull], void * const _Nullable y[_Nonnull], _Nonnull FourConstInts z); |
| void nullableArrayParameters(const char x[_Nullable], void * const _Nullable y[_Nullable], _Nullable FourConstInts z); |
| |
| typedef double real_t __attribute__((availability(swift,unavailable,message="use double"))); |
| |
| extern real_t realSin(real_t value); |
| |
| #endif |