lib: rename include dir to babeltrace2

[babeltrace.git] / plugins / ctf / common / metadata / parser.y

diff --git a/plugins/ctf/common/metadata/parser.y b/plugins/ctf/common/metadata/parser.y
index 24cc902a614ddc939d0693a00150471caf7648b9..4e666dbb98e7885ebc0a6f3e21d91e3adefe0f39 100644 (file)
--- a/plugins/ctf/common/metadata/parser.y
+++ b/plugins/ctf/common/metadata/parser.y
@@ -25,6 +25,9 @@
  * SOFTWARE.
  */
 
+#define BT_LOG_TAG "PLUGIN-CTF-METADATA-PARSER"
+#include "logging.h"
+
 #include <stdio.h>
 #include <ctype.h>
 #include <unistd.h>
@@ -34,15 +37,19 @@
 #include <glib.h>
 #include <errno.h>
 #include <inttypes.h>
-#include <babeltrace/list-internal.h>
-#include <babeltrace/babeltrace-internal.h>
+#include <babeltrace2/list-internal.h>
+#include <babeltrace2/assert-internal.h>
 #include "scanner.h"
 #include "parser.h"
 #include "ast.h"
 #include "objstack.h"
 
-BT_HIDDEN
-int yydebug;
+#if BT_LOG_ENABLED_VERBOSE
+# define YYDEBUG 1
+# define YYFPRINTF(_stream, _fmt, args...) BT_LOGV(_fmt, ## args)
+#else
+# define YYDEBUG 0
+#endif
 
 /* Join two lists, put "add" at the end of "head".  */
 static inline void
@@ -157,7 +164,7 @@ int parse_base_sequence(const char *src, size_t len, size_t pos,
                        return -1;
                }
        }
-       assert(nr_char > 0);
+       BT_ASSERT(nr_char > 0);
        buffer[nr_char] = '\0';
        *buf_len = nr_char;
        return 0;
