summaryrefslogtreecommitdiffstats
path: root/polly/lib/External/isl/interface/python.cc
diff options
context:
space:
mode:
Diffstat (limited to 'polly/lib/External/isl/interface/python.cc')
-rw-r--r--polly/lib/External/isl/interface/python.cc520
1 files changed, 0 insertions, 520 deletions
diff --git a/polly/lib/External/isl/interface/python.cc b/polly/lib/External/isl/interface/python.cc
deleted file mode 100644
index 0b4c0e28e86..00000000000
--- a/polly/lib/External/isl/interface/python.cc
+++ /dev/null
@@ -1,520 +0,0 @@
-/*
- * Copyright 2011 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 <stdio.h>
-#include <iostream>
-#include <map>
-#include <clang/AST/Attr.h>
-#include "extract_interface.h"
-#include "python.h"
-
-/* Is the given type declaration marked as being a subtype of some other
- * type? If so, return that other type in "super".
- */
-static bool is_subclass(RecordDecl *decl, string &super)
-{
- if (!decl->hasAttrs())
- return false;
-
- string sub = "isl_subclass";
- size_t len = sub.length();
- AttrVec attrs = decl->getAttrs();
- for (AttrVec::const_iterator i = attrs.begin() ; i != attrs.end(); ++i) {
- const AnnotateAttr *ann = dyn_cast<AnnotateAttr>(*i);
- if (!ann)
- continue;
- string s = ann->getAnnotation().str();
- if (s.substr(0, len) == sub) {
- super = s.substr(len + 1, s.length() - len - 2);
- return true;
- }
- }
-
- return false;
-}
-
-/* Is decl marked as a constructor?
- */
-static bool is_constructor(Decl *decl)
-{
- return has_annotation(decl, "isl_constructor");
-}
-
-/* Is decl marked as consuming a reference?
- */
-static bool takes(Decl *decl)
-{
- return has_annotation(decl, "isl_take");
-}
-
-/* isl_class collects all constructors and methods for an isl "class".
- * "name" is the name of the class.
- * "type" is the declaration that introduces the type.
- */
-struct isl_class {
- string name;
- RecordDecl *type;
- set<FunctionDecl *> constructors;
- set<FunctionDecl *> methods;
-
- void print(map<string, isl_class> &classes, set<string> &done);
- void print_constructor(FunctionDecl *method);
- void print_method(FunctionDecl *method, bool subclass, string super);
-};
-
-/* Return the class that has a name that matches the initial part
- * of the namd of function "fd".
- */
-static isl_class &method2class(map<string, isl_class> &classes,
- FunctionDecl *fd)
-{
- string best;
- map<string, isl_class>::iterator ci;
- string name = fd->getNameAsString();
-
- for (ci = classes.begin(); ci != classes.end(); ++ci) {
- if (name.substr(0, ci->first.length()) == ci->first)
- best = ci->first;
- }
-
- return classes[best];
-}
-
-/* Is "type" the type "isl_ctx *"?
- */
-static bool is_isl_ctx(QualType type)
-{
- if (!type->isPointerType())
- return 0;
- type = type->getPointeeType();
- if (type.getAsString() != "isl_ctx")
- return false;
-
- return true;
-}
-
-/* Is the first argument of "fd" of type "isl_ctx *"?
- */
-static bool first_arg_is_isl_ctx(FunctionDecl *fd)
-{
- ParmVarDecl *param;
-
- if (fd->getNumParams() < 1)
- return false;
-
- param = fd->getParamDecl(0);
- return is_isl_ctx(param->getOriginalType());
-}
-
-/* Is "type" that of a pointer to an isl_* structure?
- */
-static bool is_isl_type(QualType type)
-{
- if (type->isPointerType()) {
- string s = type->getPointeeType().getAsString();
- return s.substr(0, 4) == "isl_";
- }
-
- return false;
-}
-
-/* Is "type" that of a pointer to a function?
- */
-static bool is_callback(QualType type)
-{
- if (!type->isPointerType())
- return false;
- type = type->getPointeeType();
- return type->isFunctionType();
-}
-
-/* Is "type" that of "char *" of "const char *"?
- */
-static bool is_string(QualType type)
-{
- if (type->isPointerType()) {
- string s = type->getPointeeType().getAsString();
- return s == "const char" || s == "char";
- }
-
- return false;
-}
-
-/* Return the name of the type that "type" points to.
- * The input "type" is assumed to be a pointer type.
- */
-static string extract_type(QualType type)
-{
- if (type->isPointerType())
- return type->getPointeeType().getAsString();
- assert(0);
-}
-
-/* Drop the "isl_" initial part of the type name "name".
- */
-static string type2python(string name)
-{
- return name.substr(4);
-}
-
-/* Construct a wrapper for a callback argument (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.
- * If any exception is thrown, the wrapper keeps track of it in exc_info[0]
- * and returns -1. Otherwise the wrapper returns 0.
- */
-static void print_callback(QualType type, int arg)
-{
- const FunctionProtoType *fn = type->getAs<FunctionProtoType>();
- unsigned n_arg = fn->getNumArgs();
-
- printf(" exc_info = [None]\n");
- printf(" fn = CFUNCTYPE(c_int");
- for (int i = 0; i < n_arg - 1; ++i) {
- QualType arg_type = fn->getArgType(i);
- assert(is_isl_type(arg_type));
- printf(", c_void_p");
- }
- printf(", c_void_p)\n");
- printf(" def cb_func(");
- for (int i = 0; i < n_arg; ++i) {
- if (i)
- printf(", ");
- printf("cb_arg%d", i);
- }
- printf("):\n");
- for (int 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=cb_arg%d)\n", i, arg_type.c_str(), i);
- }
- printf(" try:\n");
- printf(" arg%d(", arg);
- for (int i = 0; i < n_arg - 1; ++i) {
- if (i)
- printf(", ");
- printf("cb_arg%d", i);
- }
- printf(")\n");
- printf(" except:\n");
- printf(" import sys\n");
- printf(" exc_info[0] = sys.exc_info()\n");
- printf(" return -1\n");
- printf(" return 0\n");
- printf(" cb = fn(cb_func)\n");
-}
-
-/* Print a python method corresponding to the C function "method".
- * "subclass" is set if the method belongs to a class that is a subclass
- * of some other class ("super").
- *
- * 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.
- *
- * For each argument of the function that refers to an isl structure,
- * including the object on which the method is called,
- * we check if the corresponding actual argument is of the right type.
- * If not, we try to convert it to the right type.
- * It that doesn't work and if subclass is set, we try to convert self
- * to the type of the superclass and call the corresponding method.
- *
- * If the function consumes a reference, then we pass it a copy of
- * the actual argument.
- */
-void isl_class::print_method(FunctionDecl *method, bool subclass, string super)
-{
- string fullname = method->getName();
- string cname = fullname.substr(name.length() + 1);
- int num_params = method->getNumParams();
- int drop_user = 0;
-
- for (int i = 1; i < num_params; ++i) {
- ParmVarDecl *param = method->getParamDecl(i);
- QualType type = param->getOriginalType();
- if (is_callback(type))
- drop_user = 1;
- }
-
- printf(" def %s(arg0", cname.c_str());
- for (int i = 1; i < num_params - drop_user; ++i)
- printf(", arg%d", i);
- printf("):\n");
-
- for (int i = 0; i < num_params; ++i) {
- ParmVarDecl *param = method->getParamDecl(i);
- string type;
- if (!is_isl_type(param->getOriginalType()))
- continue;
- type = type2python(extract_type(param->getOriginalType()));
- printf(" try:\n");
- printf(" if not arg%d.__class__ is %s:\n",
- i, type.c_str());
- printf(" arg%d = %s(arg%d)\n",
- i, type.c_str(), i);
- printf(" except:\n");
- if (i > 0 && subclass) {
- printf(" return %s(arg0).%s(",
- type2python(super).c_str(), cname.c_str());
- for (int i = 1; i < num_params - drop_user; ++i) {
- if (i != 1)
- printf(", ");
- printf("arg%d", i);
- }
- printf(")\n");
- } else
- printf(" raise\n");
- }
- for (int i = 1; i < num_params; ++i) {
- ParmVarDecl *param = method->getParamDecl(i);
- QualType type = param->getOriginalType();
- if (!is_callback(type))
- continue;
- print_callback(type->getPointeeType(), i);
- }
- printf(" res = isl.%s(", fullname.c_str());
- if (takes(method->getParamDecl(0)))
- printf("isl.%s_copy(arg0.ptr)", name.c_str());
- else
- printf("arg0.ptr");
- for (int i = 1; i < num_params - drop_user; ++i) {
- ParmVarDecl *param = method->getParamDecl(i);
- QualType type = param->getOriginalType();
- if (is_callback(type))
- printf(", cb");
- else if (takes(param)) {
- string type_s = extract_type(type);
- printf(", isl.%s_copy(arg%d.ptr)", type_s.c_str(), i);
- } else
- printf(", arg%d.ptr", i);
- }
- if (drop_user)
- printf(", None");
- printf(")\n");
-
- if (is_isl_type(method->getReturnType())) {
- string type;
- type = type2python(extract_type(method->getReturnType()));
- printf(" return %s(ctx=arg0.ctx, ptr=res)\n",
- type.c_str());
- } else {
- if (drop_user) {
- printf(" if exc_info[0] != None:\n");
- printf(" raise exc_info[0][0], "
- "exc_info[0][1], exc_info[0][2]\n");
- }
- printf(" return res\n");
- }
-}
-
-/* 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.
- *
- * If the function consumes a reference, then we pass it a copy of
- * the actual argument.
- */
-void isl_class::print_constructor(FunctionDecl *cons)
-{
- string fullname = cons->getName();
- string cname = fullname.substr(name.length() + 1);
- int num_params = cons->getNumParams();
- int drop_ctx = first_arg_is_isl_ctx(cons);
-
- printf(" if len(args) == %d", num_params - drop_ctx);
- for (int i = drop_ctx; i < num_params; ++i) {
- ParmVarDecl *param = cons->getParamDecl(i);
- if (is_isl_type(param->getOriginalType())) {
- string type;
- type = extract_type(param->getOriginalType());
- type = type2python(type);
- printf(" and args[%d].__class__ is %s",
- i - drop_ctx, type.c_str());
- } else
- printf(" and type(args[%d]) == str", i - drop_ctx);
- }
- printf(":\n");
- 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) {
- ParmVarDecl *param = cons->getParamDecl(i);
- if (i)
- printf(", ");
- if (is_isl_type(param->getOriginalType())) {
- if (takes(param)) {
- string type;
- type = extract_type(param->getOriginalType());
- printf("isl.%s_copy(args[%d].ptr)",
- type.c_str(), i - drop_ctx);
- } else
- printf("args[%d].ptr", i - drop_ctx);
- } else
- printf("args[%d]", i - drop_ctx);
- }
- printf(")\n");
- printf(" return\n");
-}
-
-/* Print out the definition of this isl_class.
- *
- * We first check if this isl_class is a subclass of some other class.
- * If it is, we make sure the superclass is printed out first.
- *
- * Then we print a constructor with several cases, one for constructing
- * a Python object from a return value and one for each function that
- * was marked as a constructor.
- *
- * Next, we print out some common methods and the methods corresponding
- * to functions that are not marked as constructors.
- *
- * 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 isl_class::print(map<string, isl_class> &classes, set<string> &done)
-{
- string super;
- string p_name = type2python(name);
- set<FunctionDecl *>::iterator in;
- bool subclass = is_subclass(type, super);
-
- if (subclass && done.find(super) == done.end())
- classes[super].print(classes, done);
- done.insert(name);
-
- printf("\n");
- printf("class %s", p_name.c_str());
- if (subclass)
- printf("(%s)", type2python(super).c_str());
- printf(":\n");
- 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 = constructors.begin(); in != constructors.end(); ++in)
- print_constructor(*in);
- printf(" raise Error\n");
- printf(" def __del__(self):\n");
- printf(" if hasattr(self, 'ptr'):\n");
- printf(" isl.%s_free(self.ptr)\n", name.c_str());
- printf(" def __str__(self):\n");
- printf(" ptr = isl.%s_to_str(self.ptr)\n", name.c_str());
- printf(" res = str(cast(ptr, c_char_p).value)\n");
- printf(" libc.free(ptr)\n");
- printf(" return res\n");
- printf(" def __repr__(self):\n");
- printf(" return 'isl.%s(\"%%s\")' %% str(self)\n",
- p_name.c_str());
-
- for (in = methods.begin(); in != methods.end(); ++in)
- print_method(*in, subclass, super);
-
- printf("\n");
- for (in = constructors.begin(); in != constructors.end(); ++in) {
- string fullname = (*in)->getName();
- printf("isl.%s.restype = c_void_p\n", fullname.c_str());
- printf("isl.%s.argtypes = [", fullname.c_str());
- for (int i = 0; i < (*in)->getNumParams(); ++i) {
- ParmVarDecl *param = (*in)->getParamDecl(i);
- QualType type = param->getOriginalType();
- if (i)
- printf(", ");
- if (is_isl_ctx(type))
- printf("Context");
- else if (is_isl_type(type))
- printf("c_void_p");
- else if (is_string(type))
- printf("c_char_p");
- else
- printf("c_int");
- }
- printf("]\n");
- }
- for (in = methods.begin(); in != methods.end(); ++in) {
- string fullname = (*in)->getName();
- if (is_isl_type((*in)->getReturnType()))
- printf("isl.%s.restype = c_void_p\n", fullname.c_str());
- }
- printf("isl.%s_free.argtypes = [c_void_p]\n", name.c_str());
- printf("isl.%s_to_str.argtypes = [c_void_p]\n", name.c_str());
- printf("isl.%s_to_str.restype = POINTER(c_char)\n", name.c_str());
-}
-
-/* Generate a python interface based on the extracted types and functions.
- * We first collect all functions that belong to a certain type,
- * separating constructors from regular methods.
- *
- * Then we print out each class in turn. If one of these is a subclass
- * of some other class, it will make sure the superclass is printed out first.
- */
-void generate_python(set<RecordDecl *> &types, set<FunctionDecl *> functions)
-{
- map<string, isl_class> classes;
- map<string, isl_class>::iterator ci;
- set<string> done;
-
- set<RecordDecl *>::iterator it;
- for (it = types.begin(); it != types.end(); ++it) {
- RecordDecl *decl = *it;
- string name = decl->getName();
- classes[name].name = name;
- classes[name].type = decl;
- }
-
- set<FunctionDecl *>::iterator in;
- for (in = functions.begin(); in != functions.end(); ++in) {
- isl_class &c = method2class(classes, *in);
- if (is_constructor(*in))
- c.constructors.insert(*in);
- else
- c.methods.insert(*in);
- }
-
- for (ci = classes.begin(); ci != classes.end(); ++ci) {
- if (done.find(ci->first) == done.end())
- ci->second.print(classes, done);
- }
-}
OpenPOWER on IntegriCloud