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/bool/BoolDone.nc

@@ -0,0 +1,6 @@
+#include "BoolTest.h"
+
+interface BoolDone {
+    event void unaryDone(bool result, bool arg);
+    event void binaryDone(bool result, bool_test_args args);
+}

nregress/c99c11/bool/BoolDoneM.nc

@@ -0,0 +1,16 @@
+#include <stdio.h>
+
+#include "BoolTest.h"
+
+generic module BoolDoneM(const char testName[]) {
+    uses interface BoolDone;
+}
+implementation {
+    event void BoolDone.unaryDone(bool result, bool arg) {
+        printf("%10s: %d -> %d\n", testName, arg, result);
+    }
+
+    event void BoolDone.binaryDone(bool result, bool_test_args args) {
+        printf("%10s: %d, %d -> %d\n", testName, args.a, args.b, result);
+    }
+}

nregress/c99c11/bool/BoolTest.h

@@ -0,0 +1,11 @@
+#ifndef __BOOL_TEST_H__
+#define __BOOL_TEST_H__
+
+#include <stdbool.h>
+
+typedef struct {
+    bool a:1;
+    bool b;
+} bool_test_args;
+
+#endif

nregress/c99c11/bool/BoolTest.nc

@@ -0,0 +1,6 @@
+#include "BoolTest.h"
+
+interface BoolTest {
+    command void unary(const bool a);
+    command void binary(const bool_test_args args);
+}

nregress/c99c11/bool/BoolTestM.nc

@@ -0,0 +1,18 @@
+#include "BoolTest.h"
+
+generic module BoolTestM(bool val) {
+    provides interface BoolTest;
+    provides interface BoolDone;
+}
+implementation {
+    command void BoolTest.unary(const bool a) {
+        const bool result = val ? a : !a;
+        signal BoolDone.unaryDone(result, a);
+    }
+
+    command void BoolTest.binary(const bool_test_args args) {
+        const bool result = val ? args.a ^ args.b
+            : !(args.a ^ args.b);
+        signal BoolDone.binaryDone(result, args);
+    }
+}

nregress/c99c11/bool/TestP.nc

@@ -0,0 +1,25 @@
+#include <stdio.h>
+
+#include "BoolTest.h"
+
+module TestP {
+    uses interface BoolTest;
+}
+implementation {
+    int main() @C() @spontaneous() {
+        bool_test_args args;
+
+        call BoolTest.unary(false);
+        call BoolTest.unary(true);
+        args.a = args.b = false;
+        call BoolTest.binary(args);
+        args.b = true;
+        call BoolTest.binary(args);
+        args.a = true; args.b = false;
+        call BoolTest.binary(args);
+        args.a = args.b = true;
+        call BoolTest.binary(args);
+
+        return 0;
+    }
+}

nregress/c99c11/bool/test.nc

@@ -0,0 +1,24 @@
+#include "BoolTest.h"
+
+#include <stddef.h>
+
+configuration test {
+}
+implementation {
+    components TestP;
+#define define_test(test_name, bool_expr)                       \
+    components new BoolTestM(bool_expr) as Test##test_name;     \
+    components new BoolDoneM(#test_name) as Done##test_name;    \
+    Test##test_name <- TestP.BoolTest;                          \
+    Test##test_name <- Done##test_name.BoolDone
+
+    define_test(True, 1 == 1 && 0 < 1);
+    define_test(False, 0 == 1 || 0 > 1);
+    define_test(Null, NULL);
+    define_test(IntTrue, 1234);
+    define_test(IntZero, 0);
+    define_test(FloatTrue, 1.23);
+    define_test(FloatZero, 0.0);
+
+#undef define_test
+}

nregress/ok/c99c11.bool.1

@@ -0,0 +1,42 @@
+      True: 0 -> 0
+     False: 0 -> 1
+      Null: 0 -> 1
+   IntTrue: 0 -> 0
+   IntZero: 0 -> 1
+ FloatTrue: 0 -> 0
+ FloatZero: 0 -> 1
+      True: 1 -> 1
+     False: 1 -> 0
+      Null: 1 -> 0
+   IntTrue: 1 -> 1
+   IntZero: 1 -> 0
+ FloatTrue: 1 -> 1
+ FloatZero: 1 -> 0
+      True: 0, 0 -> 0
+     False: 0, 0 -> 1
+      Null: 0, 0 -> 1
+   IntTrue: 0, 0 -> 0
+   IntZero: 0, 0 -> 1
+ FloatTrue: 0, 0 -> 0
+ FloatZero: 0, 0 -> 1
+      True: 0, 1 -> 1
+     False: 0, 1 -> 0
+      Null: 0, 1 -> 0
+   IntTrue: 0, 1 -> 1
+   IntZero: 0, 1 -> 0
+ FloatTrue: 0, 1 -> 1
+ FloatZero: 0, 1 -> 0
+      True: 1, 0 -> 1
+     False: 1, 0 -> 0
+      Null: 1, 0 -> 0
+   IntTrue: 1, 0 -> 1
+   IntZero: 1, 0 -> 0
+ FloatTrue: 1, 0 -> 1
+ FloatZero: 1, 0 -> 0
+      True: 1, 1 -> 0
+     False: 1, 1 -> 1
+      Null: 1, 1 -> 1
+   IntTrue: 1, 1 -> 0
+   IntZero: 1, 1 -> 1
+ FloatTrue: 1, 1 -> 0
+ FloatZero: 1, 1 -> 1

nregress/ok/c99c11.bool.2

@@ -0,0 +1,2 @@
+In component `test':
+test.nc:17: warning: passing argument 1 of `TestNull' makes integer from pointer without a cast