ctrump/io/pretty-printer.c

Go to the documentation of this file.

/* -*- coding:utf-8 -*- 
 Copyright (c) 2009, Fixstars Corporation
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, 
 are permitted provided that the following conditions are met:
 
   * Redistributions of source code must retain the above copyright notice,
     this list of conditions and the following disclaimer.
 
   * Redistributions in binary form must reproduce the above copyright notice,
     this list of conditions and the following disclaimer in the documentation
     and/or other materials provided with the distribution.
 
   * Neither the name of Fixstars Corporation nor the names of its contributors
     may be used to endorse or promote products derived from this software
     without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "ctrump/ast/ast.h"
#include "ctrump/io/pretty-printer.h"
#include "ctrump/common/abort.h"
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include "pprint-format.h"
#include <ctype.h>

#define PRINT_STR_CONST(p,s) print_str(p, s, sizeof(s)-1)
#define PRINT_STR_CONST_LOC(p,s,l) goto_loc(p,l); print_str(p, s, sizeof(s)-1)

struct printer {
    int indent;                 
    int cur_lineno;             
    int cur_column;             
    int line_begin;             
    int use_column;             
    int max_column;             
    int print_internal_info;    
    char *buffer;               
    int content_len;            
    int buf_len;                
    int suspended;              
    const char *filename;       
    const struct ctrump_pprint_format *fmt; 
};

static void print_str(struct printer *p,
                      const char *str,
                      int strlen);

static void print_declspec(struct printer *p,
                           const struct ctrump_decl_specifier *spec);
static void print_declarator(struct printer *p,
                             const struct ctrump_declarator *d);
static void print_initializer_list(struct printer *p,
                                   const struct ctrump_initializer_list *il);
static void print_initializer(struct printer *p,
                              const struct ctrump_initializer *i);
static void print_stmt(struct printer *p,
                       const struct ctrump_stmt *stmt);
static void print_decl(struct printer *p,
                       const struct ctrump_decl *def);
static void print_struct_decl(struct printer *p,
                              const struct ctrump_struct_decl *decl);
static void print_typespec(struct printer *p,
                           const struct ctrump_typespec *spec);
static void print_texpr(struct printer *p,
                        const struct ctrump_texpr *texpr,
                        int is_typename);

static void print_enum_list(struct printer *p,
                            const struct ctrump_enum_list *el);

static void print_decl_with_init(struct printer *p,
                                 const struct ctrump_decl_with_init *d);

static void
buf_reserve(struct printer *p,
            int len)
{
    if (p->buf_len <= len) {
        p->buf_len *= 2;
        p->buffer = realloc(p->buffer, p->buf_len);
    }
}

static void
buf_putc(char c,
         struct printer *p)
{
    buf_reserve(p, p->content_len+1);
    p->buffer[p->content_len] = c;
    p->content_len ++;
}

static void
print_newline(struct printer *p)
{
    if (p->suspended) return;

    buf_putc('\n', p);

    p->cur_column = 1;
    p->line_begin = 1;
    p->cur_lineno += 1;
}

static void
print_newline_if_not_use_column(struct printer *p)
{
    if (!p->use_column) {
        print_newline(p);
    }
}

static void
goto_bol(struct printer *p)
{
    if (!p->line_begin) {
        print_newline(p);
    }
}

static void
goto_loc(struct printer *p,
         const struct ctrump_location *loc)
{
    if (p->suspended) return;

    if (p->use_column) {
        int cl = p->cur_lineno, col = p->cur_column;
        int tl = loc->lineno;
        for (; cl<tl; cl++) {
            print_newline(p);
            col = 1;
        }

        tl = loc->column;
        if (tl > col) {
            for (; col<tl; col++) {
                buf_putc(' ', p);
            }
            p->cur_column = tl;
        }
    }
}

static void
print_str(struct printer *p,
          const char *str,
          int strlen)
{
    int i;

    if (p->suspended) return;

    for (i=0; i<strlen; i++) {
        char c = str[i];

        if (c == '\n') {
            print_newline(p);
        } else {
            if (p->line_begin) {
                if (!p->use_column) {
                    int i;
                    for (i=0; i<p->indent; i++) {
                        buf_putc(' ', p);
                    }
                    p->cur_column = p->indent + 1;
                }
                p->line_begin = 0;
            }
            buf_putc(c, p);
            p->cur_column++;
        }
    }
}

static void
print_sint(struct printer *p,
           int val)
{
    char buf[32];
    int len;
    len = snprintf(buf, 32, "%d", val);
    print_str(p, buf, len);
}

static void
print_source(struct printer *p,
             const struct ctrump_source_string *source)
{
    print_str(p, source->chars, source->length);
}


static void
print_sym(struct printer *p,
          const struct ctrump_symbol *sym)
{
    print_str(p, sym->symstr, sym->symlen);
}

static void
delete_extra_space(struct printer *p)
{
    if (p->buffer[p->content_len - 1] == ' ') {
        p->cur_column--;
        p->content_len--;
    }
}

static void
print_typename(struct printer *p,
               const struct ctrump_typename *typename)
{
    PRINT_STR_CONST_LOC(p, "(", &typename->lpar_loc);

    if (!p->use_column && p->fmt->padding_around_type_cast) {
        PRINT_STR_CONST(p, " ");
    }

    print_declspec(p, &typename->spec);
    if (typename->abstract_decl->nodes.code == CTRUMP_DECLARATOR_EMPTY) {
        delete_extra_space(p);
    }

    print_declarator(p, typename->abstract_decl);

    if (!p->use_column && p->fmt->padding_around_type_cast) {
        PRINT_STR_CONST(p, " ");
    }

    PRINT_STR_CONST_LOC(p, ")", &typename->rpar_loc);
}

static __attribute__((unused)) void
print_location_stderr(const struct ctrump_location *loc)
{
    fprintf(stderr, "path= %s\n", loc->path);
    fprintf(stderr, "lineno= %d\t", loc->lineno);
    fprintf(stderr, "column= %d\n", loc->column);
}

static void
indent(struct printer *p)
{
    if (!p->use_column) {
        p->indent += p->fmt->indentation_size;
    }
}

static void
dedent(struct printer *p)
{
    if (!p->use_column) {
        p->indent -= p->fmt->indentation_size;
    }
}

static void
print_comma(struct printer *p)
{
    PRINT_STR_CONST(p, ",");
    if (!p->use_column && p->fmt->space_after_comma) {
        PRINT_STR_CONST(p, " ");
    }
}

static void
print_space_before_statement_parens(struct printer *p)
{
    if (!p->use_column && p->fmt->space_before_statement_parens) {
        PRINT_STR_CONST(p, " ");
    }
}

static void
print_space_before_braces(struct printer *p)
{
    if (!p->use_column && p->fmt->space_before_braces) {
        PRINT_STR_CONST(p, " ");
    }
}

static void
print_space_before_brackets(struct printer *p)
{
    if (!p->use_column && p->fmt->space_before_brackets) {
        PRINT_STR_CONST(p, " ");
    }
}

static void
print_space_around_assignment_op(struct printer *p)
{
    if (!p->use_column && p->fmt->spaces_around_assignment_op) {
        PRINT_STR_CONST(p, " ");
    }
}

static void
print_padding_around_statement_parens(struct printer *p)
{
    if (!p->use_column && p->fmt->padding_around_statement_parens) {
        PRINT_STR_CONST(p, " ");
    }
}

static void
print_padding_around_braces(struct printer *p)
{
    if (!p->use_column && p->fmt->padding_around_braces) {
        PRINT_STR_CONST(p, " ");
    }
}
static void
print_padding_around_brackets(struct printer *p)
{
    if (!p->use_column && p->fmt->padding_around_brackets) {
        PRINT_STR_CONST(p, " ");
    }
}

static void
print_statement_lpar_loc(struct printer *p,
                         const struct ctrump_location *loc)
{
    print_space_before_statement_parens(p);

    if (loc != NULL) goto_loc(p, loc);
    PRINT_STR_CONST(p, "(");

    print_padding_around_statement_parens(p);
}

static void
print_statement_rpar_loc(struct printer *p,
                         const struct ctrump_location *loc)
{
    print_padding_around_statement_parens(p);

    if (loc != NULL) goto_loc(p, loc);
    PRINT_STR_CONST(p, ")");
}

static void
print_lbracket_loc(struct printer *p,
                   const struct ctrump_location *loc)
{
    print_space_before_brackets(p);

    if (loc != NULL) goto_loc(p, loc);
    PRINT_STR_CONST(p, "[");

    print_padding_around_brackets(p);
}

static void
print_rbracket_loc(struct printer *p,
                   const struct ctrump_location *loc)
{
    print_padding_around_brackets(p);

    if (loc != NULL) goto_loc(p, loc);
    PRINT_STR_CONST(p, "]");
}


static void
print_expr(struct printer *p,
           const struct ctrump_expr *e)
{
    int i, n;

    switch (e->code) {
    case CTRUMP_EXPR_ARRREF:
        print_expr(p, e->u.arr_ref.array);

        print_lbracket_loc(p, &e->u.arr_ref.lbr_loc);
        print_expr(p, e->u.arr_ref.subscript);
        print_rbracket_loc(p, &e->u.arr_ref.rbr_loc);
        break;

#define BIN_EXPR_STR(code,str)                  \
    case code:                                  \
        print_expr(p, e->u.binary.lhs);         \
        goto_loc(p, &e->u.binary.op_loc);       \
        PRINT_STR_CONST(p, str);                \
        print_expr(p, e->u.binary.rhs);         \
        break

        BIN_EXPR_STR(CTRUMP_EXPR_BIN_COMMA, ",");


#define PRINT_EXPR_STR(code,str)                          \
        print_expr(p, e->u.binary.lhs);                   \
        goto_loc(p, &e->u.binary.op_loc);                 \
        PRINT_STR_CONST(p, str);                          \
        print_expr(p, e->u.binary.rhs);
#define PRINT_EXPR_STR_ENCLOSED_IN_SPACE(code,str)        \
        print_expr(p, e->u.binary.lhs);                   \
        PRINT_STR_CONST(p, " ");                          \
        goto_loc(p, &e->u.binary.op_loc);                 \
        PRINT_STR_CONST(p, str);                          \
        PRINT_STR_CONST(p, " ");                          \
        print_expr(p, e->u.binary.rhs);

#define BIN_EXPR_ASSIGN_OP(code,str)                                   \
    case code:                                                         \
        if (!p->use_column && p->fmt->spaces_around_assignment_op) {   \
            PRINT_EXPR_STR_ENCLOSED_IN_SPACE(code,str);                \
        } else {                                                       \
            PRINT_EXPR_STR(code,str);                                  \
        }                                                              \
        break
#define BIN_EXPR_LOGICAL_OP(code,str)                                  \
    case code:                                                         \
        if (!p->use_column && p->fmt->spaces_around_logical_op) {      \
            PRINT_EXPR_STR_ENCLOSED_IN_SPACE(code,str);                \
        } else {                                                       \
            PRINT_EXPR_STR(code,str);                                  \
        }                                                              \
        break
#define BIN_EXPR_RELATIONAL_OP(code,str)                               \
    case code:                                                         \
        if (!p->use_column && p->fmt->spaces_around_relational_op) {   \
            PRINT_EXPR_STR_ENCLOSED_IN_SPACE(code,str);                \
        } else {                                                       \
            PRINT_EXPR_STR(code,str);                                  \
        }                                                              \
        break
#define BIN_EXPR_BITWISE_OP(code,str)                                  \
    case code:                                                         \
        if (!p->use_column && p->fmt->spaces_around_bitwise_op) {      \
            PRINT_EXPR_STR_ENCLOSED_IN_SPACE(code,str);                \
        } else {                                                       \
            PRINT_EXPR_STR(code,str);                                  \
        }                                                              \
        break
#define BIN_EXPR_MATH_OP(code,str)                                     \
    case code:                                                         \
        if (!p->use_column && p->fmt->spaces_around_math_op) {         \
            PRINT_EXPR_STR_ENCLOSED_IN_SPACE(code,str);                \
        } else {                                                       \
            PRINT_EXPR_STR(code,str);                                  \
        }                                                              \
        break
#define BIN_EXPR_SHIFT_OP(code,str)                                    \
    case code:                                                         \
        if (!p->use_column && p->fmt->spaces_around_shift_op) {        \
            PRINT_EXPR_STR_ENCLOSED_IN_SPACE(code,str);                \
        } else {                                                       \
            PRINT_EXPR_STR(code,str);                                  \
        }                                                              \
        break


        BIN_EXPR_ASSIGN_OP (CTRUMP_EXPR_BIN_ASSIGN, "=");
        BIN_EXPR_ASSIGN_OP (CTRUMP_EXPR_BIN_ADD_ASSIGN, "+=");
        BIN_EXPR_ASSIGN_OP (CTRUMP_EXPR_BIN_SUB_ASSIGN, "-=");
        BIN_EXPR_ASSIGN_OP (CTRUMP_EXPR_BIN_MUL_ASSIGN, "*=");
        BIN_EXPR_ASSIGN_OP (CTRUMP_EXPR_BIN_DIV_ASSIGN, "/=");
        BIN_EXPR_ASSIGN_OP (CTRUMP_EXPR_BIN_MOD_ASSIGN, "%=");
        BIN_EXPR_ASSIGN_OP (CTRUMP_EXPR_BIN_BAND_ASSIGN, "&=");
        BIN_EXPR_ASSIGN_OP (CTRUMP_EXPR_BIN_BOR_ASSIGN, "|=");
        BIN_EXPR_ASSIGN_OP (CTRUMP_EXPR_BIN_BXOR_ASSIGN, "^=");
        BIN_EXPR_ASSIGN_OP (CTRUMP_EXPR_BIN_LSHIFT_ASSIGN, "<<=");
        BIN_EXPR_ASSIGN_OP (CTRUMP_EXPR_BIN_RSHIFT_ASSIGN, ">>=");

        BIN_EXPR_LOGICAL_OP (CTRUMP_EXPR_BIN_LAND, "&&");
        BIN_EXPR_LOGICAL_OP (CTRUMP_EXPR_BIN_LOR, "||");

        BIN_EXPR_RELATIONAL_OP (CTRUMP_EXPR_BIN_EQ, "==");
        BIN_EXPR_RELATIONAL_OP (CTRUMP_EXPR_BIN_NE, "!=");
        BIN_EXPR_RELATIONAL_OP (CTRUMP_EXPR_BIN_LT, "<");
        BIN_EXPR_RELATIONAL_OP (CTRUMP_EXPR_BIN_GT, ">");
        BIN_EXPR_RELATIONAL_OP (CTRUMP_EXPR_BIN_LE, "<=");
        BIN_EXPR_RELATIONAL_OP (CTRUMP_EXPR_BIN_GE, ">=");

        BIN_EXPR_BITWISE_OP (CTRUMP_EXPR_BIN_BAND, "&");
        BIN_EXPR_BITWISE_OP (CTRUMP_EXPR_BIN_BOR, "|");
        BIN_EXPR_BITWISE_OP (CTRUMP_EXPR_BIN_BXOR, "^");

        BIN_EXPR_MATH_OP (CTRUMP_EXPR_BIN_ADD, "+");
        BIN_EXPR_MATH_OP (CTRUMP_EXPR_BIN_SUB, "-");
        BIN_EXPR_MATH_OP (CTRUMP_EXPR_BIN_MUL, "*");
        BIN_EXPR_MATH_OP (CTRUMP_EXPR_BIN_DIV, "/");
        BIN_EXPR_MATH_OP (CTRUMP_EXPR_BIN_MOD, "%");

        BIN_EXPR_SHIFT_OP (CTRUMP_EXPR_BIN_LSHIFT, "<<");
        BIN_EXPR_SHIFT_OP (CTRUMP_EXPR_BIN_RSHIFT, ">>");


#define UNA_PRE_EXPR_STR(code,str)                        \
    case code:                                            \
        PRINT_STR_CONST_LOC(p, str, &e->u.unary.op_loc);  \
        print_expr(p, e->u.unary.expr);                   \
        break;

#define UNA_POST_EXPR_STR(code,str)                       \
    case code:                                            \
        print_expr(p, e->u.unary.expr);                   \
        PRINT_STR_CONST_LOC(p, str, &e->u.unary.op_loc);  \
        break;

        UNA_PRE_EXPR_STR(CTRUMP_EXPR_UNA_PTRREF, "*");
        UNA_PRE_EXPR_STR(CTRUMP_EXPR_UNA_POS, "+");
        UNA_PRE_EXPR_STR(CTRUMP_EXPR_UNA_NEG, "-");
        UNA_PRE_EXPR_STR(CTRUMP_EXPR_UNA_PRE_INC, "++");
        UNA_PRE_EXPR_STR(CTRUMP_EXPR_UNA_PRE_DEC, "-");
        UNA_PRE_EXPR_STR(CTRUMP_EXPR_UNA_BCMPL, "~");
        UNA_PRE_EXPR_STR(CTRUMP_EXPR_UNA_ADDR, "&");

    case CTRUMP_EXPR_UNA_LNEG:
        PRINT_STR_CONST_LOC(p, "!", &e->u.unary.op_loc);
        if (!p->use_column && p->fmt->space_after_negation) {
            PRINT_STR_CONST(p, " ");
        }
        print_expr(p, e->u.unary.expr);
        break;

    case CTRUMP_EXPR_UNA_SIZEOF:
        if (e->u.unary.expr->code == CTRUMP_EXPR_PAREN) {
            PRINT_STR_CONST_LOC(p, "sizeof", &e->u.unary.op_loc);
        } else {
            PRINT_STR_CONST_LOC(p, "sizeof ", &e->u.unary.op_loc);
        }
        print_expr(p, e->u.unary.expr);
        break;

        UNA_POST_EXPR_STR(CTRUMP_EXPR_UNA_POST_INC, "++");
        UNA_POST_EXPR_STR(CTRUMP_EXPR_UNA_POST_DEC, "--");

    case CTRUMP_EXPR_PAREN:
        PRINT_STR_CONST_LOC(p,"(",&e->u.paren.lpar_loc);
        print_expr(p, e->u.paren.expr);
        PRINT_STR_CONST_LOC(p,")",&e->u.paren.rpar_loc);
        break;

    case CTRUMP_EXPR_VARREF:
        goto_loc(p, &e->u.varref.loc);
        print_sym(p, e->u.varref.var->name);
        if (p->print_internal_info && e->u.varref.pdg) {
            PRINT_STR_CONST(p, "_");
            print_sint(p, e->u.varref.pdg->id);
         }
        break;

    case CTRUMP_EXPR_SIZEOF_TYPE:
        PRINT_STR_CONST_LOC(p, "sizeof", &e->u.sizeof_type.sizeof_id_loc);
        print_typename(p, &e->u.sizeof_type.typename_);
        break;

    case CTRUMP_EXPR_EMPTY:
        break;

    case CTRUMP_EXPR_MEMBER_REF:
        print_expr(p, e->u.member_ref.obj_expr);
        PRINT_STR_CONST_LOC(p, ".", &e->u.member_ref.op_loc);
        goto_loc(p, &e->u.member_ref.symbol_loc);
        print_sym(p, e->u.member_ref.member_name);
        break;

    case CTRUMP_EXPR_PTR_MEMBER_REF:
        print_expr(p, e->u.member_ref.obj_expr);
        PRINT_STR_CONST_LOC(p, "->", &e->u.member_ref.op_loc);
        goto_loc(p, &e->u.member_ref.symbol_loc);
        print_sym(p, e->u.member_ref.member_name);
        break;

    case CTRUMP_EXPR_CALL:
        print_expr(p, e->u.call.func_expr);
        PRINT_STR_CONST_LOC(p, "(", &e->u.call.lpar_loc);
        n = e->u.call.num_args;

        for (i=0; i<n; i++) {
            if (i != 0) {
                print_comma(p);
            }
            print_expr(p, &e->u.call.args[i]);
        }

        PRINT_STR_CONST_LOC(p, ")", &e->u.call.rpar_loc);
        break;

    case CTRUMP_EXPR_TEXT:
        print_str(p, e->u.text, strlen(e->u.text));
        break;

    case CTRUMP_EXPR_CAST:
        print_typename(p, &e->u.cast.typename_);
        if (!p->use_column && p->fmt->space_after_type_cast) {
            PRINT_STR_CONST(p, " ");
        }
        print_expr(p, e->u.cast.expr);
        break;

    case CTRUMP_EXPR_CONDITIONAL:
        print_expr(p, e->u.cond.cond);

        if (!p->use_column && p->fmt->spaces_around_relational_op) {
            PRINT_STR_CONST(p, " ");
        }

        PRINT_STR_CONST_LOC(p, "?", &e->u.cond.question_loc);

        if (!p->use_column && p->fmt->spaces_around_relational_op) {
            PRINT_STR_CONST(p, " ");
        }

        print_expr(p, e->u.cond.then_);

        if (!p->use_column && p->fmt->spaces_around_relational_op) {
            PRINT_STR_CONST(p, " ");
        }

        PRINT_STR_CONST_LOC(p, ":", &e->u.cond.colon_loc);

        if (!p->use_column && p->fmt->spaces_around_relational_op) {
            PRINT_STR_CONST(p, " ");
        }

        print_expr(p, e->u.cond.else_);
        break;

    case CTRUMP_EXPR_IVTMP:
        print_expr(p, e->u.ivtmp.original_expr);
        break;

    case CTRUMP_EXPR_IMPLICIT_CAST:
        if (p->print_internal_info) {
            PRINT_STR_CONST(p, "(");
            PRINT_STR_CONST(p, "implicit cast:");
            print_texpr(p, e->u.implicit_cast.cast_to, 1);
            PRINT_STR_CONST(p, ")");
        }
        print_expr(p, e->u.implicit_cast.expr);
        break;

        //  check later!
    case CTRUMP_EXPR_STR_LITERAL:
        n = e->u.str_literal.num_str_literal;
        // for debug
        /*
        printf("n= %d\n", n);
        for (i=0; i<n; i++) {
            print_location_stderr(&e->u.str_literal.literals[i].loc);
            fprintf(stderr, "is_wide= %d\n", e->u.str_literal.literals[i].is_wide);
            fprintf(stderr, "chars= %s\n", e->u.str_literal.literals[i].literal.chars);
        }
        getchar();
        */

        for (i=0; i<n; i++) {
            if (i != 0) {
                if (!p->use_column && p->fmt->spaces_around_relational_op) {
                    PRINT_STR_CONST(p, " ");
                }
            }
            goto_loc(p, &e->u.str_literal.literals[i].loc);
            print_source(p, &e->u.str_literal.literals[i].literal);
        }
        break;

    case CTRUMP_EXPR_FLOAT_LITERAL:
        goto_loc(p, &e->u.float_literal.loc);
        print_source(p, &e->u.float_literal.literal);
        break;

    case CTRUMP_EXPR_DOUBLE_LITERAL:
        goto_loc(p, &e->u.double_literal.loc);
        print_source(p, &e->u.double_literal.literal);
        break;

    case CTRUMP_EXPR_LONG_DOUBLE_LITERAL:
        goto_loc(p, &e->u.long_double_literal.loc);
        print_source(p, &e->u.long_double_literal.literal);
        break;

    case CTRUMP_EXPR_SINT_LITERAL:
        goto_loc(p, &e->u.sint_literal.loc);
        print_source(p, &e->u.sint_literal.literal);
        break;

    case CTRUMP_EXPR_SLONG_LITERAL:
        goto_loc(p, &e->u.slong_literal.loc);
        print_source(p, &e->u.slong_literal.literal);
        break;

    case CTRUMP_EXPR_SLLONG_LITERAL:
        goto_loc(p, &e->u.sllong_literal.loc);
        print_source(p, &e->u.sllong_literal.literal);
        break;

    case CTRUMP_EXPR_UINT_LITERAL:
        goto_loc(p, &e->u.uint_literal.loc);
        print_source(p, &e->u.uint_literal.literal);
        break;

    case CTRUMP_EXPR_ULONG_LITERAL:
        goto_loc(p, &e->u.ulong_literal.loc);
        print_source(p, &e->u.ulong_literal.literal);
        break;

    case CTRUMP_EXPR_ULLONG_LITERAL:
        goto_loc(p, &e->u.ullong_literal.loc);
        print_source(p, &e->u.ullong_literal.literal);
        break;

    case CTRUMP_EXPR_INITIALIZER:
        print_typename(p, &e->u.initializer.typename_);
        print_initializer_list(p, &e->u.initializer.initializer);
        break;

        // check later!
    case CTRUMP_EXPR_MACRO_EXPAND:
        fprintf(stderr, "CTRUMP_EXPR_MACRO_EXPAND:\n");
        print_expr(p, e->u.macro_expand.expanded);

        ctrump_fixme("CTRUMP_EXPR_MACRO_EXPAND:");
        break;

    default:
        ctrump_unreachable("UNREACHABLE");
        break;
    }
}

