X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=formats%2Fctf%2Fmetadata%2Fctf-parser.y;h=a31e9637e24b930d8060fffe988035a282d2e6bf;hp=1d40d04f1a656b635449684d5cbcdb489b4dc9de;hb=80b07bd71464ffbf5f681b7519af520cb0d44d3a;hpb=9ecfc3e6b596858f772e09a78832526ba808638a

diff --git a/formats/ctf/metadata/ctf-parser.y b/formats/ctf/metadata/ctf-parser.y
index 1d40d04f..a31e9637 100644
--- a/formats/ctf/metadata/ctf-parser.y
+++ b/formats/ctf/metadata/ctf-parser.y
@@ -15,9 +15,18 @@
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
  */
 
 #include <stdio.h>
+#include <ctype.h>
 #include <unistd.h>
 #include <string.h>
 #include <stdlib.h>
@@ -26,16 +35,17 @@
 #include <errno.h>
 #include <inttypes.h>
 #include <babeltrace/list.h>
-#include <babeltrace/babeltrace.h>
+#include <babeltrace/babeltrace-internal.h>
 #include "ctf-scanner.h"
 #include "ctf-parser.h"
 #include "ctf-ast.h"
 
+BT_HIDDEN
 int yydebug;
 
 /* Join two lists, put "add" at the end of "head".  */
 static inline void
-_cds_list_splice_tail (struct cds_list_head *add, struct cds_list_head *head)
+_bt_list_splice_tail (struct bt_list_head *add, struct bt_list_head *head)
 {
 	/* Do nothing if the list which gets added is empty.  */
 	if (add != add->next) {
@@ -46,46 +56,34 @@ _cds_list_splice_tail (struct cds_list_head *add, struct cds_list_head *head)
 	}
 }
 
+BT_HIDDEN
 int yyparse(struct ctf_scanner *scanner);
+BT_HIDDEN
 int yylex(union YYSTYPE *yyval, struct ctf_scanner *scanner);
+BT_HIDDEN
 int yylex_init_extra(struct ctf_scanner *scanner, yyscan_t * ptr_yy_globals);
+BT_HIDDEN
 int yylex_destroy(yyscan_t yyscanner);
+BT_HIDDEN
 void yyrestart(FILE * in_str, yyscan_t scanner);
-
-int yydebug;
+BT_HIDDEN
+int yyget_lineno(yyscan_t yyscanner);
+BT_HIDDEN
+char *yyget_text(yyscan_t yyscanner);
 
 struct gc_string {
-	struct cds_list_head gc;
+	struct bt_list_head gc;
 	size_t alloclen;
 	char s[];
 };
 
 static const char *node_type_to_str[] = {
-	[ NODE_UNKNOWN ] = "NODE_UNKNOWN",
-	[ NODE_ROOT ] = "NODE_ROOT",
-	[ NODE_EVENT ] = "NODE_EVENT",
-	[ NODE_STREAM ] = "NODE_STREAM",
-	[ NODE_TRACE ] = "NODE_TRACE",
-	[ NODE_CTF_EXPRESSION ] = "NODE_CTF_EXPRESSION",
-	[ NODE_UNARY_EXPRESSION ] = "NODE_UNARY_EXPRESSION",
-	[ NODE_TYPEDEF ] = "NODE_TYPEDEF",
-	[ NODE_TYPEALIAS_TARGET ] = "NODE_TYPEALIAS_TARGET",
-	[ NODE_TYPEALIAS_ALIAS ] = "NODE_TYPEALIAS_ALIAS",
-	[ NODE_TYPEALIAS ] = "NODE_TYPEALIAS",
-	[ NODE_TYPE_SPECIFIER ] = "NODE_TYPE_SPECIFIER",
-	[ NODE_TYPE_SPECIFIER_LIST ] = "NODE_TYPE_SPECIFIER_LIST",
-	[ NODE_POINTER ] = "NODE_POINTER",
-	[ NODE_TYPE_DECLARATOR ] = "NODE_TYPE_DECLARATOR",
-	[ NODE_FLOATING_POINT ] = "NODE_FLOATING_POINT",
-	[ NODE_INTEGER ] = "NODE_INTEGER",
-	[ NODE_STRING ] = "NODE_STRING",
-	[ NODE_ENUMERATOR ] = "NODE_ENUMERATOR",
-	[ NODE_ENUM ] = "NODE_ENUM",
-	[ NODE_STRUCT_OR_VARIANT_DECLARATION ] = "NODE_STRUCT_OR_VARIANT_DECLARATION",
-	[ NODE_VARIANT ] = "NODE_VARIANT",
-	[ NODE_STRUCT ] = "NODE_STRUCT",
+#define ENTRY(S)	[S] = #S,
+	FOREACH_CTF_NODES(ENTRY)
+#undef ENTRY
 };
 
+BT_HIDDEN
 const char *node_type(struct ctf_node *node)
 {
 	if (node->type < NR_NODE_TYPES)
@@ -106,7 +104,7 @@ static struct gc_string *gc_string_alloc(struct ctf_scanner *scanner,
 	     alloclen *= 2);
 
 	gstr = malloc(alloclen);
-	cds_list_add(&gstr->gc, &scanner->allocated_strings);
+	bt_list_add(&gstr->gc, &scanner->allocated_strings);
 	gstr->alloclen = alloclen;
 	return gstr;
 }
@@ -116,6 +114,7 @@ static struct gc_string *gc_string_alloc(struct ctf_scanner *scanner,
  * gsrc will be garbage collected immediately, and gstr might be.
  * Should only be used to append characters to a string literal or constant.
  */
+BT_HIDDEN
 struct gc_string *gc_string_append(struct ctf_scanner *scanner,
 				   struct gc_string *gstr,
 				   struct gc_string *gsrc)
@@ -134,13 +133,13 @@ struct gc_string *gc_string_append(struct ctf_scanner *scanner,
 		newgstr = gc_string_alloc(scanner, newlen);
 		strcpy(newgstr->s, gstr->s);
 		strcat(newgstr->s, gsrc->s);
-		cds_list_del(&gstr->gc);
+		bt_list_del(&gstr->gc);
 		free(gstr);
 		gstr = newgstr;
 	} else {
 		strcat(gstr->s, gsrc->s);
 	}
-	cds_list_del(&gsrc->gc);
+	bt_list_del(&gsrc->gc);
 	free(gsrc);
 	return gstr;
 }
@@ -151,6 +150,144 @@ void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src)
 	strcpy(lvalp->gs->s, src);
 }
 
+static
+int str_check(size_t str_len, size_t offset, size_t len)
+{
+	/* check overflow */
+	if (offset + len < offset)
+		return -1;
+	if (offset + len > str_len)
+		return -1;
+	return 0;
+}
+
+static
+int import_basic_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
+		size_t len, const char *src, char delim)
+{
+	size_t pos = 0, dpos = 0;
+
+	if (str_check(len, pos, 1))
+		return -1;
+	if (src[pos++] != delim)
+		return -1;
+
+	while (src[pos] != delim) {
+		char c;
+
+		if (str_check(len, pos, 1))
+			return -1;
+		c = src[pos++];
+		if (c == '\\') {
+			if (str_check(len, pos, 1))
+				return -1;
+			c = src[pos++];
+
+			switch (c) {
+			case '0':
+				c = '\0';
+				break;
+			case 'a':
+				c = '\a';
+				break;
+			case 'b':
+				c = '\b';
+				break;
+			case 'f':
+				c = '\f';
+				break;
+			case 'n':
+				c = '\n';
+				break;
+			case 'r':
+				c = '\r';
+				break;
+			case 't':
+				c = '\t';
+				break;
+			case 'v':
+				c = '\v';
+				break;
+			case '\\':
+				c = '\\';
+				break;
+			case '\'':
+				c = '\'';
+				break;
+			case '\"':
+				c = '\"';
+				break;
+			case '?':
+				c = '?';
+				break;
+			case 'o':
+			{
+				size_t oct_len = 3;
+
+				if (str_check(len, pos, oct_len))
+					return -1;
+				if (!isdigit((int) src[pos]) || !isdigit((int) src[pos+1]) || !isdigit((int) src[pos+2]))
+					return -1;
+				char oct_buffer[4] = { src[pos], src[pos+1], src[pos+2], '\0' };
+				c = strtoul(&oct_buffer[0], NULL, 8);
+				pos += oct_len;
+				break;
+			}
+			case 'x':
+			{
+				size_t hex_len = 2;
+
+				if (str_check(len, pos, hex_len))
+					return -1;
+				if (!isxdigit((int) src[pos]) || !isxdigit((int) src[pos+1]))
+					return -1;
+				char hex_buffer[3] = { src[pos], src[pos+1], '\0' };
+				c = strtoul(&hex_buffer[0], NULL, 16);
+				pos += hex_len;
+				break;
+			}
+			default:
+				return -1;
+			}
+		}
+		if (str_check(len, dpos, 1))
+			return -1;
+		lvalp->gs->s[dpos++] = c;
+	}
+
+	if (str_check(len, dpos, 1))
+		return -1;
+	lvalp->gs->s[dpos++] = '\0';
+
+	if (str_check(len, pos, 1))
+		return -1;
+	if (src[pos++] != delim)
+		return -1;
+
+	if (str_check(len, pos, 1))
+		return -1;
+	if (src[pos] != '\0')
+		return -1;
+	return 0;
+}
+
+int import_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
+		const char *src, char delim)
+{
+	size_t len;
+
+	len = strlen(src) + 1;
+	lvalp->gs = gc_string_alloc(scanner, len);
+	if (src[0] == 'L') {
+		// TODO: import wide string
+		printfl_error(yyget_lineno(scanner),
+			"Wide string not supported yet.");
+		return -1;
+	} else {
+		return import_basic_string(scanner, lvalp, len, src, delim);
+	}
+}
+
 static void init_scope(struct ctf_scanner_scope *scope,
 		       struct ctf_scanner_scope *parent)
 {
@@ -194,6 +331,7 @@ static int lookup_type(struct ctf_scanner_scope *s, const char *id)
 	return ret;
 }
 
+BT_HIDDEN
 int is_type(struct ctf_scanner *scanner, const char *id)
 {
 	struct ctf_scanner_scope *it;
@@ -228,40 +366,50 @@ static struct ctf_node *make_node(struct ctf_scanner *scanner,
 		return NULL;
 	memset(node, 0, sizeof(*node));
 	node->type = type;
-	CDS_INIT_LIST_HEAD(&node->tmp_head);
-	cds_list_add(&node->gc, &ast->allocated_nodes);
-	cds_list_add(&node->siblings, &node->tmp_head);
+	node->lineno = yyget_lineno(scanner->scanner);
+	BT_INIT_LIST_HEAD(&node->tmp_head);
+	bt_list_add(&node->gc, &ast->allocated_nodes);
+	bt_list_add(&node->siblings, &node->tmp_head);
 
 	switch (type) {
 	case NODE_ROOT:
-		fprintf(stderr, "[error] %s: trying to create root node\n", __func__);
+		printfn_fatal(node, "trying to create root node");
 		break;
 
 	case NODE_EVENT:
-		CDS_INIT_LIST_HEAD(&node->u.event.declaration_list);
+		BT_INIT_LIST_HEAD(&node->u.event.declaration_list);
 		break;
 	case NODE_STREAM:
-		CDS_INIT_LIST_HEAD(&node->u.stream.declaration_list);
+		BT_INIT_LIST_HEAD(&node->u.stream.declaration_list);
+		break;
+	case NODE_ENV:
+		BT_INIT_LIST_HEAD(&node->u.env.declaration_list);
 		break;
 	case NODE_TRACE:
-		CDS_INIT_LIST_HEAD(&node->u.trace.declaration_list);
+		BT_INIT_LIST_HEAD(&node->u.trace.declaration_list);
+		break;
+	case NODE_CLOCK:
+		BT_INIT_LIST_HEAD(&node->u.clock.declaration_list);
+		break;
+	case NODE_CALLSITE:
+		BT_INIT_LIST_HEAD(&node->u.callsite.declaration_list);
 		break;
 
 	case NODE_CTF_EXPRESSION:
-		CDS_INIT_LIST_HEAD(&node->u.ctf_expression.left);
-		CDS_INIT_LIST_HEAD(&node->u.ctf_expression.right);
+		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:
-		CDS_INIT_LIST_HEAD(&node->u._typedef.type_declarators);
+		BT_INIT_LIST_HEAD(&node->u._typedef.type_declarators);
 		break;
 	case NODE_TYPEALIAS_TARGET:
-		CDS_INIT_LIST_HEAD(&node->u.typealias_target.type_declarators);
+		BT_INIT_LIST_HEAD(&node->u.typealias_target.type_declarators);
 		break;
 	case NODE_TYPEALIAS_ALIAS:
-		CDS_INIT_LIST_HEAD(&node->u.typealias_alias.type_declarators);
+		BT_INIT_LIST_HEAD(&node->u.typealias_alias.type_declarators);
 		break;
 	case NODE_TYPEALIAS:
 		break;
@@ -269,44 +417,43 @@ static struct ctf_node *make_node(struct ctf_scanner *scanner,
 	case NODE_TYPE_SPECIFIER:
 		break;
 	case NODE_TYPE_SPECIFIER_LIST:
-		CDS_INIT_LIST_HEAD(&node->u.type_specifier_list.head);
+		BT_INIT_LIST_HEAD(&node->u.type_specifier_list.head);
 		break;
 	case NODE_POINTER:
 		break;
 	case NODE_TYPE_DECLARATOR:
-		CDS_INIT_LIST_HEAD(&node->u.type_declarator.pointers);
+		BT_INIT_LIST_HEAD(&node->u.type_declarator.pointers);
 		break;
 
 	case NODE_FLOATING_POINT:
-		CDS_INIT_LIST_HEAD(&node->u.floating_point.expressions);
+		BT_INIT_LIST_HEAD(&node->u.floating_point.expressions);
 		break;
 	case NODE_INTEGER:
-		CDS_INIT_LIST_HEAD(&node->u.integer.expressions);
+		BT_INIT_LIST_HEAD(&node->u.integer.expressions);
 		break;
 	case NODE_STRING:
-		CDS_INIT_LIST_HEAD(&node->u.string.expressions);
+		BT_INIT_LIST_HEAD(&node->u.string.expressions);
 		break;
 	case NODE_ENUMERATOR:
-		CDS_INIT_LIST_HEAD(&node->u.enumerator.values);
+		BT_INIT_LIST_HEAD(&node->u.enumerator.values);
 		break;
 	case NODE_ENUM:
-		CDS_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
+		BT_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
 		break;
 	case NODE_STRUCT_OR_VARIANT_DECLARATION:
-		CDS_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.type_declarators);
+		BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.type_declarators);
 		break;
 	case NODE_VARIANT:
-		CDS_INIT_LIST_HEAD(&node->u.variant.declaration_list);
+		BT_INIT_LIST_HEAD(&node->u.variant.declaration_list);
 		break;
 	case NODE_STRUCT:
-		CDS_INIT_LIST_HEAD(&node->u._struct.declaration_list);
-		CDS_INIT_LIST_HEAD(&node->u._struct.min_align);
+		BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
+		BT_INIT_LIST_HEAD(&node->u._struct.min_align);
 		break;
 
 	case NODE_UNKNOWN:
 	default:
-		fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
-			(int) type);
+		printfn_fatal(node, "unknown node type '%d'", (int) type);
 		break;
 	}
 
