isl_pw_*_exploit_equalities_and_remove_if_empty: use isl_pw_*_get_domain_at

[isl.git] / interface / python.cc

/*
 * Copyright 2011,2015 Sven Verdoolaege. All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 *    1. Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 * 
 *    2. 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.
 * 
 * THIS SOFTWARE IS PROVIDED BY SVEN VERDOOLAEGE ''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 SVEN VERDOOLAEGE 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.
 * 
 * The views and conclusions contained in the software and documentation
 * are those of the authors and should not be interpreted as
 * representing official policies, either expressed or implied, of
 * Sven Verdoolaege.
 */ 

#include "isl_config.h"

#include <stdarg.h>
#include <stdio.h>

#include <algorithm>
#include <iostream>
#include <map>
#include <vector>

#include "python.h"
#include "generator.h"

/* Argument format for Python methods with a fixed number of arguments.
 */
static const char *fixed_arg_fmt = "arg%d";
/* Argument format for Python methods with a variable number of arguments.
 */
static const char *var_arg_fmt = "args[%d]";

/* Drop the "isl_" initial part of the type name "name".
 */
static string type2python(string name)
{
        return name.substr(4);
}

/* Print the arguments of a method with "n_arg" arguments, starting at "first".
 */
void python_generator::print_method_arguments(int first, int n_arg)
{
        for (int i = first; i < n_arg; ++i) {
                if (i > first)
                        printf(", ");
                printf("arg%d", i);
        }
}

/* Print the start of a definition for method "name"
 * (without specifying the arguments).
 * If "is_static" is set, then mark the python method as static.
 *
 * If the method is called "from", then rename it to "convert_from"
 * because "from" is a python keyword.
 */
static void print_method_def(bool is_static, const string &name)
{
        const char *s;

        if (is_static)
                printf("    @staticmethod\n");

        s = name.c_str();
        if (name == "from")
                s = "convert_from";

        printf("    def %s", s);
}

/* Print the header of the method "name" with "n_arg" arguments.
 * If "is_static" is set, then mark the python method as static.
 */
void python_generator::print_method_header(bool is_static, const string &name,
        int n_arg)
{
        print_method_def(is_static, name);
        printf("(");
        print_method_arguments(0, n_arg);
        printf("):\n");
}

/* Print formatted output with the given indentation.
 */
static void print_indent(int indent, const char *format, ...)
{
        va_list args;

        printf("%*s", indent, " ");
        va_start(args, format);
        vprintf(format, args);
        va_end(args);
}

/* Print a check that the argument in position "pos" is of type "type"
 * with the given indentation.
 * If this fails and if "upcast" is set, then convert the first
 * argument to "super" and call the method "name" on it, passing
 * the remaining of the "n" arguments.
 * If the check fails and "upcast" is not set, then simply raise
 * an exception.
 * If "upcast" is not set, then the "super", "name" and "n" arguments
 * to this function are ignored.
 * "fmt" is the format for printing Python method arguments.
 */
void python_generator::print_type_check(int indent, const string &type,
        const char *fmt, int pos, bool upcast, const string &super,
        const string &name, int n)
{
        print_indent(indent, "try:\n");
        print_indent(indent, "    if not ");
        printf(fmt, pos);
        printf(".__class__ is %s:\n", type.c_str());
        print_indent(indent, "        ");
        printf(fmt, pos);
        printf(" = %s(", type.c_str());
        printf(fmt, pos);
        printf(")\n");
        print_indent(indent, "except:\n");
        if (upcast) {
                print_indent(indent, "    return %s(",
                        type2python(super).c_str());
                printf(fmt, 0);
                printf(").%s(", name.c_str());
                for (int i = 1; i < n; ++i) {
                        if (i != 1)
                                printf(", ");
                        printf(fmt, i);
                }
                printf(")\n");
        } else
                print_indent(indent, "    raise\n");
}

/* For each of the "n" initial arguments of the function "method"
 * that refer to an isl structure,
 * including the object on which the method is called,
 * check if the corresponding actual argument is of the right type.
 * If not, try and convert it to the right type.
 * If that doesn't work and if "super" contains at least one element,
 * try and convert self to the type of the first superclass in "super" and
 * call the corresponding method.
 * If "first_is_ctx" is set, then the first argument is skipped.
 */
