/*	$NetBSD: init_c99.c,v 1.5 2025/04/12 15:49:50 rillig Exp $	*/
# 3 "init_c99.c"

// Tests for initialization in C99 or later, mainly for designators.
//
// See C99 6.7.8 "Initialization".

/* lint1-flags: -Sw -X 351 */

void use(const void *);

typedef struct any {
	const void *value;
} any;


// C99 6.7.8p11 says "optionally enclosed in braces".  Whether this wording
// means "a single pair of braces" or "as many pairs of braces as you want"
// is left for interpretation to the reader.
int scalar_without_braces = 3;
int scalar_with_optional_braces = { 3 };
int scalar_with_too_many_braces = {{ 3 }};
/* expect+1: error: too many initializers for 'int' [174] */
int scalar_with_too_many_initializers = { 3, 5 };


// See initialization_expr, 'handing over to INIT'.
void
struct_initialization_via_assignment(any arg)
{
	any local = arg;
	use(&local);
}


// See initialization_expr, initialization_init_array_from_string.
char static_duration[] = "static duration";
signed char static_duration_signed[] = "static duration";
unsigned char static_duration_unsigned[] = "static duration";
int static_duration_wchar[] = L"static duration";

// See init_expr.
void
initialization_by_braced_string(void)
{
	any local = { "hello" };
	use(&local);
}

void
initialization_by_redundantly_braced_string(void)
{
	any local = {{{{ "hello" }}}};
	use(&local);
}

/*
 * Only scalar expressions and string literals may be enclosed by additional
 * braces.  Since 'arg' is a struct, this is a compile-time error.
 */
void
initialization_with_too_many_braces(any arg)
{
	/* expect+1: error: cannot initialize 'pointer to const void' from 'struct any' [185] */
	any local = { arg };
	use(&arg);
}

// Some of the following examples are mentioned in the introduction comment
// in init.c.

int number = 12345;

int number_with_braces_and_comma = {
	12345,
};

int array_with_fixed_size[3] = {
	111,
	222,
	333,
	/* expect+1: error: too many array initializers, expected 3 [173] */
	444,
};

// See update_type_of_array_of_unknown_size.
int array_of_unknown_size[] = {
	111,
	222,
	333,
};

int array_flat[2][2] = {
	11,
	12,
	21,
	22
};

int array_nested[2][2] = {
	{
		11,
		12
	},
	{
		21,
		22
	}
};

int array_with_designators[] = {
	['1'] = 111,
	['5'] = 555,
	['9'] = 999
};

int array_with_some_designators[] = {
	['1'] = 111,
	222,
	['9'] = 999
};

struct point {
	int x;
	int y;
};

struct point point = {
	3,
	4
};

struct point point_with_designators = {
	.y = 4,
	.x = 3,
};

struct point point_with_mixed_designators = {
	.x = 3,
	4,
	/* expect+1: error: too many struct/union initializers [172] */
	5,
	.x = 3,
};

/*
 * Before cgram.y 1.230 from 2021-06-20, the grammar allowed either of the
 * operators '.' or '->' to be used for the designators and had extra code
 * to ensure that only '.' was actually used.
 */
struct point origin = {
	.x = 0,
	/* expect+1: error: syntax error '->' [249] */
	->y = 0,
};

/* Ensure that the parser can recover from the parse error. */
struct point pythagoras = { 3, 4 };

int array_with_designator[] = {
	111,
	/* expect+1: error: syntax error 'designator '.member' is only for struct/union' [249] */
	.member = 222,
	333,
};

/*
 * C99 6.7.8p11 says that the initializer of a scalar can be "optionally
 * enclosed in braces".  It does not explicitly set an upper limit on the
 * number of braces.  It also doesn't restrict the term "initializer" to only
 * mean the "outermost initializer".  6.7.8p13 defines that a brace for a
 * structure or union always means to descend into the type.  Both GCC 10 and
 * Clang 8 already warn about these extra braces, nevertheless there is
 * real-life code (the Postfix MTA) that exploits this corner case of the
 * standard.
 */
struct point scalar_with_several_braces = {
	{{{3}}},
	{{{{4}}}},
};

struct rectangle {
	struct point top_left;
	struct point bottom_right;
};

/* C99 6.7.8p18 */
struct rectangle screen = {
	.bottom_right = {
		1920,
		1080,
	}
};

/*
 * C99 6.7.8p22 says: At the _end_ of its initializer list, the array no
 * longer has incomplete type.
 */
