dub 0.2.2 → 1.0.0

data/lib/dub/lua/lua_cpp_helper.h

@@ -0,0 +1,219 @@
+/*                                     
+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.
+*/
+
+#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
+#include <string> // std::string for Exception
+#include <exception> // std::exception
+
+#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
+/** Try/catch safe versions of luaL_checknumber, luaL_checkudata, .. */
+                       
+namespace dub {
+class Exception : public std::exception
+{
+  std::string message_;
+public:
+  explicit Exception(const char *format, ...);
+
+  ~Exception() throw();
+
+  const char* what() const throw();
+};
+
+class TypeException : public Exception
+{
+public:
+  explicit TypeException(lua_State *L, int narg, const char *type, bool is_super = false);
+};
+
+} // dub
+
+
+// ================================================== dubL_check... try/catch safe
+// these provide the same funcionality of their equivalent luaL_check... but they
+// throw std::exception which can be caught (eventually to call lua_error)
+
+lua_Number dubL_checknumber(lua_State *L, int narg) throw(dub::TypeException);
+
+lua_Number dubL_checkint(lua_State *L, int narg) throw(dub::TypeException);
+
+const char *dubL_checklstring(lua_State *L, int narg, size_t *len) throw(dub::TypeException);
+
+lua_Integer dubL_checkinteger(lua_State *L, int narg) throw(dub::TypeException);
+
+void *dubL_checkudata(lua_State *L, int ud, const char *tname) throw(dub::TypeException);
+
+// super aware userdata calls
+void *dubL_checksdata(lua_State *L, int ud, const char *tname) throw(dub::TypeException);
+// does not throw exceptions (can be used with a #define for luaL_checksdata)
+void *dubL_checksdata_n(lua_State *L, int ud, const char *tname) throw();
+
+#define dubL_checkstring(L,n) (dubL_checklstring(L, (n), NULL))
+#define dubL_checkint(L,n) ((int)dubL_checkinteger(L, (n)))
+// super aware userdata check (does not throw)
+#define luaL_checksdata(L, u, t) (dubL_checksdata_n(L, u, t))
+
+/** ======================================== 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 and give it the pointer to the userdata.
+ * Passing the userdata enables early deletion from some other thread (GUI)
+ * that safely invalidates the userdatum.
+ */
+template<class T>
+void lua_pushclass2(lua_State *L, T *ptr, const char *type_name) {
+  T **userdata = (T**)lua_newuserdata(L, sizeof(T*));
+  *userdata = ptr;
+
+  // store pointer in class so that it can set it to NULL on destroy with
+  // *userdata = NULL
+  ptr->set_userdata_ptr((void**)userdata);
+
+  // the userdata is now on top of the stack
+
+  // set metatable (contains methods)
+  luaL_getmetatable(L, type_name);
+  lua_setmetatable(L, -2);
+}
+
+/** Classes that can be deleted out of Lua should inherit from this class or
+ * implement 'set_userdata_ptr' (and manage the userdata_ptr...)
+ */
+class DeletableOutOfLua {
+  void **userdata_ptr_;
+public:
+  DeletableOutOfLua();
+
+  virtual ~DeletableOutOfLua();
+
+  virtual void dub_destroy();
+
+  /** @internal
+   */
+  void set_userdata_ptr(void **ptr);
+
+protected:
+  /** MUST be called from the custom destructor.
+   */
+  void dub_cleanup();
+};
+
+/** 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 */
+
+bool is_userdata(lua_State *L, int index, const char *tname);
+
+/** ======================================== register_constants */
+
+typedef struct lua_constants_Reg {
+  const char *name;
+  double constant;
+} lua_constants_Reg;
+
+int libsize (const lua_constants_Reg *l);
+
+void register_constants(lua_State *L, const char *name_space, const lua_constants_Reg *l);
+
+// The metatable lives in libname.ClassName_
+void register_mt(lua_State *L, const char *libname, const char *class_name);
+
+#endif // DOXY_GENERATOR_LIB_DOXY_GENERATOR_INCLUDE_LUA_DOXY_HELPER_H_

data/lib/dub/lua/lua_object.cpp

