Add forgotten conversion specifiers.

[cparser] / ast.c

diff --git a/ast.c b/ast.c
index edf12ba..6b0542e 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -88,13 +88,13 @@ enum precedence_t {
 
 /**
  * Returns 1 if a given precedence level has right-to-left
- * associativity, else -1.
+ * associativity, else 0.
  *
  * @param precedence   the operator precedence
  */
 static int right_to_left(unsigned precedence) {
        return (precedence == PREC_ASSIGN || precedence == PREC_COND ||
-               precedence == PREC_UNARY) ? 1 : -1;
+               precedence == PREC_UNARY) ? 1 : 0;
 }
 
 /**
@@ -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);
 }
 
@@ -1442,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;
                }
@@ -1673,9 +1672,12 @@ static bool is_builtin_const_call(const expression_t *expression)
 
        switch (symbol->ID) {
        case T___builtin_huge_val:
+       case T___builtin_inf:
+       case T___builtin_inff:
+       case T___builtin_infl:
        case T___builtin_nan:
        case T___builtin_nanf:
-       case T___builtin_nand:
+       case T___builtin_nanl:
                return true;
        }