dub 0.3.0 → 0.6.3

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,153 @@
+#ifndef DOXY_GENERATOR_TEST_FIXTURES_APP_MATRIX_H_
+#define DOXY_GENERATOR_TEST_FIXTURES_APP_MATRIX_H_
+
+#include <cstring>
+#include <stdlib.h> // malloc
+
+
+/** @file */
+
+namespace dub {
+
+class Matrix {
+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 use_other_lib(const std::string &name) {
+    // dummy
+  }
+
+  int *ptr() {
+    // dummy
+  }
+
+  /** Named constructor.
+   */
+  static Matrix *MakeMatrix(int rows, int cols) {
+    return new Matrix(rows, cols);
+  }
+
+private:
+
+  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_;
+};
+
+
+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)

data/test/fixtures/app/vendor/lua/HISTORY

@@ -0,0 +1,183 @@
+HISTORY for Lua 5.1
+
+* Changes from version 5.0 to 5.1
+  -------------------------------
+  Language:
+  + new module system.
+  + new semantics for control variables of fors.
+  + new semantics for setn/getn.
+  + new syntax/semantics for varargs.
+  + new long strings and comments.
+  + new `mod' operator (`%')
+  + new length operator #t
+  + metatables for all types
+  API:
+  + new functions: lua_createtable, lua_get(set)field, lua_push(to)integer.
+  + user supplies memory allocator (lua_open becomes lua_newstate).
+  + luaopen_* functions must be called through Lua.
+  Implementation:
+  + new configuration scheme via luaconf.h.
+  + incremental garbage collection.
+  + better handling of end-of-line in the lexer.
+  + fully reentrant parser (new Lua function `load')
+  + better support for 64-bit machines.
+  + native loadlib support for Mac OS X.
+  + standard distribution in only one library (lualib.a merged into lua.a)
+
+* Changes from version 4.0 to 5.0
+  -------------------------------
+  Language:
+  + lexical scoping.
+  + Lua coroutines.
+  + standard libraries now packaged in tables.
+  + tags replaced by metatables and tag methods replaced by metamethods,
+    stored in metatables.
+  + proper tail calls.
+  + each function can have its own global table, which can be shared.
+  + new __newindex metamethod, called when we insert a new key into a table.
+  + new block comments: --[[ ... ]].
+  + new generic for.
+  + new weak tables.
+  + new boolean type.
+  + new syntax "local function".
+  + (f()) returns the first value returned by f.
+  + {f()} fills a table with all values returned by f.
+  + \n ignored in [[\n .
+  + fixed and-or priorities.
+  + more general syntax for function definition (e.g. function a.x.y:f()...end).
+  + more general syntax for function calls (e.g. (print or write)(9)).
+  + new functions (time/date, tmpfile, unpack, require, load*, etc.).
+  API:
+  + chunks are loaded by using lua_load; new luaL_loadfile and luaL_loadbuffer.
+  + introduced lightweight userdata, a simple "void*" without a metatable.
+  + new error handling protocol: the core no longer prints error messages;
+    all errors are reported to the caller on the stack.
+  + new lua_atpanic for host cleanup.
+  + new, signal-safe, hook scheme.
+  Implementation:
+  + new license: MIT.
+  + new, faster, register-based virtual machine.
+  + support for external multithreading and coroutines.
+  + new and consistent error message format.
+  + the core no longer needs "stdio.h" for anything (except for a single
+    use of sprintf to convert numbers to strings).
+  + lua.c now runs the environment variable LUA_INIT, if present. It can
+    be "@filename", to run a file, or the chunk itself.
+  + support for user extensions in lua.c.
+    sample implementation given for command line editing.
+  + new dynamic loading library, active by default on several platforms.
+  + safe garbage-collector metamethods.
+  + precompiled bytecodes checked for integrity (secure binary dostring).
+  + strings are fully aligned.
+  + position capture in string.find.
+  + read('*l') can read lines with embedded zeros.
+
+* Changes from version 3.2 to 4.0
+  -------------------------------
+  Language:
+  + new "break" and "for" statements (both numerical and for tables).
+  + uniform treatment of globals: globals are now stored in a Lua table.
+  + improved error messages.
+  + no more '$debug': full speed *and* full debug information.
+  + new read form: read(N) for next N bytes.
+  + general read patterns now deprecated.
+    (still available with -DCOMPAT_READPATTERNS.)
+  + all return values are passed as arguments for the last function
+    (old semantics still available with -DLUA_COMPAT_ARGRET)
+  + garbage collection tag methods for tables now deprecated.
+  + there is now only one tag method for order.
+  API:
+  + New API: fully re-entrant, simpler, and more efficient.
+  + New debug API.
+  Implementation:
+  + faster than ever: cleaner virtual machine and new hashing algorithm.
+  + non-recursive garbage-collector algorithm.
+  + reduced memory usage for programs with many strings.
+  + improved treatment for memory allocation errors.
+  + improved support for 16-bit machines (we hope).
+  + code now compiles unmodified as both ANSI C and C++.
+  + numbers in bases other than 10 are converted using strtoul.
+  + new -f option in Lua to support #! scripts.
+  + luac can now combine text and binaries.
+
+* Changes from version 3.1 to 3.2
+  -------------------------------
+  + redirected all output in Lua's core to _ERRORMESSAGE and _ALERT.
+  + increased limit on the number of constants and globals per function
+    (from 2^16 to 2^24).
+  + debugging info (lua_debug and hooks) moved into lua_state and new API
+    functions provided to get and set this info.
+  + new debug lib gives full debugging access within Lua.
+  + new table functions "foreachi", "sort", "tinsert", "tremove", "getn".
+  + new io functions "flush", "seek".
+
+* Changes from version 3.0 to 3.1
+  -------------------------------
+  + NEW FEATURE: anonymous functions with closures (via "upvalues").
+  + new syntax:
+    - local variables in chunks.
+    - better scope control with DO block END.
+    - constructors can now be also written: { record-part; list-part }.
+    - more general syntax for function calls and lvalues, e.g.:
+      f(x).y=1
+      o:f(x,y):g(z)
+      f"string" is sugar for f("string")
+  + strings may now contain arbitrary binary data (e.g., embedded zeros).
+  + major code re-organization and clean-up; reduced module interdependecies.
+  + no arbitrary limits on the total number of constants and globals.
+  + support for multiple global contexts.
+  + better syntax error messages.
+  + new traversal functions "foreach" and "foreachvar".
+  + the default for numbers is now double.
+    changing it to use floats or longs is easy.
+  + complete debug information stored in pre-compiled chunks.
+  + sample interpreter now prompts user when run interactively, and also
+    handles control-C interruptions gracefully.
+
+* Changes from version 2.5 to 3.0
+  -------------------------------
+  + NEW CONCEPT: "tag methods".
+    Tag methods replace fallbacks as the meta-mechanism for extending the
+    semantics of Lua. Whereas fallbacks had a global nature, tag methods
+    work on objects having the same tag (e.g., groups of tables).
+    Existing code that uses fallbacks should work without change.
+  + new, general syntax for constructors {[exp] = exp, ... }.
+  + support for handling variable number of arguments in functions (varargs).
+  + support for conditional compilation ($if ... $else ... $end).
+  + cleaner semantics in API simplifies host code.
+  + better support for writing libraries (auxlib.h).
+  + better type checking and error messages in the standard library.
+  + luac can now also undump.
+
+* Changes from version 2.4 to 2.5
+  -------------------------------
+  + io and string libraries are now based on pattern matching;
+    the old libraries are still available for compatibility
+  + dofile and dostring can now return values (via return statement)
+  + better support for 16- and 64-bit machines
+  + expanded documentation, with more examples
+
+* Changes from version 2.2 to 2.4
+  -------------------------------
+  + external compiler creates portable binary files that can be loaded faster
+  + interface for debugging and profiling
+  + new "getglobal" fallback
+  + new functions for handling references to Lua objects
+  + new functions in standard lib
+  + only one copy of each string is stored
+  + expanded documentation, with more examples
+
+* Changes from version 2.1 to 2.2
+  -------------------------------
+  + functions now may be declared with any "lvalue" as a name
+  + garbage collection of functions
+  + support for pipes
+
+* Changes from version 1.1 to 2.1
+  -------------------------------
+  + object-oriented support
+  + fallbacks
+  + simplified syntax for tables
+  + many internal improvements
+
+(end of HISTORY)