@@ -318,22 +465,31 @@ static int reparent_ctf_expression(struct ctf_node *node,
 {
 	switch (parent->type) {
 	case NODE_EVENT:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
 		break;
 	case NODE_STREAM:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+		break;
+	case NODE_ENV:
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
 		break;
 	case NODE_TRACE:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+		break;
+	case NODE_CLOCK:
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
+		break;
+	case NODE_CALLSITE:
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
 		break;
 	case NODE_FLOATING_POINT:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
 		break;
 	case NODE_INTEGER:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
 		break;
 	case NODE_STRING:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
 		break;
 
 	case NODE_ROOT:
@@ -356,8 +512,7 @@ static int reparent_ctf_expression(struct ctf_node *node,
 
 	case NODE_UNKNOWN:
 	default:
-		fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
-			(int) parent->type);
+		printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
 		return -EINVAL;
 	}
 	return 0;
@@ -367,22 +522,31 @@ static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
 {
 	switch (parent->type) {
 	case NODE_ROOT:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
 		break;
 	case NODE_EVENT:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
 		break;
 	case NODE_STREAM:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+		break;
+	case NODE_ENV:
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
 		break;
 	case NODE_TRACE:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+		break;
+	case NODE_CLOCK:
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
+		break;
+	case NODE_CALLSITE:
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
 		break;
 	case NODE_VARIANT:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
 		break;
 	case NODE_STRUCT:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
 		break;
 
 	case NODE_FLOATING_POINT:
@@ -405,8 +569,7 @@ static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
 
 	case NODE_UNKNOWN:
 	default:
-		fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
-			(int) parent->type);
+		printfn_fatal(node, "unknown node type %d", parent->type);
 		return -EINVAL;
 	}
 	return 0;
@@ -416,22 +579,31 @@ static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
 {
 	switch (parent->type) {
 	case NODE_ROOT:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
 		break;
 	case NODE_EVENT:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
 		break;
 	case NODE_STREAM:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+		break;
+	case NODE_ENV:
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
 		break;
 	case NODE_TRACE:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+		break;
+	case NODE_CLOCK:
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
+		break;
+	case NODE_CALLSITE:
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
 		break;
 	case NODE_VARIANT:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
 		break;
 	case NODE_STRUCT:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
 		break;
 
 	case NODE_FLOATING_POINT:
@@ -454,8 +626,7 @@ static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
 
 	case NODE_UNKNOWN:
 	default:
-		fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
-			(int) parent->type);
+		printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
 		return -EINVAL;
 	}
 	return 0;
@@ -466,13 +637,16 @@ static int reparent_type_specifier(struct ctf_node *node,
 {
 	switch (parent->type) {
 	case NODE_TYPE_SPECIFIER_LIST:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.type_specifier_list.head);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.type_specifier_list.head);
 		break;
 
 	case NODE_TYPE_SPECIFIER:
 	case NODE_EVENT:
 	case NODE_STREAM:
+	case NODE_ENV:
 	case NODE_TRACE:
+	case NODE_CLOCK:
+	case NODE_CALLSITE:
 	case NODE_VARIANT:
 	case NODE_STRUCT:
 	case NODE_TYPEDEF:
@@ -493,8 +667,7 @@ static int reparent_type_specifier(struct ctf_node *node,
 
 	case NODE_UNKNOWN:
 	default:
-		fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
-			(int) parent->type);
+		printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
 		return -EINVAL;
 	}
 	return 0;
@@ -505,22 +678,31 @@ static int reparent_type_specifier_list(struct ctf_node *node,
 {
 	switch (parent->type) {
 	case NODE_ROOT:
-		cds_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
+		bt_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
 		break;
 	case NODE_EVENT:
-		cds_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
+		bt_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
 		break;
 	case NODE_STREAM:
-		cds_list_add_tail(&node->siblings, &parent->u.stream.declaration_list);
+		bt_list_add_tail(&node->siblings, &parent->u.stream.declaration_list);
+		break;
+	case NODE_ENV:
+		bt_list_add_tail(&node->siblings, &parent->u.env.declaration_list);
 		break;
 	case NODE_TRACE:
-		cds_list_add_tail(&node->siblings, &parent->u.trace.declaration_list);
+		bt_list_add_tail(&node->siblings, &parent->u.trace.declaration_list);
+		break;
+	case NODE_CLOCK:
+		bt_list_add_tail(&node->siblings, &parent->u.clock.declaration_list);
+		break;
+	case NODE_CALLSITE:
+		bt_list_add_tail(&node->siblings, &parent->u.callsite.declaration_list);
 		break;
 	case NODE_VARIANT:
-		cds_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
+		bt_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
 		break;
 	case NODE_STRUCT:
-		cds_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
+		bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
 		break;
 	case NODE_TYPEDEF:
 		parent->u._typedef.type_specifier_list = node;
@@ -551,8 +733,7 @@ static int reparent_type_specifier_list(struct ctf_node *node,
 
 	case NODE_UNKNOWN:
 	default:
-		fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
-			(int) parent->type);
+		printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
 		return -EINVAL;
 	}
 	return 0;
@@ -567,22 +748,25 @@ static int reparent_type_declarator(struct ctf_node *node,
 		parent->u.type_declarator.u.nested.type_declarator = node;
 		break;
 	case NODE_STRUCT_OR_VARIANT_DECLARATION:
-		_cds_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.type_declarators);
 		break;
 	case NODE_TYPEDEF:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u._typedef.type_declarators);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u._typedef.type_declarators);
 		break;
 	case NODE_TYPEALIAS_TARGET:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.type_declarators);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.type_declarators);
 		break;
 	case NODE_TYPEALIAS_ALIAS:
-		_cds_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.type_declarators);
+		_bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.type_declarators);
 		break;
 
 	case NODE_ROOT:
 	case NODE_EVENT:
 	case NODE_STREAM:
+	case NODE_ENV:
 	case NODE_TRACE:
+	case NODE_CLOCK:
+	case NODE_CALLSITE:
 	case NODE_VARIANT:
 	case NODE_STRUCT:
 	case NODE_TYPEALIAS:
@@ -600,8 +784,7 @@ static int reparent_type_declarator(struct ctf_node *node,
 
 	case NODE_UNKNOWN:
 	default:
-		fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
-			(int) parent->type);
+		printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
 		return -EINVAL;
 	}
 	return 0;