struct point points[] = {
	{
		/*
		 * At this point, the size of the object 'points' is not known
		 * yet since its type is still incomplete.  Lint could warn
		 * about this, but GCC and Clang already do.
		 *
		 * Before init.c 1.179 from 2021.03.30, the type information
		 * of 'points' was set too early, resulting in a negative
		 * array size below.
		 */
		sizeof(int[-(int)sizeof(points)]),
		4
	}
};


struct triangle {
	struct point points[3];
};

struct pentagon {
	struct point points[5];
};

struct geometry {
	struct pentagon pentagons[6];
	struct triangle triangles[10];
	struct point points[3][5][2];
};

/*
 * Initialization of a complex struct containing nested arrays and nested
 * structs.
 */
struct geometry geometry = {
	.pentagons[0].points[4].x = 1,
	.points[0][0][0] = { 0, 0 },
	.points[2][4][1] = {301, 302 },
	/* expect+1: error: array subscript 3 cannot be > 2 [168] */
	.points[3][0][0] = {3001, 3002 },
	/* expect+1: error: array subscript 5 cannot be > 4 [168] */
	.points[0][5][0] = {501, 502 },
	/* expect+1: error: array subscript 2 cannot be > 1 [168] */
	.points[0][0][2] = {21, 22 },
};

struct ends_with_unnamed_bit_field {
	int member;
	int:0;
} ends_with_unnamed_bit_field = {
	12345,
	/* expect+1: error: too many struct/union initializers [172] */
	23456,
};

char prefixed_message[] = {
	'E', ':', ' ',
	/* expect+1: warning: invalid combination of integer 'char' and pointer 'pointer to char' for 'init' [183] */
	"message\n",
};

char message_with_suffix[] = {
	"message",
	/* The excess character is not detected by lint but by compilers. */
	'\n',
};

struct ten {
	int i0;
	int i1;
	int i2;
	int i3;
	int i4;
	int i5;
	int i6;
	int i7;
	int i8;
	int i9;
};

struct ten ten = {
	.i3 = 3,
	4,
	5,
	6,
};


/*
 * ISO C99 6.7.8 provides a large list of examples for initialization,
 * covering all tricky edge cases.
 */

/* expect+1: warning: lossy conversion of 3.5 to 'int' [381] */
int c99_6_7_8_p24_example1_i = 3.5;
double _Complex c99_6_7_8_p24_example1_c = 5 + 3 * 1.0fi;

int c99_6_7_8_p25_example2[] = { 1, 3, 5 };

int c99_6_7_8_p26_example3a[4][3] = {
	{ 1, 3, 5 },
	{ 2, 4, 6 },
	{ 3, 5, 7 },
};

int c99_6_7_8_p26_example3b[4][3] = {
	1, 3, 5, 2, 4, 6, 3, 5, 7
};

int c99_6_7_8_p27_example4[4][3] = {
	{ 1 }, { 2 }, { 3 }, { 4 }
};

struct {
	int a[3], b;
} c99_6_7_8_p28_example5[] = {
	{ 1 },
	2,
};

short c99_6_7_8_p29_example6a[4][3][2] = {
	{ 1 },
	{ 2, 3 },
	{ 4, 5, 6 },
};

short c99_6_7_8_p29_example6b[4][3][2] = {
	1, 0, 0, 0, 0, 0,
	2, 3, 0, 0, 0, 0,
	4, 5, 6, 0, 0, 0,
};

short c99_6_7_8_p29_example6c[4][3][2] = {
	{
		{ 1 },
	},
	{
		{ 2, 3 },
	},
	{
		{ 4, 5 },
		{ 6 },
	}
};

void
c99_6_7_8_p31_example7(void)
{
	typedef int A[];

	A a = { 1, 2 }, b = { 3, 4, 5 };

	/* expect+1: error: negative array dimension (-8) [20] */
	typedef int reveal_sizeof_a[-(int)(sizeof(a))];
	/* expect+1: error: negative array dimension (-12) [20] */
	typedef int reveal_sizeof_b[-(int)(sizeof(b))];
}

char c99_6_7_8_p32_example8_s1[] = "abc",
	 c99_6_7_8_p32_example8_t1[3] = "abc";
char c99_6_7_8_p32_example8_s2[] = { 'a', 'b', 'c', '\0' },
	 c99_6_7_8_p32_example8_t2[3] = { 'a', 'b', 'c' };