@@ -0,0 +1,158 @@
+/*
+  ==============================================================================
+
+   This file is part of the LUBYK project (http://lubyk.org)
+   Copyright (c) 2007-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_object.h"
+#include "lua_cpp_helper.h"
+
+using namespace dub;
+
+LuaObject::LuaObject() throw () :
+  lua_(NULL) {
+}
+
+int LuaObject::lua_init(lua_State *L, const char *type_name) throw() {
+  // ... <self> or new table
+  setupSuper(L); // creates self if there is no table (without a 'super' field)
+  // ... <self>.super = userdata
+  // ... <self> <udata>
+
+  setupMetatable(L, type_name);
+  // ... <self> <udata>
+  
+  setupLuaThread(L);
+  // <self>
+  return 1;
+}
+
+void LuaObject::setupSuper(lua_State *L) throw() {
+  if (!lua_istable(L, -1)) {
+    lua_newtable(L);
+  }
+  // ... <self>
+  LuaObject **userdata = (LuaObject**)lua_newuserdata(L, sizeof(LuaObject*));
+  *userdata = this;
+  // ... <self> <udata>
+  lua_pushlstring(L, "super", 5);
+  // ... <self> <udata> <"super">
+  lua_pushvalue(L, -2);
+  // ... <self> <udata> <"super"> <udata>
+  lua_rawset(L, -4);
+  // self.super = udata
+  // ... <self> <udata>
+}
+
+void LuaObject::setupMetatable(lua_State *L, const char *type_name) throw() {
+  // set metatable
+  luaL_getmetatable(L, type_name);
+  // ... <self> <udata> <mt>
+  lua_pushvalue(L, -1);
+  // ... <self> <udata> <mt> <mt>
+  lua_setmetatable(L, -3);
+  // ... <self> <udata> <mt>
+  lua_setmetatable(L, -3);
+  // ... <self> <udata>
+}
+
+// dependency relationship:
+// self.super ---> udata ---> fenv ---> thread ---> self
+//
+//   Thanks to Robert G. Jakabosky for the idea to use lua_xmove
+//   instead of weak tables to store the function reference.
+void LuaObject::setupLuaThread(lua_State *L) throw() {
+  // ... <self> <udata>
+  lua_getfenv(L, -1);
+  // ... <self> <udata> <env>
+  lua_pushstring(L, ".");
+  // ... <self> <udata> <env> "."
+  lua_rawget(L, -2); // <env>["."]
+  // ... <self> <udata> <env> <??>
+  if (!lua_rawequal(L, -1, -3)) {
+    // ... <self> <udata> <env> <nil>
+    // does not have it's own env table
+    lua_pop(L, 2);
+    // ... <self> <udata>
+    // Create env table
+    lua_newtable(L);
+    // ... <self> <udata> <env>
+    lua_pushstring(L, ".");
+    // ... <self> <udata> <env> "."
+    lua_pushvalue(L, -3);
+    // ... <self> <udata> <env> "." <udata>
+    lua_rawset(L, -3); // env["."] = udata
+    // ... <self> <udata> <env>
+    lua_pushvalue(L, -1);
+    // ... <self> <udata> <env> <env>
+    if (!lua_setfenv(L, -3)) {
+      luaL_error(L, "Could not set userdata env on '%s'.", lua_typename(L, lua_type(L, -3)));
+    }
+    // ... <self> <udata> <env>
+  } else {
+    // ... <self> <udata> <env> <self>
+    // has its own env table
+    lua_pop(L, 1);
+    // ... <self> <udata> <env>
+  }
+
+  // ... <self> <udata> <env>
+  if (lua_) {
+    // remove from env
+    luaL_unref(L, -1, thread_in_env_idx_);
+  }
+
+  lua_ = lua_newthread(L);
+  // ... <self> <udata> <env> <thread>
+
+  // Store the thread in the Thread/Socket's environment table so it is not GC too soon
+  thread_in_env_idx_ = luaL_ref(L, -2);
+  // ... <self> <udata> <env>
+
+  lua_pop(L, 2);
+  // ... <self>
+
+  // Transfer copies of <self> to thread stack
+  lua_pushvalue(L, -1);
+  // ... <self> <self>
+  lua_xmove(L, lua_, 1);
+  // ... <self>
+
+  // lua_ stack is now
+  // <self>
+
+  // L is now
+  // <self>
+}
+
+void LuaObject::pushLuaCallback(const char *method, int len) const {
+  // <self>
+  lua_pushlstring(lua_, method, len);
+  // <self> <"method">
+  lua_gettable(lua_, -2);
+  // <self> <?>
+  lua_pushvalue(lua_, 1);
+  // <self> <?> <self>
+}

data/lib/dub/lua/lua_object.h

@@ -0,0 +1,69 @@
+/*
+  ==============================================================================
+
+   This file is part of the LUBYK project (http://lubyk.org)
+   Copyright (c) 2007-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.
+
+  ==============================================================================
+*/
+#ifndef INCLUDE_DUB_LUA_OBJECT_H_
+#define INCLUDE_DUB_LUA_OBJECT_H_
+
+namespace dub {
+/** Calls a lua function back.
+ */
+class LuaObject
+{
+public:
+  /** Prepare tables to work with the table based self idion.
+   * expects stack to be:
+   * ... self
+   * if self (last argument) is a table, it is used as self. 
+   * Otherwise, a new table is created.
+   * The method leaves "self" on top of the stack, with self.super = this.
+   */
+  LuaObject() throw();
+  
+  int lua_init(lua_State *L, const char *type_name) throw();
+
+  virtual ~LuaObject() {}
+
+  /** The caller should lock before calling this.
+   * TODO: The 'const' stuff is stupid: can't we remove it ?
+   */
+  void pushLuaCallback(const char *method, int len) const;
+
+  lua_State *lua_;
+
+private:
+
+  int thread_in_env_idx_;
+
+  void setupSuper(lua_State *L) throw();
+  void setupMetatable(lua_State *L, const char *type_name) throw() ;
+  void setupLuaThread(lua_State *L) throw();
+};
+
+} // dub
+
+#endif // INCLUDE_DUB_LUA_OBJECT_H_

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

@@ -0,0 +1,42 @@
+#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[] = {
+<% if @namespace.has_functions? %>
+<%= indent(functions_registration, 2) %>,
+<% end %>
+  {NULL, NULL},
+};
+
+<% if @namespace.has_constants? %>
+static const struct lua_constants_Reg <%= @namespace.name %>_namespace_constants[] = {
+<%= indent(constants_registration, 2) %>,
+  {NULL, NULL},
+};
+<% end %>
+
+#ifdef DUB_LUA_NO_OPEN
+int luaload_<%= @namespace.lib_name %>(lua_State *L) {
+#else
+extern "C" int luaopen_<%= @namespace.lib_name %>(lua_State *L) {
+#endif
+  // 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 %>
+  return 0;
+}

data/lib/dub/lua/namespace_gen.rb

@@ -0,0 +1,69 @@
+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)
+        all_members
+        #list = (all_members || []).map do |member_or_group|
+        #  if 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
+    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