void python_generator::print_type_checks(const string &cname,
        FunctionDecl *method, bool first_is_ctx, int n,
        const vector<string> &super)
{
        for (int i = first_is_ctx; i < n; ++i) {
                ParmVarDecl *param = method->getParamDecl(i);
                string type;

                if (!is_isl_type(param->getOriginalType()))
                        continue;
                type = type2python(extract_type(param->getOriginalType()));
                if (!first_is_ctx && i > 0 && super.size() > 0)
                        print_type_check(8, type, fixed_arg_fmt,
                                        i - first_is_ctx, true,
                                        super[0], cname, n);
                else
                        print_type_check(8, type, fixed_arg_fmt,
                                        i - first_is_ctx, false, "", cname, -1);
        }
}

/* Print a call to the *_copy function corresponding to "type".
 */
void python_generator::print_copy(QualType type)
{
        string type_s = extract_type(type);

        printf("isl.%s_copy", type_s.c_str());
}

/* Construct a wrapper for callback argument "param" (at position "arg").
 * Assign the wrapper to "cb".  We assume here that a function call
 * has at most one callback argument.
 *
 * The wrapper converts the arguments of the callback to python types,
 * taking a copy if the C callback does not take its arguments.
 * If any exception is thrown, the wrapper keeps track of it in exc_info[0]
 * and returns a value indicating an error.  Otherwise the wrapper
 * returns a value indicating success.
 * In case the C callback is expected to return an isl_stat,
 * the error value is -1 and the success value is 0.
 * In case the C callback is expected to return an isl_bool,
 * the error value is -1 and the success value is 1 or 0 depending
 * on the result of the Python callback.
 * Otherwise, None is returned to indicate an error and
 * a copy of the object in case of success.
 */
void python_generator::print_callback(ParmVarDecl *param, int arg)
{
        QualType type = param->getOriginalType();
        const FunctionProtoType *fn = extract_prototype(type);
        QualType return_type = fn->getReturnType();
        unsigned n_arg = fn->getNumArgs();

        printf("        exc_info = [None]\n");
        printf("        fn = CFUNCTYPE(");
        if (is_isl_stat(return_type) || is_isl_bool(return_type))
                printf("c_int");
        else
                printf("c_void_p");
        for (unsigned i = 0; i < n_arg - 1; ++i) {
                if (!is_isl_type(fn->getArgType(i)))
                        die("Argument has non-isl type");
                printf(", c_void_p");
        }
        printf(", c_void_p)\n");
        printf("        def cb_func(");
        for (unsigned i = 0; i < n_arg; ++i) {
                if (i)
                        printf(", ");
                printf("cb_arg%d", i);
        }
        printf("):\n");
        for (unsigned i = 0; i < n_arg - 1; ++i) {
                string arg_type;
                arg_type = type2python(extract_type(fn->getArgType(i)));
                printf("            cb_arg%d = %s(ctx=arg0.ctx, ptr=",
                        i, arg_type.c_str());
                if (!callback_takes_argument(param, i))
                        print_copy(fn->getArgType(i));
                printf("(cb_arg%d))\n", i);
        }
        printf("            try:\n");
        if (is_isl_stat(return_type))
                printf("                arg%d(", arg);
        else
                printf("                res = arg%d(", arg);
        for (unsigned i = 0; i < n_arg - 1; ++i) {
                if (i)
                        printf(", ");
                printf("cb_arg%d", i);
        }
        printf(")\n");
        printf("            except BaseException as e:\n");
        printf("                exc_info[0] = e\n");
        if (is_isl_stat(return_type) || is_isl_bool(return_type))
                printf("                return -1\n");
        else
                printf("                return None\n");
        if (is_isl_stat(return_type)) {
                printf("            return 0\n");
        } else if (is_isl_bool(return_type)) {
                printf("            return 1 if res else 0\n");
        } else {
                printf("            return ");
                print_copy(return_type);
                printf("(res.ptr)\n");
        }
        printf("        cb = fn(cb_func)\n");
}

/* Print the argument at position "arg" in call to "fd".
 * "fmt" is the format for printing Python method arguments.
 * "skip" is the number of initial arguments of "fd" that are
 * skipped in the Python method.
 *
 * If the (first) argument is an isl_ctx, then print "ctx",
 * assuming that the caller has made the context available
 * in a "ctx" variable.
 * Otherwise, if the argument is a callback, then print a reference to
 * the callback wrapper "cb".
 * Otherwise, if the argument is marked as consuming a reference,
 * then pass a copy of the pointer stored in the corresponding
 * argument passed to the Python method.
 * Otherwise, if the argument is a string, then the python string is first
 * encoded as a byte sequence, using 'ascii' as encoding.  This assumes
 * that all strings passed to isl can be converted to 'ascii'.
 * Otherwise, if the argument is a pointer, then pass this pointer itself.
 * Otherwise, pass the argument directly.
 */
