python/ctrump/ctrumpmodule.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 "Python.h"
#include "structmember.h"
#include "ctrump/ctrump.h"

#if PY_VERSION_HEX < 0x02050000
typedef int Py_ssize_t;
typedef inquiry lenfunc;
typedef intargfunc ssizeargfunc;
#define PyIndex_Check(obj) PyInt_Check(obj)
#define PyNumber_AsSsize_t(obj, exc) PyInt_AsLong(obj)
#endif

struct EnvObject;
typedef struct abiObject {
        PyObject_HEAD
        struct ctrump_abi abi;
}abiObject ;
static PyTypeObject abiObject_Type;
static PyObject *symbol_obj(struct EnvObject *env, const struct ctrump_symbol *tobj);
static PyObject *texpr_obj(struct EnvObject *env, struct ctrump_texpr *tobj);

static void *
alloc_table(int num_entry)
{
        int table_size = sizeof(void*)*num_entry;
        void **ret;
        int i;

        ret = malloc(table_size);
        for (i=0; i<num_entry; i++) {
                ret[i] = NULL;
        }

        return ret;
}

static void
expand_table_size(int *current_size,
                  PyObject ***table,
                  int assert_size)
{
        int old_size = *current_size;
        if (assert_size >= *current_size) {
                int next_size = assert_size*2;
                int i;
                PyObject **tbl;
                tbl = *table = realloc(*table, sizeof(PyObject*)*next_size);
                *current_size = next_size;

                for (i=old_size; i<next_size; i++) {
                        tbl[i] = NULL;
                }
        }
}

static void
expand_table_size_memtbl(int *current_size,
                         PyObject ***id2tree_table,
                         PyObject ****memobj_table,
                         int assert_size)
{
        int old_size = *current_size;

        if (assert_size >= *current_size) {
                int next_size = assert_size*2;
                int i;
                PyObject ***mem_tbl;
                PyObject **tree_tbl;

                tree_tbl = *id2tree_table = realloc(*id2tree_table, sizeof(PyObject*)*next_size);
                mem_tbl = *memobj_table = realloc(*memobj_table, sizeof(PyObject**)*next_size);

                *current_size = next_size;

                for (i=old_size; i<next_size; i++) {
                        mem_tbl[i] = NULL;
                        tree_tbl[i] = NULL;
                }
        }
}


/********** symbol obj **********/
typedef struct
{
        PyObject_HEAD
        const struct ctrump_symbol *tree;
} symbolObject;

static PyObject *
symbol_str(symbolObject *obj)
{
        PyObject *res;
        res = PyString_FromStringAndSize(obj->tree->symstr, obj->tree->symlen);
        return res;
}

static PyTypeObject symbolObject_Type = {
  PyObject_HEAD_INIT (NULL) 0,  /* ob_size */
  "ctrump.symbol",      /* tp_name */
  sizeof (symbolObject),                /* tp_basicsize */
  0,                            /* tp_itemsize */
  /* methods */
  0,                            /* tp_dealloc */
  0,                            /* tp_print */
  (getattrfunc) 0, /* tp_getattr */
  0,                            /* tp_setattr */
  0,                            /* tp_compare */
  0,                            /* tp_repr */
  0,                            /* tp_as_number */
  0,                            /* tp_as_sequence */
  0,                            /* tp_as_mapping */
  0,                            /* tp_hash */
  0,                            /* tp_call */
  (reprfunc)symbol_str,                 /* tp_str */
};


/********** record field obj **********/

typedef struct
{
        PyObject_HEAD
        struct ctrump_record_type_field *tree;
        struct EnvObject *env;
} recordFieldObject;

static PyObject *
record_field_getattr(recordFieldObject *self, char *name)
{
        struct ctrump_record_type_field *tree;
        struct EnvObject *env = self->env;
        tree = self->tree;

        if (strcmp(name, "type") == 0) {
                return texpr_obj(env, tree->type);
        } else if (strcmp(name, "name") == 0) {
                return symbol_obj(env, tree->name);
        }

        PyErr_SetString(PyExc_AttributeError, name);
        return NULL;
}


static PyTypeObject recordFieldObject_Type = {
        PyObject_HEAD_INIT (NULL)
        0,      /* ob_size */
        "ctrump.recordField",           /* tp_name */
        sizeof (recordFieldObject),             /* tp_basicsize */
        0,                              /* tp_itemsize */
        /* methods */
        0,                              /* tp_dealloc */
        0,                              /* tp_print */
        (getattrfunc)record_field_getattr, /* tp_getattr */
        0,                              /* tp_setattr */
        0,                              /* tp_compare */
        0,                              /* tp_repr */
        0,                              /* tp_as_number */
        0,                              /* tp_as_sequence */
        0,                              /* tp_as_mapping */
        0,                              /* tp_hash */
        0,                              /* tp_call */
        (reprfunc)0,                    /*tp_str*/
        0,                              /*tp_getattro*/
        0,                              /*tp_setattro*/
        0,                              /*tp_as_buffer*/
        Py_TPFLAGS_DEFAULT,             /*tp_flags*/
        "CTRUMP record Field Object",   /* tp_doc */
        0,                             /* tp_traverse */
        0,                             /* tp_clear */
        0,                             /* tp_richcompare */
        0,                             /* tp_weaklistoffset */
        0,                             /* tp_iter */
        0,                             /* tp_iternext */
        0,                             /* tp_methods */
};

static PyObject *record_field_obj(struct EnvObject *env, struct ctrump_record_type_field *tree);

/********** texpr obj **********/
typedef struct
{
        PyObject_HEAD
        struct ctrump_texpr *tree;
        struct EnvObject *env;
} texprObject;

static PyObject *
texpr_getattr(texprObject *self, char *name)
{
        struct ctrump_texpr *tree;
        tree = self->tree;

        if (strcmp(name, "code") == 0) {
                return PyInt_FromLong(tree->code);
        }

        switch (tree->code) {
        case CTRUMP_TYPE_BUILTIN:
                break;

        case CTRUMP_TYPE_QUALIFIED:
                if (strcmp(name, "aligned")==0) {
                        return PyInt_FromLong(tree->u.qualified.attr.aligned);
                }
                if (strcmp(name, "qual_flags")==0) {
                        return PyInt_FromLong(tree->u.qualified.qual_flags);
                }
                if (strcmp(name, "unqualified_type")==0) {
                        return texpr_obj(self->env, tree->u.qualified.unqualified_type);
                }
                if (strcmp(name, "flags") == 0) {
                        return PyInt_FromLong(tree->u.qualified.attr.flags);
                }
                break;
        case CTRUMP_TYPE_POINTER:
                if (strcmp(name, "pointer_to") == 0) {
                        return texpr_obj(self->env, tree->u.pointer_to);
                }
                break;
        case CTRUMP_TYPE_TYPEDEF_NAME:
                if (strcmp(name, "defined_to") == 0) {
                        return texpr_obj(self->env, tree->u.typedef_name.defined_to);
                }
                if (strcmp(name, "def_name") == 0) {
                        return symbol_obj(self->env, tree->u.typedef_name.def_name);
                }
                break;
        case CTRUMP_TYPE_ARRAY:
                if (strcmp(name, "array_of") == 0) {
                        return texpr_obj(self->env, tree->u.array.array_of);
                }
                if (strcmp(name, "size") == 0) {
                        return PyInt_FromLong(tree->u.array.size);
                }
                break;

        case CTRUMP_TYPE_UNION:
        case CTRUMP_TYPE_STRUCT:
                if (strcmp(name, "name") == 0) {
                        return symbol_obj(self->env, tree->u.struct_.name);
                } else if (strcmp(name, "is_completed") == 0) {
                        return PyInt_FromLong(tree->u.struct_.is_completed);
                } else if (tree->u.struct_.is_completed) {
                        if (strcmp(name, "fields") == 0) {
                                int n = tree->u.struct_.nfield, i;
                                PyObject *a = PyList_New(n);
                                for (i=0; i<n; i++) {
                                        PyObject *f = record_field_obj(self->env, &tree->u.struct_.fields[i]);
                                        PyList_SetItem(a, i, f);
                                }
                                return a;
                        } else if (strcmp(name, "aligned")==0) {
                                return PyInt_FromLong(tree->u.struct_.attr.aligned);
                        } else if (strcmp(name, "flags")==0) {
                                return PyInt_FromLong(tree->u.struct_.attr.flags);
                        }
                }

                break;

        case CTRUMP_TYPE_VARLEN_ARRAY:
        case CTRUMP_TYPE_ENUM:
        case CTRUMP_TYPE_FUNC:
        case CTRUMP_TYPE_INCOMPLETE_ARRAY:
                break;
        }

        PyErr_SetString(PyExc_AttributeError, name);
        return NULL;
}


