Improve _Atomic support and add more tests

pycparser/c_parser.py

@@ -779,6 +779,13 @@ def p_declaration_specifiers_no_type_3(self, p):
         """
         p[0] = self._add_declaration_specifier(p[2], p[1], 'function')
 
+    # This is a bit ugly, but we need to process atomic specifier before qualifiers
+    # for _Atomic(x) in typedefs.
+    def p_declaration_specifiers_no_type_4(self, p):
+        """ declaration_specifiers_no_type  : atomic_specifier declaration_specifiers_no_type_opt
+        """
+        p[0] = self._add_declaration_specifier(p[2], p[1], 'type')
+
     def p_declaration_specifiers_1(self, p):
         """ declaration_specifiers  : declaration_specifiers type_qualifier
         """
@@ -841,17 +848,18 @@ def p_type_specifier_no_typeid(self, p):
         """
         p[0] = c_ast.IdentifierType([p[1]], coord=self._token_coord(p, 1))
 
-    def p_type_specifier_1(self, p):
+    def p_type_specifier(self, p):
         """ type_specifier  : typedef_name
                             | enum_specifier
                             | struct_or_union_specifier
                             | type_specifier_no_typeid
+                            | atomic_specifier
         """
         p[0] = p[1]
 
     # See section 6.7.2.4 of the C11 standard.
-    def p_type_specifier_2(self, p):
-        """ type_specifier  : _ATOMIC LPAREN type_name RPAREN
+    def p_atomic_specifier(self, p):
+        """ atomic_specifier  : _ATOMIC LPAREN type_name RPAREN
         """
         typ = p[3]
         typ.quals.append('_Atomic')

tests/c_files/c11.c

@@ -1,31 +1,38 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdnoreturn.h>
-#include <threads.h>
-#include <assert.h>
-
-/* C11 thread locals */
-_Thread_local int flag;
-thread_local int flag2;
-
-static_assert(sizeof(flag) == sizeof(flag2), "Really unexpected size difference");
-
-noreturn void func2(void)
-{
-  abort();
-}
-
-_Noreturn void func(void)
-{
-  func2();
-}
-
-int main()
-{
-  _Static_assert(sizeof(flag) == sizeof(flag2), "Unexpected size difference");
-  static_assert(sizeof(flag) == sizeof(flag2), "Unexpected size difference");
-
-  printf("Flag: %d\n", flag);
-  printf("Flag2: %d\n", flag2);
-  func();
-}
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdnoreturn.h>
+#include <threads.h>
+#include <assert.h>
+#include <stdatomic.h>
+
+/* C11 thread locals */
+_Thread_local int flag;
+thread_local int flag2;
+_Atomic int flag3;
+_Atomic(int) flag4;
+_Atomic(_Atomic(int) *) flag5;
+atomic_bool flag6;
+
+static_assert(sizeof(flag) == sizeof(flag2), "Really unexpected size difference");
+
+noreturn void func2(void)
+{
+  abort();
+}
+
+_Noreturn void func(void)
+{
+  func2();
+}
+
+int main()
+{
+  _Static_assert(sizeof(flag) == sizeof(flag2), "Unexpected size difference");
+  static_assert(sizeof(flag) == sizeof(flag2), "Unexpected size difference");
+  static_assert(sizeof(flag) == sizeof(flag3), "Unexpected size difference");
+  static_assert(sizeof(flag) == sizeof(flag4), "Unexpected size difference");
+
+  printf("Flag: %d\n", flag);
+  printf("Flag2: %d\n", flag2);
+  func();
+}

tests/test_c_generator.py

@@ -392,6 +392,28 @@ def test_atomic_qual(self):
         self.assertEqual(c3, '_Atomic int * _Atomic x;\n')
         self._assert_ctoc_correct(s3)
 
+        # FIXME: Regeneration with multiple qualifiers is not fully supported.
+        # REF: https://github.com/eliben/pycparser/issues/433
+        # self._assert_ctoc_correct('auto const _Atomic(int *) a;')
+
+        s4 = 'typedef _Atomic(int) atomic_int;'
+        c4 = self._run_c_to_c(s4)
+        self.assertEqual(c4, 'typedef _Atomic int atomic_int;\n')
+        self._assert_ctoc_correct(s4)
+
+        s5 = 'typedef _Atomic(_Atomic(_Atomic(int (*)(void)) *) *) t;'
+        c5 = self._run_c_to_c(s5)
+        self.assertEqual(c5, 'typedef int (* _Atomic * _Atomic * _Atomic t)(void);\n')
+        self._assert_ctoc_correct(s5)
+
+        self._assert_ctoc_correct(r'''
+            typedef struct node_t {
+                _Atomic(void*) a;
+                _Atomic(void) *b;
+                _Atomic void *c;
+            } node;
+            ''')
+
     def test_nested_sizeof(self):
         src = '1'
         for _ in range(30):

tests/test_c_parser.py

@@ -572,6 +572,20 @@ def test_atomic_specifier(self):
               'bar',
               ['TypeDecl', ['IdentifierType', ['int']]]])
 
+        # typedefs with _Atomic specifiers.
+        s = 'typedef _Atomic(int) atomic_int;'
+        self.assertEqual(self.get_decl(s, 0),
+            ['Typedef', 'atomic_int', ['TypeDecl', ['IdentifierType', ['int']]]])
+
+        s = 'typedef _Atomic(_Atomic(_Atomic(int (*)(void)) *) *) t;'
+        self.assertEqual(self.get_decl(s, 0),
+            ['Typedef', 't',
+             ['PtrDecl', ['_Atomic'],
+              ['PtrDecl', ['_Atomic'],
+               ['PtrDecl', ['_Atomic'],
+                ['FuncDecl', [['Typename', ['TypeDecl', ['IdentifierType', ['void']]]]],
+                 ['TypeDecl', ['IdentifierType', ['int']]]]]]]])
+
     def test_sizeof(self):
         e = """
             void foo()