@@ -284,8 +291,9 @@ int import_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
        lvalp->s = objstack_alloc(scanner->objstack, len);
        if (src[0] == 'L') {
                // TODO: import wide string
-               printfl_error(yyget_lineno(scanner),
-                       "Wide string not supported yet.");
+               _BT_LOGE_LINENO(yyget_lineno(scanner),
+                       "wide characters are not supported as of this version: "
+                       "scanner-addr=%p", scanner);
                return -1;
        } else {
                return import_basic_string(scanner, lvalp, len, src, delim);
@@ -296,20 +304,20 @@ static void init_scope(struct ctf_scanner_scope *scope,
                       struct ctf_scanner_scope *parent)
 {
        scope->parent = parent;
-       scope->types = g_hash_table_new_full(g_str_hash, g_str_equal,
+       scope->classes = g_hash_table_new_full(g_str_hash, g_str_equal,
                                             NULL, NULL);
 }
 
 static void finalize_scope(struct ctf_scanner_scope *scope)
 {
-       g_hash_table_destroy(scope->types);
+       g_hash_table_destroy(scope->classes);
 }
 
 static void push_scope(struct ctf_scanner *scanner)
 {
        struct ctf_scanner_scope *ns;
 
-       printf_debug("push scope\n");
+       BT_LOGV("Pushing scope: scanner-addr=%p", scanner);
        ns = malloc(sizeof(struct ctf_scanner_scope));
        init_scope(ns, scanner->cs);
        scanner->cs = ns;
@@ -319,7 +327,7 @@ static void pop_scope(struct ctf_scanner *scanner)
 {
        struct ctf_scanner_scope *os;
 
-       printf_debug("pop scope\n");
+       BT_LOGV("Popping scope: scanner-addr=%p", scanner);
        os = scanner->cs;
        scanner->cs = os->parent;
        finalize_scope(os);
@@ -330,8 +338,9 @@ static int lookup_type(struct ctf_scanner_scope *s, const char *id)
 {
        int ret;
 
-       ret = GPOINTER_TO_INT(g_hash_table_lookup(s->types, id));
-       printf_debug("lookup %p %s %d\n", s, id, ret);
+       ret = GPOINTER_TO_INT(g_hash_table_lookup(s->classes, id));
+       BT_LOGV("Looked up type: scanner-addr=%p, id=\"%s\", ret=%d",
+               s, id, ret);
        return ret;
 }
 
@@ -347,16 +356,18 @@ int is_type(struct ctf_scanner *scanner, const char *id)
                        break;
                }
        }
-       printf_debug("is type %s %d\n", id, ret);
+       BT_LOGV("Found if ID is type: scanner-addr=%p, id=\"%s\", ret=%d",
+               scanner, id, ret);
        return ret;
 }
 
 static void add_type(struct ctf_scanner *scanner, char *id)
 {
-       printf_debug("add type %s\n", id);
+       BT_LOGV("Adding type: scanner-addr=%p, id=\"%s\"",
+               scanner, id);
        if (lookup_type(scanner->cs, id))
                return;
-       g_hash_table_insert(scanner->cs->types, id, id);
+       g_hash_table_insert(scanner->cs->classes, id, id);
 }
 
 static struct ctf_node *make_node(struct ctf_scanner *scanner,
@@ -366,7 +377,9 @@ static struct ctf_node *make_node(struct ctf_scanner *scanner,
 
        node = objstack_alloc(scanner->objstack, sizeof(*node));
        if (!node) {
-               printfl_fatal(yyget_lineno(scanner->scanner), "out of memory");
+               _BT_LOGE_LINENO(yyget_lineno(scanner->scanner),
+                       "failed to allocate one stack entry: "
+                       "scanner-addr=%p", scanner);
                return &error_node;
        }
        node->type = type;
@@ -377,9 +390,9 @@ static struct ctf_node *make_node(struct ctf_scanner *scanner,
        switch (type) {
        case NODE_ROOT:
                node->type = NODE_ERROR;
-               printfn_fatal(node, "trying to create root node");
+               BT_LOGE("Trying to create root node: scanner-addr=%p",
+                       scanner);
                break;
-
        case NODE_EVENT:
                BT_INIT_LIST_HEAD(&node->u.event.declaration_list);
                break;
@@ -398,37 +411,33 @@ static struct ctf_node *make_node(struct ctf_scanner *scanner,
        case NODE_CALLSITE:
                BT_INIT_LIST_HEAD(&node->u.callsite.declaration_list);
                break;
-
        case NODE_CTF_EXPRESSION:
                BT_INIT_LIST_HEAD(&node->u.ctf_expression.left);
                BT_INIT_LIST_HEAD(&node->u.ctf_expression.right);
                break;
        case NODE_UNARY_EXPRESSION:
                break;
-
        case NODE_TYPEDEF:
-               BT_INIT_LIST_HEAD(&node->u._typedef.type_declarators);
+               BT_INIT_LIST_HEAD(&node->u.field_class_def.field_class_declarators);
                break;
        case NODE_TYPEALIAS_TARGET:
-               BT_INIT_LIST_HEAD(&node->u.typealias_target.type_declarators);
+               BT_INIT_LIST_HEAD(&node->u.field_class_alias_target.field_class_declarators);
                break;
        case NODE_TYPEALIAS_ALIAS:
-               BT_INIT_LIST_HEAD(&node->u.typealias_alias.type_declarators);
+               BT_INIT_LIST_HEAD(&node->u.field_class_alias_name.field_class_declarators);
                break;
        case NODE_TYPEALIAS:
                break;
-
        case NODE_TYPE_SPECIFIER:
                break;
        case NODE_TYPE_SPECIFIER_LIST:
-               BT_INIT_LIST_HEAD(&node->u.type_specifier_list.head);
+               BT_INIT_LIST_HEAD(&node->u.field_class_specifier_list.head);
                break;
        case NODE_POINTER:
                break;
        case NODE_TYPE_DECLARATOR:
-               BT_INIT_LIST_HEAD(&node->u.type_declarator.pointers);
+               BT_INIT_LIST_HEAD(&node->u.field_class_declarator.pointers);
                break;
-
        case NODE_FLOATING_POINT:
                BT_INIT_LIST_HEAD(&node->u.floating_point.expressions);
                break;
@@ -445,7 +454,7 @@ static struct ctf_node *make_node(struct ctf_scanner *scanner,
                BT_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
                break;
        case NODE_STRUCT_OR_VARIANT_DECLARATION:
-               BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.type_declarators);
+               BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.field_class_declarators);
                break;
        case NODE_VARIANT:
                BT_INIT_LIST_HEAD(&node->u.variant.declaration_list);
@@ -454,11 +463,11 @@ static struct ctf_node *make_node(struct ctf_scanner *scanner,
                BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
                BT_INIT_LIST_HEAD(&node->u._struct.min_align);
                break;
-
        case NODE_UNKNOWN:
        default:
                node->type = NODE_ERROR;
-               printfn_fatal(node, "unknown node type '%d'", (int) type);
+               BT_LOGE("Unknown node type: scanner-addr=%p, node-type=%d",
+                       scanner, type);
                break;
        }
 
@@ -517,7 +526,7 @@ static int reparent_ctf_expression(struct ctf_node *node,
 
        case NODE_UNKNOWN:
        default:
-               printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
+               BT_LOGE("Unknown node type: node-type=%d", parent->type);
                return -EINVAL;
        }
        return 0;
@@ -574,13 +583,13 @@ static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
 
        case NODE_UNKNOWN:
        default:
-               printfn_fatal(node, "unknown node type %d", parent->type);
+               BT_LOGE("Unknown node type: node-type=%d", parent->type);
                return -EINVAL;
        }
        return 0;
 }
 
-static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
+static int reparent_field_class_alias(struct ctf_node *node, struct ctf_node *parent)
 {
        switch (parent->type) {
        case NODE_ROOT:
@@ -631,18 +640,18 @@ static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
 
        case NODE_UNKNOWN:
        default:
-               printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
+               BT_LOGE("Unknown node type: node-type=%d", parent->type);
                return -EINVAL;
        }
        return 0;
 }
 
-static int reparent_type_specifier(struct ctf_node *node,
+static int reparent_field_class_specifier(struct ctf_node *node,
                                   struct ctf_node *parent)
 {
        switch (parent->type) {
        case NODE_TYPE_SPECIFIER_LIST:
-               _bt_list_splice_tail(&node->tmp_head, &parent->u.type_specifier_list.head);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_specifier_list.head);
                break;
 
        case NODE_TYPE_SPECIFIER:
@@ -672,13 +681,13 @@ static int reparent_type_specifier(struct ctf_node *node,
 
        case NODE_UNKNOWN:
        default:
-               printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
+               BT_LOGE("Unknown node type: node-type=%d", parent->type);
                return -EINVAL;
        }
        return 0;
 }
 
-static int reparent_type_specifier_list(struct ctf_node *node,
+static int reparent_field_class_specifier_list(struct ctf_node *node,
                                        struct ctf_node *parent)
 {
        switch (parent->type) {
@@ -710,19 +719,19 @@ static int reparent_type_specifier_list(struct ctf_node *node,
                bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
                break;
        case NODE_TYPEDEF:
-               parent->u._typedef.type_specifier_list = node;
+               parent->u.field_class_def.field_class_specifier_list = node;
                break;
        case NODE_TYPEALIAS_TARGET:
-               parent->u.typealias_target.type_specifier_list = node;
+               parent->u.field_class_alias_target.field_class_specifier_list = node;
                break;
        case NODE_TYPEALIAS_ALIAS:
-               parent->u.typealias_alias.type_specifier_list = node;
+               parent->u.field_class_alias_name.field_class_specifier_list = node;
                break;
        case NODE_ENUM:
-               parent->u._enum.container_type = node;
+               parent->u._enum.container_field_class = node;
                break;
        case NODE_STRUCT_OR_VARIANT_DECLARATION:
-               parent->u.struct_or_variant_declaration.type_specifier_list = node;
+               parent->u.struct_or_variant_declaration.field_class_specifier_list = node;
                break;
        case NODE_TYPE_DECLARATOR:
        case NODE_TYPE_SPECIFIER:
@@ -738,31 +747,31 @@ static int reparent_type_specifier_list(struct ctf_node *node,
 
        case NODE_UNKNOWN:
        default:
-               printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
+               BT_LOGE("Unknown node type: node-type=%d", parent->type);
                return -EINVAL;
        }
        return 0;
 }
 
-static int reparent_type_declarator(struct ctf_node *node,
+static int reparent_field_class_declarator(struct ctf_node *node,
                                    struct ctf_node *parent)
 {
        switch (parent->type) {
        case NODE_TYPE_DECLARATOR:
-               parent->u.type_declarator.type = TYPEDEC_NESTED;
-               parent->u.type_declarator.u.nested.type_declarator = node;
+               parent->u.field_class_declarator.type = TYPEDEC_NESTED;
+               parent->u.field_class_declarator.u.nested.field_class_declarator = node;
                break;
        case NODE_STRUCT_OR_VARIANT_DECLARATION:
-               _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.type_declarators);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.field_class_declarators);
                break;
        case NODE_TYPEDEF:
-               _bt_list_splice_tail(&node->tmp_head, &parent->u._typedef.type_declarators);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_def.field_class_declarators);
                break;
        case NODE_TYPEALIAS_TARGET:
-               _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.type_declarators);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_alias_target.field_class_declarators);
                break;
        case NODE_TYPEALIAS_ALIAS:
-               _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.type_declarators);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_alias_name.field_class_declarators);
                break;
 
        case NODE_ROOT:
@@ -789,7 +798,7 @@ static int reparent_type_declarator(struct ctf_node *node,
 
        case NODE_UNKNOWN:
        default:
-               printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
+               BT_LOGE("Unknown node type: node-type=%d", parent->type);
                return -EINVAL;
        }
        return 0;
@@ -812,7 +821,7 @@ static int set_parent_node(struct ctf_node *node,
 
        switch (node->type) {
        case NODE_ROOT:
-               printfn_fatal(node, "trying to reparent root node");
+               BT_LOGE_STR("Trying to reparent root node.");
                return -EINVAL;
 
        case NODE_EVENT:
@@ -862,7 +871,7 @@ static int set_parent_node(struct ctf_node *node,
                return reparent_ctf_expression(node, parent);
        case NODE_UNARY_EXPRESSION:
                if (parent->type == NODE_TYPE_DECLARATOR)
-                       parent->u.type_declarator.bitfield_len = node;
+                       parent->u.field_class_declarator.bitfield_len = node;
                else
                        return -EPERM;
                break;
@@ -871,31 +880,33 @@ static int set_parent_node(struct ctf_node *node,
                return reparent_typedef(node, parent);
        case NODE_TYPEALIAS_TARGET:
                if (parent->type == NODE_TYPEALIAS)
-                       parent->u.typealias.target = node;
+                       parent->u.field_class_alias.target = node;
                else
                        return -EINVAL;
+               /* fall-through */
        case NODE_TYPEALIAS_ALIAS:
                if (parent->type == NODE_TYPEALIAS)
-                       parent->u.typealias.alias = node;
+                       parent->u.field_class_alias.alias = node;
                else
                        return -EINVAL;
+               /* fall-through */
        case NODE_TYPEALIAS:
-               return reparent_typealias(node, parent);
+               return reparent_field_class_alias(node, parent);
 
        case NODE_POINTER:
                if (parent->type == NODE_TYPE_DECLARATOR) {
-                       _bt_list_splice_tail(&node->tmp_head, &parent->u.type_declarator.pointers);
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_declarator.pointers);
                } else
                        return -EPERM;
                break;
        case NODE_TYPE_DECLARATOR:
-               return reparent_type_declarator(node, parent);
+               return reparent_field_class_declarator(node, parent);
 
        case NODE_TYPE_SPECIFIER_LIST:
-               return reparent_type_specifier_list(node, parent);
+               return reparent_field_class_specifier_list(node, parent);
 
        case NODE_TYPE_SPECIFIER:
-               return reparent_type_specifier(node, parent);
+               return reparent_field_class_specifier(node, parent);
 
        case NODE_FLOATING_POINT:
        case NODE_INTEGER:
@@ -927,7 +938,7 @@ static int set_parent_node(struct ctf_node *node,
 
        case NODE_UNKNOWN:
        default:
-               printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
+               BT_LOGE("Unknown node type: node-type=%d", parent->type);
                return -EINVAL;
        }
        return 0;
@@ -936,9 +947,8 @@ static int set_parent_node(struct ctf_node *node,
 BT_HIDDEN
 void yyerror(struct ctf_scanner *scanner, yyscan_t yyscanner, const char *str)
 {
-       printfl_error(yyget_lineno(scanner->scanner),
-               "token \"%s\": %s\n",
-               yyget_text(scanner->scanner), str);
+       _BT_LOGE_LINENO(yyget_lineno(scanner->scanner),
+               "%s: token=\"%s\"", str, yyget_text(scanner->scanner));
 }
 
 BT_HIDDEN
@@ -976,10 +986,6 @@ int ctf_scanner_append_ast(struct ctf_scanner *scanner, FILE *input)
 {
        /* Start processing new stream */
        yyrestart(input, scanner->scanner);
-       if (yydebug)
-               fprintf(stdout, "Scanner input is a%s.\n",
-                       isatty(fileno(input)) ? "n interactive tty" :
-                                               " noninteractive file");
        return yyparse(scanner, scanner->scanner);
 }
 
@@ -988,15 +994,13 @@ struct ctf_scanner *ctf_scanner_alloc(void)
        struct ctf_scanner *scanner;
        int ret;
 
-       yydebug = babeltrace_debug;
-
        scanner = malloc(sizeof(*scanner));
        if (!scanner)
                return NULL;
        memset(scanner, 0, sizeof(*scanner));
        ret = yylex_init_extra(scanner, &scanner->scanner);
        if (ret) {
-               printf_fatal("yylex_init error");
+               BT_LOGE("yylex_init_extra() failed: ret=%d", ret);
                goto cleanup_scanner;
        }
        scanner->objstack = objstack_create();
@@ -1015,7 +1019,8 @@ cleanup_objstack:
 cleanup_lexer:
        ret = yylex_destroy(scanner->scanner);
        if (!ret)
-               printf_fatal("yylex_destroy error");
+               BT_LOGE("yylex_destroy() failed: scanner-addr=%p, ret=%d",
+                       scanner, ret);
 cleanup_scanner:
        free(scanner);
        return NULL;
@@ -1031,7 +1036,8 @@ void ctf_scanner_free(struct ctf_scanner *scanner)
        objstack_destroy(scanner->objstack);
        ret = yylex_destroy(scanner->scanner);
        if (ret)
-               printf_error("yylex_destroy error");
+               BT_LOGE("yylex_destroy() failed: scanner-addr=%p, ret=%d",
+                       scanner, ret);
        free(scanner);
 }
 
@@ -1053,9 +1059,9 @@ void ctf_scanner_free(struct ctf_scanner *scanner)
  */
 %expect 2
 %start file
-%token INTEGER_LITERAL STRING_LITERAL CHARACTER_LITERAL LSBRAC RSBRAC LPAREN RPAREN LBRAC RBRAC RARROW STAR PLUS MINUS LT GT TYPEASSIGN COLON SEMICOLON DOTDOTDOT DOT EQUAL COMMA CONST CHAR DOUBLE ENUM ENV EVENT FLOATING_POINT FLOAT INTEGER INT LONG SHORT SIGNED STREAM STRING STRUCT TRACE CALLSITE CLOCK TYPEALIAS TYPEDEF UNSIGNED VARIANT VOID _BOOL _COMPLEX _IMAGINARY TOK_ALIGN
+%token CTF_INTEGER_LITERAL CTF_STRING_LITERAL CTF_CHARACTER_LITERAL CTF_LSBRAC CTF_RSBRAC CTF_LPAREN CTF_RPAREN CTF_LBRAC CTF_RBRAC CTF_RARROW CTF_STAR CTF_PLUS CTF_MINUS CTF_LT CTF_GT CTF_TYPEASSIGN CTF_COLON CTF_SEMICOLON CTF_DOTDOTDOT CTF_DOT CTF_EQUAL CTF_COMMA CTF_CONST CTF_CHAR CTF_DOUBLE CTF_ENUM CTF_ENV CTF_EVENT CTF_FLOATING_POINT CTF_FLOAT CTF_INTEGER CTF_INT CTF_LONG CTF_SHORT CTF_SIGNED CTF_STREAM CTF_STRING CTF_STRUCT CTF_TRACE CTF_CALLSITE CTF_CLOCK CTF_TYPEALIAS CTF_TYPEDEF CTF_UNSIGNED CTF_VARIANT CTF_VOID CTF_BOOL CTF_COMPLEX CTF_IMAGINARY CTF_TOK_ALIGN
 %token <s> IDENTIFIER ID_TYPE
-%token ERROR
+%token CTF_ERROR
 %union
 {
        long long ll;
@@ -1065,11 +1071,11 @@ void ctf_scanner_free(struct ctf_scanner *scanner)
        struct ctf_node *n;
 }
 
-%type <s> STRING_LITERAL CHARACTER_LITERAL
+%type <s> CTF_STRING_LITERAL CTF_CHARACTER_LITERAL
 
 %type <s> keywords
 
-%type <ull> INTEGER_LITERAL
+%type <ull> CTF_INTEGER_LITERAL
 %type <n> postfix_expression unary_expression unary_expression_or_range
 
 %type <n> declaration
@@ -1083,12 +1089,12 @@ void ctf_scanner_free(struct ctf_scanner *scanner)
 %type <n> declaration_specifiers
 %type <n> alias_declaration_specifiers
 
-%type <n> type_declarator_list
-%type <n> integer_type_specifier
-%type <n> type_specifier
-%type <n> struct_type_specifier
-%type <n> variant_type_specifier
-%type <n> enum_type_specifier
+%type <n> field_class_declarator_list
+%type <n> integer_field_class_specifier
+%type <n> field_class_specifier
+%type <n> struct_class_specifier
+%type <n> variant_field_class_specifier
+%type <n> enum_field_class_specifier
 %type <n> struct_or_variant_declaration_list
 %type <n> struct_or_variant_declaration
 %type <n> struct_or_variant_declarator_list
@@ -1103,8 +1109,8 @@ void ctf_scanner_free(struct ctf_scanner *scanner)
 %type <n> direct_alias_abstract_declarator
 %type <n> declarator
 %type <n> direct_declarator
-%type <n> type_declarator
-%type <n> direct_type_declarator
+%type <n> field_class_declarator
+%type <n> direct_field_class_declarator
 %type <n> pointer
 %type <n> ctf_assignment_expression_list
 %type <n> ctf_assignment_expression
@@ -1125,59 +1131,59 @@ file:
        ;
 
 keywords:
-               VOID
+               CTF_VOID
                {       $$ = yylval.s;          }
-       |       CHAR
+       |       CTF_CHAR
                {       $$ = yylval.s;          }
-       |       SHORT
+       |       CTF_SHORT
                {       $$ = yylval.s;          }
-       |       INT
+       |       CTF_INT
                {       $$ = yylval.s;          }
-       |       LONG
+       |       CTF_LONG
                {       $$ = yylval.s;          }
-       |       FLOAT
+       |       CTF_FLOAT
                {       $$ = yylval.s;          }
-       |       DOUBLE
+       |       CTF_DOUBLE
                {       $$ = yylval.s;          }
-       |       SIGNED
+       |       CTF_SIGNED
                {       $$ = yylval.s;          }
-       |       UNSIGNED
+       |       CTF_UNSIGNED
                {       $$ = yylval.s;          }
-       |       _BOOL
+       |       CTF_BOOL
                {       $$ = yylval.s;          }
-       |       _COMPLEX
+       |       CTF_COMPLEX
                {       $$ = yylval.s;          }
-       |       _IMAGINARY
+       |       CTF_IMAGINARY
                {       $$ = yylval.s;          }
-       |       FLOATING_POINT
+       |       CTF_FLOATING_POINT
                {       $$ = yylval.s;          }
-       |       INTEGER
+       |       CTF_INTEGER
                {       $$ = yylval.s;          }
-       |       STRING
+       |       CTF_STRING
                {       $$ = yylval.s;          }
-       |       ENUM
+       |       CTF_ENUM
                {       $$ = yylval.s;          }
-       |       VARIANT
+       |       CTF_VARIANT
                {       $$ = yylval.s;          }
-       |       STRUCT
+       |       CTF_STRUCT
                {       $$ = yylval.s;          }
-       |       CONST
+       |       CTF_CONST
                {       $$ = yylval.s;          }
-       |       TYPEDEF
+       |       CTF_TYPEDEF
                {       $$ = yylval.s;          }
-       |       EVENT
+       |       CTF_EVENT
                {       $$ = yylval.s;          }
-       |       STREAM
+       |       CTF_STREAM
                {       $$ = yylval.s;          }
-       |       ENV
+       |       CTF_ENV
                {       $$ = yylval.s;          }
-       |       TRACE
+       |       CTF_TRACE
                {       $$ = yylval.s;          }
-       |       CLOCK
+       |       CTF_CLOCK
                {       $$ = yylval.s;          }
-       |       CALLSITE
+       |       CTF_CALLSITE
                {       $$ = yylval.s;          }
-       |       TOK_ALIGN
+       |       CTF_TOK_ALIGN
                {       $$ = yylval.s;          }
        ;
 
@@ -1203,29 +1209,29 @@ postfix_expression:
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = yylval.s;
                }
-       |       INTEGER_LITERAL
+       |       CTF_INTEGER_LITERAL
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
                        $$->u.unary_expression.u.unsigned_constant = $1;
                }
-       |       STRING_LITERAL
+       |       CTF_STRING_LITERAL
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = $1;
                }
-       |       CHARACTER_LITERAL
+       |       CTF_CHARACTER_LITERAL
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = $1;
                }
-       |       LPAREN unary_expression RPAREN
+       |       CTF_LPAREN unary_expression CTF_RPAREN
                {
                        $$ = $2;
                }
-       |       postfix_expression LSBRAC unary_expression RSBRAC
+       |       postfix_expression CTF_LSBRAC unary_expression CTF_RSBRAC
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_SBRAC;
@@ -1233,7 +1239,7 @@ postfix_expression:
                        bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
                        bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
                }
-       |       postfix_expression DOT IDENTIFIER
+       |       postfix_expression CTF_DOT IDENTIFIER
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
@@ -1242,7 +1248,7 @@ postfix_expression:
                        bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
                        bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
                }
