Custom type wrapper

Add support of custem type wrappers :
- add a hook function to allow declation of the custom wrappers
- add a configuration parameter to provide a list of types whose wrappers
  should not be generated and assumed to be provided by code added to
  the generated one.

Misc.: Graph.cpp code has been instrumented with extra debug messages
than can be activated by changing in the code the value of a  constant.

Author: grasph

src/CodeTree.cpp

@@ -315,6 +315,15 @@ std::ostream&
 CodeTree::generate_cxx_for_type(std::ostream& o,
                                 const TypeRcd& t){
 
+  //wrapper implemeted by the user
+  if(is_custom_type_wrapper(t.type_name)){
+    if(verbose > 1){
+      std::cerr << "Info. Wrapper for type " << t.type_name
+                << " is configured as custom. Wrapper code generation skipped.\n";
+    }
+    return o;
+  }
+
   //if true, fake type used to hold global functions
   bool notype = t.type_name.size() == 0;
 
@@ -595,6 +604,8 @@ CodeTree::generate_cxx(){
   o << "#include \"dbg_msg.h\"\n";
   o << "#include \"Wrapper.h\"\n";
 
+  o << "\nvoid end_hook(jlcxx::Module& jlModule) __attribute__((weak));\n";
+  
   std::vector<std::string> wrappers;
 
   //File stream to write type wrapper,
@@ -700,6 +711,8 @@ CodeTree::generate_cxx(){
 
   indent(o, 1) << "for(const auto& w: wrappers) w->add_methods();\n";
 
+  indent(o, 1) << "\nif(end_hook) end_hook(jlModule);\n";
+  
   o << "\n}\n";
   o.close();
   otimerstore.settimestamp();
@@ -2844,30 +2857,6 @@ void CodeTree::preprocess(){
       }//next paramType
     }//next iCombi
 
-
-    //Add user defined dependencies
-    for(const auto& dep: class_order_constraints_){
-      auto it1 = std::find_if(types_.begin(), types_.end(),
-                              [dep](const auto& x){ return x.type_name == dep.first;});
-      auto it2 = std::find_if(types_.begin(), types_.end(),
-                              [dep](const auto& x){ return x.type_name == dep.second;});
-
-      if(it1 != types_.end() && it2 != types_.end()){
-        type_dependencies_.preceeds(it1 - types_.begin(), it2 - types_.begin());
-        if(verbose > 1) std::cerr << "Dependency \"" << dep.second << " requires " << dep.first
-                                << "\" added.\n";
-      } else{
-        if(verbose>0){
-          std::cerr << "Warning: class dependency "
-                    << dep.first << " < " << dep.second
-                    << " not used.";
-          if(it1 == types_.end()) std::cerr << " No " << dep.first << " class.";
-          if(it2 == types_.end()) std::cerr << " No " << dep.second << " class.";
-          std::cerr << "\n";
-        }
-      }
-    }
-
 #ifdef DEFINE_TEMPLATE_METHODS_IN_CTOR
     //Add dependencies of templated classes to the type of their methods
     //argument and return value.
@@ -2904,6 +2893,32 @@ void CodeTree::preprocess(){
   } //next iChild
 #endif
 
+  //Add user defined dependencies
+  for(const auto& dep: class_order_constraints_){
+    auto it1 = std::find_if(types_.begin(), types_.end(),
+                            [dep](const auto& x){ return x.type_name == dep.first;});
+    auto it2 = std::find_if(types_.begin(), types_.end(),
+                            [dep](const auto& x){ return x.type_name == dep.second;});
+
+    if(it1 != types_.end() && it2 != types_.end()){
+      type_dependencies_.preceeds(it1 - types_.begin(), it2 - types_.begin());
+      if(verbose > 1) std::cerr << "Dependency \"" << dep.second
+                                << "( node " <<  (it2 - types_.begin()) << ")"
+                                << " requires " << dep.first
+                                << "( node " <<  (it1 - types_.begin()) << ")"
+                                << "\" added.\n";
+    } else{
+      if(verbose>0){
+          std::cerr << "Warning: class dependency "
+                    << dep.first << " < " << dep.second
+                    << " not used.";
+          if(it1 == types_.end()) std::cerr << " No " << dep.first << " class.";
+          if(it2 == types_.end()) std::cerr << " No " << dep.second << " class.";
+          std::cerr << "\n";
+      }
+    }
+  }
+  
   if(verbose > 2){
     std::cerr << "\nType list at end of preprocess:\n";
     for(const auto& t: types_){
@@ -2918,8 +2933,10 @@ void CodeTree::preprocess(){
 
   if(verbose > 2){
     std::cerr << "\nType list at end of preprocess after reordering:\n";
+    size_t j = 0;
     for(const auto i: types_sorted_indices_){
-      std::cerr << types_[i].type_name << "\n";
+      std::cerr << std::setw(4) << ++j << ". " << types_[i].type_name
+                << " (" << i << ")\n";
     }
     std::cerr << "\n";
   }
@@ -3160,21 +3177,61 @@ CodeTree::check_veto_list_for_var_or_field(const CXCursor& cursor, bool global_v
   }
 }
 
+
+//FIXME: duplicate for template class
+//strategy to adopt. add an extra_cursors vector to TypeRcd to keep tracks
+//of duplicate and select the cursor with the largest number of visited elements.
+//as main cursor.
 int
 CodeTree::add_type(const CXCursor& cursor, bool check){
   const int not_found =  -1;
   int index = not_found;
+  bool spelling_duplicate = false;
+  CXCursor dup_cursor;
   if(check){
     int i = 0;
     for(const auto& t: types_){
       if(clang_equalCursors(t.cursor, cursor)){
         index = i;
         break;
       }
+      if(str(clang_getCursorSpelling(t.cursor)) == str(clang_getCursorSpelling(cursor))){
+        spelling_duplicate = true;
+        dup_cursor = t.cursor;
+      }
       ++i;
     }
   }
   if(index == not_found){
+    if(verbose > 0 && spelling_duplicate){
+      std::cerr << "Error. Duplicate definition of "
+                << clang_getCursorSpelling(cursor)
+                << " in the type list. This can lead to "
+                << "improper wrapper definition order\n"
+                << "first location: " << clang_getCursorLocation(dup_cursor)
+                << "\n\tcursor kind: " << clang_getCursorKind(dup_cursor) << "\n"
+                << "\n\tdeclaraion: " << (clang_isDeclaration(dup_cursor.kind) ? "yes" : "no") << "\n"
+                << "\n\tFQN: " << fully_qualified_name(dup_cursor) << "\n"
+                << "secon location: " << clang_getCursorLocation(cursor)
+                << "\n\tcursor kind: " << clang_getCursorKind(cursor) << "\n"
+                << "\n\tdeclaraion: " << (clang_isDeclaration(cursor.kind) ? "yes" : "no") << "\n"
+                << "\n\tFQN: " << fully_qualified_name(cursor) << "\n"
+                << "\n";
+
+      std::cerr << "First cursor contents:\n";
+      clang_visitChildren(dup_cursor, [](CXCursor cursor, CXCursor, CXClientData data){
+        std::cerr << cursor << "(" << clang_getCursorKind(cursor) << ")\n";
+        return CXChildVisit_Recurse;
+      }, nullptr);
+
+      std::cerr << "Second cursor contents:\n";
+      clang_visitChildren(cursor, [](CXCursor cursor, CXCursor, CXClientData data){
+        std::cerr << cursor << "(" << clang_getCursorKind(cursor) << ")\n";
+        return CXChildVisit_Recurse;
+      }, nullptr);
+
+      
+    }
     index = types_.size();
     types_.emplace_back(cursor);
     set_type_rcd_ctor_info(types_.back());
@@ -3715,7 +3772,7 @@ CodeTree::get_methods_to_wrap(const TypeRcd& type_rcd, bool quiet) const{
                   << " not wrapped for type " << type_rcd.type_name
                   << ", because of an overriding ambiguity in C++. Function "
           "provided by the ancestor classes";
-        for(const auto& cl: m.second) std::cerr << ", " << cl.first.type_name << "\n";
+        for(const auto& cl: m.second) std::cerr << ", " << cl.first.type_name;
         std::cerr << ".\n";
       }
     }

src/CodeTree.h

@@ -301,8 +301,17 @@ namespace codetree{
     // Set map type for substitution in the C++ method prototypes declare to CxxWrap
     void set_cxx2cxx_typemap(const std::vector<std::string>& name_map);
 
+    void set_custom_wrapper_list(const std::vector<std::string>& l){
+      custom_type_wrappers_ = l;
+    }    
+    
   protected:
 
+    bool is_custom_type_wrapper(const std::string type_name){
+      return std::find(custom_type_wrappers_.begin(), custom_type_wrappers_.end(),
+                       type_name) != custom_type_wrappers_.end();
+    }
+    
     enum class accessor_mode_t {none, getter, both };
 
     // Adds a type to the list of types/classes to wrap.
@@ -634,6 +643,8 @@ namespace codetree{
       unsigned global_funcs = 0;
     } nwraps_;
 
+
+    std::vector<std::string> custom_type_wrappers_;
   };
 }
 

src/Graph.cpp

@@ -1,4 +1,9 @@
 #include "Graph.h"
+
+#include<iostream>
+
+static constexpr const bool verbose_sorting = false;
+
 void Graph::extend(unsigned n){
   if(n > edges_.size()){
     edges_.resize(n);
@@ -38,6 +43,9 @@ void Graph::initScan(){
   cyclicmarks_.resize(edges_.size());
   fill(cyclicmarks_.begin(), cyclicmarks_.end(), false);
 
+  inserted_.resize(edges_.size());
+  fill(inserted_.begin(), inserted_.end(), false);
+  
   cyclic_ = false;
 }
 
@@ -53,25 +61,33 @@ void Graph::localSort(unsigned vertex){
 
   /*check for all indices preceeding vertex*/
   for (const auto& node: edges_[vertex]){
-    //    std::cerr<< node << " (" << cyclicmarks_[node]
-    //             << ", " << cyclicmarks_[node] << ") "
-    //             << " ≺ "
-    //             << vertex << " (" << visited_[vertex]
-    //             << ", " << cyclicmarks_[vertex] << ") "
-    //             << "\n";
+    if(verbose_sorting){
+        std::cerr<< node << " (" << cyclicmarks_[node]
+                 << ", " << cyclicmarks_[node]
+                 << ", " << (inserted_[node] ? "in" : "")
+                 << ") "
+                 << " ≺ "
+                 << vertex << " (" << visited_[vertex]
+                 << ", " << cyclicmarks_[vertex]
+                 << ", " << (inserted_[vertex] ? "in" : "")
+                 << ") "
+                 << "\n";
+    }
     if (!visited_[node]){
       localSort(node);
     }
     cyclic_ |= cyclicmarks_[node];
-    //    std::cerr << "cyclic_: " << cyclic_ << "\n";
+    //std::cerr << "cyclic_: " << cyclic_ << "\n";
   }
 
   //remove the cycling detection mark:
   cyclicmarks_[vertex] = false;
 
   //The node vertex has no not-yet-visited preceeding
   //node, add it to the sorted list:
+  if(verbose_sorting) std::cerr << "add " << vertex << "\n";
   sortednodes_.push_back(vertex);
+  inserted_[vertex] = true;
 }
 
 void Graph::sort(){
@@ -82,6 +98,16 @@ void Graph::sort(){
       localSort(i);
     }
   }
+
+  if(verbose_sorting){
+    std::cerr << "Sorted nodes: ";
+    const char* sep = "";
+    for(const auto & i: sortednodes_){
+    std::cerr << sep << i;
+    sep = " ≺ ";
+    }
+    std::cerr << "\n";
+  }
   sorted_ = true;
 }
 

src/Graph.h

@@ -47,6 +47,7 @@ class Graph {
   std::vector<std::list<unsigned>> edges_;
 
   std::vector<bool> visited_;
+  std::vector<bool> inserted_; //not need by algo, for debug
   std::vector<bool> cyclicmarks_;
   std::vector<unsigned> sortednodes_;
   bool cyclic_;

src/main.cpp

@@ -248,6 +248,8 @@ int main(int argc, char* argv[]){
       out_cmake_fpath = resolve_out_dir("wrapit.cmake");
     }
 
+    auto custom_type_wrappers = read_vstring("custom_type_wrappers");
+    
     auto n_classes_per_file = toml_config["n_classes_per_file"].value_or(-1);
 
     auto julia_names = read_vstring("julia_names");
@@ -383,6 +385,8 @@ int main(int argc, char* argv[]){
 
     CodeTree tree;
 
+    tree.set_custom_wrapper_list(custom_type_wrappers);
+    
     tree.set_force_mode(options.count("force") > 0);
 
     tree.set_ignore_parsing_errors(options.count("ignore-parsing-errors") > 0);