/*	$NetBSD: emit.c,v 1.19 2026/03/11 00:43:08 rillig Exp $	*/
# 3 "emit.c"

/*
 * Test the symbol information that lint1 writes to a .ln file.  Using this
 * symbol information, lint2 later checks that the symbols are used
 * consistently across different translation units.
 */

/* Do not warn about unused parameters or 'extern' declarations. */
/* lint1-extra-flags: -X 231 -X 351 */

/*
 * Define some derived types.
 */

struct struct_tag {
	int member;
};

typedef struct {
	int member;
} struct_typedef;

union union_tag {
	int member;
};

typedef union {
	int member;
} union_typedef;

enum enum_tag {
	enum_tag_constant
};

typedef enum {
	enum_typedef_constant
} enum_typedef;

/*
 * Variable declarations using the basic types (C99 6.2.5p14).
 *
 * Last synced with function outtype from emit1.c 1.43.
 */

extern _Bool			extern__Bool;
extern float _Complex		extern__Complex_float;
extern double _Complex		extern__Complex_double;
extern long double _Complex	extern__Complex_long_double;
extern char			extern_char;
extern signed char		extern_signed_char;
extern unsigned char		extern_unsigned_char;
extern short			extern_short;
extern signed short		extern_signed_short;
extern unsigned short		extern_unsigned_short;
extern int			extern_int;
extern signed int		extern_signed_int;
extern unsigned int		extern_unsigned_int;
extern long			extern_long;
extern signed long		extern_signed_long;
extern unsigned long		extern_unsigned_long;
extern long long		extern_long_long;
extern signed long long		extern_signed_long_long;
extern unsigned long long	extern_unsigned_long_long;
extern float			extern_float;
extern double			extern_double;
extern long double		extern_long_double;

/*
 * Variable declarations using derived types (C99 6.2.5p20).
 */

extern void *			extern_pointer_to_void;
extern int			extern_array_5_of_int[5];

/*
 * Type tags are written to the .ln file as 'T kind length name', where 'kind'
 * is either 1, 2 or 3.  This is confusing at first since in 'T110struct_tag',
 * the apparent number 110 is to be read as 'tag kind 1, length 10'.
 */
extern struct struct_tag	extern_struct_tag;
extern struct_typedef		extern_struct_typedef;
extern union union_tag		extern_union_tag;
extern union_typedef		extern_union_typedef;
extern enum enum_tag		extern_enum_tag;
extern enum_typedef		extern_enum_typedef;

extern struct {
	int member;
}				extern_anonymous_struct;
extern union {
	int member;
}				extern_anonymous_union;
extern enum {
	anonymous_enum_constant
}				extern_anonymous_enum;

/*
 * Variable definitions.
 *
 * Static variables are not recorded in the .ln file.
 */

extern int			declared_int;
int				defined_int;
/* expect+1: warning: static variable 'static_int' unused [226] */
static int			static_int;

/*
 * Type qualifiers.
 */

extern const int		extern_const_int;
extern volatile int		extern_volatile_int;
extern const volatile int	extern_const_volatile_int;

/*
 * Functions.
 */

extern void return_void_unknown_parameters();
extern /* implicit int */ return_implicit_int_unknown_parameters();
/* expect-1: error: old-style declaration; add 'int' [1] */
/* For function declarations, the keyword 'extern' is optional. */
extern void extern_return_void_no_parameters(void);
/* implicit extern */ void return_void_no_parameters(void);
/* expect+1: warning: static function 'static_return_void_no_parameters' declared but not defined [290] */
static void static_return_void_no_parameters(void);

void taking_int(int);
/* The 'const' parameter does not make a difference. */
void taking_const_int(const int);
void taking_int_double_bool(int, double, _Bool);
void taking_struct_union_enum_tags(struct struct_tag, union union_tag,
    enum enum_tag);
void taking_struct_union_enum_typedefs(struct_typedef, union_typedef,
    enum_typedef);

void taking_varargs(const char *, ...);

/*
 * This function does not affect anything outside this translation unit.
 * Naively there is no need to record this function in the .ln file, but it
 * is nevertheless recorded.  There's probably a good reason for recording
 * it.
 */
/* expect+1: warning: static function 'static_function' declared but not defined [290] */
static int static_function(void);

void my_printf(const char *, ...);
void my_scanf(const char *, ...);