-       |       postfix_expression DOT ID_TYPE
+       |       postfix_expression CTF_DOT ID_TYPE
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
@@ -1251,7 +1257,7 @@ postfix_expression:
                        bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
                        bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
                }
-       |       postfix_expression DOT keywords
+       |       postfix_expression CTF_DOT keywords
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
@@ -1260,7 +1266,7 @@ postfix_expression:
                        bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
                        bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
                }
-       |       postfix_expression RARROW IDENTIFIER
+       |       postfix_expression CTF_RARROW IDENTIFIER
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
@@ -1269,7 +1275,7 @@ postfix_expression:
                        bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
                        bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
                }
-       |       postfix_expression RARROW ID_TYPE
+       |       postfix_expression CTF_RARROW ID_TYPE
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
@@ -1283,7 +1289,7 @@ postfix_expression:
 unary_expression:
                postfix_expression
                {       $$ = $1;                                }
-       |       PLUS postfix_expression
+       |       CTF_PLUS postfix_expression
                {
                        $$ = $2;
                        if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
@@ -1291,7 +1297,7 @@ unary_expression:
                                reparent_error(scanner, "expecting numeric constant");
                        }
                }
-       |       MINUS postfix_expression
+       |       CTF_MINUS postfix_expression
                {
                        $$ = $2;
                        if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
@@ -1308,7 +1314,7 @@ unary_expression:
        ;
 
 unary_expression_or_range:
-               unary_expression DOTDOTDOT unary_expression
+               unary_expression CTF_DOTDOTDOT unary_expression
                {
                        $$ = $1;
                        _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
@@ -1321,7 +1327,7 @@ unary_expression_or_range:
 /* 2.2: Declarations */
 
 declaration:
-               declaration_specifiers SEMICOLON
+               declaration_specifiers CTF_SEMICOLON
                {       $$ = $1;        }
        |       event_declaration
                {       $$ = $1;        }
@@ -1335,54 +1341,54 @@ declaration:
                {       $$ = $1;        }
        |       callsite_declaration
                {       $$ = $1;        }
-       |       declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
+       |       declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
                {
                        struct ctf_node *list;
 
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       $$->u._typedef.type_specifier_list = list;
-                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
+                       $$->u.field_class_def.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
                }
-       |       TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
+       |       CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
                {
                        struct ctf_node *list;
 
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       $$->u._typedef.type_specifier_list = list;
-                       _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       $$->u.field_class_def.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
                }
-       |       declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
+       |       declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
                {
                        struct ctf_node *list;
 
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       $$->u._typedef.type_specifier_list = list;
-                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       $$->u.field_class_def.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
                }
-       |       TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
+       |       CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
                {
                        struct ctf_node *list;
 
                        $$ = make_node(scanner, NODE_TYPEALIAS);
-                       $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
-                       $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
+                       $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
+                       $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
-                       _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
+                       $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
-                       _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
+                       $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
                }
        ;
 
@@ -1400,12 +1406,12 @@ event_declaration:
        ;
 
 event_declaration_begin:
-               EVENT LBRAC
+               CTF_EVENT CTF_LBRAC
                {       push_scope(scanner);    }
        ;
 
 event_declaration_end:
-               RBRAC SEMICOLON
+               CTF_RBRAC CTF_SEMICOLON
                {       pop_scope(scanner);     }
        ;
 
@@ -1424,12 +1430,12 @@ stream_declaration:
        ;
 
 stream_declaration_begin:
-               STREAM LBRAC
+               CTF_STREAM CTF_LBRAC
                {       push_scope(scanner);    }
        ;
 
 stream_declaration_end:
-               RBRAC SEMICOLON
+               CTF_RBRAC CTF_SEMICOLON
                {       pop_scope(scanner);     }
        ;
 
@@ -1447,12 +1453,12 @@ env_declaration:
        ;
 
 env_declaration_begin:
-               ENV LBRAC
+               CTF_ENV CTF_LBRAC
                {       push_scope(scanner);    }
        ;
 
 env_declaration_end:
-               RBRAC SEMICOLON
+               CTF_RBRAC CTF_SEMICOLON
                {       pop_scope(scanner);     }
        ;
 
@@ -1470,21 +1476,21 @@ trace_declaration:
        ;
 
 trace_declaration_begin:
-               TRACE LBRAC
+               CTF_TRACE CTF_LBRAC
                {       push_scope(scanner);    }
        ;
 
 trace_declaration_end:
-               RBRAC SEMICOLON
+               CTF_RBRAC CTF_SEMICOLON
                {       pop_scope(scanner);     }
        ;
 
 clock_declaration:
-               CLOCK clock_declaration_begin clock_declaration_end
+               CTF_CLOCK clock_declaration_begin clock_declaration_end
                {
                        $$ = make_node(scanner, NODE_CLOCK);
                }
-       |       CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
+       |       CTF_CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
                {
                        $$ = make_node(scanner, NODE_CLOCK);
                        if (set_parent_node($3, $$))
@@ -1493,21 +1499,21 @@ clock_declaration:
        ;
 
 clock_declaration_begin:
-               LBRAC
+               CTF_LBRAC
                {       push_scope(scanner);    }
        ;
 
 clock_declaration_end:
-               RBRAC SEMICOLON
+               CTF_RBRAC CTF_SEMICOLON
                {       pop_scope(scanner);     }
        ;
 
 callsite_declaration:
-               CALLSITE callsite_declaration_begin callsite_declaration_end
+               CTF_CALLSITE callsite_declaration_begin callsite_declaration_end
                {
                        $$ = make_node(scanner, NODE_CALLSITE);
                }
-       |       CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
+       |       CTF_CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
                {
                        $$ = make_node(scanner, NODE_CALLSITE);
                        if (set_parent_node($3, $$))
@@ -1516,287 +1522,287 @@ callsite_declaration:
        ;
 
 callsite_declaration_begin:
-               LBRAC
+               CTF_LBRAC
                {       push_scope(scanner);    }
        ;
 
 callsite_declaration_end:
-               RBRAC SEMICOLON
+               CTF_RBRAC CTF_SEMICOLON
                {       pop_scope(scanner);     }
        ;
 
 integer_declaration_specifiers:
-               CONST
+               CTF_CONST
                {
                        struct ctf_node *node;
 
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       node->u.type_specifier.type = TYPESPEC_CONST;
-                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       node->u.field_class_specifier.type = TYPESPEC_CONST;
+                       bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
                }
-       |       integer_type_specifier
+       |       integer_field_class_specifier
                {
                        struct ctf_node *node;
 
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = $1;
-                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
                }
-       |       integer_declaration_specifiers CONST
+       |       integer_declaration_specifiers CTF_CONST
                {
                        struct ctf_node *node;
 
                        $$ = $1;
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       node->u.type_specifier.type = TYPESPEC_CONST;
-                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       node->u.field_class_specifier.type = TYPESPEC_CONST;
+                       bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
                }
-       |       integer_declaration_specifiers integer_type_specifier
+       |       integer_declaration_specifiers integer_field_class_specifier
                {
                        $$ = $1;
-                       bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
                }
        ;
 
 declaration_specifiers:
-               CONST
+               CTF_CONST
                {
                        struct ctf_node *node;
 
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       node->u.type_specifier.type = TYPESPEC_CONST;
-                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       node->u.field_class_specifier.type = TYPESPEC_CONST;
+                       bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
                }
-       |       type_specifier
+       |       field_class_specifier
                {
                        struct ctf_node *node;
 
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = $1;
-                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
                }
-       |       declaration_specifiers CONST
+       |       declaration_specifiers CTF_CONST
                {
                        struct ctf_node *node;
 
                        $$ = $1;
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       node->u.type_specifier.type = TYPESPEC_CONST;
-                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       node->u.field_class_specifier.type = TYPESPEC_CONST;
+                       bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
                }
-       |       declaration_specifiers type_specifier
+       |       declaration_specifiers field_class_specifier
                {
                        $$ = $1;
-                       bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
                }
        ;
 
-type_declarator_list:
-               type_declarator
+field_class_declarator_list:
+               field_class_declarator
                {       $$ = $1;        }
-       |       type_declarator_list COMMA type_declarator
+       |       field_class_declarator_list CTF_COMMA field_class_declarator
                {
                        $$ = $1;
                        bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
                }
        ;
 
-integer_type_specifier:
-               CHAR
+integer_field_class_specifier:
+               CTF_CHAR
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_CHAR;
+                       $$->u.field_class_specifier.type = TYPESPEC_CHAR;
                }
-       |       SHORT
+       |       CTF_SHORT
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_SHORT;
+                       $$->u.field_class_specifier.type = TYPESPEC_SHORT;
                }
-       |       INT
+       |       CTF_INT
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_INT;
+                       $$->u.field_class_specifier.type = TYPESPEC_INT;
                }
-       |       LONG
+       |       CTF_LONG
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_LONG;
+                       $$->u.field_class_specifier.type = TYPESPEC_LONG;
                }
