END_TEST
START_TEST(test_case)
{
const error_t expect[] = {
{ 13, "missing choice C in case statement" },
{ 19, "missing choice B in case statement" },
{ 30, "10 to 19" },
{ 36, "4 to 2147483647" },
{ 44, "2147483647" },
{ 51, "value 50 is already covered" },
{ 53, "range 60 to 64 is already covered" },
{ 59, "value -1 outside STD.STANDARD.NATURAL bounds" },
{ 58, "0 to 2147483647" },
{ 79, "choices cover only 2 of 8 possible values" },
{ 84, "expected 3 elements in aggregate but have 2" },
{ 86, "expected 3 elements in aggregate but have 4" },
{ 88, "expected 3 elements in string literal but have 2" },
{ 90, "expected 3 elements in string literal but have 4" },
{ 95, "choices do not cover all possible values" },
{ 101, "choices cover only 2 of 100 possible values" },
{ -1, NULL }
};
expect_errors(expect);
input_from_file(TESTDIR "/bounds/case.vhd");
tree_t a = parse_and_check(T_ENTITY, T_ARCH);
fail_unless(sem_errors() == 0);
simplify(a);
bounds_check(a);
fail_unless(bounds_errors() == (sizeof(expect) / sizeof(error_t)) - 1);
}
END_TEST
START_TEST(test_issue36)
{
input_from_file(TESTDIR "/bounds/issue36.vhd");
tree_t e = parse_and_check(T_ENTITY);
fail_unless(sem_errors() == 0);
simplify(e);
bounds_check(e);
fail_unless(bounds_errors() == 0);
}
END_TEST
START_TEST(test_issue200)
{
input_from_file(TESTDIR "/bounds/issue200.vhd");
tree_t a = parse_and_check(T_ENTITY, T_ARCH);
fail_unless(sem_errors() == 0);
simplify(a);
bounds_check(a);
fail_unless(bounds_errors() == 0);
}
static tree_t run_elab(void)
{
tree_t t, last_ent = NULL;
while ((t = parse())) {
sem_check(t);
fail_if(sem_errors() > 0);
simplify(t);
if (tree_kind(t) == T_ENTITY)
last_ent = t;
}
return elab(last_ent);
}
END_TEST
START_TEST(test_issue208)
{
const error_t expect[] = {
{ 20, "case choices do not cover the following values of " },
{ -1, NULL }
};
expect_errors(expect);
input_from_file(TESTDIR "/bounds/issue208.vhd");
tree_t a = parse_and_check(T_ENTITY, T_ARCH);
fail_unless(sem_errors() == 0);
simplify(a);
bounds_check(a);
fail_unless(bounds_errors() == ARRAY_LEN(expect) - 1);
}
END_TEST
START_TEST(test_issue150)
{
const error_t expect[] = {
{ 10, "expected 8 elements in aggregate but have 6" },
{ -1, NULL }
};
expect_errors(expect);
input_from_file(TESTDIR "/bounds/issue150.vhd");
tree_t a = parse_and_check(T_ENTITY, T_ARCH);
fail_unless(sem_errors() == 0);
simplify(a);
bounds_check(a);
fail_unless(bounds_errors() == (sizeof(expect) / sizeof(error_t)) - 1);
}
END_TEST
START_TEST(test_issue99)
{
const error_t expect[] = {
{ 7, "type conversion argument -1.5 out of bounds 0 to 2147483647" },
{ 8, "type conversion argument -1 out of bounds 1 to 5" },
{ -1, NULL }
};
expect_errors(expect);
input_from_file(TESTDIR "/bounds/issue99.vhd");
tree_t a = parse_and_check(T_ENTITY, T_ARCH);
fail_unless(sem_errors() == 0);
simplify(a);
bounds_check(a);
fail_unless(bounds_errors() == (sizeof(expect) / sizeof(error_t)) - 1);
}
END_TEST
START_TEST(test_issue54)
{
const error_t expect[] = {
{ 12, "aggregate index 3 out of bounds 7 downto 4" },
{ 12, "aggregate index 0 out of bounds 7 downto 4" },
{ -1, NULL }
};
expect_errors(expect);
input_from_file(TESTDIR "/bounds/issue54.vhd");
tree_t a = parse_and_check(T_ENTITY, T_ARCH);
fail_unless(sem_errors() == 0);
simplify(a);
bounds_check(a);
fail_unless(bounds_errors() == (sizeof(expect) / sizeof(error_t)) - 1);
}
static int analyse(int argc, char **argv)
{
set_work_lib();
static struct option long_options[] = {
{ "bootstrap", no_argument, 0, 'b' },
{ "dump-llvm", no_argument, 0, 'd' },
{ "prefer-explicit", no_argument, 0, 'p' },
{ 0, 0, 0, 0 }
};
int c, index = 0;
const char *spec = "";
optind = 1;
while ((c = getopt_long(argc, argv, spec, long_options, &index)) != -1) {
switch (c) {
case 0:
// Set a flag
break;
case '?':
// getopt_long already printed an error message
exit(EXIT_FAILURE);
case 'b':
opt_set_int("bootstrap", 1);
break;
case 'd':
opt_set_int("dump-llvm", 1);
break;
case 'p':
opt_set_int("prefer-explicit", 1);
break;
default:
abort();
}
}
size_t unit_list_sz = 32;
tree_t *units LOCAL = xmalloc(sizeof(tree_t) * unit_list_sz);
int n_units = 0;
for (int i = optind; i < argc; i++) {
input_from_file(argv[i]);
tree_t unit;
while ((unit = parse()) && sem_check(unit))
ARRAY_APPEND(units, unit, n_units, unit_list_sz);
}
for (int i = 0; i < n_units; i++) {
simplify(units[i]);
bounds_check(units[i]);
}
if (parse_errors() + sem_errors() + bounds_errors() > 0)
return EXIT_FAILURE;
for (int i = 0; i < n_units; i++) {
tree_kind_t kind = tree_kind(units[i]);
const bool need_cgen =
(kind == T_PACK_BODY)
|| ((kind == T_PACKAGE) && pack_needs_cgen(units[i]));
if (need_cgen)
opt(units[i]);
else
units[i] = NULL;
}
lib_save(lib_work());
for (int i = 0; i < n_units; i++) {
if (units[i] != NULL)
cgen(units[i]);
}
return EXIT_SUCCESS;
}
static int analyse(int argc, char **argv)
{
set_work_lib();
static struct option long_options[] = {
{ "bootstrap", no_argument, 0, 'b' },
{ "dump-llvm", no_argument, 0, 'd' },
{ "dump-vcode", optional_argument, 0, 'v' },
{ "prefer-explicit", no_argument, 0, 'p' }, // DEPRECATED
{ "relax", required_argument, 0, 'r' },
{ 0, 0, 0, 0 }
};
int c, index = 0;
const char *spec = "";
optind = 1;
while ((c = getopt_long(argc, argv, spec, long_options, &index)) != -1) {
switch (c) {
case 0:
// Set a flag
break;
case '?':
fatal("unrecognised analyse option %s", argv[optind - 1]);
case 'b':
opt_set_int("bootstrap", 1);
break;
case 'd':
opt_set_int("dump-llvm", 1);
break;
case 'v':
opt_set_str("dump-vcode", optarg ?: "");
break;
case 'p':
warnf("the --prefer-explict option is deprecated: use "
"--relax=prefer-explict instead");
opt_set_int("relax", RELAX_PREFER_EXPLICT);
break;
case 'r':
opt_set_int("relax", parse_relax(optarg));
break;
default:
abort();
}
}
size_t unit_list_sz = 32;
tree_t *units LOCAL = xmalloc(sizeof(tree_t) * unit_list_sz);
int n_units = 0;
for (int i = optind; i < argc; i++) {
input_from_file(argv[i]);
tree_t unit;
while ((unit = parse()) && sem_check(unit))
ARRAY_APPEND(units, unit, n_units, unit_list_sz);
}
for (int i = 0; i < n_units; i++) {
simplify(units[i]);
bounds_check(units[i]);
}
if (parse_errors() + sem_errors() + bounds_errors() > 0)
return EXIT_FAILURE;
for (int i = 0; i < n_units; i++) {
tree_kind_t kind = tree_kind(units[i]);
const bool need_cgen =
(kind == T_PACK_BODY)
|| ((kind == T_PACKAGE) && pack_needs_cgen(units[i]));
if (need_cgen)
opt(units[i]);
else
units[i] = NULL;
}
lib_save(lib_work());
for (int i = 0; i < n_units; i++) {
if (units[i] != NULL) {
lower_unit(units[i]);
cgen(units[i]);
}
}
return EXIT_SUCCESS;
}
