Support _Bool as primitive type

Author: tgtakaoka

doc/internals-target.txt

@@ -9,7 +9,7 @@ A machine target is specified by filling in a '''machine_spec''' structure, defi
 * machine_name: name of the target
 * handle_option: a function that gets to inspect options passed to nesc1 and take appropriate action (example: the '''self''' target adjusts double alignment based on the -malign-double gcc flag).
 * big_endian: must be true for big-endian targets, false for little-endian ones
-* tptr, tfloat, tdouble, tlong_double, tshort, tint, tlong, tlong_long: size and alignment of the corresponding C types.
+* tptr, tfloat, tdouble, tlong_double, tshort, tint, tlong, tlong_long, t_Bool: size and alignment of the corresponding C types.
 * int1_align, int2_align, int4_align, int8_align: with gcc, you can ask for specific size ints (see gcc's mode attribute, and the '''type_for_mode''' function in types.c). On some platforms, some of these sizes may not correspond to any of the normal basic C types, so you get to specify the alignments for those missing sizes here...
 * wchar_t_size: size of the wchar_t type
 * size_t_size: size of the size_t type (actually this should be the C type, knowing just the size can cause problems)

nregress/c99c11/boolarg/BoolTest.nc

@@ -0,0 +1,4 @@
+interface BoolTest {
+  command void test(const char *test_name, const _Bool arg);
+  event void testDone(const char *test_name, _Bool result, _Bool arg);
+}

nregress/c99c11/boolarg/BoolTestM.nc

@@ -0,0 +1,8 @@
+module BoolTestM {
+  provides interface BoolTest;
+}
+implementation {
+  command void BoolTest.test(const char *test_name, const _Bool arg) {
+    signal BoolTest.testDone(test_name, !arg, arg);
+  }
+}

nregress/c99c11/boolarg/TestP.nc

@@ -0,0 +1,45 @@
+extern int printf(const char *__restrict format, ...);
+
+typedef struct {
+  _Bool a;
+} bool_test_args;
+
+nx_struct nx_header {
+  nx_uint32_t src;
+  nx_uint32_t dst;
+};
+
+module TestP {
+  uses interface BoolTest;
+}
+implementation {
+  int main() @C() @spontaneous() {
+#define do_test(test_name, bool_expr)  call BoolTest.test(#test_name, bool_expr)
+
+    do_test(TrueConst, 1);
+    do_test(TrueExpr, 1 == 1 && 0 < 1);
+    do_test(TrueExprSC, 0 == 0 || 0 > 1);
+    do_test(IntTrue, 1234);
+    do_test(FloatTrue, 1.23);
+    do_test(String, "string");
+
+    do_test(FalseConst, 0);
+    do_test(FalseExpr, 0 == 1 || 0 > 1);
+    do_test(FalseExprSC, 1 == 0 && 0 < 1);
+    do_test(IntZero, 0);
+    do_test(FloatZero, 0.0);
+    do_test(NullVoid, (const void *)0);
+    do_test(NullULL, (unsigned long long *)0);
+    do_test(NullStruct, (const bool_test_args *const __restrict)0);
+    do_test(NullFnP, (int (*)(char[], double))0);
+    do_test(Network, (nx_uint32_t *)0);
+    do_test(NetworkStruct, (nx_struct nx_header *)0);
+#undef do_test
+
+    return 0;
+  }
+
+  event void BoolTest.testDone(const char *test_name, _Bool result, _Bool arg) {
+    printf("%15s: %d -> %d\n", test_name, arg, result);
+  }
+}

nregress/c99c11/boolarg/test.nc

@@ -0,0 +1,7 @@
+configuration test {
+}
+implementation {
+  components TestP, BoolTestM;
+
+  TestP.BoolTest -> BoolTestM;
+}

nregress/c99c11/boolgeneric/BoolTest.nc

@@ -0,0 +1,11 @@
+typedef struct {
+  _Bool a:1;
+  _Bool b;
+} bool_test_args;
+
+interface BoolTest {
+  command void unary(const _Bool a);
+  command void binary(const bool_test_args args);
+  event void unaryDone(const char *test_name, _Bool result, _Bool arg);
+  event void binaryDone(const char *test_name, _Bool result, bool_test_args args);
+}

nregress/c99c11/boolgeneric/BoolTestM.nc

@@ -0,0 +1,15 @@
+generic module BoolTestM(_Bool val, char test_name[]) {
+  provides interface BoolTest;
+}
+implementation {
+  command void BoolTest.unary(const _Bool a) {
+    const _Bool result = val ? a : !a;
+    signal BoolTest.unaryDone(test_name, result, a);
+  }
+
+  command void BoolTest.binary(const bool_test_args args) {
+    const _Bool xor = args.a ^ args.b;
+    const _Bool result = val ? xor : !xor;
+    signal BoolTest.binaryDone(test_name, result, args);
+  }
+}

nregress/c99c11/boolgeneric/TestP.nc

@@ -0,0 +1,31 @@
+extern int printf(const char *__restrict format, ...);
+
+module TestP {
+  uses interface BoolTest;
+}
+implementation {
+  int main() @C() @spontaneous() {
+    bool_test_args args;
+
+    call BoolTest.unary(0);
+    call BoolTest.unary(1);
+    args.a = args.b = 0;
+    call BoolTest.binary(args);
+    args.b = 1;
+    call BoolTest.binary(args);
+    args.a = 1; args.b = 0;
+    call BoolTest.binary(args);
+    args.a = args.b = 1;
+    call BoolTest.binary(args);
+
+    return 0;
+  }
+
+  event void BoolTest.unaryDone(const char *test_name, _Bool result, _Bool arg) {
+    printf("%15s: %d -> %d\n", test_name, arg, result);
+  }
+
+  event void BoolTest.binaryDone(const char *test_name, _Bool result, bool_test_args args) {
+    printf("%15s: %d, %d -> %d\n", test_name, args.a, args.b, result);
+  }
+}

nregress/c99c11/boolgeneric/test.nc

@@ -0,0 +1,34 @@
+nx_struct nx_header {
+  nx_uint32_t src;
+  nx_uint32_t dst;
+};
+
+configuration test {
+}
+implementation {
+  components TestP;
+#define define_test(test_name, bool_expr)                               \
+  components new BoolTestM(bool_expr, #test_name) as Test##test_name;   \
+  Test##test_name <- TestP.BoolTest
+
+  define_test(TrueConst, 1);
+  define_test(TrueExpr, 1 == 1 && 0 < 1);
+  define_test(TrueExprSC, 0 == 0 || 0 > 1);
+  define_test(IntTrue, 1234);
+  define_test(FloatTrue, 1.23);
+  define_test(String, "string");
+
+  define_test(FalseConst, 0);
+  define_test(FalseExpr, 0 == 1 || 0 > 1);
+  define_test(FalseExprSC, 1 == 0 && 0 < 1);
+  define_test(IntZero, 0);
+  define_test(FloatZero, 0.0);
+  define_test(NullVoid, (const void *)0);
+  define_test(NullULL, (unsigned long long *)0);
+  define_test(NullStruct, (const bool_test_args *const __restrict)0);
+  define_test(NullFnP, (int (*)(char[], double))0);
+  define_test(Network, (nx_uint32_t *)0);
+  define_test(NetworkStruct, (nx_struct nx_header *)0);
+
+#undef define_test
+}

nregress/c99c11/boolinit/BoolInit.nc

@@ -0,0 +1,4 @@
+interface BoolInit {
+  command void test();
+  event void testDone(const char *test_name, _Bool value);
+}