dub 0.5.0

data/lib/dub/lua/function_gen.rb

@@ -0,0 +1,223 @@
+require 'dub/generator'
+require 'erb'
+
+module Dub
+  module Lua
+    class FunctionGen < Dub::Generator
+      FLOAT_TYPES = [
+        'float',
+        'double',
+        'size_t',
+        'unsigned int',
+        'uint',
+      ]
+
+      INT_TYPES = [
+        'int',
+        'size_t',
+        'unsigned int',
+        'uint',
+        'bool',
+        'uchar'
+      ]
+
+      def initialize
+        @function_template = ::ERB.new(File.read(File.join(File.dirname(__FILE__), 'function.cpp.erb')))
+        @group_template    = ::ERB.new(File.read(File.join(File.dirname(__FILE__), 'group.cpp.erb')))
+      end
+
+      # Produce bindings for a group of overloaded functions
+      def group(group)
+        @group = group
+        @group_template.result(binding)
+      end
+
+      def function(function)
+        @function = function
+        @function_template.result(binding)
+      end
+
+      def function_generator
+        self
+      end
+
+      def namespace_generator
+        Dub::Lua.namespace_generator
+      end
+
+      # Create a switch to choose the correct method from argument types (overloaded functions)
+      def switch(hash_or_function, depth = 1)
+        if hash_or_function.kind_of?(Function)
+          method_call(hash_or_function)
+        else
+          res = []
+          res << "type__ = lua_type(L, #{depth});" unless depth == 1
+          else_prefix = ''
+          default_sub_group = nil
+          hash_or_function.each do |type, sub_group|
+            default_sub_group = sub_group
+            case type
+            when :number
+              res << "#{else_prefix}if (type__ == LUA_TNUMBER) {"
+            when :string
+              res << "#{else_prefix}if (type__ == LUA_TSTRING) {"
+            when nil
+              res << "#{else_prefix}if (type__ == LUA_TNONE) {"
+            else
+              res << "#{else_prefix}if (type__ == LUA_TUSERDATA && is_userdata(L, #{depth}, \"#{type}\")) {"
+            end
+
+            res << indent(switch(sub_group, depth + 1), 2)
+
+            else_prefix = '} else '
+          end
+
+          last = default_sub_group.kind_of?(Hash) ? flatten_hash(default_sub_group).last : default_sub_group
+
+          res << "} else {"
+          res << "  // use any to raise errors"
+          res << indent(method_call(last), 2)
+          res << "}"
+          res.join("\n")
+        end
+      end
+
+      def signature(func, overloaded_index = nil)
+        "static int #{method_name(func, overloaded_index)}(lua_State *L)"
+      end
+
+      def body(func)
+        res = []
+
+        if func.member_method? && !func.constructor?
+          klass = func.parent
+          res << "#{klass.name} *self__ = *((#{klass.name}**)luaL_checkudata(L, 1, #{klass.id_name.inspect}));"
+          res << "lua_remove(L, 1);"
+        end
+
+        if func.has_default_arguments?
+          res << "int top__ = lua_gettop(L);"
+          if return_value = func.return_value
+            res << "#{return_value.create_type} retval__;"
+          end
+        end
+
+        if_indent = 0
+        func.arguments.each_with_index do |arg, i|
+          if arg.has_default?
+            res << indent("if (top__ < #{i+1}) {",     if_indent)
+            res << indent("  #{call_string(func, i)}", if_indent)
+            res << indent("} else {", if_indent)
+            if_indent += 2
+          end
+          res << indent(get_arg(arg, i + 1), if_indent)
+        end
+        res << indent(call_string(func, func.arguments.count), if_indent)
+        while if_indent > 0
+          if_indent -= 2
+          res << indent("}", if_indent)
+        end
+
+        res << return_value(func)
+        res.join("\n")
+      end
+
+      def method_name(func, overloaded_index = nil)
+        overloaded_index ||= func.overloaded_index
+        overloaded_index = '' if overloaded_index == 0
+        "#{func.prefix}_#{func.name}#{overloaded_index}"
+      end
+
+      def method_call(func)
+        "return #{method_name(func)}(L);"
+      end
+
+      def call_string(func, upto_arg)
+        if upto_arg == 0
+          call_string = "#{func.name}();"
+        else
+          call_string = "#{func.name}(#{func.arguments[0..(upto_arg-1)].map{|arg| arg.in_call_type}.join(', ')});"
+        end
+
+        if func.constructor?
+          call_string = "new #{call_string}"
+        elsif func.member_method?
+          call_string = "self__->#{call_string}"
+        end
+
+
+        if return_value = func.return_value
+          if func.has_default_arguments?
+            "retval__ = #{call_string}"
+          else
+            "#{return_value.create_type} retval__ = #{call_string}"
+          end
+        else
+          call_string
+        end
+      end
+
+      def return_value(func)
+        res = []
+        if return_value = func.return_value
+          case Argument.type_group(return_value)
+          when :number
+            res << "lua_pushnumber(L, retval__);"
+          when :string
+            raise "Not supported yet"
+          else
+            if func.constructor?
+              prefix = func.klass.prefix
+            else
+              prefix = func.prefix
+            end
+            res << "lua_pushclass<#{return_value.type}>(L, retval__, \"#{return_value.id_name}\");"
+          end
+          res << "return 1;"
+        else
+          res << "return 0;"
+        end
+        res.join("\n")
+      end
+
+      # Get argument and verify type
+      # // luaL_argcheck could be better to report errors like "expected Mat"
+      def get_arg(arg, stack_pos)
+        type_def = "#{arg.create_type}#{arg.name}#{arg.array_suffix}"
+        if arg.is_native?
+          if arg.is_pointer?
+            if arg.type == 'char'
+              type_def = "const #{type_def}" unless arg.is_const?
+              "#{type_def} = luaL_checkstring(L, #{stack_pos});"
+            else
+              # retrieve by using a table accessor
+              # TODO: we should have a hint on required sizes !
+              "\nDubArgPointer<#{arg.type}> ptr_#{arg.name};\n" +
+              "#{type_def} = ptr_#{arg.name}(L, #{stack_pos});"
+            end
+          else
+            if FLOAT_TYPES.include?(arg.type)
+              "#{type_def} = luaL_checknumber(L, #{stack_pos});"
+            elsif INT_TYPES.include?(arg.type)
+              "#{type_def} = luaL_checkint(L, #{stack_pos});"
+            else
+              raise "Unsuported type: #{arg.type}"
+            end
+          end
+        else
+          "#{type_def} = *((#{arg.create_type}*)luaL_checkudata(L, #{stack_pos}, #{arg.id_name.inspect}));"
+        end
+      end
+
+      def flatten_hash(hash)
+        hash.each do |k, v|
+          if v.kind_of?(Hash)
+            hash[k] = flatten_hash(v)
+          end
+        end
+        hash.to_a.flatten
+      end
+
+    end # FunctionGen
+  end # Lua
+end # Dub