static void
print_semicolon(struct printer *p)
{
    PRINT_STR_CONST(p, ";");
    print_newline_if_not_use_column(p);
}

static void
print_brace_open(struct printer *p)
{
    if (!p->use_column && p->fmt->indentation_before_left_brace) {
        indent(p);
    }

    PRINT_STR_CONST(p, "{");
    print_newline_if_not_use_column(p);
    indent(p);
}

static void
print_brace_close(struct printer *p)
{
    dedent(p);
    PRINT_STR_CONST(p, "}");

    if (!p->use_column && p->fmt->indentation_before_left_brace) {
        dedent(p);
    }
}

static void
print_compound_stmt(struct printer *p,
                    const struct ctrump_compound_stmt *c,
                    char *context)
{
    int i;
    int ni;

    print_space_before_braces(p);

    if (strcmp(context, "fundef") == 0) {
        if (!p->use_column && p->fmt->newline_after_declarator) {
            print_newline(p);
        }
    } else if (strcmp(context, "fundef-old-style") == 0) {
            print_newline_if_not_use_column(p);
    } else if (!p->use_column && p->fmt->newline_before_left_brace) {
        print_newline(p);
    }


    goto_loc(p, &c->lbr_loc);
    print_brace_open(p);

    ni = c->num_item;
    for (i=0; i<ni; i++) {
        print_stmt(p, &c->items[i]);
    }

    goto_loc(p, &c->rbr_loc);
    print_brace_close(p);

    if (strcmp(context, "if-else") == 0) {
        if (!p->use_column && p->fmt->newline_after_right_brace) {
            print_newline(p);
        } else {
            print_space_before_braces(p);
        }
    } else if (strcmp(context, "do-while") == 0) {
        if (!p->use_column && p->fmt->newline_after_right_brace) {
            print_newline(p);
        } else {
            print_space_before_braces(p);
        }
    } else {
        print_newline_if_not_use_column(p);
    }
}