void python_generator::print_arg_in_call(FunctionDecl *fd, const char *fmt,
        int arg, int skip)
{
        ParmVarDecl *param = fd->getParamDecl(arg);
        QualType type = param->getOriginalType();
        if (is_isl_ctx(type)) {
                printf("ctx");
        } else if (is_callback(type)) {
                printf("cb");
        } else if (takes(param)) {
                print_copy(type);
                printf("(");
                printf(fmt, arg - skip);
                printf(".ptr)");
        } else if (is_string(type)) {
                printf(fmt, arg - skip);
                printf(".encode('ascii')");
        } else if (type->isPointerType()) {
                printf(fmt, arg - skip);
                printf(".ptr");
        } else {
                printf(fmt, arg - skip);
        }
}

/* Generate code that raises the exception captured in "exc_info", if any,
 * with the given indentation.
 */
static void print_rethrow(int indent, const char *exc_info)
{
        print_indent(indent, "if %s is not None:\n", exc_info);
        print_indent(indent, "    raise %s\n", exc_info);
}

/* Print code with the given indentation that checks
 * whether any of the persistent callbacks of "clazz"
 * is set and if it failed with an exception.  If so, the 'exc_info'
 * field contains the exception and is raised again.
 * The field is cleared because the callback and its data may get reused.
 * "fmt" is the format for printing Python method arguments.
 */
static void print_persistent_callback_failure_check(int indent,
        const isl_class &clazz, const char *fmt)
{
        const set<FunctionDecl *> &callbacks = clazz.persistent_callbacks;
        set<FunctionDecl *>::const_iterator in;

        for (in = callbacks.begin(); in != callbacks.end(); ++in) {
                string callback_name = clazz.persistent_callback_name(*in);

                print_indent(indent, "if hasattr(");
                printf(fmt, 0);
                printf(", '%s') and ", callback_name.c_str());
                printf(fmt, 0);
                printf(".%s['exc_info'] != None:\n", callback_name.c_str());
                print_indent(indent, "    exc_info = ");
                printf(fmt, 0);
                printf(".%s['exc_info'][0]\n", callback_name.c_str());
                print_indent(indent, "    ");
                printf(fmt, 0);
                printf(".%s['exc_info'][0] = None\n", callback_name.c_str());
                print_rethrow(indent + 4, "exc_info");
        }
}

/* Print the return statement of the python method corresponding
 * to the C function "method" with the given indentation.
 * If the object on which the method was called
 * may have a persistent callback, then first check if any of those failed.
 * "fmt" is the format for printing Python method arguments.
 *
 * If the method returns a new instance of the same object type and
 * if the class has any persistent callbacks, then the data
 * for these callbacks are copied from the original to the new object.
 * If the method it itself setting a persistent callback,
 * then keep track of the constructed C callback (such that it doesn't
 * get destroyed) and the data structure that holds the captured exception
 * (such that it can be raised again).
 *
 * If the return type is a (const) char *, then convert the result
 * to a Python string, raising an error on NULL and freeing
 * the C string if needed.  For python 3 compatibility, the string returned
 * by isl is explicitly decoded as an 'ascii' string.  This is correct
 * as all strings returned by isl are expected to be 'ascii'.
 *
 * If the return type is isl_stat, isl_bool or isl_size, then
 * raise an error on isl_stat_error, isl_bool_error or isl_size_error.
 * In case of isl_bool, the result is converted to
 * a Python boolean.
 * In case of isl_size, the result is converted to a Python int.
 */
void python_generator::print_method_return(int indent, const isl_class &clazz,
        FunctionDecl *method, const char *fmt)
{
        QualType return_type = method->getReturnType();

        if (!is_static(clazz, method))
                print_persistent_callback_failure_check(indent, clazz, fmt);

        if (is_isl_type(return_type)) {
                string type;

                type = type2python(extract_type(return_type));
                print_indent(indent,
                        "obj = %s(ctx=ctx, ptr=res)\n", type.c_str());
                if (is_mutator(clazz, method) &&
                    clazz.has_persistent_callbacks())
                        print_indent(indent, "obj.copy_callbacks(arg0)\n");
                if (clazz.persistent_callbacks.count(method)) {
                        string callback_name;

                        callback_name = clazz.persistent_callback_name(method);
                        print_indent(indent, "obj.%s = { 'func': cb, "
                                "'exc_info': exc_info }\n",
                                callback_name.c_str());
                }
                print_indent(indent, "return obj\n");
        } else if (is_string(return_type)) {
                print_indent(indent, "if res == 0:\n");
                print_indent(indent, "    raise\n");
                print_indent(indent, "string = "
                       "cast(res, c_char_p).value.decode('ascii')\n");

                if (gives(method))
                        print_indent(indent, "libc.free(res)\n");

                print_indent(indent, "return string\n");
        } else if (is_isl_neg_error(return_type)) {
                print_indent(indent, "if res < 0:\n");
                print_indent(indent, "    raise\n");
                if (is_isl_bool(return_type))
                        print_indent(indent, "return bool(res)\n");
                else if (is_isl_size(return_type))
                        print_indent(indent, "return int(res)\n");
        } else {
                print_indent(indent, "return res\n");
        }
}