static PyTypeObject texprObject_Type;

static PyObject *
texpr_str(texprObject *self)
{
        PyObject *obj;
        char *buf;
        int len;

        ctrump_print_texpr_as_internal(&buf, &len, self->tree);
        obj = PyString_FromStringAndSize(buf, len);
        free(buf);

        return obj;
}

static PyTypeObject texprObject_Type = {
        PyObject_HEAD_INIT (NULL)
        0,                              /* ob_size */
        "ctrump.texpr", /* tp_name */
        sizeof (texprObject),           /* tp_basicsize */
        0,                              /* tp_itemsize */
        /* methods */
        0,                              /* tp_dealloc */
        0,                              /* tp_print */
        (getattrfunc)texpr_getattr,     /* tp_getattr */
        0,                              /* tp_setattr */
        0,                              /* tp_compare */
        0,                              /* tp_repr */
        0,                              /* tp_as_number */
        0,                              /* tp_as_sequence */
        0,                              /* tp_as_mapping */
        0,                              /* tp_hash */
        0,                              /* tp_call */
        (reprfunc)texpr_str,            /*tp_str*/
        0,                              /*tp_getattro*/
        0,                              /*tp_setattro*/
        0,                              /*tp_as_buffer*/
        Py_TPFLAGS_DEFAULT,             /*tp_flags*/
        "CTRUMP Type expr Object",      /* tp_doc */
        0,                             /* tp_traverse */
        0,                             /* tp_clear */
        0,                             /* tp_richcompare */
        0,                             /* tp_weaklistoffset */
        0,                             /* tp_iter */
        0,                             /* tp_iternext */
        0,                             /* tp_methods */
};



/********** bitmap obj **********/
typedef struct {
        PyObject_HEAD
        ctrump_bitmap_t bmp;
        int length;
} bitmapObject;

static PyObject *
bitmap_str(bitmapObject *self)
{
        PyObject *ret;
        int len = self->length;

        ret = PyString_FromStringAndSize((char*)NULL, len);
        if (ret) {
                ctrump_bitmap_t bmp = self->bmp;
                char *s = PyString_AS_STRING(ret);
                int i;
                for (i=0; i<len; i++) {
                        if (ctrump_bitmap_p(bmp, i)) {
                                s[i] = '1';
                        } else {
                                s[i] = '0';
                        }
                }
        }
        return ret;
}

static PyObject *indexerr = NULL;

static PyObject *
bitmap_item(bitmapObject *self, Py_ssize_t i)
{
        if (i < 0 || i>=self->length) {
                if (indexerr == NULL)
                        indexerr = PyString_FromString(
                                "bitmap index out of range");
                PyErr_SetObject(PyExc_IndexError, indexerr);
                return NULL;
        }

        if (ctrump_bitmap_p(self->bmp, i)) {
                Py_RETURN_TRUE;
        } else {
                Py_RETURN_FALSE;
        }
}

static Py_ssize_t
bitmap_length(bitmapObject *self)
{
        return self->length;
}

static PyObject*
bitmap_subscript(bitmapObject *self, PyObject *item)
{
        if (PyIndex_Check(item)) {
                Py_ssize_t i;
                i = PyNumber_AsSsize_t(item, PyExc_IndexError);
                if (i == -1 && PyErr_Occurred())
                        return NULL;
                return bitmap_item(self, i);
        } else {
                PyErr_SetString(PyExc_TypeError,
                                "bitmap indices must be integers");
                return NULL;
        }
}

static PyObject *
bitmap_pop(bitmapObject *self)
{
        return PyInt_FromLong(ctrump_bitmap_popcnt(self->bmp, self->length));
}

static PyMethodDef bitmap_methods[] = {
        {"__getitem__", (PyCFunction)bitmap_subscript, METH_O|METH_COEXIST},
        {"popcount", (PyCFunction)bitmap_pop, METH_NOARGS},
        {NULL, (PyCFunction)NULL, 0, NULL},
};

static PySequenceMethods bitmap_as_sequence = {
        (lenfunc)bitmap_length,
        (binaryfunc)NULL,
        NULL,
        (ssizeargfunc)bitmap_item,
};

static PyTypeObject bitmapObject_Type = {
        PyObject_HEAD_INIT (NULL)
        0,      /* ob_size */
        "ctrump.bitmap",                /* tp_name */
        sizeof (bitmapObject),          /* tp_basicsize */
        0,                              /* tp_itemsize */
                                /* methods */
        0,                              /* tp_dealloc */
        0,                              /* tp_print */
        (getattrfunc) 0,                /* tp_getattr */
        0,                              /* tp_setattr */
        0,                              /* tp_compare */
        0,                              /* tp_repr */
        0,                              /* tp_as_number */
        &bitmap_as_sequence,            /* tp_as_sequence */
        0,                              /* tp_as_mapping */
        0,                              /* tp_hash */
        0,                              /* tp_call */
        (reprfunc)bitmap_str,                   /*tp_str*/
        0,                         /*tp_getattro*/
        0,                         /*tp_setattro*/
        0,                         /*tp_as_buffer*/
        Py_TPFLAGS_DEFAULT, /*tp_flags*/
        "CTRUMP bitmap Object",            /* tp_doc */
        0,                             /* tp_traverse */
        0,                             /* tp_clear */
        0,                             /* tp_richcompare */
        0,                             /* tp_weaklistoffset */
        0,                             /* tp_iter */
        0,                             /* tp_iternext */
        bitmap_methods,         /* tp_methods */
};




/********** compilation error obj **********/
enum {
        ERROR_BUILD_CFG,
        ERROR_CFRONT_PARSE
};
typedef struct {
        PyObject_HEAD
        int error_code;
        union {
                struct ctrump_build_cfg_error build_cfg;
                struct ctrump_loginfo cfront;
        } u;
} CompilationErrorObject;

static PyObject *
error_get_error_token(CompilationErrorObject *self, PyObject *args)
{
        char *str_buf;
        int len;
        const struct ctrump_stmt *s;
        PyObject *obj;
        struct ctrump_pprint_format fmt;

        switch (self->error_code) {
        case ERROR_BUILD_CFG:
                s = self->u.build_cfg.stmt;
                fmt = ctrump_generate_pprint_format(NULL);
                ctrump_print_stmt_format(&str_buf, &len, 0, &fmt, s);
                obj = PyString_FromStringAndSize(str_buf, len);
                free(str_buf);
                return obj;

        case ERROR_CFRONT_PARSE:
                obj = PyString_FromString(self->u.cfront.tokens[0]);
                return obj;
        }

        return NULL;
}

static PyObject *
error_get_lineno(CompilationErrorObject *self)
{
        struct ctrump_location loc;
        switch (self->error_code) {

        case ERROR_CFRONT_PARSE:
                return PyInt_FromLong(self->u.cfront.line);

        case ERROR_BUILD_CFG:
                loc = ctrump_get_stmt_loc(self->u.build_cfg.stmt);
                return PyInt_FromLong(loc.lineno);
        }

        return NULL;
}

static PyObject *
error_get_reason(CompilationErrorObject *self)
{
        switch (self->error_code) {
        case ERROR_CFRONT_PARSE:
                return PyInt_FromLong(self->u.cfront.code);

        case ERROR_BUILD_CFG:
                return PyInt_FromLong(-1);
        }

        return NULL;
}

static PyObject *
error_get_path(CompilationErrorObject *self)
{
        struct ctrump_location loc;
        switch (self->error_code) {
        case ERROR_CFRONT_PARSE:
                return PyString_FromString(self->u.cfront.filename);

        case ERROR_BUILD_CFG:
                loc = ctrump_get_stmt_loc(self->u.build_cfg.stmt);
                return PyString_FromString(loc.path);
        }

        return NULL;
}

static PyObject *
error_get_message(CompilationErrorObject *self)
{
        PyObject *ret;
        char *str;
        switch (self->error_code) {
        case ERROR_CFRONT_PARSE:
                str = ctrump_get_loginfo_message(&self->u.cfront);
                ret = PyString_FromString(str);
                free(str);
                return ret;

        case ERROR_BUILD_CFG:
                return PyString_FromString("build cfg error");
        }

        return NULL;
}