data/lib/dub/lua/group.cpp.erb

@@ -0,0 +1,10 @@
+<% @group.members.each do |f| %>
+<%= function(f) %>
+
+<% end %>
+
+/** Overloaded function chooser for <%= @group.name %>(...) */
+<%= signature(@group.first, 0) %> {
+  int type__ = lua_type(L, 1);
+<%= indent(switch(Argument.decision_tree(@group.members)), 2) %>
+}

data/lib/dub/lua/lua_cpp_helper.h

@@ -0,0 +1,141 @@
+
+#ifndef DOXY_GENERATOR_LIB_DOXY_GENERATOR_INCLUDE_LUA_DOXY_HELPER_H_
+#define DOXY_GENERATOR_LIB_DOXY_GENERATOR_INCLUDE_LUA_DOXY_HELPER_H_
+
+#include <stdlib.h> // malloc
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+// We need C linkage because lua lib is compiled as C code
+#include "lua.h"
+#include "lauxlib.h"
+
+#ifdef __cplusplus
+}
+#endif
+/** ======================================== lua_pushclass          */
+
+/** Push a custom type on the stack.
+ * Since the value is passed as a pointer, we assume it has been created
+ * using 'new' and Lua can safely call delete when it needs to garbage-
+ * -collect it.
+ */
+template<class T>
+void lua_pushclass(lua_State *L, T *ptr, const char *type_name) {
+  T **userdata = (T**)lua_newuserdata(L, sizeof(T*));
+  *userdata = ptr;
+
+  // the userdata is now on top of the stack
+
+  // set metatable (contains methods)
+  luaL_getmetatable(L, type_name);
+  lua_setmetatable(L, -2);
+}
+
+/** Push a custom type on the stack.
+ * Since the value is passed by value, we have to allocate a copy
+ * using 'new' so that Lua can keep it.
+ */
+template<class T>
+void lua_pushclass(lua_State *L, T &val, const char *type_name) {
+  T *val_ptr = new T(val);
+  lua_pushclass<T>(L, val_ptr, type_name);
+}
+
+/** ======================================== DubArgPointer */
+
+/** This class is a helper to provide pointer to data from
+ * Lua to C (but maybe it's not a good idea).
+ */
+template<class T>
+class DubArgPointer {
+public:
+  DubArgPointer() : data(NULL) {}
+
+  ~DubArgPointer() {
+    if (data) free(data);
+  }
+
+  // TODO: we should have a hint on required sizes !
+  T *operator()(lua_State *L, int index) {
+    if (!lua_istable(L, index)) throw 1;
+
+    size_t size = lua_objlen(L, index);
+    if (size == 0) return NULL;
+
+    data = (T*)malloc(size * sizeof(T));
+    if (!data) throw 1;
+
+    for(size_t i=0; i < size; ++i) {
+      data[i] = get_value_at(L, index, i+1);
+    }
+    return data;
+  }
+
+private:
+  T get_value_at(lua_State *L, int table_index, int index) {
+    lua_pushinteger(L, index + 1);
+    lua_gettable(L, index);
+    T value = luaL_checknumber(L, -1);
+    lua_pop(L, 1);
+    return value;
+  }
+
+  T *data;
+};
+
+/** ======================================== is_userdata */
+
+inline bool is_userdata(lua_State *L, int index, const char *tname) {
+  void *p = lua_touserdata(L, index);
+  if (p != NULL) {  /* value is a userdata? */
+    if (lua_getmetatable(L, index)) {  /* does it have a metatable? */
+      lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */
+      if (lua_rawequal(L, -1, -2)) {  /* does it have the correct mt? */
+        lua_pop(L, 2);  /* remove both metatables */
+        // type match
+        return true;
+      }
+    }
+  }
+  // type does not match
+  return false;
+}
+
+/** ======================================== register_constants */
+
+
+typedef struct lua_constants_Reg {
+  const char *name;
+  double constant;
+} lua_constants_Reg;
+
+inline int libsize (const lua_constants_Reg *l) {
+  int size = 0;
+  for (; l->name; l++) size++;
+  return size;
+}
+
+inline void register_constants(lua_State *L, const char *name_space, const lua_constants_Reg *l) {
+  if (name_space) {
+    /* compute size hint for new table. */
+    int size = libsize(l);
+
+    /* try global variable (and create one if it does not exist) */
+    if (luaL_findtable(L, LUA_GLOBALSINDEX, name_space, size) != NULL)
+      luaL_error(L, "name conflict for module " LUA_QS, name_space);
+
+    /* found name_space in global index ==> stack -1 */
+  }
+  for (; l->name; l++) {
+    /* push each constant into the name_space (stack position = -1)*/
+    lua_pushnumber(L, l->constant);
+    lua_setfield(L, -2, l->name);
+  }
+  /* pop name_space */
+  lua_pop(L, 1);
+}
+
+
+#endif // DOXY_GENERATOR_LIB_DOXY_GENERATOR_INCLUDE_LUA_DOXY_HELPER_H_

