0x55555555 / bondage

Bindings generator

bondage

bondage is a bindings generator. It uses clang and ruby to process C++ classes into runtime reflectable methods.

for example:

namespace Meat
{

/// \expose
class Pork
{
public:
  void saltiness();
};
}

Allows class reflection:

// Prints "Pork"
for(const bondage::WrappedClass *cls : bondage::ClassWalker(Meat::bindings()))
  {
  std::cout << cls->type().name();
  }

And function reflection:

// Prints "saltiness"
const bondage::WrappedClass *pork;
for (std::size_t i = 0; i < pork->functionCount(); ++i)
  {
  std::cout << stringClass->function(i).name();
  }

bondage uses Reflect to wrap functions, and requires some kind of wrapping backend (a script engine, for example) to provide function invocation.

Example

A library for bondage processing can defined with:

require "parser/Library.rb"

# Create a library called [Gen], in the relative folder [data/Gen]
lib = Library.new("Gen", "data/Gen")

# Include files for this library are located in the library folder [data/Gen], or [.]
lib.addIncludePath(".")

# The only file in the library is the [Generator.h] file.
lib.addFile("Generator.h")

# We could also add other exposed dependencies to the library here.

C++ bindings can then be generated using:

# Parse the library. This fills visitor with the data from our C++ files.
visitor = ParsedLibrary.parse(lib)

# Create an exposer, this visits all classes in the C++, checks 
# if they should be exposed (either implicitly, or if asked - using the /// \expose command)
exposer = ClassExposer.new(visitor)

# Now we have all the data to write the bindings
libGen = CPP::LibraryGenerator.new()
libGen.generate(lib, exposer)

# libGen.header and libGen.source can now be used to write to file.

bondage also has a generator for Lua, which will generate class bindings on the lua side, which interacts with the bindings above. Lua bindings are generated using a very similar method:

# first create a lua library generator
libGen = Lua::LibraryGenerator.new(
  Lua::DEFAULT_PLUGINS,     # plugins are used to generate extra class data - properties by default
  Lua::DEFAULT_CLASSIFIERS, # classifiers can process arguments passed to functions - converting indices
  "getFunction",            # a global lua function to get a native function
  TestPathResolver.new)     # a helper class to turn a class into a file path for requiring

# Generate the bindings
libGen.generate(lib, exposer)

# write the bindings (writes a file per class, and a library file)
libGen.write("c:\somedir\")

Written with StackEdit.

bondage's Issues

Index return wrappers -1 instead of +1

https://github.com/jorj1988/bondage/blob/master/generators/Lua/ArgumentClassifiers/IndexClassifier.rb#L14

the -1 should be a +1 for returns that are indexes

IndexClassifier is called on all overloaded calls when only one contains an index

The class

/// \brief
/// \expose unmanaged
class MyClass
{
  public:

  /// \brief  Find the pork
  const std::string& findPork(const std::string& country, const std::string& town);

  /// \brief  Find the pork
  /// \param  porkUID [index] the unique identification number for the pork
  const std::string& findPork(int porkUID);
}

generates the following wrapper in lua:

local MyClass_findPork_wrapper_fwd = getNative("prk", "MyClass", "findPork")
local MyClass_findPork_wrapper = function(...)
  local argCount = select("#", ...)
  if 3 == argCount then
    return MyClass_findPork_wrapper_fwd(select(1, ...), to_native(select(2, ...)), select(3, ...))
  end
  if 2 == argCount then
    return MyClass_findPork_wrapper_fwd(select(1, ...), (select(2, ...)-1))
  end
end

The overload with two arguments (string, string) is having the first argument treated as a non-integer index, even though it isn't marked as such

"RuntimeError: non equal return types" when exposing overload that takes an index

When exposing

void remove(const std::string& name);
/// \param itemIndex [index]
void remove(int itemIndex);

I get an error in: https://github.com/jorj1988/bondage/blob/master/generators/Lua/Function/WrapperGenerator.rb#L130

RuntimeError: non equal return types
D:/bondage/generators/Lua/Function/WrapperGenerator.rb:143:in `block (2 levels) in getCommonTypeArray'
D:/bondage/generators/Lua/Function/WrapperGenerator.rb:141:in `each_index'
D:/bondage/generators/Lua/Function/WrapperGenerator.rb:141:in `block in getCommonTypeArray'
D:/bondage/generators/Lua/Function/WrapperGenerator.rb:138:in `times'
D:/bondage/generators/Lua/Function/WrapperGenerator.rb:138:in `getCommonTypeArray'
D:/bondage/generators/Lua/Function/WrapperGenerator.rb:57:in `generateOverloadCall'
D:/bondage/generators/Lua/Function/WrapperGenerator.rb:40:in `block in generate'
D:/bondage/generators/Lua/Function/WrapperGenerator.rb:38:in `each'
D:/bondage/generators/Lua/Function/WrapperGenerator.rb:38:in `generate'
D:/bondage/generators/Lua/Function/Generator.rb:57:in `generate'
D:/bondage/generators/Lua/ClassGenerator.rb:112:in `generateFunction'
D:/bondage/generators/Lua/ClassGenerator.rb:154:in `blockin generateFunctions'
D:/bondage/generators/Lua/ClassGenerator.rb:153:in `each' 
D:/bondage/generators/Lua/ClassGenerator.rb:153:in `generateFunctions'
D:/bondage/generators/Lua/ClassGenerator.rb:38:in `generate'
D:/bondage/generators/Lua/LibraryGenerator.rb:33:in `block in generate'
D:/bondage/generators/Lua/LibraryGenerator.rb:31:in `each'
D:/bondage/generators/Lua/LibraryGenerator.rb:31:in `generate'

which I think is due to the wrapper generator not handling the overload with the same number of arguments (other cases with differing number of arguments work)