-       |       SIGNED
+       |       CTF_SIGNED
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_SIGNED;
+                       $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
                }
-       |       UNSIGNED
+       |       CTF_UNSIGNED
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
+                       $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
                }
-       |       _BOOL
+       |       CTF_BOOL
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_BOOL;
+                       $$->u.field_class_specifier.type = TYPESPEC_BOOL;
                }
        |       ID_TYPE
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
-                       $$->u.type_specifier.id_type = yylval.s;
+                       $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
+                       $$->u.field_class_specifier.id_type = yylval.s;
                }
-       |       INTEGER LBRAC RBRAC
+       |       CTF_INTEGER CTF_LBRAC CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_INTEGER;
-                       $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
+                       $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
+                       $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
                }
-       |       INTEGER LBRAC ctf_assignment_expression_list RBRAC
+       |       CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_INTEGER;
-                       $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
-                       if (set_parent_node($3, $$->u.type_specifier.node))
+                       $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
+                       $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
+                       if (set_parent_node($3, $$->u.field_class_specifier.node))
                                reparent_error(scanner, "integer reparent error");
                }
        ;
 
-type_specifier:
-               VOID
+field_class_specifier:
+               CTF_VOID
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_VOID;
+                       $$->u.field_class_specifier.type = TYPESPEC_VOID;
                }