data/lib/dub/lua/namespace.cpp.erb

@@ -0,0 +1,35 @@
+#include "<%= @namespace.header %>"
+
+#include "lua_cpp_helper.h"
+
+using namespace <%= @namespace.name %>;
+
+<% if @namespace.members; @namespace.members.each do |function| %>
+
+<%= function %>
+
+<% end; end %>
+
+// Register namespace
+
+
+static const struct luaL_Reg <%= @namespace.name %>_functions[] = {
+<%= indent(functions_registration, 2) %>,
+  {NULL, NULL},
+};
+
+<% if @namespace.has_constants? %>
+static const struct lua_constants_Reg <%= @namespace.name %>_namespace_constants[] = {
+<%= indent(constants_registration, 2) %>,
+  {NULL, NULL},
+};
+<% end %>
+
+void luaopen_<%= @namespace.lib_name %>(lua_State *L) {
+  // register functions
+  luaL_register(L, <%= @namespace.name.inspect %>, <%= @namespace.name %>_functions);
+<% if @namespace.has_constants? %>
+  // register namespace enums
+  register_constants(L, <%= @namespace.id_name.inspect %>, <%= @namespace.name %>_namespace_constants);
+<% end %>
+}

data/lib/dub/lua/namespace_gen.rb

@@ -0,0 +1,86 @@
+require 'dub/generator'
+require 'erb'
+
+module Dub
+  module Lua
+    class NamespaceGen < Dub::Generator
+      def initialize
+        @namespace_template = ::ERB.new(File.read(File.join(File.dirname(__FILE__), 'namespace.cpp.erb')))
+      end
+
+      def namespace(namespace)
+        @namespace = namespace
+        @namespace_template.result(binding)
+      end
+
+      def class_generator
+        Lua.class_generator
+      end
+
+      def function_generator
+        Lua.function_generator
+      end
+
+      def functions_registration(namespace = @namespace)
+        (namespace.members || []).map do |method|
+          "{%-32s, #{method.method_name(0)}}" % method.name.inspect
+        end.join(",\n")
+      end
+
+      def constants_registration(namespace = @namespace)
+        res = []
+        if namespace.has_enums?
+          res << namespace.enums.map do |name|
+            "{%-32s, #{namespace.full_type}::#{name}}" % name.inspect
+          end.join(",\n")
+        end
+
+        if namespace.has_defines?
+          res << namespace.defines.map do |name|
+            "{%-32s, #{name}}" % name.inspect
+          end.join(",\n")
+        end
+
+        same = namespace.enums & namespace.defines
+        unless same.empty?
+          # Should never happen (not sure if it would compile ok in the first place)
+          puts "Warning: the following are present both as enum and define: #{same.inspect}"
+        end
+        res.join(",\n\n")
+      end
+
+      def members_list(all_members, ignore_list = [])
+        list = all_members.map do |member_or_group|
+          if ignore_list.include?(member_or_group.name)
+            nil
+          elsif member_or_group.kind_of?(Array)
+            members_list(member_or_group)
+          elsif ignore_member?(member_or_group)
+            nil
+          else
+            member_or_group
+          end
+        end
+
+        list.compact!
+        list == [] ? nil : list
+      end
+
+      def ignore_member?(member)
+        if member.name =~ /^~/           || # do not build constructor
+           member.name =~ /^operator/    || # no conversion operators
+           member.original_signature =~ />/ || # no complex types in signature
+           member.has_array_arguments? ||
+           member.vararg? ||
+            member.original_signature =~ /void\s+\*/
+          true # ignore
+        elsif return_value = member.return_value
+          return_value.type =~ />$/    || # no complex return types
+          return_value.is_native? && member.return_value.is_pointer?
+        else
+          false # ok, do not ignore
+        end
+      end
+    end
+  end
+end

