X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast.c;h=db18071f86f0531fb933334ffb04792a375d7124;hb=d70f5307ecc25394fc2da35bf4167fea5ac4b9ec;hp=4bf325829c0182c6c19b9d4b7474155ac79f0bc0;hpb=f3e5e1221c7cb4595e80121913d1e9ec6212de09;p=cparser

diff --git a/ast.c b/ast.c
index 4bf3258..db18071 100644
--- a/ast.c
+++ b/ast.c
@@ -83,6 +83,7 @@ static unsigned get_expression_precedence(expression_kind_t kind)
 		[EXPR_CONST]                     = PREC_PRIM,
 		[EXPR_STRING_LITERAL]            = PREC_PRIM,
 		[EXPR_WIDE_STRING_LITERAL]       = PREC_PRIM,
+		[EXPR_COMPOUND_LITERAL]          = PREC_UNARY,
 		[EXPR_CALL]                      = PREC_PRIM,
 		[EXPR_CONDITIONAL]               = PREC_COND,
 		[EXPR_SELECT]                    = PREC_ACCESS,
@@ -155,15 +156,10 @@ static unsigned get_expression_precedence(expression_kind_t kind)
 		[EXPR_BINARY_ISLESSGREATER]      = PREC_PRIM,
 		[EXPR_BINARY_ISUNORDERED]        = PREC_PRIM
 	};
-#ifndef NDEBUG
-	if ((unsigned)kind >= (sizeof(prec)/sizeof(prec[0]))) {
-		panic("wrong expression kind");
-	}
+	assert((unsigned)kind < (sizeof(prec)/sizeof(prec[0])));
 	unsigned res = prec[kind];
-	if (res == PREC_BOTTOM) {
-		panic("expression kind not defined in get_expression_precedence()");
-	}
-#endif
+
+	assert(res != PREC_BOTTOM);
 	return res;
 }
 
@@ -250,12 +246,10 @@ static void print_string_literal(
  *
  * @param wstr  the wide string literal expression
  */
-static void print_wide_string_literal(
-	const wide_string_literal_expression_t *const wstr)
+static void print_quoted_wide_string(const wide_string_t *const wstr)
 {
 	fputs("L\"", out);
-	for (const wchar_rep_t *c   = wstr->value.begin,
-	                       *end = c + wstr->value.size;
+	for (const wchar_rep_t *c = wstr->begin, *end = wstr->begin + wstr->size;
 	     c != end; ++c) {
 		switch (*c) {
 			case L'\"':  fputs("\\\"", out); break;
@@ -295,6 +289,21 @@ static void print_wide_string_literal(
 	fputc('"', out);
 }
 
+static void print_wide_string_literal(
+	const wide_string_literal_expression_t *const wstr)
+{
+	print_quoted_wide_string(&wstr->value);
+}
+
+static void print_compound_literal(
+		const compound_literal_expression_t *expression)
+{
+	fputc('(', out);
+	print_type(expression->type);
+	fputs(") ", out);
+	print_initializer(expression->initializer);
+}
+
 /**
  * Prints a call expression.
  *
@@ -614,11 +623,10 @@ static void print_classify_type_expression(
  */
 static void print_designator(const designator_t *designator)
 {
-	fputs(designator->symbol->string, out);
-	for (designator = designator->next; designator != NULL; designator = designator->next) {
-		if (designator->array_access) {
+	for ( ; designator != NULL; designator = designator->next) {
+		if (designator->symbol == NULL) {
 			fputc('[', out);
-			print_expression_prec(designator->array_access, PREC_ACCESS);
+			print_expression_prec(designator->array_index, PREC_ACCESS);
 			fputc(']', out);
 		} else {
 			fputc('.', out);
@@ -686,6 +694,9 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p
 	case EXPR_WIDE_STRING_LITERAL:
 		print_wide_string_literal(&expression->wide_string);
 		break;
+	case EXPR_COMPOUND_LITERAL:
+		print_compound_literal(&expression->compound_literal);
+		break;
 	case EXPR_CALL:
 		print_call_expression(&expression->call);
 		break;
@@ -1124,23 +1135,45 @@ static void print_storage_class(unsigned storage_class)
  */
 void print_initializer(const initializer_t *initializer)
 {
-	if(initializer->kind == INITIALIZER_VALUE) {
+	if(initializer == NULL) {
+		fputs("{ NIL-INITIALIZER }", out);
+		return;
+	}
+
+	switch(initializer->kind) {
+	case INITIALIZER_VALUE: {
 		const initializer_value_t *value = &initializer->value;
 		print_expression(value->value);
 		return;
 	}
-
-	assert(initializer->kind == INITIALIZER_LIST);
-	fputs("{ ", out);
-	const initializer_list_t *list = &initializer->list;
-
-	for(size_t i = 0 ; i < list->len; ++i) {
-		if(i > 0) {
-			fputs(", ", out);
+	case INITIALIZER_LIST: {
+		assert(initializer->kind == INITIALIZER_LIST);
+		fputs("{ ", out);
+		const initializer_list_t *list = &initializer->list;
+
+		for(size_t i = 0 ; i < list->len; ++i) {
+			const initializer_t *sub_init = list->initializers[i];
+			print_initializer(list->initializers[i]);
+			if(i < list->len-1 && sub_init->kind != INITIALIZER_DESIGNATOR) {
+				fputs(", ", out);
+			}
 		}
-		print_initializer(list->initializers[i]);
+		fputs(" }", out);
+		return;
 	}
-	fputs("}", out);
+	case INITIALIZER_STRING:
+		print_quoted_string(&initializer->string.string, '"');
+		return;
+	case INITIALIZER_WIDE_STRING:
+		print_quoted_wide_string(&initializer->wide_string.string);
+		return;
+	case INITIALIZER_DESIGNATOR:
+		print_designator(initializer->designator.designator);
+		fputs(" = ", out);
+		return;
+	}
+
+	panic("invalid initializer kind found");
 }
 
 /**
@@ -1332,6 +1365,10 @@ bool is_constant_expression(const expression_t *expression)
 		return is_constant_expression(expression->binary.left)
 			&& is_constant_expression(expression->binary.right);
 
+	case EXPR_COMPOUND_LITERAL:
+		/* TODO: check initializer if it is constant */
+		return true;
+
 	case EXPR_CONDITIONAL:
 		/* TODO: not correct, we only have to test expressions which are
 		 * evaluated, which means either the true or false part might be not