dub 0.2.2 → 1.0.0

data/test/fixtures/app/bindings/all_lua.cpp

@@ -0,0 +1,299 @@
+#include "matrix.h"
+
+#include "lua_cpp_helper.h"
+
+
+using namespace dub;
+
+
+/* ============================ Constructors     ====================== */
+
+
+/** dub::Matrix::Matrix()
+ * app/include/matrix.h:14
+ */
+static int Matrix_Matrix1(lua_State *L) {
+  Matrix * retval__    = new Matrix();
+  lua_pushclass<Matrix>(L, retval__, "dub.Matrix");
+  return 1;
+}
+
+
+/** dub::Matrix::Matrix(int rows, int cols)
+ * app/include/matrix.h:16
+ */
+static int Matrix_Matrix2(lua_State *L) {
+  int rows             = luaL_checkint   (L, 1);
+  int cols             = luaL_checkint   (L, 2);
+  Matrix * retval__    = new Matrix(rows, cols);
+  lua_pushclass<Matrix>(L, retval__, "dub.Matrix");
+  return 1;
+}
+
+
+
+/** Overloaded function chooser for Matrix(...) */
+static int Matrix_Matrix(lua_State *L) {
+  int type__ = lua_type(L, 1);
+  if (type__ == LUA_TNUMBER) {
+    return Matrix_Matrix2(L);
+  } else if (type__ == LUA_TNONE) {
+    return Matrix_Matrix1(L);
+  } else {
+    // use any to raise errors
+    return Matrix_Matrix1(L);
+  }
+}
+
+/* ============================ Destructor       ====================== */
+
+static int Matrix_destructor(lua_State *L) {
+  Matrix **userdata = (Matrix**)luaL_checkudata(L, 1, "dub.Matrix");
+  if (*userdata) delete *userdata;
+  *userdata = NULL;
+  return 0;
+}
+
+/* ============================ tostring         ====================== */
+
+static int Matrix__tostring(lua_State *L) {
+  Matrix **userdata = (Matrix**)luaL_checkudata(L, 1, "dub.Matrix");
+  lua_pushfstring(L, "dub.Matrix: %p", *userdata);
+  return 1;
+}
+
+/* ============================ Member Methods   ====================== */
+
+
+/** double dub::Matrix::cols()
+ * app/include/matrix.h:29
+ */
+static int Matrix_cols(lua_State *L) {
+  Matrix *self__       = *((Matrix**)luaL_checkudata(L, 1, "dub.Matrix"));
+  lua_remove(L, 1);
+  double retval__      = self__->cols();
+  lua_pushnumber(L, retval__);
+  return 1;
+}
+
+
+/** double dub::Matrix::rows()
+ * app/include/matrix.h:33
+ */
+static int Matrix_rows(lua_State *L) {
+  Matrix *self__       = *((Matrix**)luaL_checkudata(L, 1, "dub.Matrix"));
+  lua_remove(L, 1);
+  double retval__      = self__->rows();
+  lua_pushnumber(L, retval__);
+  return 1;
+}
+
+
+/** size_t dub::Matrix::size()
+ * app/include/matrix.h:25
+ */
+static int Matrix_size(lua_State *L) {
+  Matrix *self__       = *((Matrix**)luaL_checkudata(L, 1, "dub.Matrix"));
+  lua_remove(L, 1);
+  size_t retval__      = self__->size();
+  lua_pushnumber(L, retval__);
+  return 1;
+}
+
+
+
+
+/* ============================ Lua Registration ====================== */
+
+static const struct luaL_Reg Matrix_member_methods[] = {
+  {"cols"              , Matrix_cols},
+  {"rows"              , Matrix_rows},
+  {"size"              , Matrix_size},
+  {"__tostring"        , Matrix__tostring},
+  {"__gc"              , Matrix_destructor},
+  {NULL, NULL},
+};
+
+static const struct luaL_Reg Matrix_namespace_methods[] = {
+  {"Matrix"            , Matrix_Matrix},
+  {NULL, NULL},
+};
+
+static void luaopen_dub_Matrix(lua_State *L) {
+  // Create the metatable which will contain all the member methods
+  luaL_newmetatable(L, "dub.Matrix"); // "dub.Matrix"
+
+  // metatable.__index = metatable (find methods in the table itself)
+  lua_pushvalue(L, -1);
+  lua_setfield(L, -2, "__index");
+
+  // register member methods
+  luaL_register(L, NULL, Matrix_member_methods);  // dub_Matrix_member_methods
+
+  // register class methods in a global table like "dub.Matrix"
+  luaL_register(L, "dub", Matrix_namespace_methods); // dub_Matrix_class_methods
+}
+#include "matrix.h"
+
+#include "lua_cpp_helper.h"
+
+
+using namespace dub;
+
+
+/* ============================ Constructors     ====================== */
+
+
+/** dub::FloatMat::FloatMat()
+ * app/include/matrix.h:62
+ */
+static int FloatMat_FloatMat1(lua_State *L) {
+  FloatMat * retval__  = new FloatMat();
+  lua_pushclass<FloatMat>(L, retval__, "dub.FloatMat");
+  return 1;
+}
+
+
+/** dub::FloatMat::FloatMat(int rows, int cols)
+ * app/include/matrix.h:64
+ */
+static int FloatMat_FloatMat2(lua_State *L) {
+  int rows             = luaL_checkint   (L, 1);
+  int cols             = luaL_checkint   (L, 2);
+  FloatMat * retval__  = new FloatMat(rows, cols);
+  lua_pushclass<FloatMat>(L, retval__, "dub.FloatMat");
+  return 1;
+}
+
+
+
+/** Overloaded function chooser for FloatMat(...) */
+static int FloatMat_FloatMat(lua_State *L) {
+  int type__ = lua_type(L, 1);
+  if (type__ == LUA_TNUMBER) {
+    return FloatMat_FloatMat2(L);
+  } else if (type__ == LUA_TNONE) {
+    return FloatMat_FloatMat1(L);
+  } else {
+    // use any to raise errors
+    return FloatMat_FloatMat1(L);
+  }
+}
+
+/* ============================ Destructor       ====================== */
+
+static int FloatMat_destructor(lua_State *L) {
+  FloatMat **userdata = (FloatMat**)luaL_checkudata(L, 1, "dub.FloatMat");
+  if (*userdata) delete *userdata;
+  *userdata = NULL;
+  return 0;
+}
+
+/* ============================ tostring         ====================== */
+
+static int FloatMat__tostring(lua_State *L) {
+  FloatMat **userdata = (FloatMat**)luaL_checkudata(L, 1, "dub.FloatMat");
+  lua_pushfstring(L, "dub.FloatMat: %p", *userdata);
+  return 1;
+}
+
+/* ============================ Member Methods   ====================== */
+
+
+/** size_t dub::FloatMat::cols()
+ * app/include/matrix.h:77
+ */
+static int FloatMat_cols(lua_State *L) {
+  FloatMat *self__     = *((FloatMat**)luaL_checkudata(L, 1, "dub.FloatMat"));
+  lua_remove(L, 1);
+  size_t retval__      = self__->cols();
+  lua_pushnumber(L, retval__);
+  return 1;
+}
+
+
+/** void dub::FloatMat::fill(T value)
+ * app/include/matrix.h:85
+ */
+static int FloatMat_fill(lua_State *L) {
+  FloatMat *self__     = *((FloatMat**)luaL_checkudata(L, 1, "dub.FloatMat"));
+  lua_remove(L, 1);
+  float value          = luaL_checknumber(L, 1);
+  self__->fill(value);
+  return 0;
+}
+
+
+/** T dub::FloatMat::get(size_t row, size_t col)
+ * app/include/matrix.h:89
+ */
+static int FloatMat_get(lua_State *L) {
+  FloatMat *self__     = *((FloatMat**)luaL_checkudata(L, 1, "dub.FloatMat"));
+  lua_remove(L, 1);
+  size_t row           = luaL_checknumber(L, 1);
+  size_t col           = luaL_checknumber(L, 2);
+  float retval__       = self__->get(row, col);
+  lua_pushnumber(L, retval__);
+  return 1;
+}
+
+
+/** size_t dub::FloatMat::rows()
+ * app/include/matrix.h:81
+ */
+static int FloatMat_rows(lua_State *L) {
+  FloatMat *self__     = *((FloatMat**)luaL_checkudata(L, 1, "dub.FloatMat"));
+  lua_remove(L, 1);
+  size_t retval__      = self__->rows();
+  lua_pushnumber(L, retval__);
+  return 1;
+}
+
+
+/** size_t dub::FloatMat::size()
+ * app/include/matrix.h:73
+ */
+static int FloatMat_size(lua_State *L) {
+  FloatMat *self__     = *((FloatMat**)luaL_checkudata(L, 1, "dub.FloatMat"));
+  lua_remove(L, 1);
+  size_t retval__      = self__->size();
+  lua_pushnumber(L, retval__);
+  return 1;
+}
+
+
+
+
+/* ============================ Lua Registration ====================== */
+
+static const struct luaL_Reg FloatMat_member_methods[] = {
+  {"cols"              , FloatMat_cols},
+  {"fill"              , FloatMat_fill},
+  {"get"               , FloatMat_get},
+  {"rows"              , FloatMat_rows},
+  {"size"              , FloatMat_size},
+  {"__tostring"        , FloatMat__tostring},
+  {"__gc"              , FloatMat_destructor},
+  {NULL, NULL},
+};
+
+static const struct luaL_Reg FloatMat_namespace_methods[] = {
+  {"FloatMat"          , FloatMat_FloatMat},
+  {"FMatrix"           , FloatMat_FloatMat},
+  {NULL, NULL},
+};
+
+static void luaopen_dub_FloatMat(lua_State *L) {
+  // Create the metatable which will contain all the member methods
+  luaL_newmetatable(L, "dub.FloatMat"); // "dub.Matrix"
+
+  // metatable.__index = metatable (find methods in the table itself)
+  lua_pushvalue(L, -1);
+  lua_setfield(L, -2, "__index");
+
+  // register member methods
+  luaL_register(L, NULL, FloatMat_member_methods);  // dub_Matrix_member_methods
+
+  // register class methods in a global table like "dub.Matrix"
+  luaL_register(L, "dub", FloatMat_namespace_methods); // dub_Matrix_class_methods
+}