-       |       CHAR
+       |       CTF_CHAR
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_CHAR;
+                       $$->u.field_class_specifier.type = TYPESPEC_CHAR;
                }
-       |       SHORT
+       |       CTF_SHORT
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_SHORT;
+                       $$->u.field_class_specifier.type = TYPESPEC_SHORT;
                }
-       |       INT
+       |       CTF_INT
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_INT;
+                       $$->u.field_class_specifier.type = TYPESPEC_INT;
                }
-       |       LONG
+       |       CTF_LONG
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_LONG;
+                       $$->u.field_class_specifier.type = TYPESPEC_LONG;
                }
-       |       FLOAT
+       |       CTF_FLOAT
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_FLOAT;
+                       $$->u.field_class_specifier.type = TYPESPEC_FLOAT;
                }
-       |       DOUBLE
+       |       CTF_DOUBLE
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_DOUBLE;
+                       $$->u.field_class_specifier.type = TYPESPEC_DOUBLE;
                }
-       |       SIGNED
+       |       CTF_SIGNED
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_SIGNED;
+                       $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
                }
-       |       UNSIGNED
+       |       CTF_UNSIGNED
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
+                       $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
                }
-       |       _BOOL
+       |       CTF_BOOL
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_BOOL;
+                       $$->u.field_class_specifier.type = TYPESPEC_BOOL;
                }
-       |       _COMPLEX
+       |       CTF_COMPLEX
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_COMPLEX;
+                       $$->u.field_class_specifier.type = TYPESPEC_COMPLEX;
                }
-       |       _IMAGINARY
+       |       CTF_IMAGINARY
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_IMAGINARY;
+                       $$->u.field_class_specifier.type = TYPESPEC_IMAGINARY;
                }
        |       ID_TYPE
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
-                       $$->u.type_specifier.id_type = yylval.s;
+                       $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
+                       $$->u.field_class_specifier.id_type = yylval.s;
                }
-       |       FLOATING_POINT LBRAC RBRAC
+       |       CTF_FLOATING_POINT CTF_LBRAC CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
-                       $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
+                       $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
+                       $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
                }
-       |       FLOATING_POINT LBRAC ctf_assignment_expression_list RBRAC
+       |       CTF_FLOATING_POINT CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
-                       $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
-                       if (set_parent_node($3, $$->u.type_specifier.node))
+                       $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
+                       $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
+                       if (set_parent_node($3, $$->u.field_class_specifier.node))
                                reparent_error(scanner, "floating point reparent error");
                }
-       |       INTEGER LBRAC RBRAC
+       |       CTF_INTEGER CTF_LBRAC CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_INTEGER;
-                       $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
+                       $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
+                       $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
                }
-       |       INTEGER LBRAC ctf_assignment_expression_list RBRAC
+       |       CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_INTEGER;
-                       $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
-                       if (set_parent_node($3, $$->u.type_specifier.node))
+                       $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
+                       $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
+                       if (set_parent_node($3, $$->u.field_class_specifier.node))
                                reparent_error(scanner, "integer reparent error");
                }
