dub 0.10.3 → 1.0.0

data/lib/dub/lua/function_gen.rb

@@ -0,0 +1,329 @@
+require 'dub/generator'
+require 'erb'
+
+module Dub
+  module Lua
+    SELF = "self"
+    class FunctionGen < Dub::Generator
+      # klass is used when parsing members from the superclasses.
+      attr_accessor :template_path, :klass
+
+      NUMBER_TYPES = [
+        'float',
+        'double',
+        'time_t',
+      ]
+
+      INT_TYPES = [
+        'int',
+        'size_t',
+        'unsigned int',
+        'uint',
+        'uchar',
+        'char',
+      ]
+
+      BOOL_TYPES = [
+        'bool',
+      ]
+
+      DEFAULT_CUSTOM_TYPES = [
+        [/lua_State /, Proc.new do |type_def, arg, stack_pos|
+          if type_def =~ /lua_State\s*\*\s*L/
+            ""
+          else
+            "#{type_def} = L;"
+          end
+        end]
+      ]
+
+      def initialize
+        load_erb
+        @custom_types = DEFAULT_CUSTOM_TYPES.dup
+      end
+
+      def template_path=(template_path)
+        @template_path = template_path
+        load_erb
+      end
+
+      def custom_type(regexp, &block)
+        @custom_types << [regexp, block]
+      end
+
+      # Produce bindings for a group of overloaded functions
+      def group(group)
+        @group = group
+        if @group.members
+          @group_template.result(binding)
+        else
+          ''
+        end
+      end
+
+      def function(function)
+        @function = function
+        @function_template.result(binding)
+      end
+
+      def function_generator
+        self
+      end
+
+      def namespace_generator
+        Dub::Lua.namespace_generator
+      end
+
+      def chooser_body(group = @group)
+        if group.first.member_method? && !group.first.constructor?
+          delta_depth = 1
+        else
+          delta_depth = 0
+        end
+        decision_tree = Argument.decision_tree(group.members)
+        res = []
+        res << "int type__ = lua_type(L, #{1 + delta_depth});"
+        if flatten_hash(decision_tree).include?(nil)
+          res << "int top__  = lua_gettop(L);"
+        end
+        res << switch(decision_tree, delta_depth + 1, true)
+        res.join("\n")
+      end
+
+      # Create a switch to choose the correct method from argument types (overloaded functions)
+      def switch(hash_or_function, depth = 1, start = false)
+        if hash_or_function.kind_of?(Function)
+          method_call(hash_or_function)
+        else
+          res = []
+          res << "type__ = lua_type(L, #{depth});" unless start
+          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 (top__ < #{depth}) {"
+            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
+
+      # The check_prefix parameter chooses between dubL_check and luaL_check depending
+      # on exceptions that can be thrown.
+      def body(func, check_prefix)
+        res = []
+        delta_top = 0
+        if func.member_method? && !func.constructor? && !func.static?
+          # Force @klass when serializing members from superclass.
+          klass = @klass || func.parent
+          res << "#{klass.name} *#{SELF} = *((#{klass.name}**)#{check_prefix}L_checksdata(L, 1, #{klass.id_name.inspect}));"
+          if func.member_method? && func.klass.custom_destructor?
+            # protect calls
+            if check_prefix == 'dub'
+              # we cannot use luaL_error
+              res << "if (!#{SELF}) throw dub::Exception(\"Using deleted #{klass.id_name} in #{func.name}\");"
+            else
+              res << "if (!#{SELF}) return luaL_error(L, \"Using deleted #{klass.id_name} in #{func.name}\");"
+            end
+          end
+          delta_top = 1
+        end
+        
+        custom_body = func.custom_body('lua')
+
+        if_indent = 0
+        if custom_body && func.has_default_arguments?
+          # we do not prepare arguments
+        else
+          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
+          func.arguments.each_with_index do |arg, i|
+            if arg.has_default?
+              res << indent("if (top__ < #{i+1+delta_top}) {",     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 + delta_top, check_prefix), if_indent)
+          end
+        end
+        if custom_body
+          res << indent(custom_body, if_indent)
+        else
+          res << indent(call_string(func, func.arguments.count), if_indent)
+        end
+        while if_indent > 0
+          if_indent -= 2
+          res << indent("}", if_indent)
+        end
+
+        unless custom_body
+          res << return_value(func)
+        end
+        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 = nil)
+        upto_arg ||= func.arguments.count
+        if upto_arg == 0
+          call_string = "#{func.call_name}();"
+        else
+          call_string = "#{func.call_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? && !func.static?
+          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
+          if return_value.create_type == 'LuaStackSize '
+            return "return retval__;"
+          end
+          case Argument.type_group(return_value)
+          when :number
+            res << "lua_pushnumber(L, retval__);"
+          when :boolean
+            res << "lua_pushboolean(L, retval__);"
+          when :string
+            res << "lua_pushstring(L, retval__);"
+          else
+            pushclass = 'lua_pushclass'
+            if func.constructor?
+              if ctor_with_lua_init?(func)
+                res << "// The class inherits from 'LuaCallback', use lua_init instead of pushclass."
+                res << "return retval__->luaInit(L, retval__, \"#{return_value.id_name}\");"
+                return res.join("\n")
+              elsif func.klass.custom_destructor?
+                # Use special pushclass to set userdata
+                pushclass = 'lua_pushclass2'
+              end
+              prefix = func.klass.prefix
+            else
+              prefix = func.prefix
+            end
+            res << "#{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"
+      # the check_prefix chooses between 'luaL_check...' and 'dubL_check' methods
+      # depending on C++ exceptions raised by the function.
+      def get_arg(arg, stack_pos, check_prefix)
+        type_def = "#{arg.create_type}#{arg.name}#{arg.array_suffix}"
+        if custom_type = @custom_types.detect {|reg,proc| type_def =~ reg}
+          custom_type[1].call(type_def, arg, stack_pos)
+        elsif arg.is_native?
+          if arg.is_pointer?
+            if arg.type == 'char'
+              type_def = "const #{type_def}" unless arg.is_const?
+              "#{type_def} = #{check_prefix}L_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 NUMBER_TYPES.include?(arg.type)
+              "#{type_def} = #{check_prefix}L_checknumber(L, #{stack_pos});"
+            elsif BOOL_TYPES.include?(arg.type)
+              "#{type_def} = lua_toboolean(L, #{stack_pos});"
+            elsif INT_TYPES.include?(arg.type)
+              "#{type_def} = #{check_prefix}L_checkint(L, #{stack_pos});"
+            else
+              raise "Unsuported type: #{arg.type}"
+            end
+          end
+        else
+          "#{type_def} = *((#{arg.create_type}*)#{check_prefix}L_checksdata(L, #{stack_pos}, #{arg.id_name.inspect}));"
+        end
+      end
+
+      def flatten_hash(hash)
+        list = []
+        hash.each do |k, v|
+          if v.kind_of?(Hash)
+            list << [k, flatten_hash(v)]
+          else
+            list << [k, v]
+          end
+        end
+        list.flatten
+      end
+
+      def load_erb
+        @function_template = ::ERB.new(File.read(@template_path ||File.join(File.dirname(__FILE__), 'function.cpp.erb')), nil, '%<>-')
+        @group_template    = ::ERB.new(File.read(File.join(File.dirname(__FILE__), 'group.cpp.erb')))
+      end
+
+      def ctor_with_lua_init?(func)
+        # If the class inherits from LuaObject, we need to use
+        # s->lua_init(L); instead of pushclass.
+        if func.constructor?
+          func.klass.ancestors.detect{|a| a =~ /LuaObject/}
+        else
+          false
+        end
+      end
+    end # FunctionGen
+  end # Lua
+end # Dub

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