data/test/fixtures/app/include/matrix.h

@@ -0,0 +1,283 @@
+#ifndef DOXY_GENERATOR_TEST_FIXTURES_APP_MATRIX_H_
+#define DOXY_GENERATOR_TEST_FIXTURES_APP_MATRIX_H_
+
+#include <cstring>
+#include <stdlib.h> // malloc
+
+
+/** @file */
+typedef int LuaStackSize;
+
+namespace dub {
+
+/** Matrix class.
+ *
+ * @dub var_from_dub:'dummy value'
+ *      other_from_dub: "some other value"
+ *      ignore: 'bad_method'
+ */
+class Matrix {
+
+  Q_PROPERTY(size_t foo_prop READ size)
+  Q_PROPERTY(size_t size READ size WRITE setSize)
+public:
+  Matrix() : data_(NULL), rows_(0), cols_(0) {}
+
+  Matrix(int rows, int cols) : rows_(rows), cols_(cols) {
+    data_ = (double*)malloc(size() * sizeof(double));
+  }
+
+  ~Matrix() {
+    if (data_) free(data_);
+  }
+
+  /** Return size of matrix (rows * cols). */
+  size_t size() {
+    return rows_ * cols_;
+  }
+
+  double cols() {
+    return cols_;
+  }
+
+  double rows() {
+    return rows_;
+  }
+
+  /** Dummy template based class method.
+   */
+  template<class T>
+  T *give_me_tea() {
+    return new T();
+  }
+
+  operator size_t() {
+    return size();
+  }
+
+  void mul(TMat<int> other) {
+    // dummy
+  }
+
+  void do_something(int i, bool fast=false) {
+
+  }
+
+  void do_something(int i, const char *baz) {
+    // overloaded member method
+  }
+
+  void bad_method(int i) {
+    // method should not exist in bindings
+  }
+
+  void use_other_lib(const std::string &name) {
+    // dummy
+  }
+
+  int *ptr() {
+    // dummy
+  }
+
+  bool true() {
+    // dummy
+    return true;
+  }
+
+  const char *name() {
+    // should make method return string
+  }
+
+  int *lua_thing(int a, lua_State *L, int b) {
+    // dummy
+  }
+
+  LuaStackSize work_with_lua(int a, int b) {
+    // method that directly pushes lua values on the stack
+    return 2;
+  }
+
+  /** Named constructor.
+   */
+  static Matrix *MakeMatrix(int rows, int cols) {
+    return new Matrix(rows, cols);
+  }
+
+private:
+  Matrix(int x) {
+    // private constructor
+  }
+
+  int private_method() {
+    // should not be implemented
+    return 0;
+  }
+
+protected:
+
+  int protected_method() {
+    // should not be implemented
+    return 0;
+  }
+
+  double *data_;
+  size_t rows_;
+  size_t cols_;
+};
+
+
+/** Test that private constructors are not used.
+ */
+class PrivateConstr {
+public:
+
+  PrivateConstr(int x) {}
+
+  ~PrivateConstr() {}
+
+private:
+  // should not be used to build a FunctionGroup
+  PrivateConstr(const char *name) {}
+};
+
+/** Test that custom destructors are used.
+ * @dub destructor: 'dub_destroy'
+ */
+class CustomDestructor : public DeletableOutOfLua
+{
+public:
+
+  CustomDestructor(int x) {}
+
+  ~CustomDestructor() {}
+
+  void do_this(int x) {
+
+  }
+};
+
+/** Test that no destructor option is used.
+ *
+ * @dub destructor: ''
+ */
+class NoDestructor {
+public:
+
+  NoDestructor(int x) {}
+
+  ~NoDestructor() {}
+};
+
+/** Test that we can use a static constructor.
+ * @dub constructor: 'MakeStaticConstr'
+ */
+class StaticConstr {
+public:
+
+  StaticConstr(int x) {}
+
+  ~StaticConstr() {}
+
+  // We usually want to push the userdata ourself in
+  // such cases.
+  static LuaStackSize MakeStaticConstr(lua_State *L) {
+    return 0; // fake error (nil return)
+  }
+};
+
+// class inheritence tests
+class Base {
+public:
+  Base() {}
+  ~Base() {}
+
+  const char *method_in_base(int x, float y) {
+    return "nothing";
+  }
+};
+
+// class inheritence tests
+class SubBase : public Base {
+public:
+  SubBase() {}
+  ~SubBase() {}
+
+  void method_in_sub(float y) {
+    return "nothing";
+  }
+};
+
+// class inheritence tests
+class PrivSubBase : private Base {
+public:
+  SubBase() {}
+  ~SubBase() {}
+
+  void method_in_sub(float y) {
+    return "nothing";
+  }
+};
+template<class T>
+class TMat {
+public:
+  TMat() : data_(NULL), rows_(0), cols_(0) {}
+
+  TMat(int rows, int cols) : rows_(rows), cols_(cols) {
+    data_ = (T*)malloc(size() * sizeof(T));
+  }
+
+  // test constructor with T parameter
+  TMat(T dummy) {
+
+  }
+
+  ~TMat() {
+    if (data_) free(data_);
+  }
+
+  /** Dummy template based class method.
+   */
+  template<class T2>
+  T2 *give_me_tea() {
+    return new T2();
+  }
+
+  /** Return size of matrix (rows * cols). */
+  size_t size() {
+    return rows_ * cols_;
+  }
+
+  size_t cols() {
+    return cols_;
+  }
+
+  size_t rows() {
+    return rows_;
+  }
+
+  void fill(T value) {
+    // dummy
+  }
+
+  void FunkyThing(double v[7]) {
+
+  }
+
+  T get(size_t row, size_t col) {
+    return data_[row * cols_ + col];
+  }
+
+private:
+  T *data_;
+  size_t rows_;
+  size_t cols_;
+};
+
+/** @var FloatMat
+ */
+typedef TMat<float> FloatMat;
+typedef FloatMat FMatrix;
+
+} // dub
+
+#endif // DOXY_GENERATOR_TEST_FIXTURES_APP_MATRIX_H_