data/lib/dub/lua.rb

@@ -0,0 +1,24 @@
+require 'dub/lua/function_gen'
+require 'dub/lua/namespace_gen'
+require 'dub/lua/class_gen'
+
+module Dub
+  module Lua
+    def self.function_generator
+      @@function_generator ||= Dub::Lua::FunctionGen.new
+    end
+
+    def self.class_generator
+      @@class_generator ||= Dub::Lua::ClassGen.new
+    end
+
+    def self.namespace_generator
+      @@namespace_generator ||= Dub::Lua::NamespaceGen.new
+    end
+
+    def self.bind(object)
+      object.bind(self)
+      object
+    end
+  end # Lua
+end # Dub

data/lib/dub/member_extraction.rb

@@ -0,0 +1,88 @@
+require 'dub/function'
+require 'dub/function_group'
+require 'dub/klass'
+
+module Dub
+  class Klass
+  end
+
+  # This module is used by Namespace and Klass to extract member functions
+  module MemberExtraction
+    def members_prefix
+      @name
+    end
+
+    def parse_members
+      @members_hash   = {}
+      @t_members_hash = {}
+      # TODO: template functions
+      (@xml/'memberdef').each do |member|
+        Dub.logger.info "Parsing #{member.name}"
+        name = (member/"name").innerHTML
+        if (member/'templateparamlist').first
+          insert_member(member, name, @t_members_hash)
+        else
+          insert_member(member, name, @members_hash)
+        end
+      end
+    end
+
+    def insert_member(member, name, destination)
+      if destination[name].kind_of?(Array)
+        destination[name] << member
+      elsif first_member = destination[name]
+        destination[name] = [first_member, member]
+      else
+        destination[name] = member
+      end
+    end
+
+    def member(name)
+      get_member(name.to_s)
+    end
+
+    def members
+      @members ||= begin
+        list = []
+        @members_hash.each do |name, member|
+          list << get_member(name)
+        end
+        list.compact!
+        list.sort
+      end
+    end
+
+    # Lazy construction of members
+    def get_member(name)
+      if member_or_group = @members_hash[name]
+        if member_or_group.kind_of?(Array)
+          if member_or_group.first.kind_of?(Hpricot::Elem)
+            list = Dub::FunctionGroup.new(self)
+            member_or_group.each_with_index do |m,i|
+              list << make_member(name, m, i + 1)
+            end
+            member_or_group = list.compact
+            member_or_group = nil if member_or_group == []
+          end
+        elsif member_or_group.kind_of?(Hpricot::Elem)
+          @members_hash[name] = member_or_group = make_member(name, member_or_group)
+        end
+      end
+      member_or_group
+    end
+
+    def make_member(name, member, overloaded_index = nil)
+      case member[:kind]
+      when 'function'
+        Dub.logger.info "Building #{members_prefix}::#{name}"
+        Function.new(self, name, member, members_prefix, overloaded_index)
+      when 'class'
+        Dub.logger.info "Building #{members_prefix}::#{name}"
+        Klass.new(self, name, member, members_prefix)
+      else
+        # not supported: ignore
+        nil
+      end
+    end
+  end
+end # Dub