static void
print_stmt(struct printer *p,
           const struct ctrump_stmt *c)
{
tailcall:
    switch (c->code) {

    case CTRUMP_STMT_DECL:
        print_decl(p, &c->u.decl);
        break;

    case CTRUMP_STMT_FOR:
        PRINT_STR_CONST_LOC(p, "for", &c->u.for_.kwd_loc);

        print_statement_lpar_loc(p, &c->u.for_.lpar_loc);

        print_expr(p, &c->u.for_.init);

        PRINT_STR_CONST_LOC(p, ";", &c->u.for_.semi_loc1);
        if (!p->use_column && p->fmt->space_after_semicolon) {
            PRINT_STR_CONST(p, " ");
        }

        print_expr(p, &c->u.for_.cond);

        PRINT_STR_CONST_LOC(p, ";", &c->u.for_.semi_loc2);
        if (!p->use_column && p->fmt->space_after_semicolon) {
            PRINT_STR_CONST(p, " ");
        }

        print_expr(p, &c->u.for_.iter);

        print_statement_rpar_loc(p, &c->u.for_.rpar_loc);

        c = c->u.for_.body;
        if (c->code == CTRUMP_STMT_COMPOUND ||
            c->code == CTRUMP_STMT_LIST) {
            print_compound_stmt(p, &c->u.compound, "for");
        } else {
            print_newline_if_not_use_column(p);
            indent(p);
            print_stmt(p, c);
            dedent(p);
        }
        break;

        // check later!
    case CTRUMP_STMT_FOR_DECL:
        // for debug
        /*
        print_location_stderr(&c->u.for_decl.kwd_loc);
        print_location_stderr(&c->u.for_decl.lpar_loc);
        print_location_stderr(&c->u.for_decl.semi_loc);
        */

        PRINT_STR_CONST_LOC(p, "for", &c->u.for_decl.kwd_loc);

        print_statement_lpar_loc(p, &c->u.for_decl.lpar_loc);

        int i, nd;
        print_declspec(p, &c->u.for_decl.init.spec);
        nd = c->u.for_decl.init.num_decls;
        for (i=0; i<nd; i++) {
            if (i != 0) {
                print_comma(p);
            }
            print_decl_with_init(p, &c->u.for_decl.init.decls[i]);
        }

        goto_loc(p, &c->u.for_decl.init.semi_loc);
        PRINT_STR_CONST(p, ";");
        if (!p->use_column && p->fmt->space_after_semicolon) {
            PRINT_STR_CONST(p, " ");
        }

        print_expr(p, &c->u.for_decl.cond);

        PRINT_STR_CONST_LOC(p, ";", &c->u.for_decl.semi_loc);
        if (!p->use_column && p->fmt->space_after_semicolon) {
            PRINT_STR_CONST(p, " ");
        }

        print_expr(p, &c->u.for_decl.iter);

        print_statement_rpar_loc(p, &c->u.for_decl.rpar_loc);

        c = c->u.for_decl.body;
        if (c->code == CTRUMP_STMT_COMPOUND ||
            c->code == CTRUMP_STMT_LIST) {
            print_compound_stmt(p, &c->u.compound, "for");
        } else {
            print_newline_if_not_use_column(p);
            indent(p);
            print_stmt(p, c);
            dedent(p);
        }
        break;

    case CTRUMP_STMT_COMPOUND:
        print_compound_stmt(p, &c->u.compound, "compound");
        break;

    case CTRUMP_STMT_EXPR:
        print_expr(p, &c->u.expr.expr);
        goto_loc(p, &c->u.expr.semi_loc);
        print_semicolon(p);
        break;

    case CTRUMP_STMT_EMPTY:
        goto_loc(p, &c->u.empty.semi_loc);
        print_semicolon(p);
        break;

    case CTRUMP_STMT_NEWLINE:
        print_newline(p);
        break;

    case CTRUMP_STMT_IF:
        PRINT_STR_CONST_LOC(p, "if", &c->u.if_.kwd_loc);

        print_statement_lpar_loc(p, &c->u.if_.lpar_loc);
        print_expr(p, &c->u.if_.cond);
        print_statement_rpar_loc(p, &c->u.if_.rpar_loc);

        c = c->u.if_.body;
        if (c->code == CTRUMP_STMT_COMPOUND) {
            print_compound_stmt(p, &c->u.compound, "if");
        } else {
            print_newline_if_not_use_column(p);
            indent(p);
            print_stmt(p, c);
            dedent(p);
        }
        break;

    case CTRUMP_STMT_IF_ELSE:
        PRINT_STR_CONST_LOC(p, "if", &c->u.if_else.kwd_loc);

        print_statement_lpar_loc(p, &c->u.if_else.lpar_loc);
        print_expr(p, &c->u.if_else.cond);
        print_statement_rpar_loc(p, &c->u.if_else.rpar_loc);

        if (c->u.if_else.then_body->code == CTRUMP_STMT_COMPOUND) {
            print_compound_stmt(p, &c->u.if_else.then_body->u.compound, "if-else");
        } else {
            print_newline_if_not_use_column(p);
            indent(p);
            print_stmt(p, c->u.if_else.then_body);
            dedent(p);
        }


        PRINT_STR_CONST_LOC(p, "else", &c->u.if_else.else_loc);

        if (c->u.if_else.else_body->code == CTRUMP_STMT_COMPOUND) {
            print_compound_stmt(p, &c->u.if_else.else_body->u.compound, "else");
        } else if (c->u.if_else.else_body->code == CTRUMP_STMT_IF_ELSE  ||
                   c->u.if_else.else_body->code == CTRUMP_STMT_IF) {
            PRINT_STR_CONST(p, " ");
            c = c->u.if_else.else_body;
            goto tailcall;
        } else {
            print_newline_if_not_use_column(p);
            indent(p);
            print_stmt(p, c->u.if_else.else_body);
            dedent(p);
        }
        break;

    case CTRUMP_STMT_RETURN:
        PRINT_STR_CONST_LOC(p, "return", &c->u.return_.kwd_loc);
        goto_loc(p, &c->u.return_.semi_loc);
        print_semicolon(p);

        break;

    case CTRUMP_STMT_RETURN_EXPR:
        if (c->u.ret_expr.retval.code == CTRUMP_EXPR_PAREN) {
            PRINT_STR_CONST_LOC(p, "return", &c->u.ret_expr.kwd_loc);
        } else {
            PRINT_STR_CONST_LOC(p, "return ", &c->u.ret_expr.kwd_loc);
        }
        print_expr(p, &c->u.ret_expr.retval);
        goto_loc(p, &c->u.ret_expr.semi_loc);
        print_semicolon(p);
        break;

    case CTRUMP_STMT_WHILE:
        PRINT_STR_CONST_LOC(p, "while", &c->u.while_.kwd_loc);

        print_statement_lpar_loc(p, &c->u.while_.lpar_loc);
        print_expr(p, &c->u.while_.cond);
        print_statement_rpar_loc(p, &c->u.while_.rpar_loc);

        c = c->u.while_.body;
        if (c->code == CTRUMP_STMT_COMPOUND) {
            print_compound_stmt(p, &c->u.compound, "while");
        } else {
            print_newline_if_not_use_column(p);
            indent(p);
            print_stmt(p, c);
            dedent(p);
        }
        break;

    case CTRUMP_STMT_DO_WHILE:
        PRINT_STR_CONST_LOC(p, "do", &c->u.do_while.do_loc);

        if (c->u.do_while.body->code == CTRUMP_STMT_COMPOUND) {
            print_compound_stmt(p, &c->u.do_while.body->u.compound, "do-while");
        } else {
            print_newline_if_not_use_column(p);
            indent(p);
            print_stmt(p, c->u.do_while.body);
            dedent(p);
        }

        PRINT_STR_CONST_LOC(p, "while", &c->u.do_while.while_loc);

        print_statement_lpar_loc(p, &c->u.do_while.lpar_loc);
        print_expr(p, &c->u.do_while.cond);
        print_statement_rpar_loc(p, &c->u.do_while.rpar_loc);

        goto_loc(p, &c->u.do_while.semi_loc);
        print_semicolon(p);
        break;

    case CTRUMP_STMT_GOTO:
        PRINT_STR_CONST_LOC(p, "goto ", &c->u.goto_.kwd_loc);
        goto_loc(p, &c->u.goto_.label_loc);
        print_sym(p, c->u.goto_.label);
        print_semicolon(p);
        break;

    case CTRUMP_STMT_LABELED:
        goto_loc(p, &c->u.labeled.label_loc);
        dedent(p);
        print_sym(p, c->u.labeled.label_symbol);
        PRINT_STR_CONST_LOC(p, ":", &c->u.labeled.colon_loc);
        print_newline_if_not_use_column(p);
        indent(p);
        c = c->u.labeled.stmt;
        goto tailcall;
        break;

    case CTRUMP_STMT_SWITCH:
        PRINT_STR_CONST_LOC(p, "switch", &c->u.switch_.kwd_loc);

        print_statement_lpar_loc(p, &c->u.switch_.lpar_loc);
        print_expr(p, &c->u.switch_.cond);
        print_statement_rpar_loc(p, &c->u.switch_.rpar_loc);

        c = c->u.switch_.body;
        if (c->code == CTRUMP_STMT_COMPOUND) {
            print_compound_stmt(p, &c->u.compound, "switch");
        } else {
            print_newline_if_not_use_column(p);
            indent(p);
            print_stmt(p, c);
            dedent(p);
        }
        break;

    case CTRUMP_STMT_CASE:
        dedent(p);
        PRINT_STR_CONST_LOC(p, "case ", &c->u.case_.kwd_loc);
        print_expr(p, &c->u.case_.val);
        PRINT_STR_CONST_LOC(p, ":", &c->u.case_.colon_loc);
        print_newline_if_not_use_column(p);
        indent(p);
        c = c->u.case_.stmt;
        goto tailcall;

    case CTRUMP_STMT_DEFAULT:
        dedent(p);
        PRINT_STR_CONST_LOC(p, "default", &c->u.default_.kwd_loc);
        PRINT_STR_CONST_LOC(p, ":", &c->u.default_.colon_loc);
        print_newline_if_not_use_column(p);
        indent(p);
        c = c->u.default_.stmt;
        goto tailcall;

    case CTRUMP_STMT_CONTINUE:
        PRINT_STR_CONST_LOC(p, "continue", &c->u.continue_.kwd_loc);
        goto_loc(p, &c->u.continue_.semi_loc);
        print_semicolon(p);
        break;

    case CTRUMP_STMT_BREAK:
        PRINT_STR_CONST_LOC(p, "break", &c->u.break_.kwd_loc);
        goto_loc(p, &c->u.break_.semi_loc);
        print_semicolon(p);
        break;

        // UNDEFINED
    case CTRUMP_STMT_PRAGMA:
    case CTRUMP_STMT_SLASLA_COMMENT:
    case CTRUMP_STMT_SLAAST_COMMENT:
        ctrump_fixme("Undefined print statement");
        break;

        // POSTPONED
    case CTRUMP_STMT_IFDEF:
    case CTRUMP_STMT_ASM:
    case CTRUMP_STMT_DEFINE:
    case CTRUMP_STMT_UNDEF:
        ctrump_fixme("Postponed");
        break;

    case CTRUMP_STMT_LIST:
    {
        int i, n = c->u.stmt_list.num_stmt;

        for (i=0; i<n; i++) {
            print_stmt(p, &c->u.stmt_list.stmts[i]);
        }
    }
    break;

    default:
        ctrump_unreachable("UNREACHABLE");
        break;

    }
}

static void print_ext_fundef(struct printer *p,
                             const struct ctrump_fundef *def)
{
    int i;
    int nod = def->num_oldstyle_declaration;

    print_declspec(p, &def->decl_spec);

    if (!p->use_column && p->fmt->newline_after_declspec) {
        print_newline(p);
    }

    print_declarator(p, def->decl);

    if (nod == 0) {
        print_compound_stmt(p, &def->body, "fundef");
    } else {
        /* fixme : oldstyle arguments */
        // check later!
        print_newline_if_not_use_column(p);
        indent(p);
        for (i=0; i<nod; i++) {
            print_decl(p, &def->oldstyle_decl_list[i]);
            print_newline_if_not_use_column(p);
        }
        dedent(p);

        print_compound_stmt(p, &def->body, "fundef-old-style");
    }

    if (!p->use_column) {
        for (i=0; i<p->fmt->num_blank_lines_after_func; i++) {
            print_newline(p);
        }
    } else {
        print_newline_if_not_use_column(p);
    }
}

static void
print_qual_flags(struct printer *p, int flags)
{
    if (flags & CTRUMP_QUAL_CONST) {
        PRINT_STR_CONST(p, "const ");
    }
    if (flags & CTRUMP_QUAL_RESTRICT) {
        PRINT_STR_CONST(p, "restrict ");
    }
    if (flags & CTRUMP_QUAL_VOLATILE) {
        PRINT_STR_CONST(p, "volatile ");
    }
}

static void
print_attr(struct printer *p,
           const struct ctrump_gccext_attribute *attr)
{
    if (attr->aligned != CTRUMP_ALIGN_UNSPECIFIED) {
        PRINT_STR_CONST(p, "__attribute__((aligned(");
        print_sint(p, attr->aligned);
        PRINT_STR_CONST(p, "))) ");
    }
}