@@ -624,26 +807,47 @@ static int set_parent_node(struct ctf_node *node,
 
 	switch (node->type) {
 	case NODE_ROOT:
-		fprintf(stderr, "[error] %s: trying to reparent root node\n", __func__);
+		printfn_fatal(node, "trying to reparent root node");
 		return -EINVAL;
 
 	case NODE_EVENT:
 		if (parent->type == NODE_ROOT) {
-			_cds_list_splice_tail(&node->tmp_head, &parent->u.root.event);
+			_bt_list_splice_tail(&node->tmp_head, &parent->u.root.event);
 		} else {
 			return -EPERM;
 		}
 		break;
 	case NODE_STREAM:
 		if (parent->type == NODE_ROOT) {
-			_cds_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
+			_bt_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
+		} else {
+			return -EPERM;
+		}
+		break;
+	case NODE_ENV:
+		if (parent->type == NODE_ROOT) {
+			_bt_list_splice_tail(&node->tmp_head, &parent->u.root.env);
 		} else {
 			return -EPERM;
 		}
 		break;
 	case NODE_TRACE:
 		if (parent->type == NODE_ROOT) {
-			_cds_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
+			_bt_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
+		} else {
+			return -EPERM;
+		}
+		break;
+	case NODE_CLOCK:
+		if (parent->type == NODE_ROOT) {
+			_bt_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
+		} else {
+			return -EPERM;
+		}
+		break;
+	case NODE_CALLSITE:
+		if (parent->type == NODE_ROOT) {
+			_bt_list_splice_tail(&node->tmp_head, &parent->u.root.callsite);
 		} else {
 			return -EPERM;
 		}
@@ -675,7 +879,7 @@ static int set_parent_node(struct ctf_node *node,
 
 	case NODE_POINTER:
 		if (parent->type == NODE_TYPE_DECLARATOR) {
-			_cds_list_splice_tail(&node->tmp_head, &parent->u.type_declarator.pointers);
+			_bt_list_splice_tail(&node->tmp_head, &parent->u.type_declarator.pointers);
 		} else
 			return -EPERM;
 		break;
@@ -698,7 +902,7 @@ static int set_parent_node(struct ctf_node *node,
 
 	case NODE_ENUMERATOR:
 		if (parent->type == NODE_ENUM) {
-			_cds_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
+			_bt_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
 		} else {
 			return -EPERM;
 		}
@@ -706,10 +910,10 @@ static int set_parent_node(struct ctf_node *node,
 	case NODE_STRUCT_OR_VARIANT_DECLARATION:
 		switch (parent->type) {
 		case NODE_STRUCT:
-			_cds_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
+			_bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
 			break;
 		case NODE_VARIANT:
-			_cds_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
+			_bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
 			break;
 		default:
 			return -EINVAL;
@@ -718,18 +922,21 @@ static int set_parent_node(struct ctf_node *node,
 
 	case NODE_UNKNOWN:
 	default:
-		fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
-			(int) parent->type);
+		printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
 		return -EINVAL;
 	}
 	return 0;
 }
 
+BT_HIDDEN
 void yyerror(struct ctf_scanner *scanner, const char *str)
 {
-	fprintf(stderr, "error %s\n", str);
+	printfl_error(yyget_lineno(scanner->scanner),
+		"token \"%s\": %s\n",
+		yyget_text(scanner->scanner), str);
 }
  
+BT_HIDDEN
 int yywrap(void)
 {
 	return 1;
@@ -737,15 +944,15 @@ int yywrap(void)
 
 #define reparent_error(scanner, str)				\
 do {								\
-	yyerror(scanner, YY_("reparent_error: " str "\n"));	\
+	yyerror(scanner, YY_("reparent_error: " str));	\
 	YYERROR;						\
 } while (0)
 
-static void free_strings(struct cds_list_head *list)
+static void free_strings(struct bt_list_head *list)
 {
 	struct gc_string *gstr, *tmp;
 
-	cds_list_for_each_entry_safe(gstr, tmp, list, gc)
+	bt_list_for_each_entry_safe(gstr, tmp, list, gc)
 		free(gstr);
 }
 
@@ -757,13 +964,16 @@ static struct ctf_ast *ctf_ast_alloc(void)
 	if (!ast)
 		return NULL;
 	memset(ast, 0, sizeof(*ast));
-	CDS_INIT_LIST_HEAD(&ast->allocated_nodes);
+	BT_INIT_LIST_HEAD(&ast->allocated_nodes);
 	ast->root.type = NODE_ROOT;
-	CDS_INIT_LIST_HEAD(&ast->root.tmp_head);
-	CDS_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
-	CDS_INIT_LIST_HEAD(&ast->root.u.root.trace);
-	CDS_INIT_LIST_HEAD(&ast->root.u.root.stream);
-	CDS_INIT_LIST_HEAD(&ast->root.u.root.event);
+	BT_INIT_LIST_HEAD(&ast->root.tmp_head);
+	BT_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
+	BT_INIT_LIST_HEAD(&ast->root.u.root.trace);
+	BT_INIT_LIST_HEAD(&ast->root.u.root.env);
+	BT_INIT_LIST_HEAD(&ast->root.u.root.stream);
+	BT_INIT_LIST_HEAD(&ast->root.u.root.event);
+	BT_INIT_LIST_HEAD(&ast->root.u.root.clock);
+	BT_INIT_LIST_HEAD(&ast->root.u.root.callsite);
 	return ast;
 }
 
@@ -771,8 +981,9 @@ static void ctf_ast_free(struct ctf_ast *ast)
 {
 	struct ctf_node *node, *tmp;
 
-	cds_list_for_each_entry_safe(node, tmp, &ast->allocated_nodes, gc)
+	bt_list_for_each_entry_safe(node, tmp, &ast->allocated_nodes, gc)
 		free(node);
+	free(ast);
 }
 
 int ctf_scanner_append_ast(struct ctf_scanner *scanner)
@@ -794,7 +1005,7 @@ struct ctf_scanner *ctf_scanner_alloc(FILE *input)
 
 	ret = yylex_init_extra(scanner, &scanner->scanner);
 	if (ret) {
-		fprintf(stderr, "yylex_init error\n");
+		printf_fatal("yylex_init error");
 		goto cleanup_scanner;
 	}
 	/* Start processing new stream */
@@ -805,7 +1016,7 @@ struct ctf_scanner *ctf_scanner_alloc(FILE *input)
 		goto cleanup_lexer;
 	init_scope(&scanner->root_scope, NULL);
 	scanner->cs = &scanner->root_scope;
-	CDS_INIT_LIST_HEAD(&scanner->allocated_strings);
+	BT_INIT_LIST_HEAD(&scanner->allocated_strings);
 
 	if (yydebug)
 		fprintf(stdout, "Scanner input is a%s.\n",
@@ -817,7 +1028,7 @@ struct ctf_scanner *ctf_scanner_alloc(FILE *input)
 cleanup_lexer:
 	ret = yylex_destroy(scanner->scanner);
 	if (!ret)
-		fprintf(stderr, "yylex_destroy error\n");
+		printf_fatal("yylex_destroy error");
 cleanup_scanner:
 	free(scanner);
 	return NULL;
@@ -832,7 +1043,7 @@ void ctf_scanner_free(struct ctf_scanner *scanner)
 	ctf_ast_free(scanner->ast);
 	ret = yylex_destroy(scanner->scanner);
 	if (ret)
-		fprintf(stderr, "yylex_destroy error\n");
+		printf_error("yylex_destroy error");
 	free(scanner);
 }
 
@@ -840,6 +1051,7 @@ void ctf_scanner_free(struct ctf_scanner *scanner)
 
 %define api.pure
 	/* %locations */
+%error-verbose
 %parse-param {struct ctf_scanner *scanner}
 %lex-param {struct ctf_scanner *scanner}
 /*
@@ -852,26 +1064,32 @@ void ctf_scanner_free(struct ctf_scanner *scanner)
  */
 %expect 2
 %start file
-%token CHARACTER_CONSTANT_START SQUOTE STRING_LITERAL_START DQUOTE ESCSEQ CHAR_STRING_TOKEN LSBRAC RSBRAC LPAREN RPAREN LBRAC RBRAC RARROW STAR PLUS MINUS LT GT TYPEASSIGN COLON SEMICOLON DOTDOTDOT DOT EQUAL COMMA CONST CHAR DOUBLE ENUM EVENT FLOATING_POINT FLOAT INTEGER INT LONG SHORT SIGNED STREAM STRING STRUCT TRACE TYPEALIAS TYPEDEF UNSIGNED VARIANT VOID _BOOL _COMPLEX _IMAGINARY DECIMAL_CONSTANT OCTAL_CONSTANT HEXADECIMAL_CONSTANT TOK_ALIGN
+%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 <gs> IDENTIFIER ID_TYPE
 %token ERROR
 %union
 {
 	long long ll;
+	unsigned long long ull;
 	char c;
 	struct gc_string *gs;
 	struct ctf_node *n;
 }
 
+%type <gs> STRING_LITERAL CHARACTER_LITERAL
+
 %type <gs> keywords
-%type <gs> s_char s_char_sequence c_char c_char_sequence
 
+%type <ull> INTEGER_LITERAL
 %type <n> postfix_expression unary_expression unary_expression_or_range
 
 %type <n> declaration
 %type <n> event_declaration
 %type <n> stream_declaration
+%type <n> env_declaration
 %type <n> trace_declaration
+%type <n> clock_declaration
+%type <n> callsite_declaration
 %type <n> integer_declaration_specifiers
 %type <n> declaration_specifiers
 %type <n> alias_declaration_specifiers
@@ -962,47 +1180,18 @@ keywords:
 		{	$$ = yylval.gs;		}
 	|	STREAM
 		{	$$ = yylval.gs;		}
+	|	ENV
+		{	$$ = yylval.gs;		}
 	|	TRACE
 		{	$$ = yylval.gs;		}
+	|	CLOCK
+		{	$$ = yylval.gs;		}
+	|	CALLSITE
+		{	$$ = yylval.gs;		}
 	|	TOK_ALIGN
 		{	$$ = yylval.gs;		}
 	;
 
-/* 1.5 Constants */
-
-c_char_sequence:
-		c_char
-		{	$$ = $1;					}
-	|	c_char_sequence c_char
-		{	$$ = gc_string_append(scanner, $1, $2);		}
-	;
-
-c_char:
-		CHAR_STRING_TOKEN
-		{	$$ = yylval.gs;					}
-	|	ESCSEQ
-		{
-			reparent_error(scanner, "escape sequences not supported yet");
-		}
-	;
-
-/* 1.6 String literals */
-
-s_char_sequence:
-		s_char
-		{	$$ = $1;					}
-	|	s_char_sequence s_char
-		{	$$ = gc_string_append(scanner, $1, $2);		}
-	;
-
-s_char:
-		CHAR_STRING_TOKEN
-		{	$$ = yylval.gs;					}
-	|	ESCSEQ
-		{
-			reparent_error(scanner, "escape sequences not supported yet");
-		}
-	;
 
 /* 2: Phrase structure grammar */
 
@@ -1025,44 +1214,23 @@ postfix_expression:
 			$$->u.unary_expression.type = UNARY_STRING;
 			$$->u.unary_expression.u.string = yylval.gs->s;
 		}
-	|	DECIMAL_CONSTANT
+	|	INTEGER_LITERAL
 		{
 			$$ = make_node(scanner, NODE_UNARY_EXPRESSION);
 			$$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
-			sscanf(yylval.gs->s, "%" PRIu64,
-			       &$$->u.unary_expression.u.unsigned_constant);
+			$$->u.unary_expression.u.unsigned_constant = $1;
 		}
-	|	OCTAL_CONSTANT
-		{
-			$$ = make_node(scanner, NODE_UNARY_EXPRESSION);
-			$$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
-			sscanf(yylval.gs->s, "0%" PRIo64,
-			       &$$->u.unary_expression.u.unsigned_constant);
-		}
-	|	HEXADECIMAL_CONSTANT
-		{
-			$$ = make_node(scanner, NODE_UNARY_EXPRESSION);
-			$$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
-			sscanf(yylval.gs->s, "0x%" PRIx64,
-			       &$$->u.unary_expression.u.unsigned_constant);
-		}
-	|	STRING_LITERAL_START DQUOTE
+	|	STRING_LITERAL
 		{
 			$$ = make_node(scanner, NODE_UNARY_EXPRESSION);
 			$$->u.unary_expression.type = UNARY_STRING;
-			$$->u.unary_expression.u.string = "";
+			$$->u.unary_expression.u.string = $1->s;
 		}
-	|	STRING_LITERAL_START s_char_sequence DQUOTE
+	|	CHARACTER_LITERAL
 		{
 			$$ = make_node(scanner, NODE_UNARY_EXPRESSION);
 			$$->u.unary_expression.type = UNARY_STRING;
-			$$->u.unary_expression.u.string = $2->s;
-		}
-	|	CHARACTER_CONSTANT_START c_char_sequence SQUOTE
-		{
-			$$ = make_node(scanner, NODE_UNARY_EXPRESSION);
-			$$->u.unary_expression.type = UNARY_STRING;
-			$$->u.unary_expression.u.string = $2->s;
+			$$->u.unary_expression.u.string = $1->s;
 		}
 	|	LPAREN unary_expression RPAREN
 		{
@@ -1075,8 +1243,8 @@ postfix_expression:
 			$$ = make_node(scanner, NODE_UNARY_EXPRESSION);
 			$$->u.unary_expression.type = UNARY_SBRAC;
 			$$->u.unary_expression.u.sbrac_exp = $3;
-			cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
-			cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
+			bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
+			bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
 		}
 	|	postfix_expression DOT IDENTIFIER
 		{
@@ -1084,8 +1252,8 @@ postfix_expression:
 			$$->u.unary_expression.type = UNARY_STRING;
 			$$->u.unary_expression.u.string = yylval.gs->s;
 			$$->u.unary_expression.link = UNARY_DOTLINK;
-			cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
-			cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
+			bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
+			bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
 		}
 	|	postfix_expression DOT ID_TYPE
 		{
@@ -1093,8 +1261,8 @@ postfix_expression:
 			$$->u.unary_expression.type = UNARY_STRING;
 			$$->u.unary_expression.u.string = yylval.gs->s;
 			$$->u.unary_expression.link = UNARY_DOTLINK;
-			cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
-			cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
+			bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
+			bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
 		}
 	|	postfix_expression RARROW IDENTIFIER
 		{
@@ -1102,8 +1270,8 @@ postfix_expression:
 			$$->u.unary_expression.type = UNARY_STRING;
 			$$->u.unary_expression.u.string = yylval.gs->s;
 			$$->u.unary_expression.link = UNARY_ARROWLINK;
-			cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
-			cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
+			bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
+			bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
 		}
 	|	postfix_expression RARROW ID_TYPE
 		{
@@ -1111,8 +1279,8 @@ postfix_expression:
 			$$->u.unary_expression.type = UNARY_STRING;
 			$$->u.unary_expression.u.string = yylval.gs->s;
 			$$->u.unary_expression.link = UNARY_ARROWLINK;
-			cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
-			cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
+			bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
+			bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
 		}
 	;
 
@@ -1120,21 +1288,25 @@ unary_expression:
 		postfix_expression
 		{	$$ = $1;				}
 	|	PLUS postfix_expression
-		{	$$ = $2;				}
-	|	MINUS postfix_expression
 		{
 			$$ = $2;
-			if ($$->u.unary_expression.type != UNARY_SIGNED_CONSTANT
-				&& $$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT)
+			if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
+				&& $$->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
 				reparent_error(scanner, "expecting numeric constant");
-
+			}
+		}
+	|	MINUS postfix_expression
+		{
+			$$ = $2;
 			if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
 				$$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
 				$$->u.unary_expression.u.signed_constant =
 					-($$->u.unary_expression.u.unsigned_constant);
-			} else {
+			} else if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
 				$$->u.unary_expression.u.signed_constant =
 					-($$->u.unary_expression.u.signed_constant);
+			} else {
+				reparent_error(scanner, "expecting numeric constant");
 			}
 		}
 	;