utils/fake_libc_include/_fake_defines.h

@@ -236,4 +236,19 @@
 /* C11 assert.h defines */
 #define static_assert _Static_assert
 
+/* C11 stdatomic.h defines */
+#define ATOMIC_BOOL_LOCK_FREE       0
+#define ATOMIC_CHAR_LOCK_FREE       0
+#define ATOMIC_CHAR16_T_LOCK_FREE   0
+#define ATOMIC_CHAR32_T_LOCK_FREE   0
+#define ATOMIC_WCHAR_T_LOCK_FREE    0
+#define ATOMIC_SHORT_LOCK_FREE      0
+#define ATOMIC_INT_LOCK_FREE        0
+#define ATOMIC_LONG_LOCK_FREE       0
+#define ATOMIC_LLONG_LOCK_FREE      0
+#define ATOMIC_POINTER_LOCK_FREE    0
+#define ATOMIC_VAR_INIT(value) (value)
+#define ATOMIC_FLAG_INIT { 0 }
+#define kill_dependency(y) (y)
+
 #endif

utils/fake_libc_include/_fake_typedefs.h

@@ -169,4 +169,52 @@ typedef struct xcb_connection_t xcb_connection_t;
 typedef uint32_t xcb_window_t;
 typedef uint32_t xcb_visualid_t;
 
+/* C11 stdatomic.h types */
+typedef _Atomic(_Bool)              atomic_bool;
+typedef _Atomic(char)               atomic_char;
+typedef _Atomic(signed char)        atomic_schar;
+typedef _Atomic(unsigned char)      atomic_uchar;
+typedef _Atomic(short)              atomic_short;
+typedef _Atomic(unsigned short)     atomic_ushort;
+typedef _Atomic(int)                atomic_int;
+typedef _Atomic(unsigned int)       atomic_uint;
+typedef _Atomic(long)               atomic_long;
+typedef _Atomic(unsigned long)      atomic_ulong;
+typedef _Atomic(long long)          atomic_llong;
+typedef _Atomic(unsigned long long) atomic_ullong;
+typedef _Atomic(uint_least16_t)     atomic_char16_t;
+typedef _Atomic(uint_least32_t)     atomic_char32_t;
+typedef _Atomic(wchar_t)            atomic_wchar_t;
+typedef _Atomic(int_least8_t)       atomic_int_least8_t;
+typedef _Atomic(uint_least8_t)      atomic_uint_least8_t;
+typedef _Atomic(int_least16_t)      atomic_int_least16_t;
+typedef _Atomic(uint_least16_t)     atomic_uint_least16_t;
+typedef _Atomic(int_least32_t)      atomic_int_least32_t;
+typedef _Atomic(uint_least32_t)     atomic_uint_least32_t;
+typedef _Atomic(int_least64_t)      atomic_int_least64_t;
+typedef _Atomic(uint_least64_t)     atomic_uint_least64_t;
+typedef _Atomic(int_fast8_t)        atomic_int_fast8_t;
+typedef _Atomic(uint_fast8_t)       atomic_uint_fast8_t;
+typedef _Atomic(int_fast16_t)       atomic_int_fast16_t;
+typedef _Atomic(uint_fast16_t)      atomic_uint_fast16_t;
+typedef _Atomic(int_fast32_t)       atomic_int_fast32_t;
+typedef _Atomic(uint_fast32_t)      atomic_uint_fast32_t;
+typedef _Atomic(int_fast64_t)       atomic_int_fast64_t;
+typedef _Atomic(uint_fast64_t)      atomic_uint_fast64_t;
+typedef _Atomic(intptr_t)           atomic_intptr_t;
+typedef _Atomic(uintptr_t)          atomic_uintptr_t;
+typedef _Atomic(size_t)             atomic_size_t;
+typedef _Atomic(ptrdiff_t)          atomic_ptrdiff_t;
+typedef _Atomic(intmax_t)           atomic_intmax_t;
+typedef _Atomic(uintmax_t)          atomic_uintmax_t;
+typedef struct atomic_flag { atomic_bool _Value; } atomic_flag;
+typedef enum memory_order {
+  memory_order_relaxed,
+  memory_order_consume,
+  memory_order_acquire,
+  memory_order_release,
+  memory_order_acq_rel,
+  memory_order_seq_cst
+} memory_order;
+
 #endif

utils/fake_libc_include/stdatomic.h

@@ -0,0 +1,2 @@
+#include "_fake_defines.h"
+#include "_fake_typedefs.h"