-       |       STRING
+       |       CTF_STRING
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_STRING;
-                       $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
+                       $$->u.field_class_specifier.type = TYPESPEC_STRING;
+                       $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
                }
-       |       STRING LBRAC RBRAC
+       |       CTF_STRING CTF_LBRAC CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_STRING;
-                       $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
+                       $$->u.field_class_specifier.type = TYPESPEC_STRING;
+                       $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
                }
-       |       STRING LBRAC ctf_assignment_expression_list RBRAC
+       |       CTF_STRING CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_STRING;
-                       $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
-                       if (set_parent_node($3, $$->u.type_specifier.node))
+                       $$->u.field_class_specifier.type = TYPESPEC_STRING;
+                       $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
+                       if (set_parent_node($3, $$->u.field_class_specifier.node))
                                reparent_error(scanner, "string reparent error");
                }
-       |       ENUM enum_type_specifier
+       |       CTF_ENUM enum_field_class_specifier
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_ENUM;
-                       $$->u.type_specifier.node = $2;
+                       $$->u.field_class_specifier.type = TYPESPEC_ENUM;
+                       $$->u.field_class_specifier.node = $2;
                }
-       |       VARIANT variant_type_specifier
+       |       CTF_VARIANT variant_field_class_specifier
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_VARIANT;
-                       $$->u.type_specifier.node = $2;
+                       $$->u.field_class_specifier.type = TYPESPEC_VARIANT;
+                       $$->u.field_class_specifier.node = $2;
                }
-       |       STRUCT struct_type_specifier
+       |       CTF_STRUCT struct_class_specifier
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_STRUCT;
-                       $$->u.type_specifier.node = $2;
+                       $$->u.field_class_specifier.type = TYPESPEC_STRUCT;
+                       $$->u.field_class_specifier.node = $2;
                }
        ;
 
-struct_type_specifier:
+struct_class_specifier:
                struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
                {
                        $$ = make_node(scanner, NODE_STRUCT);
@@ -1832,7 +1838,7 @@ struct_type_specifier:
                        $$->u._struct.has_body = 0;
                        $$->u._struct.name = $1;
                }
-       |       struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
+       |       struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
                {
                        $$ = make_node(scanner, NODE_STRUCT);
                        $$->u._struct.has_body = 1;
@@ -1840,7 +1846,7 @@ struct_type_specifier:
                        if ($2 && set_parent_node($2, $$))
                                reparent_error(scanner, "struct reparent error");
                }
-       |       IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
+       |       IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
                {
                        $$ = make_node(scanner, NODE_STRUCT);
                        $$->u._struct.has_body = 1;
@@ -1849,7 +1855,7 @@ struct_type_specifier:
                        if ($3 && set_parent_node($3, $$))
                                reparent_error(scanner, "struct reparent error");
                }
-       |       ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
+       |       ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
                {
                        $$ = make_node(scanner, NODE_STRUCT);
                        $$->u._struct.has_body = 1;
@@ -1861,16 +1867,16 @@ struct_type_specifier:
        ;
 
 struct_declaration_begin:
-               LBRAC
+               CTF_LBRAC
                {       push_scope(scanner);    }
        ;
 
 struct_declaration_end:
-               RBRAC
+               CTF_RBRAC
                {       pop_scope(scanner);     }
        ;
 
-variant_type_specifier:
+variant_field_class_specifier:
                variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
@@ -1878,7 +1884,7 @@ variant_type_specifier:
                        if ($2 && set_parent_node($2, $$))
                                reparent_error(scanner, "variant reparent error");
                }
-       |       LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
+       |       CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
                        $$->u.variant.has_body = 1;
@@ -1886,7 +1892,7 @@ variant_type_specifier:
                        if ($5 && set_parent_node($5, $$))
                                reparent_error(scanner, "variant reparent error");
                }
-       |       LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
+       |       CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
                        $$->u.variant.has_body = 1;
@@ -1902,7 +1908,7 @@ variant_type_specifier:
                        if ($3 && set_parent_node($3, $$))
                                reparent_error(scanner, "variant reparent error");
                }
-       |       IDENTIFIER LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
+       |       IDENTIFIER CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
                        $$->u.variant.has_body = 1;
@@ -1911,14 +1917,14 @@ variant_type_specifier:
                        if ($6 && set_parent_node($6, $$))
                                reparent_error(scanner, "variant reparent error");
                }
-       |       IDENTIFIER LT IDENTIFIER GT
+       |       IDENTIFIER CTF_LT IDENTIFIER CTF_GT
                {
                        $$ = make_node(scanner, NODE_VARIANT);
                        $$->u.variant.has_body = 0;
                        $$->u.variant.name = $1;
                        $$->u.variant.choice = $3;
                }
-       |       IDENTIFIER LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
+       |       IDENTIFIER CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
                        $$->u.variant.has_body = 1;
@@ -1927,7 +1933,7 @@ variant_type_specifier:
                        if ($6 && set_parent_node($6, $$))
                                reparent_error(scanner, "variant reparent error");
                }
-       |       IDENTIFIER LT ID_TYPE GT
+       |       IDENTIFIER CTF_LT ID_TYPE CTF_GT
                {
                        $$ = make_node(scanner, NODE_VARIANT);
                        $$->u.variant.has_body = 0;
@@ -1942,7 +1948,7 @@ variant_type_specifier:
                        if ($3 && set_parent_node($3, $$))
                                reparent_error(scanner, "variant reparent error");
                }
-       |       ID_TYPE LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
+       |       ID_TYPE CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
                        $$->u.variant.has_body = 1;
@@ -1951,14 +1957,14 @@ variant_type_specifier:
                        if ($6 && set_parent_node($6, $$))
                                reparent_error(scanner, "variant reparent error");
                }
-       |       ID_TYPE LT IDENTIFIER GT
+       |       ID_TYPE CTF_LT IDENTIFIER CTF_GT
                {
                        $$ = make_node(scanner, NODE_VARIANT);
                        $$->u.variant.has_body = 0;
                        $$->u.variant.name = $1;
                        $$->u.variant.choice = $3;
                }
-       |       ID_TYPE LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
+       |       ID_TYPE CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
                        $$->u.variant.has_body = 1;
@@ -1967,7 +1973,7 @@ variant_type_specifier:
                        if ($6 && set_parent_node($6, $$))
                                reparent_error(scanner, "variant reparent error");
                }
-       |       ID_TYPE LT ID_TYPE GT
+       |       ID_TYPE CTF_LT ID_TYPE CTF_GT
                {
                        $$ = make_node(scanner, NODE_VARIANT);
                        $$->u.variant.has_body = 0;
@@ -1977,85 +1983,85 @@ variant_type_specifier:
        ;
 
 variant_declaration_begin:
-               LBRAC
+               CTF_LBRAC
                {       push_scope(scanner);    }
        ;
 
 variant_declaration_end:
-               RBRAC
+               CTF_RBRAC
                {       pop_scope(scanner);     }
        ;
 
-enum_type_specifier:
-               LBRAC enumerator_list RBRAC
+enum_field_class_specifier:
+               CTF_LBRAC enumerator_list CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
                        _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
+       |       CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
-                       ($$)->u._enum.container_type = $2;
+                       ($$)->u._enum.container_field_class = $2;
                        _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       IDENTIFIER LBRAC enumerator_list RBRAC
+       |       IDENTIFIER CTF_LBRAC enumerator_list CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1;
                        _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
+       |       IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1;
-                       ($$)->u._enum.container_type = $3;
+                       ($$)->u._enum.container_field_class = $3;
                        _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       ID_TYPE LBRAC enumerator_list RBRAC
+       |       ID_TYPE CTF_LBRAC enumerator_list CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1;
                        _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
+       |       ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1;
-                       ($$)->u._enum.container_type = $3;
+                       ($$)->u._enum.container_field_class = $3;
                        _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       LBRAC enumerator_list COMMA RBRAC
+       |       CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
                        _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
+       |       CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
-                       ($$)->u._enum.container_type = $2;
+                       ($$)->u._enum.container_field_class = $2;
                        _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       IDENTIFIER LBRAC enumerator_list COMMA RBRAC
+       |       IDENTIFIER CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1;
                        _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
+       |       IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1;
-                       ($$)->u._enum.container_type = $3;
+                       ($$)->u._enum.container_field_class = $3;
                        _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       IDENTIFIER
@@ -2064,19 +2070,19 @@ enum_type_specifier:
                        $$->u._enum.has_body = 0;
                        $$->u._enum.enum_id = $1;
                }
-       |       ID_TYPE LBRAC enumerator_list COMMA RBRAC
+       |       ID_TYPE CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1;
                        _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
+       |       ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1;
-                       ($$)->u._enum.container_type = $3;
+                       ($$)->u._enum.container_field_class = $3;
                        _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       ID_TYPE
@@ -2103,84 +2109,84 @@ struct_or_variant_declaration_list:
        ;
 
 struct_or_variant_declaration:
-               declaration_specifiers struct_or_variant_declarator_list SEMICOLON
+               declaration_specifiers struct_or_variant_declarator_list CTF_SEMICOLON
                {
                        struct ctf_node *list;
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
                        $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
-                       ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
-                       _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
+                       ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.field_class_declarators);
                }
-       |       declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
+       |       declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
                {
                        struct ctf_node *list;
 
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       $$->u._typedef.type_specifier_list = list;
-                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
+                       $$->u.field_class_def.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
                }
-       |       TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
+       |       CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
                {
                        struct ctf_node *list;
 
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       $$->u._typedef.type_specifier_list = list;
-                       _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       $$->u.field_class_def.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
                }
-       |       declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
+       |       declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
                {
                        struct ctf_node *list;
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
                        $$ = make_node(scanner, NODE_TYPEDEF);
-                       ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
                }
-       |       TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
+       |       CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
                {
                        struct ctf_node *list;
 
                        $$ = make_node(scanner, NODE_TYPEALIAS);
-                       $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
-                       $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
+                       $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
+                       $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
-                       _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
+                       $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
-                       _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
+                       $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
                }
        ;
 
 alias_declaration_specifiers:
-               CONST
+               CTF_CONST
                {
                        struct ctf_node *node;
 
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       node->u.type_specifier.type = TYPESPEC_CONST;
-                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       node->u.field_class_specifier.type = TYPESPEC_CONST;
+                       bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
                }
-       |       type_specifier
+       |       field_class_specifier
                {
                        struct ctf_node *node;
 
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = $1;
-                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
                }
        |       IDENTIFIER
                {
@@ -2189,23 +2195,23 @@ alias_declaration_specifiers:
                        add_type(scanner, $1);
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       node->u.type_specifier.type = TYPESPEC_ID_TYPE;
-                       node->u.type_specifier.id_type = yylval.s;
-                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
+                       node->u.field_class_specifier.id_type = yylval.s;
+                       bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
                }
-       |       alias_declaration_specifiers CONST
+       |       alias_declaration_specifiers CTF_CONST
                {
                        struct ctf_node *node;
 
                        $$ = $1;
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       node->u.type_specifier.type = TYPESPEC_CONST;
-                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       node->u.field_class_specifier.type = TYPESPEC_CONST;
+                       bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
                }
-       |       alias_declaration_specifiers type_specifier
+       |       alias_declaration_specifiers field_class_specifier
                {
                        $$ = $1;
-                       bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
                }
        |       alias_declaration_specifiers IDENTIFIER
                {
@@ -2214,16 +2220,16 @@ alias_declaration_specifiers:
                        add_type(scanner, $2);
                        $$ = $1;
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       node->u.type_specifier.type = TYPESPEC_ID_TYPE;
-                       node->u.type_specifier.id_type = yylval.s;
-                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
+                       node->u.field_class_specifier.id_type = yylval.s;
+                       bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
                }
        ;
 
 struct_or_variant_declarator_list:
                struct_or_variant_declarator
                {       $$ = $1;        }
-       |       struct_or_variant_declarator_list COMMA struct_or_variant_declarator
+       |       struct_or_variant_declarator_list CTF_COMMA struct_or_variant_declarator
                {
                        $$ = $1;
                        bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
@@ -2233,9 +2239,9 @@ struct_or_variant_declarator_list:
 struct_or_variant_declarator:
                declarator
                {       $$ = $1;        }
-       |       COLON unary_expression
+       |       CTF_COLON unary_expression
                {       $$ = $2;        }
-       |       declarator COLON unary_expression
+       |       declarator CTF_COLON unary_expression
                {
                        $$ = $1;
                        if (set_parent_node($3, $1))
@@ -2246,7 +2252,7 @@ struct_or_variant_declarator:
 enumerator_list:
                enumerator
                {       $$ = $1;        }
-       |       enumerator_list COMMA enumerator
+       |       enumerator_list CTF_COMMA enumerator
                {
                        $$ = $1;
                        bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
@@ -2269,30 +2275,30 @@ enumerator:
                        $$ = make_node(scanner, NODE_ENUMERATOR);
                        $$->u.enumerator.id = $1;
                }
-       |       STRING_LITERAL
+       |       CTF_STRING_LITERAL
                {
                        $$ = make_node(scanner, NODE_ENUMERATOR);
                        $$->u.enumerator.id = $1;
                }
-       |       IDENTIFIER EQUAL unary_expression_or_range
+       |       IDENTIFIER CTF_EQUAL unary_expression_or_range
                {
                        $$ = make_node(scanner, NODE_ENUMERATOR);
                        $$->u.enumerator.id = $1;
                        bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
                }
-       |       ID_TYPE EQUAL unary_expression_or_range
+       |       ID_TYPE CTF_EQUAL unary_expression_or_range
                {
                        $$ = make_node(scanner, NODE_ENUMERATOR);
                        $$->u.enumerator.id = $1;
                        bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
                }
-       |       keywords EQUAL unary_expression_or_range
+       |       keywords CTF_EQUAL unary_expression_or_range
                {
                        $$ = make_node(scanner, NODE_ENUMERATOR);
                        $$->u.enumerator.id = $1;
                        bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
                }
-       |       STRING_LITERAL EQUAL unary_expression_or_range
+       |       CTF_STRING_LITERAL CTF_EQUAL unary_expression_or_range
                {
                        $$ = make_node(scanner, NODE_ENUMERATOR);
                        $$->u.enumerator.id = $1;
@@ -2303,7 +2309,7 @@ enumerator:
 abstract_declarator_list:
                abstract_declarator
                {       $$ = $1;        }
-       |       abstract_declarator_list COMMA abstract_declarator
+       |       abstract_declarator_list CTF_COMMA abstract_declarator
                {
                        $$ = $1;
                        bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
@@ -2316,7 +2322,7 @@ abstract_declarator:
        |       pointer direct_abstract_declarator
                {
                        $$ = $2;
-                       bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
+                       bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
                }
        ;
 
@@ -2324,42 +2330,42 @@ direct_abstract_declarator:
                /* empty */
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                        $$->u.type_declarator.type = TYPEDEC_ID;
+                        $$->u.field_class_declarator.type = TYPEDEC_ID;
                        /* id is NULL */
                }
        |       IDENTIFIER
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_ID;
-                       $$->u.type_declarator.u.id = $1;
+                       $$->u.field_class_declarator.type = TYPEDEC_ID;
+                       $$->u.field_class_declarator.u.id = $1;
                }
-       |       LPAREN abstract_declarator RPAREN
+       |       CTF_LPAREN abstract_declarator CTF_RPAREN
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_NESTED;
-                       $$->u.type_declarator.u.nested.type_declarator = $2;
+                       $$->u.field_class_declarator.type = TYPEDEC_NESTED;
+                       $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
                }
-       |       direct_abstract_declarator LSBRAC unary_expression RSBRAC
+       |       direct_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_NESTED;
-                       $$->u.type_declarator.u.nested.type_declarator = $1;
-                       BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+                       $$->u.field_class_declarator.type = TYPEDEC_NESTED;
+                       $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
+                       BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
                }
