X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast.c;h=0ba0492d4e6b9dfb657938b39c59dcdb95e6514d;hb=6dc5b6251ac0d183a62021b991d17d2debd603eb;hp=984df78d4acc2b6b9fad306f6bcd0fc6d7987b60;hpb=f0b545b1bc21b2e153590fe034d063d2498174e2;p=cparser

diff --git a/ast.c b/ast.c
index 984df78..0ba0492 100644
--- a/ast.c
+++ b/ast.c
@@ -29,7 +29,7 @@ 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;
@@ -41,10 +41,10 @@ static void print_const(const const_t *cnst)
 	}
 }
 
-static void print_string_literal(const string_literal_t *string_literal)
+static void print_quoted_string(const char *string)
 {
 	fputc('"', out);
-	for(const char *c = string_literal->value; *c != '\0'; ++c) {
+	for(const char *c = string; *c != '\0'; ++c) {
 		switch(*c) {
 		case '\"':  fputs("\\\"", out); break;
 		case '\\':  fputs("\\\\", out); break;
@@ -68,6 +68,12 @@ static void print_string_literal(const string_literal_t *string_literal)
 	fputc('"', out);
 }
 
+static void print_string_literal(
+		const string_literal_expression_t *string_literal)
+{
+	print_quoted_string(string_literal->value);
+}
+
 static void print_call_expression(const call_expression_t *call)
 {
 	print_expression(call->function);
@@ -160,6 +166,9 @@ static void print_unary_expression(const unary_expression_t *unexpr)
 		print_type(unexpr->expression.datatype);
 		fputs(")", out);
 		break;
+	case UNEXPR_CAST_IMPLICIT:
+		print_expression(unexpr->value);
+		return;
 	case UNEXPR_INVALID:
 		fprintf(out, "unop%d", (int) unexpr->type);
 		break;
@@ -176,11 +185,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 +242,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);
@@ -250,45 +267,45 @@ void print_expression(const expression_t *expression)
 		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((const classify_type_expression_t*)expression);
+		print_classify_type_expression(&expression->classify_type);
 		break;
 
 	case EXPR_OFFSETOF:
@@ -309,7 +326,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();
@@ -445,23 +462,80 @@ static void print_for_statement(const for_statement_t *statement)
 	print_statement(statement->body);
 }
 
+static void print_asm_constraints(asm_constraint_t *constraints)
+{
+	asm_constraint_t *constraint = constraints;
+	for( ; constraint != NULL; constraint = constraint->next) {
+		if(constraint != constraints)
+			fputs(", ", out);
+
+		if(constraint->symbol) {
+			fprintf(out, "[%s] ", constraint->symbol->string);
+		}
+		print_quoted_string(constraint->constraints);
+		fputs(" (", out);
+		print_expression(constraint->expression);
+		fputs(")", out);
+	}
+}
+
+static void print_asm_clobbers(asm_clobber_t *clobbers)
+{
+	asm_clobber_t *clobber = clobbers;
+	for( ; clobber != NULL; clobber = clobber->next) {
+		if(clobber != clobbers)
+			fputs(", ", out);
+
+		print_quoted_string(clobber->clobber);
+	}
+}
+
+static void print_asm_statement(const asm_statement_t *statement)
+{
+	fputs("asm ", out);
+	if(statement->is_volatile) {
+		fputs("volatile ", out);
+	}
+	fputs("(", out);
+	print_quoted_string(statement->asm_text);
+	if(statement->inputs == NULL && statement->outputs == NULL
+			&& statement->clobbers == NULL)
+		goto end_of_print_asm_statement;
+
+	fputs(" : ", out);
+	print_asm_constraints(statement->inputs);
+	if(statement->outputs == NULL && statement->clobbers == NULL)
+		goto end_of_print_asm_statement;
+
+	fputs(" : ", out);
+	print_asm_constraints(statement->outputs);
+	if(statement->clobbers == NULL)
+		goto end_of_print_asm_statement;
+
+	fputs(" : ", out);
+	print_asm_clobbers(statement->clobbers);
+
+end_of_print_asm_statement:
+	fputs(");\n", out);
+}
+
 void print_statement(const statement_t *statement)
 {
 	switch(statement->type) {
 	case STATEMENT_COMPOUND:
-		print_compound_statement((const compound_statement_t*) statement);
+		print_compound_statement(&statement->compound);
 		break;
 	case STATEMENT_RETURN:
-		print_return_statement((const return_statement_t*) statement);
+		print_return_statement(&statement->returns);
 		break;
 	case STATEMENT_EXPRESSION:
-		print_expression_statement((const expression_statement_t*) statement);
+		print_expression_statement(&statement->expression);
 		break;
 	case STATEMENT_LABEL:
-		print_label_statement((const label_statement_t*) statement);
+		print_label_statement(&statement->label);
 		break;
 	case STATEMENT_GOTO:
-		print_goto_statement((const goto_statement_t*) statement);
+		print_goto_statement(&statement->gotos);
 		break;
 	case STATEMENT_CONTINUE:
 		fputs("continue;\n", out);
@@ -470,25 +544,28 @@ void print_statement(const statement_t *statement)
 		fputs("break;\n", out);
 		break;
 	case STATEMENT_IF:
-		print_if_statement((const if_statement_t*) statement);
+		print_if_statement(&statement->ifs);
 		break;
 	case STATEMENT_SWITCH:
-		print_switch_statement((const switch_statement_t*) statement);
+		print_switch_statement(&statement->switchs);
 		break;
 	case STATEMENT_CASE_LABEL:
-		print_case_label((const case_label_statement_t*) statement);
+		print_case_label(&statement->case_label);
 		break;
 	case STATEMENT_DECLARATION:
-		print_declaration_statement((const declaration_statement_t*) statement);
+		print_declaration_statement(&statement->declaration);
 		break;
 	case STATEMENT_WHILE:
-		print_while_statement((const while_statement_t*) statement);
+		print_while_statement(&statement->whiles);
 		break;
 	case STATEMENT_DO_WHILE:
-		print_do_while_statement((const do_while_statement_t*) statement);
+		print_do_while_statement(&statement->do_while);
 		break;
 	case STATEMENT_FOR:
-		print_for_statement((const for_statement_t*) statement);
+		print_for_statement(&statement->fors);
+		break;
+	case STATEMENT_ASM:
+		print_asm_statement(&statement->asms);
 		break;
 	case STATEMENT_INVALID:
 		fprintf(out, "*invalid statement*");
@@ -496,17 +573,20 @@ 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;
 	}
 }
 
@@ -533,12 +613,12 @@ void print_initializer(const initializer_t *initializer)
 
 static void print_normal_declaration(const declaration_t *declaration)
 {
-	print_storage_class((storage_class_t)declaration->storage_class);
-	print_type_ext(declaration->type, declaration->symbol,
-	               &declaration->context);
+	print_storage_class(declaration->storage_class);
 	if(declaration->is_inline) {
 		fputs("inline ", out);
 	}
+	print_type_ext(declaration->type, declaration->symbol,
+	               &declaration->context);
 
 	if(declaration->type->type == TYPE_FUNCTION) {
 		if(declaration->init.statement != NULL) {
@@ -590,7 +670,6 @@ 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) {