/* Print a python "get" method corresponding to the C function "fd"
 * in class "clazz" using a name that includes the "get_" prefix.
 *
 * This method simply calls the variant without the "get_" prefix and
 * returns its result.
 * Note that static methods are not considered to be "get" methods.
 */
void python_generator::print_get_method(const isl_class &clazz,
        FunctionDecl *fd)
{
        string get_name = clazz.base_method_name(fd);
        string name = clazz.method_name(fd);
        int num_params = fd->getNumParams();

        print_method_header(false, get_name, num_params);
        printf("        return arg0.%s(", name.c_str());
        print_method_arguments(1, num_params);
        printf(")\n");
}

/* Print a call to "method", along with the corresponding
 * return statement, with the given indentation.
 * "drop_ctx" is set if the first argument is an isl_ctx.
 * "drop_user" is set if the last argument is a "user" argument
 * corresponding to a callback argument.
 *
 * A "ctx" variable is first initialized as it may be needed
 * in the first call to print_arg_in_call and in print_method_return.
 *
 * If the method has a callback function, then any exception
 * thrown in the callback also need to be rethrown.
 */
void python_generator::print_method_call(int indent, const isl_class &clazz,
        FunctionDecl *method, const char *fmt, int drop_ctx, int drop_user)
{
        string fullname = method->getName().str();
        int num_params = method->getNumParams();

        if (drop_ctx) {
                print_indent(indent, "ctx = Context.getDefaultInstance()\n");
        } else {
                print_indent(indent, "ctx = ");
                printf(fmt, 0);
                printf(".ctx\n");
        }
        print_indent(indent, "res = isl.%s(", fullname.c_str());
        for (int i = 0; i < num_params - drop_user; ++i) {
                if (i > 0)
                        printf(", ");
                print_arg_in_call(method, fmt, i, drop_ctx);
        }
        if (drop_user)
                printf(", None");
        printf(")\n");

        if (drop_user)
                print_rethrow(indent, "exc_info[0]");

        print_method_return(indent, clazz, method, fmt);
}

/* Print a python method corresponding to the C function "method".
 * "super" contains the superclasses of the class to which the method belongs,
 * with the first element corresponding to the annotation that appears
 * closest to the annotated type.  This superclass is the least
 * general extension of the annotated type in the linearization
 * of the class hierarchy.
 *
 * If the first argument of "method" is something other than an instance
 * of the class, then mark the python method as static.
 * If, moreover, this first argument is an isl_ctx, then remove
 * it from the arguments of the Python method.
 *
 * If the function has a callback argument, then it also has a "user"
 * argument.  Since Python has closures, there is no need for such
 * a user argument in the Python interface, so we simply drop it.
 * We also create a wrapper ("cb") for the callback.
 *
 * If the function consumes a reference, then we pass it a copy of
 * the actual argument.
 *
 * For methods that are identified as "get" methods, also
 * print a variant of the method using a name that includes
 * the "get_" prefix.
 */
void python_generator::print_method(const isl_class &clazz,
        FunctionDecl *method, vector<string> super)
{
        string cname = clazz.method_name(method);
        int num_params = method->getNumParams();
        int drop_user = 0;
        int drop_ctx = first_arg_is_isl_ctx(method);

        for (int i = 1; i < num_params; ++i) {
                ParmVarDecl *param = method->getParamDecl(i);
                QualType type = param->getOriginalType();
                if (is_callback(type))
                        drop_user = 1;
        }

        print_method_header(is_static(clazz, method), cname,
                            num_params - drop_ctx - drop_user);

        print_type_checks(cname, method, drop_ctx,
                            num_params - drop_user, super);
        for (int i = 1; i < num_params; ++i) {
                ParmVarDecl *param = method->getParamDecl(i);
                QualType type = param->getOriginalType();
                if (!is_callback(type))
                        continue;
                print_callback(param, i - drop_ctx);
        }
        print_method_call(8, clazz, method, fixed_arg_fmt, drop_ctx, drop_user);

        if (clazz.is_get_method(method))
                print_get_method(clazz, method);
}

/* Print a condition that checks whether Python method argument "i"
 * corresponds to the C function argument type "type".
 */
