X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast.c;h=073ab7dda5b1e78c3a7498df699a77205bb10aca;hb=f4997f4d3a17361c4a6e7beaec96f76caecd1e51;hp=08499d7bf746780f3f7fcf932227de8b768cc743;hpb=5c61a93fb824513c566542f1edac071ab785fef4;p=cparser

diff --git a/ast.c b/ast.c
index 08499d7..073ab7d 100644
--- a/ast.c
+++ b/ast.c
@@ -14,6 +14,7 @@ struct obstack ast_obstack;
 
 static FILE *out;
 static int   indent;
+static int   print_implicit_casts = 1;
 
 static void print_statement(const statement_t *statement);
 
@@ -140,10 +141,19 @@ static void print_call_expression(const call_expression_t *call)
 
 static void print_binary_expression(const binary_expression_t *binexpr)
 {
+	if(binexpr->expression.kind == EXPR_BINARY_BUILTIN_EXPECT) {
+		fputs("__builtin_expect(", out);
+		print_expression(binexpr->left);
+		fputs(", ", out);
+		print_expression(binexpr->right);
+		fputs(")", out);
+		return;
+	}
+
 	fprintf(out, "(");
 	print_expression(binexpr->left);
 	fprintf(out, " ");
-	switch(binexpr->expression.type) {
+	switch(binexpr->expression.kind) {
 	case EXPR_BINARY_COMMA:              fputs(",", out);     break;
 	case EXPR_BINARY_ASSIGN:             fputs("=", out);     break;
 	case EXPR_BINARY_ADD:                fputs("+", out);     break;
@@ -184,7 +194,7 @@ static void print_binary_expression(const binary_expression_t *binexpr)
 
 static void print_unary_expression(const unary_expression_t *unexpr)
 {
-	switch(unexpr->expression.type) {
+	switch(unexpr->expression.kind) {
 	case EXPR_UNARY_NEGATE:           fputs("-", out);  break;
 	case EXPR_UNARY_PLUS:             fputs("+", out);  break;
 	case EXPR_UNARY_NOT:              fputs("!", out);  break;
@@ -194,6 +204,10 @@ static void print_unary_expression(const unary_expression_t *unexpr)
 	case EXPR_UNARY_DEREFERENCE:      fputs("*", out);  break;
 	case EXPR_UNARY_TAKE_ADDRESS:     fputs("&", out);  break;
 
+	case EXPR_UNARY_BITFIELD_EXTRACT:
+		print_expression(unexpr->value);
+		return;
+
 	case EXPR_UNARY_POSTFIX_INCREMENT:
 		fputs("(", out);
 		print_expression(unexpr->value);
@@ -206,14 +220,20 @@ static void print_unary_expression(const unary_expression_t *unexpr)
 		fputs(")", out);
 		fputs("--", out);
 		return;
+	case EXPR_UNARY_CAST_IMPLICIT:
+		if(!print_implicit_casts) {
+			print_expression(unexpr->value);
+			return;
+		}
+		/* fallthrough */
 	case EXPR_UNARY_CAST:
 		fputs("(", out);
 		print_type(unexpr->expression.datatype);
 		fputs(")", out);
 		break;
-	case EXPR_UNARY_CAST_IMPLICIT:
-		print_expression(unexpr->value);
-		return;
+	case EXPR_UNARY_ASSUME:
+		fputs("__assume", out);
+		break;
 	default:
 		panic("invalid unary expression found");
 	}
@@ -258,11 +278,40 @@ static void print_sizeof_expression(const sizeof_expression_t *expression)
 	}
 }
 
+static void print_alignof_expression(const alignof_expression_t *expression)
+{
+	fputs("__alignof__(", out);
+	print_type(expression->type);
+	fputc(')', out);
+}
+
 static void print_builtin_symbol(const builtin_symbol_expression_t *expression)
 {
 	fputs(expression->symbol->string, out);
 }
 
+static void print_builtin_constant(const builtin_constant_expression_t *expression)
+{
+	fputs("__builtin_constant_p(", out);
+	print_expression(expression->value);
+	fputc(')', out);
+}
+
+static void print_builtin_prefetch(const builtin_prefetch_expression_t *expression)
+{
+	fputs("__builtin_prefetch(", out);
+	print_expression(expression->adr);
+	if (expression->rw) {
+		fputc(',', out);
+		print_expression(expression->rw);
+	}
+	if (expression->locality) {
+		fputc(',', out);
+		print_expression(expression->locality);
+	}
+	fputc(')', out);
+}
+
 static void print_conditional(const conditional_expression_t *expression)
 {
 	fputs("(", out);
@@ -296,7 +345,7 @@ static void print_select(const select_expression_t *expression)
 {
 	print_expression(expression->compound);
 	if(expression->compound->base.datatype == NULL ||
-			expression->compound->base.datatype->type == TYPE_POINTER) {
+			expression->compound->base.datatype->kind == TYPE_POINTER) {
 		fputs("->", out);
 	} else {
 		fputc('.', out);
@@ -312,9 +361,41 @@ static void print_classify_type_expression(
 	fputc(')', out);
 }
 
+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) {
+			fputc('[', out);
+			print_expression(designator->array_access);
+			fputc(']', out);
+		} else {
+			fputc('.', out);
+			fputs(designator->symbol->string, out);
+		}
+	}
+}
+
+static void print_offsetof_expression(const offsetof_expression_t *expression)
+{
+	fputs("__builtin_offsetof", out);
+	fputc('(', out);
+	print_type(expression->type);
+	fputc(',', out);
+	print_designator(expression->designator);
+	fputc(')', out);
+}
+
+static void print_statement_expression(const statement_expression_t *expression)
+{
+	fputc('(', out);
+	print_statement(expression->statement);
+	fputc(')', out);
+}
+
 void print_expression(const expression_t *expression)
 {
-	switch(expression->type) {
+	switch(expression->kind) {
 	case EXPR_UNKNOWN:
 	case EXPR_INVALID:
 		fprintf(out, "*invalid expression*");
@@ -348,14 +429,24 @@ void print_expression(const expression_t *expression)
 	case EXPR_SIZEOF:
 		print_sizeof_expression(&expression->sizeofe);
 		break;
+	case EXPR_ALIGNOF:
+		print_alignof_expression(&expression->alignofe);
+		break;
 	case EXPR_BUILTIN_SYMBOL:
 		print_builtin_symbol(&expression->builtin_symbol);
 		break;
+	case EXPR_BUILTIN_CONSTANT_P:
+		print_builtin_constant(&expression->builtin_constant);
+		break;
+	case EXPR_BUILTIN_PREFETCH:
+		print_builtin_prefetch(&expression->builtin_prefetch);
+		break;
 	case EXPR_CONDITIONAL:
 		print_conditional(&expression->conditional);
 		break;
 	case EXPR_VA_START:
 		print_va_start(&expression->va_starte);
+		break;
 	case EXPR_VA_ARG:
 		print_va_arg(&expression->va_arge);
 		break;
@@ -365,11 +456,16 @@ void print_expression(const expression_t *expression)
 	case EXPR_CLASSIFY_TYPE:
 		print_classify_type_expression(&expression->classify_type);
 		break;
-
 	case EXPR_OFFSETOF:
+		print_offsetof_expression(&expression->offsetofe);
+		break;
 	case EXPR_STATEMENT:
+		print_statement_expression(&expression->statement);
+		break;
+
+	default:
 		/* TODO */
-		fprintf(out, "some expression of type %d", (int) expression->type);
+		fprintf(out, "some expression of type %d", (int) expression->kind);
 		break;
 	}
 }
@@ -579,7 +675,7 @@ end_of_print_asm_statement:
 
 void print_statement(const statement_t *statement)
 {
-	switch(statement->type) {
+	switch(statement->kind) {
 	case STATEMENT_COMPOUND:
 		print_compound_statement(&statement->compound);
 		break;
@@ -650,13 +746,13 @@ static void print_storage_class(unsigned storage_class)
 
 void print_initializer(const initializer_t *initializer)
 {
-	if(initializer->type == INITIALIZER_VALUE) {
+	if(initializer->kind == INITIALIZER_VALUE) {
 		const initializer_value_t *value = &initializer->value;
 		print_expression(value->value);
 		return;
 	}
 
-	assert(initializer->type == INITIALIZER_LIST);
+	assert(initializer->kind == INITIALIZER_LIST);
 	fputs("{ ", out);
 	const initializer_list_t *list = &initializer->list;
 
@@ -673,7 +769,7 @@ static void print_normal_declaration(const declaration_t *declaration)
 {
 	print_storage_class(declaration->storage_class);
 	if(declaration->is_inline) {
-		if (declaration->decl_modifiers & DM_FORCEINLINE)
+		if (declaration->modifiers & DM_FORCEINLINE)
 			fputs("__forceinline ", out);
 		else
 			fputs("inline ", out);
@@ -681,7 +777,7 @@ static void print_normal_declaration(const declaration_t *declaration)
 	print_type_ext(declaration->type, declaration->symbol,
 	               &declaration->context);
 
-	if(declaration->type->type == TYPE_FUNCTION) {
+	if(declaration->type->kind == TYPE_FUNCTION) {
 		if(declaration->init.statement != NULL) {
 			fputs("\n", out);
 			print_statement(declaration->init.statement);
@@ -748,7 +844,7 @@ void print_ast(const translation_unit_t *unit)
 
 bool is_constant_expression(const expression_t *expression)
 {
-	switch(expression->type) {
+	switch(expression->kind) {
 
 	case EXPR_CONST:
 	case EXPR_STRING_LITERAL:
@@ -758,9 +854,12 @@ bool is_constant_expression(const expression_t *expression)
 	case EXPR_FUNCTION:
 	case EXPR_PRETTY_FUNCTION:
 	case EXPR_OFFSETOF:
+	case EXPR_ALIGNOF:
+	case EXPR_BUILTIN_CONSTANT_P:
 		return true;
 
 	case EXPR_BUILTIN_SYMBOL:
+	case EXPR_BUILTIN_PREFETCH:
 	case EXPR_CALL:
 	case EXPR_SELECT:
 	case EXPR_VA_START:
@@ -770,6 +869,8 @@ bool is_constant_expression(const expression_t *expression)
 	case EXPR_UNARY_POSTFIX_DECREMENT:
 	case EXPR_UNARY_PREFIX_INCREMENT:
 	case EXPR_UNARY_PREFIX_DECREMENT:
+	case EXPR_UNARY_BITFIELD_EXTRACT:
+	case EXPR_UNARY_ASSUME: /* has VOID type */
 	case EXPR_BINARY_ASSIGN:
 	case EXPR_BINARY_MUL_ASSIGN:
 	case EXPR_BINARY_DIV_ASSIGN:
@@ -812,6 +913,7 @@ bool is_constant_expression(const expression_t *expression)
 	case EXPR_BINARY_LOGICAL_OR:
 	case EXPR_BINARY_SHIFTLEFT:
 	case EXPR_BINARY_SHIFTRIGHT:
+	case EXPR_BINARY_BUILTIN_EXPECT:
 	case EXPR_BINARY_ISGREATER:
 	case EXPR_BINARY_ISGREATEREQUAL:
 	case EXPR_BINARY_ISLESS: