projects / cparser / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add forgotten conversion specifiers.
[cparser] / ast.c
diff --git a/ast.c b/ast.c
index 1dc4398..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;
 }
 
 /**
@@ -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);
@@ -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;
                }
@@ -1672,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;
        }
 
cparser