static void
print_record(struct printer *p,
             const struct ctrump_record_definition *def)
{
    int i;
    int nd = def->num_decl;

    print_space_before_braces(p);
    PRINT_STR_CONST_LOC(p, "{", &def->lbr_loc);

    print_newline_if_not_use_column(p);

    indent(p);
    for (i=0; i<nd; i++) {
        print_struct_decl(p, &def->decls[i]);
        goto_loc(p, &def->decls[i].semi_loc);
        print_semicolon(p);
    }
    dedent(p);

    PRINT_STR_CONST_LOC(p, "}", &def->rbr_loc);
    print_space_before_braces(p);

    print_attr(p, &def->attr);
}

static void
print_typespec(struct printer *p,
               const struct ctrump_typespec *spec)
{
    switch (spec->code) {
    case CTRUMP_TYPESPEC_BUILTIN:
        print_str(p,
                  spec->u.builtin.texpr->u.builtin.name, 
                  strlen(spec->u.builtin.texpr->u.builtin.name));
        PRINT_STR_CONST(p, " ");
        break;
    case CTRUMP_TYPESPEC_UNTYPED_SIGNED_INT:
        break;
    case CTRUMP_TYPESPEC_TYPEDEF_NAME:
        print_sym(p, spec->u.typedef_name.name);
        PRINT_STR_CONST(p, " ");

        break;
    case CTRUMP_TYPESPEC_STRUCT_NAME:
        PRINT_STR_CONST_LOC(p, "struct ", &spec->u.struct_name.kwd_loc);
        print_sym(p, spec->u.struct_name.name);
        PRINT_STR_CONST(p, " ");
        break;
    case CTRUMP_TYPESPEC_STRUCT_DEFINITION:
        PRINT_STR_CONST_LOC(p, "struct ", &spec->u.struct_definition.kwd_loc);
        print_sym(p, spec->u.struct_definition.name);
        print_record(p, &spec->u.struct_definition.def);
        break;
    case CTRUMP_TYPESPEC_ANON_STRUCT_DEFINITION:
        PRINT_STR_CONST_LOC(p, "struct", &spec->u.anon_struct_definition.kwd_loc);
        print_record(p, &spec->u.anon_struct_definition.def);
        break;

    case CTRUMP_TYPESPEC_UNION_NAME:
        PRINT_STR_CONST_LOC(p, "union ", &spec->u.union_name.kwd_loc);
        print_sym(p, spec->u.union_name.name);
        PRINT_STR_CONST(p, " ");
        break;
    case CTRUMP_TYPESPEC_UNION_DEFINITION:
        PRINT_STR_CONST_LOC(p, "union ", &spec->u.union_definition.kwd_loc);
        print_sym(p, spec->u.union_definition.name);
        print_record(p, &spec->u.union_definition.def);
        break;
    case CTRUMP_TYPESPEC_ANON_UNION_DEFINITION:
        PRINT_STR_CONST_LOC(p, "union", &spec->u.anon_union_definition.kwd_loc);
        print_record(p, &spec->u.anon_union_definition.def);
        break;

    case CTRUMP_TYPESPEC_ENUM_NAME:
        PRINT_STR_CONST_LOC(p, "enum ", &spec->u.enum_name.kwd_loc);
        goto_loc(p, &spec->u.enum_name.name_loc);
        print_sym(p, spec->u.enum_name.name);
        PRINT_STR_CONST(p, " ");
        break;
    case CTRUMP_TYPESPEC_ENUM_DEFINITION:
        PRINT_STR_CONST_LOC(p, "enum ", &spec->u.enum_definition.kwd_loc);
        goto_loc(p, &spec->u.enum_definition.name_loc);
        print_sym(p, spec->u.enum_definition.name);
        print_enum_list(p, &spec->u.enum_definition.list);
        break;
    case CTRUMP_TYPESPEC_ANON_ENUM_DEFINITION:
        PRINT_STR_CONST_LOC(p, "enum", &spec->u.anon_enum_definition.kwd_loc);
        print_enum_list(p, &spec->u.anon_enum_definition.list);
        break;

    default:
        ctrump_unreachable("UNREACHABLE");
        break;
    }
}

static void
print_declspec(struct printer *p,
               const struct ctrump_decl_specifier *spec)
{
    goto_loc(p, &spec->begin);
    switch (spec->stor_class) {
    case CTRUMP_STOR_CLASS_EXTERN:
        PRINT_STR_CONST(p, "extern ");
        break;
    case CTRUMP_STOR_CLASS_STATIC:
        PRINT_STR_CONST(p, "static ");
        break;
    case CTRUMP_STOR_CLASS_REGISTER:
        PRINT_STR_CONST(p, "register ");
        break;
    case CTRUMP_STOR_CLASS_TYPEDEF:
        PRINT_STR_CONST(p, "typedef ");
        break;

    default:
        break;
    }

    if (spec->func_spec == CTRUMP_FUNC_SPEC_INLINE) {
        PRINT_STR_CONST(p, "inline ");
    }

    print_qual_flags(p, spec->qual_flags);
    print_attr(p, &spec->attr);
    print_typespec(p, &spec->type_spec);
}


#define DECL_POINTER_PREC 1
#define DECL_QUALIFIY_PREC 1
#define DECL_ARRAY_PREC 2
#define DECL_TYPELIST_PREC 3

static void
print_decl_left(struct printer *p,
                const struct ctrump_declarator_node *n)
{
    switch (n->code) {
    case CTRUMP_DECLARATOR_IDENTIFIER:
        goto_loc(p, &n->u.identifier.loc);
        print_sym(p, n->u.identifier.identifier);
        break;

    case CTRUMP_DECLARATOR_EMPTY:
        break;

    case CTRUMP_DECLARATOR_POINTER:
        PRINT_STR_CONST_LOC(p, "*", &n->u.pointer.star_loc);
        print_qual_flags(p, n->u.pointer.qual_flags);
        print_attr(p, &n->u.pointer.attr);

        print_decl_left(p, n->u.pointer.decl);
        break;

    case CTRUMP_DECLARATOR_ARRAY:
        print_decl_left(p, n->u.array.decl);
        break;

    case CTRUMP_DECLARATOR_VARLEN_ARRAY:
        print_decl_left(p, n->u.varlen_array.decl);
        break;

    case CTRUMP_DECLARATOR_INCOMPLETE_ARRAY:
        print_decl_left(p, n->u.incomplete_array.decl);
        break;

    case CTRUMP_DECLARATOR_PARAM_TYPELIST:
        print_decl_left(p, n->u.param_typelist.decl);
        break;

    case CTRUMP_DECLARATOR_PAREN:
        PRINT_STR_CONST_LOC(p, "(", &n->u.paren.lpar_loc);
        print_decl_left(p, n->u.paren.decl);
        break;

        // check later!
    case CTRUMP_DECLARATOR_PARAM_IDENTIFIER_LIST:
        print_decl_left(p, n->u.param_id_list.decl);
        // ctrump_fixme("Undefined decl statement");
        break;

    default:
        ctrump_unreachable("UNREACHABLE");
        break;
    }
}

static void
print_decl_right(struct printer *p,
                 const struct ctrump_declarator_node *n)
{
    int i, na;
    switch (n->code) {
    case CTRUMP_DECLARATOR_IDENTIFIER:
        break;

    case CTRUMP_DECLARATOR_EMPTY:
        break;

    case CTRUMP_DECLARATOR_POINTER:
        print_decl_right(p, n->u.pointer.decl);
        break;

    case CTRUMP_DECLARATOR_ARRAY:
        print_decl_right(p, n->u.array.decl);

        print_lbracket_loc(p, &n->u.array.lbr_loc);
        print_qual_flags(p, n->u.array.qual_flags);
        print_expr(p, &n->u.array.size);
        print_rbracket_loc(p, &n->u.array.rbr_loc);
        break;

    case CTRUMP_DECLARATOR_VARLEN_ARRAY:
        print_decl_right(p, n->u.varlen_array.decl);

        print_lbracket_loc(p, &n->u.varlen_array.lbr_loc);
        print_qual_flags(p, n->u.varlen_array.qual_flags);
        PRINT_STR_CONST_LOC(p, "*", &n->u.varlen_array.star_loc);
        print_rbracket_loc(p, &n->u.varlen_array.rbr_loc);
        break;

    case CTRUMP_DECLARATOR_INCOMPLETE_ARRAY:
        print_decl_right(p, n->u.incomplete_array.decl);

        print_lbracket_loc(p, &n->u.incomplete_array.lbr_loc);
        print_qual_flags(p, n->u.incomplete_array.qual_flags);
        print_rbracket_loc(p, &n->u.incomplete_array.rbr_loc);
        break;

    case CTRUMP_DECLARATOR_PARAM_TYPELIST:
        print_decl_right(p, n->u.param_typelist.decl);
        PRINT_STR_CONST_LOC(p, "(", &n->u.param_typelist.lpar_loc);

        na = n->u.param_typelist.num_args;
        if (na == 0) {
            ;
        } else {
            if (!p->use_column && p->fmt->newline_after_decl_params) {
                int tab = p->indent;
                p->indent = p->cur_column-1;

                for (i=0; i<na; i++) {
                    if (i != 0) {
                        PRINT_STR_CONST(p, ",");
                        print_newline(p);
                    }
                    print_declspec(p, &n->u.param_typelist.args[i].decl_spec);
                    print_declarator(p, n->u.param_typelist.args[i].decl);
                }
                if (n->u.param_typelist.has_unspecified_arg) {
                    print_comma(p);
                    PRINT_STR_CONST(p, "...");
                }

                p->indent = tab;
            } else {
                for (i=0; i<na; i++) {
                    if (i != 0) {
                        goto_loc(p, &n->u.param_typelist.args[i].left_comma_loc);
                        print_comma(p);
                    }
                    print_declspec(p, &n->u.param_typelist.args[i].decl_spec);
                    print_declarator(p, n->u.param_typelist.args[i].decl);
                }
                if (n->u.param_typelist.has_unspecified_arg) {
                    goto_loc(p, &n->u.param_typelist.unspec_comma_loc);
                    print_comma(p);
                    PRINT_STR_CONST_LOC(p, "...", &n->u.param_typelist.unspec_arg_loc);
                }
            }
        }

        delete_extra_space(p);
        PRINT_STR_CONST_LOC(p, ")", &n->u.param_typelist.rpar_loc);
        break;

    case CTRUMP_DECLARATOR_PAREN:
        print_decl_right(p, n->u.paren.decl);
        PRINT_STR_CONST_LOC(p, ")", &n->u.paren.rpar_loc);
        break;

        // check later!
    case CTRUMP_DECLARATOR_PARAM_IDENTIFIER_LIST:
        PRINT_STR_CONST_LOC(p, "(", &n->u.param_id_list.lpar_loc);
        na = n->u.param_id_list.num_args;
        for (i=0; i<na; i++) {
            if (i != 0) {
                goto_loc(p, &n->u.param_id_list.identifiers[i].comma_loc);
                print_comma(p);
            }
            goto_loc(p, &n->u.param_id_list.identifiers[i].id_loc);
            print_sym(p, n->u.param_id_list.identifiers[i].name);
        }
        PRINT_STR_CONST_LOC(p, ")", &n->u.param_id_list.rpar_loc);
        // ctrump_fixme("Undefined decl statement");
        break;

    default:
        ctrump_unreachable("UNREACHABLE");
        break;
    }
}


static void
print_declarator(struct printer *p,
                 const struct ctrump_declarator *d)
{
    print_decl_left(p, &d->nodes);
    print_decl_right(p, &d->nodes);
    print_attr(p, &d->attr);
}

static void
print_ctrump_designator(struct printer *p,
                        const struct ctrump_designator *d)
{
    switch (d->code) {

    case CTRUMP_DESIGNATOR_INDEX:
        print_lbracket_loc(p, &d->u.index.lbr_loc);
        print_expr(p, d->u.index.index);
        print_rbracket_loc(p, &d->u.index.rbr_loc);
        break;

    case CTRUMP_DESIGNATOR_IDENT:
        PRINT_STR_CONST_LOC(p, ".", &d->u.ident.dot_loc);
        goto_loc(p, &d->u.ident.name_loc);
        print_sym(p, d->u.ident.ident);
        break;

    default:
        ctrump_unreachable("UNREACHABLE");
        break;
    }
}

static void
print_initializer_list(struct printer *p,
                       const struct ctrump_initializer_list *il)
{
    int i;
    int j;
    int ne;
    int nd;

    print_space_before_braces(p);
    PRINT_STR_CONST_LOC(p, "{", &il->lbr_loc);
    print_padding_around_braces(p);

    ne = il->num_elem;
    for (i=0; i<ne; i++) {
        if (i != 0) {
            goto_loc(p, &il->elems[i].left_comma_loc);
            print_comma(p);
        }

        nd = il->elems[i].num_designator;
        for (j=0; j<nd; j++) {
            print_ctrump_designator(p, &il->elems[i].designators_list[j]);
        }

        if (nd != 0) {
            print_space_around_assignment_op(p);
            PRINT_STR_CONST_LOC(p, "=", &il->elems[i].eq_loc);
            print_space_around_assignment_op(p);
        }

        print_initializer(p, &il->elems[i].initializer);
    }

    if (il->hints_for_printer == CTRUMP_INITIALIZER_HAVE_LAST_COMMA) {
        goto_loc(p, &il->last_comma_loc);
        print_comma(p);
    }

    print_padding_around_braces(p);
    PRINT_STR_CONST_LOC(p, "}", &il->rbr_loc);
}

