view release on metacpan or  search on metacpan

src/sparse-0.4.4/lib.c  view on Meta::CPAN

	va_list args;
	va_start(args, fmt);
	do_error(sctx_ pos, fmt, args);
	va_end(args);
}

void expression_error(SCTX_ struct expression *expr, const char *fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	do_error(sctx_ expr->pos->pos, fmt, args);
	va_end(args);
	expr->ctype = &sctxp bad_ctype;
}

void error_die(SCTX_ struct position pos, const char * fmt, ...) 
{
	va_list args;
	va_start(args, fmt);
	do_warn(sctx_ "error: ", pos, fmt, args);
	va_end(args);
	exit(1);
}

void sparse_die(SCTX_ const char *fmt, ...) 
{
	va_list args;
	static char buffer[512];

	va_start(args, fmt);
	vsnprintf(buffer, sizeof(buffer), fmt, args);
	va_end(args);

	fprintf(stderr, "%s\n", buffer);
	exit(1);
}

#ifndef DO_CTX
static struct token *pre_buffer_begin = NULL;
static struct token *pre_buffer_end = NULL;

int Waddress_space = 1;
int Wbitwise = 0;
int Wcast_to_as = 0;
int Wcast_truncate = 1;
int Wcontext = 1;
int Wdecl = 1;
int Wdeclarationafterstatement = -1;
int Wdefault_bitfield_sign = 0;
int Wdesignated_init = 1;
int Wdo_while = 0;
int Winit_cstring = 0;
int Wenum_mismatch = 1;
int Wnon_pointer_null = 1;
int Wold_initializer = 1;
int Wone_bit_signed_bitfield = 1;
int Wparen_string = 0;
int Wptr_subtraction_blows = 0;
int Wreturn_void = 0;
int Wshadow = 0;
int Wtransparent_union = 0;
int Wtypesign = 0;
int Wundef = 0;
int Wuninitialized = 1;
int Wvla = 1;

int dbg_entry = 0;
int dbg_dead = 0;

int preprocess_only;

enum standard_enum standard = STANDARD_GNU89;

#endif

/* ctx.h:
#ifdef __x86_64__
#define ARCH_M64_DEFAULT 1
#else
#define ARCH_M64_DEFAULT 0
#endif
*/

#ifndef DO_CTX
int arch_m64 = ARCH_M64_DEFAULT;
int arch_msize_long = 0;

/*#define CMDLINE_INCLUDE 20*//*ctx.h*/
static int cmdline_include_nr = 0;
static char *cmdline_include[CMDLINE_INCLUDE];
#endif 


void add_pre_buffer(SCTX_ int idx, const char *fmt, ...)
{
	va_list args;
	unsigned int size;
	struct token *begin, *end;
	char buffer[4096];
	struct expansion *e;

	va_start(args, fmt);
	size = vsnprintf(buffer, sizeof(buffer), fmt, args);
	va_end(args);
	e = tokenize_buffer(sctx_ buffer, idx, size, &end);
	begin = e->s;
	if (!sctxp pre_buffer_begin)
		sctxp pre_buffer_begin = begin;
	if (sctxp pre_buffer_end)
		sctxp pre_buffer_end->next = begin;
	sctxp pre_buffer_end = end;
}

static char **handle_switch_D(SCTX_ char *arg, char **next)
{
	const char *name = arg + 1;
	const char *value = "1";

	if (!*name || isspace(*name))
		sparse_die(sctx_ "argument to `-D' is missing");

src/sparse-0.4.4/lib.c  view on Meta::CPAN

	if (sctxp arch_m64) {
		sctxp bits_in_long = 64;
		sctxp max_int_alignment = 8;
		sctxp bits_in_pointer = 64;
		sctxp pointer_alignment = 8;
		sctxp size_t_ctype = &sctxp ulong_ctype;
		sctxp ssize_t_ctype = &sctxp long_ctype;
#ifdef __x86_64__
		add_pre_buffer(sctx_ sctxp stream_sb->id, "#weak_define __x86_64__ 1\n");
#endif
	}
}

static void handle_arch_msize_long_finalize(SCTX)
{
	if (sctxp arch_msize_long) {
		sctxp size_t_ctype = &sctxp ulong_ctype;
		sctxp ssize_t_ctype = &sctxp long_ctype;
	}
}

static void handle_arch_finalize(SCTX)
{
	handle_arch_m64_finalize(sctx );
	handle_arch_msize_long_finalize(sctx );
}


static char **handle_switch_o(SCTX_ char *arg, char **next)
{
	if (!strcmp (arg, "o")) {       // "-o foo"
		if (!*++next)
			sparse_die(sctx_ "argument to '-o' is missing");
	}
	// else "-ofoo"

	return next;
}

#ifndef DO_CTX
static const struct warning warnings[WCNT] = {
	{ "address-space", &Waddress_space },
	{ "bitwise", &Wbitwise },
	{ "cast-to-as", &Wcast_to_as },
	{ "cast-truncate", &Wcast_truncate },
	{ "context", &Wcontext },
	{ "decl", &Wdecl },
	{ "declaration-after-statement", &Wdeclarationafterstatement },
	{ "default-bitfield-sign", &Wdefault_bitfield_sign },
	{ "designated-init", &Wdesignated_init },
	{ "do-while", &Wdo_while },
	{ "enum-mismatch", &Wenum_mismatch },
	{ "init-cstring", &Winit_cstring },
	{ "non-pointer-null", &Wnon_pointer_null },
	{ "old-initializer", &Wold_initializer },
	{ "one-bit-signed-bitfield", &Wone_bit_signed_bitfield },
	{ "paren-string", &Wparen_string },
	{ "ptr-subtraction-blows", &Wptr_subtraction_blows },
	{ "return-void", &Wreturn_void },
	{ "shadow", &Wshadow },
	{ "transparent-union", &Wtransparent_union },
	{ "typesign", &Wtypesign },
	{ "undef", &Wundef },
	{ "uninitialized", &Wuninitialized },
	{ "vla", &Wvla },
};
#endif 

enum {
	WARNING_OFF,
	WARNING_ON,
	WARNING_FORCE_OFF
};


static char **handle_onoff_switch(SCTX_ char *arg, char **next, const struct warning *warnings, int n)
{
	int flag = WARNING_ON;
	char *p = arg + 1;
	unsigned i;

	if (!strcmp(p, "sparse-all")) {
		for (i = 0; i < n; i++) {
			if (*warnings[i].flag != WARNING_FORCE_OFF)
				*warnings[i].flag = WARNING_ON;
		}
	}

	// Prefixes "no" and "no-" mean to turn warning off.
	if (p[0] == 'n' && p[1] == 'o') {
		p += 2;
		if (p[0] == '-')
			p++;
		flag = WARNING_FORCE_OFF;
	}

	for (i = 0; i < n; i++) {
		if (!strcmp(p,warnings[i].name)) {
			*warnings[i].flag = flag;
			return next;
		}
	}

	// Unknown.
	return NULL;
}

static char **handle_switch_W(SCTX_ char *arg, char **next)
{
	char ** ret = handle_onoff_switch(sctx_ arg, next, sctxp warnings, WCNT /*ARRAY_SIZE(warnings)*/);
	if (ret)
		return ret;

	// Unknown.
	return next;
}

#ifndef DO_CTX
static struct warning debugs[] = {
	{ "entry", &dbg_entry},
	{ "dead", &dbg_dead},