char *c99_6_7_8_p32_example8_p = "abc";

enum { member_one, member_two };
const char *c99_6_7_8_p33_example9[] = {
	[member_two] = "member two",
	[member_one] = "member one",
};

struct {
	int quot, rem;
} c99_6_7_8_p34_example10 = { .quot = 2, .rem = -1 };

struct { int a[3], b; } c99_6_7_8_p35_example11[] =
	{ [0].a = {1}, [1].a[0] = 2 };

int c99_6_7_8_p36_example12a[16] = {
	1, 3, 5, 7, 9, [16-5] = 8, 6, 4, 2, 0
};

int c99_6_7_8_p36_example12b[8] = {
	1, 3, 5, 7, 9, [8-5] = 8, 6, 4, 2, 0
};

union {
	int first_member;
	void *second_member;
	unsigned char any_member;
} c99_6_7_8_p38_example13 = { .any_member = 42 };


/*
 * During initialization of an object of type array of unknown size, the type
 * information on the symbol is updated in-place.  Ensure that this happens on
 * a copy of the type.
 *
 * C99 6.7.8p31 example 7
 */
void
ensure_array_type_is_not_modified_during_initialization(void)
{
	typedef int array_of_unknown_size[];

	array_of_unknown_size a1 = { 1, 2, 3};

	switch (4) {
	case sizeof(array_of_unknown_size):
	/* expect+1: error: duplicate case '0' in switch [199] */
	case 0:
	case 3:
	case 4:
	case 12:
		break;
	}

	/* expect+1: error: negative array dimension (-12) [20] */
	typedef int reveal_sizeof_a1[-(int)(sizeof(a1))];
}

struct point unknown_member_name_beginning = {
	/* expect+1: error: type 'struct point' does not have member 'r' [101] */
	.r = 5,
	.x = 4,
	.y = 3,
};

struct point unknown_member_name_middle = {
	.x = 4,
	/* expect+1: error: type 'struct point' does not have member 'r' [101] */
	.r = 5,
	.y = 3,
};

struct point unknown_member_name_end = {
	.x = 4,
	.y = 3,
	/* expect+1: error: type 'struct point' does not have member 'r' [101] */
	.r = 5,
};

union value {
	int int_value;
	void *pointer_value;
};

union value unknown_union_member_name_first = {
	/* expect+1: error: type 'union value' does not have member 'unknown_value' [101] */
	.unknown_value = 4,
	.int_value = 3,
};

union value unknown_union_member_name_second = {
	.int_value = 3,
	/* expect+1: error: type 'union value' does not have member 'unknown_value' [101] */
	.unknown_value = 4,
};

struct point subscript_designator_on_struct = {
	/* expect+1: error: syntax error 'designator '[...]' is only for arrays' [249] */
	[0] = 3,
};

struct point unknown_member_on_struct = {
	/* expect+1: error: type 'struct point' does not have member 'member' [101] */
	.member[0][0].member = 4,
};

struct point unknown_member_on_scalar = {
	/* expect+1: error: syntax error 'scalar type cannot use designator' [249] */
	.x.y.z = 5,
};

struct {
	int:16;
	/* expect+2: warning: 'struct <unnamed>' has no named members [65] */
	/* expect+1: error: cannot initialize struct/union with no named member [179] */
} struct_with_only_unnamed_members = {
	123,
};

union {
	int:16;
	/* expect+2: warning: 'union <unnamed>' has no named members [65] */
	/* expect+1: error: cannot initialize struct/union with no named member [179] */
} union_with_only_unnamed_members = {
	123,
};

int designator_for_scalar = {
	/* expect+1: error: syntax error 'scalar type cannot use designator' [249] */
	.value = 3,
};

struct point member_designator_for_scalar_in_struct = {
	/* expect+1: error: syntax error 'scalar type cannot use designator' [249] */
	{ .x = 3 },
};
struct point subscript_designator_for_scalar_in_struct = {
	/* expect+1: error: syntax error 'designator '[...]' is only for arrays' [249] */
	{ [1] = 4 },
};


/* Seen in pcidevs_data.h, variable 'pci_words'. */
const char string_initialized_with_braced_literal[] = {
	"initializer",
};

// An array of unknown size containing strings.
char weekday_names[][4] = {
	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};