static void
print_initializer(struct printer *p,
                  const struct ctrump_initializer *i)
{
    switch (i->code) {
    case CTRUMP_INITIALIZER_EMPTY:
        ;
        break;

    case CTRUMP_INITIALIZER_EXPR:
        print_expr(p, i->u.expr);
        break;

    case CTRUMP_INITIALIZER_NESTED:
        print_initializer_list(p, i->u.nest);
        break;

    default:
        ctrump_unreachable("UNREACHABLE");
        break;
    }
}

static void
print_decl_with_init(struct printer *p,
                     const struct ctrump_decl_with_init *d)
{
    print_declarator(p, d->decl);

    switch (d->initializer.code) {
    case CTRUMP_INITIALIZER_EMPTY:
        break;

    case CTRUMP_INITIALIZER_EXPR:
    case CTRUMP_INITIALIZER_NESTED:
        print_space_around_assignment_op(p);
        PRINT_STR_CONST_LOC(p, "=", &d->eq_loc);
        print_space_around_assignment_op(p);

        print_initializer(p, &d->initializer);
        break;
    }
}

static void
print_decl(struct printer *p,
           const struct ctrump_decl *decl)
{
    int i, nd;

    print_declspec(p, &decl->spec);

    nd = decl->num_decls;
    for (i=0; i<nd; i++) {
        if (i != 0) {
            print_comma(p);
        }
        print_decl_with_init(p, &decl->decls[i]);
    }

    goto_loc(p, &decl->semi_loc);
    print_semicolon(p);

    switch (decl->spec.type_spec.code) {
    case CTRUMP_TYPESPEC_STRUCT_DEFINITION:
    case CTRUMP_TYPESPEC_UNION_DEFINITION:
    case CTRUMP_TYPESPEC_ANON_STRUCT_DEFINITION:
    case CTRUMP_TYPESPEC_ANON_UNION_DEFINITION:
    case CTRUMP_TYPESPEC_ENUM_DEFINITION:
    case CTRUMP_TYPESPEC_ANON_ENUM_DEFINITION:
        print_newline_if_not_use_column(p);
        break;
    default:
        break;
    }
}

static void
print_struct_declarator(struct printer *p,
                        const struct ctrump_struct_declarator *declarator)
{
    if (declarator->decl)
        print_declarator(p, declarator->decl);

    if (declarator->bitfield_expr) {
        goto_loc(p, &declarator->colon_loc);
        PRINT_STR_CONST(p, ":");
        print_expr(p, declarator->bitfield_expr);
    }
}

static void
print_struct_decl(struct printer *p,
                  const struct ctrump_struct_decl *decl)
{
    int i, nd;

    if (decl->code == CTRUMP_STRUCT_DECL_FIELDS) {
        print_declspec(p, &decl->u.decl.spec);

        nd = decl->u.decl.num_decls;
        for (i=0; i<nd; i++) {
            if (i != 0) {
                print_comma(p);
            }
            print_struct_declarator(p, &decl->u.decl.decls[i]);
        }
    }
}


static void
pprint_tree(struct printer *p,
            const struct ctrump_translation_unit *t)
{
    int i;
    int n = t->num_decl;
    struct ctrump_extdecl *decls = t->decls;

    for (i=0; i<n; i++) {
        goto_loc(p, &decls[i].loc);
        switch (decls[i].code) {
        case CTRUMP_EXT_FUNCTION_DEFINITION:
            print_ext_fundef(p, &decls[i].u.func_def);
            break;
        case CTRUMP_EXT_OBJECT_DEFINITION:
            print_decl(p, &decls[i].u.obj_def);
            break;
        case CTRUMP_EXT_EMPTY_DEFINITION:
            print_semicolon(p);
            break;
        case CTRUMP_EXT_SLASLA_COMMENT:
        case CTRUMP_EXT_SLAAST_COMMENT:
            print_source(p, &decls[i].source_text);
            break;

        case CTRUMP_EXT_INCLUDE_PATH:
            goto_bol(p);
            PRINT_STR_CONST(p, "#include ");
            if (decls[i].u.include_path.is_quote)
                PRINT_STR_CONST(p, "\"");
            else
                PRINT_STR_CONST(p, "<");

            print_str(p, 
                      decls[i].u.include_path.path_str,
                      strlen(decls[i].u.include_path.path_str));

            if (decls[i].u.include_path.is_quote){
                PRINT_STR_CONST(p, "\"");
                print_newline(p);
            }else{
                PRINT_STR_CONST(p, ">");
                print_newline(p);
            }
            break;

        case CTRUMP_EXT_NEWLINE:
            print_newline(p);
            break;

            // POSTPONED
        case CTRUMP_EXT_IFDEF_BLOCK:
        case CTRUMP_EXT_INCLUDE:
        case CTRUMP_EXT_UNDEF:
        case CTRUMP_EXT_DEFINE:
            ctrump_fixme("Postponed");
            break;

        case CTRUMP_EXT_GCC_CPP_NOTE:
            break;
            if (! p->suspended) {
                p->suspended = 1;
                break;
            }

            if (strcmp(decls[i].u.gcc_cpp_note.path_str, p->filename) == 0) {
                int j, k;
                int num = decls[i].u.gcc_cpp_note.num_digit;
                FILE *fp;
                char buf[1024];
                struct ctrump_location loc;

                for (j=0; j<num; j++) {
                    if (decls[i].u.gcc_cpp_note.digits[j] == 2) {
                        // for debug
                        //printf("line= %d\n",decls[i].u.gcc_cpp_note.line);
                        //printf("path_str= %s\n",decls[i].u.gcc_cpp_note.path_str);
                        //printf("filename= %s\n",p->filename);
                        p->suspended = 0;
                        loc.column = 1;
                        loc.lineno = decls[i].u.gcc_cpp_note.line - 1;
                        goto_loc(p, &loc);

                        if ((fp = fopen(p->filename, "r")) == NULL) {
                            fprintf(stderr, "ERROR: cannot open file \"%s\".\n", p->filename);
                            exit(1);
                        }

                        for (k = 0; k < decls[i].u.gcc_cpp_note.line - 1; k++) {
                            fgets(buf, sizeof(buf), fp);
                        }

                        print_str(p, buf, strlen(buf));
                        fclose(fp);
                        break;
                    }
                }
            }
            break;

        default:
            ctrump_unreachable("UNREACHABLE");
            break;
        }
    }
}

static void
init_printer(struct printer *p, int is_use_column, int print_internal_info,
             const struct ctrump_translation_unit *t)
{
    p->cur_lineno = 1;
    p->cur_column = 1;
    p->indent = 0;
    p->line_begin = 1;
    p->buffer = malloc(32);
    p->content_len = 0;
    p->buf_len = 32;
    p->use_column = is_use_column;
    p->max_column = 80;
    p->print_internal_info = print_internal_info;

    p->suspended = 0;
    if (t != NULL) {
        p->filename = t->filename;
    }
}

static void
init_printer_with_format(struct printer *p,
                         int print_internal_info,
                         const struct ctrump_pprint_format *fmt,
                         const struct ctrump_translation_unit *t)
{
    init_printer(p, 0, print_internal_info, t);
    p->fmt = fmt;
}

void
ctrump_print_translation_unit(char **ret,
                              int *ret_length,
                              int print_internal_info,
                              const struct ctrump_translation_unit *t)
{
    struct printer p;

    init_printer(&p, 1, print_internal_info, t);
    pprint_tree(&p, t);
    PRINT_STR_CONST(&p, "\n\0");

    *ret = p.buffer;
    *ret_length = p.content_len-1;
}

void
ctrump_print_translation_unit_format(char **ret,
                                     int *ret_length,
                                     int print_internal_info,
                                     const struct ctrump_pprint_format *fmt,
                                     const struct ctrump_translation_unit *t)
{
    struct printer p;

    init_printer_with_format(&p, print_internal_info, fmt, t);
    pprint_tree(&p, t);
    PRINT_STR_CONST(&p, "\n\0");

    *ret = p.buffer;
    *ret_length = p.content_len-1;
}

void
ctrump_print_stmt(char **ret,
                  int *ret_length,
                  int print_ssa_node,
                  const struct ctrump_stmt *stmt)
{
    struct printer p;

    init_printer(&p, 0, print_ssa_node, NULL);
    print_stmt(&p, stmt);
    PRINT_STR_CONST(&p, "\0");

    *ret = p.buffer;
    *ret_length = p.content_len-1;
}

void ctrump_print_stmt_format(char **ret,
                              int *ret_length,
                              int print_ssa_node,
                              const struct ctrump_pprint_format *fmt,
                              const struct ctrump_stmt *stmt)
{
    struct printer p;

    init_printer_with_format(&p, print_ssa_node, fmt, NULL);
    print_stmt(&p, stmt);
    PRINT_STR_CONST(&p, "\0");

    *ret = p.buffer;
    *ret_length = p.content_len-1;
}

void
ctrump_print_expr(char **ret,
                  int *ret_length,
                  int print_ssa_node,
                  const struct ctrump_expr *expr)
{
    struct printer p;

    init_printer(&p, 0, print_ssa_node, NULL);
    print_expr(&p, expr);
    PRINT_STR_CONST(&p, "\0");

    *ret = p.buffer;
    *ret_length = p.content_len-1;
}

void
ctrump_print_expr_format(char **ret,
                         int *ret_length,
                         int print_ssa_node,
                         const struct ctrump_pprint_format *fmt,
                         const struct ctrump_expr *expr)
{
    struct printer p;

    init_printer_with_format(&p, print_ssa_node, fmt, NULL);
    print_expr(&p, expr);
    PRINT_STR_CONST(&p, "\0");

    *ret = p.buffer;
    *ret_length = p.content_len-1;
}

static struct ctrump_gccext_attribute
attr_empty(void)
{
    struct ctrump_gccext_attribute attr;
    attr.flags = 0;
    attr.aligned = CTRUMP_ALIGN_UNSPECIFIED;
    return attr;
}

static void
print_texpr_record(struct printer *p,
                   const struct ctrump_record_type *record,
                   int is_typename)
{
    int i,n;
    if (! record->is_completed){
        return;
    }

    n = record->nfield;

    if (record->name) {
        print_sym(p, record->name);
    } else {
        PRINT_STR_CONST(p, "<anon>");
    }

    if (! is_typename) {
        PRINT_STR_CONST(p, "{");
        print_newline(p);
        indent(p);

        for (i=0; i<n ;i++) {
            print_texpr(p, record->fields[i].type, is_typename);
            print_newline(p);
        }

        dedent(p);
        PRINT_STR_CONST(p, "}");
    }
}

static void
print_texpr_spec(struct printer *p,
                 const struct ctrump_texpr *texpr,
                 int flags,
                 struct ctrump_gccext_attribute *attr,
                 int is_typename)
{
    struct ctrump_gccext_attribute next_attr;

tailcall:
    switch (texpr->code) {
    case CTRUMP_TYPE_BUILTIN:
        print_qual_flags(p, flags);
        print_attr(p, attr);
        print_str(p, texpr->u.builtin.name, strlen(texpr->u.builtin.name));
        break;

    case CTRUMP_TYPE_TYPEDEF_NAME:
        print_qual_flags(p, flags);
        print_attr(p, attr);
        print_sym(p, texpr->u.typedef_name.def_name);
        break;

    case CTRUMP_TYPE_UNION:
        print_qual_flags(p, flags);
        print_attr(p, attr);
        PRINT_STR_CONST(p, "union ");
        print_texpr_record(p, &texpr->u.union_, is_typename);
        break;

    case CTRUMP_TYPE_STRUCT:
        print_qual_flags(p, flags);
        print_attr(p, attr);
        PRINT_STR_CONST(p, "struct ");
        print_texpr_record(p, &texpr->u.struct_, is_typename);
        break;

    case CTRUMP_TYPE_FUNC:
        flags = 0;
        next_attr = attr_empty();
        attr = &next_attr;
        texpr = texpr->u.func.ret;
        goto tailcall;

    case CTRUMP_TYPE_POINTER:
        flags = 0;
        next_attr = attr_empty();
        attr = &next_attr;
        texpr = texpr->u.pointer_to;
        goto tailcall;

    case CTRUMP_TYPE_ARRAY:
        flags = 0;
        next_attr = attr_empty();
        attr = &next_attr;
        texpr = texpr->u.array.array_of;
        goto tailcall;

    case CTRUMP_TYPE_QUALIFIED:
        next_attr = ctrump_merge_attr(attr, &texpr->u.qualified.attr);
        flags |= texpr->u.qualified.qual_flags;
        attr = &next_attr;
        texpr = texpr->u.qualified.unqualified_type;
        goto tailcall;

    case CTRUMP_TYPE_VARLEN_ARRAY:
    case CTRUMP_TYPE_INCOMPLETE_ARRAY:
    case CTRUMP_TYPE_ENUM:
        ctrump_fixme("print type spec");
        break;

    default:
        ctrump_unreachable("UNREACHABLE");
        break;
    }
}