@@ -0,0 +1,9 @@
+<% @group.members.each do |f| %>
+<%= function(f) %>
+
+<% end %>
+
+/** Overloaded function chooser for <%= @group.name %>(...) */
+<%= signature(@group.first, 0) %> {
+<%= indent(chooser_body, 2) %>
+}

data/lib/dub/lua/lua_cpp_helper.cpp

@@ -0,0 +1,259 @@
+/* 
+Copyright (c) 2011 by Gaspard Bucher (http://teti.ch).
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "lua_cpp_helper.h"
+
+#define DUB_EXCEPTION_BUFFER_SIZE 256  
+#define TYPE_EXCEPTION_MSG "%s expected, got %s"
+#define TYPE_EXCEPTION_SMSG "%s expected, got %s (using super)"
+using namespace dub;
+
+Exception::Exception(const char *format, ...) {
+  char buffer[DUB_EXCEPTION_BUFFER_SIZE];
+  va_list args;
+  va_start(args, format);
+    vsnprintf(buffer, DUB_EXCEPTION_BUFFER_SIZE, format, args);
+  va_end(args);
+  message_ = buffer;
+}
+
+Exception::~Exception() throw() {}
+
+const char* Exception::what() const throw() {
+  return message_.c_str();
+}
+
+
+TypeException::TypeException(lua_State *L, int narg, const char *type, bool is_super) :
+  Exception(is_super ? TYPE_EXCEPTION_SMSG : TYPE_EXCEPTION_MSG, type, luaL_typename(L, narg)) {}
+
+// ================================================== LuaL_check... try/catch safe
+// These methods (dubL_...) are slight adaptations from luaxlib.c
+// Copyright (C) 1994-2008 Lua.org, PUC-Rio.
+
+lua_Number dubL_checknumber(lua_State *L, int narg) throw(TypeException) {
+  lua_Number d = lua_tonumber(L, narg);
+  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
+    throw TypeException(L, narg, lua_typename(L, LUA_TNUMBER));
+  return d;
+}
+
+lua_Integer dubL_checkinteger(lua_State *L, int narg) throw(TypeException) {
+  lua_Integer d = lua_tointeger(L, narg);
+  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
+    throw TypeException(L, narg, lua_typename(L, LUA_TNUMBER));
+  return d;
+}
+
+const char *dubL_checklstring(lua_State *L, int narg, size_t *len) throw(TypeException) {
+  const char *s = lua_tolstring(L, narg, len);
+  if (!s) throw TypeException(L, narg, lua_typename(L, LUA_TSTRING));
+  return s;
+}
+
+void *dubL_checkudata(lua_State *L, int ud, const char *tname) throw(TypeException) {
+  void *p = lua_touserdata(L, ud);
+  if (p != NULL) {  /* value is a userdata? */
+    if (lua_getmetatable(L, ud)) {  /* 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 */
+        return p;
+      }
+    }
+  }
+  throw TypeException(L, ud, tname); /* else error */
+  return NULL;  /* to avoid warnings */
+}
+
+// throws exceptions
+void *dubL_checksdata(lua_State *L, int ud, const char *tname) throw(dub::TypeException) {
+  void *p = lua_touserdata(L, ud);
+  if (p != NULL) {  /* value is a userdata? */
+    if (lua_getmetatable(L, ud)) {  /* 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 */
+        return p;
+      }
+    }
+  } else if (lua_istable(L, ud)) {
+    if (ud < 0) {
+      ud = lua_gettop(L) + 1 + ud;
+    }
+    // get p from super
+    // ... <ud> ...
+    // TODO: optimize by storing key in registry ?
+    lua_pushlstring(L, "super", 5);
+    // ... <ud> ... <'super'>
+    lua_rawget(L, ud);
+    // ... <ud> ... <ud?>
+    p = lua_touserdata(L, -1);
+    if (p != NULL) {
+      if (lua_getmetatable(L, -1)) {  /* 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, 3);  /* remove both metatables and super */
+          return p;
+        }
+        // remove both metatables
+        lua_pop(L, 2);
+      }
+      throw dub::TypeException(L, -1, tname, true);
+    }
+  }
+  throw dub::TypeException(L, ud, tname);
+  return NULL;
+}
+
+// does not throw exceptions
+void *dubL_checksdata_n(lua_State *L, int ud, const char *tname) throw() {
+  void *p = lua_touserdata(L, ud);
+  if (p != NULL) {  /* value is a userdata? */
+    if (lua_getmetatable(L, ud)) {  /* 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 */
+        return p;
+      }
+    }
+  } else if (lua_istable(L, ud)) {
+    if (ud < 0) {
+      ud = lua_gettop(L) + 1 + ud;
+    }
+    // get p from super
+    // ... <ud> ...
+    // TODO: optimize by storing key in registry ?
+    lua_pushlstring(L, "super", 5);
+    // ... <ud> ... <'super'>
+    lua_rawget(L, ud);
+    // ... <ud> ... <ud?>
+    p = lua_touserdata(L, -1);
+    if (p != NULL) {
+      if (lua_getmetatable(L, -1)) {  /* 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, 3);  /* remove both metatables and super */
+          return p;
+        }
+        // remove both metatables
+        lua_pop(L, 2);
+      }
+      luaL_error(L, "%s expected, got %s (using super)", tname, luaL_typename(L, -1));
+    }
+  }
+  luaL_error(L, "%s expected, got %s", tname, luaL_typename(L, ud));
+  return NULL;
+}
+
+// ==================================================
+
+DeletableOutOfLua::DeletableOutOfLua() :
+   userdata_ptr_(NULL) {}
+
+DeletableOutOfLua::~DeletableOutOfLua() {
+  if (userdata_ptr_) {
+    *userdata_ptr_ = NULL;
+    userdata_ptr_ = NULL;
+  }
+}
+
+void DeletableOutOfLua::dub_destroy() {
+  dub_cleanup();
+  delete this;
+}
+
+void DeletableOutOfLua::set_userdata_ptr(void **ptr) {
+  userdata_ptr_ = ptr;
+}
+
+void DeletableOutOfLua::dub_cleanup() {
+  // so that it is not changed in ~DeletableOutOfLua
+  userdata_ptr_ = NULL;
+}
+
+/** ======================================== is_userdata */
+
+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;
+}
+
+int libsize (const lua_constants_Reg *l) {
+  int size = 0;
+  for (; l->name; l++) size++;
+  return size;
+}
+
+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);
+}
+
+// The metatable lives in libname.ClassName_
+void register_mt(lua_State *L, const char *libname, const char *class_name) {
+  size_t len = strlen(class_name) + 2;
+  char *buffer = (char*)malloc(sizeof(char) * len);
+  snprintf(buffer, len, "%s_", class_name);
+
+  // meta-table should be on top
+  // <mt>
+  lua_getglobal(L, libname);
+  // <mt> <lib>
+  lua_pushstring(L, buffer);
+  // <mt> <lib> "Foobar_"
+  lua_pushvalue(L, -3);
+  // <mt> <lib> "Foobar" <mt>
+  lua_settable(L, -3);
+  // <mt> <lib>
+  lua_pop(L, 1);
+  // <mt>
+}
+
+