static struct PyMethodDef compile_error_methods[] = {
        {"get_error_token", (PyCFunction)error_get_error_token, METH_VARARGS, NULL},
        {"lineno", (PyCFunction)error_get_lineno, METH_NOARGS, NULL},
        {"path", (PyCFunction)error_get_path, METH_NOARGS, NULL},
        {"reason", (PyCFunction)error_get_reason, METH_NOARGS, NULL},
        {"message", (PyCFunction)error_get_message, METH_NOARGS, NULL},
        {NULL,   (PyCFunction)NULL, 0, NULL}            /* sentinel */
};

static PyTypeObject CompilationErrorObject_Type = {
        PyObject_HEAD_INIT(NULL)
        0,                           /* ob_size */
        "ctrump.CompilationErrorObject", /* tp_name */
        sizeof(CompilationErrorObject), /* tp_basicsize */
        0,                          /* tp_itemsize */
        /* methods */
        0,                                  /* tp_dealloc */
        0,                                  /* tp_print */
        (getattrfunc)0,                     /* tp_getattr */
        0,                                  /* tp_setattr */
        0,                                  /* tp_compare */
        0,                                  /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                         /*tp_call*/
        0,                         /*tp_str*/
        0,                         /*tp_getattro*/
        0,                         /*tp_setattro*/
        0,                         /*tp_as_buffer*/
        Py_TPFLAGS_DEFAULT, /*tp_flags*/
        "CTRUMP Compilation Error Object", /* tp_doc */
        0,                             /* tp_traverse */
        0,                             /* tp_clear */
        0,                             /* tp_richcompare */
        0,                             /* tp_weaklistoffset */
        0,                             /* tp_iter */
        0,                             /* tp_iternext */
        compile_error_methods,         /* tp_methods */
        0,                             /* tp_members */
        0,                         /* tp_getset */
        0,                         /* tp_base */
        0,                         /* tp_dict */
        0,                         /* tp_descr_get */
        0,                         /* tp_descr_set */
        0,                         /* tp_dictoffset */
        (initproc)0,               /* tp_init */
        0,                         /* tp_alloc */
        0,                         /* tp_new */
};


static CompilationErrorObject *
build_cfg_error_New(struct ctrump_build_cfg_error *e)
{
        CompilationErrorObject *o = PyObject_New(CompilationErrorObject, &CompilationErrorObject_Type);
        if (o == NULL)
                return NULL;
        o->u.build_cfg = *e;
        o->error_code = ERROR_BUILD_CFG;
        return o;
}

static CompilationErrorObject *
cfront_parse_error_New(struct ctrump_loginfo *loginfo)
{
        CompilationErrorObject *o = PyObject_New(CompilationErrorObject, &CompilationErrorObject_Type);
        if (o == NULL)
                return NULL;
        o->u.cfront = *loginfo;
        o->error_code = ERROR_CFRONT_PARSE;

        return o;
}


/********** type env obj **********/
typedef struct {
        PyObject_HEAD
        struct ctrump_type_env type_env;
        int id2texpr_obj_table_size;
        PyObject **id2texpr_obj_table;

#define DEFINE_BUILTIN_TYPE(str_name,code,sym)  \
        texprObject *str_name;
#include "ctrump/ast/builtin-types.def"
#undef DEFINE_BUILTIN_TYPE

} TypeEnvObject;

static PyMethodDef typeenv_methods[] = {
        {NULL, (PyCFunction)NULL, 0, NULL},
};

static int
typeenv_Init(TypeEnvObject *self, struct EnvObject *env, PyObject *args, PyObject *kwds)
{
        int num_texpr;
        texprObject *type_obj;

        ctrump_type_env_init(&self->type_env, 1);

        num_texpr = self->type_env.id;

        self->id2texpr_obj_table = alloc_table(num_texpr);
        self->id2texpr_obj_table_size = num_texpr;

#define DEFINE_BUILTIN_TYPE(str_name,c,sym)                             \
        type_obj = PyObject_New(texprObject, &texprObject_Type);        \
        type_obj->tree = &ctrump_builtin_##str_name;                    \
        type_obj->env = env;                                            \
        self->id2texpr_obj_table[type_obj->tree->id] = (PyObject*)type_obj; \
        self->str_name = type_obj;

#include "ctrump/ast/builtin-types.def"
#undef DEFINE_BUILTIN_TYPE

        return 0;
}

static void
typeenv_dealloc(TypeEnvObject *o)
{
        free(o->id2texpr_obj_table);
        ctrump_type_env_destroy(&o->type_env);
        PyObject_Del(o);
}