static void
print_texpr_abstract_declarator(struct printer *p,
                                const struct ctrump_texpr *texpr,
                                int prec,
                                int flags,
                                struct ctrump_gccext_attribute *attr,
                                int is_typename)
{
    struct ctrump_texpr **args;
    int has_unspecified_arg;
    struct ctrump_gccext_attribute next_attr;

tailcall:
    switch (texpr->code) {
    case CTRUMP_TYPE_BUILTIN:
    case CTRUMP_TYPE_UNION:
    case CTRUMP_TYPE_STRUCT:
    case CTRUMP_TYPE_TYPEDEF_NAME:
        break;
        break;

    case CTRUMP_TYPE_FUNC:
        has_unspecified_arg = texpr->u.func.has_unspecified_arg;
        args = texpr->u.func.args;
        next_attr = attr_empty();
        print_texpr_abstract_declarator(p, texpr->u.func.ret, DECL_TYPELIST_PREC,
                                        0, &next_attr, is_typename);
        PRINT_STR_CONST(p, "(");

        if (texpr->u.func.arg_num) {
            int i,n;
            indent(p);
            print_texpr(p, args[0], is_typename);
            n = texpr->u.func.arg_num;
            for (i=1; i<n; i++) {
                PRINT_STR_CONST(p, ", ");
                print_texpr(p, args[i], is_typename);
            }

            if (has_unspecified_arg) {
                PRINT_STR_CONST(p, ", ...");
            }

            dedent(p);
        } else if (!has_unspecified_arg) {
            PRINT_STR_CONST(p, "void");
        }

        PRINT_STR_CONST(p, ")");
        break;

    case CTRUMP_TYPE_POINTER:
        if (prec > DECL_POINTER_PREC) {
            PRINT_STR_CONST(p, "(");
        }
        PRINT_STR_CONST(p, "*");
        print_qual_flags(p, flags);
        print_attr(p, attr);
        print_texpr_abstract_declarator(p, texpr->u.pointer_to, DECL_POINTER_PREC,
                                        0, &next_attr, is_typename);
        if (prec > DECL_POINTER_PREC) {
            PRINT_STR_CONST(p, ")");
        }
        break;

    case CTRUMP_TYPE_ARRAY:
        if (prec > DECL_ARRAY_PREC) {
            PRINT_STR_CONST(p, "(");
        }
        print_texpr_abstract_declarator(p, texpr->u.array.array_of,
                                        DECL_ARRAY_PREC, flags, attr, is_typename);
        PRINT_STR_CONST(p, "[");
        print_sint(p, texpr->u.array.size);
        PRINT_STR_CONST(p, "]");

        if (prec > DECL_ARRAY_PREC) {
            PRINT_STR_CONST(p, ")");
        }

        break;

    case CTRUMP_TYPE_QUALIFIED:
        flags |= texpr->u.qualified.qual_flags;
        next_attr = ctrump_merge_attr(&texpr->u.qualified.attr, attr);
        attr = &next_attr;
        texpr = texpr->u.qualified.unqualified_type;
        goto tailcall;

    case CTRUMP_TYPE_VARLEN_ARRAY:
    case CTRUMP_TYPE_INCOMPLETE_ARRAY:
    case CTRUMP_TYPE_ENUM:
        ctrump_fixme("print type spec");
        break;

    default:
        ctrump_unreachable("UNREACHABLE");
        break;
    }
}

static void
print_texpr(struct printer *p,
            const struct ctrump_texpr *type,
            int is_typename)
{
    struct ctrump_gccext_attribute attr;
    attr = attr_empty();
    print_texpr_spec(p, type, 0, &attr, is_typename);
    attr = attr_empty();
    print_texpr_abstract_declarator(p, type, 0, 0, &attr, is_typename);
}

void
ctrump_print_texpr_as_typename(char **ret,
                               int *ret_length,
                               const struct ctrump_texpr *texpr)
{
    struct printer p;
    init_printer(&p, 0, 0, NULL);

    print_texpr(&p, texpr, 1);
    PRINT_STR_CONST(&p, "\0");

    *ret = p.buffer;
    *ret_length = p.content_len-1;
}

void
ctrump_print_texpr_as_internal(char **ret,
                               int *ret_length,
                               const struct ctrump_texpr *texpr)
{
    struct printer p;
    init_printer(&p, 0, 0, NULL);

    print_texpr(&p, texpr, 0);
    PRINT_STR_CONST(&p, "\0");

    *ret = p.buffer;
    *ret_length = p.content_len-1;
}

int
ctrump_print_expr_stderr(struct ctrump_expr *e, int is_print_internal)
{
    char *p;
    int len;
    int r;
    ctrump_print_expr(&p, &len, is_print_internal, e);
    r = fwrite(p, 1, len, stderr);
    if (r < 0)
        return r;
    fputc('\n', stderr);
    fflush(stderr);
    free(p);

    return 0;
}

int
ctrump_print_translation_unit_stderr(struct ctrump_translation_unit *u)
{
    char *p;
    int len;
    int r;
    ctrump_print_translation_unit(&p, &len, 1, u);
    r = fwrite(p, 1, len, stderr);
    if (r < 0)
        return r;
    fputc('\n', stderr);
    fflush(stderr);
    free(p);

    return 0;
}

int
ctrump_print_texpr_stderr(const struct ctrump_texpr *texpr)
{
    char *p;
    int len;
    int r;
    ctrump_print_texpr_as_internal(&p, &len, texpr);
    r = fwrite(p, 1, len, stderr);
    if (r < 0)
        return r;
    fputc('\n', stderr);
    fflush(stderr);
    free(p);

    return 0;
}

static void
print_enum_list(struct printer *p,
                const struct ctrump_enum_list *el)
{
    int i;
    int n;

    print_space_before_braces(p);
    PRINT_STR_CONST_LOC(p, "{", &el->lbr_loc);

    print_newline_if_not_use_column(p);
    indent(p);

    n = el->num_elem;
    for (i = 0; i < n; i++) {
        goto_loc(p, &el->elems[i].name_loc);
        print_sym(p, el->elems[i].name);

        if (el->elems[i].value) {
            print_space_around_assignment_op(p);
            PRINT_STR_CONST_LOC(p, "=", &el->elems[i].eq_loc);
            print_space_around_assignment_op(p);

            print_expr(p, el->elems[i].value);
        }

        if (i != n-1) {
            PRINT_STR_CONST_LOC(p, ",", &el->elems[i+1].comma_loc);
        } else if (el->flags == CTRUMP_ENUM_LIST_HAVE_LAST_COMMA) {
            PRINT_STR_CONST_LOC(p, ",", &el->comma_loc);
        }

        print_newline_if_not_use_column(p);
    }

    dedent(p);

    PRINT_STR_CONST_LOC(p, "}", &el->rbr_loc);
    print_space_before_braces(p);
}


static int
is_empty_line(char *buf)
{
    char *c = buf;

    while (*c != '\n') {
        if (*c++ != ' ') return 0;
    }
    return 1;
}

static int
is_slasla_comment_line(char *buf)
{
    char *c = buf;

    while (*c == ' ') c++;
    return (strncmp(c, "//", 2) == 0) ? 1 : 0;
}

static int
is_preprocessor_exp_line(char *buf)
{
    char *c = buf;

    while (*c == ' ') c++;
    return (*c == '#') ? 1 : 0;
}


static void
remove_comment_preprocessor(char *file_in,
                            char *file_out)
{
    FILE *f_in;
    FILE *f_out;

    if ((f_in = fopen(file_in, "r")) == NULL) {
        fprintf(stderr, "ERROR: cannot open file \"%s\".\n", file_in);
        exit(1);
    }

    if ((f_out = fopen(file_out, "w")) == NULL) {
        fprintf(stderr, "ERROR: cannot open file \"%s\".\n", file_out);
        exit(1);
    }

    char buf[1024];
    char *c;
    int in_slaast_comment = 0;

    while (fgets(buf, sizeof(buf), f_in) != NULL) {
        c = buf;
    start_loop:
        if (!in_slaast_comment) {
            while (*c != '\n') {
                if (is_slasla_comment_line(c) ||
                    is_preprocessor_exp_line(c)) {
                    goto end_loop;
                }

                if (strcmp(c, "/*") == 0) {
                    fputc(' ', f_out);
                    in_slaast_comment = 1;
                    c += 2;
                    goto start_loop;
                }
                fputc(*c, f_out);
                c++;
            }
        } else {
            while (*c != '\n') {
                if (strcmp(c, "*/") == 0) {
                    in_slaast_comment = 0;
                    c += 2;
                    goto start_loop;
                }
                fputc(*c, f_out);
                c++;
            }
        }
    end_loop:
        fputc('\n', f_out);
    }

    fclose(f_in);
    fclose(f_out);
}

void
ctrump_format_file2pprint_format(char *file_name,
                                 struct ctrump_pprint_format *fmt)
{
    FILE *fp;
    char buf[1024];
    int  n;
    char fmt_in[1024];
    int  val;
    char dummy[1024];
    int  error = 0;


    if ((fp = fopen(file_name, "r")) == NULL) {
        fprintf(stderr, "ERROR: cannot open file \"%s\".\n", file_name);
        exit(1);
    }

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        if (is_empty_line(buf) || is_slasla_comment_line(buf)) {
            continue;
        }

        n = sscanf(buf, "%s %d %[^\n]s", fmt_in, &val, dummy);

#define READ_VAL_FOR_LABEL(label)                  \
        if (strcmp(fmt_in, #label) == 0) {         \
            fmt->label = val;                      \
        } else 

        READ_VAL_FOR_LABEL(indentation_size)
        READ_VAL_FOR_LABEL(num_blank_lines_after_func)
        READ_VAL_FOR_LABEL(indentation_before_left_brace)
        READ_VAL_FOR_LABEL(newline_after_declspec)
        READ_VAL_FOR_LABEL(newline_after_decl_params)
        READ_VAL_FOR_LABEL(newline_after_declarator)
        READ_VAL_FOR_LABEL(newline_before_left_brace)
        READ_VAL_FOR_LABEL(newline_after_right_brace)
        READ_VAL_FOR_LABEL(space_before_statement_parens)
        READ_VAL_FOR_LABEL(space_before_braces)
        READ_VAL_FOR_LABEL(space_before_brackets)
        READ_VAL_FOR_LABEL(space_after_comma)
        READ_VAL_FOR_LABEL(space_after_semicolon)
        READ_VAL_FOR_LABEL(space_after_type_cast)
        READ_VAL_FOR_LABEL(space_after_negation)
        READ_VAL_FOR_LABEL(spaces_around_assignment_op)
        READ_VAL_FOR_LABEL(spaces_around_logical_op)
        READ_VAL_FOR_LABEL(spaces_around_relational_op)
        READ_VAL_FOR_LABEL(spaces_around_bitwise_op)
        READ_VAL_FOR_LABEL(spaces_around_math_op)
        READ_VAL_FOR_LABEL(spaces_around_shift_op)
        READ_VAL_FOR_LABEL(padding_around_statement_parens)
        READ_VAL_FOR_LABEL(padding_around_braces)
        READ_VAL_FOR_LABEL(padding_around_brackets)
        READ_VAL_FOR_LABEL(padding_around_type_cast)
        {
            fprintf(stderr, "ERROR: unknown label \"%s\" ", fmt_in);
            fprintf(stderr, "appears in \"%s\".\n", file_name);
            error = 1;
            continue;
        }

        if (n == 1) {
            fprintf(stderr, "ERROR: too few arguments for label ");
            fprintf(stderr, "\"%s\"\n", fmt_in);
            error = 1;
        } else if (n > 2) {
            if (! is_slasla_comment_line(dummy)) {
                fprintf(stderr, "ERROR: too many arguments for label ");
                fprintf(stderr, "\"%s\"\n", fmt_in);
                error = 1;
            }
        }
    }

    fclose(fp);

    if (error) exit(1);
}

struct ctrump_pprint_format
ctrump_generate_pprint_format(char *file_name)
{
    char *default_format = DEFAULT_PP_FORMAT_FILE;
    struct ctrump_pprint_format fmt;

    if (file_name == NULL) {
        ctrump_format_file2pprint_format(default_format, &fmt);
    } else {
        ctrump_format_file2pprint_format(default_format, &fmt);
        ctrump_format_file2pprint_format(file_name, &fmt);
    }

    return fmt;
}


static void
call_preprocessor(const char *prog_file,
                  const char *cpp_file)
{
    char cpp_call[1024] = "cpp -imacros ../../data/compat-macros.h ";

    strcat (cpp_call, prog_file);
    strcat (cpp_call, " > ");
    strcat (cpp_call, cpp_file);

    system(cpp_call);
}


#include "ctrump/parser/error.h"
#include "ctrump/parser/cfront.h"

void
ctrump_indent(struct ctrump_translation_unit *tree,
              const struct ctrump_pprint_format *fmt,
              char *file_tmp)
{
    FILE *fp;
#ifdef _WIN32
    char file_tmp_cpp[L_tmpnam];
#else
    char file_tmp_cpp[] = "tmp.ctrump_indent_e.c.XXXXXX";
#endif
    char *ptr;
    int len;

    strcpy(file_tmp, "tmp.ctrump_indent.c.XXXXXX");
#ifdef _WIN32
    tmpnam(file_tmp);
    tmpnam(file_tmp_cpp);
#else
    mkstemp(file_tmp);
    mkstemp(file_tmp_cpp);
#endif

    ctrump_print_translation_unit_format(&ptr, &len, 0, fmt, tree);

    if ((fp = fopen(file_tmp, "w")) == NULL) {
        fprintf(stderr, "ERROR: cannot open file \"%s\".\n", file_tmp);
        exit(1);
    }
    fwrite(ptr, 1, len, fp);
    fclose(fp);

    call_preprocessor(file_tmp, file_tmp_cpp);

    struct ctrump_type_env type_env;
    struct ctrump_mempool tree_pool;
    int r;
    struct ctrump_loginfo *error;
    int num_error;
    struct ctrump_parser_option parse_opt;

    ctrump_type_env_init(&type_env, 0);
    ctrump_mempool_init(&tree_pool, 1024);

    ctrump_get_default_parser_option(&parse_opt);

    r = ctrump_parse(&error, &num_error, tree, file_tmp_cpp, file_tmp,
                     &type_env, &ctrump_ppc32_abi, &parse_opt,
                     0, &tree_pool);
    if (r<0) {
        int i;
        fprintf(stderr, "num_error= %d\n", num_error);
        for(i=0;i<num_error;i++) {
            fprintf(stderr, "%d\n", error->code);
        }
        ctrump_fixme("ERROR: ctrump_parse() in ctrump_indent()\n");
    }

    if (remove(file_tmp_cpp) != 0) {
        fprintf(stderr, "WARNING: fail to remove temporally file \"%s\".\n",
                file_tmp_cpp);
    }
}



static char *
column_begin_with(char *buf, char *key)
{
    char *c1;
    int i;

    c1 = strstr(buf, key);
    if (c1 != NULL) {
        for (i = 0; i < c1-buf; i++) {
            if (buf[i] != ' ') break;
        }
        if (i == c1-buf) return c1;
    }

    return NULL;
}


static char *
column_begin_with_forifwhileswitch(char *buf)
{
    char *pc;

    pc = column_begin_with(buf, "for");
    if (pc != NULL) return pc;

    pc = column_begin_with(buf, "if");
    if (pc != NULL) return pc;

    pc = column_begin_with(buf, "while");
    if (pc != NULL) return pc;

    pc = column_begin_with(buf, "switch");
    if (pc != NULL) return pc;

    return NULL;
}



static void
set_indentation_size(FILE *fp,
                     struct ctrump_pprint_format *fmt)
{
    int lineno;
    char buf[1024];
    int i;

    rewind(fp);

    lineno = 1;
    fmt->indentation_size = 1000;

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        if (buf[0] != ' ') continue;

        for (i = 0; i < strlen(buf)-1; i++) {
            if (buf[i] == ':') goto next_loop;
        }

        for (i = 0; i < strlen(buf)-1; i++) {
            if (buf[i] != ' ') break;
        }
        if (i == strlen(buf)-1) continue;

        if (i < fmt->indentation_size) {
            fmt->indentation_size = i;
        }

    next_loop:
        lineno++;
    }

    if (fmt->indentation_size == 1000) {
        fmt->indentation_size = -1;
    }
}

static void
set_indentation_before_left_brace(FILE *fp,
                                  struct ctrump_pprint_format *fmt)
{
    char buf[1024];
    int curr_kwd_col;
    int prev_kwd_col = -1;
    int lpar_col;
    char *pcurr_kwd;
    char *plpar;

    rewind(fp);

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        pcurr_kwd = column_begin_with_forifwhileswitch(buf);
        curr_kwd_col = (pcurr_kwd == NULL) ? -1 : pcurr_kwd - buf;

        plpar = column_begin_with(buf, "{");
        lpar_col = (plpar == NULL) ? -1 : plpar - buf;

        if (lpar_col > 0 && curr_kwd_col < 0 && prev_kwd_col > 0) {
            fmt->indentation_before_left_brace = (prev_kwd_col < lpar_col) ? 1 : 0;
            return;
        }

        prev_kwd_col = curr_kwd_col;

    }
}

static void
ctrump_translation_unit2pprint_format(const struct ctrump_translation_unit *t,
                                      struct ctrump_pprint_format *fmt)
{
    int i;
    int n = t->num_decl;
    struct ctrump_extdecl *decls = t->decls;

    int lineno_decl_spec;
    int lineno_decl;
    int lineno_decl_param1;
    int lineno_decl_param2;
    int lineno_decl_rpar;
    int lineno_body_lbr;
    struct ctrump_declarator_node *nodes;
    int na;

    for (i=0; i<n; i++) {
        lineno_decl_spec   = -1;
        lineno_decl        = -1;
        lineno_decl_param1 = -1;
        lineno_decl_param2 = -1;
        lineno_decl_rpar   = -1;
        lineno_body_lbr    = -1;

        switch (decls[i].code) {
        case CTRUMP_EXT_FUNCTION_DEFINITION:
            lineno_decl_spec = decls[i].u.func_def.decl_spec.begin.lineno;
            lineno_decl      = decls[i].u.func_def.decl->nodes.u.identifier.loc.lineno;

            nodes = &decls[i].u.func_def.decl->nodes;
            if (nodes->code == CTRUMP_DECLARATOR_PARAM_TYPELIST) {
                na = nodes->u.param_typelist.num_args;
                if (na == 0) {
                    ;
                } else if (na == 1) {
                    lineno_decl_param1 =
                        nodes->u.param_typelist.args[0].decl_spec.begin.lineno;
                } else {
                    lineno_decl_param1 =
                        nodes->u.param_typelist.args[0].decl_spec.begin.lineno;
                    lineno_decl_param2 =
                        nodes->u.param_typelist.args[1].decl_spec.begin.lineno;
                }
                lineno_decl_rpar = nodes->u.param_typelist.rpar_loc.lineno;
            }
            lineno_body_lbr = decls[i].u.func_def.body.lbr_loc.lineno;
            break;

        default:
            break;
        }

        if (lineno_decl_spec > 0 && lineno_decl > 0) {
            fmt->newline_after_declspec =
                (lineno_decl_spec == lineno_decl) ? 0 : 1;
        }

        if (lineno_decl_param1 > 0 && lineno_decl_param2 > 0) {
            fmt->newline_after_decl_params =
                (lineno_decl_param1 == lineno_decl_param2) ? 0 : 1;
        }

        if (lineno_decl_rpar > 0 && lineno_body_lbr > 0) {
            fmt->newline_after_declarator =
                (lineno_decl_rpar == lineno_body_lbr) ? 0 : 1;
        }

        // for debug
        /*
        printf("- lineno_decl_spec  = %d\n", lineno_decl_spec);
        printf("- lineno_decl       = %d\n", lineno_decl);
        printf("- lineno_decl_param1= %d\n", lineno_decl_param1);
        printf("- lineno_decl_param2= %d\n", lineno_decl_param2);
        printf("- lineno_decl_rpar  = %d\n", lineno_decl_rpar);
        printf("- lineno_body_lbr   = %d\n", lineno_body_lbr);
        printf("--- newline_after_declspec   = %d\n", fmt->newline_after_declspec);
        printf("--- newline_after_decl_params= %d\n", fmt->newline_after_decl_params);
        printf("--- newline_after_declarator = %d\n", fmt->newline_after_declarator);
        */

        if (fmt->newline_after_declspec    != -1 &&
            fmt->newline_after_decl_params != -1 &&
            fmt->newline_after_declarator  != -1) {
            break;
        }
    }


    int prev_fundef = 0;
    int lineno_prev_fundef_end = -1;

    for (i=0; i<n; i++) {
        lineno_decl_spec   = -1;

        switch (decls[i].code) {
        case CTRUMP_EXT_FUNCTION_DEFINITION:
            lineno_decl_spec = decls[i].u.func_def.decl_spec.begin.lineno;

            if (prev_fundef) {
                fmt->num_blank_lines_after_func =
                    lineno_decl_spec - lineno_prev_fundef_end - 1;
                goto exit_num_blank_lines;
            }

            prev_fundef = 1;
                lineno_prev_fundef_end = decls[i].u.func_def.body.rbr_loc.lineno;
            break;

        default:
            prev_fundef = 0;
            break;
        }
    }
 exit_num_blank_lines:
    return;
}



static void
set_newline_before_left_brace(FILE *fp,
                              struct ctrump_pprint_format *fmt)
{
    char buf[1024];
    char *pcurr_kwd;
    char *pprev_kwd = NULL;
    char *plbr;

    rewind(fp);

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        pcurr_kwd = column_begin_with_forifwhileswitch(buf);
        plbr  = strstr(buf, "{");
        if (plbr != NULL) {
            if (pcurr_kwd != NULL && pcurr_kwd < plbr) {
                fmt->newline_before_left_brace = 0;
                return;
            } else if (pprev_kwd != 0) {
                fmt->newline_before_left_brace = 1;
                return;
            }
        }

        pprev_kwd = pcurr_kwd;
    }
}

static void
set_newline_after_right_brace(FILE *fp,
                              struct ctrump_pprint_format *fmt)
{
    char buf[1024];
    char *pcurr_rbr;
    char *pprev_rbr = NULL;
    char *pelse;

    rewind(fp);

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        pcurr_rbr = strstr(buf, "}");
        pelse = strstr(buf, "else");

        if (pelse != NULL) {
            if (pcurr_rbr != NULL && pcurr_rbr < pelse) {
                fmt->newline_after_right_brace = 0;
                return;
            } else if (pprev_rbr != NULL) {
                fmt->newline_after_right_brace = 1;
                return;
            }
        }

        pprev_rbr = pcurr_rbr;
    }
}

static void
set_space_before_statement_parens(FILE *fp,
                                  struct ctrump_pprint_format *fmt)
{
    char buf[1024];
    int i;
    char *pkwd;
    char *plpar;
    char *kwd [] = { "for", "if", "while", "switch" };

    rewind(fp);

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        for (i = 0; i < sizeof(kwd)/sizeof(kwd[0]); i++) {
            pkwd = column_begin_with(buf, kwd[i]);
            plpar = strstr(buf, "(");
            if (pkwd != NULL && plpar != NULL) {
                fmt->space_before_statement_parens = 
                    (plpar == pkwd + strlen(kwd[i])) ? 0 : 1;
                return;
            }
        }
    }
}

static void
set_space_before_braces(FILE *fp,
                        struct ctrump_pprint_format *fmt)
{
    char buf[1024];
    char *prpar;
    char *plbr;

    rewind(fp);

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        if (!column_begin_with_forifwhileswitch(buf)) continue;
        prpar = strstr(buf, ")");
        plbr  = strstr(buf, "{");
        if (prpar != NULL && plbr != NULL) {
            fmt->space_before_braces = (plbr == prpar+1) ? 0 : 1;
            return;
        }
    }
}

static void
set_space_before_brackets(FILE *fp,
                          struct ctrump_pprint_format *fmt)
{
    char buf[1024];
    char *plbracket;

    rewind(fp);

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        plbracket = strstr(buf, "[");
        if (plbracket != NULL) {
            fmt->space_before_brackets = (*(plbracket-1) == ' ') ? 1 : 0;
            return;
        }
    }
}

static void
set_space_after_comma(FILE *fp,
                      struct ctrump_pprint_format *fmt)
{
    char buf[1024];
    char *pcomma;

    rewind(fp);

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        pcomma = strstr(buf, ",");
        if (pcomma != NULL) {
            if (*(pcomma+1) == ' ') {
                fmt->space_after_comma = 1;
                return;
            } else if (isalnum(*(pcomma+1)) || *(pcomma+1) == '(') {
                fmt->space_after_comma = 0;
                return;
            }
        }
    }
}

static void
set_space_after_semicolon(FILE *fp,
                          struct ctrump_pprint_format *fmt)
{
    char buf[1024];
    char *psemi;

    rewind(fp);

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        if (!column_begin_with(buf, "for")) continue;

        psemi = strstr(buf, ";");
        if (psemi != NULL) {
            if (*(psemi+1) == ' ') {
                fmt->space_after_semicolon = 1;
                return;
            } else if (isalnum(*(psemi+1)) || *(psemi+1) == '(') {
                fmt->space_after_semicolon = 0;
                return;
            }
        }
    }
}

static void
set_space_after_type_cast(FILE *fp,
                          struct ctrump_pprint_format *fmt)
{
    char buf[1024];
    int i;
    char *pkwd;
    char *plpar;
    char *prpar;
    char *peq;
    char *kwd [] = { "char", "int", "long", "float", "double" };

    rewind(fp);

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        for (i = 0; i < sizeof(kwd)/sizeof(kwd[0]); i++) {
            plpar = strstr(buf, "(");
            pkwd  = strstr(buf, kwd[i]);
            prpar = strstr(buf, ")");

            if (plpar != NULL && pkwd != NULL && prpar != NULL &&
                plpar < pkwd && pkwd < prpar) {

                // skip "for (int i= ....; ; )"
                peq = strstr(plpar, "=");
                if (peq != NULL && peq < prpar) break;

                if (*(prpar+1) == ' ') {
                    fmt->space_after_type_cast = 1;
                    return;
                } else if (isalnum(*(prpar+1)) || *(prpar+1) == '(') {
                    fmt->space_after_type_cast = 0;
                    return;
                }
            }
        }
    }
}

static void
set_space_after_negation(FILE *fp,
                         struct ctrump_pprint_format *fmt)
{
    char buf[1024];
    char *pexcl;

    rewind(fp);

    while (fgets(buf, sizeof(buf), fp) != NULL) {
        pexcl = strstr(buf, "!");

        if (pexcl != NULL) {
            if (*(pexcl+1) == ' ') {
                fmt->space_after_negation = 1;
                return;
            } else if (isalnum(*(pexcl+1)) || *(pexcl+1) == '(') {
                fmt->space_after_negation = 0;
                return;
            }
        }
    }
}

static void
set_spaces_around_op(FILE *fp,
                    struct ctrump_pprint_format *fmt)
{
    char buf[1024];
    int i;
    char *pop;

    char *assign_op []     = { "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=",
                               "<<=", ">>=", ">>>=" };
    char *logical_op []    = { "&&", "||" };
    char *relational_op [] = { "==", "!=", "<", ">", "<=", ">=" };
    char *bitwise_op []    = { "|", "^" }; // ignore "&"
    char *math_op []       = { "+", "-", "/", "%" }; // ignore "*"
    char *shift_op []      = { "<<", ">>", ">>>" };