/* nested struct/union initialization */
struct outer {
	int i;
	char c;
	union inner {
		short us;
		char uc;
	} u;
	char *s;
} struct_containing_union[] = {
	{
		.s = "foo",
		.c = 'b',
		.u = {
			.uc = 'c'
		}
	},
	{
		.i = 1,
		.c = 'a',
		.u = {
			.us = 2
		}
	},
};

/*
 * The expansion of the offsetof macro may dereference a null pointer.
 * Such expressions are allowed in initializers for objects with
 * static duration.
 */
struct offset_and_data {
	unsigned long offset;
	unsigned long data;
};

struct offset_and_data offset_and_data = {
	(unsigned long)&(((struct offset_and_data *)0)->data),
	0,
};

// The size of the array is determined by the maximum index, not by the last
// one mentioned.
int arr_11[] = { [10] = 10, [0] = 0 };
/* expect+1: error: negative array dimension (-11) [20] */
typedef int ctassert_11[-(int)(sizeof(arr_11) / sizeof(arr_11[0]))];

// Without an explicit subscript designator, the subscript counts up.
int arr_3[] = { [1] = 1, [0] = 0, 1, 2 };
/* expect+1: error: negative array dimension (-3) [20] */
typedef int ctassert_3[-(int)(sizeof(arr_3) / sizeof(arr_3[0]))];


// C99 struct initialization using designators.
struct {
	int i;
	char *s;
} struct_array[] = {
	{
		.i = 2,
	},
	{
		.s = "foo"
	},
	{
		.i = 1,
		.s = "bar"
	},
	{
		.s = "foo",
		.i = -1
	},
};

// Ensure that deeply nested structs can be designated in an initializer.
int
init_deeply_nested_struct(void)
{
	struct rgb {
		unsigned red;
		unsigned green;
		unsigned blue;
	};

	struct hobbies {
		unsigned dancing: 1;
		unsigned running: 1;
		unsigned swimming: 1;
	};

	struct person {
		struct hobbies hobbies;
		struct rgb favorite_color;
	};

	struct city {
		struct person mayor;
	};

	struct state {
		struct city capital;
	};

	struct state st = {
		.capital.mayor.hobbies.dancing = 1,
		.capital.mayor.favorite_color.green = 0xFF,
		.capital.mayor.favorite_color.red = 0xFF,
	};
	return st.capital.mayor.favorite_color.red;
}

struct {
	int i[10];
	char *s;
} struct_array_with_inner_array[] = {
	{
		{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
		"foo"
	},
};

struct {
	int type;
	union {
		char b[20];
		short s[10];
		long l[5];
	} data;
} array_in_union_in_struct = {
	.type = 3,
	.data.l[0] = 4
};

// Somewhere between 2005.12.24.20.47.56 and 2006.12.19.19.06.44, lint could
// not initialize named members, see PR bin/20264.
union {
	char *p;
	int a[1];
} array_in_union = {
	.a = { 7 }
};

/*
 * Initialization of a nested struct, in which some parts are initialized
 * from non-constant expressions of the inner struct type.
 *
 * In C99, 6.7.8p13 describes exactly this case.
 */
void
init_nested_struct(void)
{

	typedef enum O1 {
		O1C = 101
	} O1;
	typedef enum O2 {
		O2C = 102
	} O2;
	typedef enum O3 {
		O3C = 103
	} O3;
	typedef enum I1 {
		I1C = 201
	} I1;
	typedef enum I2 {
		I2C = 202
	} I2;

	struct Inner1 {
		I1 i1;
	};

	struct Outer3Inner1 {
		O1 o1;
		struct Inner1 inner;
		O3 o3;
	};

	struct Inner1 inner1 = {
		I1C
	};
	struct Outer3Inner1 o3i1 = {
		O1C,
		inner1,
		O3C
	};

	O1 o1 = o3i1.o1;

	struct Inner2 {
		I1 i1;
		I2 i2;
	};

	struct Outer3Inner2 {
		O1 o1;
		struct Inner2 inner;
		O3 o3;
	};

	struct Inner2 inner2 = {
		I1C,
		I2C
	};
	struct Outer3Inner2 o3i2 = {
		O1C,
		inner2,
		O3C
	};
	o1 = o3i2.o1;

	/*
	 * For static storage duration, each initializer expression must be a
	 * constant expression.
	 */
	static struct Inner2 inner3_static = {
		I1C,
		I2C
	};
	static struct Outer3Inner2 o3i2_static = {
		O1C,
		/* expect+1: error: non-constant initializer [177] */
		inner3_static,
		O3C
	};
}
