fix warnings, disable empty statement warning by default

[cparser] / ast.c

diff --git a/ast.c b/ast.c
index 86ee507..c29b730 100644 (file)
--- 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);
 
@@ -41,10 +42,10 @@ static void print_const(const const_expression_t *cnst)
        }
 }
 
-static void print_quoted_string(const char *string)
+static void print_quoted_string(const string_t *const string)
 {
        fputc('"', out);
-       for(const char *c = string; *c != '\0'; ++c) {
+       for (const char *c = string->begin, *const end = c + string->size; c != end; ++c) {
                switch(*c) {
                case '\"':  fputs("\\\"", out); break;
                case '\\':  fputs("\\\\", out); break;
@@ -58,7 +59,7 @@ static void print_quoted_string(const char *string)
                case '\?':  fputs("\\?", out); break;
                default:
                        if(!isprint(*c)) {
-                               fprintf(out, "\\x%x", *c);
+                               fprintf(out, "\\%03o", *c);
                                break;
                        }
                        fputc(*c, out);
@@ -71,7 +72,7 @@ static void print_quoted_string(const char *string)
 static void print_string_literal(
                const string_literal_expression_t *string_literal)
 {
-       print_quoted_string(string_literal->value);
+       print_quoted_string(&string_literal->value);
 }
 
 static void print_wide_string_literal(
@@ -140,7 +141,7 @@ static void print_call_expression(const call_expression_t *call)
 
 static void print_binary_expression(const binary_expression_t *binexpr)
 {
-       if(binexpr->expression.type == EXPR_BINARY_BUILTIN_EXPECT) {
+       if(binexpr->expression.kind == EXPR_BINARY_BUILTIN_EXPECT) {
                fputs("__builtin_expect(", out);
                print_expression(binexpr->left);
                fputs(", ", out);
@@ -152,7 +153,7 @@ static void print_binary_expression(const binary_expression_t *binexpr)
        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;
@@ -193,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;
@@ -203,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);
@@ -215,14 +220,17 @@ 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;
@@ -270,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);
@@ -308,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);
@@ -324,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*");
@@ -360,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;
@@ -377,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;
        }
 }
@@ -542,7 +626,7 @@ static void print_asm_constraints(asm_constraint_t *constraints)
                if(constraint->symbol) {
                        fprintf(out, "[%s] ", constraint->symbol->string);
                }
-               print_quoted_string(constraint->constraints);
+               print_quoted_string(&constraint->constraints);
                fputs(" (", out);
                print_expression(constraint->expression);
                fputs(")", out);
@@ -556,7 +640,7 @@ static void print_asm_clobbers(asm_clobber_t *clobbers)
                if(clobber != clobbers)
                        fputs(", ", out);
 
-               print_quoted_string(clobber->clobber);
+               print_quoted_string(&clobber->clobber);
        }
 }
 
@@ -567,7 +651,7 @@ static void print_asm_statement(const asm_statement_t *statement)
                fputs("volatile ", out);
        }
        fputs("(", out);
-       print_quoted_string(statement->asm_text);
+       print_quoted_string(&statement->asm_text);
        if(statement->inputs == NULL && statement->outputs == NULL
                        && statement->clobbers == NULL)
                goto end_of_print_asm_statement;
@@ -591,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;
@@ -662,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;
 
@@ -685,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);
@@ -693,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);
@@ -760,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:
@@ -770,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:
@@ -782,6 +869,7 @@ 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: