projects / cparser / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
add missing print_indent() (now correctly prints nsted functions)
[cparser] / ast.c
diff --git a/ast.c b/ast.c
index 1621bb2..dfd13de 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -390,7 +390,7 @@ static void print_compound_literal(
 {
        fputc('(', out);
        print_type(expression->type);
-       fputs(") ", out);
+       fputc(')', out);
        print_initializer(expression->initializer);
 }
 
@@ -439,44 +439,42 @@ static void print_binary_expression(const binary_expression_t *binexpr)
        }
 
        print_expression_prec(binexpr->left, prec + r2l);
-       if (binexpr->base.kind != EXPR_BINARY_COMMA) {
-               fputc(' ', out);
-       }
+       char const* op;
        switch (binexpr->base.kind) {
-       case EXPR_BINARY_COMMA:              fputs(",", out);     break;
-       case EXPR_BINARY_ASSIGN:             fputs("=", out);     break;
-       case EXPR_BINARY_ADD:                fputs("+", out);     break;
-       case EXPR_BINARY_SUB:                fputs("-", out);     break;
-       case EXPR_BINARY_MUL:                fputs("*", out);     break;
-       case EXPR_BINARY_MOD:                fputs("%", out);     break;
-       case EXPR_BINARY_DIV:                fputs("/", out);     break;
-       case EXPR_BINARY_BITWISE_OR:         fputs("|", out);     break;
-       case EXPR_BINARY_BITWISE_AND:        fputs("&", out);     break;
-       case EXPR_BINARY_BITWISE_XOR:        fputs("^", out);     break;
-       case EXPR_BINARY_LOGICAL_OR:         fputs("||", out);    break;
-       case EXPR_BINARY_LOGICAL_AND:        fputs("&&", out);    break;
-       case EXPR_BINARY_NOTEQUAL:           fputs("!=", out);    break;
-       case EXPR_BINARY_EQUAL:              fputs("==", out);    break;
-       case EXPR_BINARY_LESS:               fputs("<", out);     break;
-       case EXPR_BINARY_LESSEQUAL:          fputs("<=", out);    break;
-       case EXPR_BINARY_GREATER:            fputs(">", out);     break;
-       case EXPR_BINARY_GREATEREQUAL:       fputs(">=", out);    break;
-       case EXPR_BINARY_SHIFTLEFT:          fputs("<<", out);    break;
-       case EXPR_BINARY_SHIFTRIGHT:         fputs(">>", out);    break;
-
-       case EXPR_BINARY_ADD_ASSIGN:         fputs("+=", out);    break;
-       case EXPR_BINARY_SUB_ASSIGN:         fputs("-=", out);    break;
-       case EXPR_BINARY_MUL_ASSIGN:         fputs("*=", out);    break;
-       case EXPR_BINARY_MOD_ASSIGN:         fputs("%=", out);    break;
-       case EXPR_BINARY_DIV_ASSIGN:         fputs("/=", out);    break;
-       case EXPR_BINARY_BITWISE_OR_ASSIGN:  fputs("|=", out);    break;
-       case EXPR_BINARY_BITWISE_AND_ASSIGN: fputs("&=", out);    break;
-       case EXPR_BINARY_BITWISE_XOR_ASSIGN: fputs("^=", out);    break;
-       case EXPR_BINARY_SHIFTLEFT_ASSIGN:   fputs("<<=", out);   break;
-       case EXPR_BINARY_SHIFTRIGHT_ASSIGN:  fputs(">>=", out);   break;
+       case EXPR_BINARY_COMMA:              op = ", ";    break;
+       case EXPR_BINARY_ASSIGN:             op = " = ";   break;
+       case EXPR_BINARY_ADD:                op = " + ";   break;
+       case EXPR_BINARY_SUB:                op = " - ";   break;
+       case EXPR_BINARY_MUL:                op = " * ";   break;
+       case EXPR_BINARY_MOD:                op = " % ";   break;
+       case EXPR_BINARY_DIV:                op = " / ";   break;
+       case EXPR_BINARY_BITWISE_OR:         op = " | ";   break;
+       case EXPR_BINARY_BITWISE_AND:        op = " & ";   break;
+       case EXPR_BINARY_BITWISE_XOR:        op = " ^ ";   break;
+       case EXPR_BINARY_LOGICAL_OR:         op = " || ";  break;
+       case EXPR_BINARY_LOGICAL_AND:        op = " && ";  break;
+       case EXPR_BINARY_NOTEQUAL:           op = " != ";  break;
+       case EXPR_BINARY_EQUAL:              op = " == ";  break;
+       case EXPR_BINARY_LESS:               op = " < ";   break;
+       case EXPR_BINARY_LESSEQUAL:          op = " <= ";  break;
+       case EXPR_BINARY_GREATER:            op = " > ";   break;
+       case EXPR_BINARY_GREATEREQUAL:       op = " >= ";  break;
+       case EXPR_BINARY_SHIFTLEFT:          op = " << ";  break;
+       case EXPR_BINARY_SHIFTRIGHT:         op = " >> ";  break;
+
+       case EXPR_BINARY_ADD_ASSIGN:         op = " += ";  break;
+       case EXPR_BINARY_SUB_ASSIGN:         op = " -= ";  break;
+       case EXPR_BINARY_MUL_ASSIGN:         op = " *= ";  break;
+       case EXPR_BINARY_MOD_ASSIGN:         op = " %= ";  break;
+       case EXPR_BINARY_DIV_ASSIGN:         op = " /= ";  break;
+       case EXPR_BINARY_BITWISE_OR_ASSIGN:  op = " |= ";  break;
+       case EXPR_BINARY_BITWISE_AND_ASSIGN: op = " &= ";  break;
+       case EXPR_BINARY_BITWISE_XOR_ASSIGN: op = " ^= ";  break;
+       case EXPR_BINARY_SHIFTLEFT_ASSIGN:   op = " <<= "; break;
+       case EXPR_BINARY_SHIFTRIGHT_ASSIGN:  op = " >>= "; break;
        default: panic("invalid binexpression found");
        }
-       fputc(' ', out);
+       fputs(op, out);
        print_expression_prec(binexpr->right, prec - r2l);
 }
 
@@ -660,7 +658,7 @@ static void print_va_start(const va_start_expression_t *const expression)
        print_expression_prec(expression->ap, PREC_COMMA + 1);
        fputs(", ", out);
        fputs(expression->parameter->symbol->string, out);
-       fputs(")", out);
+       fputc(')', out);
 }
 
 /**
@@ -674,7 +672,7 @@ static void print_va_arg(const va_arg_expression_t *expression)
        print_expression_prec(expression->ap, PREC_COMMA + 1);
        fputs(", ", out);
        print_type(expression->base.type);
-       fputs(")", out);
+       fputc(')', out);
 }
 
 /**
@@ -1120,7 +1118,7 @@ static void print_asm_arguments(asm_argument_t *arguments)
                print_quoted_string(&argument->constraints, '"', 1);
                fputs(" (", out);
                print_expression(argument->expression);
-               fputs(")", out);
+               fputc(')', out);
        }
 }
 
@@ -1151,20 +1149,21 @@ static void print_asm_statement(const asm_statement_t *statement)
        if(statement->is_volatile) {
                fputs("volatile ", out);
        }
-       fputs("(", out);
+       fputc('(', out);
        print_quoted_string(&statement->asm_text, '"', 1);
-       if(statement->inputs == NULL && statement->outputs == NULL
-                       && statement->clobbers == NULL)
+       if (statement->outputs  == NULL &&
+           statement->inputs   == NULL &&
+           statement->clobbers == NULL)
                goto end_of_print_asm_statement;
 
        fputs(" : ", out);
-       print_asm_arguments(statement->inputs);
-       if(statement->outputs == NULL && statement->clobbers == NULL)
+       print_asm_arguments(statement->outputs);
+       if (statement->inputs == NULL && statement->clobbers == NULL)
                goto end_of_print_asm_statement;
 
        fputs(" : ", out);
-       print_asm_arguments(statement->outputs);
-       if(statement->clobbers == NULL)
+       print_asm_arguments(statement->inputs);
+       if (statement->clobbers == NULL)
                goto end_of_print_asm_statement;
 
        fputs(" : ", out);
@@ -1268,7 +1267,7 @@ void print_statement(const statement_t *statement)
                print_leave_statement(&statement->leave);
                break;
        case STATEMENT_INVALID:
-               fputs("$invalid statement$", out);
+               fputs("$invalid statement$\n", out);
                break;
        }
 }
@@ -1441,6 +1440,7 @@ static void print_normal_declaration(const declaration_t *declaration)
        if(declaration->type->kind == TYPE_FUNCTION) {
                if(declaration->init.statement != NULL) {
                        fputs("\n", out);
+                       print_indent();
                        print_statement(declaration->init.statement);
                        return;
                }
@@ -1478,22 +1478,28 @@ void print_declaration(const declaration_t *declaration)
        case NAMESPACE_STRUCT:
                fputs("struct ", out);
                fputs(declaration->symbol->string, out);
-               fputc(' ', out);
-               print_compound_definition(declaration);
+               if (declaration->init.complete) {
+                       fputc(' ', out);
+                       print_compound_definition(declaration);
+               }
                fputc(';', out);
                break;
        case NAMESPACE_UNION:
                fputs("union ", out);
                fputs(declaration->symbol->string, out);
-               fputc(' ', out);
-               print_compound_definition(declaration);
+               if (declaration->init.complete) {
+                       fputc(' ', out);
+                       print_compound_definition(declaration);
+               }
                fputc(';', out);
                break;
        case NAMESPACE_ENUM:
                fputs("enum ", out);
                fputs(declaration->symbol->string, out);
-               fputc(' ', out);
-               print_enum_definition(declaration);
+               if (declaration->init.complete) {
+                       fputc(' ', out);
+                       print_enum_definition(declaration);
+               }
                fputc(';', out);
                break;
        }
@@ -1602,10 +1608,11 @@ bool is_address_constant(const expression_t *expression)
 
        case EXPR_UNARY_CAST: {
                type_t *dest = skip_typeref(expression->base.type);
-               if (!is_type_pointer(dest) &&
-                               ! (dest->kind == TYPE_ATOMIC
-                                       && (get_atomic_type_flags(dest->atomic.akind) & ATOMIC_TYPE_FLAG_INTEGER)
-                                       && (get_atomic_type_size(dest->atomic.akind) >= get_atomic_type_size(get_intptr_kind()))))
+               if (!is_type_pointer(dest) && (
+                       dest->kind != TYPE_ATOMIC                                               ||
+                       !(get_atomic_type_flags(dest->atomic.akind) & ATOMIC_TYPE_FLAG_INTEGER) ||
+                       (get_atomic_type_size(dest->atomic.akind) < get_atomic_type_size(get_intptr_kind())
+                   )))
                        return false;
 
                return (is_constant_expression(expression->unary.value)
@@ -1700,9 +1707,17 @@ static bool is_object_with_constant_address(const expression_t *expression)
                        return is_object_with_constant_address(compound);
                }
        }
-       case EXPR_ARRAY_ACCESS:
-               return is_constant_pointer(expression->array_access.array_ref)
-                       && is_constant_expression(expression->array_access.index);
+
+       case EXPR_ARRAY_ACCESS: {
+               array_access_expression_t const* const array_access =
+                       &expression->array_access;
+               return
+                       is_constant_expression(array_access->index) && (
+                               is_object_with_constant_address(array_access->array_ref) ||
+                               is_constant_pointer(array_access->array_ref)
+                       );
+       }
+
        case EXPR_UNARY_DEREFERENCE:
                return is_constant_pointer(expression->unary.value);
        default:
cparser