static void print_argument_check(QualType type, int i)
{
        if (generator::is_isl_type(type)) {
                string type_str;
                type_str = generator::extract_type(type);
                type_str = type2python(type_str);
                printf("args[%d].__class__ is %s", i, type_str.c_str());
        } else if (type->isPointerType()) {
                printf("type(args[%d]) == str", i);
        } else {
                printf("type(args[%d]) == int", i);
        }
}

/* Print a test that checks whether the arguments passed
 * to the Python method correspond to the arguments
 * expected by "fd".
 * "drop_ctx" is set if the first argument of "fd" is an isl_ctx,
 * which does not appear as an argument to the Python method.
 *
 * If an automatic conversion function is available for any
 * of the argument types, then also allow the argument
 * to be of the type as prescribed by the second input argument
 * of the conversion function.
 * The corresponding arguments are then converted to the expected types
 * if needed.  The argument tuple first needs to be converted to a list
 * in order to be able to modify the entries.
 */
void python_generator::print_argument_checks(const isl_class &clazz,
        FunctionDecl *fd, int drop_ctx)
{
        int num_params = fd->getNumParams();
        int first = generator::is_static(clazz, fd) ? drop_ctx : 1;
        std::vector<bool> convert(num_params);

        printf("        if len(args) == %d", num_params - drop_ctx);
        for (int i = first; i < num_params; ++i) {
                ParmVarDecl *param = fd->getParamDecl(i);
                QualType type = param->getOriginalType();
                const Type *ptr = type.getTypePtr();

                printf(" and ");
                if (conversions.count(ptr) == 0) {
                        print_argument_check(type, i - drop_ctx);
                } else {
                        QualType type2 = conversions.at(ptr)->getOriginalType();
                        convert[i] = true;
                        printf("(");
                        print_argument_check(type, i - drop_ctx);
                        printf(" or ");
                        print_argument_check(type2, i - drop_ctx);
                        printf(")");
                }
        }
        printf(":\n");

        if (std::find(convert.begin(), convert.end(), true) == convert.end())
                return;
        print_indent(12, "args = list(args)\n");
        for (int i = first; i < num_params; ++i) {
                ParmVarDecl *param = fd->getParamDecl(i);
                string type;

                if (!convert[i])
                        continue;
                type = type2python(extract_type(param->getOriginalType()));
                print_type_check(12, type, var_arg_fmt,
                                i - drop_ctx, false, "", "", -1);
        }
}

/* Print part of an overloaded python method corresponding to the C function
 * "method".
 * "drop_ctx" is set if the first argument of "method" is an isl_ctx.
 *
 * In particular, print code to test whether the arguments passed to
 * the python method correspond to the arguments expected by "method"
 * and to call "method" if they do.
 */
void python_generator::print_method_overload(const isl_class &clazz,
        FunctionDecl *method)
{
        int drop_ctx = first_arg_is_isl_ctx(method);

        print_argument_checks(clazz, method, drop_ctx);
        print_method_call(12, clazz, method, var_arg_fmt, drop_ctx, 0);
}

/* Print a python method with a name derived from "fullname"
 * corresponding to the C functions "methods".
 * "super" contains the superclasses of the class to which the method belongs.
 *
 * If "methods" consists of a single element that is not marked overloaded,
 * the use print_method to print the method.
 * Otherwise, print an overloaded method with pieces corresponding
 * to each function in "methods".
 */
void python_generator::print_method(const isl_class &clazz,
        const string &fullname, const function_set &methods,
        vector<string> super)
{
        string cname;
        function_set::const_iterator it;
        FunctionDecl *any_method;

        any_method = *methods.begin();
        if (methods.size() == 1 && !is_overload(any_method)) {
                print_method(clazz, any_method, super);
                return;
        }

        cname = clazz.method_name(any_method);

        print_method_def(is_static(clazz, any_method), cname);
        printf("(*args):\n");

        for (it = methods.begin(); it != methods.end(); ++it)
                print_method_overload(clazz, *it);
        printf("        raise Error\n");
}

/* Print a python method "name" corresponding to "fd" setting
 * the enum value "value".
 * "super" contains the superclasses of the class to which the method belongs,
 * with the first element corresponding to the annotation that appears
 * closest to the annotated type.
 *
 * The last argument of the C function does not appear in the method call,
 * but is fixed to "value" instead.
 * Other than that, the method printed here is similar to one
 * printed by python_generator::print_method, except that
 * some of the special cases do not occur.
 */