@@ -1143,7 +1315,7 @@ unary_expression_or_range:
 		unary_expression DOTDOTDOT unary_expression
 		{
 			$$ = $1;
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
+			_bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
 			$3->u.unary_expression.link = UNARY_DOTDOTDOT;
 		}
 	|	unary_expression
@@ -1159,8 +1331,14 @@ declaration:
 		{	$$ = $1;	}
 	|	stream_declaration
 		{	$$ = $1;	}
+	|	env_declaration
+		{	$$ = $1;	}
 	|	trace_declaration
 		{	$$ = $1;	}
+	|	clock_declaration
+		{	$$ = $1;	}
+	|	callsite_declaration
+		{	$$ = $1;	}
 	|	declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
 		{
 			struct ctf_node *list;
@@ -1168,9 +1346,9 @@ declaration:
 			$$ = make_node(scanner, NODE_TYPEDEF);
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			$$->u._typedef.type_specifier_list = list;
-			_cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
+			_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);
 		}
 	|	TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
 		{
@@ -1179,8 +1357,8 @@ declaration:
 			$$ = make_node(scanner, NODE_TYPEDEF);
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			$$->u._typedef.type_specifier_list = list;
-			_cds_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+			_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);
 		}
 	|	declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
 		{
@@ -1189,8 +1367,8 @@ declaration:
 			$$ = make_node(scanner, NODE_TYPEDEF);
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			$$->u._typedef.type_specifier_list = list;
-			_cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+			_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);
 		}
 	|	TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
 		{
@@ -1202,13 +1380,13 @@ declaration:
 
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			$$->u.typealias.target->u.typealias_target.type_specifier_list = list;
-			_cds_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
+			_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);
 
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			$$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
-			_cds_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
+			_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);
 		}
 	;
 