data/test/fixtures/app/make_lua_bindings.rb

@@ -0,0 +1,13 @@
+require 'dub'
+require 'dub/lua'
+require 'pathname'
+
+dub = Dub.parse(Pathname(__FILE__).dirname + 'xml/namespacedub.xml')[:dub]
+
+Dub::Lua.bind(dub)
+
+File.open(Pathname(__FILE__).dirname + "bindings/all_lua.cpp", 'wb') do |f|
+  %w{Matrix FloatMat}.each do |name|
+    f.puts dub[name]
+  end
+end

data/test/fixtures/app/vendor/lua/CMakeLists.txt

@@ -0,0 +1,25 @@
+# ----------------------------------------------------------------------------
+#  CMake file for Lua. See root CMakeLists.txt
+#
+# ----------------------------------------------------------------------------
+project(lua)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+# ----------------------------------------------------------------------------------
+# 				Define the library target:
+# ----------------------------------------------------------------------------------
+
+set(the_target "lua")
+
+file(GLOB lib_srcs *.c)
+list (REMOVE_ITEM lib_srcs ${CMAKE_CURRENT_SOURCE_DIR}/lua.c ${CMAKE_CURRENT_SOURCE_DIR}/luac.c)
+file(GLOB lib_hdrs *.h)
+set(lib_ext_hdrs)
+
+add_library(${the_target} STATIC ${lib_srcs} ${lib_hdrs} ${lib_ext_hdrs})
+
+set_target_properties(${the_target}
+	PROPERTIES OUTPUT_NAME "${the_target}"
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/vendor_lib
+	)

data/test/fixtures/app/vendor/lua/COPYRIGHT

@@ -0,0 +1,34 @@
+Lua License
+-----------
+
+Lua is licensed under the terms of the MIT license reproduced below.
+This means that Lua is free software and can be used for both academic
+and commercial purposes at absolutely no cost.
+
+For details and rationale, see http://www.lua.org/license.html .
+
+===============================================================================
+
+Copyright (C) 1994-2007 Lua.org, PUC-Rio.
+
+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.
+
+===============================================================================
+
+(end of COPYRIGHT)