static PyMemberDef typeenv_members[] = {
#define DEFINE_BUILTIN_TYPE(str_name,c,sym)                             \
        {#str_name, T_OBJECT, offsetof(TypeEnvObject, str_name), READONLY},
#include "ctrump/ast/builtin-types.def"
#undef DEFINE_BUILTIN_TYPE
        {0},
};


static PyTypeObject TypeEnvObject_Type = {
        PyObject_HEAD_INIT (NULL)
        0,                      /* ob_size */
        "ctrump.TypeEnv",               /* tp_name */
        sizeof (TypeEnvObject),         /* tp_basicsize */
        0,                              /* tp_itemsize */
                                /* methods */
        (destructor)typeenv_dealloc,    /* tp_dealloc */
        0,                              /* tp_print */
        (getattrfunc) 0,                /* tp_getattr */
        0,                              /* tp_setattr */
        0,                              /* tp_compare */
        0,                              /* tp_repr */
        0,                              /* tp_as_number */
        0,                              /* tp_as_sequence */
        0,                              /* tp_as_mapping */
        0,                              /* tp_hash */
        0,                              /* tp_call */
        (reprfunc)0,                    /*tp_str*/
        0,                         /*tp_getattro*/
        0,                         /*tp_setattro*/
        0,                         /*tp_as_buffer*/
        Py_TPFLAGS_DEFAULT,        /*tp_flags*/
        "CTRUMP C Types",            /* tp_doc */
        0,                             /* tp_traverse */
        0,                             /* tp_clear */
        0,                             /* tp_richcompare */
        0,                             /* tp_weaklistoffset */
        0,                             /* tp_iter */
        0,                             /* tp_iternext */
        typeenv_methods,         /* tp_methods */
        typeenv_members,         /* tp_members */
};



/********** env obj **********/
typedef struct EnvObject {
        PyObject_HEAD
        struct ctrump_mempool tree_pool;
        struct ctrump_mempool pyobj_pool;
        int num_object;
        int id2symbol_table_size;
        int id_table_size;
        PyObject **id2tree_obj_table;
        PyObject **id2symbol_table;
        PyObject ***member_obj_table;
        TypeEnvObject *type_env;
} EnvObject;

static PyTypeObject EnvObject_Type;

static int
env_Init(EnvObject *self, PyObject *args, PyObject *kwds)
{
        int num_sym;

        ctrump_mempool_init(&self->tree_pool, 1024);
        ctrump_mempool_init(&self->pyobj_pool, 1024);

        num_sym = ctrump_get_current_symbol_num();
        if (num_sym < 16)
                num_sym = 16;

        self->id2symbol_table = alloc_table(num_sym);
        self->id2symbol_table_size = num_sym;
        self->member_obj_table = alloc_table(16);
        self->id2tree_obj_table = alloc_table(16);

        self->type_env = PyObject_New(TypeEnvObject, &TypeEnvObject_Type);
        self->id_table_size = 16;
        self->num_object = 0;

        typeenv_Init(self->type_env, self, NULL, NULL);

        return 0;
}

static PyObject *
texpr_obj(EnvObject *env, struct ctrump_texpr *tobj)
{
        TypeEnvObject *tenv = env->type_env;
        PyObject **tbl;
        int id = tobj->id;
        PyObject *ret;
        texprObject *obj;

        expand_table_size(&tenv->id2texpr_obj_table_size,
                          &tenv->id2texpr_obj_table,
                          id);
        tbl = tenv->id2texpr_obj_table;
        ret = tbl[id];

        if (ret) {
                Py_INCREF(ret);
                return ret;
        }

        obj = PyObject_New(texprObject, &texprObject_Type);
        obj->tree = tobj;
        obj->env = env;

        tbl[id] = (PyObject*)obj;
        Py_INCREF(obj);

        return (PyObject*)obj;
}

static PyObject *
symbol_obj(EnvObject *env, const struct ctrump_symbol *tobj)
{
        PyObject **tbl;
        int id = tobj->id;
        PyObject *ret;
        symbolObject *obj;

        expand_table_size(&env->id2symbol_table_size,
                          &env->id2symbol_table,
                          id);
        tbl = env->id2symbol_table;

        ret = tbl[id];

        if (ret) {
                Py_INCREF(ret);
                return ret;
        }

        obj = PyObject_New(symbolObject, &symbolObject_Type);
        obj->tree = tobj;

        tbl[id] = (PyObject*)obj;
        Py_INCREF(obj);

        return (PyObject*)obj;
}

static PyObject *
member_obj(PyObject **mem_tbl, int index)
{
        PyObject *obj = mem_tbl[index];
        Py_INCREF(obj);
        return obj;
}

static PyObject *record_field_obj(struct EnvObject *env, struct ctrump_record_type_field *tree)
{
        recordFieldObject *o = PyObject_New(recordFieldObject, &recordFieldObject_Type);
        o->env = env;
        Py_INCREF(env);
        o->tree = tree;

        return (PyObject*)o;
}

/********** parse option **********/
typedef struct ParserOptionObject {
        PyObject_HEAD
        struct ctrump_parser_option tree;
} ParserOptionObject;

static PyMemberDef parserOption_members[] = {
        {"is_vector_keyword", T_INT, offsetof(ParserOptionObject, tree.is_vector_keyword), 0, "whether `vector' is keyword or not"},
        {0},
};

static int
parserOption_Init(ParserOptionObject *self, PyObject *args, PyObject *kwds)
{
        ctrump_get_default_parser_option(&self->tree);
        return 0;
}

static PyTypeObject ParserOption_Type = {
        PyObject_HEAD_INIT(NULL)
        0,                      /* ob_size */
        "ctrump.ParserOption",     /* tp_name */
        sizeof(ParserOptionObject),      /* tp_basicsize */
        0,                      /* tp_itemsize */
        /* methods */
        0,                      /* tp_dealloc */
        0,                                  /* tp_print */
        0,                                  /* tp_getattr */
        0,                                  /* tp_setattr */
        0,                                  /* tp_compare */
        0,                                  /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                         /*tp_call*/
        0,                         /*tp_str*/
        0,                         /*tp_getattro*/
        0,                         /*tp_setattro*/
        0,                         /*tp_as_buffer*/
        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
        "CTRUMP Parser Option Object",           /* tp_doc */
        0,                             /* tp_traverse */
        0,                             /* tp_clear */
        0,                             /* tp_richcompare */
        0,                             /* tp_weaklistoffset */
        0,                             /* tp_iter */
        0,                             /* tp_iternext */
        0,                   /* tp_methods */
        parserOption_members,                  /* tp_members */
        0,                         /* tp_getset */
        0,                         /* tp_base */
        0,                         /* tp_dict */
        0,                         /* tp_descr_get */
        0,                         /* tp_descr_set */
        0,                         /* tp_dictoffset */
        (initproc)parserOption_Init, /* tp_init */
        0,                         /* tp_alloc */
        0,         /* tp_new */
};

static PyObject *
fill_table_symbol(EnvObject *env, const struct ctrump_symbol *sym)
{
        return NULL;
}

static PyObject *
fill_table_texpr(EnvObject *env, const struct ctrump_texpr *sym)
{
        return NULL;
}

#include "astobj.h"

static PyObject *
cfront_parse(EnvObject *self, PyObject *args)
{
        char *fname;
        char *original_fname;
        struct ctrump_loginfo *error;
        int num_error=0;
        struct ctrump_build_cfg_error build_cfg_error;
        struct ctrump_translation_unit *unit;
        int num_tree, i, next_id, start_id;
        PyObject *ret;          /* tuple of (result-tree or None, errors) */
        PyObject *errors;       /* list of [error object] */
        PyObject *tree_obj;     /* translation-unit Object */
        PyObject *option_obj;
        ParserOptionObject *option;

        if (!PyArg_ParseTuple(args, "ssO", &fname, &original_fname, &option_obj)) /*  */
                return NULL;

        if (!PyObject_TypeCheck(option_obj, &ParserOption_Type)) {
                PyErr_SetString(PyExc_TypeError, "requires parser option");
                return NULL;
        }

        option = (ParserOptionObject*)option_obj;
        ret = PyTuple_New(2);

        unit = ctrump_mempool_alloc(&self->tree_pool, sizeof(*unit));

        start_id = self->num_object;
        next_id = ctrump_parse(&error, &num_error, unit, fname, original_fname,
                               &self->type_env->type_env, &ctrump_ppc32_abi,
                               &option->tree, start_id, &self->tree_pool);

        if (next_id < 0) {
                errors = PyList_New(num_error);

                PyTuple_SetItem(ret, 0, Py_None);
                PyTuple_SetItem(ret, 1, errors);

                for (i=0; i<num_error; i++) {
                        PyObject *o = (PyObject*)cfront_parse_error_New(&error[i]);
                        PyList_SetItem(errors, i, o);
                }

                return ret;
        }

        num_tree = next_id - start_id;
        next_id = ctrump_analyze(unit, &ctrump_ppc32_abi, &self->tree_pool, &build_cfg_error, num_tree, next_id);

        if (next_id < 0) {
                int num_all_error = num_error + 1;

                errors = PyList_New(num_all_error);

                PyTuple_SetItem(ret, 0, Py_None);
                PyTuple_SetItem(ret, 1, errors);

                for (i=0; i<num_error; i++) {
                        PyObject *o = (PyObject*)cfront_parse_error_New(&error[i]);
                        PyList_SetItem(errors, i, o);
                }

                PyList_SetItem(errors, num_error, (PyObject*)build_cfg_error_New(&build_cfg_error));
                return ret;
        }

        expand_table_size_memtbl(&self->id_table_size,
                                 &self->id2tree_obj_table,
                                 &self->member_obj_table,
                                 next_id);

        self->num_object = next_id;
        self->id_table_size = next_id;

        tree_obj = fill_table_translation_unit(self, unit);

        PyTuple_SetItem(ret, 0, tree_obj);
        errors = PyList_New(num_error);
        PyTuple_SetItem(ret, 1, errors);

        for (i=0; i<num_error; i++) {
                PyObject *o = (PyObject*)cfront_parse_error_New(&error[i]);
                PyList_SetItem(errors, i, o);
        }

        return ret;
}



static PyObject *
pprint0(PyObject *args, int print_ssa)
{
        PyObject *obj, *use_column = Py_None;
        translation_unitObject *tobj;
        char *buf;
        int len;
        int is_use_column = 0;
        struct ctrump_pprint_format fmt;

        if (!PyArg_ParseTuple(args, "O|O", 
                              &obj, &use_column))
                return NULL;
        if (!PyObject_TypeCheck(obj, &translation_unitObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "requires translation unit");
                return NULL;
        }
        tobj = (translation_unitObject*)obj;

        if (use_column == Py_True) {
                is_use_column = 1;
        }

        fmt = ctrump_generate_pprint_format(NULL);
        ctrump_print_translation_unit_format(&buf, &len, print_ssa, &fmt, tobj->tree);
        obj = PyString_FromStringAndSize(buf, len);
        free(buf);

        return obj;
}

static PyObject *
pprint(EnvObject *self, PyObject *args)
{
        return pprint0(args, 0);
}
static PyObject *
pprint_ssa(EnvObject *self, PyObject *args)
{
        return pprint0(args, 1);
}


static PyObject *
pprint_stmt(PyObject *self, PyObject *args)
{
        PyObject *obj;
        stmtObject *sobj;
        char *buf;
        int len;
        struct ctrump_pprint_format fmt;

        if (!PyArg_ParseTuple(args, "O", 
                              &obj))
                return NULL;
        if (!PyObject_TypeCheck(obj, &stmtObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "requires stmt");
                return NULL;
        }
        sobj = (stmtObject*)obj;

        fmt = ctrump_generate_pprint_format(NULL);
        ctrump_print_stmt_format(&buf, &len, 0, &fmt, sobj->tree);
        obj = PyString_FromStringAndSize(buf, len);
        free(buf);

        return obj;
}
static PyObject *
pprint_expr0(PyObject *args, int print_ssa)
{
        PyObject *obj;
        exprObject *eobj;
        char *buf;
        int len;
        struct ctrump_pprint_format fmt;

        if (!PyArg_ParseTuple(args, "O", 
                              &obj))
                return NULL;
        if (!PyObject_TypeCheck(obj, &exprObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "requires expr");
                return NULL;
        }
        eobj = (exprObject*)obj;

        fmt = ctrump_generate_pprint_format(NULL);
        ctrump_print_expr_format(&buf, &len, print_ssa, &fmt, eobj->tree);
        obj = PyString_FromStringAndSize(buf, len);
        free(buf);

        return obj;
}

static PyObject*
pprint_expr(PyObject *self, PyObject *args)
{
        return pprint_expr0(args, 0);
}
static PyObject*
pprint_ssa_expr(PyObject *self, PyObject *args)
{
        return pprint_expr0(args, 1);
}

static struct ctrump_loop_subscript *
subscript_typecheck(PyObject *o)
{
        if (PyObject_TypeCheck(o, &loop_subscriptObject_Type)) {
                return ((loop_subscriptObject*)o)->tree;
        }
        if (PyObject_TypeCheck(o, &loop_subscriptProxy_Type)) {
                return ((loop_subscriptProxyObject*)o)->tree;
        }

        return NULL;
}

static struct ctrump_loop_index *
index_typecheck(PyObject *o)
{
        if (PyObject_TypeCheck(o, &loop_indexObject_Type)) {
                return ((loop_indexObject*)o)->tree;
        }
        if (PyObject_TypeCheck(o, &loop_indexProxy_Type)) {
                return ((loop_indexProxyObject*)o)->tree;
        }

        return NULL;
}



static PyObject*
loop_subscript_hash(PyObject *self, PyObject *args)
{
        PyObject *sub;
        struct ctrump_loop_subscript *s;

        if (!PyArg_ParseTuple(args, "O", &sub))
                return NULL;

        if (!(s = subscript_typecheck(sub))) {
                PyErr_SetString(PyExc_TypeError, "requires loop_subscript");
                return NULL;
        }

        return PyInt_FromLong(ctrump_loop_subscript_hash(s));
}

static PyObject*
loop_subscript_equal(PyObject *self, PyObject *args)
{
        PyObject *sub1, *sub2;
        struct ctrump_loop_subscript *s1, *s2;
        int r;

        if (!PyArg_ParseTuple(args, "OO", &sub1, &sub2))
                return NULL;

        if (!(s1=subscript_typecheck(sub1))) {
                PyErr_SetString(PyExc_TypeError, "requires loop_subscript");
                return NULL;
        }
        if (!(s2=subscript_typecheck(sub2))) {
                PyErr_SetString(PyExc_TypeError, "requires loop_subscript");
                return NULL;
        }

        r = ctrump_loop_subscript_equal(s1, s2);

        return PyBool_FromLong(r);
}

static PyObject*
loop_index_equal(PyObject *self, PyObject *args)
{
        PyObject *sub1, *sub2;
        struct ctrump_loop_index *i1, *i2;
        int r;

        if (!PyArg_ParseTuple(args, "OO", &sub1, &sub2))
                return NULL;

        if (!(i1=index_typecheck(sub1))) {
                PyErr_SetString(PyExc_TypeError, "requires loop_index");
                return NULL;
        }
        if (!(i2=index_typecheck(sub2))) {
                PyErr_SetString(PyExc_TypeError, "requires loop_index");
                return NULL;
        }

        r = ctrump_loop_index_equal(i1, i2);

        return PyBool_FromLong(r);
}




static texprObject *
texpr_arg(PyObject *args)
{
        PyObject *obj;
        if (!PyArg_ParseTuple(args, "O", 
                              &obj))
                return NULL;
        if (!PyObject_TypeCheck(obj, &texprObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "requires texpr");
                return NULL;
        }
        return (texprObject*)obj;
}

static PyObject *
is_pointer_type(PyObject *self, PyObject *args)
{
        texprObject *tobj;

        tobj = texpr_arg(args);
        if (!tobj)
                return NULL;

        if (ctrump_texpr_is_pointer(tobj->tree)) {
                Py_RETURN_TRUE;
        } else {
                Py_RETURN_FALSE;
        }
}

static PyObject *
type_apply_unary_pointer_conversion(PyObject *self, PyObject *args)
{
        texprObject *tobj;
        EnvObject *env;
        struct ctrump_texpr *pointer_type;
        struct ctrump_type_env *tenv;

        tobj = texpr_arg(args);
        if (!tobj)
                return NULL;

        env = tobj->env;
        tenv = &env->type_env->type_env;

        pointer_type = ctrump_texpr_apply_unary_pointer_conversion(tenv, tobj->tree);

        if (pointer_type) {
                return texpr_obj(env, pointer_type);
        } else {
                Py_RETURN_NONE;
        }
}


static PyObject *
fold_const(PyObject *self, PyObject *args)
{
        PyObject *arg_obj;
        exprObject *expr_obj;
        int is_const;
        int val;

        if (!PyArg_ParseTuple(args, "O",
                              &arg_obj))
                return NULL;

        if (! PyObject_TypeCheck(arg_obj, &exprObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "requries expr");
                return NULL;
        }

        expr_obj = (exprObject*)arg_obj;
        val = ctrump_ast_fold_const_sint(expr_obj->tree, &is_const);

        if (is_const) {
                return PyInt_FromLong(val);
        } else {
                Py_RETURN_NONE;
        }
}



static PyObject *
calc_type_size(PyObject *self, PyObject *args)
{
        PyObject *tobj;
        PyObject *abi_obj;
        size_t sz;
        size_t align;
        int r;

        if (!PyArg_ParseTuple(args, "OO", 
                              &abi_obj, &tobj))
                return NULL;
        if (!PyObject_TypeCheck(tobj, &texprObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "requires texpr");
                return NULL;
        }
        if (!PyObject_TypeCheck(abi_obj, &abiObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "requires abi");
                return NULL;
        }

        r = ctrump_texpr_size(&sz, &align,
                              &((abiObject*)abi_obj)->abi, 
                              ((texprObject*)tobj)->tree);

        if (r < 0) {
                PyErr_SetString(PyExc_TypeError, "unknown size");
                return NULL;
        }

        return PyInt_FromLong(sz);
}

static PyObject *
struct_field_offset(PyObject *self, PyObject *args)
{
        PyObject *tobj;
        PyObject *abi_obj;
        PyObject *sym_obj;
        int r;
        struct ctrump_texpr *record_type;

        if (!PyArg_ParseTuple(args, "OOO", 
                              &abi_obj, &tobj, &sym_obj))
                return NULL;
        if (!PyObject_TypeCheck(tobj, &texprObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "requires texpr");
                return NULL;
        }
        if (!PyObject_TypeCheck(abi_obj, &abiObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "requires abi");
                return NULL;
        }
        if (!PyObject_TypeCheck(sym_obj, &symbolObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "requires symbol");
                return NULL;
        }

        record_type = ((texprObject*)tobj)->tree;
        record_type = ctrump_get_unqualified_type(record_type);
        if (record_type->code == CTRUMP_TYPE_UNION) {
                return PyInt_FromLong(0);
        }

        record_type = ctrump_retrieve_typedef_name(record_type);

        if (record_type->code != CTRUMP_TYPE_STRUCT) {
                PyErr_SetString(PyExc_TypeError, "requires struct type");
                return NULL;
        }

        r = ctrump_struct_field_offset(&record_type->u.struct_,
                                       ((symbolObject*)sym_obj)->tree,
                                       &((abiObject*)abi_obj)->abi);

        if (r < 0) {
                PyErr_SetString(PyExc_TypeError, "unknown size");
                return NULL;
        }

        return PyInt_FromLong(r);
}




static PyObject *
retrieve_pointer_type(PyObject *self, PyObject *args)
{
        texprObject *tobj;
        struct ctrump_texpr *t;

        tobj = texpr_arg(args);
        if (!tobj)
                return NULL;

        t = ctrump_retrieve_pointer_type(tobj->tree);

        if (!t) {
                PyErr_SetString(PyExc_TypeError, "require pointer type");
                return NULL;
        }

        return texpr_obj(tobj->env, t);
}

static PyObject *
retrieve_address_type(PyObject *self, PyObject *args)
{
        texprObject *tobj;
        struct ctrump_texpr *t;

        tobj = texpr_arg(args);
        if (!tobj)
                return NULL;

        t = ctrump_retrieve_address_type(tobj->tree);

        if (!t) {
                PyErr_SetString(PyExc_TypeError, "require pointer or array type");
                return NULL;
        }

        return texpr_obj(tobj->env, t);
}


static void
EnvObject_dealloc(EnvObject *o)
{
        ctrump_mempool_destroy(&o->tree_pool);
        ctrump_mempool_destroy(&o->pyobj_pool);

        free(o->id2symbol_table);
        free(o->member_obj_table);
        free(o->id2tree_obj_table);

        Py_DECREF(o->type_env);

        PyObject_Del(o);
}

#define NELEM(a) (sizeof(a)/sizeof(a[0]))

static PyObject *
expr_prec(PyObject *self, PyObject *args)
{
        int val;
        if (!PyArg_ParseTuple(args, "i", &val))
                return NULL;

        if (val > CTRUMP_EXPR_EMPTY) {
                PyErr_SetString(PyExc_IndexError, "expr code error");
                return NULL;
        }

        return PyInt_FromLong(ctrump_expr_prec_table[val]);
}

static PyObject *
get_stmt_loc(PyObject *self, PyObject *args)
{
        PyObject *stmt_obj;
        PyObject *ret, *path, *lineno;
        struct ctrump_stmt *stmt;
        struct ctrump_location loc;

        if (!PyArg_ParseTuple(args, "O", &stmt_obj))
                return NULL;

        if (PyObject_TypeCheck(stmt_obj, &stmtObject_Type)) {
                stmt = ((stmtObject*)stmt_obj)->tree;
        } else if (PyObject_TypeCheck(stmt_obj, &stmtProxy_Type)) {
                stmt = ((stmtProxyObject*)stmt_obj)->tree;
        } else {
                PyErr_SetString(PyExc_TypeError, "require stmt");
                return NULL;
        }

        ret = PyTuple_New(2);
        loc = ctrump_get_stmt_loc(stmt);

        if (loc.path) {
                path = PyString_FromString(loc.path);
        } else {
                path = PyString_FromString("<unknown>");
        }
        lineno = PyInt_FromLong(loc.lineno);

        PyTuple_SetItem(ret, 0, path);
        PyTuple_SetItem(ret, 1, lineno);

        return ret;
}


static PyMethodDef env_methods[] = {
        {"parse", (PyCFunction)cfront_parse, METH_VARARGS},
        {"cfront_parse", (PyCFunction)cfront_parse, METH_VARARGS},
        {NULL,   (PyCFunction)NULL, 0, NULL}            /* sentinel */
};

static PyMemberDef env_members[] = {
        {"type_env", T_OBJECT, offsetof(EnvObject, type_env), READONLY},
        {0},
};

static PyTypeObject EnvObject_Type = {
        PyObject_HEAD_INIT(NULL)
        0,                      /* ob_size */
        "ctrump.EnvObject",     /* tp_name */
        sizeof(EnvObject),      /* tp_basicsize */
        0,                      /* tp_itemsize */
        /* methods */
        (destructor)EnvObject_dealloc,      /* tp_dealloc */
        0,                                  /* tp_print */
        0,                                  /* tp_getattr */
        0,                                  /* tp_setattr */
        0,                                  /* tp_compare */
        0,                                  /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                         /*tp_call*/
        0,                         /*tp_str*/
        0,                         /*tp_getattro*/
        0,                         /*tp_setattro*/
        0,                         /*tp_as_buffer*/
        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
        "CTRUMP Env Object",           /* tp_doc */
        0,                             /* tp_traverse */
        0,                             /* tp_clear */
        0,                             /* tp_richcompare */
        0,                             /* tp_weaklistoffset */
        0,                             /* tp_iter */
        0,                             /* tp_iternext */
        env_methods,                   /* tp_methods */
        env_members,                   /* tp_members */
        0,                         /* tp_getset */
        0,                         /* tp_base */
        0,                         /* tp_dict */
        0,                         /* tp_descr_get */
        0,                         /* tp_descr_set */
        0,                         /* tp_dictoffset */
        (initproc)env_Init,        /* tp_init */
        0,                         /* tp_alloc */
        0,         /* tp_new */
};

#define EnvObject_Check(v) ((v)->ob_type == &EnvObject_Type)


/********** builder obj **********/

typedef struct {
        PyObject_HEAD
        EnvObject *env;
} BuilderObject ;

#include "build-ast.h"

static void
BuilderObject_dealloc(BuilderObject *self)
{
        Py_XDECREF(self->env);
        PyObject_DEL(self);
}

static int
builder_Init(BuilderObject *self, PyObject *args)
{
        PyObject *arg_obj;
        EnvObject *env_obj;
        if (!PyArg_ParseTuple(args, "O", 
                              &arg_obj))
                return -1;

        if (!PyObject_TypeCheck(arg_obj, &EnvObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "requires env");
                return -1;
        }

        env_obj = (EnvObject*)arg_obj;
        self->env = env_obj;

        Py_INCREF(self->env);

        return 0;
}

static PyObject *
build_symbol(BuilderObject *self, PyObject *args)
{
        char *sym_buf;
        int sym_len;
        const struct ctrump_symbol *sym;
        EnvObject *env = self->env;

        if (!PyArg_ParseTuple(args, "t#", &sym_buf, &sym_len))
                return NULL;

        sym = ctrump_intern(sym_buf, sym_len);
        return symbol_obj(env, sym);
}

static PyObject *
build_struct(BuilderObject *self, PyObject *args)
{
        EnvObject *env = self->env;
        PyObject *name_obj, *decls_vec_obj;
        int i, n;
        int code;
        struct ctrump_texpr *record_type;
        struct ctrump_struct_decl *decls;
        struct ctrump_type_env *tenv = &env->type_env->type_env;
        struct ctrump_location loc;
        struct ctrump_gccext_attribute attr;
        const struct ctrump_symbol *name;

        if (!PyArg_ParseTuple(args, "OOiii", &name_obj, &decls_vec_obj, &code, &attr.flags, &attr.aligned))
                return NULL;

        if (!PyList_Check(decls_vec_obj)) {
                PyErr_SetString(PyExc_TypeError, "decls should be list.");
                return NULL;
        }

        if (code != CTRUMP_TYPE_UNION &&
            code != CTRUMP_TYPE_STRUCT &&
            code != CTRUMP_TYPE_ENUM) {
                PyErr_SetString(PyExc_TypeError, "texpr code should be struct.");
                return NULL;
        }

        if (name_obj == Py_None) {
                name = NULL;
        } else if (PyObject_TypeCheck(name_obj, &symbolObject_Type)) {
                name = ((symbolObject*)name_obj)->tree;
        } else {
                PyErr_SetString(PyExc_TypeError, "name requires symbol.");
                return NULL;
        }

        LOCATION_GENERATED(loc);

        n = PyList_Size(decls_vec_obj);
        record_type = ctrump_get_incomplete_struct_type(tenv, code, name);
        decls = ctrump_mempool_alloc(&env->tree_pool, sizeof(*decls)*n);

        for (i=0; i<n; i++) {
                PyObject *o = PyList_GetItem(decls_vec_obj, i);
                struct ctrump_struct_decl *decl;

                if (!PyObject_TypeCheck(o, &struct_declObject_Type)) {
                        PyErr_SetString(PyExc_TypeError, "decls should be list of struct_decl");
                        return NULL;
                }

                decl = ((struct_declObject*)o)->tree;
                decls[i] = *decl;
        }

        ctrump_env_handle_record_decls(&record_type->u.struct_, tenv, decls,
                                       n, n, &attr, &loc, &env->tree_pool);

        return texpr_obj(env, record_type);
}

static PyObject *
build_incomplete_field_type(BuilderObject *self,
                            PyObject *args)
{
        EnvObject *env = self->env;
        int code;
        struct ctrump_location loc;
        struct ctrump_texpr *texpr;
        const struct ctrump_symbol *sym;
        PyObject *name_obj;

        if (!PyArg_ParseTuple(args, "iO", &code, &name_obj)) {
                return NULL;
        }

        if ((code != CTRUMP_TYPE_STRUCT) &&
            (code != CTRUMP_TYPE_UNION) &&
            (code != CTRUMP_TYPE_ENUM)) {
                PyErr_SetString(PyExc_TypeError, "texpr code should be struct.");
                return NULL;
        }

        if (name_obj == Py_None) {
                sym = NULL;
        } else if (PyObject_TypeCheck(name_obj, &symbolObject_Type)) {
                sym = ((symbolObject*)name_obj)->tree;
        } else {
                PyErr_SetString(PyExc_TypeError, "name requires symbol type object.");
                return NULL;
        }

        LOCATION_GENERATED(loc);

        texpr = ctrump_get_incomplete_struct_type(&env->type_env->type_env, code, sym);

        return texpr_obj(env, texpr);
}

static PyObject *
build_typedef_name(BuilderObject *self,
                   PyObject *args)
{
        EnvObject *env = self->env;
        PyObject *sym, *texpr;
        struct ctrump_texpr *new_tree;

        if (!PyArg_ParseTuple(args, "OO", &texpr, &sym)) {
                return NULL;
        }

        if (!PyObject_TypeCheck(sym, &symbolObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "not symbol object");
                return NULL;
        }
        if (!PyObject_TypeCheck(texpr, &texprObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "not texpr object");
                return NULL;
        }

        new_tree = ctrump_get_typedef_name(&env->type_env->type_env,
                                           ((texprObject*)texpr)->tree,
                                           ((symbolObject*)sym)->tree);

        return texpr_obj(env, new_tree);
}

static PyObject *
build_func_type(BuilderObject *self,
                PyObject *args)
{
        PyObject *arg_types_obj, *ret_type_obj, *arg_type_obj;
        texprObject *ret_type, *arg_type;
        int has_unspec_arg;
        int i, n;
        struct ctrump_get_functype_iterator iter;
        EnvObject *env = self->env;
        struct ctrump_type_env *type_env;
        struct ctrump_texpr *func_type;

        if (!PyArg_ParseTuple(args, "OOi", &ret_type_obj, &arg_types_obj, &has_unspec_arg)) {
                return NULL;
        }

        if (!PyList_Check(arg_types_obj)) {
                PyErr_SetString(PyExc_TypeError, "require types.");
                return NULL;
        }
        if (!PyObject_TypeCheck(ret_type_obj, &texprObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "return type is not texpr.");
                return NULL;
        }

        ret_type = (texprObject*)ret_type_obj;

        type_env = &env->type_env->type_env;
        n = PyList_Size(arg_types_obj);

        ctrump_get_functype_begin(&iter, type_env, ret_type->tree, n);
        for (i=0; i<n; i++) {
                arg_type_obj = PyList_GetItem(arg_types_obj, i);
                if (!PyObject_TypeCheck(arg_type_obj, &texprObject_Type)) {
                        PyErr_SetString(PyExc_TypeError, "arg type is not texpr.");
                        ctrump_get_functype_cancel(&iter);
                        return NULL;
                }
                arg_type = (texprObject*)arg_type_obj;
                ctrump_get_functype_next(type_env, &iter, arg_type->tree);
        }

        func_type = ctrump_get_functype_end(type_env, &iter, has_unspec_arg);

        return texpr_obj(env, func_type);
}

static PyObject *
build_array_type(BuilderObject *self,
                 PyObject *args)
{
        PyObject *array_of_obj;
        int size;
        struct ctrump_texpr *array_of, *array_type;
        struct ctrump_type_env *type_env = &self->env->type_env->type_env;
        if (!PyArg_ParseTuple(args, "Oi", &array_of_obj, &size)) {
                return NULL;
        }

        if (!PyObject_TypeCheck(array_of_obj, &texprObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "element type is not texpr.");
                return NULL;
        }

        array_of = ((texprObject*)array_of_obj)->tree;
        array_type = ctrump_get_array_type(type_env, array_of, size);

        return texpr_obj(self->env, array_type);
}

static PyObject *
build_pointer_type(BuilderObject *self,
                   PyObject *args)
{
        PyObject *pointer_to_obj;
        struct ctrump_texpr *pointer_type, *pointer_to_type;
        struct ctrump_type_env *type_env = &self->env->type_env->type_env;
        if (!PyArg_ParseTuple(args, "O", &pointer_to_obj)) {
                return NULL;
        }

        if (!PyObject_TypeCheck(pointer_to_obj, &texprObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "`pointer to' is not texpr.");
                return NULL;
        }

        pointer_to_type = ((texprObject*)pointer_to_obj)->tree;
        pointer_type = ctrump_get_pointer_type(type_env, pointer_to_type);

        return texpr_obj(self->env, pointer_type);
}

static PyObject *
build_qualified_type(BuilderObject *self,
                     PyObject *args)
{
        PyObject *type_obj;
        struct ctrump_texpr *t, *qt;
        struct ctrump_gccext_attribute attr;
        int flags;
        attr.aligned = CTRUMP_ALIGN_UNSPECIFIED;
        attr.flags = 0;
        if (!PyArg_ParseTuple(args, "Oi|ii", &type_obj, &flags, &attr.aligned, &attr.flags)) {
                return NULL;
        }

        if (!PyObject_TypeCheck(type_obj, &texprObject_Type)) {
                PyErr_SetString(PyExc_TypeError, "qualified type is not texpr.");
                return NULL;
        }

        t = ((texprObject*)type_obj)->tree;
        qt = ctrump_get_qualified_attr_type(&self->env->type_env->type_env, t, flags, &attr);

        return texpr_obj(self->env, qt);
}

static PyMethodDef builder_methods[] = {
        {"symbol", (PyCFunction)build_symbol, METH_VARARGS, NULL},
        {"decls_to_struct_texpr", (PyCFunction)build_struct, METH_VARARGS, NULL},
        {"incomplete_struct", (PyCFunction)build_incomplete_field_type,METH_VARARGS, NULL},
        {"array_type", (PyCFunction)build_array_type, METH_VARARGS, NULL},
        {"typedef_name", (PyCFunction)build_typedef_name, METH_VARARGS, NULL},
        {"func_type", (PyCFunction)build_func_type, METH_VARARGS, NULL},
        {"pointer_type", (PyCFunction)build_pointer_type, METH_VARARGS, NULL},
        {"qualified_type", (PyCFunction)build_qualified_type, METH_VARARGS, NULL},
        BUILDER_METHOD_TABLE
        {NULL, NULL, 0, NULL}
};

static PyTypeObject BuilderObject_Type = {
        PyObject_HEAD_INIT(NULL)
        0,                      /* ob_size */
        "ctrump.BuilderObject", /* tp_name */
        sizeof(BuilderObject),  /* tp_basicsize */
        0,                      /* tp_itemsize */
        /* methods */
        (destructor)BuilderObject_dealloc,      /* tp_dealloc */
        0,                                  /* tp_print */
        0,                                  /* tp_getattr */
        0,                                  /* tp_setattr */
        0,                                  /* tp_compare */
        0,                                  /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                         /*tp_call*/
        0,                         /*tp_str*/
        0,                         /*tp_getattro*/
        0,                         /*tp_setattro*/
        0,                         /*tp_as_buffer*/
        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
        "CTRUMP C AST Builder",                   /* tp_doc */
        0,                             /* tp_traverse */
        0,                             /* tp_clear */
        0,                             /* tp_richcompare */
        0,                             /* tp_weaklistoffset */
        0,                             /* tp_iter */
        0,                             /* tp_iternext */
        builder_methods,                   /* tp_methods */
        0,                             /* tp_members */
        0,                         /* tp_getset */
        0,                         /* tp_base */
        0,                         /* tp_dict */
        0,                         /* tp_descr_get */
        0,                         /* tp_descr_set */
        0,                         /* tp_dictoffset */
        (initproc)builder_Init,        /* tp_init */
        0,                         /* tp_alloc */
        0,                         /* tp_new */
};


#define TranslationUnitObject_Check(v) ((v)->ob_type == &translation_unit_Type)
#define CompilationErrorObject_Check(v) ((v)->ob_type == &CompilationErrorObject_Type)

static struct PyMethodDef ctrump_methods[] = {
        {"pprint", (PyCFunction)pprint, METH_VARARGS},
        {"pprint_ssa", (PyCFunction)pprint_ssa, METH_VARARGS},
        {"pprint_expr", (PyCFunction)pprint_expr, METH_VARARGS},
        {"pprint_ssa_expr", (PyCFunction)pprint_ssa_expr, METH_VARARGS},
        {"pprint_stmt", (PyCFunction)pprint_stmt, METH_VARARGS},
        {"fold_const", (PyCFunction)fold_const, METH_VARARGS},
        {"expr_prec", (PyCFunction)expr_prec, METH_VARARGS},
        {"is_pointer_type", (PyCFunction)is_pointer_type, METH_VARARGS},
        {"type_apply_unary_pointer_conversion", (PyCFunction)type_apply_unary_pointer_conversion, METH_VARARGS},
        {"calc_type_size", (PyCFunction)calc_type_size, METH_VARARGS},
        {"get_stmt_loc", (PyCFunction)get_stmt_loc, METH_VARARGS},
        {"retrieve_pointer_type", (PyCFunction)retrieve_pointer_type, METH_VARARGS},
        {"retrieve_address_type", (PyCFunction)retrieve_address_type, METH_VARARGS},
        {"struct_field_offset", (PyCFunction)struct_field_offset, METH_VARARGS},
        {"loop_index_equal", (PyCFunction)loop_index_equal, METH_VARARGS},
        {"loop_subscript_equal", (PyCFunction)loop_subscript_equal, METH_VARARGS},
        {"loop_subscript_hash", (PyCFunction)loop_subscript_hash, METH_VARARGS},
        {NULL,   (PyCFunction)NULL, 0, NULL}            /* sentinel */
};

PyDoc_STRVAR(module_doc,
             "Python interface for ctrump.");

static PyMemberDef abi_members[] = {
        {"sizeof_pointer", T_INT, offsetof(abiObject, abi.sizeof_pointer), READONLY},
        {"sizeof_long", T_INT, offsetof(abiObject, abi.sizeof_long), READONLY},
        {"sizeof_int", T_INT, offsetof(abiObject, abi.sizeof_int), READONLY},
        {"sizeof_short", T_INT, offsetof(abiObject, abi.sizeof_short), READONLY},
        {"sizeof_bool", T_INT, offsetof(abiObject, abi.sizeof_bool), READONLY},
        {"sizeof_longlong", T_INT, offsetof(abiObject, abi.sizeof_longlong), READONLY},
        {"sizeof_float", T_INT, offsetof(abiObject, abi.sizeof_float), READONLY},
        {"sizeof_double", T_INT, offsetof(abiObject, abi.sizeof_double), READONLY},
        {"sizeof_long_double", T_INT, offsetof(abiObject, abi.sizeof_long_double), READONLY},
        {"sizeof_enum", T_INT, offsetof(abiObject, abi.sizeof_enum), READONLY},
        {"sizeof_vector", T_INT, offsetof(abiObject, abi.sizeof_vector), READONLY},

        {"alignof_pointer", T_INT, offsetof(abiObject,abi.alignof_pointer), READONLY},
        {"alignof_long", T_INT, offsetof(abiObject,abi.alignof_long), READONLY},
        {"alignof_int", T_INT, offsetof(abiObject,abi.alignof_int), READONLY},
        {"alignof_short", T_INT, offsetof(abiObject,abi.alignof_short), READONLY},
        {"alignof_bool", T_INT, offsetof(abiObject,abi.alignof_bool), READONLY},
        {"alignof_longlong", T_INT, offsetof(abiObject,abi.alignof_longlong), READONLY},
        {"alignof_float", T_INT, offsetof(abiObject,abi.alignof_float), READONLY},
        {"alignof_double", T_INT, offsetof(abiObject,abi.alignof_double), READONLY},
        {"alignof_long_double", T_INT, offsetof(abiObject,abi.alignof_long_double), READONLY},
        {"alignof_enum", T_INT, offsetof(abiObject,abi.alignof_enum), READONLY},
        {"alignof_vector", T_INT, offsetof(abiObject,abi.alignof_vector), READONLY},

        {"is_char_signed", T_INT, offsetof(abiObject, abi.is_char_signed), READONLY},
        {0},
};

static PyTypeObject abiObject_Type = {
        PyObject_HEAD_INIT(NULL)
        0,
        "ctrump.abi",
        sizeof(abiObject),
        0,
        /* methods */
        (destructor)NULL,                                 /* tp_dealloc */
        0,                                        /* tp_print */
        0,                                        /* tp_getattr */
        0,                                        /* tp_setattr */
        0,                                        /* tp_compare */
        0,                                        /* tp_repr */
        0,                                        /* tp_as_number */
        0,                                        /* tp_as_sequence */
        0,                                        /* tp_as_mapping */
        0,                                        /* tp_hash */
        0,                                        /*tp_call*/
        0,                                        /*tp_str*/
        0,                                        /*tp_getattro*/
        0,                                        /*tp_setattro*/
        0,                                        /*tp_as_buffer*/
        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
        "CTRUMP ABI Object",           /* tp_doc */
        0,                             /* tp_traverse */
        0,                             /* tp_clear */
        0,                             /* tp_richcompare */
        0,                             /* tp_weaklistoffset */
        0,                             /* tp_iter */
        0,                             /* tp_iternext */
        0,                             /* tp_methods */
        abi_members,                   /* tp_members */
};

struct ctrump_abi_register_node {
        const char *name;
        const struct ctrump_abi *abi;
};
static struct ctrump_abi_register_node abis[] = {
        {"spu_abi", &ctrump_spu_abi},
        {"ppc32_abi", &ctrump_ppc32_abi},
        {"ppc64_abi", &ctrump_ppc64_abi}
};

static void
register_abis(PyObject *dict)
{
        abiObject *obj;
        int n = sizeof(abis)/sizeof(abis[0]);
        int i;

        for (i=0; i<n; i++) {
                struct ctrump_abi_register_node *node = &abis[i];
                obj = PyObject_New(abiObject, &abiObject_Type);
                obj->abi = *(node->abi);
                PyDict_SetItemString(dict, node->name, 
                                     (PyObject*)obj);
        }
}


CTRUMP_EXTDEF PyMODINIT_FUNC
init_ctrump(void)
{
        PyObject *m, *d, *constant_arr;
        PyTypeObject *t;

        EnvObject_Type.tp_new = PyType_GenericNew;
        BuilderObject_Type.tp_new = PyType_GenericNew;
        ParserOption_Type.tp_new = PyType_GenericNew;

        ctrump_init_all();
        t = &EnvObject_Type;

        if (PyType_Ready(t) < 0)
                return;
        if (PyType_Ready(&CompilationErrorObject_Type) < 0)
                return;
        if (PyType_Ready(&bitmapObject_Type) < 0)
                return;
        if (PyType_Ready(&BuilderObject_Type) < 0)
                return;
        if (PyType_Ready(&TypeEnvObject_Type) < 0)
                return;
        if (PyType_Ready(&texprObject_Type) < 0)
                return;
        if (PyType_Ready(&symbolObject_Type) < 0)
                return;
        if (PyType_Ready(&recordFieldObject_Type) < 0)
                return;
        if (PyType_Ready(&ParserOption_Type) < 0)
                return;
        if (PyType_Ready(&abiObject_Type) < 0)
                return;


        /* Create the module and add the functions */
        m = Py_InitModule3("_ctrump",
                           ctrump_methods,
                           module_doc);
        if (m == NULL)
                return;

        if (astobj_init() < 0)
                return;

        d = PyModule_GetDict(m);

        /* Add some symbolic constants to the module */

        Py_INCREF(t);
        if (PyDict_SetItemString(d, "EnvType", 
                                 (PyObject*)t) != 0)
                return;
        Py_INCREF(&CompilationErrorObject_Type);
        if (PyDict_SetItemString(d, "CompilationErrorType",
                                 (PyObject*)&CompilationErrorObject_Type) != 0)
                return;
        Py_INCREF(&BuilderObject_Type);
        if (PyDict_SetItemString(d, "BuilderType", 
                                 (PyObject*)&BuilderObject_Type) != 0)
                return;
        Py_INCREF(&texprObject_Type);
        if (PyDict_SetItemString(d, "texprType",
                                 (PyObject*)&texprObject_Type) != 0)
                return;
        Py_INCREF(&symbolObject_Type);
        if (PyDict_SetItemString(d, "symbolType",
                                 (PyObject*)&symbolObject_Type) != 0)
                return;
        Py_INCREF(&ParserOption_Type);
        if (PyDict_SetItemString(d, "ParserOptionType",
                                 (PyObject*)&ParserOption_Type) != 0)
                return;

        register_abis(d);

        PyModule_AddStringConstant(m, "builtin_optimizer_dir", BUILTIN_OPTIMIZER_DIR);
        PyModule_AddStringConstant(m, "target_include_dir", TARGET_INCLUDE_DIR);
        PyModule_AddStringConstant(m, "cpp_comapt_macros_path", CPP_COMPAT_MACROS_H);
        PyModule_AddStringConstant(m, "version", CTRUMP_VERSION);

#include "constants.h"

        /* Check for errors */
        if (PyErr_Occurred())
                Py_FatalError("can't initialize module ctrump");
}
/*
 * Local Variables:
 * mode: C
 * c-file-style : "python"
 * End:
 */

---