Most keywords have a variant with the leading nd trailing
double-underscore. Some have also a variant with only the
leading underscores. But only the identifier change, the
remaining of the information is duplicated for them.
So, use some macros to define the corresponding entries
without duplication.
Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@xxxxxxxxx>
---
parse.c | 223 +++++++++++++++++++++++++-------------------------------
1 file changed, 98 insertions(+), 125 deletions(-)
diff --git a/parse.c b/parse.c
index c18a9e66e0a8..188b7485c61b 100644
--- a/parse.c
+++ b/parse.c
@@ -460,6 +460,12 @@ static struct symbol_op mode_word_op = {
* The entries in the 'typedef' and put in NS_TYPEDEF and
* are automatically set as reserved keyword while the ones
* in the 'keyword' table are just put in NS_KEYWORD.
+ *
+ * The entries are added via the 3 macros:
+ * N() for entries with "name" only,
+ * D() for entries with "name" & "__name__",
+ * A() for entries with "name", "__name" & "__name__",
+ * U() for entries with "__name" & "__name__".
*/
static struct init_keyword {
const char *name;
@@ -467,147 +473,114 @@ static struct init_keyword {
struct symbol *type;
unsigned long mods;
} typedefs[] = {
+#define N(I, O,...) { I, O,##__VA_ARGS__ }
+#define D(I, O,...) N(I,O,##__VA_ARGS__ ), \
+ N("__" I "__",O,##__VA_ARGS__)
+#define A(I, O,...) N(I,O,##__VA_ARGS__ ), \
+ N("__" I,O,##__VA_ARGS__), \
+ N("__" I "__",O,##__VA_ARGS__)
+#define U(I, O,...) N("__" I,O,##__VA_ARGS__), \
+ N("__" I "__",O,##__VA_ARGS__)
/* Storage classes */
- { "auto", &auto_op },
- { "register", ®ister_op },
- { "static", &static_op },
- { "extern", &extern_op },
- { "__thread", &thread_op },
- { "_Thread_local", &thread_op },
+ N("auto", &auto_op),
+ N("register", ®ister_op),
+ N("static", &static_op),
+ N("extern", &extern_op),
+ N("__thread", &thread_op),
+ N("_Thread_local", &thread_op),
- { "inline", &inline_op },
- { "__inline__", &inline_op },
- { "__inline", &inline_op },
+ A("inline", &inline_op),
/* Typedef ... */
- { "typedef", &typedef_op },
- { "typeof", &typeof_op },
- { "__typeof__", &typeof_op },
- { "__typeof", &typeof_op },
- { "__auto_type", &autotype_op },
+ N("typedef", &typedef_op),
+ A("typeof", &typeof_op),
+ N("__auto_type", &autotype_op),
/* Type qualifiers */
- { "const", &const_op },
- { "__const__", &const_op },
- { "__const", &const_op },
- { "volatile", &volatile_op },
- { "__volatile__", &volatile_op },
- { "__volatile", &volatile_op },
- { "restrict", &restrict_op },
- { "__restrict__", &restrict_op },
- { "__restrict", &restrict_op },
-
- { "_Atomic", &atomic_op },
- { "_Noreturn", &noreturn_op },
- { "_Alignas", &alignas_op },
-
- { "__attribute__", &attribute_op },
- { "__attribute", &attribute_op },
+ A("const", &const_op),
+ A("volatile", &volatile_op),
+ A("restrict", &restrict_op),
+
+ N("_Atomic", &atomic_op),
+ N("_Noreturn", &noreturn_op),
+ N("_Alignas", &alignas_op),
+
+ U("attribute", &attribute_op),
/* Type specifiers */
- { "struct", &struct_op },
- { "union", &union_op },
- { "enum", &enum_op },
-
- { "void", &spec_op, .type = &void_ctype },
- { "char", &char_op },
- { "short", &short_op },
- { "int", &int_op },
- { "long", &long_op },
- { "float", &float_op },
- { "double", &double_op },
- { "signed", &signed_op },
- { "__signed__", &signed_op },
- { "__signed", &signed_op },
- { "unsigned", &unsigned_op },
- { "__int128", &int128_op },
- { "_Bool", &spec_op, .type = &bool_ctype },
+ N("struct", &struct_op),
+ N("union", &union_op),
+ N("enum", &enum_op),
+
+ N("void", &spec_op, .type = &void_ctype),
+ N("char", &char_op),
+ N("short", &short_op),
+ N("int", &int_op),
+ N("long", &long_op),
+ N("float", &float_op),
+ N("double", &double_op),
+ A("signed", &signed_op),
+ N("unsigned", &unsigned_op),
+ N("__int128", &int128_op),
+ N("_Bool", &spec_op, .type = &bool_ctype),
/* Predeclared types */
- { "__builtin_va_list", &spec_op, .type = &ptr_ctype },
- { "__builtin_ms_va_list",&spec_op, .type = &ptr_ctype },
- { "__int128_t", &spec_op, .type = &sint128_ctype },
- { "__uint128_t", &spec_op, .type = &uint128_ctype },
- { "_Float32", &spec_op, .type = &float32_ctype },
- { "_Float32x", &spec_op, .type = &float32x_ctype },
- { "_Float64", &spec_op, .type = &float64_ctype },
- { "_Float64x", &spec_op, .type = &float64x_ctype },
- { "_Float128", &spec_op, .type = &float128_ctype },
+ N("__builtin_va_list", &spec_op, .type = &ptr_ctype),
+ N("__builtin_ms_va_list",&spec_op, .type = &ptr_ctype),
+ N("__int128_t", &spec_op, .type = &sint128_ctype),
+ N("__uint128_t", &spec_op, .type = &uint128_ctype),
+ N("_Float32", &spec_op, .type = &float32_ctype),
+ N("_Float32x", &spec_op, .type = &float32x_ctype),
+ N("_Float64", &spec_op, .type = &float64_ctype),
+ N("_Float64x", &spec_op, .type = &float64x_ctype),
+ N("_Float128", &spec_op, .type = &float128_ctype),
}, keywords[] = {
/* Statements */
- { "if", &if_op },
- { "return", &return_op },
- { "break", &loop_iter_op },
- { "continue", &loop_iter_op },
- { "default", &default_op },
- { "case", &case_op },
- { "switch", &switch_op },
- { "for", &for_op },
- { "while", &while_op },
- { "do", &do_op },
- { "goto", &goto_op },
- { "asm", &asm_op },
- { "__asm__", &asm_op },
- { "__asm", &asm_op },
- { "context", &context_op },
- { "__context__", &__context___op },
- { "__range__", &range_op },
- { "_Static_assert", &static_assert_op },
+ N("if", &if_op),
+ N("return", &return_op),
+ N("break", &loop_iter_op),
+ N("continue", &loop_iter_op),
+ N("default", &default_op),
+ N("case", &case_op),
+ N("switch", &switch_op),
+ N("for", &for_op),
+ N("while", &while_op),
+ N("do", &do_op),
+ N("goto", &goto_op),
+ A("asm", &asm_op),
+ N("context", &context_op),
+ N("__context__", &__context___op),
+ N("__range__", &range_op),
+ N("_Static_assert", &static_assert_op),
/* Attributes */
- { "packed", &packed_op },
- { "__packed__", &packed_op },
- { "aligned", &aligned_op },
- { "__aligned__", &aligned_op },
- { "nocast", &attr_mod_op, .mods = MOD_NOCAST },
- { "__nocast__", &attr_mod_op, .mods = MOD_NOCAST },
- { "noderef", &attr_mod_op, .mods = MOD_NODEREF },
- { "__noderef__", &attr_mod_op, .mods = MOD_NODEREF },
- { "safe", &attr_mod_op, .mods = MOD_SAFE },
- { "__safe__", &attr_mod_op, .mods = MOD_SAFE },
- { "unused", &attr_mod_op, .mods = MOD_UNUSED },
- { "__unused__", &attr_mod_op, .mods = MOD_UNUSED },
- { "externally_visible",&attr_mod_op, .mods = MOD_EXT_VISIBLE },
- { "__externally_visible__",&attr_mod_op, .mods = MOD_EXT_VISIBLE },
- { "force", &attr_force_op },
- { "__force__", &attr_force_op },
- { "bitwise", &attr_bitwise_op, .mods = MOD_BITWISE },
- { "__bitwise__", &attr_bitwise_op, .mods = MOD_BITWISE },
- { "address_space", &address_space_op },
- { "__address_space__", &address_space_op },
- { "designated_init", &designated_init_op },
- { "__designated_init__",&designated_init_op },
- { "transparent_union", &transparent_union_op },
- { "__transparent_union__",&transparent_union_op },
- { "noreturn", &attr_fun_op, .mods = MOD_NORETURN },
- { "__noreturn__", &attr_fun_op, .mods = MOD_NORETURN },
- { "pure", &attr_fun_op, .mods = MOD_PURE },
- { "__pure__", &attr_fun_op, .mods = MOD_PURE },
- { "const", &attr_fun_op, .mods = MOD_PURE },
- { "__const__", &attr_fun_op, .mods = MOD_PURE },
- { "__const", &attr_fun_op, .mods = MOD_PURE },
- { "gnu_inline", &attr_fun_op, .mods = MOD_GNU_INLINE },
- { "__gnu_inline__", &attr_fun_op, .mods = MOD_GNU_INLINE },
+ D("packed", &packed_op),
+ D("aligned", &aligned_op),
+ D("nocast", &attr_mod_op, .mods = MOD_NOCAST),
+ D("noderef", &attr_mod_op, .mods = MOD_NODEREF),
+ D("safe", &attr_mod_op, .mods = MOD_SAFE),
+ D("unused", &attr_mod_op, .mods = MOD_UNUSED),
+ D("externally_visible", &attr_mod_op, .mods = MOD_EXT_VISIBLE),
+ D("force", &attr_force_op),
+ D("bitwise", &attr_bitwise_op, .mods = MOD_BITWISE),
+ D("address_space", &address_space_op),
+ D("designated_init", &designated_init_op),
+ D("transparent_union", &transparent_union_op),
+ D("noreturn", &attr_fun_op, .mods = MOD_NORETURN),
+ D("pure", &attr_fun_op, .mods = MOD_PURE),
+ A("const", &attr_fun_op, .mods = MOD_PURE),
+ D("gnu_inline", &attr_fun_op, .mods = MOD_GNU_INLINE),
/* Modes */
- { "mode", &mode_op },
- { "__mode__", &mode_op },
- { "QI", &mode_QI_op },
- { "__QI__", &mode_QI_op },
- { "HI", &mode_HI_op },
- { "__HI__", &mode_HI_op },
- { "SI", &mode_SI_op },
- { "__SI__", &mode_SI_op },
- { "DI", &mode_DI_op },
- { "__DI__", &mode_DI_op },
- { "TI", &mode_TI_op },
- { "__TI__", &mode_TI_op },
- { "byte", &mode_QI_op },
- { "__byte__", &mode_QI_op },
- { "pointer", &mode_pointer_op },
- { "__pointer__", &mode_pointer_op },
- { "word", &mode_word_op },
- { "__word__", &mode_word_op },
+ D("mode", &mode_op),
+ D("QI", &mode_QI_op),
+ D("HI", &mode_HI_op),
+ D("SI", &mode_SI_op),
+ D("DI", &mode_DI_op),
+ D("TI", &mode_TI_op),
+ D("byte", &mode_QI_op),
+ D("pointer", &mode_pointer_op),
+ D("word", &mode_word_op),
};
--
2.27.0