    rewind(fp);
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        for (i = 0; i < sizeof(assign_op)/sizeof(assign_op[0]); i++) {
            pop  = strstr(buf, assign_op[i]);

            if (pop != NULL) {
                if (strncmp(pop, "==", 2) == 0) break;

                if (*(pop-1) == ' ') {
                    fmt->spaces_around_assignment_op = 1;
                    goto exit_assign_op;
                } else if (isalnum(*(pop-1)) || *(pop-1) == ')') {
                    fmt->spaces_around_assignment_op = 0;
                    goto exit_assign_op;
                }
            }
        }
    }
 exit_assign_op:

    rewind(fp);
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        for (i = 0; i < sizeof(logical_op)/sizeof(logical_op[0]); i++) {
            pop  = strstr(buf, logical_op[i]);

            if (pop != NULL) {
                if (*(pop-1) == ' ') {
                    fmt->spaces_around_logical_op = 1;
                    goto exit_logical_op;
                } else if (isalnum(*(pop-1)) || *(pop-1) == ')') {
                    fmt->spaces_around_logical_op = 0;
                    goto exit_logical_op;
                }
            }
        }
    }
 exit_logical_op:

    rewind(fp);
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        for (i = 0; i < sizeof(relational_op)/sizeof(relational_op[0]); i++) {
            pop  = strstr(buf, relational_op[i]);

            if (pop != NULL) {
                if (*(pop-1) == ' ') {
                    fmt->spaces_around_relational_op = 1;
                    goto exit_relational_op;
                } else if (isalnum(*(pop-1)) || *(pop-1) == ')') {
                    fmt->spaces_around_relational_op = 0;
                    goto exit_relational_op;
                }
            }
        }
    }
 exit_relational_op:

    rewind(fp);
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        for (i = 0; i < sizeof(bitwise_op)/sizeof(bitwise_op[0]); i++) {
            pop  = strstr(buf, bitwise_op[i]);

            if (pop != NULL) {
                if (strncmp(pop, "&&", 2) == 0) break;
                if (strncmp(pop, "||", 2) == 0) break;
                if (strncmp(pop, "&=", 2) == 0) break;
                if (strncmp(pop, "|=", 2) == 0) break;
                if (strncmp(pop, "^=", 2) == 0) break;

                if (*(pop-1) == ' ') {
                    fmt->spaces_around_bitwise_op = 1;
                    goto exit_bitwise_op;
                } else if (isalnum(*(pop-1)) || *(pop-1) == ')') {
                    fmt->spaces_around_bitwise_op = 0;
                    goto exit_bitwise_op;
                }
            }
        }
    }
 exit_bitwise_op:

    rewind(fp);
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        for (i = 0; i < sizeof(math_op)/sizeof(math_op[0]); i++) {
            pop  = strstr(buf, math_op[i]);

            if (pop != NULL) {
                if (strncmp(pop, "++", 2) == 0) break;
                if (strncmp(pop, "--", 2) == 0) break;
                if (strncmp(pop, "+=", 2) == 0) break;
                if (strncmp(pop, "-=", 2) == 0) break;
                if (strncmp(pop, "/=", 2) == 0) break;
                if (strncmp(pop, "%=", 2) == 0) break;

                if (*(pop-1) == ' ') {
                    fmt->spaces_around_math_op = 1;
                    goto exit_math_op;
                } else if (isalnum(*(pop-1)) || *(pop-1) == ')') {
                    fmt->spaces_around_math_op = 0;
                    goto exit_math_op;
                }
            }
        }
    }
 exit_math_op:

    rewind(fp);
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        for (i = 0; i < sizeof(shift_op)/sizeof(shift_op[0]); i++) {
            pop  = strstr(buf, shift_op[i]);

            if (pop != NULL) {
                if (strncmp(pop, "<<=", 3) == 0) break;
                if (strncmp(pop, ">>=", 3) == 0) break;
                if (strncmp(pop, ">>>=", 4) == 0) break;

                if (*(pop-1) == ' ') {
                    fmt->spaces_around_shift_op = 1;
                    goto exit_shift_op;
                } else if (isalnum(*(pop-1)) || *(pop-1) == ')') {
                    fmt->spaces_around_shift_op = 0;
                    goto exit_shift_op;
                }
            }
        }
    }
 exit_shift_op:

    return;
}

static void
set_padding_around_parens(FILE *fp,
                          struct ctrump_pprint_format *fmt)
{
    char buf[1024];
    char *pkwd;
    char *plpar;
    char *plbr;
    char *plbracket;

    int i;
    char *prpar;
    char *peq;
    char *kwd [] = { "char", "int", "long", "float", "double" };

    rewind(fp);
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        pkwd = column_begin_with_forifwhileswitch(buf);
        if (pkwd != NULL) {
            plpar = strstr(pkwd, "(");
            if (plpar != NULL && pkwd < plpar) {
                if (*(plpar+1) == ' ') {
                    fmt->padding_around_statement_parens = 1;
                    goto exit_statement_parens;
                } else if (isalnum(*(plpar+1)) || *(plpar+1) == '(') {
                    fmt->padding_around_statement_parens = 0;
                    goto exit_statement_parens;
                }
            }
        }
    }
 exit_statement_parens:


    rewind(fp);
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        plbr = strstr(buf, "{");
        if (plbr != NULL) {
            if (*(plbr+1) == ' ') {
                fmt->padding_around_braces = 1;
                goto exit_braces;
            } else if (isalnum(*(plbr+1)) || *(plbr+1) == '(') {
                fmt->padding_around_braces = 0;
                goto exit_braces;
            }
        }
    }
 exit_braces:

    rewind(fp);
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        plbracket = strstr(buf, "[");
        if (plbracket != NULL) {
            if (*(plbracket+1) == ' ') {
                fmt->padding_around_braces = 1;
                goto exit_brackets;
            } else if (isalnum(*(plbracket+1)) || *(plbracket+1) == '(') {
                fmt->padding_around_brackets = 0;
                goto exit_brackets;
            }
        }
    }
 exit_brackets:

    rewind(fp);
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        for (i = 0; i < sizeof(kwd)/sizeof(kwd[0]); i++) {
            plpar = strstr(buf, "(");
            pkwd  = strstr(buf, kwd[i]);
            prpar = strstr(buf, ")");

            if (plpar != NULL && pkwd != NULL && prpar != NULL &&
                plpar < pkwd && pkwd < prpar) {

                // skip "for (int i= ....; ; )"
                peq = strstr(plpar, "=");
                if (peq != NULL && peq < prpar) break;

                if (*(plpar+1) == ' ') {
                    fmt->padding_around_type_cast = 1;
                    goto exit_type_cast;
                } else if (isalnum(*(prpar+1)) || *(prpar+1) == '(') {
                    fmt->padding_around_type_cast = 0;
                    goto exit_type_cast;
                }
            }
        }
    }
 exit_type_cast:

    return;
}

static void
init_pprint_format(struct ctrump_pprint_format *fmt)
{

#define INIT_LABEL(label) fmt->label = -1;

    INIT_LABEL(indentation_size);
    INIT_LABEL(num_blank_lines_after_func);
    INIT_LABEL(indentation_before_left_brace);
    INIT_LABEL(newline_after_declspec);
    INIT_LABEL(newline_after_decl_params);
    INIT_LABEL(newline_after_declarator);
    INIT_LABEL(newline_before_left_brace);
    INIT_LABEL(newline_after_right_brace);
    INIT_LABEL(space_before_statement_parens);
    INIT_LABEL(space_before_braces);
    INIT_LABEL(space_before_brackets);
    INIT_LABEL(space_after_comma);
    INIT_LABEL(space_after_semicolon);
    INIT_LABEL(space_after_type_cast);
    INIT_LABEL(space_after_negation);
    INIT_LABEL(spaces_around_assignment_op);
    INIT_LABEL(spaces_around_logical_op);
    INIT_LABEL(spaces_around_relational_op);
    INIT_LABEL(spaces_around_bitwise_op);
    INIT_LABEL(spaces_around_math_op);
    INIT_LABEL(spaces_around_shift_op);
    INIT_LABEL(padding_around_statement_parens);
    INIT_LABEL(padding_around_braces);
    INIT_LABEL(padding_around_brackets);
    INIT_LABEL(padding_around_type_cast);
}

void
ctrump_prog_file2pprint_format(char *prog_file,
                               struct ctrump_pprint_format *fmt)
{
    FILE *fp;
#ifdef _WIN32
    char prog_file_tmp[L_tmpnam];
    tmpnam(prog_file_tmp);
#else
    char prog_file_tmp[] = "tmp.prog2format.c.XXXXXX";
    mkstemp(prog_file_tmp);
#endif

    remove_comment_preprocessor(prog_file, prog_file_tmp);


    if ((fp = fopen(prog_file_tmp, "r")) == NULL) {
        fprintf(stderr, "ERROR: cannot open file \"%s\".\n", prog_file);
        exit(1);
    }

    init_pprint_format(fmt);

    set_indentation_size(fp, fmt);
    set_indentation_before_left_brace(fp, fmt);
    set_newline_before_left_brace(fp, fmt);
    set_newline_after_right_brace(fp, fmt);
    set_space_before_statement_parens(fp, fmt);
    set_space_before_braces(fp, fmt);
    set_space_before_brackets(fp, fmt);
    set_space_after_comma(fp, fmt);
    set_space_after_semicolon(fp, fmt);
    set_space_after_type_cast(fp, fmt);
    set_space_after_negation(fp, fmt);
    set_spaces_around_op(fp, fmt);
    set_padding_around_parens(fp, fmt);

    fclose(fp);

#ifdef _WIN32
    char cpp_file_tmp[L_tmpnam];
    tmpnam(cpp_file_tmp);
#else
    char cpp_file_tmp[] = "tmp.prog2format_e.c.XXXXXX";
    mkstemp(cpp_file_tmp);
#endif

    call_preprocessor(prog_file, cpp_file_tmp);

    struct ctrump_translation_unit tree;
    struct ctrump_type_env type_env;
    struct ctrump_mempool tree_pool;
    int r;
    struct ctrump_loginfo *error;
    int num_error;
    struct ctrump_parser_option parse_opt;

    ctrump_type_env_init(&type_env, 0);
    ctrump_mempool_init(&tree_pool, 1024);

    ctrump_get_default_parser_option(&parse_opt);
    r = ctrump_parse(&error, &num_error, &tree, cpp_file_tmp, prog_file_tmp,
                     &type_env, &ctrump_ppc32_abi, &parse_opt,
                     0, &tree_pool);

    // set fmt->num_blank_lines_after_func
    //     fmt->newline_after_declspec
    //     fmt->newline_after_decl_params
    //     fmt->newline_after_declarator
    ctrump_translation_unit2pprint_format(&tree, fmt);


    if (remove(prog_file_tmp) != 0) {
        fprintf(stderr, "WARNING: fail to remove temporally file \"%s\".\n",
                prog_file_tmp);
    }

    if (remove(cpp_file_tmp) != 0) {
        fprintf(stderr, "WARNING: fail to remove temporally file \"%s\".\n",
                cpp_file_tmp);
    }
}


void
ctrump_pprint_format2format_file(const struct ctrump_pprint_format *fmt,
                                 char *fname)
{
    FILE *fp;
    fp = fopen(fname, "w");

#define WRITE_VAL_FOR_LABEL(label)                    \
    if (fmt->label != -1) {                           \
        fprintf(fp, "%-40s%d\n", #label, fmt->label); \
    }

    WRITE_VAL_FOR_LABEL(indentation_size);
    WRITE_VAL_FOR_LABEL(num_blank_lines_after_func);
    WRITE_VAL_FOR_LABEL(indentation_before_left_brace);
    WRITE_VAL_FOR_LABEL(newline_after_declspec);
    WRITE_VAL_FOR_LABEL(newline_after_decl_params);
    WRITE_VAL_FOR_LABEL(newline_after_declarator);
    WRITE_VAL_FOR_LABEL(newline_before_left_brace);
    WRITE_VAL_FOR_LABEL(newline_after_right_brace);
    WRITE_VAL_FOR_LABEL(space_before_statement_parens);
    WRITE_VAL_FOR_LABEL(space_before_braces);
    WRITE_VAL_FOR_LABEL(space_before_brackets);
    WRITE_VAL_FOR_LABEL(space_after_comma);
    WRITE_VAL_FOR_LABEL(space_after_semicolon);
    WRITE_VAL_FOR_LABEL(space_after_type_cast);
    WRITE_VAL_FOR_LABEL(space_after_negation);
    WRITE_VAL_FOR_LABEL(spaces_around_assignment_op);
    WRITE_VAL_FOR_LABEL(spaces_around_logical_op);
    WRITE_VAL_FOR_LABEL(spaces_around_relational_op);
    WRITE_VAL_FOR_LABEL(spaces_around_bitwise_op);
    WRITE_VAL_FOR_LABEL(spaces_around_math_op);
    WRITE_VAL_FOR_LABEL(spaces_around_shift_op);
    WRITE_VAL_FOR_LABEL(padding_around_statement_parens);
    WRITE_VAL_FOR_LABEL(padding_around_braces);
    WRITE_VAL_FOR_LABEL(padding_around_brackets);
    WRITE_VAL_FOR_LABEL(padding_around_type_cast);

    fclose(fp);
}


void
ctrump_prog_file2format_file(char *prog_fname,
                             char *format_fname)
{
    struct ctrump_pprint_format fmt;

    ctrump_prog_file2pprint_format(prog_fname, &fmt);
    ctrump_pprint_format2format_file(&fmt, format_fname);
}

---