void python_generator::print_set_enum(const isl_class &clazz,
        FunctionDecl *fd, int value, const string &name,
        const vector<string> &super)
{
        string fullname = fd->getName().str();
        int num_params = fd->getNumParams();

        print_method_header(is_static(clazz, fd), name, num_params - 1);

        print_type_checks(name, fd, false, num_params - 1, super);
        printf("        ctx = arg0.ctx\n");
        printf("        res = isl.%s(", fullname.c_str());
        for (int i = 0; i < num_params - 1; ++i) {
                if (i)
                        printf(", ");
                print_arg_in_call(fd, fixed_arg_fmt, i, 0);
        }
        printf(", %d", value);
        printf(")\n");
        print_method_return(8, clazz, fd, fixed_arg_fmt);
}

/* Print python methods corresponding to "fd", which sets an enum.
 * "super" contains the superclasses of the class to which the method belongs,
 * with the first element corresponding to the annotation that appears
 * closest to the annotated type.
 *
 * A method is generated for each value in the enum, setting
 * the enum to that value.
 */
void python_generator::print_set_enum(const isl_class &clazz,
        FunctionDecl *fd, const vector<string> &super)
{
        vector<set_enum>::const_iterator it;
        const vector<set_enum> &set_enums = clazz.set_enums.at(fd);

        for (it = set_enums.begin(); it != set_enums.end(); ++it)
                print_set_enum(clazz, fd, it->value, it->method_name, super);
}

/* Print part of the constructor for this isl_class.
 *
 * In particular, check if the actual arguments correspond to the
 * formal arguments of "cons" and if so call "cons" and put the
 * result in self.ptr and a reference to the default context in self.ctx.
 */
void python_generator::print_constructor(const isl_class &clazz,
        FunctionDecl *cons)
{
        string fullname = cons->getName().str();
        string cname = clazz.method_name(cons);
        int num_params = cons->getNumParams();
        int drop_ctx = first_arg_is_isl_ctx(cons);

        print_argument_checks(clazz, cons, drop_ctx);
        printf("            self.ctx = Context.getDefaultInstance()\n");
        printf("            self.ptr = isl.%s(", fullname.c_str());
        if (drop_ctx)
                printf("self.ctx");
        for (int i = drop_ctx; i < num_params; ++i) {
                if (i)
                        printf(", ");
                print_arg_in_call(cons, var_arg_fmt, i, drop_ctx);
        }
        printf(")\n");
        printf("            return\n");
}

/* If "clazz" has a type function describing subclasses,
 * then add constructors that allow each of these subclasses
 * to be treated as an object to the superclass.
 */
void python_generator::print_upcast_constructors(const isl_class &clazz)
{
        map<int, string>::const_iterator i;

        if (!clazz.fn_type)
                return;

        for (i = clazz.type_subclasses.begin();
             i != clazz.type_subclasses.end(); ++i) {
                printf("        if len(args) == 1 and "
                                                "isinstance(args[0], %s):\n",
                         type2python(i->second).c_str());
                printf("            self.ctx = args[0].ctx\n");
                printf("            self.ptr = isl.%s_copy(args[0].ptr)\n",
                        clazz.name.c_str());
                printf("            return\n");
        }
}

/* Print the header of the class "name" with superclasses "super".
 * The order of the superclasses is the opposite of the order
 * in which the corresponding annotations appear in the source code.
 * If "clazz" is a subclass derived from a type function,
 * then the immediate superclass is recorded in "clazz" itself.
 */
void python_generator::print_class_header(const isl_class &clazz,
        const string &name, const vector<string> &super)
{
        printf("class %s", name.c_str());
        if (super.size() > 0) {
                printf("(");
                for (unsigned i = 0; i < super.size(); ++i) {
                        if (i > 0)
                                printf(", ");
                        printf("%s", type2python(super[i]).c_str());
                }
                printf(")");
        } else if (clazz.is_type_subclass()) {
                printf("(%s)", type2python(clazz.superclass_name).c_str());
        } else {
                printf("(object)");
        }
        printf(":\n");
}

/* Tell ctypes about the return type of "fd".
 * In particular, if "fd" returns a pointer to an isl object,
 * then tell ctypes it returns a "c_void_p".
 * If "fd" returns a char *, then simply tell ctypes.
 *
 * Nothing needs to be done for functions returning
 * isl_bool, isl_stat or isl_size since they are represented by an int and
 * ctypes assumes that a function returns int by default.
 */
void python_generator::print_restype(FunctionDecl *fd)
{
        string fullname = fd->getName().str();
        QualType type = fd->getReturnType();
        if (is_isl_type(type))
                printf("isl.%s.restype = c_void_p\n", fullname.c_str());
        else if (is_string(type))
                printf("isl.%s.restype = POINTER(c_char)\n", fullname.c_str());
}