-       |       direct_abstract_declarator LSBRAC RSBRAC
+       |       direct_abstract_declarator CTF_LSBRAC CTF_RSBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_NESTED;
-                       $$->u.type_declarator.u.nested.type_declarator = $1;
-                       $$->u.type_declarator.u.nested.abstract_array = 1;
+                       $$->u.field_class_declarator.type = TYPEDEC_NESTED;
+                       $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
+                       $$->u.field_class_declarator.u.nested.abstract_array = 1;
                }
        ;
 
 alias_abstract_declarator_list:
                alias_abstract_declarator
                {       $$ = $1;        }
-       |       alias_abstract_declarator_list COMMA alias_abstract_declarator
+       |       alias_abstract_declarator_list CTF_COMMA alias_abstract_declarator
                {
                        $$ = $1;
                        bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
@@ -2372,7 +2378,7 @@ alias_abstract_declarator:
        |       pointer direct_alias_abstract_declarator
                {
                        $$ = $2;
-                       bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
+                       bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
                }
        ;
 
@@ -2380,29 +2386,29 @@ direct_alias_abstract_declarator:
                /* empty */
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                        $$->u.type_declarator.type = TYPEDEC_ID;
+                        $$->u.field_class_declarator.type = TYPEDEC_ID;
                        /* id is NULL */
                }
-       |       LPAREN alias_abstract_declarator RPAREN
+       |       CTF_LPAREN alias_abstract_declarator CTF_RPAREN
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_NESTED;
-                       $$->u.type_declarator.u.nested.type_declarator = $2;
+                       $$->u.field_class_declarator.type = TYPEDEC_NESTED;
+                       $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
                }
-       |       direct_alias_abstract_declarator LSBRAC unary_expression RSBRAC
+       |       direct_alias_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_NESTED;
-                       $$->u.type_declarator.u.nested.type_declarator = $1;
-                       BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+                       $$->u.field_class_declarator.type = TYPEDEC_NESTED;
+                       $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
+                       BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
                }
-       |       direct_alias_abstract_declarator LSBRAC RSBRAC
+       |       direct_alias_abstract_declarator CTF_LSBRAC CTF_RSBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_NESTED;
-                       $$->u.type_declarator.u.nested.type_declarator = $1;
-                       $$->u.type_declarator.u.nested.abstract_array = 1;
+                       $$->u.field_class_declarator.type = TYPEDEC_NESTED;
+                       $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
+                       $$->u.field_class_declarator.u.nested.abstract_array = 1;
                }
        ;
 
@@ -2412,7 +2418,7 @@ declarator:
        |       pointer direct_declarator
                {
                        $$ = $2;
-                       bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
+                       bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
                }
        ;
 
@@ -2420,70 +2426,70 @@ direct_declarator:
                IDENTIFIER
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_ID;
-                       $$->u.type_declarator.u.id = $1;
+                       $$->u.field_class_declarator.type = TYPEDEC_ID;
+                       $$->u.field_class_declarator.u.id = $1;
                }
-       |       LPAREN declarator RPAREN
+       |       CTF_LPAREN declarator CTF_RPAREN
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_NESTED;
-                       $$->u.type_declarator.u.nested.type_declarator = $2;
+                       $$->u.field_class_declarator.type = TYPEDEC_NESTED;
+                       $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
                }
-       |       direct_declarator LSBRAC unary_expression RSBRAC
+       |       direct_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_NESTED;
-                       $$->u.type_declarator.u.nested.type_declarator = $1;
-                       BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+                       $$->u.field_class_declarator.type = TYPEDEC_NESTED;
+                       $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
+                       BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
                }
        ;
 
-type_declarator:
-               direct_type_declarator
+field_class_declarator:
+               direct_field_class_declarator
                {       $$ = $1;        }
-       |       pointer direct_type_declarator
+       |       pointer direct_field_class_declarator
                {
                        $$ = $2;
-                       bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
+                       bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
                }
        ;
 
-direct_type_declarator:
+direct_field_class_declarator:
                IDENTIFIER
                {
                        add_type(scanner, $1);
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_ID;
-                       $$->u.type_declarator.u.id = $1;
+                       $$->u.field_class_declarator.type = TYPEDEC_ID;
+                       $$->u.field_class_declarator.u.id = $1;
                }
-       |       LPAREN type_declarator RPAREN
+       |       CTF_LPAREN field_class_declarator CTF_RPAREN
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_NESTED;
-                       $$->u.type_declarator.u.nested.type_declarator = $2;
+                       $$->u.field_class_declarator.type = TYPEDEC_NESTED;
+                       $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
                }
-       |       direct_type_declarator LSBRAC unary_expression RSBRAC
+       |       direct_field_class_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_NESTED;
-                       $$->u.type_declarator.u.nested.type_declarator = $1;
-                       BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+                       $$->u.field_class_declarator.type = TYPEDEC_NESTED;
+                       $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
+                       BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
                }
        ;
 
 pointer:
-               STAR
+               CTF_STAR
                {
                        $$ = make_node(scanner, NODE_POINTER);
                }
-       |       STAR pointer
+       |       CTF_STAR pointer
                {
                        $$ = make_node(scanner, NODE_POINTER);
                        bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
                }
-       |       STAR type_qualifier_list pointer
+       |       CTF_STAR type_qualifier_list pointer
                {
                        $$ = make_node(scanner, NODE_POINTER);
                        $$->u.pointer.const_qualifier = 1;
@@ -2493,16 +2499,16 @@ pointer:
 
 type_qualifier_list:
                /* pointer assumes only const type qualifier */
-               CONST
-       |       type_qualifier_list CONST
+               CTF_CONST
+       |       type_qualifier_list CTF_CONST
        ;
 
 /* 2.3: CTF-specific declarations */
 
 ctf_assignment_expression_list:
-               ctf_assignment_expression SEMICOLON
+               ctf_assignment_expression CTF_SEMICOLON
                {       $$ = $1;        }
-       |       ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
+       |       ctf_assignment_expression_list ctf_assignment_expression CTF_SEMICOLON
                {
                        $$ = $1;
                        bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
@@ -2510,7 +2516,7 @@ ctf_assignment_expression_list:
        ;
 
 ctf_assignment_expression:
-               unary_expression EQUAL unary_expression
+               unary_expression CTF_EQUAL unary_expression
                {
                        /*
                         * Because we have left and right, cannot use
@@ -2522,7 +2528,7 @@ ctf_assignment_expression:
                                reparent_error(scanner, "ctf_assignment_expression left expects string");
                        _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
                }
-       |       unary_expression TYPEASSIGN declaration_specifiers      /* Only allow struct */
+       |       unary_expression CTF_TYPEASSIGN declaration_specifiers  /* Only allow struct */
                {
                        /*
                         * Because we have left and right, cannot use
@@ -2534,53 +2540,53 @@ ctf_assignment_expression:
                                reparent_error(scanner, "ctf_assignment_expression left expects string");
                        bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
                }
-       |       declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
+       |       declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list
                {
                        struct ctf_node *list;
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
                        $$ = make_node(scanner, NODE_TYPEDEF);
-                       ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
-                       _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
+                       ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
                }
-       |       TYPEDEF declaration_specifiers type_declarator_list
+       |       CTF_TYPEDEF declaration_specifiers field_class_declarator_list
                {
                        struct ctf_node *list;
 
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       $$->u._typedef.type_specifier_list = list;
-                       _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       $$->u.field_class_def.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
                }
-       |       declaration_specifiers TYPEDEF type_declarator_list
+       |       declaration_specifiers CTF_TYPEDEF field_class_declarator_list
                {
                        struct ctf_node *list;
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
                        $$ = make_node(scanner, NODE_TYPEDEF);
-                       ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
                }
-       |       TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
+       |       CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
                {
                        struct ctf_node *list;
 
                        $$ = make_node(scanner, NODE_TYPEALIAS);
-                       $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
-                       $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
+                       $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
+                       $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
-                       _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
+                       $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
-                       _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
+                       $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
+                       _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
+                       _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
                }
        ;