Пример #1
0
int main(int argc, char **argv) {
	char dummy;
	MR_Integer value;
	MercuryList list;
	int exit_status;

	printf("In main().\n");

	/*
	** call mercury_init() to initialize the Mercury engine.
	** This must be done before we can call any Mercury predicates
	** or functions.
	*/
	mercury_init(argc, argv, &dummy);

	/*
	** call the C function foo_test(), which is the interface
	** to the Mercury predicate foo/1 in mode
	** 	:- mode foo(in) is semidet.
	*/
	printf("foo_test(42) returns %s\n", foo_test(42) ? "TRUE" : "FALSE");
	printf("foo_test(43) returns %s\n", foo_test(43) ? "TRUE" : "FALSE");

	/*
	** call the C function one_foo(), which is the interface
	** to the Mercury predicate foo/1 in mode
	** 	:- mode foo(out) is cc_multi.
	*/
	one_foo(&value);
	printf("one_foo(&value) gives value = %ld\n", (long) value);

	/*
	** call the C function foo_list(), which is the interface
	** to the Mercury predicate foo/1 in mode
	** 	:- mode foo(out) is multi.
	*/
	printf("foo_list() = ");
	foo_list(&list);
	print_list(list);
	printf("\n");

	/*
	** call the C functions bar(), bar_test(), and bar_inverse(),
	** which are the C interfaces to the Mercury function bar/1
	** in the modes
	**	:- mode bar(in) = out is det.
	**	:- mode bar(out) = in is det.
	**	:- mode bar(in) = in is det.
	** respectively.
	*/
	printf("bar(100) = %ld\n", (long) bar(100));
	printf("bar_test(100, 101) returns %s\n",
		(bar_test(100, 101) ? "TRUE" : "FALSE"));
	printf("bar_test(100, 200) returns %s\n",
		(bar_test(100, 200) ? "TRUE" : "FALSE"));
	bar_inverse(&value, 101);
	printf("bar_inverse(&value, 101) gives value = %ld\n", (long) value);
	bar_inverse(&value, 200);
	printf("bar_inverse(&value, 200) gives value = %ld\n", (long) value);

	if (baz(1, &value)) {
		printf("baz(1, &value) returns TRUE with value = %ld\n",
			(long) value);
	} else {
		printf("baz(100, &value) returns FALSE\n");
	}
	if (baz(100, &value)) {
		printf("baz(100, &value) returns TRUE with value = %ld\n",
			(long) value);
	} else {
		printf("baz(100, &value) returns FALSE\n");
	}

	/*
	** call mercury_terminate() to shutdown the Mercury engine.
	** This should be done after we have finished calling Mercury
	** predicates or functions.
	*/
	exit_status = mercury_terminate();

	printf("Returning from main().\n");
	return exit_status;
}
Пример #2
0
void foo()
{
    bpptree_map<int, int> bp_0;
    bpptree_map<std::string, std::string> bp_1;
    bpptree_map<int, int> const bp_2;
    bpptree_map<std::string, std::string> const bp_3;
    bpptree_multimap<int, int> bp_4;
    bpptree_multimap<std::string, std::string> bp_5;
    bpptree_multimap<int, int> const bp_6;
    bpptree_multimap<std::string, std::string> const bp_7;
    bpptree_set<int> bp_8;
    bpptree_set<std::string> bp_9;
    bpptree_set<int> const bp_a;
    bpptree_set<std::string> const bp_b;
    bpptree_multiset<int> bp_c;
    bpptree_multiset<std::string> bp_d;
    bpptree_multiset<int> const bp_e;
    bpptree_multiset<std::string> const bp_f;

    foo_test(bp_0);
    foo_test(bp_1);
    foo_test(bp_2);
    foo_test(bp_3);
    foo_test(bp_4);
    foo_test(bp_5);
    foo_test(bp_6);
    foo_test(bp_7);
    foo_test(bp_8);
    foo_test(bp_9);
    foo_test(bp_a);
    foo_test(bp_b);
    foo_test(bp_c);
    foo_test(bp_d);
    foo_test(bp_e);
    foo_test(bp_f);
}