X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast.c;h=e1097544da3ba03d76b6c598e86341de7f4dc8b5;hb=9de06381987e3b71a9efea26cb9b596fd433191c;hp=901eef13742dbd6f297d0f630b1d0e30fdcaacb0;hpb=93b256acc783d281b7eb29184591a76c8e83e62a;p=cparser

diff --git a/ast.c b/ast.c
index 901eef1..e109754 100644
--- a/ast.c
+++ b/ast.c
@@ -29,19 +29,20 @@ void print_indent(void)
 		fprintf(out, "\t");
 }
 
-static void print_const(const const_t *cnst)
+static void print_const(const const_expression_t *cnst)
 {
 	if(cnst->expression.datatype == NULL)
 		return;
 
 	if(is_type_integer(cnst->expression.datatype)) {
-		fprintf(out, "%d", cnst->v.int_value);
+		fprintf(out, "%lld", cnst->v.int_value);
 	} else if(is_type_floating(cnst->expression.datatype)) {
 		fprintf(out, "%Lf", cnst->v.float_value);
 	}
 }
 
-static void print_string_literal(const string_literal_t *string_literal)
+static void print_string_literal(
+		const string_literal_expression_t *string_literal)
 {
 	fputc('"', out);
 	for(const char *c = string_literal->value; *c != '\0'; ++c) {
@@ -161,7 +162,7 @@ static void print_unary_expression(const unary_expression_t *unexpr)
 		fputs(")", out);
 		break;
 	case UNEXPR_INVALID:
-		fprintf(out, "unop%d", unexpr->type);
+		fprintf(out, "unop%d", (int) unexpr->type);
 		break;
 	}
 	fputs("(", out);
@@ -176,11 +177,19 @@ static void print_reference_expression(const reference_expression_t *ref)
 
 static void print_array_expression(const array_access_expression_t *expression)
 {
-	fputs("(", out);
-	print_expression(expression->array_ref);
-	fputs(")[", out);
-	print_expression(expression->index);
-	fputs("]", out);
+	if(!expression->flipped) {
+		fputs("(", out);
+		print_expression(expression->array_ref);
+		fputs(")[", out);
+		print_expression(expression->index);
+		fputs("]", out);
+	} else {
+		fputs("(", out);
+		print_expression(expression->index);
+		fputs(")[", out);
+		print_expression(expression->array_ref);
+		fputs("]", out);
+	}
 }
 
 static void print_sizeof_expression(const sizeof_expression_t *expression)
@@ -225,8 +234,8 @@ static void print_va_arg(const va_arg_expression_t *expression)
 static void print_select(const select_expression_t *expression)
 {
 	print_expression(expression->compound);
-	if(expression->compound->datatype == NULL ||
-			expression->compound->datatype->type == TYPE_POINTER) {
+	if(expression->compound->base.datatype == NULL ||
+			expression->compound->base.datatype->type == TYPE_POINTER) {
 		fputs("->", out);
 	} else {
 		fputc('.', out);
@@ -234,55 +243,67 @@ static void print_select(const select_expression_t *expression)
 	fputs(expression->symbol->string, out);
 }
 
+static void print_classify_type_expression(
+	const classify_type_expression_t *const expr)
+{
+	fputs("__builtin_classify_type(", out);
+	print_expression(expr->type_expression);
+	fputc(')', out);
+}
+
 void print_expression(const expression_t *expression)
 {
 	switch(expression->type) {
+	case EXPR_UNKNOWN:
 	case EXPR_INVALID:
 		fprintf(out, "*invalid expression*");
 		break;
 	case EXPR_CONST:
-		print_const((const const_t*) expression);
+		print_const(&expression->conste);
 		break;
 	case EXPR_FUNCTION:
 	case EXPR_PRETTY_FUNCTION:
 	case EXPR_STRING_LITERAL:
-		print_string_literal((const string_literal_t*) expression);
+		print_string_literal(&expression->string);
 		break;
 	case EXPR_CALL:
-		print_call_expression((const call_expression_t*) expression);
+		print_call_expression(&expression->call);
 		break;
 	case EXPR_BINARY:
-		print_binary_expression((const binary_expression_t*) expression);
+		print_binary_expression(&expression->binary);
 		break;
 	case EXPR_REFERENCE:
-		print_reference_expression((const reference_expression_t*) expression);
+		print_reference_expression(&expression->reference);
 		break;
 	case EXPR_ARRAY_ACCESS:
-		print_array_expression((const array_access_expression_t*) expression);
+		print_array_expression(&expression->array_access);
 		break;
 	case EXPR_UNARY:
-		print_unary_expression((const unary_expression_t*) expression);
+		print_unary_expression(&expression->unary);
 		break;
 	case EXPR_SIZEOF:
-		print_sizeof_expression((const sizeof_expression_t*) expression);
+		print_sizeof_expression(&expression->sizeofe);
 		break;
 	case EXPR_BUILTIN_SYMBOL:
-		print_builtin_symbol((const builtin_symbol_expression_t*) expression);
+		print_builtin_symbol(&expression->builtin_symbol);
 		break;
 	case EXPR_CONDITIONAL:
-		print_conditional((const conditional_expression_t*) expression);
+		print_conditional(&expression->conditional);
 		break;
 	case EXPR_VA_ARG:
-		print_va_arg((const va_arg_expression_t*) expression);
+		print_va_arg(&expression->va_arge);
 		break;
 	case EXPR_SELECT:
-		print_select((const select_expression_t*) expression);
+		print_select(&expression->select);
+		break;
+	case EXPR_CLASSIFY_TYPE:
+		print_classify_type_expression(&expression->classify_type);
 		break;
 
 	case EXPR_OFFSETOF:
 	case EXPR_STATEMENT:
 		/* TODO */
-		fprintf(out, "some expression of type %d", expression->type);
+		fprintf(out, "some expression of type %d", (int) expression->type);
 		break;
 	}
 }
@@ -297,7 +318,7 @@ static void print_compound_statement(const compound_statement_t *block)
 		print_indent();
 		print_statement(statement);
 
-		statement = statement->next;
+		statement = statement->base.next;
 	}
 	indent--;
 	print_indent();
@@ -368,6 +389,7 @@ static void print_case_label(const case_label_statement_t *statement)
 		print_expression(statement->expression);
 		fputs(":\n", out);
 	}
+	print_statement(statement->label_statement);
 }
 
 static void print_declaration_statement(
@@ -483,35 +505,40 @@ void print_statement(const statement_t *statement)
 	}
 }
 