@@ -1259,6 +1437,28 @@ stream_declaration_end:
 		{	pop_scope(scanner);	}
 	;
 
+env_declaration:
+		env_declaration_begin env_declaration_end
+		{
+			$$ = make_node(scanner, NODE_ENV);
+		}
+	|	env_declaration_begin ctf_assignment_expression_list env_declaration_end
+		{
+			$$ = make_node(scanner, NODE_ENV);
+			if (set_parent_node($2, $$))
+				reparent_error(scanner, "env declaration");
+		}
+	;
+
+env_declaration_begin:
+		ENV LBRAC
+		{	push_scope(scanner);	}
+	;
+
+env_declaration_end:
+		RBRAC SEMICOLON
+		{	pop_scope(scanner);	}
+	;
 
 trace_declaration:
 		trace_declaration_begin trace_declaration_end
@@ -1283,6 +1483,52 @@ trace_declaration_end:
 		{	pop_scope(scanner);	}
 	;
 
+clock_declaration:
+		CLOCK clock_declaration_begin clock_declaration_end
+		{
+			$$ = make_node(scanner, NODE_CLOCK);
+		}
+	|	CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
+		{
+			$$ = make_node(scanner, NODE_CLOCK);
+			if (set_parent_node($3, $$))
+				reparent_error(scanner, "trace_declaration");
+		}
+	;
+
+clock_declaration_begin:
+		LBRAC
+		{	push_scope(scanner);	}
+	;
+
+clock_declaration_end:
+		RBRAC SEMICOLON
+		{	pop_scope(scanner);	}
+	;
+
+callsite_declaration:
+		CALLSITE callsite_declaration_begin callsite_declaration_end
+		{
+			$$ = make_node(scanner, NODE_CALLSITE);
+		}
+	|	CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
+		{
+			$$ = make_node(scanner, NODE_CALLSITE);
+			if (set_parent_node($3, $$))
+				reparent_error(scanner, "trace_declaration");
+		}
+	;
+
+callsite_declaration_begin:
+		LBRAC
+		{	push_scope(scanner);	}
+	;
+
+callsite_declaration_end:
+		RBRAC SEMICOLON
+		{	pop_scope(scanner);	}
+	;
+
 integer_declaration_specifiers:
 		CONST
 		{
@@ -1291,7 +1537,7 @@ integer_declaration_specifiers:
 			$$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			node = make_node(scanner, NODE_TYPE_SPECIFIER);
 			node->u.type_specifier.type = TYPESPEC_CONST;
-			cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
 		}
 	|	integer_type_specifier
 		{
@@ -1299,7 +1545,7 @@ integer_declaration_specifiers:
 
 			$$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			node = $1;
-			cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
 		}
 	|	integer_declaration_specifiers CONST
 		{
@@ -1308,12 +1554,12 @@ integer_declaration_specifiers:
 			$$ = $1;
 			node = make_node(scanner, NODE_TYPE_SPECIFIER);
 			node->u.type_specifier.type = TYPESPEC_CONST;
-			cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
 		}
 	|	integer_declaration_specifiers integer_type_specifier
 		{
 			$$ = $1;
-			cds_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
 		}
 	;
 
@@ -1325,7 +1571,7 @@ declaration_specifiers:
 			$$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			node = make_node(scanner, NODE_TYPE_SPECIFIER);
 			node->u.type_specifier.type = TYPESPEC_CONST;
-			cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
 		}
 	|	type_specifier
 		{
@@ -1333,7 +1579,7 @@ declaration_specifiers:
 
 			$$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			node = $1;
-			cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
 		}
 	|	declaration_specifiers CONST
 		{
@@ -1342,12 +1588,12 @@ declaration_specifiers:
 			$$ = $1;
 			node = make_node(scanner, NODE_TYPE_SPECIFIER);
 			node->u.type_specifier.type = TYPESPEC_CONST;
-			cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
 		}
 	|	declaration_specifiers type_specifier
 		{
 			$$ = $1;
-			cds_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
 		}
 	;
 
@@ -1357,7 +1603,7 @@ type_declarator_list:
 	|	type_declarator_list COMMA type_declarator
 		{
 			$$ = $1;
-			cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+			bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
 		}
 	;
 
@@ -1594,7 +1840,7 @@ struct_type_specifier:
 		{
 			$$ = make_node(scanner, NODE_STRUCT);
 			$$->u._struct.has_body = 1;
-			cds_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
+			bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
 			if ($2 && set_parent_node($2, $$))
 				reparent_error(scanner, "struct reparent error");
 		}
@@ -1603,7 +1849,7 @@ struct_type_specifier:
 			$$ = make_node(scanner, NODE_STRUCT);
 			$$->u._struct.has_body = 1;
 			$$->u._struct.name = $1->s;
-			cds_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
+			bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
 			if ($3 && set_parent_node($3, $$))
 				reparent_error(scanner, "struct reparent error");
 		}
@@ -1612,7 +1858,7 @@ struct_type_specifier:
 			$$ = make_node(scanner, NODE_STRUCT);
 			$$->u._struct.has_body = 1;
 			$$->u._struct.name = $1->s;