/* Tell ctypes about the types of the arguments of the function "fd".
 */
void python_generator::print_argtypes(FunctionDecl *fd)
{
        string fullname = fd->getName().str();
        int n = fd->getNumParams();
        int drop_user = 0;

        printf("isl.%s.argtypes = [", fullname.c_str());
        for (int i = 0; i < n - drop_user; ++i) {
                ParmVarDecl *param = fd->getParamDecl(i);
                QualType type = param->getOriginalType();
                if (is_callback(type))
                        drop_user = 1;
                if (i)
                        printf(", ");
                if (is_isl_ctx(type))
                        printf("Context");
                else if (is_isl_type(type) || is_callback(type))
                        printf("c_void_p");
                else if (is_string(type))
                        printf("c_char_p");
                else if (is_long(type))
                        printf("c_long");
                else
                        printf("c_int");
        }
        if (drop_user)
                printf(", c_void_p");
        printf("]\n");
}

/* Print type definitions for the method 'fd'.
 */
void python_generator::print_method_type(FunctionDecl *fd)
{
        print_restype(fd);
        print_argtypes(fd);
}

/* If "clazz" has a type function describing subclasses or
 * if it is one of those type subclasses, then print a __new__ method.
 *
 * In the superclass, the __new__ method constructs an object
 * of the subclass type specified by the type function.
 * In the subclass, the __new__ method reverts to the original behavior.
 */
void python_generator::print_new(const isl_class &clazz,
        const string &python_name)
{
        if (!clazz.fn_type && !clazz.is_type_subclass())
                return;

        printf("    def __new__(cls, *args, **keywords):\n");

        if (clazz.fn_type) {
                map<int, string>::const_iterator i;

                printf("        if \"ptr\" in keywords:\n");
                printf("            type = isl.%s(keywords[\"ptr\"])\n",
                        clazz.fn_type->getNameAsString().c_str());

                for (i = clazz.type_subclasses.begin();
                     i != clazz.type_subclasses.end(); ++i) {
                        printf("            if type == %d:\n", i->first);
                        printf("                return %s(**keywords)\n",
                                type2python(i->second).c_str());
                }
                printf("            raise\n");
        }

        printf("        return super(%s, cls).__new__(cls)\n",
                python_name.c_str());
}

/* Print declarations for methods printing the class representation,
 * provided there is a corresponding *_to_str function.
 *
 * In particular, provide an implementation of __str__ and __repr__ methods to
 * override the default representation used by python. Python uses __str__ to
 * pretty print the class (e.g., when calling print(obj)) and uses __repr__
 * when printing a precise representation of an object (e.g., when dumping it
 * in the REPL console).
 *
 * Check the type of the argument before calling the *_to_str function
 * on it in case the method was called on an object from a subclass.
 *
 * The return value of the *_to_str function is decoded to a python string
 * assuming an 'ascii' encoding.  This is necessary for python 3 compatibility.
 */
void python_generator::print_representation(const isl_class &clazz,
        const string &python_name)
{
        if (!clazz.fn_to_str)
                return;

        printf("    def __str__(arg0):\n");
        print_type_check(8, python_name, fixed_arg_fmt, 0, false, "", "", -1);
        printf("        ptr = isl.%s(arg0.ptr)\n",
                string(clazz.fn_to_str->getName()).c_str());
        printf("        res = cast(ptr, c_char_p).value.decode('ascii')\n");
        printf("        libc.free(ptr)\n");
        printf("        return res\n");
        printf("    def __repr__(self):\n");
        printf("        s = str(self)\n");
        printf("        if '\"' in s:\n");
        printf("            return 'isl.%s(\"\"\"%%s\"\"\")' %% s\n",
                python_name.c_str());
        printf("        else:\n");
        printf("            return 'isl.%s(\"%%s\")' %% s\n",
                python_name.c_str());
}

/* If "clazz" has any persistent callbacks, then print the definition
 * of a "copy_callbacks" function that copies the persistent callbacks
 * from one object to another.
 */
void python_generator::print_copy_callbacks(const isl_class &clazz)
{
        const set<FunctionDecl *> &callbacks = clazz.persistent_callbacks;
        set<FunctionDecl *>::const_iterator in;

        if (!clazz.has_persistent_callbacks())
                return;

        printf("    def copy_callbacks(self, obj):\n");
        for (in = callbacks.begin(); in != callbacks.end(); ++in) {
                string callback_name = clazz.persistent_callback_name(*in);

                printf("        if hasattr(obj, '%s'):\n",
                        callback_name.c_str());
                printf("            self.%s = obj.%s\n",
                        callback_name.c_str(), callback_name.c_str());
        }
}