-static void print_storage_class(storage_class_t storage_class)
+static void print_storage_class(unsigned storage_class)
 {
-	switch(storage_class) {
+	switch((storage_class_tag_t) storage_class) {
 	case STORAGE_CLASS_ENUM_ENTRY:
 	case STORAGE_CLASS_NONE:
 		break;
-	case STORAGE_CLASS_TYPEDEF:  fputs("typedef ", out); break;
-	case STORAGE_CLASS_EXTERN:   fputs("extern ", out); break;
-	case STORAGE_CLASS_STATIC:   fputs("static ", out); break;
-	case STORAGE_CLASS_AUTO:     fputs("auto ", out); break;
-	case STORAGE_CLASS_REGISTER: fputs("register ", out); break;
+	case STORAGE_CLASS_TYPEDEF:       fputs("typedef ",        out); break;
+	case STORAGE_CLASS_EXTERN:        fputs("extern ",         out); break;
+	case STORAGE_CLASS_STATIC:        fputs("static ",         out); break;
+	case STORAGE_CLASS_AUTO:          fputs("auto ",           out); break;
+	case STORAGE_CLASS_REGISTER:      fputs("register ",       out); break;
+	case STORAGE_CLASS_THREAD:        fputs("__thread",        out); break;
+	case STORAGE_CLASS_THREAD_EXTERN: fputs("extern __thread", out); break;
+	case STORAGE_CLASS_THREAD_STATIC: fputs("static __thread", out); break;
 	}
 }
 
 void print_initializer(const initializer_t *initializer)
 {
 	if(initializer->type == INITIALIZER_VALUE) {
-		print_expression(initializer->v.value);
+		const initializer_value_t *value = &initializer->value;
+		print_expression(value->value);
 		return;
 	}
 
 	assert(initializer->type == INITIALIZER_LIST);
 	fputs("{ ", out);
-	initializer_t *iter = initializer->v.list;
-	for( ; iter != NULL; iter = iter->next) {
-		print_initializer(iter);
-		if(iter->next != NULL) {
+	const initializer_list_t *list = &initializer->list;
+
+	for(size_t i = 0 ; i < list->len; ++i) {
+		if(i > 0) {
 			fputs(", ", out);
 		}
+		print_initializer(list->initializers[i]);
 	}
 	fputs("}", out);
 }
@@ -540,11 +567,11 @@ static void print_normal_declaration(const declaration_t *declaration)
 
 void print_declaration(const declaration_t *declaration)
 {
-	if(declaration->namespace != NAMESPACE_NORMAL &&
+	if(declaration->namespc != NAMESPACE_NORMAL &&
 			declaration->symbol == NULL)
 		return;
 
-	switch(declaration->namespace) {
+	switch(declaration->namespc) {
 	case NAMESPACE_NORMAL:
 		print_normal_declaration(declaration);
 		break;
@@ -575,13 +602,12 @@ void print_declaration(const declaration_t *declaration)
 void print_ast(const translation_unit_t *unit)
 {
 	inc_type_visited();
-	set_print_compound_entries(true);
 
 	declaration_t *declaration = unit->context.declarations;
 	for( ; declaration != NULL; declaration = declaration->next) {
 		if(declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY)
 			continue;
-		if(declaration->namespace != NAMESPACE_NORMAL &&
+		if(declaration->namespc != NAMESPACE_NORMAL &&
 				declaration->symbol == NULL)
 			continue;