-			cds_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
+			bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
 			if ($3 && set_parent_node($3, $$))
 				reparent_error(scanner, "struct reparent error");
 		}
@@ -1749,21 +1995,21 @@ enum_type_specifier:
 		{
 			$$ = make_node(scanner, NODE_ENUM);
 			$$->u._enum.has_body = 1;
-			_cds_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
+			_bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
 		}
 	|	COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
 		{
 			$$ = make_node(scanner, NODE_ENUM);
 			$$->u._enum.has_body = 1;
 			($$)->u._enum.container_type = $2;
-			_cds_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
+			_bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
 		}
 	|	IDENTIFIER LBRAC enumerator_list RBRAC
 		{
 			$$ = make_node(scanner, NODE_ENUM);
 			$$->u._enum.has_body = 1;
 			$$->u._enum.enum_id = $1->s;
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
+			_bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
 		}
 	|	IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
 		{
@@ -1771,14 +2017,14 @@ enum_type_specifier:
 			$$->u._enum.has_body = 1;
 			$$->u._enum.enum_id = $1->s;
 			($$)->u._enum.container_type = $3;
-			_cds_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
+			_bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
 		}
 	|	ID_TYPE LBRAC enumerator_list RBRAC
 		{
 			$$ = make_node(scanner, NODE_ENUM);
 			$$->u._enum.has_body = 1;
 			$$->u._enum.enum_id = $1->s;
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
+			_bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
 		}
 	|	ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
 		{
@@ -1786,27 +2032,27 @@ enum_type_specifier:
 			$$->u._enum.has_body = 1;
 			$$->u._enum.enum_id = $1->s;
 			($$)->u._enum.container_type = $3;
-			_cds_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
+			_bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
 		}
 	|	LBRAC enumerator_list COMMA RBRAC
 		{
 			$$ = make_node(scanner, NODE_ENUM);
 			$$->u._enum.has_body = 1;
-			_cds_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
+			_bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
 		}
 	|	COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
 		{
 			$$ = make_node(scanner, NODE_ENUM);
 			$$->u._enum.has_body = 1;
 			($$)->u._enum.container_type = $2;
-			_cds_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
+			_bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
 		}
 	|	IDENTIFIER LBRAC enumerator_list COMMA RBRAC
 		{
 			$$ = make_node(scanner, NODE_ENUM);
 			$$->u._enum.has_body = 1;
 			$$->u._enum.enum_id = $1->s;
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
+			_bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
 		}
 	|	IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
 		{
@@ -1814,7 +2060,7 @@ enum_type_specifier:
 			$$->u._enum.has_body = 1;
 			$$->u._enum.enum_id = $1->s;
 			($$)->u._enum.container_type = $3;
-			_cds_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
+			_bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
 		}
 	|	IDENTIFIER
 		{
@@ -1827,7 +2073,7 @@ enum_type_specifier:
 			$$ = make_node(scanner, NODE_ENUM);
 			$$->u._enum.has_body = 1;
 			$$->u._enum.enum_id = $1->s;
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
+			_bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
 		}
 	|	ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
 		{
@@ -1835,7 +2081,7 @@ enum_type_specifier:
 			$$->u._enum.has_body = 1;
 			$$->u._enum.enum_id = $1->s;
 			($$)->u._enum.container_type = $3;
-			_cds_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
+			_bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
 		}
 	|	ID_TYPE
 		{
@@ -1852,10 +2098,10 @@ struct_or_variant_declaration_list:
 		{
 			if ($1) {
 				$$ = $1;
-				cds_list_add_tail(&($2)->siblings, &($$)->tmp_head);
+				bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
 			} else {
 				$$ = $2;
-				cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
+				bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
 			}
 		}
 	;
@@ -1866,10 +2112,10 @@ struct_or_variant_declaration:
 			struct ctf_node *list;
 
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-			_cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+			_bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
 			$$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
 			($$)->u.struct_or_variant_declaration.type_specifier_list = list;
-			_cds_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
+			_bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
 		}
 	|	declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
 		{
@@ -1878,9 +2124,9 @@ struct_or_variant_declaration:
 			$$ = make_node(scanner, NODE_TYPEDEF);
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			$$->u._typedef.type_specifier_list = list;
-			_cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
+			_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);
 		}
 	|	TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
 		{
@@ -1889,18 +2135,18 @@ struct_or_variant_declaration:
 			$$ = make_node(scanner, NODE_TYPEDEF);
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			$$->u._typedef.type_specifier_list = list;
-			_cds_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+			_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);
 		}
 	|	declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
 		{
 			struct ctf_node *list;
 
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-			_cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+			_bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
 			$$ = make_node(scanner, NODE_TYPEDEF);
 			($$)->u.struct_or_variant_declaration.type_specifier_list = list;
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+			_bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
 		}
 	|	TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
 		{
@@ -1912,13 +2158,13 @@ struct_or_variant_declaration:
 
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			$$->u.typealias.target->u.typealias_target.type_specifier_list = list;
-			_cds_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
+			_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);
 
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			$$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
-			_cds_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
+			_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);
 		}
 	;
 
@@ -1930,7 +2176,7 @@ alias_declaration_specifiers:
 			$$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			node = make_node(scanner, NODE_TYPE_SPECIFIER);
 			node->u.type_specifier.type = TYPESPEC_CONST;
-			cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
 		}
 	|	type_specifier
 		{
@@ -1938,7 +2184,7 @@ alias_declaration_specifiers:
 
 			$$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			node = $1;
-			cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
 		}
 	|	IDENTIFIER
 		{
@@ -1949,7 +2195,7 @@ alias_declaration_specifiers:
 			node = make_node(scanner, NODE_TYPE_SPECIFIER);
 			node->u.type_specifier.type = TYPESPEC_ID_TYPE;
 			node->u.type_specifier.id_type = yylval.gs->s;
-			cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
 		}
 	|	alias_declaration_specifiers CONST
 		{
@@ -1958,12 +2204,12 @@ alias_declaration_specifiers:
 			$$ = $1;
 			node = make_node(scanner, NODE_TYPE_SPECIFIER);
 			node->u.type_specifier.type = TYPESPEC_CONST;
-			cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
 		}
 	|	alias_declaration_specifiers type_specifier
 		{
 			$$ = $1;
-			cds_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
 		}
 	|	alias_declaration_specifiers IDENTIFIER
 		{
@@ -1974,7 +2220,7 @@ alias_declaration_specifiers:
 			node = make_node(scanner, NODE_TYPE_SPECIFIER);
 			node->u.type_specifier.type = TYPESPEC_ID_TYPE;
 			node->u.type_specifier.id_type = yylval.gs->s;
-			cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+			bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
 		}
 	;
 
@@ -1984,7 +2230,7 @@ struct_or_variant_declarator_list:
 	|	struct_or_variant_declarator_list COMMA struct_or_variant_declarator
 		{
 			$$ = $1;
-			cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+			bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
 		}
 	;
 
@@ -2007,7 +2253,7 @@ enumerator_list:
 	|	enumerator_list COMMA enumerator
 		{
 			$$ = $1;
-			cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+			bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
 		}
 	;
 
@@ -2027,45 +2273,34 @@ enumerator:
 			$$ = make_node(scanner, NODE_ENUMERATOR);
 			$$->u.enumerator.id = $1->s;
 		}