/* Print code to set method type signatures.
 *
 * To be able to call C functions it is necessary to explicitly set their
 * argument and result types.  Do this for all exported constructors and
 * methods (including those that set a persistent callback and
 * those that set an enum value),
 * as well as for the *_to_str and the type function, if they exist.
 * Assuming each exported class has a *_copy and a *_free method,
 * also unconditionally set the type of such methods.
 */
void python_generator::print_method_types(const isl_class &clazz)
{
        function_set::const_iterator in;
        map<string, function_set>::const_iterator it;
        map<FunctionDecl *, vector<set_enum> >::const_iterator ie;
        const set<FunctionDecl *> &callbacks = clazz.persistent_callbacks;

        for (in = clazz.constructors.begin(); in != clazz.constructors.end();
                ++in)
                print_method_type(*in);

        for (in = callbacks.begin(); in != callbacks.end(); ++in)
                print_method_type(*in);
        for (it = clazz.methods.begin(); it != clazz.methods.end(); ++it)
                for (in = it->second.begin(); in != it->second.end(); ++in)
                        print_method_type(*in);
        for (ie = clazz.set_enums.begin(); ie != clazz.set_enums.end(); ++ie)
                print_method_type(ie->first);

        print_method_type(clazz.fn_copy);
        print_method_type(clazz.fn_free);
        if (clazz.fn_to_str)
                print_method_type(clazz.fn_to_str);
        if (clazz.fn_type)
                print_method_type(clazz.fn_type);
}

/* Print out the definition of this isl_class.
 *
 * We first check if this isl_class is a subclass of one or more other classes.
 * If it is, we make sure those superclasses are printed out first.
 *
 * Then we print a constructor with several cases, one for constructing
 * a Python object from a return value, one for each function that
 * was marked as a constructor and for each type based subclass.
 *
 * Next, we print out some common methods and the methods corresponding
 * to functions that are not marked as constructors, including those
 * that set a persistent callback and those that set an enum value.
 *
 * Finally, we tell ctypes about the types of the arguments of the
 * constructor functions and the return types of those function returning
 * an isl object.
 */
void python_generator::print(const isl_class &clazz)
{
        string p_name = type2python(clazz.subclass_name);
        function_set::const_iterator in;
        map<string, function_set>::const_iterator it;
        map<FunctionDecl *, vector<set_enum> >::const_iterator ie;
        vector<string> super = find_superclasses(clazz.type);
        const set<FunctionDecl *> &callbacks = clazz.persistent_callbacks;

        for (unsigned i = 0; i < super.size(); ++i)
                if (done.find(super[i]) == done.end())
                        print(classes[super[i]]);
        if (clazz.is_type_subclass() && done.find(clazz.name) == done.end())
                print(classes[clazz.name]);
        done.insert(clazz.subclass_name);

        printf("\n");
        print_class_header(clazz, p_name, super);
        printf("    def __init__(self, *args, **keywords):\n");

        printf("        if \"ptr\" in keywords:\n");
        printf("            self.ctx = keywords[\"ctx\"]\n");
        printf("            self.ptr = keywords[\"ptr\"]\n");
        printf("            return\n");

        for (in = clazz.constructors.begin(); in != clazz.constructors.end();
                ++in)
                print_constructor(clazz, *in);
        print_upcast_constructors(clazz);
        printf("        raise Error\n");
        printf("    def __del__(self):\n");
        printf("        if hasattr(self, 'ptr'):\n");
        printf("            isl.%s_free(self.ptr)\n", clazz.name.c_str());

        print_new(clazz, p_name);
        print_representation(clazz, p_name);
        print_copy_callbacks(clazz);

        for (in = callbacks.begin(); in != callbacks.end(); ++in)
                print_method(clazz, *in, super);
        for (it = clazz.methods.begin(); it != clazz.methods.end(); ++it)
                print_method(clazz, it->first, it->second, super);
        for (ie = clazz.set_enums.begin(); ie != clazz.set_enums.end(); ++ie)
                print_set_enum(clazz, ie->first, super);

        printf("\n");

        print_method_types(clazz);
}

/* Generate a python interface based on the extracted types and
 * functions.
 *
 * Print out each class in turn.  If one of these is a subclass of some
 * other class, make sure the superclass is printed out first.
 * functions.
 */
void python_generator::generate()
{
        map<string, isl_class>::iterator ci;

        for (ci = classes.begin(); ci != classes.end(); ++ci) {
                if (done.find(ci->first) == done.end())
                        print(ci->second);
        }
}