/*
 * String literals that occur in function calls are written to the .ln file,
 * just in case they are related to a printf-like or scanf-like function.
 *
 * In this example, the various strings are not format strings, they just
 * serve to cover the code that escapes character literals (outqchar in
 * lint1) and reads them back into characters (inpqstrg in lint2).
 */
void
cover_outqchar(void)
{
	my_printf("%s", "%");
	my_printf("%s", "%s");
	my_printf("%s", "%%");
	my_printf("%s", "%\\ %\" %' %\a %\b %\f %\n %\r %\t %\v %\177");
}

void
cover_outfstrg(void)
{
	my_printf("%s", "%-3d %+3d % d %#x %03d %*.*s %6.2f %hd %ld %Ld %qd");
	my_scanf("%s", "%[0-9]s %[^A-Za-z]s %[][A-Za-z0-9]s %[+-]s");
}

/*
 * Calls to GCC builtin functions should not be emitted since GCC already
 * guarantees a consistent definition of these function and checks the
 * arguments, so there is nothing left to do for lint.
 */
void
call_gcc_builtins(int x, long *ptr)
{
	long value;

	__builtin_expect(x > 0, 1);
	__builtin_bswap32(0x12345678);

	__atomic_load(ptr, &value, 0);
}

/*
 * XXX: It's strange that a function can be annotated with VARARGS even
 * though it does not take varargs at all.
 *
 * This feature is not useful for modern code anyway, it focused on pre-C90
 * code that did not have function prototypes.
 */

/* VARARGS */
void
varargs_comment(const char *fmt)
{
}

/* VARARGS 0 */
void
varargs_0_comment(const char *fmt)
{
}

/* VARARGS 3 */
void
varargs_3_comment(int a, int b, int c, const char *fmt)
{
}

/* PRINTFLIKE */
void
printflike_comment(const char *fmt)
{
}

/* PRINTFLIKE 0 */
void
printflike_0_comment(const char *fmt)
{
}

/* PRINTFLIKE 3 */
void
printflike_3_comment(int a, int b, const char *fmt)
{
}

/* PRINTFLIKE 10 */
void
printflike_10_comment(int a1, int a2, int a3, int a4, int a5,
		      int a6, int a7, int a8, int a9,
		      const char *fmt)
{
}

/* SCANFLIKE */
void
scanflike_comment(const char *fmt)
{
}

/* SCANFLIKE 0 */
void
scanflike_0_comment(const char *fmt)
{
}

/* SCANFLIKE 3 */
void
scanflike_3_comment(int a, int b, const char *fmt)
{
}

int
used_function(void)
{
	return 4;
}

inline int
inline_function(void)
{
	used_function();
	(void)used_function();
	return used_function();
}

extern int declared_used_var;
int defined_used_var;

/*
 * When a function is used, that usage is output as a 'c' record.
 * When a variable is used, that usage is output as a 'u' record.
 */
void
use_vars(void)
{
	declared_used_var++;
	defined_used_var++;
}

/*
 * Since C99, an initializer may contain a compound expression. This allows
 * to create trees of pointer data structures at compile time.
 *
 * The objects that are created for these compound literals are unnamed,
 * therefore there is no point in exporting them to the .ln file.
 *
 * Before emit1.c 1.60 from 2021-11-28, lint exported them.
 */
struct compound_expression_in_initializer {
	const char * const *info;
};

struct compound_expression_in_initializer compound = {
	.info = (const char *[16]){
		[0] = "zero",
	},
};

/*
 * Before decl.c 1.312 and init.c 1.242 from 2023-05-22, the type that ended up
 * in the .ln file was 'A0cC', which was wrong as it had array size 0 instead
 * of the correct 8.  That type had been taken too early, before looking at the
 * initializer.
 */
const char array_of_unknown_size[] = "unknown";

int used_and_using(int);
int only_used(void);

int
only_using(void)
{
	return used_and_using(only_used());
}

/*
 * When a function returns a value and doesn't ever reach the point where it
 * would return no value, the value-less return doesn't count.
 */

__attribute__((__noreturn__)) void exit(int);

int maybe_exit(int i);

// FIXME: do not emit that maybe_exit might return void.
int
call_maybe_exit(void)
{
	return maybe_exit(13);
}

int
maybe_exit(int i)
{
	exit(1);
}