-	|	STRING_LITERAL_START DQUOTE
+	|	STRING_LITERAL
 		{
 			$$ = make_node(scanner, NODE_ENUMERATOR);
-			$$->u.enumerator.id = "";
-		}
-	|	STRING_LITERAL_START s_char_sequence DQUOTE
-		{
-			$$ = make_node(scanner, NODE_ENUMERATOR);
-			$$->u.enumerator.id = $2->s;
+			$$->u.enumerator.id = $1->s;
 		}
 	|	IDENTIFIER EQUAL unary_expression_or_range
 		{
 			$$ = make_node(scanner, NODE_ENUMERATOR);
 			$$->u.enumerator.id = $1->s;
-			cds_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
+			bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
 		}
 	|	ID_TYPE EQUAL unary_expression_or_range
 		{
 			$$ = make_node(scanner, NODE_ENUMERATOR);
 			$$->u.enumerator.id = $1->s;
-			cds_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
+			bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
 		}
 	|	keywords EQUAL unary_expression_or_range
 		{
 			$$ = make_node(scanner, NODE_ENUMERATOR);
 			$$->u.enumerator.id = $1->s;
-			cds_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
+			bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
 		}
-	|	STRING_LITERAL_START DQUOTE EQUAL unary_expression_or_range
+	|	STRING_LITERAL EQUAL unary_expression_or_range
 		{
 			$$ = make_node(scanner, NODE_ENUMERATOR);
-			$$->u.enumerator.id = "";
-			cds_list_splice(&($4)->tmp_head, &($$)->u.enumerator.values);
-		}
-	|	STRING_LITERAL_START s_char_sequence DQUOTE EQUAL unary_expression_or_range
-		{
-			$$ = make_node(scanner, NODE_ENUMERATOR);
-			$$->u.enumerator.id = $2->s;
-			cds_list_splice(&($5)->tmp_head, &($$)->u.enumerator.values);
+			$$->u.enumerator.id = $1->s;
+			bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
 		}
 	;
 
@@ -2075,7 +2310,7 @@ abstract_declarator_list:
 	|	abstract_declarator_list COMMA abstract_declarator
 		{
 			$$ = $1;
-			cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+			bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
 		}
 	;
 
@@ -2085,7 +2320,7 @@ abstract_declarator:
 	|	pointer direct_abstract_declarator
 		{
 			$$ = $2;
-			cds_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
+			bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
 		}
 	;
 
@@ -2113,8 +2348,8 @@ direct_abstract_declarator:
 			$$ = make_node(scanner, NODE_TYPE_DECLARATOR);
 			$$->u.type_declarator.type = TYPEDEC_NESTED;
 			$$->u.type_declarator.u.nested.type_declarator = $1;
-			CDS_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+			BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
+			_bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
 		}
 	|	direct_abstract_declarator LSBRAC RSBRAC
 		{
@@ -2131,7 +2366,7 @@ alias_abstract_declarator_list:
 	|	alias_abstract_declarator_list COMMA alias_abstract_declarator
 		{
 			$$ = $1;
-			cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+			bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
 		}
 	;
 
@@ -2141,7 +2376,7 @@ alias_abstract_declarator:
 	|	pointer direct_alias_abstract_declarator
 		{
 			$$ = $2;
-			cds_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
+			bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
 		}
 	;
 
@@ -2163,8 +2398,8 @@ direct_alias_abstract_declarator:
 			$$ = make_node(scanner, NODE_TYPE_DECLARATOR);
 			$$->u.type_declarator.type = TYPEDEC_NESTED;
 			$$->u.type_declarator.u.nested.type_declarator = $1;
-			CDS_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+			BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
+			_bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
 		}
 	|	direct_alias_abstract_declarator LSBRAC RSBRAC
 		{
@@ -2181,7 +2416,7 @@ declarator:
 	|	pointer direct_declarator
 		{
 			$$ = $2;
-			cds_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
+			bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
 		}
 	;
 
@@ -2203,8 +2438,8 @@ direct_declarator:
 			$$ = make_node(scanner, NODE_TYPE_DECLARATOR);
 			$$->u.type_declarator.type = TYPEDEC_NESTED;
 			$$->u.type_declarator.u.nested.type_declarator = $1;
-			CDS_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+			BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
+			_bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
 		}
 	;
 
@@ -2214,7 +2449,7 @@ type_declarator:
 	|	pointer direct_type_declarator
 		{
 			$$ = $2;
-			cds_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
+			bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
 		}
 	;
 
@@ -2237,8 +2472,8 @@ direct_type_declarator:
 			$$ = make_node(scanner, NODE_TYPE_DECLARATOR);
 			$$->u.type_declarator.type = TYPEDEC_NESTED;
 			$$->u.type_declarator.u.nested.type_declarator = $1;
-			CDS_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+			BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
+			_bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
 		}
 	;
 
@@ -2250,13 +2485,13 @@ pointer:
 	|	STAR pointer
 		{
 			$$ = make_node(scanner, NODE_POINTER);
-			cds_list_splice(&($2)->tmp_head, &($$)->tmp_head);
+			bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
 		}
 	|	STAR type_qualifier_list pointer
 		{
 			$$ = make_node(scanner, NODE_POINTER);
 			$$->u.pointer.const_qualifier = 1;
-			cds_list_splice(&($3)->tmp_head, &($$)->tmp_head);
+			bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
 		}
 	;
 
@@ -2274,7 +2509,7 @@ ctf_assignment_expression_list:
 	|	ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
 		{
 			$$ = $1;
-			cds_list_add_tail(&($2)->siblings, &($$)->tmp_head);
+			bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
 		}
 	;
 
@@ -2286,10 +2521,10 @@ ctf_assignment_expression:
 			 * set_parent_node.
 			 */
 			$$ = make_node(scanner, NODE_CTF_EXPRESSION);
-			_cds_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
+			_bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
 			if ($1->u.unary_expression.type != UNARY_STRING)
 				reparent_error(scanner, "ctf_assignment_expression left expects string");
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
+			_bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
 		}
 	|	unary_expression TYPEASSIGN declaration_specifiers	/* Only allow struct */
 		{
@@ -2298,21 +2533,21 @@ ctf_assignment_expression:
 			 * set_parent_node.
 			 */
 			$$ = make_node(scanner, NODE_CTF_EXPRESSION);
-			_cds_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
+			_bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
 			if ($1->u.unary_expression.type != UNARY_STRING)
 				reparent_error(scanner, "ctf_assignment_expression left expects string");
-			cds_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
+			bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
 		}
 	|	declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
 		{
 			struct ctf_node *list;
 
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-			_cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+			_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);
 			$$ = make_node(scanner, NODE_TYPEDEF);
 			($$)->u.struct_or_variant_declaration.type_specifier_list = list;
-			_cds_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
+			_bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
 		}
 	|	TYPEDEF declaration_specifiers type_declarator_list
 		{
@@ -2321,18 +2556,18 @@ ctf_assignment_expression:
 			$$ = make_node(scanner, NODE_TYPEDEF);
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			$$->u._typedef.type_specifier_list = list;
-			_cds_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+			_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);
 		}
 	|	declaration_specifiers TYPEDEF type_declarator_list
 		{
 			struct ctf_node *list;
 
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-			_cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+			_bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
 			$$ = make_node(scanner, NODE_TYPEDEF);
 			($$)->u.struct_or_variant_declaration.type_specifier_list = list;
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+			_bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
 		}
 	|	TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
 		{
@@ -2344,12 +2579,12 @@ ctf_assignment_expression:
 
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			$$->u.typealias.target->u.typealias_target.type_specifier_list = list;
-			_cds_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
+			_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);
 
 			list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
 			$$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
-			_cds_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-			_cds_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
+			_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);
 		}
 	;