interface/generator.cc

   1 /*
   2  * Copyright 2011,2015 Sven Verdoolaege. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  *    1. Redistributions of source code must retain the above copyright
   9  *       notice, this list of conditions and the following disclaimer.
  10  *
  11  *    2. Redistributions in binary form must reproduce the above
  12  *       copyright notice, this list of conditions and the following
  13  *       disclaimer in the documentation and/or other materials provided
  14  *       with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY SVEN VERDOOLAEGE ''AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SVEN VERDOOLAEGE OR
  20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  23  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * The views and conclusions contained in the software and documentation
  29  * are those of the authors and should not be interpreted as
  30  * representing official policies, either expressed or implied, of
  31  * Sven Verdoolaege.
  32  */
  33
  34 #include <stdio.h>
  35 #include <iostream>
  36
  37 #include <clang/AST/Attr.h>
  38
  39 #include "isl_config.h"
  40 #include "extract_interface.h"
  41 #include "generator.h"
  42
  43 /* Should "method" be considered to be a static method?
  44  * That is, is the first argument something other than
  45  * an instance of the class?
  46  */
  47 bool generator::is_static(const isl_class &clazz, FunctionDecl *method)
  48 {
  49         ParmVarDecl *param = method->getParamDecl(0);
  50         QualType type = param->getOriginalType();
  51
  52         if (!is_isl_type(type))
  53                 return true;
  54         return extract_type(type) != clazz.name;
  55 }
  56
  57 /* Find the FunctionDecl with name "name",
  58  * returning NULL if there is no such FunctionDecl.
  59  * If "required" is set, then error out if no FunctionDecl can be found.
  60  */
  61 FunctionDecl *generator::find_by_name(const string &name, bool required)
  62 {
  63         map<string, FunctionDecl *>::iterator i;
  64
  65         i = functions_by_name.find(name);
  66         if (i != functions_by_name.end())
  67                 return i->second;
  68         if (required)
  69                 die("No " + name + " function found");
  70         return NULL;
  71 }
  72
  73 /* Collect all functions that belong to a certain type, separating
  74  * constructors from regular methods and keeping track of the _to_str,
  75  * _copy and _free functions, if any, separately.  If there are any overloaded
  76  * functions, then they are grouped based on their name after removing the
  77  * argument type suffix.
  78  */
  79 generator::generator(set<RecordDecl *> &exported_types,
  80         set<FunctionDecl *> exported_functions, set<FunctionDecl *> functions)
  81 {
  82         map<string, isl_class>::iterator ci;
  83
  84         set<FunctionDecl *>::iterator in;
  85         for (in = functions.begin(); in != functions.end(); ++in) {
  86                 FunctionDecl *decl = *in;
  87                 functions_by_name[decl->getName()] = decl;
  88         }
  89
  90         set<RecordDecl *>::iterator it;
  91         for (it = exported_types.begin(); it != exported_types.end(); ++it) {
  92                 RecordDecl *decl = *it;
  93                 string name = decl->getName();
  94                 classes[name].name = name;
  95                 classes[name].type = decl;
  96                 classes[name].fn_to_str = find_by_name(name + "_to_str", false);
  97                 classes[name].fn_copy = find_by_name(name + "_copy", true);
  98                 classes[name].fn_free = find_by_name(name + "_free", true);
  99         }
 100
 101         for (in = exported_functions.begin(); in != exported_functions.end();
 102              ++in) {
 103                 isl_class *c = method2class(classes, *in);
 104                 if (!c)
 105                         continue;
 106                 if (is_constructor(*in)) {
 107                         c->constructors.insert(*in);
 108                 } else {
 109                         FunctionDecl *method = *in;
 110                         string fullname = method->getName();
 111                         fullname = drop_type_suffix(fullname, method);
 112                         c->methods[fullname].insert(method);
 113                 }
 114         }
 115 }
 116
 117 /* Print error message "msg" and abort.
 118  */
 119 void generator::die(const char *msg)
 120 {
 121         fprintf(stderr, "%s\n", msg);
 122         abort();
 123 }
 124
 125 /* Print error message "msg" and abort.
 126  */
 127 void generator::die(string msg)
 128 {
 129         die(msg.c_str());
 130 }
 131
 132 /* Return a sequence of the types of which the given type declaration is
 133  * marked as being a subtype.
 134  * The order of the types is the opposite of the order in which they
 135  * appear in the source.  In particular, the first annotation
 136  * is the one that is closest to the annotated type and the corresponding
 137  * type is then also the first that will appear in the sequence of types.
 138  */
 139 std::vector<string> generator::find_superclasses(RecordDecl *decl)
 140 {
 141         vector<string> super;
 142
 143         if (!decl->hasAttrs())
 144                 return super;
 145
 146         string sub = "isl_subclass";
 147         size_t len = sub.length();
 148         AttrVec attrs = decl->getAttrs();
 149         for (AttrVec::const_iterator i = attrs.begin(); i != attrs.end(); ++i) {
 150                 const AnnotateAttr *ann = dyn_cast<AnnotateAttr>(*i);
 151                 if (!ann)
 152                         continue;
 153                 string s = ann->getAnnotation().str();
 154                 if (s.substr(0, len) == sub) {
 155                         s = s.substr(len + 1, s.length() - len  - 2);
 156                         super.push_back(s);
 157                 }
 158         }
 159
 160         return super;
 161 }
 162
 163 /* Is decl marked as being part of an overloaded method?
 164  */
 165 bool generator::is_overload(Decl *decl)
 166 {
 167         return has_annotation(decl, "isl_overload");
 168 }
 169
 170 /* Is decl marked as a constructor?
 171  */
 172 bool generator::is_constructor(Decl *decl)
 173 {
 174         return has_annotation(decl, "isl_constructor");
 175 }
 176
 177 /* Is decl marked as consuming a reference?
 178  */
 179 bool generator::takes(Decl *decl)
 180 {
 181         return has_annotation(decl, "isl_take");
 182 }
 183
 184 /* Is decl marked as preserving a reference?
 185  */
 186 bool generator::keeps(Decl *decl)
 187 {
 188         return has_annotation(decl, "isl_keep");
 189 }
 190
 191 /* Is decl marked as returning a reference that is required to be freed.
 192  */
 193 bool generator::gives(Decl *decl)
 194 {
 195         return has_annotation(decl, "isl_give");
 196 }
 197
 198 /* Return the class that has a name that matches the initial part
 199  * of the name of function "fd" or NULL if no such class could be found.
 200  */
 201 isl_class *generator::method2class(map<string, isl_class> &classes,
 202         FunctionDecl *fd)
 203 {
 204         string best;
 205         map<string, isl_class>::iterator ci;
 206         string name = fd->getNameAsString();
 207
 208         for (ci = classes.begin(); ci != classes.end(); ++ci) {
 209                 if (name.substr(0, ci->first.length()) == ci->first)
 210                         best = ci->first;
 211         }
 212
 213         if (classes.find(best) == classes.end()) {
 214                 cerr << "Unable to find class of " << name << endl;
 215                 return NULL;
 216         }
 217
 218         return &classes[best];
 219 }
 220
 221 /* Is "type" the type "isl_ctx *"?
 222  */
 223 bool generator::is_isl_ctx(QualType type)
 224 {
 225         if (!type->isPointerType())
 226                 return 0;
 227         type = type->getPointeeType();
 228         if (type.getAsString() != "isl_ctx")
 229                 return false;
 230
 231         return true;
 232 }
 233
 234 /* Is the first argument of "fd" of type "isl_ctx *"?
 235  */
 236 bool generator::first_arg_is_isl_ctx(FunctionDecl *fd)
 237 {
 238         ParmVarDecl *param;
 239
 240         if (fd->getNumParams() < 1)
 241                 return false;
 242
 243         param = fd->getParamDecl(0);
 244         return is_isl_ctx(param->getOriginalType());
 245 }
 246
 247 /* Is "type" that of a pointer to an isl_* structure?
 248  */
 249 bool generator::is_isl_type(QualType type)
 250 {
 251         if (type->isPointerType()) {
 252                 string s;
 253
 254                 type = type->getPointeeType();
 255                 if (type->isFunctionType())
 256                         return false;
 257                 s = type.getAsString();
 258                 return s.substr(0, 4) == "isl_";
 259         }
 260
 261         return false;
 262 }
 263
 264 /* Is "type" the type isl_bool?
 265  */
 266 bool generator::is_isl_bool(QualType type)
 267 {
 268         string s;
 269
 270         if (type->isPointerType())
 271                 return false;
 272
 273         s = type.getAsString();
 274         return s == "isl_bool";
 275 }
 276
 277 /* Is "type" the type isl_stat?
 278  */
 279 bool generator::is_isl_stat(QualType type)
 280 {
 281         string s;
 282
 283         if (type->isPointerType())
 284                 return false;
 285
 286         s = type.getAsString();
 287         return s == "isl_stat";
 288 }
 289
 290
 291 /* Is "type" that of a pointer to a function?
 292  */
 293 bool generator::is_callback(QualType type)
 294 {
 295         if (!type->isPointerType())
 296                 return false;
 297         type = type->getPointeeType();
 298         return type->isFunctionType();
 299 }
 300
 301 /* Is "type" that of "char *" of "const char *"?
 302  */
 303 bool generator::is_string(QualType type)
 304 {
 305         if (type->isPointerType()) {
 306                 string s = type->getPointeeType().getAsString();
 307                 return s == "const char" || s == "char";
 308         }
 309
 310         return false;
 311 }
 312
 313 /* Return the name of the type that "type" points to.
 314  * The input "type" is assumed to be a pointer type.
 315  */
 316 string generator::extract_type(QualType type)
 317 {
 318         if (type->isPointerType())
 319                 return type->getPointeeType().getAsString();
 320         die("Cannot extract type from non-pointer type");
 321 }
 322
 323 /* If "method" is overloaded, then drop the suffix of "name"
 324  * corresponding to the type of the final argument and
 325  * return the modified name (or the original name if
 326  * no modifications were made).
 327  */
 328 string generator::drop_type_suffix(string name, FunctionDecl *method)
 329 {
 330         int num_params;
 331         ParmVarDecl *param;
 332         string type;
 333         size_t name_len, type_len;
 334
 335         if (!is_overload(method))
 336                 return name;
 337
 338         num_params = method->getNumParams();
 339         param = method->getParamDecl(num_params - 1);
 340         type = extract_type(param->getOriginalType());
 341         type = type.substr(4);
 342         name_len = name.length();
 343         type_len = type.length();
 344
 345         if (name_len > type_len && name.substr(name_len - type_len) == type)
 346                 name = name.substr(0, name_len - type_len - 1);
 347
 348         return name;
 349 }