Llewellyn/conky
1
0
Fork 0
mirror of https://github.com/Llewellynvdm/conky.git synced 2024-11-15 17:47:09 +00:00
Code Issues Releases Activity

Add toluapp subtree (#712)

Browse Source 
* First commit!

* Import to git

* Droping down CMake requirement

* Corrected installation of libraries

* Adding travis build

* Updated cmake macros

* Fixed find package

* Updated travis hook

* Updated travis hook

* Patch to support Lua 5.3.

* Fix Lua header include directives in tolua++.h

Use angle bracket rather than double quotes when including Lua headers in the tolua++ header. This fixes a problem on systems that default to a Lua version newer than 5.1 and install the tolua++ header to the same directory as newer Lua headers.

As there are (usually) no Lua headers in the same directory when building tolua++ itself, the preprocessor will look to the include directories passed to the compiler, one of which would be the Lua 5.1 include directory, and tolua++ will build with those (correct) headers. Then the tolua++ header is usually installed in the default include directory, alongside the newer Lua headers, which you wouldn't expect to cause any trouble.

But it does cause trouble when trying to build other programs that include the tolua++ header, because now the preprocessor does find Lua headers in the same directory as the tolua++ header, which are the newer (incorrect) headers. Now the program will either fail to compile, because it doesn't support the newer headers, or fail to link with the tolua++ shared object because they were compiled against different Lua headers.

Using angle brackets instead of double quotes in the include directives will fix the problem, because then the preprocessor will look to the include directories passed to the compiler first.

See http://www.cegui.org.uk/forum/viewtopic.php?f=10&t=7195

* Remove email notifications.

* Update travis build.

* Build shared and static libs.

* Patch toluapp to support Lua 5.3.

With this change, support for Lua 5.1 is dropped.

This resolve #116.

* Add some comments to clarify the toluapp handling.

* Add minor sonar fix.
This commit is contained in:
Brenden Matthews 2018-12-20 15:18:51 -05:00 committed by GitHub
parent 3a3092902e
commit bb8723dd36
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
131 changed files with 31223 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
.travis.yml
View File

@ -17,8 +17,7 @@ matrix:
- libglib2.0-dev
- libxml2-dev
- libcurl4-gnutls-dev
- liblua5.1-0-dev
- libtolua++5.1-dev
- liblua5.3-dev
- libcairo2-dev
- libimlib2-dev
- libxinerama-dev
@ -28,7 +27,6 @@ matrix:
- libcairo2-dev
- libmicrohttpd-dev
- ncurses-dev
- liblua5.1-dev
- librsvg2-dev
- libaudclient-dev
- libxmmsclient-dev
@ -37,7 +35,6 @@ matrix:
- audacious-dev
- libsystemd-dev
- libxml2-dev
- tolua++
- gawk
env:
- MATRIX_EVAL="CC=gcc-5 && CXX=g++-5"
@ -57,8 +54,7 @@ matrix:
- libglib2.0-dev
- libxml2-dev
- libcurl4-gnutls-dev
- liblua5.1-0-dev
- libtolua++5.1-dev
- liblua5.3-dev
- libcairo2-dev
- libimlib2-dev
- libxinerama-dev
@ -68,7 +64,6 @@ matrix:
- libcairo2-dev
- libmicrohttpd-dev
- ncurses-dev
- liblua5.1-dev
- librsvg2-dev
- libaudclient-dev
- libxmmsclient-dev
@ -77,7 +72,6 @@ matrix:
- audacious-dev
- libsystemd-dev
- libxml2-dev
- tolua++
- gawk
env:
- MATRIX_EVAL="CC=gcc-6 && CXX=g++-6"
@ -97,8 +91,7 @@ matrix:
- libglib2.0-dev
- libxml2-dev
- libcurl4-gnutls-dev
- liblua5.1-0-dev
- libtolua++5.1-dev
- liblua5.3-dev
- libcairo2-dev
- libimlib2-dev
- libxinerama-dev
@ -108,7 +101,6 @@ matrix:
- libcairo2-dev
- libmicrohttpd-dev
- ncurses-dev
- liblua5.1-dev
- librsvg2-dev
- libaudclient-dev
- libxmmsclient-dev
@ -117,7 +109,6 @@ matrix:
- audacious-dev
- libsystemd-dev
- libxml2-dev
- tolua++
- gawk
env:
- MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
@ -137,8 +128,7 @@ matrix:
- libglib2.0-dev
- libxml2-dev
- libcurl4-gnutls-dev
- liblua5.1-0-dev
- libtolua++5.1-dev
- liblua5.3-dev
- libcairo2-dev
- libimlib2-dev
- libxinerama-dev
@ -148,7 +138,6 @@ matrix:
- libcairo2-dev
- libmicrohttpd-dev
- ncurses-dev
- liblua5.1-dev
- librsvg2-dev
- libaudclient-dev
- libxmmsclient-dev
@ -157,7 +146,6 @@ matrix:
- audacious-dev
- libsystemd-dev
- libxml2-dev
- tolua++
- gawk
env:
- MATRIX_EVAL="CC=gcc-8 && CXX=g++-8"
@ -177,8 +165,7 @@ matrix:
- libglib2.0-dev
- libxml2-dev
- libcurl4-gnutls-dev
- liblua5.1-0-dev
- libtolua++5.1-dev
- liblua5.3-dev
- libcairo2-dev
- libimlib2-dev
- libxinerama-dev
@ -188,7 +175,6 @@ matrix:
- libcairo2-dev
- libmicrohttpd-dev
- ncurses-dev
- liblua5.1-dev
- librsvg2-dev
- libaudclient-dev
- libxmmsclient-dev
@ -197,7 +183,6 @@ matrix:
- audacious-dev
- libsystemd-dev
- libxml2-dev
- tolua++
- gawk
env:
- MATRIX_EVAL="CC=clang-6.0 && CXX=clang++-6.0"
@ -218,8 +203,7 @@ matrix:
- libglib2.0-dev
- libxml2-dev
- libcurl4-gnutls-dev
- liblua5.1-0-dev
- libtolua++5.1-dev
- liblua5.3-dev
- libcairo2-dev
- libimlib2-dev
- libxinerama-dev
@ -229,7 +213,6 @@ matrix:
- libcairo2-dev
- libmicrohttpd-dev
- ncurses-dev
- liblua5.1-dev
- librsvg2-dev
- libaudclient-dev
- libxmmsclient-dev
@ -238,7 +221,6 @@ matrix:
- audacious-dev
- libsystemd-dev
- libxml2-dev
- tolua++
- gawk
sonarcloud:
organization: "brndnmtthws-github"
@ -256,8 +238,7 @@ before_install:
- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then eval "${MATRIX_EVAL}" ; fi
- |
if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
brew update;
brew install freetype gettext lua imlib2 ccache;
HOMEBREW_NO_AUTO_UPDATE=1 brew install freetype gettext lua imlib2 librsvg ccache;
export PATH="/usr/local/opt/ccache/libexec:$PATH";
fi
- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew link gettext --force ; fi
@ -269,7 +250,6 @@ before_script:
cmake \
-DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-DBUILD_MYSQL=ON \
-DBUILD_LUA_CAIRO=ON \
-DBUILD_LUA_IMLIB2=ON \
-DBUILD_LUA_RSVG=ON \
-DBUILD_LUA_CAIRO=ON \
@ -294,7 +274,6 @@ before_script:
-DBUILD_LUA_CAIRO=ON \
-DBUILD_LUA_IMLIB2=ON \
-DBUILD_LUA_RSVG=ON \
-DBUILD_LUA_CAIRO=ON \
-DBUILD_AUDACIOUS=ON \
-DBUILD_XMMS2=ON \
-DBUILD_ICAL=ON \
@ -310,14 +289,18 @@ before_script:
mkdir build && cd build
cmake \
-DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-DBUILD_LUA_RSVG=ON \
-DBUILD_LUA_IMLIB2=ON \
..
cd ..
mkdir build-no-x11
cd build-no-x11
cmake \
-DBUILD_X11=OFF \
-DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-DBUILD_X11=OFF \
-DBUILD_LUA_RSVG=ON \
-DBUILD_LUA_IMLIB2=ON \
..
cd ..
fi

100
3rdparty/toluapp/.travis.yml vendored Normal file
View File

@ -0,0 +1,100 @@
language: cpp
cache: ccache
dist: xenial
matrix:
include:
- os: linux
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-5
- liblua5.3-dev
env:
- MATRIX_EVAL="CC=gcc-5 && CXX=g++-5"
- os: linux
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-6
- liblua5.3-dev
env:
- MATRIX_EVAL="CC=gcc-6 && CXX=g++-6"
- os: linux
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-7
- liblua5.3-dev
env:
- MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
- os: linux
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-8
- liblua5.3-dev
env:
- MATRIX_EVAL="CC=gcc-8 && CXX=g++-8"
- os: linux
addons:
apt:
sources:
- llvm-toolchain-xenial-6.0
packages:
- clang-6.0
- liblua5.3-dev
env:
- MATRIX_EVAL="CC=clang-6.0 && CXX=clang++-6.0"
- os: linux
addons:
apt:
sources:
- llvm-toolchain-xenial-7
packages:
- clang-7
- liblua5.3-dev
env:
- MATRIX_EVAL="CC=clang-7 && CXX=clang++-7"
- os: osx
osx_image: xcode9.4
- os: osx
osx_image: xcode10
- os: osx
osx_image: xcode10.1
before_install:
- |
if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
brew update;
brew install lua ccache;
export PATH="/usr/local/opt/ccache/libexec:$PATH";
fi
- eval "${MATRIX_EVAL}"
# Combine global build options with OS/compiler-dependent options
- export CMAKE_OPTIONS="${CMAKE_OPTIONS} ${ENV_CMAKE_OPTIONS} -DCMAKE_CXX_COMPILER_LAUNCHER=ccache"
- export CXX_FLAGS="${CXX_FLAGS} ${ENV_CXX_FLAGS}"
install:
- echo ${PATH}
- echo ${CXX}
- ${CXX} --version
- ${CXX} -v
script:
- mkdir -p build
- cd build
- cmake ${CMAKE_OPTIONS} -DCMAKE_CXX_FLAGS=${CXX_FLAGS} ..
- make -j4
# Only watch the master branch
branches:
only:
- master

42
3rdparty/toluapp/CMakeLists.txt vendored Normal file
View File

@ -0,0 +1,42 @@
# Copyright (C) 2007-2012 LuaDist.
# Created by Peter Kapec
# Redistribution and use of this file is allowed according to the terms of the MIT license.
# For details see the COPYRIGHT file distributed with LuaDist.
# Please note that the package source code is licensed under its own license.
project ( toluapp C )
cmake_minimum_required ( VERSION 3.4 )
# Disable dist stuff, we're not installing this as a lib
# include ( cmake/dist.cmake )
include(FindPkgConfig)
pkg_search_module(LUA REQUIRED lua>=5.3 lua5.3 lua-5.3 lua53 lua5.2 lua-5.2 lua52 luajit)
include_directories ( include src/lib ${LUA_INCLUDE_DIRS} )
# Build lib
file ( GLOB SRC_LIBTOLUAPP src/lib/*.c )
if ( MSVC )
set ( DEF_FILE libtoluapp.def )
endif ( )
# add_library ( toluapp_lib SHARED ${SRC_LIBTOLUAPP} ${DEF_FILE} )
add_library ( toluapp_lib_static STATIC ${SRC_LIBTOLUAPP} ${DEF_FILE} )
target_link_libraries ( toluapp_lib_static ${LUA_LIBRARIES} )
set_target_properties ( toluapp_lib_static PROPERTIES COMPILE_FLAGS -fPIC) # -fPIC required for static linking
set_target_properties ( toluapp_lib_static PROPERTIES OUTPUT_NAME toluapp CLEAN_DIRECT_OUTPUT
1 )
# Build app
include_directories ( src/bin )
set ( SRC_TOLUA src/bin/tolua.c src/bin/toluabind.c )
add_executable ( toluapp ${SRC_TOLUA} )
target_link_libraries ( toluapp toluapp_lib_static ${LUA_LIBRARIES} )
# Disable installation, we don't need these at runtime for Conky
# Install
#install_library ( toluapp_lib )
#install_executable ( toluapp )
#install_header ( include/ )
#install_data ( README INSTALL )
#install_doc ( doc/ )

33
3rdparty/toluapp/COPYRIGHT vendored Normal file
View File

@ -0,0 +1,33 @@
tolua++ License
---------------
tolua++ is based on toLua (www.tecgraf.puc-rio.br/~celes/tolua), and
it's 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.
===============================================================================
Copyright (C) 2009 Ariel Manzur.
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)

42
3rdparty/toluapp/INSTALL vendored Normal file
View File

@ -0,0 +1,42 @@
This version of tolua++ uses SCons to compile (http://www.scons.org). SCons uses
pythin. If you don't want to install python, check "Installation without scons"
below.
* Installation
1. Edit the "config" file for your platform to suit your environment,
if at all necessary (for cygwin, mingw, BSD and mac OSX use
'config_posix')
2. Then, type "scons".
You can use 'scons -h' to see a list of available command line options.
* What you get
If "scons" succeeds, you get:
* an executable to generate binding code in ./bin;
* the C library to be linked in your application in ./lib;
* the include file needed to compile your application in ./include.
These are the only directories you need for development, besides Lua.
You can use 'scons install' to install the files, see the 'prefix' option.
* Installation without scons
The instructions for building tolua++ without scons depend on the particular
compiler you are using.
The simplest way is to create a folder with all .c and .h files except
'toluabind_default.c', and then create a project for the executable and the
library, as follows:
tolua.exe: all *.c *.h in src/bin (except toluabind_default.c)
tolua.lib: all *.c *.h in src/lib.
* Installation with Microsoft Visual Studio
The directory 'win32' contains project files for Microsoft Visual Studio 7
(contributed by Makoto Hamanaka). The project has 4 different build options:
withLua50_Release, withLua51_Release, withLua50_Debug and withLua51_Debug.
They all expect the lua library names used by the LuaBinaries packages
(http://luabinaries.luaforge.net/). The resulting files are built on /lib and
/bin (for the library and tolua++.exe).

5
3rdparty/toluapp/Makefile vendored Normal file
View File

@ -0,0 +1,5 @@
# makefile for tolua hierarchy
all:
@echo "Makefile is deprecated ;)"
@echo "see INSTALL for details on how to build tolua++"

30
3rdparty/toluapp/README vendored Normal file
View File

@ -0,0 +1,30 @@
This is tolua++-1.0
* What is tolua++?
tolua++ is an extension of toLua, a tool to integrate C/C++ code with
Lua. tolua++ includes new features oriented to c++, such as class
templates.
tolua is a tool that greatly simplifies the integration of C/C++ code
with Lua. Based on a "cleaned" header file, tolua automatically generates
the binding code to access C/C++ features from Lua. Using Lua-5.0 API and
metamethod facilities, the current version automatically maps C/C++
constants, external variables, functions, namespace, classes, and methods
to Lua. It also provides facilities to create Lua modules.
* Availability
tolua++ is freely available for both academic and commercial purposes.
See COPYRIGHT for details.
tolua++ can be downloaded from the sites below:
http://www.codenix.com/~tolua/
* Installation
See INSTALL.
* Contacting the author
tolua has been designed and implemented by Waldemar Celes.
tolua++ is maintained by Ariel Manzur.
Send your comments, bug reports and anything else to
tolua@codenix.com

50
3rdparty/toluapp/README-5.1 vendored Executable file
View File

@ -0,0 +1,50 @@
Compiling for lua 5.1
---------------------
Starting from version 1.0.8pre1, tolua++ can be compiled with both lua 5.0 and
5.1. Both versions will output the same code, and the C API (tolua++.h) is the
same.
The build system is not yet ready to detect/decide when to compile for 5.1,
the easiest way right now is to add a file called 'custom.py' on the root of
the package, with the following:
## BEGIN custom.py
CCFLAGS = ['-I/usr/local/include/lua5.1', '-O2', '-ansi']
LIBPATH = ['/usr/local/lib']
LIBS = ['lua5.1', 'dl', 'm']
tolua_bin = 'tolua++5.1'
tolua_lib = 'tolua++5.1'
TOLUAPP = 'tolua++5.1'
## END custom.py
This will build the binary as 'tolua++5.1' and the library as 'libtolua++5.1.a'
(taken from tolua_bin and tolua_lib), and take the lua headers and libraries
from /usr/local/include/lua5.1 and /usr/local/lib. It will also link with
'-llua5.1'. Modify the parameters acording to your system.
Compatibility
-------------
There are a couple of things to keep in mind when running code inside tolua
using the -L option:
* `...' and arg: you can still use 'arg' on 5.1, this is done automatically by
adding the 'arg' declaration to functions on files loaded with dofile.
For example, the line:
function foo( ... )
becomes
function foo( ... ) local arg = {n=select('#', ...), ...};
This lets you use the same code on both versions without having to make any
modifications.
* keep in mind that there are slight differences on the way string.gsub works,
and the original version of the function is always kept, so it will behave
diffently depending on which version of lua you're using.

182
3rdparty/toluapp/SConstruct vendored Normal file
View File

@ -0,0 +1,182 @@
import sys;
import os
tools = ['default']
if os.name == 'nt':
tools = ['mingw']
env = Environment(tools = tools)
options_file = None
if sys.platform == 'linux2':
options_file = "linux"
elif 'msvc' in env['TOOLS']:
options_file = "msvc"
else:
options_file = "posix"
opts = Options(["config_"+options_file+".py", "custom.py", "custom_"+options_file+".py"], ARGUMENTS)
opts.Add('CC', 'The C compiler.')
opts.Add('CXX', 'The C++ compiler (for the tests)')
opts.Add('CCFLAGS', 'Flags for the compiler.', ['-O2', '-Wall'])
opts.Add('LINK', 'The linker.')
opts.Add('LINKFLAGS', 'Linker flags.', [])
opts.Add('no_cygwin', 'Use -mno-cygwin to build using the mingw compiler on cygwin', 0)
opts.Add('LIBS', 'libraries', [])
opts.Add('LIBPATH', 'library path', [])
opts.Add('tolua_bin', 'the resulting binary', 'tolua++')
opts.Add('tolua_lib', 'the resulting library', 'tolua++')
opts.Add('TOLUAPP', 'the name of the tolua++ binary (to use with built_dev=1)', 'tolua++')
opts.Add('prefix', 'The installation prefix')
opts.Add('build_dev', 'Build for development (uses tolua to rebuild toluabind.c with the embeded scripts', 0)
opts.Add('build_failsafe', "Build using 'factory default' toluabind file (in case build_dev fails)", 0)
opts.Add('ENV', 'The environment variables')
opts.Add('shared', 'Build a shared object', False)
opts.Update(env)
Help(opts.GenerateHelpText(env))
def save_config(target, source, env):
opts.Save('custom.py', env)
cust = env.Command('custom.py', [], save_config)
env.Alias('configure', [cust])
env['TOLUAPP_BOOTSTRAP'] = env['tolua_bin']+"_bootstrap"+env['PROGSUFFIX']
env['build_dev'] = int(env['build_dev'])
## detecting the install directory on win32
if 'msvc' in env['TOOLS'] and not (env.has_key('prefix') or env['prefix']):
if env['MSVS'].has_key('PLATFORMSDKDIR'):
env['prefix'] = env['MSVS']['PLATFORMSDKDIR']
SConscriptChdir(0)
############ helper builders
def pkg_scan_dep(self, target, source):
import re
## TODO: detectar si el archivo existe antes de abrirlo asi nomas
pkg = open(source, "rt")
for linea in pkg.xreadlines():
dep = re.search("^[\t\w]*\$[cphl]file\s*\"([^\"]+)\"", linea)
if dep:
self.Depends(target, '#' + dep.groups()[0]);
if dep.groups()[0][-4:] == '.pkg':
# recursividad
self.pkg_scan_dep(target, dep.groups()[0])
def make_tolua_code(self, target, source, pkgname = None, bootstrap = False, use_own = False, use_typeid=None):
ptarget = Dir('.').path + '/' + target
psource = Dir('.').path + '/' + source
header = target[:-2] + '.h'
pheader = Dir('.').path + '/' + header
print("Generating ", target, " from ", source)
tolua = ""
if bootstrap:
if os.name == 'nt':
tolua = 'bin\\'+self['TOLUAPP_BOOTSTRAP']
else:
tolua = 'bin/'+self['TOLUAPP_BOOTSTRAP']
print("********* tolua is ", tolua)
else:
if use_own:
if 'msvc' in self['TOOLS']:
tolua = 'bin\\$tolua_bin'
else:
tolua = 'bin/$tolua_bin'
else:
tolua = "$TOLUAPP"
if pkgname:
pkgname = ' -n '+pkgname
else:
pkgname = ''
if use_typeid:
tolua = tolua+' -t'
comando = tolua + ' -C -H ' + pheader + ' -o ' + ptarget + pkgname + ' ' + psource
command = self.Command(target, source, comando)
self.SideEffect(header, target)
self.Depends(target, source)
self.pkg_scan_dep(target, psource)
if bootstrap:
self.Depends(target, "#/bin/$TOLUAPP_BOOTSTRAP")
if use_own:
self.Depends(target, "#/bin/$tolua_bin")
return command
env.__class__.LuaBinding = make_tolua_code;
env.__class__.pkg_scan_dep = pkg_scan_dep;
def print_install_error(target, source, env):
msg = """Error: no install prefix was specified, or detected.
you can use the 'prefix' option on command line to specify one. Examples:
scons prefix=/usr/local install
or on Windows:
scons "prefix=c:\\program files\\visual basic" install
Files will be installed on <prefix>/bin, <prefix>/lib and <prefix>/include
"""
import SCons.Errors
raise SCons.Errors.UserError(msg)
########### end of helper builders
env['CPPPATH'] = '#/include'
env['LIBPATH'] = ['#/lib'] + env['LIBPATH']
if env['no_cygwin']:
env['CCFLAGS'] += ['-mno-cygwin']
env['LINKFLAGS'] += ['-mno-cygwin']
import string
Export('env')
SConscript('src/lib/SCsub')
SConscript('src/bin/SCsub')
#SConscript('src/lib/SCsub')
SConscript('src/tests/SCsub')
env.Alias('all', [env.bin_target, env.lib_target])
env.Alias('test', env.test_targets)
Default('all')
if env['prefix']:
env.Install(env['prefix']+'/bin', env.bin_target)
env.Install(env['prefix']+'/lib', env.lib_target)
env.Install(env['prefix']+'/include', '#include/tolua++.h')
env.Alias('install', [env['prefix']+'/bin', env['prefix']+'/include', env['prefix']+'/lib'])
else:
env.Command('install', [], print_install_error)
env.Depends('install', 'all')
env.Command('deb', [], 'dpkg-buildpackage -I.svn -Icustom.py -Itoluabind_dev.c -Itoluabind_dev.h -Itoluabind_default.o -Icustom.lua -I.sconsign', ENV=os.environ)

308
3rdparty/toluapp/cmake/dist.cmake vendored Normal file
View File

@ -0,0 +1,308 @@
# LuaDist CMake utility library.
# Provides sane project defaults and macros common to LuaDist CMake builds.
#
# Copyright (C) 2007-2012 LuaDist.
# by David Manura, Peter Drahoš
# Redistribution and use of this file is allowed according to the terms of the MIT license.
# For details see the COPYRIGHT file distributed with LuaDist.
# Please note that the package source code is licensed under its own license.
## Extract information from dist.info
if ( NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/dist.info )
message ( FATAL_ERROR
"Missing dist.info file (${CMAKE_CURRENT_SOURCE_DIR}/dist.info)." )
endif ()
file ( READ ${CMAKE_CURRENT_SOURCE_DIR}/dist.info DIST_INFO )
if ( "${DIST_INFO}" STREQUAL "" )
message ( FATAL_ERROR "Failed to load dist.info." )
endif ()
# Reads field `name` from dist.info string `DIST_INFO` into variable `var`.
macro ( _parse_dist_field name var )
string ( REGEX REPLACE ".*${name}[ \t]?=[ \t]?[\"']([^\"']+)[\"'].*" "\\1"
${var} "${DIST_INFO}" )
if ( ${var} STREQUAL DIST_INFO )
message ( FATAL_ERROR "Failed to extract \"${var}\" from dist.info" )
endif ()
endmacro ()
#
_parse_dist_field ( name DIST_NAME )
_parse_dist_field ( version DIST_VERSION )
_parse_dist_field ( license DIST_LICENSE )
_parse_dist_field ( author DIST_AUTHOR )
_parse_dist_field ( maintainer DIST_MAINTAINER )
_parse_dist_field ( url DIST_URL )
_parse_dist_field ( desc DIST_DESC )
message ( "DIST_NAME: ${DIST_NAME}")
message ( "DIST_VERSION: ${DIST_VERSION}")
message ( "DIST_LICENSE: ${DIST_LICENSE}")
message ( "DIST_AUTHOR: ${DIST_AUTHOR}")
message ( "DIST_MAINTAINER: ${DIST_MAINTAINER}")
message ( "DIST_URL: ${DIST_URL}")
message ( "DIST_DESC: ${DIST_DESC}")
string ( REGEX REPLACE ".*depends[ \t]?=[ \t]?[\"']([^\"']+)[\"'].*" "\\1"
DIST_DEPENDS ${DIST_INFO} )
if ( DIST_DEPENDS STREQUAL DIST_INFO )
set ( DIST_DEPENDS "" )
endif ()
message ( "DIST_DEPENDS: ${DIST_DEPENDS}")
## 2DO: Parse DIST_DEPENDS and try to install Dependencies with automatically using externalproject_add
## INSTALL DEFAULTS (Relative to CMAKE_INSTALL_PREFIX)
# Primary paths
set ( INSTALL_BIN bin CACHE PATH "Where to install binaries to." )
set ( INSTALL_LIB lib CACHE PATH "Where to install libraries to." )
set ( INSTALL_INC include CACHE PATH "Where to install headers to." )
set ( INSTALL_ETC etc CACHE PATH "Where to store configuration files" )
set ( INSTALL_SHARE share CACHE PATH "Directory for shared data." )
# Secondary paths
option ( INSTALL_VERSION
"Install runtime libraries and executables with version information." OFF)
set ( INSTALL_DATA ${INSTALL_SHARE}/${DIST_NAME} CACHE PATH
"Directory the package can store documentation, tests or other data in.")
set ( INSTALL_DOC ${INSTALL_DATA}/doc CACHE PATH
"Recommended directory to install documentation into.")
set ( INSTALL_EXAMPLE ${INSTALL_DATA}/example CACHE PATH
"Recommended directory to install examples into.")
set ( INSTALL_TEST ${INSTALL_DATA}/test CACHE PATH
"Recommended directory to install tests into.")
set ( INSTALL_FOO ${INSTALL_DATA}/etc CACHE PATH
"Where to install additional files")
# Tweaks and other defaults
# Setting CMAKE to use loose block and search for find modules in source directory
set ( CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true )
set ( CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH} )
option ( BUILD_SHARED_LIBS "Build shared libraries" ON )
# In MSVC, prevent warnings that can occur when using standard libraries.
if ( MSVC )
add_definitions ( -D_CRT_SECURE_NO_WARNINGS )
endif ()
## MACROS
# Parser macro
macro ( parse_arguments prefix arg_names option_names)
set ( DEFAULT_ARGS )
foreach ( arg_name ${arg_names} )
set ( ${prefix}_${arg_name} )
endforeach ()
foreach ( option ${option_names} )
set ( ${prefix}_${option} FALSE )
endforeach ()
set ( current_arg_name DEFAULT_ARGS )
set ( current_arg_list )
foreach ( arg ${ARGN} )
set ( larg_names ${arg_names} )
list ( FIND larg_names "${arg}" is_arg_name )
if ( is_arg_name GREATER -1 )
set ( ${prefix}_${current_arg_name} ${current_arg_list} )
set ( current_arg_name ${arg} )
set ( current_arg_list )
else ()
set ( loption_names ${option_names} )
list ( FIND loption_names "${arg}" is_option )
if ( is_option GREATER -1 )
set ( ${prefix}_${arg} TRUE )
else ()
set ( current_arg_list ${current_arg_list} ${arg} )
endif ()
endif ()
endforeach ()
set ( ${prefix}_${current_arg_name} ${current_arg_list} )
endmacro ()
# install_executable ( executable_targets )
# Installs any executables generated using "add_executable".
# USE: install_executable ( lua )
# NOTE: subdirectories are NOT supported
set ( CPACK_COMPONENT_RUNTIME_DISPLAY_NAME "${DIST_NAME} Runtime" )
set ( CPACK_COMPONENT_RUNTIME_DESCRIPTION
"Executables and runtime libraries. Installed into ${INSTALL_BIN}." )
macro ( install_executable )
foreach ( _file ${ARGN} )
if ( INSTALL_VERSION )
set_target_properties ( ${_file} PROPERTIES VERSION ${DIST_VERSION}
SOVERSION ${DIST_VERSION} )
endif ()
install ( TARGETS ${_file} RUNTIME DESTINATION ${INSTALL_BIN}
COMPONENT Runtime )
endforeach()
endmacro ()
# install_library ( library_targets )
# Installs any libraries generated using "add_library" into apropriate places.
# USE: install_library ( libexpat )
# NOTE: subdirectories are NOT supported
set ( CPACK_COMPONENT_LIBRARY_DISPLAY_NAME "${DIST_NAME} Development Libraries" )
set ( CPACK_COMPONENT_LIBRARY_DESCRIPTION
"Static and import libraries needed for development. Installed into ${INSTALL_LIB} or ${INSTALL_BIN}." )
macro ( install_library )
foreach ( _file ${ARGN} )
if ( INSTALL_VERSION )
set_target_properties ( ${_file} PROPERTIES VERSION ${DIST_VERSION}
SOVERSION ${DIST_VERSION} )
endif ()
install ( TARGETS ${_file}
RUNTIME DESTINATION ${INSTALL_BIN} COMPONENT Runtime
LIBRARY DESTINATION ${INSTALL_LIB} COMPONENT Runtime
ARCHIVE DESTINATION ${INSTALL_LIB} COMPONENT Library )
endforeach()
endmacro ()
# helper function for various install_* functions, for PATTERN/REGEX args.
macro ( _complete_install_args )
if ( NOT("${_ARG_PATTERN}" STREQUAL "") )
set ( _ARG_PATTERN PATTERN ${_ARG_PATTERN} )
endif ()
if ( NOT("${_ARG_REGEX}" STREQUAL "") )
set ( _ARG_REGEX REGEX ${_ARG_REGEX} )
endif ()
endmacro ()
# install_header ( files/directories [INTO destination] )
# Install a directories or files into header destination.
# USE: install_header ( lua.h luaconf.h ) or install_header ( GL )
# USE: install_header ( mylib.h INTO mylib )
# For directories, supports optional PATTERN/REGEX arguments like install().
set ( CPACK_COMPONENT_HEADER_DISPLAY_NAME "${DIST_NAME} Development Headers" )
set ( CPACK_COMPONENT_HEADER_DESCRIPTION
"Headers needed for development. Installed into ${INSTALL_INC}." )
macro ( install_header )
parse_arguments ( _ARG "INTO;PATTERN;REGEX" "" ${ARGN} )
_complete_install_args()
foreach ( _file ${_ARG_DEFAULT_ARGS} )
if ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_file}" )
install ( DIRECTORY ${_file} DESTINATION ${INSTALL_INC}/${_ARG_INTO}
COMPONENT Header ${_ARG_PATTERN} ${_ARG_REGEX} )
else ()
install ( FILES ${_file} DESTINATION ${INSTALL_INC}/${_ARG_INTO}
COMPONENT Header )
endif ()
endforeach()
endmacro ()
# install_data ( files/directories [INTO destination] )
# This installs additional data files or directories.
# USE: install_data ( extra data.dat )
# USE: install_data ( image1.png image2.png INTO images )
# For directories, supports optional PATTERN/REGEX arguments like install().
set ( CPACK_COMPONENT_DATA_DISPLAY_NAME "${DIST_NAME} Data" )
set ( CPACK_COMPONENT_DATA_DESCRIPTION
"Application data. Installed into ${INSTALL_DATA}." )
macro ( install_data )
parse_arguments ( _ARG "INTO;PATTERN;REGEX" "" ${ARGN} )
_complete_install_args()
foreach ( _file ${_ARG_DEFAULT_ARGS} )
if ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_file}" )
install ( DIRECTORY ${_file}
DESTINATION ${INSTALL_DATA}/${_ARG_INTO}
COMPONENT Data ${_ARG_PATTERN} ${_ARG_REGEX} )
else ()
install ( FILES ${_file} DESTINATION ${INSTALL_DATA}/${_ARG_INTO}
COMPONENT Data )
endif ()
endforeach()
endmacro ()
# INSTALL_DOC ( files/directories [INTO destination] )
# This installs documentation content
# USE: install_doc ( doc/ doc.pdf )
# USE: install_doc ( index.html INTO html )
# For directories, supports optional PATTERN/REGEX arguments like install().
set ( CPACK_COMPONENT_DOCUMENTATION_DISPLAY_NAME "${DIST_NAME} Documentation" )
set ( CPACK_COMPONENT_DOCUMENTATION_DESCRIPTION
"Application documentation. Installed into ${INSTALL_DOC}." )
macro ( install_doc )
parse_arguments ( _ARG "INTO;PATTERN;REGEX" "" ${ARGN} )
_complete_install_args()
foreach ( _file ${_ARG_DEFAULT_ARGS} )
if ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_file}" )
install ( DIRECTORY ${_file} DESTINATION ${INSTALL_DOC}/${_ARG_INTO}
COMPONENT Documentation ${_ARG_PATTERN} ${_ARG_REGEX} )
else ()
install ( FILES ${_file} DESTINATION ${INSTALL_DOC}/${_ARG_INTO}
COMPONENT Documentation )
endif ()
endforeach()
endmacro ()
# install_example ( files/directories [INTO destination] )
# This installs additional examples
# USE: install_example ( examples/ exampleA )
# USE: install_example ( super_example super_data INTO super)
# For directories, supports optional PATTERN/REGEX argument like install().
set ( CPACK_COMPONENT_EXAMPLE_DISPLAY_NAME "${DIST_NAME} Examples" )
set ( CPACK_COMPONENT_EXAMPLE_DESCRIPTION
"Examples and their associated data. Installed into ${INSTALL_EXAMPLE}." )
macro ( install_example )
parse_arguments ( _ARG "INTO;PATTERN;REGEX" "" ${ARGN} )
_complete_install_args()
foreach ( _file ${_ARG_DEFAULT_ARGS} )
if ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_file}" )
install ( DIRECTORY ${_file} DESTINATION ${INSTALL_EXAMPLE}/${_ARG_INTO}
COMPONENT Example ${_ARG_PATTERN} ${_ARG_REGEX} )
else ()
install ( FILES ${_file} DESTINATION ${INSTALL_EXAMPLE}/${_ARG_INTO}
COMPONENT Example )
endif ()
endforeach()
endmacro ()
# install_test ( files/directories [INTO destination] )
# This installs tests and test files, DOES NOT EXECUTE TESTS
# USE: install_test ( my_test data.sql )
# USE: install_test ( feature_x_test INTO x )
# For directories, supports optional PATTERN/REGEX argument like install().
set ( CPACK_COMPONENT_TEST_DISPLAY_NAME "${DIST_NAME} Tests" )
set ( CPACK_COMPONENT_TEST_DESCRIPTION
"Tests and associated data. Installed into ${INSTALL_TEST}." )
macro ( install_test )
parse_arguments ( _ARG "INTO;PATTERN;REGEX" "" ${ARGN} )
_complete_install_args()
foreach ( _file ${_ARG_DEFAULT_ARGS} )
if ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_file}" )
install ( DIRECTORY ${_file} DESTINATION ${INSTALL_TEST}/${_ARG_INTO}
COMPONENT Test ${_ARG_PATTERN} ${_ARG_REGEX} )
else ()
install ( FILES ${_file} DESTINATION ${INSTALL_TEST}/${_ARG_INTO}
COMPONENT Test )
endif ()
endforeach()
endmacro ()
# install_foo ( files/directories [INTO destination] )
# This installs optional or otherwise unneeded content
# USE: install_foo ( etc/ example.doc )
# USE: install_foo ( icon.png logo.png INTO icons)
# For directories, supports optional PATTERN/REGEX argument like install().
set ( CPACK_COMPONENT_OTHER_DISPLAY_NAME "${DIST_NAME} Unspecified Content" )
set ( CPACK_COMPONENT_OTHER_DESCRIPTION
"Other unspecified content. Installed into ${INSTALL_FOO}." )
macro ( install_foo )
parse_arguments ( _ARG "INTO;PATTERN;REGEX" "" ${ARGN} )
_complete_install_args()
foreach ( _file ${_ARG_DEFAULT_ARGS} )
if ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_file}" )
install ( DIRECTORY ${_file} DESTINATION ${INSTALL_FOO}/${_ARG_INTO}
COMPONENT Other ${_ARG_PATTERN} ${_ARG_REGEX} )
else ()
install ( FILES ${_file} DESTINATION ${INSTALL_FOO}/${_ARG_INTO}
COMPONENT Other )
endif ()
endforeach()
endmacro ()
## CTest defaults
## CPack defaults
set ( CPACK_GENERATOR "ZIP" )
set ( CPACK_STRIP_FILES TRUE )
set ( CPACK_PACKAGE_NAME "${DIST_NAME}" )
set ( CPACK_PACKAGE_VERSION "${DIST_VERSION}")
set ( CPACK_PACKAGE_VENDOR "LuaDist" )
set ( CPACK_COMPONENTS_ALL Runtime Library Header Data Documentation Example Other )
include ( CPack )

293
3rdparty/toluapp/cmake/lua.cmake vendored Normal file
View File

@ -0,0 +1,293 @@
# LuaDist CMake utility library for Lua.
#
# Copyright (C) 2007-2012 LuaDist.
# by David Manura, Peter Drahos
# Redistribution and use of this file is allowed according to the terms of the MIT license.
# For details see the COPYRIGHT file distributed with LuaDist.
# Please note that the package source code is licensed under its own license.
set ( INSTALL_LMOD ${INSTALL_LIB}/lua
CACHE PATH "Directory to install Lua modules." )
set ( INSTALL_CMOD ${INSTALL_LIB}/lua
CACHE PATH "Directory to install Lua binary modules." )
option ( SKIP_LUA_WRAPPER
"Do not build and install Lua executable wrappers." OFF)
# List of (Lua module name, file path) pairs.
# Used internally by add_lua_test. Built by add_lua_module.
set ( _lua_modules )
# utility function: appends path `path` to path `basepath`, properly
# handling cases when `path` may be relative or absolute.
macro ( _append_path basepath path result )
if ( IS_ABSOLUTE "${path}" )
set ( ${result} "${path}" )
else ()
set ( ${result} "${basepath}/${path}" )
endif ()
endmacro ()
# install_lua_executable ( target source )
# Automatically generate a binary if srlua package is available
# The application or its source will be placed into /bin
# If the application source did not have .lua suffix then it will be added
# USE: lua_executable ( sputnik src/sputnik.lua )
macro ( install_lua_executable _name _source )
get_filename_component ( _source_name ${_source} NAME_WE )
# Find srlua and glue
find_program( SRLUA_EXECUTABLE NAMES srlua )
find_program( GLUE_EXECUTABLE NAMES glue )
# Executable output
set ( _exe ${CMAKE_CURRENT_BINARY_DIR}/${_name}${CMAKE_EXECUTABLE_SUFFIX} )
if ( NOT SKIP_LUA_WRAPPER AND SRLUA_EXECUTABLE AND GLUE_EXECUTABLE )
# Generate binary gluing the lua code to srlua, this is a robuust approach for most systems
add_custom_command(
OUTPUT ${_exe}
COMMAND ${GLUE_EXECUTABLE}
ARGS ${SRLUA_EXECUTABLE} ${_source} ${_exe}
DEPENDS ${_source}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
VERBATIM
)
# Make sure we have a target associated with the binary
add_custom_target(${_name} ALL
DEPENDS ${_exe}
)
# Install with run permissions
install ( PROGRAMS ${_exe} DESTINATION ${INSTALL_BIN} COMPONENT Runtime)
# Also install source as optional resurce
install ( FILES ${_source} DESTINATION ${INSTALL_FOO} COMPONENT Other )
else()
# Install into bin as is but without the lua suffix, we assume the executable uses UNIX shebang/hash-bang magic
install ( PROGRAMS ${_source} DESTINATION ${INSTALL_BIN}
RENAME ${_source_name}
COMPONENT Runtime
)
endif()
endmacro ()
macro ( _lua_module_helper is_install _name )
parse_arguments ( _MODULE "LINK;ALL_IN_ONE" "" ${ARGN} )
# _target is CMake-compatible target name for module (e.g. socket_core).
# _module is relative path of target (e.g. socket/core),
# without extension (e.g. .lua/.so/.dll).
# _MODULE_SRC is list of module source files (e.g. .lua and .c files).
# _MODULE_NAMES is list of module names (e.g. socket.core).
if ( _MODULE_ALL_IN_ONE )
string ( REGEX REPLACE "\\..*" "" _target "${_name}" )
string ( REGEX REPLACE "\\..*" "" _module "${_name}" )
set ( _target "${_target}_all_in_one")
set ( _MODULE_SRC ${_MODULE_ALL_IN_ONE} )
set ( _MODULE_NAMES ${_name} ${_MODULE_DEFAULT_ARGS} )
else ()
string ( REPLACE "." "_" _target "${_name}" )
string ( REPLACE "." "/" _module "${_name}" )
set ( _MODULE_SRC ${_MODULE_DEFAULT_ARGS} )
set ( _MODULE_NAMES ${_name} )
endif ()
if ( NOT _MODULE_SRC )
message ( FATAL_ERROR "no module sources specified" )
endif ()
list ( GET _MODULE_SRC 0 _first_source )
get_filename_component ( _ext ${_first_source} EXT )
if ( _ext STREQUAL ".lua" ) # Lua source module
list ( LENGTH _MODULE_SRC _len )
if ( _len GREATER 1 )
message ( FATAL_ERROR "more than one source file specified" )
endif ()
set ( _module "${_module}.lua" )
get_filename_component ( _module_dir ${_module} PATH )
get_filename_component ( _module_filename ${_module} NAME )
_append_path ( "${CMAKE_CURRENT_SOURCE_DIR}" "${_first_source}" _module_path )
list ( APPEND _lua_modules "${_name}" "${_module_path}" )
if ( ${is_install} )
install ( FILES ${_first_source} DESTINATION ${INSTALL_LMOD}/${_module_dir}
RENAME ${_module_filename}
COMPONENT Runtime
)
endif ()
else () # Lua C binary module
enable_language ( C )
find_package ( Lua REQUIRED )
include_directories ( ${LUA_INCLUDE_DIR} )
set ( _module "${_module}${CMAKE_SHARED_MODULE_SUFFIX}" )
get_filename_component ( _module_dir ${_module} PATH )
get_filename_component ( _module_filenamebase ${_module} NAME_WE )
foreach ( _thisname ${_MODULE_NAMES} )
list ( APPEND _lua_modules "${_thisname}"
"${CMAKE_CURRENT_BINARY_DIR}/\${CMAKE_CFG_INTDIR}/${_module}" )
endforeach ()
add_library( ${_target} MODULE ${_MODULE_SRC})
target_link_libraries ( ${_target} ${LUA_LIBRARY} ${_MODULE_LINK} )
set_target_properties ( ${_target} PROPERTIES LIBRARY_OUTPUT_DIRECTORY
"${_module_dir}" PREFIX "" OUTPUT_NAME "${_module_filenamebase}" )
if ( ${is_install} )
install ( TARGETS ${_target} DESTINATION ${INSTALL_CMOD}/${_module_dir} COMPONENT Runtime)
endif ()
endif ()
endmacro ()
# add_lua_module
# Builds a Lua source module into a destination locatable by Lua
# require syntax.
# Binary modules are also supported where this function takes sources and
# libraries to compile separated by LINK keyword.
# USE: add_lua_module ( socket.http src/http.lua )
# USE2: add_lua_module ( mime.core src/mime.c )
# USE3: add_lua_module ( socket.core ${SRC_SOCKET} LINK ${LIB_SOCKET} )
# USE4: add_lua_module ( ssl.context ssl.core ALL_IN_ONE src/context.c src/ssl.c )
# This form builds an "all-in-one" module (e.g. ssl.so or ssl.dll containing
# both modules ssl.context and ssl.core). The CMake target name will be
# ssl_all_in_one.
# Also sets variable _module_path (relative path where module typically
# would be installed).
macro ( add_lua_module )
_lua_module_helper ( 0 ${ARGN} )
endmacro ()
# install_lua_module
# This is the same as `add_lua_module` but also installs the module.
# USE: install_lua_module ( socket.http src/http.lua )
# USE2: install_lua_module ( mime.core src/mime.c )
# USE3: install_lua_module ( socket.core ${SRC_SOCKET} LINK ${LIB_SOCKET} )
macro ( install_lua_module )
_lua_module_helper ( 1 ${ARGN} )
endmacro ()
# Builds string representing Lua table mapping Lua modules names to file
# paths. Used internally.
macro ( _make_module_table _outvar )
set ( ${_outvar} )
list ( LENGTH _lua_modules _n )
if ( ${_n} GREATER 0 ) # avoids cmake complaint
foreach ( _i RANGE 1 ${_n} 2 )
list ( GET _lua_modules ${_i} _path )
math ( EXPR _ii ${_i}-1 )
list ( GET _lua_modules ${_ii} _name )
set ( ${_outvar} "${_table} ['${_name}'] = '${_path}'\;\n")
endforeach ()
endif ()
set ( ${_outvar}
"local modules = {
${_table}}" )
endmacro ()
# add_lua_test ( _testfile [ WORKING_DIRECTORY _working_dir ] )
# Runs Lua script `_testfile` under CTest tester.
# Optional named argument `WORKING_DIRECTORY` is current working directory to
# run test under (defaults to ${CMAKE_CURRENT_BINARY_DIR}).
# Both paths, if relative, are relative to ${CMAKE_CURRENT_SOURCE_DIR}.
# Any modules previously defined with install_lua_module are automatically
# preloaded (via package.preload) prior to running the test script.
# Under LuaDist, set test=true in config.lua to enable testing.
# USE: add_lua_test ( test/test1.lua [args...] [WORKING_DIRECTORY dir])
macro ( add_lua_test _testfile )
if ( NOT SKIP_TESTING )
parse_arguments ( _ARG "WORKING_DIRECTORY" "" ${ARGN} )
include ( CTest )
find_program ( LUA NAMES lua lua.bat )
get_filename_component ( TESTFILEABS ${_testfile} ABSOLUTE )
get_filename_component ( TESTFILENAME ${_testfile} NAME )
get_filename_component ( TESTFILEBASE ${_testfile} NAME_WE )
# Write wrapper script.
# Note: One simple way to allow the script to find modules is
# to just put them in package.preload.
set ( TESTWRAPPER ${CMAKE_CURRENT_BINARY_DIR}/${TESTFILENAME} )
_make_module_table ( _table )
set ( TESTWRAPPERSOURCE
"local CMAKE_CFG_INTDIR = ... or '.'
${_table}
local function preload_modules(modules)
for name, path in pairs(modules) do
if path:match'%.lua' then
package.preload[name] = assert(loadfile(path))
else
local name = name:gsub('.*%-', '') -- remove any hyphen prefix
local symbol = 'luaopen_' .. name:gsub('%.', '_')
--improve: generalize to support all-in-one loader?
local path = path:gsub('%$%{CMAKE_CFG_INTDIR%}', CMAKE_CFG_INTDIR)
package.preload[name] = assert(package.loadlib(path, symbol))
end
end
end
preload_modules(modules)
arg[0] = '${TESTFILEABS}'
table.remove(arg, 1)
return assert(loadfile '${TESTFILEABS}')(unpack(arg))
" )
if ( _ARG_WORKING_DIRECTORY )
get_filename_component (
TESTCURRENTDIRABS ${_ARG_WORKING_DIRECTORY} ABSOLUTE )
# note: CMake 2.6 (unlike 2.8) lacks WORKING_DIRECTORY parameter.
set ( _pre ${CMAKE_COMMAND} -E chdir "${TESTCURRENTDIRABS}" )
endif ()
file ( WRITE ${TESTWRAPPER} ${TESTWRAPPERSOURCE})
add_test ( NAME ${TESTFILEBASE} COMMAND ${_pre} ${LUA}
${TESTWRAPPER} "${CMAKE_CFG_INTDIR}"
${_ARG_DEFAULT_ARGS} )
endif ()
# see also http://gdcm.svn.sourceforge.net/viewvc/gdcm/Sandbox/CMakeModules/UsePythonTest.cmake
# Note: ${CMAKE_CFG_INTDIR} is a command-line argument to allow proper
# expansion by the native build tool.
endmacro ()
# Converts Lua source file `_source` to binary string embedded in C source
# file `_target`. Optionally compiles Lua source to byte code (not available
# under LuaJIT2, which doesn't have a bytecode loader). Additionally, Lua
# versions of bin2c [1] and luac [2] may be passed respectively as additional
# arguments.
#
# [1] http://lua-users.org/wiki/BinToCee
# [2] http://lua-users.org/wiki/LuaCompilerInLua
function ( add_lua_bin2c _target _source )
find_program ( LUA NAMES lua lua.bat )
execute_process ( COMMAND ${LUA} -e "string.dump(function()end)"
RESULT_VARIABLE _LUA_DUMP_RESULT ERROR_QUIET )
if ( NOT ${_LUA_DUMP_RESULT} )
SET ( HAVE_LUA_DUMP true )
endif ()
message ( "-- string.dump=${HAVE_LUA_DUMP}" )
if ( ARGV2 )
get_filename_component ( BIN2C ${ARGV2} ABSOLUTE )
set ( BIN2C ${LUA} ${BIN2C} )
else ()
find_program ( BIN2C NAMES bin2c bin2c.bat )
endif ()
if ( HAVE_LUA_DUMP )
if ( ARGV3 )
get_filename_component ( LUAC ${ARGV3} ABSOLUTE )
set ( LUAC ${LUA} ${LUAC} )
else ()
find_program ( LUAC NAMES luac luac.bat )
endif ()
endif ( HAVE_LUA_DUMP )
message ( "-- bin2c=${BIN2C}" )
message ( "-- luac=${LUAC}" )
get_filename_component ( SOURCEABS ${_source} ABSOLUTE )
if ( HAVE_LUA_DUMP )
get_filename_component ( SOURCEBASE ${_source} NAME_WE )
add_custom_command (
OUTPUT ${_target} DEPENDS ${_source}
COMMAND ${LUAC} -o ${CMAKE_CURRENT_BINARY_DIR}/${SOURCEBASE}.lo
${SOURCEABS}
COMMAND ${BIN2C} ${CMAKE_CURRENT_BINARY_DIR}/${SOURCEBASE}.lo
">${_target}" )
else ()
add_custom_command (
OUTPUT ${_target} DEPENDS ${SOURCEABS}
COMMAND ${BIN2C} ${_source} ">${_target}" )
endif ()
endfunction()

22
3rdparty/toluapp/config_linux.py vendored Normal file
View File

@ -0,0 +1,22 @@
## This is the linux configuration file
# use 'scons -h' to see the list of command line options available
# Compiler flags (based on Debian's installation of lua)
#LINKFLAGS = ['-g']
CCFLAGS = ['-O2', '-ansi', '-Wall']
#CCFLAGS = ['-I/usr/include/lua50', '-g']
# this is the default directory for installation. Files will be installed on
# <prefix>/bin, <prefix>/lib and <prefix>/include when you run 'scons install'
#
# You can also specify this directory on the command line with the 'prefix'
# option
#
# You can see more 'generic' options for POSIX systems on config_posix.py
prefix = '/usr/local'
# libraries (based on Debian's installation of lua)
LIBS = ['lua', 'dl', 'm']

28
3rdparty/toluapp/config_msvc.py vendored Normal file
View File

@ -0,0 +1,28 @@
## This is the MSVC configuration file
# use 'scons -h' to see the list of command line options available
# flags for the compiler
CCFLAGS = ['/nologo']
# this is the default directory for installation. Files will be installed on
# <prefix>/bin, <prefix>/lib and <prefix>/include when you run 'scons install'
#
# You can also specify this directory on the command line with the 'prefix'
# option
#
# If you leave it as 'None', we'll try to auto-detect it (as 'PLATFORMSDKDIR'
# detected by SCons).
prefix = None # (it's a string)
# the libraries
LIBS = ['lua', 'lualib']
# linkflags
LINKFLAGS = ['/nologo']
## We need to specifiy the environment for the PATH and LIB and all those
# parameters cl tales from it
import os
ENV = os.environ

23
3rdparty/toluapp/config_posix.py vendored Normal file
View File

@ -0,0 +1,23 @@
## This is the POSIX configuration file (will be included for cygwin, mingw
# and possibly mac OSX and BSDs)
# use 'scons -h' to see the list of command line options available
# flags for the compiler
#CCFLAGS = []
CCFLAGS = ['-O2', '-ansi', '-Wall']
# this is the default directory for installation. Files will be installed on
# <prefix>/bin, <prefix>/lib and <prefix>/include when you run 'scons install'
#
# You can also specify this directory on the command line with the 'prefix'
# option
prefix = '/usr/local'
# libraries
LIBS = ['lua', 'lualib', 'm']
import os

9
3rdparty/toluapp/custom-5.1.py vendored Normal file
View File

@ -0,0 +1,9 @@
CCFLAGS = ['-I/usr/include/lua5.1', '-O2', '-ansi']
#LIBPATH = ['/usr/local/lib']
LIBS = ['lua5.1', 'dl', 'm']
prefix = '/mingw'
#build_dev=1
tolua_bin = 'tolua++5.1'
tolua_lib = 'tolua++5.1'
TOLUAPP = 'tolua++5.1'

6
3rdparty/toluapp/debian/README vendored Normal file
View File

@ -0,0 +1,6 @@
The Debian Package tolua++
----------------------------
Comments regarding the Package
Ariel Manzur <puntob@gmail.com>, Thu, 30 Dec 2004 11:59:14 -0300

6
3rdparty/toluapp/debian/README.Debian vendored Normal file
View File

@ -0,0 +1,6 @@
tolua++ for Debian
------------------
<possible notes regarding this package - if none, delete this file>
-- Ariel Manzur <puntob@gmail.com>, Thu, 30 Dec 2004 11:59:14 -0300

121
3rdparty/toluapp/debian/changelog vendored Normal file
View File

@ -0,0 +1,121 @@
tolua++ (1.0.92pre1-1) unstable; urgency=low
* fixed array bound check bug
* moved parsing of 'extern' keyword to the parser
* fixed bug in module name generation from package filename
* added -E command line option
-- Ariel Manzur <puntob@gmail.com> Mon, 13 Mar 2006 19:28:14 -0300
tolua++ (1.0.8pre3-1) unstable; urgency=low
* changed tolua_touserdata
* fixed bugs
-- Ariel Manzur <puntob@gmail.com> Tue, 13 Dec 2005 01:46:33 +0100
tolua++ (1.0.7-1) unstable; urgency=low
* added -C flag
* added object access
* added parser_hook
* merged Mildred's patch (sorry, no last name): code on open function is
nested, embedded lua chunks have better names
-- Ariel Manzur <puntob@gmail.com> Tue, 18 Oct 2005 22:51:04 -0300
tolua++ (1.0.6-1) unstable; urgency=low
* fixed parser bugs
* added tolua_property
* added TOLUA_PROTECTED_DESTRUCTOR
* added inheritance from C objects by lua objects
* fixed class constructor bug (calling the class name directly works)
-- Ariel Manzur <puntob@gmail.com> Sat, 6 Aug 2005 09:24:10 -0300
tolua++ (1.0.6pre3-1) unstable; urgency=low
* fixed tolua_tocppstring
-- Ariel Manzur <puntob@gmail.com> Sun, 26 Jun 2005 21:01:50 -0300
tolua++ (1.0.6pre2-1) unstable; urgency=low
* fixed c compilation bug
* added -D flag
* fixed tolua.releaseownership?
-- Ariel Manzur <puntob@gmail.com> Mon, 2 May 2005 20:56:04 -0300
tolua++ (1.0.6pre1-1) unstable; urgency=low
* something
-- Ariel Manzur <puntob@gmail.com> Wed, 27 Apr 2005 00:09:41 -0300
tolua++ (1.0.5-1) unstable; urgency=low
* fixed missed inheritance bug.
* ready for 1.0.5
-- Ariel Manzur <puntob@gmail.com> Fri, 8 Apr 2005 23:15:19 -0300
tolua++ (1.0.5~pre6-1) unstable; urgency=low
* fixed bug in tolua.cast (introduced on previous version)
-- Ariel Manzur <puntob@gmail.com> Sat, 2 Apr 2005 00:36:45 -0300
tolua++ (1.0.5~pre5-1) unstable; urgency=low
* fixed bug in tolua.cast
-- Ariel Manzur <puntob@gmail.com> Fri, 18 Mar 2005 01:13:55 -0300
tolua++ (1.0.5~pre4-1) unstable; urgency=low
* fixed support for overloading methods across multiple class definitions
-- Ariel Manzur <puntob@gmail.com> Thu, 3 Mar 2005 19:03:04 -0300
tolua++ (1.0.5~pre3-1) unstable; urgency=low
* fixed bugs in parser
-- Ariel Manzur <puntob@gmail.com> Sun, 20 Feb 2005 19:56:32 -0300
tolua++ (1.0.5~pre2-1) unstable; urgency=low
* added tolua_outside
-- Ariel Manzur <puntob@gmail.com> Fri, 11 Feb 2005 02:50:45 -0300
tolua++ (1.0.5~pre1-1) unstable; urgency=low
* fixed bug in type detection
* fixed bug in code output for static variables
-- Ariel Manzur <puntob@gmail.com> Thu, 3 Feb 2005 02:05:43 -0300
tolua++ (1.0.4-3) unstable; urgency=low
* jumped the gun on the previous release
-- Ariel Manzur <puntob@gmail.com> Thu, 20 Jan 2005 23:20:17 -0300
tolua++ (1.0.4-2) unstable; urgency=low
* added optimize flags for binary package
-- Ariel Manzur <puntob@gmail.com> Fri, 14 Jan 2005 00:43:09 -0300
tolua++ (1.0.4-1) unstable; urgency=low
* Initial Release.
-- Ariel Manzur <puntob@gmail.com> Thu, 30 Dec 2004 11:59:14 -0300
Local variables:
mode: debian-changelog
End:

1
3rdparty/toluapp/debian/compat vendored Normal file
View File

@ -0,0 +1 @@
4

7
3rdparty/toluapp/debian/conffiles.ex vendored Normal file
View File

@ -0,0 +1,7 @@
#
# If you want to use this conffile, remove all comments and put files that
# you want dpkg to process here using their absolute pathnames.
# See the policy manual
#
# for example:
# /etc/tolua++/tolua++.conf

13
3rdparty/toluapp/debian/control vendored Normal file
View File

@ -0,0 +1,13 @@
Source: tolua++
Section: unknown
Priority: optional
Maintainer: Ariel Manzur <puntob@gmail.com>
Build-Depends: debhelper (>= 4.0.0), scons, liblua50-dev, liblualib50-dev
Standards-Version: 3.6.1
Package: tolua++
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}, liblua50-dev, liblualib50-dev
Description: tolua++
tolua++ is an extended version of tolua, a tool to integrate C/C++ code with
Lua. tolua++ includes new features oriented to c++.

16
3rdparty/toluapp/debian/copyright vendored Normal file
View File

@ -0,0 +1,16 @@
This package is maintained by Ariel Manzur <puntob@gmail.com> on
Sat, 08 Jan 2005 06:11:22 -0300
Latest version can be found on http://www.codenix.com/~tolua/
Upstream Author(s): Waldemar Celes <celes@tecgraf.puc-rio.br>,
Ariel Manzur <puntob@gmail.com>
Copyright:
Quoted from the README file accompanying tolua:
'tolua is freely available; you can redistribute it and/or modify it.
The software provided hereunder is on an "as is" basis, and
the author has no obligation to provide maintenance, support,
updates, enhancements, or modifications.'

4
3rdparty/toluapp/debian/cron.d.ex vendored Normal file
View File

@ -0,0 +1,4 @@
#
# Regular cron jobs for the tolua++ package
#
0 4 * * * root tolua++_maintenance

4
3rdparty/toluapp/debian/dirs vendored Normal file
View File

@ -0,0 +1,4 @@
usr/bin
usr/lib
usr/include

1
3rdparty/toluapp/debian/docs vendored Normal file
View File

@ -0,0 +1 @@
README

45
3rdparty/toluapp/debian/emacsen-install.ex vendored Normal file
View File

@ -0,0 +1,45 @@
#! /bin/sh -e
# /usr/lib/emacsen-common/packages/install/tolua++
# Written by Jim Van Zandt <jrv@vanzandt.mv.com>, borrowing heavily
# from the install scripts for gettext by Santiago Vila
# <sanvila@ctv.es> and octave by Dirk Eddelbuettel <edd@debian.org>.
FLAVOR=$1
PACKAGE=tolua++
if [ ${FLAVOR} = emacs ]; then exit 0; fi
echo install/${PACKAGE}: Handling install for emacsen flavor ${FLAVOR}
#FLAVORTEST=`echo $FLAVOR | cut -c-6`
#if [ ${FLAVORTEST} = xemacs ] ; then
# SITEFLAG="-no-site-file"
#else
# SITEFLAG="--no-site-file"
#fi
FLAGS="${SITEFLAG} -q -batch -l path.el -f batch-byte-compile"
ELDIR=/usr/share/emacs/site-lisp/${PACKAGE}
ELCDIR=/usr/share/${FLAVOR}/site-lisp/${PACKAGE}
# Install-info-altdir does not actually exist.
# Maybe somebody will write it.
if test -x /usr/sbin/install-info-altdir; then
echo install/${PACKAGE}: install Info links for ${FLAVOR}
install-info-altdir --quiet --section "" "" --dirname=${FLAVOR} /usr/info/${PACKAGE}.info.gz
fi
install -m 755 -d ${ELCDIR}
cd ${ELDIR}
FILES=`echo *.el`
cp ${FILES} ${ELCDIR}
cd ${ELCDIR}
cat << EOF > path.el
(setq load-path (cons "." load-path) byte-compile-warnings nil)
EOF
${FLAVOR} ${FLAGS} ${FILES}
rm -f *.el path.el
exit 0

15
3rdparty/toluapp/debian/emacsen-remove.ex vendored Normal file
View File

@ -0,0 +1,15 @@
#!/bin/sh -e
# /usr/lib/emacsen-common/packages/remove/tolua++
FLAVOR=$1
PACKAGE=tolua++
if [ ${FLAVOR} != emacs ]; then
if test -x /usr/sbin/install-info-altdir; then
echo remove/${PACKAGE}: removing Info links for ${FLAVOR}
install-info-altdir --quiet --remove --dirname=${FLAVOR} /usr/info/tolua++.info.gz
fi
echo remove/${PACKAGE}: purging byte-compiled files for ${FLAVOR}
rm -rf /usr/share/${FLAVOR}/site-lisp/${PACKAGE}
fi

19
3rdparty/toluapp/debian/emacsen-startup.ex vendored Normal file
View File

@ -0,0 +1,19 @@
;; -*-emacs-lisp-*-
;;
;; Emacs startup file for the Debian tolua++ package
;;
;; Originally contributed by Nils Naumann <naumann@unileoben.ac.at>
;; Modified by Dirk Eddelbuettel <edd@debian.org>
;; Adapted for dh-make by Jim Van Zandt <jrv@vanzandt.mv.com>
;; The tolua++ package follows the Debian/GNU Linux 'emacsen' policy and
;; byte-compiles its elisp files for each 'emacs flavor' (emacs19,
;; xemacs19, emacs20, xemacs20...). The compiled code is then
;; installed in a subdirectory of the respective site-lisp directory.
;; We have to add this to the load-path:
(let ((package-dir (concat "/usr/share/"
(symbol-name flavor)
"/site-lisp/tolua++")))
(when (file-directory-p package-dir)
(setq load-path (cons package-dir load-path))))

74
3rdparty/toluapp/debian/init.d.ex vendored Normal file
View File

@ -0,0 +1,74 @@
#! /bin/sh
#
# skeleton example file to build /etc/init.d/ scripts.
# This file should be used to construct scripts for /etc/init.d.
#
# Written by Miquel van Smoorenburg <miquels@cistron.nl>.
# Modified for Debian
# by Ian Murdock <imurdock@gnu.ai.mit.edu>.
#
# Version: @(#)skeleton 1.9 26-Feb-2001 miquels@cistron.nl
#
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DAEMON=/usr/sbin/tolua++
NAME=tolua++
DESC=tolua++
test -x $DAEMON || exit 0
# Include tolua++ defaults if available
if [ -f /etc/default/tolua++ ] ; then
. /etc/default/tolua++
fi
set -e
case "$1" in
start)
echo -n "Starting $DESC: "
start-stop-daemon --start --quiet --pidfile /var/run/$NAME.pid \
--exec $DAEMON -- $DAEMON_OPTS
echo "$NAME."
;;
stop)
echo -n "Stopping $DESC: "
start-stop-daemon --stop --quiet --pidfile /var/run/$NAME.pid \
--exec $DAEMON
echo "$NAME."
;;
#reload)
#
# If the daemon can reload its config files on the fly
# for example by sending it SIGHUP, do it here.
#
# If the daemon responds to changes in its config file
# directly anyway, make this a do-nothing entry.
#
# echo "Reloading $DESC configuration files."
# start-stop-daemon --stop --signal 1 --quiet --pidfile \
# /var/run/$NAME.pid --exec $DAEMON
#;;
restart|force-reload)
#
# If the "reload" option is implemented, move the "force-reload"
# option to the "reload" entry above. If not, "force-reload" is
# just the same as "restart".
#
echo -n "Restarting $DESC: "
start-stop-daemon --stop --quiet --pidfile \
/var/run/$NAME.pid --exec $DAEMON
sleep 1
start-stop-daemon --start --quiet --pidfile \
/var/run/$NAME.pid --exec $DAEMON -- $DAEMON_OPTS
echo "$NAME."
;;
*)
N=/etc/init.d/$NAME
# echo "Usage: $N {start|stop|restart|reload|force-reload}" >&2
echo "Usage: $N {start|stop|restart|force-reload}" >&2
exit 1
;;
esac
exit 0

59
3rdparty/toluapp/debian/manpage.1.ex vendored Normal file
View File

@ -0,0 +1,59 @@
.\" Hey, EMACS: -*- nroff -*-
.\" First parameter, NAME, should be all caps
.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
.\" other parameters are allowed: see man(7), man(1)
.TH TOLUA++ SECTION "December 30, 2004"
.\" Please adjust this date whenever revising the manpage.
.\"
.\" Some roff macros, for reference:
.\" .nh disable hyphenation
.\" .hy enable hyphenation
.\" .ad l left justify
.\" .ad b justify to both left and right margins
.\" .nf disable filling
.\" .fi enable filling
.\" .br insert line break
.\" .sp <n> insert n+1 empty lines
.\" for manpage-specific macros, see man(7)
.SH NAME
tolua++ \- program to do something
.SH SYNOPSIS
.B tolua++
.RI [ options ] " files" ...
.br
.B bar
.RI [ options ] " files" ...
.SH DESCRIPTION
This manual page documents briefly the
.B tolua++
and
.B bar
commands.
.PP
.\" TeX users may be more comfortable with the \fB<whatever>\fP and
.\" \fI<whatever>\fP escape sequences to invode bold face and italics,
.\" respectively.
\fBtolua++\fP is a program that...
.SH OPTIONS
These programs follow the usual GNU command line syntax, with long
options starting with two dashes (`-').
A summary of options is included below.
For a complete description, see the Info files.
.TP
.B \-h, \-\-help
Show summary of options.
.TP
.B \-v, \-\-version
Show version of program.
.SH SEE ALSO
.BR bar (1),
.BR baz (1).
.br
The programs are documented fully by
.IR "The Rise and Fall of a Fooish Bar" ,
available via the Info system.
.SH AUTHOR
tolua++ was written by <upstream author>.
.PP
This manual page was written by Ariel Manzur <puntob@gmail.com>,
for the Debian project (but may be used by others).

156
3rdparty/toluapp/debian/manpage.sgml.ex vendored Normal file
View File

@ -0,0 +1,156 @@
<!doctype refentry PUBLIC "-//OASIS//DTD DocBook V4.1//EN" [
<!-- Process this file with docbook-to-man to generate an nroff manual
page: `docbook-to-man manpage.sgml > manpage.1'. You may view
the manual page with: `docbook-to-man manpage.sgml | nroff -man |
less'. A typical entry in a Makefile or Makefile.am is:
manpage.1: manpage.sgml
docbook-to-man $< > $@
The docbook-to-man binary is found in the docbook-to-man package.
Please remember that if you create the nroff version in one of the
debian/rules file targets (such as build), you will need to include
docbook-to-man in your Build-Depends control field.
-->
<!-- Fill in your name for FIRSTNAME and SURNAME. -->
<!ENTITY dhfirstname "<firstname>FIRSTNAME</firstname>">
<!ENTITY dhsurname "<surname>SURNAME</surname>">
<!-- Please adjust the date whenever revising the manpage. -->
<!ENTITY dhdate "<date>December 30, 2004</date>">
<!-- SECTION should be 1-8, maybe w/ subsection other parameters are
allowed: see man(7), man(1). -->
<!ENTITY dhsection "<manvolnum>SECTION</manvolnum>">
<!ENTITY dhemail "<email>puntob@gmail.com</email>">
<!ENTITY dhusername "Ariel Manzur">
<!ENTITY dhucpackage "<refentrytitle>TOLUA++</refentrytitle>">
<!ENTITY dhpackage "tolua++">
<!ENTITY debian "<productname>Debian</productname>">
<!ENTITY gnu "<acronym>GNU</acronym>">
<!ENTITY gpl "&gnu; <acronym>GPL</acronym>">
]>
<refentry>
<refentryinfo>
<address>
&dhemail;
</address>
<author>
&dhfirstname;
&dhsurname;
</author>
<copyright>
<year>2003</year>
<holder>&dhusername;</holder>
</copyright>
&dhdate;
</refentryinfo>
<refmeta>
&dhucpackage;
&dhsection;
</refmeta>
<refnamediv>
<refname>&dhpackage;</refname>
<refpurpose>program to do something</refpurpose>
</refnamediv>
<refsynopsisdiv>
<cmdsynopsis>
<command>&dhpackage;</command>
<arg><option>-e <replaceable>this</replaceable></option></arg>
<arg><option>--example <replaceable>that</replaceable></option></arg>
</cmdsynopsis>
</refsynopsisdiv>
<refsect1>
<title>DESCRIPTION</title>
<para>This manual page documents briefly the
<command>&dhpackage;</command> and <command>bar</command>
commands.</para>
<para>This manual page was written for the &debian; distribution
because the original program does not have a manual page.
Instead, it has documentation in the &gnu;
<application>Info</application> format; see below.</para>
<para><command>&dhpackage;</command> is a program that...</para>
</refsect1>
<refsect1>
<title>OPTIONS</title>
<para>These programs follow the usual &gnu; command line syntax,
with long options starting with two dashes (`-'). A summary of
options is included below. For a complete description, see the
<application>Info</application> files.</para>
<variablelist>
<varlistentry>
<term><option>-h</option>
<option>--help</option>
</term>
<listitem>
<para>Show summary of options.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><option>-v</option>
<option>--version</option>
</term>
<listitem>
<para>Show version of program.</para>
</listitem>
</varlistentry>
</variablelist>
</refsect1>
<refsect1>
<title>SEE ALSO</title>
<para>bar (1), baz (1).</para>
<para>The programs are documented fully by <citetitle>The Rise and
Fall of a Fooish Bar</citetitle> available via the
<application>Info</application> system.</para>
</refsect1>
<refsect1>
<title>AUTHOR</title>
<para>This manual page was written by &dhusername; &dhemail; for
the &debian; system (but may be used by others). Permission is
granted to copy, distribute and/or modify this document under
the terms of the &gnu; General Public License, Version 2 any
later version published by the Free Software Foundation.
</para>
<para>
On Debian systems, the complete text of the GNU General Public
License can be found in /usr/share/common-licenses/GPL.
</para>
</refsect1>
</refentry>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:2
sgml-indent-data:t
sgml-parent-document:nil
sgml-default-dtd-file:nil
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->

148
3rdparty/toluapp/debian/manpage.xml.ex vendored Normal file
View File

@ -0,0 +1,148 @@
<?xml version='1.0' encoding='ISO-8859-1'?>
<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd" [
<!--
Process this file with an XSLT processor: `xsltproc \
-''-nonet /usr/share/sgml/docbook/stylesheet/xsl/nwalsh/\
manpages/docbook.xsl manpage.dbk'. A manual page
<package>.<section> will be generated. You may view the
manual page with: nroff -man <package>.<section> | less'. A
typical entry in a Makefile or Makefile.am is:
DB2MAN=/usr/share/sgml/docbook/stylesheet/xsl/nwalsh/\
manpages/docbook.xsl
XP=xsltproc -''-nonet
manpage.1: manpage.dbk
$(XP) $(DB2MAN) $<
The xsltproc binary is found in the xsltproc package. The
XSL files are in docbook-xsl. Please remember that if you
create the nroff version in one of the debian/rules file
targets (such as build), you will need to include xsltproc
and docbook-xsl in your Build-Depends control field.
-->
<!-- Fill in your name for FIRSTNAME and SURNAME. -->
<!ENTITY dhfirstname "<firstname>FIRSTNAME</firstname>">
<!ENTITY dhsurname "<surname>SURNAME</surname>">
<!-- Please adjust the date whenever revising the manpage. -->
<!ENTITY dhdate "<date>December 30, 2004</date>">
<!-- SECTION should be 1-8, maybe w/ subsection other parameters are
allowed: see man(7), man(1). -->
<!ENTITY dhsection "<manvolnum>SECTION</manvolnum>">
<!ENTITY dhemail "<email>puntob@gmail.com</email>">
<!ENTITY dhusername "Ariel Manzur">
<!ENTITY dhucpackage "<refentrytitle>TOLUA++</refentrytitle>">
<!ENTITY dhpackage "tolua++">
<!ENTITY debian "<productname>Debian</productname>">
<!ENTITY gnu "<acronym>GNU</acronym>">
<!ENTITY gpl "&gnu; <acronym>GPL</acronym>">
]>
<refentry>
<refentryinfo>
<address>
&dhemail;
</address>
<author>
&dhfirstname;
&dhsurname;
</author>
<copyright>
<year>2003</year>
<holder>&dhusername;</holder>
</copyright>
&dhdate;
</refentryinfo>
<refmeta>
&dhucpackage;
&dhsection;
</refmeta>
<refnamediv>
<refname>&dhpackage;</refname>
<refpurpose>program to do something</refpurpose>
</refnamediv>
<refsynopsisdiv>
<cmdsynopsis>
<command>&dhpackage;</command>
<arg><option>-e <replaceable>this</replaceable></option></arg>
<arg><option>--example <replaceable>that</replaceable></option></arg>
</cmdsynopsis>
</refsynopsisdiv>
<refsect1>
<title>DESCRIPTION</title>
<para>This manual page documents briefly the
<command>&dhpackage;</command> and <command>bar</command>
commands.</para>
<para>This manual page was written for the &debian; distribution
because the original program does not have a manual page.
Instead, it has documentation in the &gnu;
<application>Info</application> format; see below.</para>
<para><command>&dhpackage;</command> is a program that...</para>
</refsect1>
<refsect1>
<title>OPTIONS</title>
<para>These programs follow the usual &gnu; command line syntax,
with long options starting with two dashes (`-'). A summary of
options is included below. For a complete description, see the
<application>Info</application> files.</para>
<variablelist>
<varlistentry>
<term><option>-h</option>
<option>--help</option>
</term>
<listitem>
<para>Show summary of options.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><option>-v</option>
<option>--version</option>
</term>
<listitem>
<para>Show version of program.</para>
</listitem>
</varlistentry>
</variablelist>
</refsect1>
<refsect1>
<title>SEE ALSO</title>
<para>bar (1), baz (1).</para>
<para>The programs are documented fully by <citetitle>The Rise and
Fall of a Fooish Bar</citetitle> available via the
<application>Info</application> system.</para>
</refsect1>
<refsect1>
<title>AUTHOR</title>
<para>This manual page was written by &dhusername; &dhemail; for
the &debian; system (but may be used by others). Permission is
granted to copy, distribute and/or modify this document under
the terms of the &gnu; General Public License, Version 2 any
later version published by the Free Software Foundation.
</para>
<para>
On Debian systems, the complete text of the GNU General Public
License can be found in /usr/share/common-licenses/GPL.
</para>
</refsect1>
</refentry>

2
3rdparty/toluapp/debian/menu.ex vendored Normal file
View File

@ -0,0 +1,2 @@
?package(tolua++):needs="X11|text|vc|wm" section="Apps/see-menu-manual"\
title="tolua++" command="/usr/bin/tolua++"

42
3rdparty/toluapp/debian/postinst.ex vendored Normal file
View File

@ -0,0 +1,42 @@
#! /bin/sh
# postinst script for tolua++
#
# see: dh_installdeb(1)
set -e
# summary of how this script can be called:
# * <postinst> `configure' <most-recently-configured-version>
# * <old-postinst> `abort-upgrade' <new version>
# * <conflictor's-postinst> `abort-remove' `in-favour' <package>
# <new-version>
# * <deconfigured's-postinst> `abort-deconfigure' `in-favour'
# <failed-install-package> <version> `removing'
# <conflicting-package> <version>
# for details, see http://www.debian.org/doc/debian-policy/ or
# the debian-policy package
#
case "$1" in
configure)
;;
abort-upgrade|abort-remove|abort-deconfigure)
;;
*)
echo "postinst called with unknown argument \`$1'" >&2
exit 1
;;
esac
# dh_installdeb will replace this with shell code automatically
# generated by other debhelper scripts.
#DEBHELPER#
exit 0

38
3rdparty/toluapp/debian/postrm.ex vendored Normal file
View File

@ -0,0 +1,38 @@
#! /bin/sh
# postrm script for tolua++
#
# see: dh_installdeb(1)
set -e
# summary of how this script can be called:
# * <postrm> `remove'
# * <postrm> `purge'
# * <old-postrm> `upgrade' <new-version>
# * <new-postrm> `failed-upgrade' <old-version>
# * <new-postrm> `abort-install'
# * <new-postrm> `abort-install' <old-version>
# * <new-postrm> `abort-upgrade' <old-version>
# * <disappearer's-postrm> `disappear' <r>overwrit>r> <new-version>
# for details, see http://www.debian.org/doc/debian-policy/ or
# the debian-policy package
case "$1" in
purge|remove|upgrade|failed-upgrade|abort-install|abort-upgrade|disappear)
;;
*)
echo "postrm called with unknown argument \`$1'" >&2
exit 1
esac
# dh_installdeb will replace this with shell code automatically
# generated by other debhelper scripts.
#DEBHELPER#
exit 0

44
3rdparty/toluapp/debian/preinst.ex vendored Normal file
View File

@ -0,0 +1,44 @@
#! /bin/sh
# preinst script for tolua++
#
# see: dh_installdeb(1)
set -e
# summary of how this script can be called:
# * <new-preinst> `install'
# * <new-preinst> `install' <old-version>
# * <new-preinst> `upgrade' <old-version>
# * <old-preinst> `abort-upgrade' <new-version>
#
# for details, see http://www.debian.org/doc/debian-policy/ or
# the debian-policy package
case "$1" in
install|upgrade)
# if [ "$1" = "upgrade" ]
# then
# start-stop-daemon --stop --quiet --oknodo \
# --pidfile /var/run/tolua++.pid \
# --exec /usr/sbin/tolua++ 2>/dev/null || true
# fi
;;
abort-upgrade)
;;
*)
echo "preinst called with unknown argument \`$1'" >&2
exit 1
;;
esac
# dh_installdeb will replace this with shell code automatically
# generated by other debhelper scripts.
#DEBHELPER#
exit 0

39
3rdparty/toluapp/debian/prerm.ex vendored Normal file
View File

@ -0,0 +1,39 @@
#! /bin/sh
# prerm script for tolua++
#
# see: dh_installdeb(1)
set -e
# summary of how this script can be called:
# * <prerm> `remove'
# * <old-prerm> `upgrade' <new-version>
# * <new-prerm> `failed-upgrade' <old-version>
# * <conflictor's-prerm> `remove' `in-favour' <package> <new-version>
# * <deconfigured's-prerm> `deconfigure' `in-favour'
# <package-being-installed> <version> `removing'
# <conflicting-package> <version>
# for details, see http://www.debian.org/doc/debian-policy/ or
# the debian-policy package
case "$1" in
remove|upgrade|deconfigure)
# install-info --quiet --remove /usr/info/tolua++.info.gz
;;
failed-upgrade)
;;
*)
echo "prerm called with unknown argument \`$1'" >&2
exit 1
;;
esac
# dh_installdeb will replace this with shell code automatically
# generated by other debhelper scripts.
#DEBHELPER#
exit 0

102
3rdparty/toluapp/debian/rules vendored Executable file
View File

@ -0,0 +1,102 @@
#!/usr/bin/make -f
# -*- makefile -*-
# Sample debian/rules that uses debhelper.
# This file was originally written by Joey Hess and Craig Small.
# As a special exception, when this file is copied by dh-make into a
# dh-make output file, you may use that output file without restriction.
# This special exception was added by Craig Small in version 0.37 of dh-make.
# Uncomment this to turn on verbose mode.
#export DH_VERBOSE=1
CFLAGS = -Wall -g
ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
CFLAGS += -O0
else
CFLAGS += -O2
endif
configure: configure-stamp
configure-stamp:
dh_testdir
# Add here commands to configure the package.
scons build_dev=0 prefix=$(CURDIR)/debian/tolua++/usr configure
touch configure-stamp
build: build-stamp
build-stamp: configure-stamp
dh_testdir
# Add here commands to compile the package.
#$(MAKE)
scons all
#docbook-to-man debian/tolua++.sgml > tolua++.1
touch build-stamp
clean:
dh_testdir
dh_testroot
rm -f build-stamp configure-stamp
# Add here commands to clean up after the build process.
#-$(MAKE) clean
scons -c build_dev=0 all configure
dh_clean
install: build
dh_testdir
dh_testroot
dh_clean -k
dh_installdirs
# Add here commands to install the package into debian/tolua++.
#$(MAKE) install DESTDIR=$(CURDIR)/debian/tolua++
scons install
# Build architecture-independent files here.
binary-indep: build install
# We have nothing to do by default.
# Build architecture-dependent files here.
binary-arch: build install
dh_testdir
dh_testroot
dh_installchangelogs
dh_installdocs
dh_installexamples
# dh_install
# dh_installmenu
# dh_installdebconf
# dh_installlogrotate
# dh_installemacsen
# dh_installpam
# dh_installmime
# dh_installinit
# dh_installcron
# dh_installinfo
dh_installman
dh_link
dh_strip
dh_compress
dh_fixperms
# dh_perl
# dh_python
# dh_makeshlibs
dh_installdeb
dh_shlibdeps
dh_gencontrol
dh_md5sums
dh_builddeb
binary: binary-indep binary-arch
.PHONY: build clean binary-indep binary-arch binary install configure

10
3rdparty/toluapp/debian/tolua++-default.ex vendored Normal file
View File

@ -0,0 +1,10 @@
# Defaults for tolua++ initscript
# sourced by /etc/init.d/tolua++
# installed at /etc/default/tolua++ by the maintainer scripts
#
# This is a POSIX shell fragment
#
# Additional options that are passed to the Daemon.
DAEMON_OPTS=""

22
3rdparty/toluapp/debian/tolua++.doc-base.EX vendored Normal file
View File

@ -0,0 +1,22 @@
Document: tolua++
Title: Debian tolua++ Manual
Author: <insert document author here>
Abstract: This manual describes what tolua++ is
and how it can be used to
manage online manuals on Debian systems.
Section: unknown
Format: debiandoc-sgml
Files: /usr/share/doc/tolua++/tolua++.sgml.gz
Format: postscript
Files: /usr/share/doc/tolua++/tolua++.ps.gz
Format: text
Files: /usr/share/doc/tolua++/tolua++.text.gz
Format: HTML
Index: /usr/share/doc/tolua++/html/index.html
Files: /usr/share/doc/tolua++/html/*.html

6
3rdparty/toluapp/debian/watch.ex vendored Normal file
View File

@ -0,0 +1,6 @@
# Example watch control file for uscan
# Rename this file to "watch" and then you can run the "uscan" command
# to check for upstream updates and more.
# Site Directory Pattern Version Script
version=2
sunsite.unc.edu /pub/Linux/Incoming tolua++-(.*)\.tar\.gz debian uupdate

14
3rdparty/toluapp/dist.info vendored Normal file
View File

@ -0,0 +1,14 @@
--- This file is part of LuaDist project
name = "toluapp"
version = "1.0.93"
desc = "tolua++ is an extension of toLua, a tool to integrate C/Cpp code with Lua."
author = "Waldemar Celes, Ariel Manzur"
license = "as-is"
url = "http://www.codenix.com/~tolua/"
maintainer = "Peter Kapec"
depends = {
"lua ~> 5.1"
}

226
3rdparty/toluapp/doc/index.html vendored Normal file
View File

@ -0,0 +1,226 @@
<head>
<title>toLua++ - binding c/c++ code to lua</title>
</head>
<body bgcolor="white">
<h1>
<img src="toluapp.gif">tolua++ - Home</h1>
<p>
<a href="#news">news</a> -
<a href="#download">download</a> - <a href="#documentation">documentation</a> - <a href="#installing">installing</a> -
<a href="mailto:tolua@codenix.com">contact</a> - <a href="lua_qt/">lua_qt</a> - <a href="http://www.codenix.com">Codenix</a>
<br>
<hr>
<b>tolua++</b> is an extended version of <a href="http://www.tecgraf.puc-rio.br/~celes/tolua/">tolua</a>, a tool to integrate
C/C++ code with <A HREF="http://www.tecgraf.puc-rio.br/lua">Lua</A>. <b>tolua++</b>
includes new features oriented to c++ such as:
<p>
<ul>
<li> Support for <b>std::string</b> as a <a href="#basics">basic type</a> (this can be turned off by a command line option).</li>
<li> Support for <a href="#templates">class templates</a></li>
</ul>
<p>
As well as other features and bugfixes.
<hr>
<a name="news"></a>
<h3>News:</h3>
<p>
<b>15/02/09</b>: Version <b><a href="tolua++-1.0.93.tar.bz2">1.0.93</a></b> released. Some bugfixes and new features:
<p>
<ul>
<li> Build process bootstraps.
<li> Added hooks to handle custom types.
<li> Added hooks to handle exceptions.
<li> Fixed issues with newer GCC compilers.
<li> Changed to MIT license. See <a href="COPYRIGHT">COPYRIGHT</a> file for details.
</ul>
<b>27/04/06</b>: Version <b><a href="tolua++-1.0.92.tar.bz2">1.0.92</a></b> released. Some bugfixes and new features:
<p>
<ul>
<li> Fixed garbage collector bug for C objects.
<li> Fixed problems with C compilers (including microsoft's)
<li> Added a .proj file to build with Visual Studio 7 (contributed by Makoto Hamanaka).
<li> New command line option: <tt>-E</tt> to define extra values
<li> New command line option: <tt>-t</tt> to associate C++ types with their lua names (see the <a href="tolua++.html">manual</a> for details)
</ul>
<b>25/02/06</b>: Version <b><a href="tolua++-1.0.91.tar.bz2">1.0.91</a></b> released. This version contains a small garbage collection bugfix for 1.0.90 (thanks to Rolf E. Thorup for the report), everyone should upgrade.
<p>
<b>18/02/06</b>: Version <b><a href="tolua++-1.0.90.tar.bz2">1.0.90</a></b> released. Some bugfixes and new features:
<p>
<ul>
<li> <b>lua 5.1</b> support (see <tt>README-5.1</tt>)
<li> Support for casting operators (for example <tt>operator const char();</tt>)
<li> New utility functions, <tt>tolua.setpeer</tt> and <tt>tolua.getpeer</tt>, for easier (and faster) inheritance from C/C++ objects (only for lua 5.1)
<li> Some small API changes (see the <a href="tolua++.html#compatibility">compatibility section</a> of the manual)
</ul>
<p>
<b>18/10/05</b>: Version <b><a href="tolua++_1.0.7-1.tar.gz">1.0.7</a></b> released. Some bugfixes and new features:
<p>
<ul>
<li> New command line option: -C, to disable the cleanup of included lua code (for easier debugging).
<li> Merged <a href="http://lua-users.org/lists/lua-l/2005-09/msg00227.html">Mildred's</a> patch: embedded lua chunks have better names, code on package initializer function is nested.
<li> New hook: <tt>parser_hook</tt>, allows modifications to the behavior of the main parser.
<li> Objects can be private (or protected). This doesn't affect the normal usage (everything is public by default), but it's useful to declare types that don't export any code, but serve
as 'support' for other declarations.
<li> Misc bugfixes.
</ul>
<p>
<b>01/9/05</b>: Version <b><a href="tolua++_1.0.6-1.tar.gz">1.0.6</a></b> released. Several bugfixes and new features:
<p>
<ul>
<li> Classes can have properties, using the 'tolua_property' keyboard. Property types are customizable.
<li> Added a command line flag -D, to disable automatic generation of destructors for all classes with constructors (for compatibility with tolua5)
<li> Classes with protected or private destructors can be tagged individually using the "TOLUA_PROTECTED_DESTRUCTOR" macro.
<li> Added utility function "tolua.inherit", to allow a lua table to "inherit" from an instance of a C/C++ class
<li> Fixed class constructor bug (it is now possible to use 'ClassName()' to create a lua-owned instance of the class without problems)
<li> Misc bugfixes.
</ul>
<p>
<b>10/4/05</b>: Version <b><a href="tolua++_1.0.5-1.tar.gz">1.0.5</a></b> released. This version contains some minor bugfixes and a new feature,
the <b>tolua_outside</b> keyword, used to specify regular functions as methods of classes or structs. This release is also paired with <a href="lua_qt/">lua_qt</a>
version 0.0.1a.
<p>
<b>1/2/05</b>: version <b><a href="tolua++-1.0.4.tar.bz2">1.0.4</a></b> released. This version contains some bugfixes and new features:
<p>
<ul>
<li> Ability to customize tolua++'s behaviour to add functionality.
<li> Basic support for multiple inheritance.
<li> Several bugfixes on the parser.
<li> <a href="tolua++_1.0.4-3_i386.deb">Debian package</a> available for download.
</ul>
<p>
Most of the changes on this version were added for <a href="lua_qt/">lua_qt</a>, a package
to bind the <a href="http://www.trolltech.com/products/qt/index.html">Qt</a> toolkit to lua.
<p>
<b>20/9/04</b>: version <b><a href="tolua++-1.0.3.tar.bz2">1.0.3</a></b> released. This version contains major bugfixes:
<p>
<ul>
<li> Fixed bugs in object tracking (the 'memory address' bug; there's still some work left, but people should be able to use <tt>union</tt>s with no problems)</li>
<li> Fixed parser bugs, functions with template parameters should work, also functions with default parameters that call constructos and with commas on them should work.</li>
<li> Added a <tt>__call</tt> method for class names, to replace <tt>new_local</tt> to create instances owned by lua.
<li> Fixed other minor bugs.</li>
<li> Removed the link to win32 binaries, since I aparently don't know what the hell I'm doing with a microsoft compiler ;-)</li>
</ul>
<p>
Everyone should upgrade.
<p>
<b>23/10/03</b>: version <b><a href="tolua++-1.0.2.tar.bz2">1.0.2</a></b> released. This version contains major bugfixes:
<p>
<ul>
<li> Fixed bugs in gargabe collection (thanks to <b>Christian Vogler</b> for doing all the work :-)</li>
<li> <tt>namespace</tt>s and nested types are now fully supported.</li>
<li> Fixed other minor bugs.</li>
</ul>
<p>
Everyone should upgrade.
<hr>
<a name="download"></a>
<h3>Downloading</B></H3>
The latest development version of the code is available through SVN from tolua++'s BerliOS project page. You can checkout using:
svn checkout svn://svn.berlios.de/toluapp/trunk
The <B>tolua++</B> source is freely available by http.
The software provided under the terms of the MIT license. See the <a href="COPYRIGHT">COPYRIGHT</a> file distributed
with the source.
<p>
Current version is <b><a href="tolua++-1.0.93.tar.bz2">1.0.93</a></b>, older versions:
<p>
<li> <a href="tolua++-1.0.93.tar.bz2">tolua++-1.0.93.tar.bz2</a>
<li> <a href="tolua++-1.0.92.tar.bz2">tolua++-1.0.92.tar.bz2</a>
<li> <a href="tolua++-1.0.91.tar.bz2">tolua++-1.0.91.tar.bz2</a>
<li> <a href="tolua++_1.0.7-1.tar.gz">tolua++_1.0.7-1.tar.gz</a> [<a href="tolua++_1.0.7-1_i386.deb">deb</a>]
<li> <a href="tolua++_1.0.6-1.tar.gz">tolua++_1.0.6-1.tar.gz</a> [<a href="tolua++_1.0.6-1_i386.deb">deb</a>]
<li> <a href="tolua++_1.0.5-1.tar.gz">tolua++_1.0.5-1.tar.gz</a> [<a href="tolua++_1.0.5-1_i386.deb">deb</a>]
<li> <a href="tolua++-1.0.4.tar.bz2">tolua++-1.0.4.tar.bz2</a> [<a href="tolua++_1.0.4-3_i386.deb">deb</a>]
<li> <a href="tolua++-1.0.3.tar.bz2">tolua++-1.0.3.tar.bz2</a>
<li> <a href="tolua++-1.0.2.tar.bz2">tolua++-1.0.2.tar.bz2</a>
<li> <a href="tolua++-1.0.tar.bz2">tolua++-1.0.tar.bz2</a>
<hr>
<a name="documentation"></a>
<h3>Documentation</h3>
<p>
You can find the manual <a href="tolua++.html">here</a> or under the doc/ directory
on the distribution.
<p>
I'll also be adding interesting addons/examples to <a href="http://lua-users.org/wiki/ArielManzur">my page</a>
on the <a href="http://lua-users.org/">lua-users wiki</a>.
<hr>
<a name="installing"></a>
<h3>Instalation</h3>
<p>
tolua++ uses <a href="http://www.scons.org">SCons</a> to build. SCons is based on
python, you can get a stand-alone version on <a href="http://www.scons.org">
their website</a>. After you have SCons, follow this simple instructions:
<p>
<li> Type '<b>scons all</b>' to compile.</li>
<li> Type '<b>scons install</b>'. The default install prefix is /usr/local, so if you are
on a POSIX system, it should work. On other systems, you can change it with the
'<b>prefix</b>' option on command line.
<p>
<b>scons prefix=/usr install</b>
<p>
<i>or on windows</i>
<p>
<b>scons "prefix=c:\Program Files\Visual C" install</b>
<p>
Use <b>scons -h</b> to see a list of available command line options.
<p>
The files you need (in case you want to do a <b>manual install</b>) are:
<ul>
<li> bin/tolua++[.exe] - the main binary
<li> include/tolua++.h - the header file
<li> lib/libtolua++.a <i>or</i> lib/tolua++.lib - the library
</ul>
<li> See INSTALL for instructions on how to install without SCons. There are also instructions on how
to build without scons at the <a href="http://lua-users.org/wiki/CompilingToluappWithoutScons">lua-users wiki</a>
(if you know the author of this, <a href="mailto:tolua@codenix.com">contact me</a>)</li>
<li> For <b>lua 5.1</b>, see <tt>README-5.1</tt>
<hr>
<b>tolua++</b> and this website are maintained by Ariel Manzur.<br>
<a href="http://www.codenix.com/index.php?section=contact">Contact us</a> with any
bugs, fixes, suggestions, or questions about this package.
<hr>
</body>

1956
3rdparty/toluapp/doc/tolua++.html vendored Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
3rdparty/toluapp/doc/toluapp.gif vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.8 KiB

186
3rdparty/toluapp/include/tolua++.h vendored Normal file
View File

@ -0,0 +1,186 @@
/* tolua
** Support code for Lua bindings.
** Written by Waldemar Celes
** TeCGraf/PUC-Rio
** Apr 2003
** $Id: $
*/
/* This code is free software; you can redistribute it and/or modify it.
** The software provided hereunder is on an "as is" basis, and
** the author has no obligation to provide maintenance, support, updates,
** enhancements, or modifications.
*/
#ifndef TOLUA_H
#define TOLUA_H
#ifndef TOLUA_API
#define TOLUA_API extern
#endif
#define TOLUA_VERSION "tolua++-1.0.92"
#ifdef __cplusplus
extern "C" {
#endif
#define tolua_pushcppstring(x,y) tolua_pushstring(x,y.c_str())
#define tolua_iscppstring tolua_isstring
#define tolua_iscppstringarray tolua_isstringarray
#define tolua_pushfieldcppstring(L,lo,idx,s) tolua_pushfieldstring(L, lo, idx, s.c_str())
#ifndef TEMPLATE_BIND
#define TEMPLATE_BIND(p)
#endif
#define TOLUA_TEMPLATE_BIND(p)
#define TOLUA_PROTECTED_DESTRUCTOR
#define TOLUA_PROPERTY_TYPE(p)
typedef int lua_Object;
#include <lua.h>
#include <lauxlib.h>
struct tolua_Error
{
int index;
int array;
const char* type;
};
typedef struct tolua_Error tolua_Error;
#define TOLUA_NOPEER LUA_REGISTRYINDEX /* for lua 5.1 */
TOLUA_API const char* tolua_typename (lua_State* L, int lo);
TOLUA_API void tolua_error (lua_State* L, const char* msg, tolua_Error* err);
TOLUA_API int tolua_isnoobj (lua_State* L, int lo, tolua_Error* err);
TOLUA_API int tolua_isvalue (lua_State* L, int lo, int def, tolua_Error* err);
TOLUA_API int tolua_isvaluenil (lua_State* L, int lo, tolua_Error* err);
TOLUA_API int tolua_isboolean (lua_State* L, int lo, int def, tolua_Error* err);
TOLUA_API int tolua_isnumber (lua_State* L, int lo, int def, tolua_Error* err);
TOLUA_API int tolua_isstring (lua_State* L, int lo, int def, tolua_Error* err);
TOLUA_API int tolua_istable (lua_State* L, int lo, int def, tolua_Error* err);
TOLUA_API int tolua_isusertable (lua_State* L, int lo, const char* type, int def, tolua_Error* err);
TOLUA_API int tolua_isuserdata (lua_State* L, int lo, int def, tolua_Error* err);
TOLUA_API int tolua_isusertype (lua_State* L, int lo, const char* type, int def, tolua_Error* err);
TOLUA_API int tolua_isvaluearray
(lua_State* L, int lo, int dim, int def, tolua_Error* err);
TOLUA_API int tolua_isbooleanarray
(lua_State* L, int lo, int dim, int def, tolua_Error* err);
TOLUA_API int tolua_isnumberarray
(lua_State* L, int lo, int dim, int def, tolua_Error* err);
TOLUA_API int tolua_isstringarray
(lua_State* L, int lo, int dim, int def, tolua_Error* err);
TOLUA_API int tolua_istablearray
(lua_State* L, int lo, int dim, int def, tolua_Error* err);
TOLUA_API int tolua_isuserdataarray
(lua_State* L, int lo, int dim, int def, tolua_Error* err);
TOLUA_API int tolua_isusertypearray
(lua_State* L, int lo, const char* type, int dim, int def, tolua_Error* err);
TOLUA_API void tolua_open (lua_State* L);
TOLUA_API void* tolua_copy (lua_State* L, void* value, unsigned int size);
TOLUA_API int tolua_register_gc (lua_State* L, int lo);
TOLUA_API int tolua_default_collect (lua_State* tolua_S);
TOLUA_API void tolua_usertype (lua_State* L, const char* type);
TOLUA_API void tolua_beginmodule (lua_State* L, const char* name);
TOLUA_API void tolua_endmodule (lua_State* L);
TOLUA_API void tolua_module (lua_State* L, const char* name, int hasvar);
TOLUA_API void tolua_class (lua_State* L, const char* name, const char* base);
TOLUA_API void tolua_cclass (lua_State* L, const char* lname, const char* name, const char* base, lua_CFunction col);
TOLUA_API void tolua_function (lua_State* L, const char* name, lua_CFunction func);
TOLUA_API void tolua_constant (lua_State* L, const char* name, lua_Number value);
TOLUA_API void tolua_variable (lua_State* L, const char* name, lua_CFunction get, lua_CFunction set);
TOLUA_API void tolua_array (lua_State* L,const char* name, lua_CFunction get, lua_CFunction set);
/* TOLUA_API void tolua_set_call_event(lua_State* L, lua_CFunction func, char* type); */
/* TOLUA_API void tolua_addbase(lua_State* L, char* name, char* base); */
TOLUA_API void tolua_pushvalue (lua_State* L, int lo);
TOLUA_API void tolua_pushboolean (lua_State* L, int value);
TOLUA_API void tolua_pushnumber (lua_State* L, lua_Number value);
TOLUA_API void tolua_pushstring (lua_State* L, const char* value);
TOLUA_API void tolua_pushuserdata (lua_State* L, void* value);
TOLUA_API void tolua_pushusertype (lua_State* L, void* value, const char* type);
TOLUA_API void tolua_pushusertype_and_takeownership(lua_State* L, void* value, const char* type);
TOLUA_API void tolua_pushfieldvalue (lua_State* L, int lo, int index, int v);
TOLUA_API void tolua_pushfieldboolean (lua_State* L, int lo, int index, int v);
TOLUA_API void tolua_pushfieldnumber (lua_State* L, int lo, int index, lua_Number v);
TOLUA_API void tolua_pushfieldstring (lua_State* L, int lo, int index, const char* v);
TOLUA_API void tolua_pushfielduserdata (lua_State* L, int lo, int index, void* v);
TOLUA_API void tolua_pushfieldusertype (lua_State* L, int lo, int index, void* v, const char* type);
TOLUA_API void tolua_pushfieldusertype_and_takeownership (lua_State* L, int lo, int index, void* v, const char* type);
TOLUA_API lua_Number tolua_tonumber (lua_State* L, int narg, lua_Number def);
TOLUA_API const char* tolua_tostring (lua_State* L, int narg, const char* def);
TOLUA_API void* tolua_touserdata (lua_State* L, int narg, void* def);
TOLUA_API void* tolua_tousertype (lua_State* L, int narg, void* def);
TOLUA_API int tolua_tovalue (lua_State* L, int narg, int def);
TOLUA_API int tolua_toboolean (lua_State* L, int narg, int def);
TOLUA_API lua_Number tolua_tofieldnumber (lua_State* L, int lo, int index, lua_Number def);
TOLUA_API const char* tolua_tofieldstring (lua_State* L, int lo, int index, const char* def);
TOLUA_API void* tolua_tofielduserdata (lua_State* L, int lo, int index, void* def);
TOLUA_API void* tolua_tofieldusertype (lua_State* L, int lo, int index, void* def);
TOLUA_API int tolua_tofieldvalue (lua_State* L, int lo, int index, int def);
TOLUA_API int tolua_getfieldboolean (lua_State* L, int lo, int index, int def);
TOLUA_API void tolua_dobuffer(lua_State* L, char* B, unsigned int size, const char* name);
TOLUA_API int class_gc_event (lua_State* L);
#ifdef __cplusplus
static inline const char* tolua_tocppstring (lua_State* L, int narg, const char* def) {
const char* s = tolua_tostring(L, narg, def);
return s?s:"";
};
static inline const char* tolua_tofieldcppstring (lua_State* L, int lo, int index, const char* def) {
const char* s = tolua_tofieldstring(L, lo, index, def);
return s?s:"";
};
#else
#define tolua_tocppstring tolua_tostring
#define tolua_tofieldcppstring tolua_tofieldstring
#endif
TOLUA_API int tolua_fast_isa(lua_State *L, int mt_indexa, int mt_indexb, int super_index);
#ifndef Mtolua_new
#define Mtolua_new(EXP) new EXP
#endif
#ifndef Mtolua_delete
#define Mtolua_delete(EXP) delete EXP
#endif
#ifndef Mtolua_new_dim
#define Mtolua_new_dim(EXP, len) new EXP[len]
#endif
#ifndef Mtolua_delete_dim
#define Mtolua_delete_dim(EXP) delete [] EXP
#endif
#ifndef tolua_outside
#define tolua_outside
#endif
#ifndef tolua_owned
#define tolua_owned
#endif
#ifdef __cplusplus
}
#endif
#endif

65
3rdparty/toluapp/libtoluapp.def vendored Normal file
View File

@ -0,0 +1,65 @@
EXPORTS
class_gc_event
push_table_instance
tolua_array
tolua_beginmodule
tolua_cclass
tolua_classevents
tolua_constant
tolua_copy
tolua_default_collect
tolua_dobuffer
tolua_endmodule
tolua_error
tolua_fast_isa
tolua_function
tolua_getfieldboolean
tolua_isboolean
tolua_isbooleanarray
tolua_ismodulemetatable
tolua_isnoobj
tolua_isnumber
tolua_isnumberarray
tolua_isstring
tolua_isstringarray
tolua_istable
tolua_istablearray
tolua_isuserdata
tolua_isuserdataarray
tolua_isusertable
tolua_isusertype
tolua_isusertypearray
tolua_isvalue
tolua_isvaluearray
tolua_module
tolua_moduleevents
tolua_open
tolua_pushboolean
tolua_pushfieldboolean
tolua_pushfieldnumber
tolua_pushfieldstring
tolua_pushfielduserdata
tolua_pushfieldusertype
tolua_pushfieldusertype_and_takeownership
tolua_pushfieldvalue
tolua_pushnumber
tolua_pushstring
tolua_pushuserdata
tolua_pushusertype
tolua_pushusertype_and_takeownership
tolua_pushvalue
tolua_register_gc
tolua_toboolean
tolua_tofieldnumber
tolua_tofieldstring
tolua_tofielduserdata
tolua_tofieldusertype
tolua_tofieldvalue
tolua_tonumber
tolua_tostring
tolua_touserdata
tolua_tousertype
tolua_tovalue
tolua_typename
tolua_usertype
tolua_variable

12
3rdparty/toluapp/src/bin/SCsub vendored Normal file
View File

@ -0,0 +1,12 @@
Import('env')
src = [
env.Object('tolua.c'),
]
#toluabind = env.LuaBinding('toluabind.c', 'tolua_scons.pkg', 'tolua', bootstrap = True)
env.bin_target = env.Program('#/bin/'+env['tolua_bin'], src, LIBS = ['$tolua_lib'] + env['LIBS'])
env.bootstrap_target = env.Program('#/bin/'+env['TOLUAPP_BOOTSTRAP'], src + ['toluabind_default.c', env.lib_target_static], LIBS = env['LIBS'])

30
3rdparty/toluapp/src/bin/lua/all.lua vendored Normal file
View File

@ -0,0 +1,30 @@
dofile(path.."compat-5.1.lua")
dofile(path.."compat.lua")
dofile(path.."feature.lua")
dofile(path.."verbatim.lua")
dofile(path.."basic.lua")
dofile(path.."code.lua")
dofile(path.."typedef.lua")
dofile(path.."container.lua")
dofile(path.."package.lua")
dofile(path.."module.lua")
dofile(path.."namespace.lua")
dofile(path.."define.lua")
dofile(path.."enumerate.lua")
dofile(path.."declaration.lua")
dofile(path.."variable.lua")
dofile(path.."array.lua")
dofile(path.."function.lua")
dofile(path.."operator.lua")
dofile(path.."template_class.lua")
dofile(path.."class.lua")
dofile(path.."clean.lua")
--dofile(path.."custom.lua")
dofile(path.."doit.lua")
local err,msg = xpcall(doit, debug.traceback)
if not err then
--print("**** msg is "..tostring(msg))
local _,_,label,msg = strfind(msg,"(.-:.-:%s*)(.*)")
tolua_error(msg,label)
end

233
3rdparty/toluapp/src/bin/lua/array.lua vendored Normal file
View File

@ -0,0 +1,233 @@
-- tolua: array class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1999
-- $Id: array.lua,v 1.1 2000/11/06 22:03:57 celes Exp $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Array class
-- Represents a extern array variable or a public member of a class.
-- Stores all fields present in a declaration.
classArray = {
}
classArray.__index = classArray
setmetatable(classArray,classDeclaration)
-- Print method
function classArray:print (ident,close)
print(ident.."Array{")
print(ident.." mod = '"..self.mod.."',")
print(ident.." type = '"..self.type.."',")
print(ident.." ptr = '"..self.ptr.."',")
print(ident.." name = '"..self.name.."',")
print(ident.." def = '"..self.def.."',")
print(ident.." dim = '"..self.dim.."',")
print(ident.." ret = '"..self.ret.."',")
print(ident.."}"..close)
end
-- check if it is a variable
function classArray:isvariable ()
return true
end
-- get variable value
function classArray:getvalue (class,static)
if class and static then
return class..'::'..self.name..'[tolua_index]'
elseif class then
return 'self->'..self.name..'[tolua_index]'
else
return self.name..'[tolua_index]'
end
end
-- Write binding functions
function classArray:supcode ()
local class = self:inclass()
-- get function ------------------------------------------------
if class then
output("/* get function:",self.name," of class ",class," */")
else
output("/* get function:",self.name," */")
end
self.cgetname = self:cfuncname("tolua_get")
output("#ifndef TOLUA_DISABLE_"..self.cgetname)
output("\nstatic int",self.cgetname,"(lua_State* tolua_S)")
output("{")
output(" int tolua_index;")
-- declare self, if the case
local _,_,static = strfind(self.mod,'^%s*(static)')
if class and static==nil then
output(' ',self.parent.type,'*','self;')
output(' lua_pushstring(tolua_S,".self");')
output(' lua_rawget(tolua_S,1);')
output(' self = ')
output('(',self.parent.type,'*) ')
output('lua_touserdata(tolua_S,-1);')
elseif static then
_,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
end
-- check index
output('#ifndef TOLUA_RELEASE\n')
output(' {')
output(' tolua_Error tolua_err;')
output(' if (!tolua_isnumber(tolua_S,2,0,&tolua_err))')
output(' tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);')
output(' }')
output('#endif\n')
if flags['1'] then -- for compatibility with tolua5 ?
output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;')
else
output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0);')
end
output('#ifndef TOLUA_RELEASE\n')
if self.dim and self.dim ~= '' then
output(' if (tolua_index<0 || tolua_index>='..self.dim..')')
else
output(' if (tolua_index<0)')
end
output(' tolua_error(tolua_S,"array indexing out of range.",NULL);')
output('#endif\n')
-- return value
local t,ct = isbasic(self.type)
local push_func = get_push_function(t)
if t then
output(' tolua_push'..t..'(tolua_S,(',ct,')'..self:getvalue(class,static)..');')
else
t = self.type
if self.ptr == '&' or self.ptr == '' then
output(' ',push_func,'(tolua_S,(void*)&'..self:getvalue(class,static)..',"',t,'");')
else
output(' ',push_func,'(tolua_S,(void*)'..self:getvalue(class,static)..',"',t,'");')
end
end
output(' return 1;')
output('}')
output('#endif //#ifndef TOLUA_DISABLE\n')
output('\n')
-- set function ------------------------------------------------
if not strfind(self.type,'const') then
if class then
output("/* set function:",self.name," of class ",class," */")
else
output("/* set function:",self.name," */")
end
self.csetname = self:cfuncname("tolua_set")
output("#ifndef TOLUA_DISABLE_"..self.csetname)
output("\nstatic int",self.csetname,"(lua_State* tolua_S)")
output("{")
-- declare index
output(' int tolua_index;')
-- declare self, if the case
local _,_,static = strfind(self.mod,'^%s*(static)')
if class and static==nil then
output(' ',self.parent.type,'*','self;')
output(' lua_pushstring(tolua_S,".self");')
output(' lua_rawget(tolua_S,1);')
output(' self = ')
output('(',self.parent.type,'*) ')
output('lua_touserdata(tolua_S,-1);')
elseif static then
_,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
end
-- check index
output('#ifndef TOLUA_RELEASE\n')
output(' {')
output(' tolua_Error tolua_err;')
output(' if (!tolua_isnumber(tolua_S,2,0,&tolua_err))')
output(' tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);')
output(' }')
output('#endif\n')
if flags['1'] then -- for compatibility with tolua5 ?
output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;')
else
output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0);')
end
output('#ifndef TOLUA_RELEASE\n')
if self.dim and self.dim ~= '' then
output(' if (tolua_index<0 || tolua_index>='..self.dim..')')
else
output(' if (tolua_index<0)')
end
output(' tolua_error(tolua_S,"array indexing out of range.",NULL);')
output('#endif\n')
-- assign value
local ptr = ''
if self.ptr~='' then ptr = '*' end
output(' ')
if class and static then
output(class..'::'..self.name..'[tolua_index]')
elseif class then
output('self->'..self.name..'[tolua_index]')
else
output(self.name..'[tolua_index]')
end
local t = isbasic(self.type)
output(' = ')
if not t and ptr=='' then output('*') end
output('((',self.mod,self.type)
if not t then
output('*')
end
output(') ')
local def = 0
if self.def ~= '' then def = self.def end
if t then
output('tolua_to'..t,'(tolua_S,3,',def,'));')
else
local to_func = get_to_function(self.type)
output(to_func,'(tolua_S,3,',def,'));')
end
output(' return 0;')
output('}')
output('#endif //#ifndef TOLUA_DISABLE\n')
output('\n')
end
end
function classArray:register (pre)
if not self:check_public_access() then
return
end
pre = pre or ''
if self.csetname then
output(pre..'tolua_array(tolua_S,"'..self.lname..'",'..self.cgetname..','..self.csetname..');')
else
output(pre..'tolua_array(tolua_S,"'..self.lname..'",'..self.cgetname..',NULL);')
end
end
-- Internal constructor
function _Array (t)
setmetatable(t,classArray)
append(t)
return t
end
-- Constructor
-- Expects a string representing the variable declaration.
function Array (s)
return _Array (Declaration(s,'var'))
end

417
3rdparty/toluapp/src/bin/lua/basic.lua vendored Normal file
View File

@ -0,0 +1,417 @@
-- tolua: basic utility functions
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- Last update: Apr 2003
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Basic C types and their corresponding Lua types
-- All occurrences of "char*" will be replaced by "_cstring",
-- and all occurrences of "void*" will be replaced by "_userdata"
_basic = {
['void'] = '',
['char'] = 'number',
['int'] = 'number',
['short'] = 'number',
['long'] = 'number',
['unsigned'] = 'number',
['float'] = 'number',
['double'] = 'number',
['_cstring'] = 'string',
['_userdata'] = 'userdata',
['char*'] = 'string',
['void*'] = 'userdata',
['bool'] = 'boolean',
['lua_Object'] = 'value',
['LUA_VALUE'] = 'value', -- for compatibility with tolua 4.0
['lua_State*'] = 'state',
['_lstate'] = 'state',
['lua_Function'] = 'value',
}
_basic_ctype = {
number = "lua_Number",
string = "const char*",
userdata = "void*",
boolean = "bool",
value = "int",
state = "lua_State*",
}
-- functions the are used to do a 'raw push' of basic types
_basic_raw_push = {}
-- List of user defined types
-- Each type corresponds to a variable name that stores its tag value.
_usertype = {}
-- List of types that have to be collected
_collect = {}
-- List of types
_global_types = {n=0}
_global_types_hash = {}
-- list of classes
_global_classes = {}
-- List of enum constants
_global_enums = {}
-- List of auto renaming
_renaming = {}
function appendrenaming (s)
local b,e,old,new = strfind(s,"%s*(.-)%s*@%s*(.-)%s*$")
if not b then
error("#Invalid renaming syntax; it should be of the form: pattern@pattern")
end
tinsert(_renaming,{old=old, new=new})
end
function applyrenaming (s)
for i,v in ipairs(_renaming) do
local m,n = gsub(s,v.old,v.new)
if n ~= 0 then
return m
end
end
return nil
end
-- Error handler
function tolua_error (s,f)
if _curr_code then
print("***curr code for error is "..tostring(_curr_code))
print(debug.traceback())
end
local out = _OUTPUT
_OUTPUT = _STDERR
if strsub(s,1,1) == '#' then
write("\n** tolua: "..strsub(s,2)..".\n\n")
if _curr_code then
local _,_,s = strfind(_curr_code,"^%s*(.-\n)") -- extract first line
if s==nil then s = _curr_code end
s = gsub(s,"_userdata","void*") -- return with 'void*'
s = gsub(s,"_cstring","char*") -- return with 'char*'
s = gsub(s,"_lstate","lua_State*") -- return with 'lua_State*'
write("Code being processed:\n"..s.."\n")
end
else
if not f then f = "(f is nil)" end
print("\n** tolua internal error: "..f..s..".\n\n")
return
end
_OUTPUT = out
end
function warning (msg)
if flags.q then return end
local out = _OUTPUT
_OUTPUT = _STDERR
write("\n** tolua warning: "..msg..".\n\n")
_OUTPUT = out
end
-- register an user defined type: returns full type
function regtype (t)
--if isbasic(t) then
-- return t
--end
local ft = findtype(t)
if not _usertype[ft] then
return appendusertype(t)
end
return ft
end
-- return type name: returns full type
function typevar(type)
if type == '' or type == 'void' then
return type
else
local ft = findtype(type)
if ft then
return ft
end
_usertype[type] = type
return type
end
end
-- check if basic type
function isbasic (type)
local t = gsub(type,'const ','')
local m,t = applytypedef('', t)
local b = _basic[t]
if b then
return b,_basic_ctype[b]
end
return nil
end
-- split string using a token
function split (s,t)
local l = {n=0}
local f = function (s)
l.n = l.n + 1
l[l.n] = s
return ""
end
local p = "%s*(.-)%s*"..t.."%s*"
s = gsub(s,"^%s+","")
s = gsub(s,"%s+$","")
s = gsub(s,p,f)
l.n = l.n + 1
l[l.n] = gsub(s,"(%s%s*)$","")
return l
end
-- splits a string using a pattern, considering the spacial cases of C code (templates, function parameters, etc)
-- pattern can't contain the '^' (as used to identify the begining of the line)
-- also strips whitespace
function split_c_tokens(s, pat)
s = string.gsub(s, "^%s*", "")
s = string.gsub(s, "%s*$", "")
local token_begin = 1
local token_end = 1
local ofs = 1
local ret = {n=0}
function add_token(ofs)
local t = string.sub(s, token_begin, ofs)
t = string.gsub(t, "^%s*", "")
t = string.gsub(t, "%s*$", "")
ret.n = ret.n + 1
ret[ret.n] = t
end
while ofs <= string.len(s) do
local sub = string.sub(s, ofs, -1)
local b,e = string.find(sub, "^"..pat)
if b then
add_token(ofs-1)
ofs = ofs+e
token_begin = ofs
else
local char = string.sub(s, ofs, ofs)
if char == "(" or char == "<" then
local block
if char == "(" then block = "^%b()" end
if char == "<" then block = "^%b<>" end
b,e = string.find(sub, block)
if not b then
-- unterminated block?
ofs = ofs+1
else
ofs = ofs + e
end
else
ofs = ofs+1
end
end
end
add_token(ofs)
--if ret.n == 0 then
-- ret.n=1
-- ret[1] = ""
--end
return ret
end
-- concatenate strings of a table
function concat (t,f,l,jstr)
jstr = jstr or " "
local s = ''
local i=f
while i<=l do
s = s..t[i]
i = i+1
if i <= l then s = s..jstr end
end
return s
end
-- concatenate all parameters, following output rules
function concatparam (line, ...)
local i=1
local arg={...}
while i<=#arg do
if _cont and not strfind(_cont,'[%(,"]') and
strfind(arg[i],"^[%a_~]") then
line = line .. ' '
end
line = line .. arg[i]
if arg[i] ~= '' then
_cont = strsub(arg[i],-1,-1)
end
i = i+1
end
if strfind(arg[#arg],"[%/%)%;%{%}]$") then
_cont=nil line = line .. '\n'
end
return line
end
-- output line
function output (...)
local i=1
local arg = {...}
while i<=#arg do
if _cont and not strfind(_cont,'[%(,"]') and
strfind(arg[i],"^[%a_~]") then
write(' ')
end
write(arg[i])
if arg[i] ~= '' then
_cont = strsub(arg[i],-1,-1)
end
i = i+1
end
if strfind(arg[#arg],"[%/%)%;%{%}]$") then
_cont=nil write('\n')
end
end
function get_property_methods(ptype, name)
if get_property_methods_hook and get_property_methods_hook(ptype,name) then
return get_property_methods_hook(ptype, name)
end
if ptype == "default" then -- get_name, set_name
return "get_"..name, "set_"..name
end
if ptype == "qt" then -- name, setName
return name, "set"..string.upper(string.sub(name, 1, 1))..string.sub(name, 2, -1)
end
if ptype == "overload" then -- name, name
return name,name
end
return nil
end
-------------- the hooks
-- called right after processing the $[ichl]file directives,
-- right before processing anything else
-- takes the package object as the parameter
function preprocess_hook(p)
-- p.code has all the input code from the pkg
end
-- called for every $ifile directive
-- takes a table with a string called 'code' inside, the filename, and any extra arguments
-- passed to $ifile. no return value
function include_file_hook(t, filename, ...)
end
-- called after processing anything that's not code (like '$renaming', comments, etc)
-- and right before parsing the actual code.
-- takes the Package object with all the code on the 'code' key. no return value
function preparse_hook(package)
end
-- called before starting output
function pre_output_hook(package)
end
-- called after writing all the output.
-- takes the Package object
function post_output_hook(package)
end
-- called from 'get_property_methods' to get the methods to retrieve a property
-- according to its type
function get_property_methods_hook(property_type, name)
end
-- called from ClassContainer:doparse with the string being parsed
-- return nil, or a substring
function parser_hook(s)
return nil
end
-- called from classFunction:supcode, before the call to the function is output
function pre_call_hook(f)
end
-- called from classFunction:supcode, after the call to the function is output
function post_call_hook(f)
end
-- called before the register code is output
function pre_register_hook(package)
end
-- called to output an error message
function output_error_hook(...)
return string.format(table.unpack{...})
end
-- custom pushers
_push_functions = {}
_is_functions = {}
_to_functions = {}
_base_push_functions = {}
_base_is_functions = {}
_base_to_functions = {}
local function search_base(t, funcs)
local class = _global_classes[t]
while class do
if funcs[class.type] then
return funcs[class.type]
end
class = _global_classes[class.btype]
end
return nil
end
function get_push_function(t)
return _push_functions[t] or search_base(t, _base_push_functions) or "tolua_pushusertype"
end
function get_to_function(t)
return _to_functions[t] or search_base(t, _base_to_functions) or "tolua_tousertype"
end
function get_is_function(t)
return _is_functions[t] or search_base(t, _base_is_functions) or "tolua_isusertype"
end

202
3rdparty/toluapp/src/bin/lua/class.lua vendored Normal file
View File

@ -0,0 +1,202 @@
-- tolua: class class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Class class
-- Represents a class definition.
-- Stores the following fields:
-- name = class name
-- base = class base, if any (only single inheritance is supported)
-- {i} = list of members
classClass = {
classtype = 'class',
name = '',
base = '',
type = '',
btype = '',
ctype = '',
}
classClass.__index = classClass
setmetatable(classClass,classContainer)
-- register class
function classClass:register (pre)
if not self:check_public_access() then
return
end
pre = pre or ''
push(self)
if _collect[self.type] then
output(pre,'#ifdef __cplusplus\n')
output(pre..'tolua_cclass(tolua_S,"'..self.lname..'","'..self.type..'","'..self.btype..'",'.._collect[self.type]..');')
output(pre,'#else\n')
output(pre..'tolua_cclass(tolua_S,"'..self.lname..'","'..self.type..'","'..self.btype..'",NULL);')
output(pre,'#endif\n')
else
output(pre..'tolua_cclass(tolua_S,"'..self.lname..'","'..self.type..'","'..self.btype..'",NULL);')
end
if self.extra_bases then
for k,base in ipairs(self.extra_bases) do
-- not now
--output(pre..' tolua_addbase(tolua_S, "'..self.type..'", "'..base..'");')
end
end
output(pre..'tolua_beginmodule(tolua_S,"'..self.lname..'");')
local i=1
while self[i] do
self[i]:register(pre..' ')
i = i+1
end
output(pre..'tolua_endmodule(tolua_S);')
pop()
end
-- return collection requirement
function classClass:requirecollection (t)
if self.flags.protected_destructor or (not self:check_public_access()) then
return false
end
push(self)
local r = false
local i=1
while self[i] do
r = self[i]:requirecollection(t) or r
i = i+1
end
pop()
-- only class that exports destructor can be appropriately collected
-- classes that export constructors need to have a collector (overrided by -D flag on command line)
if self._delete or ((not flags['D']) and self._new) then
--t[self.type] = "tolua_collect_" .. gsub(self.type,"::","_")
t[self.type] = "tolua_collect_" .. clean_template(self.type)
r = true
end
return r
end
-- output tags
function classClass:decltype ()
push(self)
self.type = regtype(self.original_name or self.name)
self.btype = typevar(self.base)
self.ctype = 'const '..self.type
if self.extra_bases then
for i=1,#self.extra_bases do
self.extra_bases[i] = typevar(self.extra_bases[i])
end
end
local i=1
while self[i] do
self[i]:decltype()
i = i+1
end
pop()
end
-- Print method
function classClass:print (ident,close)
print(ident.."Class{")
print(ident.." name = '"..self.name.."',")
print(ident.." base = '"..self.base.."';")
print(ident.." lname = '"..self.lname.."',")
print(ident.." type = '"..self.type.."',")
print(ident.." btype = '"..self.btype.."',")
print(ident.." ctype = '"..self.ctype.."',")
local i=1
while self[i] do
self[i]:print(ident.." ",",")
i = i+1
end
print(ident.."}"..close)
end
function classClass:set_protected_destructor(p)
self.flags.protected_destructor = self.flags.protected_destructor or p
end
-- Internal constructor
function _Class (t)
setmetatable(t,classClass)
t:buildnames()
append(t)
return t
end
-- Constructor
-- Expects the name, the base (array) and the body of the class.
function Class (n,p,b)
if #p > 1 then
b = string.sub(b, 1, -2)
for i=2,#p,1 do
b = b.."\n tolua_inherits "..p[i].." __"..p[i].."__;\n"
end
b = b.."\n}"
end
-- check for template
b = string.gsub(b, "^{%s*TEMPLATE_BIND", "{\nTOLUA_TEMPLATE_BIND")
local t,_,T,I = string.find(b, '^{%s*TOLUA_TEMPLATE_BIND%s*%(+%s*\"?([^\",]*)\"?%s*,%s*([^%)]*)%s*%)+')
if t then
-- remove quotes
I = string.gsub(I, "\"", "")
T = string.gsub(T, "\"", "")
-- get type list
local types = split_c_tokens(I, ",")
-- remove TEMPLATE_BIND line
local bs = string.gsub(b, "^{%s*TOLUA_TEMPLATE_BIND[^\n]*\n", "{\n")
local Tl = split(T, " ")
local tc = TemplateClass(n, p, bs, Tl)
tc:throw(types, true)
--for i=1,types.n do
-- tc:throw(split_c_tokens(types[i], " "), true)
--end
return
end
local mbase
if p then
mbase = table.remove(p, 1)
if not p[1] then p = nil end
end
mbase = mbase and resolve_template_types(mbase)
local c
local oname = string.gsub(n, "@.*$", "")
oname = getnamespace(classContainer.curr)..oname
if _global_classes[oname] then
c = _global_classes[oname]
if mbase and ((not c.base) or c.base == "") then
c.base = mbase
end
else
c = _Class(_Container{name=n, base=mbase, extra_bases=p})
local ft = getnamespace(c.parent)..c.original_name
append_global_type(ft, c)
end
push(c)
c:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces
pop()
end

79
3rdparty/toluapp/src/bin/lua/clean.lua vendored Normal file
View File

@ -0,0 +1,79 @@
-- mark up comments and strings
STR1 = "\001"
STR2 = "\002"
STR3 = "\003"
STR4 = "\004"
REM = "\005"
ANY = "([\001-\005])"
ESC1 = "\006"
ESC2 = "\007"
MASK = { -- the substitution order is important
{ESC1, "\\'"},
{ESC2, '\\"'},
{STR1, "'"},
{STR2, '"'},
{STR3, "%[%["},
{STR4, "%]%]"},
{REM , "%-%-"},
}
function mask (s)
for i = 1,#MASK do
s = gsub(s,MASK[i][2],MASK[i][1])
end
return s
end
function unmask (s)
for i = 1,#MASK do
s = gsub(s,MASK[i][1],MASK[i][2])
end
return s
end
function clean (s)
-- check for compilation error
local code = "return function ()\n" .. s .. "\n end"
if not dostring(code) then
return nil
end
if flags['C'] then
return s
end
local S = "" -- saved string
s = mask(s)
-- remove blanks and comments
while 1 do
local b,e,d = strfind(s,ANY)
if b then
S = S..strsub(s,1,b-1)
s = strsub(s,b+1)
if d==STR1 or d==STR2 then
e = strfind(s,d)
S = S ..d..strsub(s,1,e)
s = strsub(s,e+1)
elseif d==STR3 then
e = strfind(s,STR4)
S = S..d..strsub(s,1,e)
s = strsub(s,e+1)
elseif d==REM then
s = gsub(s,"[^\n]*(\n?)","%1",1)
end
else
S = S..s
break
end
end
-- eliminate unecessary spaces
S = gsub(S,"[ \t]+"," ")
S = gsub(S,"[ \t]*\n[ \t]*","\n")
S = gsub(S,"\n+","\n")
S = unmask(S)
return S
end

105
3rdparty/toluapp/src/bin/lua/code.lua vendored Normal file
View File

@ -0,0 +1,105 @@
-- tolua: code class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1999
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- global
code_n = 1
-- Code class
-- Represents Lua code to be compiled and included
-- in the initialization function.
-- The following fields are stored:
-- text = text code
classCode = {
text = '',
}
classCode.__index = classCode
setmetatable(classCode,classFeature)
-- register code
function classCode:register (pre)
pre = pre or ''
-- clean Lua code
local s = clean(self.text)
if not s then
--print(self.text)
error("parser error in embedded code")
end
-- get first line
local _, _, first_line=string.find(self.text, "^([^\n\r]*)")
if string.find(first_line, "^%s*%-%-") then
if string.find(first_line, "^%-%-##") then
first_line = string.gsub(first_line, "^%-%-##", "")
if flags['C'] then
s = string.gsub(s, "^%-%-##[^\n\r]*\n", "")
end
end
else
first_line = ""
end
-- pad to 16 bytes
local npad = 16 - (#s % 16)
local spad = ""
for i=1,npad do
spad = spad .. "-"
end
s = s..spad
-- convert to C
output('\n'..pre..'{ /* begin embedded lua code */\n')
output(pre..' int top = lua_gettop(tolua_S);')
output(pre..' static const unsigned char B[] = {\n ')
local t={n=0}
local b = gsub(s,'(.)',function (c)
local e = ''
t.n=t.n+1 if t.n==15 then t.n=0 e='\n'..pre..' ' end
return format('%3u,%s',strbyte(c),e)
end
)
output(b..strbyte(" "))
output('\n'..pre..' };\n')
if first_line and first_line ~= "" then
output(pre..' tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua embedded: '..first_line..'");')
else
output(pre..' tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code '..code_n..'");')
end
output(pre..' lua_settop(tolua_S, top);')
output(pre..'} /* end of embedded lua code */\n\n')
code_n = code_n +1
end
-- Print method
function classCode:print (ident,close)
print(ident.."Code{")
print(ident.." text = [["..self.text.."]],")
print(ident.."}"..close)
end
-- Internal constructor
function _Code (t)
setmetatable(t,classCode)
append(t)
return t
end
-- Constructor
-- Expects a string representing the code text
function Code (l)
return _Code {
text = l
}
end

57
3rdparty/toluapp/src/bin/lua/compat-5.1.lua vendored Executable file
View File

@ -0,0 +1,57 @@
if string.find(_VERSION, "5%.0") then
return
end
-- "loadfile"
local function pp_dofile(path)
local loaded = false
local getfile = function()
if loaded then
return
else
local file,err = io.open(path)
if not file then
error("error loading file "..path..": "..err)
end
local ret = file:read("*a")
file:close()
ret = string.gsub(ret, "%.%.%.%s*%)", "...) local arg = {n=select('#', ...), ...};")
loaded = true
return ret
end
end
local f = load(getfile, path)
if not f then
error("error loading file "..path ..": " .. errmsg)
end
return f()
end
old_dofile = dofile
dofile = pp_dofile
-- string.gsub
--[[
local ogsub = string.gsub
local function compgsub(a,b,c,d)
if type(c) == "function" then
local oc = c
c = function (...) return oc(...) or '' end
end
return ogsub(a,b,c,d)
end
string.repl = ogsub
--]]
--string.gsub = compgsub

193
3rdparty/toluapp/src/bin/lua/compat.lua vendored Normal file
View File

@ -0,0 +1,193 @@
-------------------------------------------------------------------
-- Real globals
-- _ALERT
-- _ERRORMESSAGE
-- _VERSION
-- _G
-- assert
-- error
-- metatable
-- next
-- print
-- require
-- tonumber
-- tostring
-- type
-- unpack
-------------------------------------------------------------------
-- collectgarbage
-- gcinfo
-- globals
-- call -> protect(f, err)
-- loadfile
-- loadstring
-- rawget
-- rawset
-- getargs = Main.getargs ??
rawtype = type
function do_ (f, err)
if not f then print(err); return end
local a,b = pcall(f)
if not a then print(b); return nil
else return b or true
end
end
function dostring(s) return do_(load(s)) end
-- function dofile(s) return do_(loadfile(s)) end
-------------------------------------------------------------------
-- Table library
local tab = table
getn = function (tab) return #tab end
tinsert = tab.insert
tremove = tab.remove
sort = tab.sort
-------------------------------------------------------------------
-- Debug library
local dbg = debug
getinfo = dbg.getinfo
getlocal = dbg.getlocal
setcallhook = function () error"`setcallhook' is deprecated" end
setlinehook = function () error"`setlinehook' is deprecated" end
setlocal = dbg.setlocal
-------------------------------------------------------------------
-- math library
local math = math
abs = math.abs
acos = function (x) return math.deg(math.acos(x)) end
asin = function (x) return math.deg(math.asin(x)) end
atan = function (x) return math.deg(math.atan(x)) end
atan2 = function (x,y) return math.deg(math.atan2(x,y)) end
ceil = math.ceil
cos = function (x) return math.cos(math.rad(x)) end
deg = math.deg
exp = math.exp
floor = math.floor
frexp = math.frexp
ldexp = math.ldexp
log = math.log
log10 = function(val) return math.log(10, val) end
max = math.max
min = math.min
mod = math.mod
PI = math.pi
--??? pow = math.pow
rad = math.rad
random = math.random
randomseed = math.randomseed
sin = function (x) return math.sin(math.rad(x)) end
sqrt = math.sqrt
tan = function (x) return math.tan(math.rad(x)) end
-------------------------------------------------------------------
-- string library
local str = string
strbyte = str.byte
strchar = str.char
strfind = str.find
format = str.format
gsub = str.gsub
strlen = str.len
strlower = str.lower
strrep = str.rep
strsub = str.sub
strupper = str.upper
-------------------------------------------------------------------
-- os library
clock = os.clock
date = os.date
difftime = os.difftime
execute = os.execute --?
exit = os.exit
getenv = os.getenv
remove = os.remove
rename = os.rename
setlocale = os.setlocale
time = os.time
tmpname = os.tmpname
-------------------------------------------------------------------
-- compatibility only
getglobal = function (n) return _G[n] end
setglobal = function (n,v) _G[n] = v end
-------------------------------------------------------------------
local io, tab = io, table
-- IO library (files)
_STDIN = io.stdin
_STDERR = io.stderr
_STDOUT = io.stdout
_INPUT = io.stdin
_OUTPUT = io.stdout
seek = io.stdin.seek -- sick ;-)
tmpfile = io.tmpfile
closefile = io.close
openfile = io.open
function flush (f)
if f then f:flush()
else _OUTPUT:flush()
end
end
function readfrom (name)
if name == nil then
local f, err, cod = io.close(_INPUT)
_INPUT = io.stdin
return f, err, cod
else
local f, err, cod = io.open(name, "r")
_INPUT = f or _INPUT
return f, err, cod
end
end
function writeto (name)
if name == nil then
local f, err, cod = io.close(_OUTPUT)
_OUTPUT = io.stdout
return f, err, cod
else
local f, err, cod = io.open(name, "w")
_OUTPUT = f or _OUTPUT
return f, err, cod
end
end
function appendto (name)
local f, err, cod = io.open(name, "a")
_OUTPUT = f or _OUTPUT
return f, err, cod
end
function read (...)
local f = _INPUT
local arg = {...}
if rawtype(arg[1]) == 'userdata' then
f = tab.remove(arg, 1)
end
return f:read(table.unpack(arg))
end
function write (...)
local f = _OUTPUT
local arg = {...}
if rawtype(arg[1]) == 'userdata' then
f = tab.remove(arg, 1)
end
return f:write(table.unpack(arg))
end

786
3rdparty/toluapp/src/bin/lua/container.lua vendored Normal file
View File

@ -0,0 +1,786 @@
-- tolua: container abstract class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- table to store namespaced typedefs/enums in global scope
global_typedefs = {}
global_enums = {}
-- Container class
-- Represents a container of features to be bound
-- to lua.
classContainer =
{
curr = nil,
}
classContainer.__index = classContainer
setmetatable(classContainer,classFeature)
-- output tags
function classContainer:decltype ()
push(self)
local i=1
while self[i] do
self[i]:decltype()
i = i+1
end
pop()
end
-- write support code
function classContainer:supcode ()
if not self:check_public_access() then
return
end
push(self)
local i=1
while self[i] do
if self[i]:check_public_access() then
self[i]:supcode()
end
i = i+1
end
pop()
end
function classContainer:hasvar ()
local i=1
while self[i] do
if self[i]:isvariable() then
return 1
end
i = i+1
end
return 0
end
-- Internal container constructor
function _Container (self)
setmetatable(self,classContainer)
self.n = 0
self.typedefs = {tolua_n=0}
self.usertypes = {}
self.enums = {tolua_n=0}
self.lnames = {}
return self
end
-- push container
function push (t)
t.prox = classContainer.curr
classContainer.curr = t
end
-- pop container
function pop ()
--print("name",classContainer.curr.name)
--foreach(classContainer.curr.usertypes,print)
--print("______________")
classContainer.curr = classContainer.curr.prox
end
-- get current namespace
function getcurrnamespace ()
return getnamespace(classContainer.curr)
end
-- append to current container
function append (t)
return classContainer.curr:append(t)
end
-- append typedef to current container
function appendtypedef (t)
return classContainer.curr:appendtypedef(t)
end
-- append usertype to current container
function appendusertype (t)
return classContainer.curr:appendusertype(t)
end
-- append enum to current container
function appendenum (t)
return classContainer.curr:appendenum(t)
end
-- substitute typedef
function applytypedef (mod,type)
return classContainer.curr:applytypedef(mod,type)
end
-- check if is type
function findtype (type)
local t = classContainer.curr:findtype(type)
return t
end
-- check if is typedef
function istypedef (type)
return classContainer.curr:istypedef(type)
end
-- get fulltype (with namespace)
function fulltype (t)
local curr = classContainer.curr
while curr do
if curr then
if curr.typedefs and curr.typedefs[t] then
return curr.typedefs[t]
elseif curr.usertypes and curr.usertypes[t] then
return curr.usertypes[t]
end
end
curr = curr.prox
end
return t
end
-- checks if it requires collection
function classContainer:requirecollection (t)
push(self)
local i=1
local r = false
while self[i] do
r = self[i]:requirecollection(t) or r
i = i+1
end
pop()
return r
end
-- get namesapce
function getnamespace (curr)
local namespace = ''
while curr do
if curr and
( curr.classtype == 'class' or curr.classtype == 'namespace')
then
namespace = (curr.original_name or curr.name) .. '::' .. namespace
--namespace = curr.name .. '::' .. namespace
end
curr = curr.prox
end
return namespace
end
-- get namespace (only namespace)
function getonlynamespace ()
local curr = classContainer.curr
local namespace = ''
while curr do
if curr.classtype == 'class' then
return namespace
elseif curr.classtype == 'namespace' then
namespace = curr.name .. '::' .. namespace
end
curr = curr.prox
end
return namespace
end
-- check if is enum
function isenum (type)
return classContainer.curr:isenum(type)
end
-- append feature to container
function classContainer:append (t)
self.n = self.n + 1
self[self.n] = t
t.parent = self
end
-- append typedef
function classContainer:appendtypedef (t)
local namespace = getnamespace(classContainer.curr)
self.typedefs.tolua_n = self.typedefs.tolua_n + 1
self.typedefs[self.typedefs.tolua_n] = t
self.typedefs[t.utype] = namespace .. t.utype
global_typedefs[namespace..t.utype] = t
t.ftype = findtype(t.type) or t.type
--print("appending typedef "..t.utype.." as "..namespace..t.utype.." with ftype "..t.ftype)
append_global_type(namespace..t.utype)
if t.ftype and isenum(t.ftype) then
global_enums[namespace..t.utype] = true
end
end
-- append usertype: return full type
function classContainer:appendusertype (t)
local container
if t == (self.original_name or self.name) then
container = self.prox
else
container = self
end
local ft = getnamespace(container) .. t
container.usertypes[t] = ft
_usertype[ft] = ft
return ft
end
-- append enum
function classContainer:appendenum (t)
local namespace = getnamespace(classContainer.curr)
self.enums.tolua_n = self.enums.tolua_n + 1
self.enums[self.enums.tolua_n] = t
global_enums[namespace..t.name] = t
end
-- determine lua function name overload
function classContainer:overload (lname)
if not self.lnames[lname] then
self.lnames[lname] = 0
else
self.lnames[lname] = self.lnames[lname] + 1
end
return format("%02d",self.lnames[lname])
end
-- applies typedef: returns the 'the facto' modifier and type
function classContainer:applytypedef (mod,type)
if global_typedefs[type] then
--print("found typedef "..global_typedefs[type].type)
local mod1, type1 = global_typedefs[type].mod, global_typedefs[type].ftype
local mod2, type2 = applytypedef(mod.." "..mod1, type1)
--return mod2 .. ' ' .. mod1, type2
return mod2, type2
end
do return mod,type end
end
-- check if it is a typedef
function classContainer:istypedef (type)
local env = self
while env do
if env.typedefs then
local i=1
while env.typedefs[i] do
if env.typedefs[i].utype == type then
return type
end
i = i+1
end
end
env = env.parent
end
return nil
end
function find_enum_var(var)
if tonumber(var) then return var end
local c = classContainer.curr
while c do
local ns = getnamespace(c)
for k,v in pairs(_global_enums) do
if match_type(var, v, ns) then
return v
end
end
if c.base and c.base ~= '' then
c = _global_classes[c:findtype(c.base)]
else
c = nil
end
end
return var
end
-- check if is a registered type: return full type or nil
function classContainer:findtype (t)
t = string.gsub(t, "=.*", "")
if _basic[t] then
return t
end
local _,_,em = string.find(t, "([&%*])%s*$")
t = string.gsub(t, "%s*([&%*])%s*$", "")
p = self
while p and type(p)=='table' do
local st = getnamespace(p)
for i=_global_types.n,1,-1 do -- in reverse order
if match_type(t, _global_types[i], st) then
return _global_types[i]..(em or "")
end
end
if p.base and p.base ~= '' and p.base ~= t then
--print("type is "..t..", p is "..p.base.." self.type is "..self.type.." self.name is "..self.name)
p = _global_classes[p:findtype(p.base)]
else
p = nil
end
end
return nil
end
function append_global_type(t, class)
_global_types.n = _global_types.n +1
_global_types[_global_types.n] = t
_global_types_hash[t] = 1
if class then append_class_type(t, class) end
end
function append_class_type(t,class)
if _global_classes[t] then
class.flags = _global_classes[t].flags
class.lnames = _global_classes[t].lnames
if _global_classes[t].base and (_global_classes[t].base ~= '') then
class.base = _global_classes[t].base or class.base
end
end
_global_classes[t] = class
class.flags = class.flags or {}
end
function match_type(childtype, regtype, st)
--print("findtype "..childtype..", "..regtype..", "..st)
local b,e = string.find(regtype, childtype, -string.len(childtype), true)
if b then
if e == string.len(regtype) and
(b == 1 or (string.sub(regtype, b-1, b-1) == ':' and
string.sub(regtype, 1, b-1) == string.sub(st, 1, b-1))) then
return true
end
end
return false
end
function findtype_on_childs(self, t)
local tchild
if self.classtype == 'class' or self.classtype == 'namespace' then
for k,v in ipairs(self) do
if v.classtype == 'class' or v.classtype == 'namespace' then
if v.typedefs and v.typedefs[t] then
return v.typedefs[t]
elseif v.usertypes and v.usertypes[t] then
return v.usertypes[t]
end
tchild = findtype_on_childs(v, t)
if tchild then return tchild end
end
end
end
return nil
end
function classContainer:isenum (type)
if global_enums[type] then
return type
else
return false
end
local basetype = gsub(type,"^.*::","")
local env = self
while env do
if env.enums then
local i=1
while env.enums[i] do
if env.enums[i].name == basetype then
return true
end
i = i+1
end
end
env = env.parent
end
return false
end
methodisvirtual = false -- a global
-- parse chunk
function classContainer:doparse (s)
--print ("parse "..s)
-- try the parser hook
do
local sub = parser_hook(s)
if sub then
return sub
end
end
-- try the null statement
do
local b,e,code = string.find(s, "^%s*;")
if b then
return strsub(s,e+1)
end
end
-- try empty verbatim line
do
local b,e,code = string.find(s, "^%s*$\n")
if b then
return strsub(s,e+1)
end
end
-- try Lua code
do
local b,e,code = strfind(s,"^%s*(%b\1\2)")
if b then
Code(strsub(code,2,-2))
return strsub(s,e+1)
end
end
-- try C code
do
local b,e,code = strfind(s,"^%s*(%b\3\4)")
if b then
code = '{'..strsub(code,2,-2)..'\n}\n'
Verbatim(code,'r') -- verbatim code for 'r'egister fragment
return strsub(s,e+1)
end
end
-- try C code for preamble section
do
local b,e,code = string.find(s, "^%s*(%b\5\6)")
if b then
code = string.sub(code, 2, -2).."\n"
Verbatim(code, '')
return string.sub(s, e+1)
end
end
-- try default_property directive
do
local b,e,ptype = strfind(s, "^%s*TOLUA_PROPERTY_TYPE%s*%(+%s*([^%)%s]*)%s*%)+%s*;?")
if b then
if not ptype or ptype == "" then
ptype = "default"
end
self:set_property_type(ptype)
return strsub(s, e+1)
end
end
-- try protected_destructor directive
do
local b,e = string.find(s, "^%s*TOLUA_PROTECTED_DESTRUCTOR%s*;?")
if b then
if self.set_protected_destructor then
self:set_protected_destructor(true)
end
return strsub(s, e+1)
end
end
-- try 'extern' keyword
do
local b,e = string.find(s, "^%s*extern%s+")
if b then
-- do nothing
return strsub(s, e+1)
end
end
-- try 'virtual' keyworkd
do
local b,e = string.find(s, "^%s*virtual%s+")
if b then
methodisvirtual = true
return strsub(s, e+1)
end
end
-- try labels (public, private, etc)
do
local b,e = string.find(s, "^%s*%w*%s*:[^:]")
if b then
return strsub(s, e) -- preserve the [^:]
end
end
-- try module
do
local b,e,name,body = strfind(s,"^%s*module%s%s*([_%w][_%w]*)%s*(%b{})%s*")
if b then
_curr_code = strsub(s,b,e)
Module(name,body)
return strsub(s,e+1)
end
end
-- try namesapce
do
local b,e,name,body = strfind(s,"^%s*namespace%s%s*([_%w][_%w]*)%s*(%b{})%s*;?")
if b then
_curr_code = strsub(s,b,e)
Namespace(name,body)
return strsub(s,e+1)
end
end
-- try define
do
local b,e,name = strfind(s,"^%s*#define%s%s*([^%s]*)[^\n]*\n%s*")
if b then
_curr_code = strsub(s,b,e)
Define(name)
return strsub(s,e+1)
end
end
-- try enumerates
do
local b,e,name,body,varname = strfind(s,"^%s*enum%s+(%S*)%s*(%b{})%s*([^%s;]*)%s*;?%s*")
if b then
--error("#Sorry, declaration of enums and variables on the same statement is not supported.\nDeclare your variable separately (example: '"..name.." "..varname..";')")
_curr_code = strsub(s,b,e)
Enumerate(name,body,varname)
return strsub(s,e+1)
end
end
-- do
-- local b,e,name,body = strfind(s,"^%s*enum%s+(%S*)%s*(%b{})%s*;?%s*")
-- if b then
-- _curr_code = strsub(s,b,e)
-- Enumerate(name,body)
-- return strsub(s,e+1)
-- end
-- end
do
local b,e,body,name = strfind(s,"^%s*typedef%s+enum[^{]*(%b{})%s*([%w_][^%s]*)%s*;%s*")
if b then
_curr_code = strsub(s,b,e)
Enumerate(name,body)
return strsub(s,e+1)
end
end
-- try operator
do
local b,e,decl,kind,arg,const = strfind(s,"^%s*([_%w][_%w%s%*&:<>,]-%s+operator)%s*([^%s][^%s]*)%s*(%b())%s*(c?o?n?s?t?)%s*;%s*")
if not b then
-- try inline
b,e,decl,kind,arg,const = strfind(s,"^%s*([_%w][_%w%s%*&:<>,]-%s+operator)%s*([^%s][^%s]*)%s*(%b())%s*(c?o?n?s?t?)[%s\n]*%b{}%s*;?%s*")
end
if not b then
-- try cast operator
b,e,decl,kind,arg,const = strfind(s, "^%s*(operator)%s+([%w_:%d<>%*%&%s]+)%s*(%b())%s*(c?o?n?s?t?)");
if b then
local _,ie = string.find(s, "^%s*%b{}", e+1)
if ie then
e = ie
end
end
end
if b then
_curr_code = strsub(s,b,e)
Operator(decl,kind,arg,const)
return strsub(s,e+1)
end
end
-- try function
do
--local b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&:<>]*[_%w])%s*(%b())%s*(c?o?n?s?t?)%s*=?%s*0?%s*;%s*")
local b,e,decl,arg,const,virt = strfind(s,"^%s*([^%(\n]+)%s*(%b())%s*(c?o?n?s?t?)%s*(=?%s*0?)%s*;%s*")
if not b then
-- try function with template
b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&:<>]*[_%w]%b<>)%s*(%b())%s*(c?o?n?s?t?)%s*=?%s*0?%s*;%s*")
end
if not b then
-- try a single letter function name
b,e,decl,arg,const = strfind(s,"^%s*([_%w])%s*(%b())%s*(c?o?n?s?t?)%s*;%s*")
end
if not b then
-- try function pointer
b,e,decl,arg,const = strfind(s,"^%s*([^%(;\n]+%b())%s*(%b())%s*;%s*")
if b then
decl = string.gsub(decl, "%(%s*%*([^%)]*)%s*%)", " %1 ")
end
end
if b then
if virt and string.find(virt, "[=0]") then
if self.flags then
self.flags.pure_virtual = true
end
end
_curr_code = strsub(s,b,e)
Function(decl,arg,const)
return strsub(s,e+1)
end
end
-- try inline function
do
local b,e,decl,arg,const = strfind(s,"^%s*([^%(\n]+)%s*(%b())%s*(c?o?n?s?t?)[^;{]*%b{}%s*;?%s*")
--local b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&:<>]*[_%w>])%s*(%b())%s*(c?o?n?s?t?)[^;]*%b{}%s*;?%s*")
if not b then
-- try a single letter function name
b,e,decl,arg,const = strfind(s,"^%s*([_%w])%s*(%b())%s*(c?o?n?s?t?).-%b{}%s*;?%s*")
end
if b then
_curr_code = strsub(s,b,e)
Function(decl,arg,const)
return strsub(s,e+1)
end
end
-- try class
do
local b,e,name,base,body
base = '' body = ''
b,e,name = strfind(s,"^%s*class%s*([_%w][_%w@]*)%s*;") -- dummy class
local dummy = false
if not b then
b,e,name = strfind(s,"^%s*struct%s*([_%w][_%w@]*)%s*;") -- dummy struct
if not b then
b,e,name,base,body = strfind(s,"^%s*class%s*([_%w][_%w@]*)%s*([^{]-)%s*(%b{})%s*")
if not b then
b,e,name,base,body = strfind(s,"^%s*struct%s+([_%w][_%w@]*)%s*([^{]-)%s*(%b{})%s*")
if not b then
b,e,name,base,body = strfind(s,"^%s*union%s*([_%w][_%w@]*)%s*([^{]-)%s*(%b{})%s*")
if not b then
base = ''
b,e,body,name = strfind(s,"^%s*typedef%s%s*struct%s%s*[_%w]*%s*(%b{})%s*([_%w][_%w@]*)%s*;")
end
end
end
else dummy = 1 end
else dummy = 1 end
if b then
if base ~= '' then
base = string.gsub(base, "^%s*:%s*", "")
base = string.gsub(base, "%s*public%s*", "")
base = split(base, ",")
--local b,e
--b,e,base = strfind(base,".-([_%w][_%w<>,:]*)$")
else
base = {}
end
_curr_code = strsub(s,b,e)
Class(name,base,body)
if not dummy then
varb,vare,varname = string.find(s, "^%s*([_%w]+)%s*;", e+1)
if varb then
Variable(name.." "..varname)
e = vare
end
end
return strsub(s,e+1)
end
end
-- try typedef
do
local b,e,types = strfind(s,"^%s*typedef%s%s*(.-)%s*;%s*")
if b then
_curr_code = strsub(s,b,e)
Typedef(types)
return strsub(s,e+1)
end
end
-- try variable
do
local b,e,decl = strfind(s,"^%s*([_%w][_@%s%w%d%*&:<>,]*[_%w%d])%s*;%s*")
if b then
_curr_code = strsub(s,b,e)
local list = split_c_tokens(decl, ",")
Variable(list[1])
if list.n > 1 then
local _,_,type = strfind(list[1], "(.-)%s+([^%s]*)$");
local i =2;
while list[i] do
Variable(type.." "..list[i])
i=i+1
end
end
--Variable(decl)
return strsub(s,e+1)
end
end
-- try string
do
local b,e,decl = strfind(s,"^%s*([_%w]?[_%s%w%d]-char%s+[_@%w%d]*%s*%[%s*%S+%s*%])%s*;%s*")
if b then
_curr_code = strsub(s,b,e)
Variable(decl)
return strsub(s,e+1)
end
end
-- try array
do
local b,e,decl = strfind(s,"^%s*([_%w][][_@%s%w%d%*&:<>]*[]_%w%d])%s*;%s*")
if b then
_curr_code = strsub(s,b,e)
Array(decl)
return strsub(s,e+1)
end
end
-- no matching
if gsub(s,"%s%s*","") ~= "" then
_curr_code = s
error("#parse error")
else
return ""
end
end
function classContainer:parse (s)
--self.curr_member_access = nil
while s ~= '' do
s = self:doparse(s)
methodisvirtual = false
end
end
-- property types
function get_property_type()
return classContainer.curr:get_property_type()
end
function classContainer:set_property_type(ptype)
ptype = string.gsub(ptype, "^%s*", "")
ptype = string.gsub(ptype, "%s*$", "")
self.property_type = ptype
end
function classContainer:get_property_type()
return self.property_type or (self.parent and self.parent:get_property_type()) or "default"
end

45
3rdparty/toluapp/src/bin/lua/custom.lua vendored Normal file
View File

@ -0,0 +1,45 @@
function extract_code(fn,s)
local code = ""
if fn then
code = '\n$#include "'..fn..'"\n'
end
s= "\n" .. s .. "\n" -- add blank lines as sentinels
local _,e,c,t = strfind(s, "\n([^\n]-)SCRIPT_([%w_]*)[^\n]*\n")
while e do
t = strlower(t)
if t == "bind_begin" then
_,e,c = strfind(s,"(.-)\n[^\n]*SCRIPT_BIND_END[^\n]*\n",e)
if not e then
tolua_error("Unbalanced 'SCRIPT_BIND_BEGIN' directive in header file")
end
end
if t == "bind_class" or t == "bind_block" then
local b
_,e,c,b = string.find(s, "([^{]-)(%b{})", e)
c = c..'{\n'..extract_code(nil, b)..'\n};\n'
end
code = code .. c .. "\n"
_,e,c,t = strfind(s, "\n([^\n]-)SCRIPT_([%w_]*)[^\n]*\n",e)
end
return code
end
function preprocess_hook(p)
end
function preparse_hook(p)
end
function include_file_hook(p, filename)
do return end
--print("FILENAME is "..filename)
p.code = string.gsub(p.code, "\n%s*SigC::Signal", "\n\ttolua_readonly SigC::Signal")
p.code = string.gsub(p.code, "#ifdef __cplusplus\nextern \"C\" {\n#endif", "")
p.code = string.gsub(p.code, "#ifdef __cplusplus\n};?\n#endif", "")
p.code = string.gsub(p.code, "DECLSPEC", "")
p.code = string.gsub(p.code, "SDLCALL", "")
p.code = string.gsub(p.code, "DLLINTERFACE", "")
p.code = string.gsub(p.code, "#define[^\n]*_[hH]_?%s*\n", "\n")
--print("code is "..p.code)
end

579
3rdparty/toluapp/src/bin/lua/declaration.lua vendored Normal file
View File

@ -0,0 +1,579 @@
-- tolua: declaration class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Declaration class
-- Represents variable, function, or argument declaration.
-- Stores the following fields:
-- mod = type modifiers
-- type = type
-- ptr = "*" or "&", if representing a pointer or a reference
-- name = name
-- dim = dimension, if a vector
-- def = default value, if any (only for arguments)
-- ret = "*" or "&", if value is to be returned (only for arguments)
classDeclaration = {
mod = '',
type = '',
ptr = '',
name = '',
dim = '',
ret = '',
def = ''
}
classDeclaration.__index = classDeclaration
setmetatable(classDeclaration,classFeature)
-- Create an unique variable name
function create_varname ()
if not _varnumber then _varnumber = 0 end
_varnumber = _varnumber + 1
return "tolua_var_".._varnumber
end
-- Check declaration name
-- It also identifies default values
function classDeclaration:checkname ()
if strsub(self.name,1,1) == '[' and not findtype(self.type) then
self.name = self.type..self.name
local m = split(self.mod,'%s%s*')
self.type = m[m.n]
self.mod = concat(m,1,m.n-1)
end
local t = split(self.name,'=')
if t.n==2 then
self.name = t[1]
self.def = find_enum_var(t[t.n])
end
local b,e,d = strfind(self.name,"%[(.-)%]")
if b then
self.name = strsub(self.name,1,b-1)
self.dim = find_enum_var(d)
end
if self.type ~= '' and self.type ~= 'void' and self.name == '' then
self.name = create_varname()
elseif self.kind=='var' then
if self.type=='' and self.name~='' then
self.type = self.type..self.name
self.name = create_varname()
elseif findtype(self.name) then
if self.type=='' then self.type = self.name
else self.type = self.type..' '..self.name end
self.name = create_varname()
end
end
-- adjust type of string
if self.type == 'char' and self.dim ~= '' then
self.type = 'char*'
end
if self.kind and self.kind == 'var' then
self.name = string.gsub(self.name, ":.*$", "") -- ???
end
end
-- Check declaration type
-- Substitutes typedef's.
function classDeclaration:checktype ()
-- check if there is a pointer to basic type
local basic = isbasic(self.type)
if self.kind == 'func' and basic=='number' and string.find(self.ptr, "%*") then
self.type = '_userdata'
self.ptr = ""
end
if basic and self.ptr~='' then
self.ret = self.ptr
self.ptr = nil
if isbasic(self.type) == 'number' then
self.return_userdata = true
end
end
-- check if there is array to be returned
if self.dim~='' and self.ret~='' then
error('#invalid parameter: cannot return an array of values')
end
-- restore 'void*' and 'string*'
if self.type == '_userdata' then self.type = 'void*'
elseif self.type == '_cstring' then self.type = 'char*'
elseif self.type == '_lstate' then self.type = 'lua_State*'
end
-- resolve types inside the templates
if self.type then
self.type = resolve_template_types(self.type)
end
--
-- -- if returning value, automatically set default value
-- if self.ret ~= '' and self.def == '' then
-- self.def = '0'
-- end
--
end
function resolve_template_types(type)
if isbasic(type) then
return type
end
local b,_,m = string.find(type, "(%b<>)")
if b then
m = split_c_tokens(string.sub(m, 2, -2), ",")
for i=1, #m do
m[i] = string.gsub(m[i],"%s*([%*&])", "%1")
if not isbasic(m[i]) then
if not isenum(m[i]) then _, m[i] = applytypedef("", m[i]) end
m[i] = findtype(m[i]) or m[i]
m[i] = resolve_template_types(m[i])
end
end
local b,i
type,b,i = break_template(type)
--print("concat is ",concat(m, 1, m.n))
local template_part = "<"..concat(m, 1, m.n, ",")..">"
type = rebuild_template(type, b, template_part)
type = string.gsub(type, ">>", "> >")
end
return type
end
function break_template(s)
local b,e,timpl = string.find(s, "(%b<>)")
if timpl then
s = string.gsub(s, "%b<>", "")
return s, b, timpl
else
return s, 0, nil
end
end
function rebuild_template(s, b, timpl)
if b == 0 then
return s
end
return string.sub(s, 1, b-1)..timpl..string.sub(s, b, -1)
end
-- Print method
function classDeclaration:print (ident,close)
print(ident.."Declaration{")
print(ident.." mod = '"..self.mod.."',")
print(ident.." type = '"..self.type.."',")
print(ident.." ptr = '"..self.ptr.."',")
print(ident.." name = '"..self.name.."',")
print(ident.." dim = '"..self.dim.."',")
print(ident.." def = '"..self.def.."',")
print(ident.." ret = '"..self.ret.."',")
print(ident.."}"..close)
end
-- check if array of values are returned to Lua
function classDeclaration:requirecollection (t)
if self.mod ~= 'const' and
self.dim and self.dim ~= '' and
not isbasic(self.type) and
self.ptr == '' and self:check_public_access() then
local type = gsub(self.type,"%s*const%s+","")
t[type] = "tolua_collect_" .. clean_template(type)
return true
end
return false
end
-- declare tag
function classDeclaration:decltype ()
self.type = typevar(self.type)
if strfind(self.mod,'const') then
self.type = 'const '..self.type
self.mod = gsub(self.mod,'const%s*','')
end
end
-- output type checking
function classDeclaration:outchecktype (narg)
local def
local t = isbasic(self.type)
if self.def~='' then
def = 1
else
def = 0
end
if self.dim ~= '' then
--if t=='string' then
-- return 'tolua_isstringarray(tolua_S,'..narg..','..def..',&tolua_err)'
--else
return '!tolua_istable(tolua_S,'..narg..',0,&tolua_err)'
--end
elseif t then
return '!tolua_is'..t..'(tolua_S,'..narg..','..def..',&tolua_err)'
else
local is_func = get_is_function(self.type)
if self.ptr == '&' or self.ptr == '' then
return '(tolua_isvaluenil(tolua_S,'..narg..',&tolua_err) || !'..is_func..'(tolua_S,'..narg..',"'..self.type..'",'..def..',&tolua_err))'
else
return '!'..is_func..'(tolua_S,'..narg..',"'..self.type..'",'..def..',&tolua_err)'
end
end
end
function classDeclaration:builddeclaration (narg, cplusplus)
local array = self.dim ~= '' and tonumber(self.dim)==nil
local line = ""
local ptr = ''
local mod
local type = self.type
local nctype = gsub(self.type,'const%s+','')
if self.dim ~= '' then
type = gsub(self.type,'const%s+','') -- eliminates const modifier for arrays
end
if self.ptr~='' and not isbasic(type) then ptr = '*' end
line = concatparam(line," ",self.mod,type,ptr)
if array then
line = concatparam(line,'*')
end
line = concatparam(line,self.name)
if self.dim ~= '' then
if tonumber(self.dim)~=nil then
line = concatparam(line,'[',self.dim,'];')
else
if cplusplus then
line = concatparam(line,' = Mtolua_new_dim(',type,ptr,', '..self.dim..');')
else
line = concatparam(line,' = (',type,ptr,'*)',
'malloc((',self.dim,')*sizeof(',type,ptr,'));')
end
end
else
local t = isbasic(type)
line = concatparam(line,' = ')
if t == 'state' then
line = concatparam(line, 'tolua_S;')
else
--print("t is "..tostring(t)..", ptr is "..tostring(self.ptr))
if t == 'number' and string.find(self.ptr, "%*") then
t = 'userdata'
end
if not t and ptr=='' then line = concatparam(line,'*') end
line = concatparam(line,'((',self.mod,type)
if not t then
line = concatparam(line,'*')
end
line = concatparam(line,') ')
if isenum(nctype) then
line = concatparam(line,'(int) ')
end
local def = 0
if self.def ~= '' then
def = self.def
if (ptr == '' or self.ptr == '&') and not t then
def = "(void*)&(const "..type..")"..def
end
end
if t then
line = concatparam(line,'tolua_to'..t,'(tolua_S,',narg,',',def,'));')
else
local to_func = get_to_function(type)
line = concatparam(line,to_func..'(tolua_S,',narg,',',def,'));')
end
end
end
return line
end
-- Declare variable
function classDeclaration:declare (narg)
if self.dim ~= '' and tonumber(self.dim)==nil then
output('#ifdef __cplusplus\n')
output(self:builddeclaration(narg,true))
output('#else\n')
output(self:builddeclaration(narg,false))
output('#endif\n')
else
output(self:builddeclaration(narg,false))
end
end
-- Get parameter value
function classDeclaration:getarray (narg)
if self.dim ~= '' then
local type = gsub(self.type,'const ','')
output(' {')
output('#ifndef TOLUA_RELEASE\n')
local def; if self.def~='' then def=1 else def=0 end
local t = isbasic(type)
if (t) then
output(' if (!tolua_is'..t..'array(tolua_S,',narg,',',self.dim,',',def,',&tolua_err))')
else
output(' if (!tolua_isusertypearray(tolua_S,',narg,',"',type,'",',self.dim,',',def,',&tolua_err))')
end
output(' goto tolua_lerror;')
output(' else\n')
output('#endif\n')
output(' {')
output(' int i;')
output(' for(i=0; i<'..self.dim..';i++)')
local t = isbasic(type)
local ptr = ''
if self.ptr~='' then ptr = '*' end
output(' ',self.name..'[i] = ')
if not t and ptr=='' then output('*') end
output('((',type)
if not t then
output('*')
end
output(') ')
local def = 0
if self.def ~= '' then def = self.def end
if t then
output('tolua_tofield'..t..'(tolua_S,',narg,',i+1,',def,'));')
else
output('tolua_tofieldusertype(tolua_S,',narg,',i+1,',def,'));')
end
output(' }')
output(' }')
end
end
-- Get parameter value
function classDeclaration:setarray (narg)
if not strfind(self.type,'const%s+') and self.dim ~= '' then
local type = gsub(self.type,'const ','')
output(' {')
output(' int i;')
output(' for(i=0; i<'..self.dim..';i++)')
local t,ct = isbasic(type)
if t then
output(' tolua_pushfield'..t..'(tolua_S,',narg,',i+1,(',ct,')',self.name,'[i]);')
else
if self.ptr == '' then
output(' {')
output('#ifdef __cplusplus\n')
output(' void* tolua_obj = Mtolua_new((',type,')(',self.name,'[i]));')
output(' tolua_pushfieldusertype_and_takeownership(tolua_S,',narg,',i+1,tolua_obj,"',type,'");')
output('#else\n')
output(' void* tolua_obj = tolua_copy(tolua_S,(void*)&',self.name,'[i],sizeof(',type,'));')
output(' tolua_pushfieldusertype(tolua_S,',narg,',i+1,tolua_obj,"',type,'");')
output('#endif\n')
output(' }')
else
output(' tolua_pushfieldusertype(tolua_S,',narg,',i+1,(void*)',self.name,'[i],"',type,'");')
end
end
output(' }')
end
end
-- Free dynamically allocated array
function classDeclaration:freearray ()
if self.dim ~= '' and tonumber(self.dim)==nil then
output('#ifdef __cplusplus\n')
output(' Mtolua_delete_dim(',self.name,');')
output('#else\n')
output(' free(',self.name,');')
output('#endif\n')
end
end
-- Pass parameter
function classDeclaration:passpar ()
if self.ptr=='&' and not isbasic(self.type) then
output('*'..self.name)
elseif self.ret=='*' then
output('&'..self.name)
else
output(self.name)
end
end
-- Return parameter value
function classDeclaration:retvalue ()
if self.ret ~= '' then
local t,ct = isbasic(self.type)
if t and t~='' then
output(' tolua_push'..t..'(tolua_S,(',ct,')'..self.name..');')
else
local push_func = get_push_function(self.type)
output(' ',push_func,'(tolua_S,(void*)'..self.name..',"',self.type,'");')
end
return 1
end
return 0
end
-- Internal constructor
function _Declaration (t)
setmetatable(t,classDeclaration)
t:buildnames()
t:checkname()
t:checktype()
local ft = findtype(t.type) or t.type
if not isenum(ft) then
t.mod, t.type = applytypedef(t.mod, ft)
end
if t.kind=="var" and (string.find(t.mod, "tolua_property%s") or string.find(t.mod, "tolua_property$")) then
t.mod = string.gsub(t.mod, "tolua_property", "tolua_property__"..get_property_type())
end
return t
end
-- Constructor
-- Expects the string declaration.
-- The kind of declaration can be "var" or "func".
function Declaration (s,kind,is_parameter)
-- eliminate spaces if default value is provided
s = gsub(s,"%s*=%s*","=")
s = gsub(s, "%s*<", "<")
local defb,tmpdef
defb,_,tmpdef = string.find(s, "(=.*)$")
if defb then
s = string.gsub(s, "=.*$", "")
else
tmpdef = ''
end
if kind == "var" then
-- check the form: void
if s == '' or s == 'void' then
return _Declaration{type = 'void', kind = kind, is_parameter = is_parameter}
end
end
-- check the form: mod type*& name
local t = split_c_tokens(s,'%*%s*&')
if t.n == 2 then
if kind == 'func' then
error("#invalid function return type: "..s)
end
--local m = split(t[1],'%s%s*')
local m = split_c_tokens(t[1],'%s+')
return _Declaration{
name = t[2]..tmpdef,
ptr = '*',
ret = '&',
--type = rebuild_template(m[m.n], tb, timpl),
type = m[m.n],
mod = concat(m,1,m.n-1),
is_parameter = is_parameter,
kind = kind
}
end
-- check the form: mod type** name
t = split_c_tokens(s,'%*%s*%*')
if t.n == 2 then
if kind == 'func' then
error("#invalid function return type: "..s)
end
--local m = split(t[1],'%s%s*')
local m = split_c_tokens(t[1],'%s+')
return _Declaration{
name = t[2]..tmpdef,
ptr = '*',
ret = '*',
--type = rebuild_template(m[m.n], tb, timpl),
type = m[m.n],
mod = concat(m,1,m.n-1),
is_parameter = is_parameter,
kind = kind
}
end
-- check the form: mod type& name
t = split_c_tokens(s,'&')
if t.n == 2 then
--local m = split(t[1],'%s%s*')
local m = split_c_tokens(t[1],'%s+')
return _Declaration{
name = t[2]..tmpdef,
ptr = '&',
--type = rebuild_template(m[m.n], tb, timpl),
type = m[m.n],
mod = concat(m,1,m.n-1),
is_parameter = is_parameter,
kind = kind
}
end
-- check the form: mod type* name
local s1 = gsub(s,"(%b%[%])",function (n) return gsub(n,'%*','\1') end)
t = split_c_tokens(s1,'%*')
if t.n == 2 then
t[2] = gsub(t[2],'\1','%*') -- restore * in dimension expression
--local m = split(t[1],'%s%s*')
local m = split_c_tokens(t[1],'%s+')
return _Declaration{
name = t[2]..tmpdef,
ptr = '*',
type = m[m.n],
--type = rebuild_template(m[m.n], tb, timpl),
mod = concat(m,1,m.n-1) ,
is_parameter = is_parameter,
kind = kind
}
end
if kind == 'var' then
-- check the form: mod type name
--t = split(s,'%s%s*')
t = split_c_tokens(s,'%s+')
local v
if findtype(t[t.n]) then v = create_varname() else v = t[t.n]; t.n = t.n-1 end
return _Declaration{
name = v..tmpdef,
--type = rebuild_template(t[t.n], tb, timpl),
type = t[t.n],
mod = concat(t,1,t.n-1),
is_parameter = is_parameter,
kind = kind
}
else -- kind == "func"
-- check the form: mod type name
--t = split(s,'%s%s*')
t = split_c_tokens(s,'%s+')
local v = t[t.n] -- last word is the function name
local tp,md
if t.n>1 then
tp = t[t.n-1]
md = concat(t,1,t.n-2)
end
--if tp then tp = rebuild_template(tp, tb, timpl) end
return _Declaration{
name = v,
type = tp,
mod = md,
is_parameter = is_parameter,
kind = kind
}
end
end

63
3rdparty/toluapp/src/bin/lua/define.lua vendored Normal file
View File

@ -0,0 +1,63 @@
-- tolua: define class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: define.lua,v 1.2 1999/07/28 22:21:08 celes Exp $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Define class
-- Represents a numeric const definition
-- The following filds are stored:
-- name = constant name
classDefine = {
name = '',
}
classDefine.__index = classDefine
setmetatable(classDefine,classFeature)
-- register define
function classDefine:register (pre)
if not self:check_public_access() then
return
end
pre = pre or ''
output(pre..'tolua_constant(tolua_S,"'..self.lname..'",'..self.name..');')
end
-- Print method
function classDefine:print (ident,close)
print(ident.."Define{")
print(ident.." name = '"..self.name.."',")
print(ident.." lname = '"..self.lname.."',")
print(ident.."}"..close)
end
-- Internal constructor
function _Define (t)
setmetatable(t,classDefine)
t:buildnames()
if t.name == '' then
error("#invalid define")
end
append(t)
return t
end
-- Constructor
-- Expects a string representing the constant name
function Define (n)
return _Define{
name = n
}
end

101
3rdparty/toluapp/src/bin/lua/doit.lua vendored Normal file
View File

@ -0,0 +1,101 @@
-- Generate binding code
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- Last update: Apr 2003
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
function parse_extra()
for k,v in ipairs(_extra_parameters or {}) do
local b,e,name,value = string.find(v, "^([^=]*)=(.*)$")
if b then
_extra_parameters[name] = value
else
_extra_parameters[v] = true
end
end
end
function doit ()
-- define package name, if not provided
if not flags.n then
if flags.f then
flags.n = gsub(flags.f,"%..*$","")
_,_,flags.n = string.find(flags.n, "([^/\\]*)$")
else
error("#no package name nor input file provided")
end
end
-- parse table with extra paramters
parse_extra()
-- do this after setting the package name
if flags['L'] then
dofile(flags['L'])
end
-- add cppstring
if not flags['S'] then
_basic['string'] = 'cppstring'
_basic['std::string'] = 'cppstring'
_basic_ctype.cppstring = 'const char*'
end
-- proccess package
local p = Package(flags.n,flags.f)
if flags.p then
return -- only parse
end
if flags.o then
local st,msg = writeto(flags.o)
if not st then
error('#'..msg)
end
end
p:decltype()
if flags.P then
p:print()
else
push(p)
pre_output_hook(p)
pop()
p:preamble()
p:supcode()
push(p)
pre_register_hook(p)
pop()
p:register()
push(p)
post_output_hook(p)
pop()
end
if flags.o then
writeto()
end
-- write header file
if not flags.P then
if flags.H then
local st,msg = writeto(flags.H)
if not st then
error('#'..msg)
end
p:header()
writeto()
end
end
end

106
3rdparty/toluapp/src/bin/lua/enumerate.lua vendored Normal file
View File

@ -0,0 +1,106 @@
-- tolua: enumerate class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: enumerate.lua,v 1.3 2000/01/24 20:41:15 celes Exp $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Enumerate class
-- Represents enumeration
-- The following fields are stored:
-- {i} = list of constant names
classEnumerate = {
}
classEnumerate.__index = classEnumerate
setmetatable(classEnumerate,classFeature)
-- register enumeration
function classEnumerate:register (pre)
if not self:check_public_access() then
return
end
pre = pre or ''
local nspace = getnamespace(classContainer.curr)
local i=1
while self[i] do
if self.lnames[i] and self.lnames[i] ~= "" then
output(pre..'tolua_constant(tolua_S,"'..self.lnames[i]..'",'..nspace..self[i]..');')
end
i = i+1
end
end
-- Print method
function classEnumerate:print (ident,close)
print(ident.."Enumerate{")
print(ident.." name = "..self.name)
local i=1
while self[i] do
print(ident.." '"..self[i].."'("..self.lnames[i].."),")
i = i+1
end
print(ident.."}"..close)
end
-- Internal constructor
function _Enumerate (t,varname)
setmetatable(t,classEnumerate)
append(t)
appendenum(t)
if varname and varname ~= "" then
if t.name ~= "" then
Variable(t.name.." "..varname)
else
local ns = getcurrnamespace()
warning("Variable "..ns..varname.." of type <anonymous enum> is declared as read-only")
Variable("tolua_readonly int "..varname)
end
end
local parent = classContainer.curr
if parent then
t.access = parent.curr_member_access
t.global_access = t:check_public_access()
end
return t
end
-- Constructor
-- Expects a string representing the enumerate body
function Enumerate (n,b,varname)
b = string.gsub(b, ",[%s\n]*}", "\n}") -- eliminate last ','
local t = split(strsub(b,2,-2),',') -- eliminate braces
local i = 1
local e = {n=0}
while t[i] do
local tt = split(t[i],'=') -- discard initial value
e.n = e.n + 1
e[e.n] = tt[1]
i = i+1
end
-- set lua names
i = 1
e.lnames = {}
local ns = getcurrnamespace()
while e[i] do
local t = split(e[i],'@')
e[i] = t[1]
if not t[2] then
t[2] = applyrenaming(t[1])
end
e.lnames[i] = t[2] or t[1]
_global_enums[ ns..e[i] ] = (ns..e[i])
i = i+1
end
e.name = n
if n ~= "" then
Typedef("int "..n)
end
return _Enumerate(e, varname)
end

139
3rdparty/toluapp/src/bin/lua/feature.lua vendored Normal file
View File

@ -0,0 +1,139 @@
-- tolua: abstract feature class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Feature class
-- Represents the base class of all mapped feature.
classFeature = {
}
classFeature.__index = classFeature
-- write support code
function classFeature:supcode ()
end
-- output tag
function classFeature:decltype ()
end
-- register feature
function classFeature:register (pre)
end
-- translate verbatim
function classFeature:preamble ()
end
-- check if it is a variable
function classFeature:isvariable ()
return false
end
-- check if it requires collection
function classFeature:requirecollection (t)
return false
end
-- build names
function classFeature:buildnames ()
if self.name and self.name~='' then
local n = split(self.name,'@')
self.name = n[1]
self.name = string.gsub(self.name, ":%d*$", "")
if not n[2] then
n[2] = applyrenaming(n[1])
end
self.lname = n[2] or gsub(n[1],"%[.-%]","")
self.lname = string.gsub(self.lname, ":%d*$", "")
self.original_name = self.name
self.lname = clean_template(self.lname)
end
if not self.is_parameter then
self.name = getonlynamespace() .. self.name
end
local parent = classContainer.curr
if parent then
self.access = parent.curr_member_access
self.global_access = self:check_public_access()
else
end
end
function classFeature:check_public_access()
if type(self.global_access) == "boolean" then
return self.global_access
end
if self.access and self.access ~= 0 then
return false
end
local parent = classContainer.curr
while parent do
if parent.access and parent.access ~= 0 then
return false
end
parent = parent.prox
end
return true
end
function clean_template(t)
return string.gsub(t, "[<>:, %*]", "_")
end
-- check if feature is inside a container definition
-- it returns the container class name or nil.
function classFeature:incontainer (which)
if self.parent then
local parent = self.parent
while parent do
if parent.classtype == which then
return parent.name
end
parent = parent.parent
end
end
return nil
end
function classFeature:inclass ()
return self:incontainer('class')
end
function classFeature:inmodule ()
return self:incontainer('module')
end
function classFeature:innamespace ()
return self:incontainer('namespace')
end
-- return C binding function name based on name
-- the client specifies a prefix
function classFeature:cfuncname (n)
if self.parent then
n = self.parent:cfuncname(n)
end
local fname = self.lname
if not fname or fname == '' then
fname = self.name
end
n = string.gsub(n..'_'.. (fname), "[<>:, \\.%*&]", "_")
return n
end

577
3rdparty/toluapp/src/bin/lua/function.lua vendored Normal file
View File

@ -0,0 +1,577 @@
-- tolua: function class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Function class
-- Represents a function or a class method.
-- The following fields are stored:
-- mod = type modifiers
-- type = type
-- ptr = "*" or "&", if representing a pointer or a reference
-- name = name
-- lname = lua name
-- args = list of argument declarations
-- const = if it is a method receiving a const "this".
classFunction = {
mod = '',
type = '',
ptr = '',
name = '',
args = {n=0},
const = '',
}
classFunction.__index = classFunction
setmetatable(classFunction,classFeature)
-- declare tags
function classFunction:decltype ()
self.type = typevar(self.type)
if strfind(self.mod,'const') then
self.type = 'const '..self.type
self.mod = gsub(self.mod,'const','')
end
local i=1
while self.args[i] do
self.args[i]:decltype()
i = i+1
end
end
-- Write binding function
-- Outputs C/C++ binding function.
function classFunction:supcode (local_constructor)
local overload = strsub(self.cname,-2,-1) - 1 -- indicate overloaded func
local nret = 0 -- number of returned values
local class = self:inclass()
local _,_,static = strfind(self.mod,'^%s*(static)')
if class then
if self.name == 'new' and self.parent.flags.pure_virtual then
-- no constructor for classes with pure virtual methods
return
end
if local_constructor then
output("/* method: new_local of class ",class," */")
else
output("/* method:",self.name," of class ",class," */")
end
else
output("/* function:",self.name," */")
end
if local_constructor then
output("#ifndef TOLUA_DISABLE_"..self.cname.."_local")
output("\nstatic int",self.cname.."_local","(lua_State* tolua_S)")
else
output("#ifndef TOLUA_DISABLE_"..self.cname)
output("\nstatic int",self.cname,"(lua_State* tolua_S)")
end
output("{")
-- check types
if overload < 0 then
output('#ifndef TOLUA_RELEASE\n')
end
output(' tolua_Error tolua_err;')
output(' if (\n')
-- check self
local narg
if class then narg=2 else narg=1 end
if class then
local func = get_is_function(self.parent.type)
local type = self.parent.type
if self.name=='new' or static~=nil then
func = 'tolua_isusertable'
type = self.parent.type
end
if self.const ~= '' then
type = "const "..type
end
output(' !'..func..'(tolua_S,1,"'..type..'",0,&tolua_err) ||\n')
end
-- check args
if self.args[1].type ~= 'void' then
local i=1
while self.args[i] do
local btype = isbasic(self.args[i].type)
if btype ~= 'value' and btype ~= 'state' then
output(' '..self.args[i]:outchecktype(narg)..' ||\n')
end
if btype ~= 'state' then
narg = narg+1
end
i = i+1
end
end
-- check end of list
output(' !tolua_isnoobj(tolua_S,'..narg..',&tolua_err)\n )')
output(' goto tolua_lerror;')
output(' else\n')
if overload < 0 then
output('#endif\n')
end
output(' {')
-- declare self, if the case
local narg
if class then narg=2 else narg=1 end
if class and self.name~='new' and static==nil then
output(' ',self.const,self.parent.type,'*','self = ')
output('(',self.const,self.parent.type,'*) ')
local to_func = get_to_function(self.parent.type)
output(to_func,'(tolua_S,1,0);')
elseif static then
_,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
end
-- declare parameters
if self.args[1].type ~= 'void' then
local i=1
while self.args[i] do
self.args[i]:declare(narg)
if isbasic(self.args[i].type) ~= "state" then
narg = narg+1
end
i = i+1
end
end
-- check self
if class and self.name~='new' and static==nil then
output('#ifndef TOLUA_RELEASE\n')
output(' if (!self) tolua_error(tolua_S,"'..output_error_hook("invalid \'self\' in function \'%s\'", self.name)..'", NULL);');
output('#endif\n')
end
-- get array element values
if class then narg=2 else narg=1 end
if self.args[1].type ~= 'void' then
local i=1
while self.args[i] do
self.args[i]:getarray(narg)
narg = narg+1
i = i+1
end
end
pre_call_hook(self)
local out = string.find(self.mod, "tolua_outside")
-- call function
if class and self.name=='delete' then
output(' Mtolua_delete(self);')
elseif class and self.name == 'operator&[]' then
if flags['1'] then -- for compatibility with tolua5 ?
output(' self->operator[](',self.args[1].name,'-1) = ',self.args[2].name,';')
else
output(' self->operator[](',self.args[1].name,') = ',self.args[2].name,';')
end
else
output(' {')
if self.type ~= '' and self.type ~= 'void' then
output(' ',self.mod,self.type,self.ptr,'tolua_ret = ')
output('(',self.mod,self.type,self.ptr,') ')
else
output(' ')
end
if class and self.name=='new' then
output('Mtolua_new((',self.type,')(')
elseif class and static then
if out then
output(self.name,'(')
else
output(class..'::'..self.name,'(')
end
elseif class then
if out then
output(self.name,'(')
else
if self.cast_operator then
--output('static_cast<',self.mod,self.type,self.ptr,' >(*self')
output('self->operator ',self.mod,self.type,'(')
else
output('self->'..self.name,'(')
end
end
else
output(self.name,'(')
end
if out and not static then
output('self')
if self.args[1] and self.args[1].name ~= '' then
output(',')
end
end
-- write parameters
local i=1
while self.args[i] do
self.args[i]:passpar()
i = i+1
if self.args[i] then
output(',')
end
end
if class and self.name == 'operator[]' and flags['1'] then
output('-1);')
else
if class and self.name=='new' then
output('));') -- close Mtolua_new(
else
output(');')
end
end
-- return values
if self.type ~= '' and self.type ~= 'void' then
nret = nret + 1
local t,ct = isbasic(self.type)
if t and self.name ~= "new" then
if self.cast_operator and _basic_raw_push[t] then
output(' ',_basic_raw_push[t],'(tolua_S,(',ct,')tolua_ret);')
else
output(' tolua_push'..t..'(tolua_S,(',ct,')tolua_ret);')
end
else
t = self.type
new_t = string.gsub(t, "const%s+", "")
local owned = false
if string.find(self.mod, "tolua_owned") then
owned = true
end
local push_func = get_push_function(t)
if self.ptr == '' then
output(' {')
output('#ifdef __cplusplus\n')
output(' void* tolua_obj = Mtolua_new((',new_t,')(tolua_ret));')
output(' ',push_func,'(tolua_S,tolua_obj,"',t,'");')
output(' tolua_register_gc(tolua_S,lua_gettop(tolua_S));')
output('#else\n')
output(' void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(',t,'));')
output(' ',push_func,'(tolua_S,tolua_obj,"',t,'");')
output(' tolua_register_gc(tolua_S,lua_gettop(tolua_S));')
output('#endif\n')
output(' }')
elseif self.ptr == '&' then
output(' ',push_func,'(tolua_S,(void*)&tolua_ret,"',t,'");')
else
output(' ',push_func,'(tolua_S,(void*)tolua_ret,"',t,'");')
if owned or local_constructor then
output(' tolua_register_gc(tolua_S,lua_gettop(tolua_S));')
end
end
end
end
local i=1
while self.args[i] do
nret = nret + self.args[i]:retvalue()
i = i+1
end
output(' }')
-- set array element values
if class then narg=2 else narg=1 end
if self.args[1].type ~= 'void' then
local i=1
while self.args[i] do
self.args[i]:setarray(narg)
narg = narg+1
i = i+1
end
end
-- free dynamically allocated array
if self.args[1].type ~= 'void' then
local i=1
while self.args[i] do
self.args[i]:freearray()
i = i+1
end
end
end
post_call_hook(self)
output(' }')
output(' return '..nret..';')
-- call overloaded function or generate error
if overload < 0 then
output('#ifndef TOLUA_RELEASE\n')
output('tolua_lerror:\n')
output(' tolua_error(tolua_S,"'..output_error_hook("#ferror in function \'%s\'.", self.lname)..'",&tolua_err);')
output(' return 0;')
output('#endif\n')
else
local _local = ""
if local_constructor then
_local = "_local"
end
output('tolua_lerror:\n')
output(' return '..strsub(self.cname,1,-3)..format("%02d",overload).._local..'(tolua_S);')
end
output('}')
output('#endif //#ifndef TOLUA_DISABLE\n')
output('\n')
-- recursive call to write local constructor
if class and self.name=='new' and not local_constructor then
self:supcode(1)
end
end
-- register function
function classFunction:register (pre)
if not self:check_public_access() then
return
end
if self.name == 'new' and self.parent.flags.pure_virtual then
-- no constructor for classes with pure virtual methods
return
end
output(pre..'tolua_function(tolua_S,"'..self.lname..'",'..self.cname..');')
if self.name == 'new' then
output(pre..'tolua_function(tolua_S,"new_local",'..self.cname..'_local);')
output(pre..'tolua_function(tolua_S,".call",'..self.cname..'_local);')
--output(' tolua_set_call_event(tolua_S,'..self.cname..'_local, "'..self.parent.type..'");')
end
end
-- Print method
function classFunction:print (ident,close)
print(ident.."Function{")
print(ident.." mod = '"..self.mod.."',")
print(ident.." type = '"..self.type.."',")
print(ident.." ptr = '"..self.ptr.."',")
print(ident.." name = '"..self.name.."',")
print(ident.." lname = '"..self.lname.."',")
print(ident.." const = '"..self.const.."',")
print(ident.." cname = '"..self.cname.."',")
print(ident.." lname = '"..self.lname.."',")
print(ident.." args = {")
local i=1
while self.args[i] do
self.args[i]:print(ident.." ",",")
i = i+1
end
print(ident.." }")
print(ident.."}"..close)
end
-- check if it returns an object by value
function classFunction:requirecollection (t)
local r = false
if self.type ~= '' and not isbasic(self.type) and self.ptr=='' then
local type = gsub(self.type,"%s*const%s+","")
t[type] = "tolua_collect_" .. clean_template(type)
r = true
end
local i=1
while self.args[i] do
r = self.args[i]:requirecollection(t) or r
i = i+1
end
return r
end
-- determine lua function name overload
function classFunction:overload ()
return self.parent:overload(self.lname)
end
function param_object(par) -- returns true if the parameter has an object as its default value
if not string.find(par, '=') then return false end -- it has no default value
local _,_,def = string.find(par, "=(.*)$")
if string.find(par, "|") then -- a list of flags
return true
end
if string.find(par, "%*") then -- it's a pointer with a default value
if string.find(par, '=%s*new') or string.find(par, "%(") then -- it's a pointer with an instance as default parameter.. is that valid?
return true
end
return false -- default value is 'NULL' or something
end
if string.find(par, "[%(&]") then
return true
end -- default value is a constructor call (most likely for a const reference)
--if string.find(par, "&") then
-- if string.find(def, ":") or string.find(def, "^%s*new%s+") then
-- -- it's a reference with default to something like Class::member, or 'new Class'
-- return true
-- end
--end
return false -- ?
end
function strip_last_arg(all_args, last_arg) -- strips the default value from the last argument
local _,_,s_arg = string.find(last_arg, "^([^=]+)")
last_arg = string.gsub(last_arg, "([%%%(%)])", "%%%1");
all_args = string.gsub(all_args, "%s*,%s*"..last_arg.."%s*%)%s*$", ")")
return all_args, s_arg
end
-- Internal constructor
function _Function (t)
setmetatable(t,classFunction)
if t.const ~= 'const' and t.const ~= '' then
error("#invalid 'const' specification")
end
append(t)
if t:inclass() then
--print ('t.name is '..t.name..', parent.name is '..t.parent.name)
if string.gsub(t.name, "%b<>", "") == string.gsub(t.parent.original_name or t.parent.name, "%b<>", "") then
t.name = 'new'
t.lname = 'new'
t.parent._new = true
t.type = t.parent.name
t.ptr = '*'
elseif string.gsub(t.name, "%b<>", "") == '~'..string.gsub(t.parent.original_name or t.parent.name, "%b<>", "") then
t.name = 'delete'
t.lname = 'delete'
t.parent._delete = true
end
end
t.cname = t:cfuncname("tolua")..t:overload(t)
return t
end
-- Constructor
-- Expects three strings: one representing the function declaration,
-- another representing the argument list, and the third representing
-- the "const" or empty string.
function Function (d,a,c)
--local t = split(strsub(a,2,-2),',') -- eliminate braces
--local t = split_params(strsub(a,2,-2))
if not flags['W'] and string.find(a, "%.%.%.%s*%)") then
warning("Functions with variable arguments (`...') are not supported. Ignoring "..d..a..c)
return nil
end
local i=1
local l = {n=0}
a = string.gsub(a, "%s*([%(%)])%s*", "%1")
local t,strip,last = strip_pars(strsub(a,2,-2));
if strip then
--local ns = string.sub(strsub(a,1,-2), 1, -(string.len(last)+1))
local ns = join(t, ",", 1, last-1)
ns = "("..string.gsub(ns, "%s*,%s*$", "")..')'
--ns = strip_defaults(ns)
local f = Function(d, ns, c)
for i=1,last do
t[i] = string.gsub(t[i], "=.*$", "")
end
end
while t[i] do
l.n = l.n+1
l[l.n] = Declaration(t[i],'var',true)
i = i+1
end
local f = Declaration(d,'func')
f.args = l
f.const = c
return _Function(f)
end
function join(t, sep, first, last)
first = first or 1
last = last or #t
local lsep = ""
local ret = ""
local loop = false
for i = first,last do
ret = ret..lsep..t[i]
lsep = sep
loop = true
end
if not loop then
return ""
end
return ret
end
function strip_pars(s)
local t = split_c_tokens(s, ',')
local strip = false
local last
for i=t.n,1,-1 do
if not strip and param_object(t[i]) then
last = i
strip = true
end
--if strip then
-- t[i] = string.gsub(t[i], "=.*$", "")
--end
end
return t,strip,last
end
function strip_defaults(s)
s = string.gsub(s, "^%(", "")
s = string.gsub(s, "%)$", "")
local t = split_c_tokens(s, ",")
local sep, ret = "",""
for i=1,t.n do
t[i] = string.gsub(t[i], "=.*$", "")
ret = ret..sep..t[i]
sep = ","
end
return "("..ret..")"
end

68
3rdparty/toluapp/src/bin/lua/module.lua vendored Normal file
View File

@ -0,0 +1,68 @@
-- tolua: module class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Module class
-- Represents module.
-- The following fields are stored:
-- {i} = list of objects in the module.
classModule = {
classtype = 'module'
}
classModule.__index = classModule
setmetatable(classModule,classContainer)
-- register module
function classModule:register (pre)
pre = pre or ''
push(self)
output(pre..'tolua_module(tolua_S,"'..self.name..'",',self:hasvar(),');')
output(pre..'tolua_beginmodule(tolua_S,"'..self.name..'");')
local i=1
while self[i] do
self[i]:register(pre..' ')
i = i+1
end
output(pre..'tolua_endmodule(tolua_S);')
pop()
end
-- Print method
function classModule:print (ident,close)
print(ident.."Module{")
print(ident.." name = '"..self.name.."';")
local i=1
while self[i] do
self[i]:print(ident.." ",",")
i = i+1
end
print(ident.."}"..close)
end
-- Internal constructor
function _Module (t)
setmetatable(t,classModule)
append(t)
return t
end
-- Constructor
-- Expects two string representing the module name and body.
function Module (n,b)
local t = _Module(_Container{name=n})
push(t)
t:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces
pop()
return t
end

52
3rdparty/toluapp/src/bin/lua/namespace.lua vendored Normal file
View File

@ -0,0 +1,52 @@
-- tolua: namespace class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 2003
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Namespace class
-- Represents a namesapce definition.
-- Stores the following fields:
-- name = class name
-- {i} = list of members
classNamespace = {
classtype = 'namespace',
name = '',
}
classNamespace.__index = classNamespace
setmetatable(classNamespace,classModule)
-- Print method
function classNamespace:print (ident,close)
print(ident.."Namespace{")
print(ident.." name = '"..self.name.."',")
local i=1
while self[i] do
self[i]:print(ident.." ",",")
i = i+1
end
print(ident.."}"..close)
end
-- Internal constructor
function _Namespace (t)
setmetatable(t,classNamespace)
append(t)
return t
end
-- Constructor
-- Expects the name and the body of the namespace.
function Namespace (n,b)
local c = _Namespace(_Container{name=n})
push(c)
c:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces
pop()
end

220
3rdparty/toluapp/src/bin/lua/operator.lua vendored Normal file
View File

@ -0,0 +1,220 @@
-- tolua: operator class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Operator class
-- Represents an operator function or a class operator method.
-- It stores the same fields as functions do plus:
-- kind = set of character representing the operator (as it appers in C++ code)
classOperator = {
kind = '',
}
classOperator.__index = classOperator
setmetatable(classOperator,classFunction)
-- table to transform operator kind into the appropriate tag method name
_TM = {['+'] = 'add',
['-'] = 'sub',
['*'] = 'mul',
['/'] = 'div',
['<'] = 'lt',
['<='] = 'le',
['=='] = 'eq',
['[]'] = 'geti',
['&[]'] = 'seti',
--['->'] = 'flechita',
}
-- Print method
function classOperator:print (ident,close)
print(ident.."Operator{")
print(ident.." kind = '"..self.kind.."',")
print(ident.." mod = '"..self.mod.."',")
print(ident.." type = '"..self.type.."',")
print(ident.." ptr = '"..self.ptr.."',")
print(ident.." name = '"..self.name.."',")
print(ident.." const = '"..self.const.."',")
print(ident.." cname = '"..self.cname.."',")
print(ident.." lname = '"..self.lname.."',")
print(ident.." args = {")
local i=1
while self.args[i] do
self.args[i]:print(ident.." ",",")
i = i+1
end
print(ident.." }")
print(ident.."}"..close)
end
function classOperator:supcode_tmp()
if not _TM[self.kind] then
return classFunction.supcode(self)
end
-- no overload, no parameters, always inclass
output("/* method:",self.name," of class ",self:inclass()," */")
output("#ifndef TOLUA_DISABLE_"..self.cname)
output("\nstatic int",self.cname,"(lua_State* tolua_S)")
if overload < 0 then
output('#ifndef TOLUA_RELEASE\n')
end
output(' tolua_Error tolua_err;')
output(' if (\n')
-- check self
local is_func = get_is_function(self.parent.type)
output(' !'..is_func..'(tolua_S,1,"'..self.parent.type..'",0,&tolua_err) ||\n')
output(' !tolua_isnoobj(tolua_S,2,&tolua_err)\n )')
output(' goto tolua_lerror;')
output(' else\n')
output('#endif\n') -- tolua_release
output(' {')
-- declare self
output(' ',self.const,self.parent.type,'*','self = ')
output('(',self.const,self.parent.type,'*) ')
local to_func = get_to_func(self.parent.type)
output(to_func,'(tolua_S,1,0);')
-- check self
output('#ifndef TOLUA_RELEASE\n')
output(' if (!self) tolua_error(tolua_S,"'..output_error_hook("invalid \'self\' in function \'%s\'", self.name)..'",NULL);');
output('#endif\n')
-- cast self
output(' ',self.mod,self.type,self.ptr,'tolua_ret = ')
output('(',self.mod,self.type,self.ptr,')(*self);')
-- return value
local t,ct = isbasic(self.type)
if t then
output(' tolua_push'..t..'(tolua_S,(',ct,')tolua_ret);')
else
t = self.type
local push_func = get_push_function(t)
new_t = string.gsub(t, "const%s+", "")
if self.ptr == '' then
output(' {')
output('#ifdef __cplusplus\n')
output(' void* tolua_obj = Mtolua_new((',new_t,')(tolua_ret));')
output(' ',push_func,'(tolua_S,tolua_obj,"',t,'");')
output(' tolua_register_gc(tolua_S,lua_gettop(tolua_S));')
output('#else\n')
output(' void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(',t,'));')
output(' ',push_func,'(tolua_S,tolua_obj,"',t,'");')
output(' tolua_register_gc(tolua_S,lua_gettop(tolua_S));')
output('#endif\n')
output(' }')
elseif self.ptr == '&' then
output(' ',push_func,'(tolua_S,(void*)&tolua_ret,"',t,'");')
else
if local_constructor then
output(' ',push_func,'(tolua_S,(void *)tolua_ret,"',t,'");')
output(' tolua_register_gc(tolua_S,lua_gettop(tolua_S));')
else
output(' ',push_func,'(tolua_S,(void*)tolua_ret,"',t,'");')
end
end
end
output(' }')
output(' return 1;')
output('#ifndef TOLUA_RELEASE\n')
output('tolua_lerror:\n')
output(' tolua_error(tolua_S,"'..output_error_hook("#ferror in function \'%s\'.", self.lname)..'",&tolua_err);')
output(' return 0;')
output('#endif\n')
output('}')
output('#endif //#ifndef TOLUA_DISABLE\n')
output('\n')
end
-- Internal constructor
function _Operator (t)
setmetatable(t,classOperator)
if t.const ~= 'const' and t.const ~= '' then
error("#invalid 'const' specification")
end
append(t)
if not t:inclass() then
error("#operator can only be defined as class member")
end
--t.name = t.name .. "_" .. (_TM[t.kind] or t.kind)
t.cname = t:cfuncname("tolua")..t:overload(t)
t.name = "operator" .. t.kind -- set appropriate calling name
return t
end
-- Constructor
function Operator (d,k,a,c)
local op_k = string.gsub(k, "^%s*", "")
op_k = string.gsub(k, "%s*$", "")
--if string.find(k, "^[%w_:%d<>%*%&]+$") then
if d == "operator" and k ~= '' then
d = k.." operator"
elseif not _TM[op_k] then
if flags['W'] then
error("tolua: no support for operator" .. f.kind)
else
warning("No support for operator "..op_k..", ignoring")
return nil
end
end
local ref = ''
local t = split_c_tokens(strsub(a,2,strlen(a)-1),',') -- eliminate braces
local i=1
local l = {n=0}
while t[i] do
l.n = l.n+1
l[l.n] = Declaration(t[i],'var')
i = i+1
end
if k == '[]' then
local _
_, _, ref = strfind(d,'(&)')
d = gsub(d,'&','')
elseif k=='&[]' then
l.n = l.n+1
l[l.n] = Declaration(d,'var')
l[l.n].name = 'tolua_value'
end
local f = Declaration(d,'func')
if k == '[]' and (l[1]==nil or isbasic(l[1].type)~='number') then
error('operator[] can only be defined for numeric index.')
end
f.args = l
f.const = c
f.kind = op_k
f.lname = "."..(_TM[f.kind] or f.kind)
if not _TM[f.kind] then
f.cast_operator = true
end
if f.kind == '[]' and ref=='&' and f.const~='const' then
Operator(d,'&'..k,a,c) -- create correspoding set operator
end
return _Operator(f)
end

342
3rdparty/toluapp/src/bin/lua/package.lua vendored Normal file
View File

@ -0,0 +1,342 @@
-- tolua: package class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Package class
-- Represents the whole package being bound.
-- The following fields are stored:
-- {i} = list of objects in the package.
classPackage = {
classtype = 'package'
}
classPackage.__index = classPackage
setmetatable(classPackage,classContainer)
-- Print method
function classPackage:print ()
print("Package: "..self.name)
local i=1
while self[i] do
self[i]:print("","")
i = i+1
end
end
function classPackage:preprocess ()
-- avoid preprocessing embedded Lua code
local L = {}
self.code = gsub(self.code,"\n%s*%$%[","\1") -- deal with embedded lua code
self.code = gsub(self.code,"\n%s*%$%]","\2")
self.code = gsub(self.code,"(%b\1\2)", function (c)
tinsert(L,c)
return "\n#[".. #L .."]#"
end)
-- avoid preprocessing embedded C code
local C = {}
self.code = gsub(self.code,"\n%s*%$%<","\3") -- deal with embedded C code
self.code = gsub(self.code,"\n%s*%$%>","\4")
self.code = gsub(self.code,"(%b\3\4)", function (c)
tinsert(C,c)
return "\n#<".. #C ..">#"
end)
-- avoid preprocessing embedded C code
self.code = gsub(self.code,"\n%s*%$%{","\5") -- deal with embedded C code
self.code = gsub(self.code,"\n%s*%$%}","\6")
self.code = gsub(self.code,"(%b\5\6)", function (c)
tinsert(C,c)
return "\n#<".. #C..">#"
end)
--self.code = gsub(self.code,"\n%s*#[^d][^\n]*\n", "\n\n") -- eliminate preprocessor directives that don't start with 'd'
self.code = gsub(self.code,"\n[ \t]*#[ \t]*[^d%<%[]", "\n//") -- eliminate preprocessor directives that don't start with 'd'
-- avoid preprocessing verbatim lines
local V = {}
self.code = gsub(self.code,"\n(%s*%$[^%[%]][^\n]*)",function (v)
tinsert(V,v)
return "\n#".. #V .."#"
end)
-- perform global substitution
self.code = gsub(self.code,"(//[^\n]*)","") -- eliminate C++ comments
self.code = gsub(self.code,"/%*","\1")
self.code = gsub(self.code,"%*/","\2")
self.code = gsub(self.code,"%b\1\2","")
self.code = gsub(self.code,"\1","/%*")
self.code = gsub(self.code,"\2","%*/")
self.code = gsub(self.code,"%s*@%s*","@") -- eliminate spaces beside @
self.code = gsub(self.code,"%s?inline(%s)","%1") -- eliminate 'inline' keyword
--self.code = gsub(self.code,"%s?extern(%s)","%1") -- eliminate 'extern' keyword
--self.code = gsub(self.code,"%s?virtual(%s)","%1") -- eliminate 'virtual' keyword
--self.code = gsub(self.code,"public:","") -- eliminate 'public:' keyword
self.code = gsub(self.code,"([^%w_])void%s*%*","%1_userdata ") -- substitute 'void*'
self.code = gsub(self.code,"([^%w_])void%s*%*","%1_userdata ") -- substitute 'void*'
self.code = gsub(self.code,"([^%w_])char%s*%*","%1_cstring ") -- substitute 'char*'
self.code = gsub(self.code,"([^%w_])lua_State%s*%*","%1_lstate ") -- substitute 'lua_State*'
-- restore embedded Lua code
self.code = gsub(self.code,"%#%[(%d+)%]%#",function (n)
return L[tonumber(n)]
end)
-- restore embedded C code
self.code = gsub(self.code,"%#%<(%d+)%>%#",function (n)
return C[tonumber(n)]
end)
-- restore verbatim lines
self.code = gsub(self.code,"%#(%d+)%#",function (n)
return V[tonumber(n)]
end)
self.code = string.gsub(self.code, "\n%s*%$([^\n]+)", function (l)
Verbatim(l.."\n")
return "\n"
end)
end
-- translate verbatim
function classPackage:preamble ()
output('/*\n')
output('** Lua binding: '..self.name..'\n')
output('** Generated automatically by '..TOLUA_VERSION..' on '..date()..'.\n')
output('*/\n\n')
output('#ifndef __cplusplus\n')
output('#include "stdlib.h"\n')
output('#endif\n')
output('#include "string.h"\n\n')
output('#include "tolua++.h"\n\n')
if not flags.h then
output('/* Exported function */')
output('TOLUA_API int tolua_'..self.name..'_open (lua_State* tolua_S);')
output('\n')
end
local i=1
while self[i] do
self[i]:preamble()
i = i+1
end
if self:requirecollection(_collect) then
output('\n')
output('/* function to release collected object via destructor */')
output('#ifdef __cplusplus\n')
for i,v in pairs(_collect) do
output('\nstatic int '..v..' (lua_State* tolua_S)')
output('{')
output(' '..i..'* self = ('..i..'*) tolua_tousertype(tolua_S,1,0);')
output(' Mtolua_delete(self);')
output(' return 0;')
output('}')
end
output('#endif\n\n')
end
output('\n')
output('/* function to register type */')
output('static void tolua_reg_types (lua_State* tolua_S)')
output('{')
if flags.t then
output("#ifndef Mtolua_typeid\n#define Mtolua_typeid(L,TI,T)\n#endif\n")
end
for n,v in pairs(_usertype) do
if (not _global_classes[v]) or _global_classes[v]:check_public_access() then
output(' tolua_usertype(tolua_S,"',v,'");')
if flags.t then
output(' Mtolua_typeid(tolua_S,typeid(',v,'), "',v,'");')
end
end
end
output('}')
output('\n')
end
-- register package
-- write package open function
function classPackage:register (pre)
pre = pre or ''
push(self)
output(pre.."/* Open function */")
output(pre.."TOLUA_API int tolua_"..self.name.."_open (lua_State* tolua_S)")
output(pre.."{")
output(pre.." tolua_open(tolua_S);")
output(pre.." tolua_reg_types(tolua_S);")
output(pre.." tolua_module(tolua_S,NULL,",self:hasvar(),");")
output(pre.." tolua_beginmodule(tolua_S,NULL);")
local i=1
while self[i] do
self[i]:register(pre.." ")
i = i+1
end
output(pre.." tolua_endmodule(tolua_S);")
output(pre.." return 1;")
output(pre.."}")
output("\n\n")
output("#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501\n");
output(pre.."TOLUA_API int luaopen_"..self.name.." (lua_State* tolua_S) {")
output(pre.." return tolua_"..self.name.."_open(tolua_S);")
output(pre.."};")
output("#endif\n\n")
pop()
end
-- write header file
function classPackage:header ()
output('/*\n') output('** Lua binding: '..self.name..'\n')
output('** Generated automatically by '..TOLUA_VERSION..' on '..date()..'.\n')
output('*/\n\n')
if not flags.h then
output('/* Exported function */')
output('TOLUA_API int tolua_'..self.name..'_open (lua_State* tolua_S);')
output('\n')
end
end
-- Internal constructor
function _Package (self)
setmetatable(self,classPackage)
return self
end
-- Parse C header file with tolua directives
-- *** Thanks to Ariel Manzur for fixing bugs in nested directives ***
function extract_code(fn,s)
local code = '\n$#include "'..fn..'"\n'
s= "\n" .. s .. "\n" -- add blank lines as sentinels
local _,e,c,t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n")
while e do
t = strlower(t)
if t == "begin" then
_,e,c = strfind(s,"(.-)\n[^\n]*[Tt][Oo][Ll][Uu][Aa]_[Ee][Nn][Dd][^\n]*\n",e)
if not e then
tolua_error("Unbalanced 'tolua_begin' directive in header file")
end
end
code = code .. c .. "\n"
_,e,c,t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n",e)
end
return code
end
-- Constructor
-- Expects the package name, the file extension, and the file text.
function Package (name,fn)
local ext = "pkg"
-- open input file, if any
local st,msg
if fn then
st, msg = readfrom(flags.f)
if not st then
error('#'..msg)
end
local _; _, _, ext = strfind(fn,".*%.(.*)$")
end
local code
if ext == 'pkg' then
code = prep(st)
else
code = "\n" .. read('*a')
if ext == 'h' or ext == 'hpp' then
code = extract_code(fn,code)
end
end
-- close file
if fn then
readfrom()
end
-- deal with include directive
local nsubst
repeat
code,nsubst = gsub(code,'\n%s*%$(.)file%s*"(.-)"([^\n]*)\n',
function (kind,fn,extra)
local _, _, ext = strfind(fn,".*%.(.*)$")
local fp,msg = openfile(fn,'r')
if not fp then
error('#'..msg..': '..fn)
end
if kind == 'p' then
local s = prep(fp)
closefile(fp)
return s
end
local s = read(fp,'*a')
closefile(fp)
if kind == 'c' or kind == 'h' then
return extract_code(fn,s)
elseif kind == 'l' then
return "\n$[--##"..fn.."\n" .. s .. "\n$]\n"
elseif kind == 'i' then
local t = {code=s}
extra = string.gsub(extra, "^%s*,%s*", "")
local pars = split_c_tokens(extra, ",")
include_file_hook(t, fn, table.unpack(pars))
return "\n\n" .. t.code
else
error('#Invalid include directive (use $cfile, $pfile, $lfile or $ifile)')
end
end)
until nsubst==0
-- deal with renaming directive
repeat -- I don't know why this is necesary
code,nsubst = gsub(code,'\n%s*%$renaming%s*(.-)%s*\n', function (r) appendrenaming(r) return "\n" end)
until nsubst == 0
local t = _Package(_Container{name=name, code=code})
push(t)
preprocess_hook(t)
t:preprocess()
preparse_hook(t)
t:parse(t.code)
pop()
return t
end
setmetatable(_extra_parameters, { __index = _G })
function prep(file)
local chunk = {'local __ret = {"\\n"}\n'}
for line in file:lines() do
if string.find(line, "^##") then
table.insert(chunk, string.sub(line, 3) .. "\n")
else
local last = 1
for text, expr, index in string.gmatch(line, "(.-)$(%b())()") do
last = index
if text ~= "" then
table.insert(chunk, string.format('table.insert(__ret, %q )', text))
end
table.insert(chunk, string.format('table.insert(__ret, %s )', expr))
end
table.insert(chunk, string.format('table.insert(__ret, %q)\n',
string.sub(line, last).."\n"))
end
end
table.insert(chunk, '\nreturn table.concat(__ret)\n')
local f,e = load(table.concat(chunk), nil, "t", _extra_parameters)
if e then
error("#"..e)
end
return f()
end

82
3rdparty/toluapp/src/bin/lua/template_class.lua vendored Normal file
View File

@ -0,0 +1,82 @@
_global_templates = {}
classTemplateClass = {
name = '',
body = '',
parents = {},
args = {}, -- the template arguments
}
classTemplateClass.__index = classTemplateClass
function classTemplateClass:throw(types, local_scope)
--if table.getn(types) ~= table.getn(self.args) then
-- error("#invalid parameter count")
--end
-- replace
for i =1 , types.n do
local Il = split_c_tokens(types[i], " ")
if #Il ~= #self.args then
error("#invalid parameter count for "..types[i])
end
local bI = self.body
local pI = {}
for j = 1,self.args.n do
--Tl[j] = findtype(Tl[j]) or Tl[j]
bI = string.gsub(bI, "([^_%w])"..self.args[j].."([^_%w])", "%1"..Il[j].."%2")
if self.parents then
for i=1,#self.parents do
pI[i] = string.gsub(self.parents[i], "([^_%w]?)"..self.args[j].."([^_%w]?)", "%1"..Il[j].."%2")
end
end
end
--local append = "<"..string.gsub(types[i], "%s+", ",")..">"
local append = "<"..concat(Il, 1, #Il, ",")..">"
append = string.gsub(append, "%s*,%s*", ",")
append = string.gsub(append, ">>", "> >")
for i=1,#pI do
--pI[i] = string.gsub(pI[i], ">>", "> >")
pI[i] = resolve_template_types(pI[i])
end
bI = string.gsub(bI, ">>", "> >")
local n = self.name
if local_scope then
n = self.local_name
end
Class(n..append, pI, bI)
end
end
function TemplateClass(name, parents, body, parameters)
local o = {
parents = parents,
body = body,
args = parameters,
}
local oname = string.gsub(name, "@.*$", "")
oname = getnamespace(classContainer.curr)..oname
o.name = oname
o.local_name = name
setmetatable(o, classTemplateClass)
if _global_templates[oname] then
warning("Duplicate declaration of template "..oname)
else
_global_templates[oname] = o
end
return o
end

71
3rdparty/toluapp/src/bin/lua/typedef.lua vendored Normal file
View File

@ -0,0 +1,71 @@
-- tolua: typedef class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Typedef class
-- Represents a type synonym.
-- The 'de facto' type replaces the typedef before the
-- remaining code is parsed.
-- The following fields are stored:
-- utype = typedef name
-- type = 'the facto' type
-- mod = modifiers to the 'de facto' type
classTypedef = {
utype = '',
mod = '',
type = ''
}
classTypedef.__index = classTypedef
-- Print method
function classTypedef:print (ident,close)
print(ident.."Typedef{")
print(ident.." utype = '"..self.utype.."',")
print(ident.." mod = '"..self.mod.."',")
print(ident.." type = '"..self.type.."',")
print(ident.."}"..close)
end
-- Return it's not a variable
function classTypedef:isvariable ()
return false
end
-- Internal constructor
function _Typedef (t)
setmetatable(t,classTypedef)
t.type = resolve_template_types(t.type)
appendtypedef(t)
return t
end
-- Constructor
-- Expects one string representing the type definition.
function Typedef (s)
if strfind(string.gsub(s, '%b<>', ''),'[%*&]') then
tolua_error("#invalid typedef: pointers (and references) are not supported")
end
local o = {mod = ''}
if string.find(s, "[<>]") then
_,_,o.type,o.utype = string.find(s, "^%s*([^<>]+%b<>[^%s]*)%s+(.-)$")
else
local t = split(gsub(s,"%s%s*"," ")," ")
o = {
utype = t[t.n],
type = t[t.n-1],
mod = concat(t,1,t.n-2),
}
end
return _Typedef(o)
end

300
3rdparty/toluapp/src/bin/lua/variable.lua vendored Normal file
View File

@ -0,0 +1,300 @@
-- tolua: variable class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Variable class
-- Represents a extern variable or a public member of a class.
-- Stores all fields present in a declaration.
classVariable = {
_get = {}, -- mapped get functions
_set = {}, -- mapped set functions
}
classVariable.__index = classVariable
setmetatable(classVariable,classDeclaration)
-- Print method
function classVariable:print (ident,close)
print(ident.."Variable{")
print(ident.." mod = '"..self.mod.."',")
print(ident.." type = '"..self.type.."',")
print(ident.." ptr = '"..self.ptr.."',")
print(ident.." name = '"..self.name.."',")
if self.dim then print(ident.." dim = '"..self.dim.."',") end
print(ident.." def = '"..self.def.."',")
print(ident.." ret = '"..self.ret.."',")
print(ident.."}"..close)
end
-- Generates C function name
function classVariable:cfuncname (prefix)
local parent = ""
local unsigned = ""
local ptr = ""
local p = self:inmodule() or self:innamespace() or self:inclass()
if p then
if self.parent.classtype == 'class' then
parent = "_" .. self.parent.type
else
parent = "_" .. p
end
end
if strfind(self.mod,"(unsigned)") then
unsigned = "_unsigned"
end
if self.ptr == "*" then ptr = "_ptr"
elseif self.ptr == "&" then ptr = "_ref"
end
local name = prefix .. parent .. unsigned .. "_" .. gsub(self.lname or self.name,".*::","") .. ptr
name = clean_template(name)
return name
end
-- check if it is a variable
function classVariable:isvariable ()
return true
end
-- get variable value
function classVariable:getvalue (class,static, prop_get)
local name
if prop_get then
name = prop_get.."()"
else
name = self.name
end
if class and static then
return self.parent.type..'::'..name
elseif class then
return 'self->'..name
else
return name
end
end
-- get variable pointer value
function classVariable:getpointervalue (class,static)
if class and static then
return class..'::p'
elseif class then
return 'self->p'
else
return 'p'
end
end
-- Write binding functions
function classVariable:supcode ()
local class = self:inclass()
local prop_get,prop_set
if string.find(self.mod, 'tolua_property') then
local _,_,type = string.find(self.mod, "tolua_property__([^%s]*)")
type = type or "default"
prop_get,prop_set = get_property_methods(type, self.name)
self.mod = string.gsub(self.mod, "tolua_property[^%s]*", "")
end
-- get function ------------------------------------------------
if class then
output("/* get function:",self.name," of class ",class," */")
else
output("/* get function:",self.name," */")
end
self.cgetname = self:cfuncname("tolua_get")
output("#ifndef TOLUA_DISABLE_"..self.cgetname)
output("\nstatic int",self.cgetname,"(lua_State* tolua_S)")
output("{")
-- declare self, if the case
local _,_,static = strfind(self.mod,'^%s*(static)')
if class and static==nil then
output(' ',self.parent.type,'*','self = ')
output('(',self.parent.type,'*) ')
local to_func = get_to_function(self.parent.type)
output(to_func,'(tolua_S,1,0);')
elseif static then
_,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
end
-- check self value
if class and static==nil then
output('#ifndef TOLUA_RELEASE\n')
output(' if (!self) tolua_error(tolua_S,"'..output_error_hook("invalid \'self\' in accessing variable \'%s\'", self.name)..'",NULL);');
output('#endif\n')
end
-- return value
if string.find(self.mod, 'tolua_inherits') then
local push_func = get_push_function(self.type)
output('#ifdef __cplusplus\n')
output(' ',push_func,'(tolua_S,(void*)static_cast<'..self.type..'*>(self), "',self.type,'");')
output('#else\n')
output(' ',push_func,'(tolua_S,(void*)(('..self.type..'*)self), "',self.type,'");')
output('#endif\n')
else
local t,ct = isbasic(self.type)
if t then
output(' tolua_push'..t..'(tolua_S,(',ct,')'..self:getvalue(class,static,prop_get)..');')
else
local push_func = get_push_function(self.type)
t = self.type
if self.ptr == '&' or self.ptr == '' then
output(' ',push_func,'(tolua_S,(void*)&'..self:getvalue(class,static,prop_get)..',"',t,'");')
else
output(' ',push_func,'(tolua_S,(void*)'..self:getvalue(class,static,prop_get)..',"',t,'");')
end
end
end
output(' return 1;')
output('}')
output('#endif //#ifndef TOLUA_DISABLE\n')
output('\n')
-- set function ------------------------------------------------
if not (strfind(self.type,'const%s+') or string.find(self.mod, 'tolua_readonly') or string.find(self.mod, 'tolua_inherits')) then
if class then
output("/* set function:",self.name," of class ",class," */")
else
output("/* set function:",self.name," */")
end
self.csetname = self:cfuncname("tolua_set")
output("#ifndef TOLUA_DISABLE_"..self.csetname)
output("\nstatic int",self.csetname,"(lua_State* tolua_S)")
output("{")
-- declare self, if the case
if class and static==nil then
output(' ',self.parent.type,'*','self = ')
output('(',self.parent.type,'*) ')
local to_func = get_to_function(self.parent.type)
output(to_func,'(tolua_S,1,0);')
-- check self value
end
-- check types
output('#ifndef TOLUA_RELEASE\n')
output(' tolua_Error tolua_err;')
if class and static==nil then
output(' if (!self) tolua_error(tolua_S,"'..output_error_hook("invalid \'self\' in accessing variable \'%s\'", self.name)..'",NULL);');
elseif static then
_,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
end
-- check variable type
output(' if ('..self:outchecktype(2)..')')
output(' tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);')
output('#endif\n')
-- assign value
local def = 0
if self.def ~= '' then def = self.def end
if self.type == 'char*' and self.dim ~= '' then -- is string
output(' strncpy((char*)')
if class and static then
output(self.parent.type..'::'..self.name)
elseif class then
output('self->'..self.name)
else
output(self.name)
end
output(',(const char*)tolua_tostring(tolua_S,2,',def,'),',self.dim,'-1);')
else
local ptr = ''
if self.ptr~='' then ptr = '*' end
output(' ')
local name = prop_set or self.name
if class and static then
output(self.parent.type..'::'..name)
elseif class then
output('self->'..name)
else
output(name)
end
local t = isbasic(self.type)
if prop_set then
output('(')
else
output(' = ')
end
if not t and ptr=='' then output('*') end
output('((',self.mod,self.type)
if not t then
output('*')
end
output(') ')
if t then
if isenum(self.type) then
output('(int) ')
end
output('tolua_to'..t,'(tolua_S,2,',def,'))')
else
local to_func = get_to_function(self.type)
output(to_func,'(tolua_S,2,',def,'))')
end
if prop_set then
output(")")
end
output(";")
end
output(' return 0;')
output('}')
output('#endif //#ifndef TOLUA_DISABLE\n')
output('\n')
end
end
function classVariable:register (pre)
if not self:check_public_access() then
return
end
pre = pre or ''
local parent = self:inmodule() or self:innamespace() or self:inclass()
if not parent then
if classVariable._warning==nil then
warning("Mapping variable to global may degrade performance")
classVariable._warning = 1
end
end
if self.csetname then
output(pre..'tolua_variable(tolua_S,"'..self.lname..'",'..self.cgetname..','..self.csetname..');')
else
output(pre..'tolua_variable(tolua_S,"'..self.lname..'",'..self.cgetname..',NULL);')
end
end
-- Internal constructor
function _Variable (t)
setmetatable(t,classVariable)
append(t)
return t
end
-- Constructor
-- Expects a string representing the variable declaration.
function Variable (s)
return _Variable (Declaration(s,'var'))
end

78
3rdparty/toluapp/src/bin/lua/verbatim.lua vendored Normal file
View File

@ -0,0 +1,78 @@
-- tolua: verbatim class
-- Written by Waldemar Celes
-- TeCGraf/PUC-Rio
-- Jul 1998
-- $Id: verbatim.lua,v 1.3 2000/01/24 20:41:16 celes Exp $
-- This code is free software; you can redistribute it and/or modify it.
-- The software provided hereunder is on an "as is" basis, and
-- the author has no obligation to provide maintenance, support, updates,
-- enhancements, or modifications.
-- Verbatim class
-- Represents a line translated directed to the binding file.
-- The following filds are stored:
-- line = line text
classVerbatim = {
line = '',
cond = nil, -- condition: where to generate the code (s=suport, r=register)
}
classVerbatim.__index = classVerbatim
setmetatable(classVerbatim,classFeature)
-- preamble verbatim
function classVerbatim:preamble ()
if self.cond == '' then
write(self.line)
end
end
-- support code
function classVerbatim:supcode ()
if strfind(self.cond,'s') then
write(self.line)
write('\n')
end
end
-- register code
function classVerbatim:register (pre)
if strfind(self.cond,'r') then
write(self.line)
end
end
-- Print method
function classVerbatim:print (ident,close)
print(ident.."Verbatim{")
print(ident.." line = '"..self.line.."',")
print(ident.."}"..close)
end
-- Internal constructor
function _Verbatim (t)
setmetatable(t,classVerbatim)
append(t)
return t
end
-- Constructor
-- Expects a string representing the text line
function Verbatim (l,cond)
if strsub(l,1,1) == "'" then
l = strsub(l,2)
elseif strsub(l,1,1) == '$' then
cond = 'sr' -- generates in both suport and register fragments
l = strsub(l,2)
end
return _Verbatim {
line = l,
cond = cond or '',
}
end

181
3rdparty/toluapp/src/bin/tolua.c vendored Normal file
View File

@ -0,0 +1,181 @@
/* tolua
** Support code for Lua bindings.
** Written by Waldemar Celes
** TeCGraf/PUC-Rio
** Aug 2003
** $Id:$
*/
/* This code is free software; you can redistribute it and/or modify it.
** The software provided hereunder is on an "as is" basis, and
** the author has no obligation to provide maintenance, support, updates,
** enhancements, or modifications.
*/
#include "tolua++.h"
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static void help (void)
{
fprintf(stderr,"\n"
"usage: tolua++ [options] input_file\n"
"\n"
"Command line options are:\n"
" -v : print version information.\n"
" -o file : set output file; default is stdout.\n"
" -H file : create include file.\n"
" -n name : set package name; default is input file root name.\n"
" -p : parse only.\n"
" -P : parse and print structure information (for debug).\n"
" -S : disable support for c++ strings.\n"
" -1 : substract 1 to operator[] index (for compatibility with tolua5).\n"
" -L file : run lua file (with dofile()) before doing anything.\n"
" -D : disable automatic exporting of destructors for classes that have\n"
" constructors (for compatibility with tolua5)\n"
" -W : disable warnings for unsupported features (for compatibility\n"
" with tolua5)\n"
" -C : disable cleanup of included lua code (for easier debugging)\n"
" -E value[=value] : add extra values to the luastate\n"
" -t : export a list of types asociates with the C++ typeid name\n"
" -q : don't print warnings to the console\n"
" -h : print this message.\n"
"Should the input file be omitted, stdin is assumed;\n"
"in that case, the package name must be explicitly set.\n\n"
);
}
static void version (void)
{
fprintf(stderr, "%s (written by W. Celes, A. Manzur)\n",TOLUA_VERSION);
}
static void setfield (lua_State* L, int table, char* f, char* v)
{
lua_pushstring(L,f);
lua_pushstring(L,v);
lua_settable(L,table);
}
static void add_extra (lua_State* L, char* value) {
int len;
lua_getglobal(L, "_extra_parameters");
#if LUA_VERSION_NUM > 501
len = lua_rawlen(L, -1);
#else
len = luaL_getn(L, -1);
#endif
lua_pushstring(L, value);
lua_rawseti(L, -2, len+1);
lua_pop(L, 1);
};
static void error (char* o)
{
fprintf(stderr,"tolua: unknown option '%s'\n",o);
help();
exit(1);
}
int main (int argc, char* argv[])
{
#ifdef LUA_VERSION_NUM /* lua 5.1 */
lua_State* L = luaL_newstate();
luaL_openlibs(L);
#else
lua_State* L = lua_open();
luaopen_base(L);
luaopen_io(L);
luaopen_string(L);
luaopen_table(L);
luaopen_math(L);
luaopen_debug(L);
#endif
lua_pushstring(L,TOLUA_VERSION); lua_setglobal(L,"TOLUA_VERSION");
lua_pushstring(L,LUA_VERSION); lua_setglobal(L,"TOLUA_LUA_VERSION");
if (argc==1)
{
help();
return 0;
}
else
{
int i, t;
lua_newtable(L);
lua_setglobal(L, "_extra_parameters");
lua_newtable(L);
lua_pushvalue(L,-1);
lua_setglobal(L,"flags");
t = lua_gettop(L);
// Ignore the last arg in the arg list.
for (i=1; i<argc - 1; ++i)
{
if (*argv[i] == '-')
{
switch (argv[i][1])
{
case 'v': version(); return 0;
case 'h': help(); return 0;
case 'p': setfield(L,t,"p",""); break;
case 'P': setfield(L,t,"P",""); break;
case 'o': setfield(L,t,"o",argv[++i]); break;
case 'n': setfield(L,t,"n",argv[++i]); break;
case 'H': setfield(L,t,"H",argv[++i]); break;
case 'S': setfield(L,t,"S",""); break;
case '1': setfield(L,t,"1",""); break;
case 'L': setfield(L,t,"L",argv[++i]); break;
case 'D': setfield(L,t,"D",""); break;
case 'W': setfield(L,t,"W",""); break;
case 'C': setfield(L,t,"C",""); break;
case 'E': add_extra(L,argv[++i]); break;
case 't': setfield(L,t,"t",""); break;
case 'q': setfield(L,t,"q",""); break;
default: error(argv[i]); break;
}
}
else
{
setfield(L,t,"f",argv[i]);
break;
}
}
lua_pop(L,1);
}
#define TOLUA_SCRIPT_RUN
#ifndef TOLUA_SCRIPT_RUN
{
int tolua_tolua_open (lua_State* L);
tolua_tolua_open(L);
}
#else
{
// Take the path to the Lua sources from the last arg.
char *pkg_path = argv[argc - 1];
char full_path[1024];
strcpy(full_path, pkg_path);
strcat(full_path, "all.lua");
lua_pushstring(L, pkg_path); lua_setglobal(L,"path");
if (luaL_loadfile(L, full_path) != 0) {
fprintf(stderr, "luaL_loadfile failed\n");
return 1;
}
if (lua_pcall(L, 0,0,0) != 0) {
const char *errmsg = lua_tostring(L, -1);
fprintf(stderr, "lua_pcall failed: %s\n", errmsg);
lua_pop(L, 1);
return 1;
}
}
#endif
return 0;
}

31
3rdparty/toluapp/src/bin/tolua_scons.pkg vendored Normal file
View File

@ -0,0 +1,31 @@
$lfile "src/bin/lua/compat-5.1.lua"
$lfile "src/bin/lua/compat.lua"
$lfile "src/bin/lua/basic.lua"
$lfile "src/bin/lua/feature.lua"
$lfile "src/bin/lua/verbatim.lua"
$lfile "src/bin/lua/code.lua"
$lfile "src/bin/lua/typedef.lua"
$lfile "src/bin/lua/container.lua"
$lfile "src/bin/lua/package.lua"
$lfile "src/bin/lua/module.lua"
$lfile "src/bin/lua/namespace.lua"
$lfile "src/bin/lua/define.lua"
$lfile "src/bin/lua/enumerate.lua"
$lfile "src/bin/lua/declaration.lua"
$lfile "src/bin/lua/variable.lua"
$lfile "src/bin/lua/array.lua"
$lfile "src/bin/lua/function.lua"
$lfile "src/bin/lua/operator.lua"
$lfile "src/bin/lua/template_class.lua"
$lfile "src/bin/lua/class.lua"
$lfile "src/bin/lua/clean.lua"
$lfile "src/bin/lua/doit.lua"
$[
local err,msg = pcall(doit)
if not err then
local _,_,label,msg = strfind(msg,"(.-:.-:%s*)(.*)")
tolua_error(msg,label)
print(debug.traceback())
end
$]

8072
3rdparty/toluapp/src/bin/toluabind.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

8
3rdparty/toluapp/src/bin/toluabind.h vendored Normal file
View File

@ -0,0 +1,8 @@
/*
** Lua binding: tolua
** Generated automatically by tolua++-1.0.92 on Sun Feb 15 22:29:48 2009.
*/
/* Exported function */
TOLUA_API int tolua_tolua_open (lua_State* tolua_S);

8009
3rdparty/toluapp/src/bin/toluabind_default.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

8
3rdparty/toluapp/src/bin/toluabind_default.h vendored Normal file
View File

@ -0,0 +1,8 @@
/*
** Lua binding: tolua
** Generated automatically by tolua++-1.0.8pre2 on Tue Dec 13 01:43:55 2005.
*/
/* Exported function */
TOLUA_API int tolua_tolua_open (lua_State* tolua_S);

18
3rdparty/toluapp/src/lib/SCsub vendored Normal file
View File

@ -0,0 +1,18 @@
Import('env')
sources = [
'tolua_event.c',
'tolua_is.c',
'tolua_map.c',
'tolua_push.c',
'tolua_to.c',
]
env.lib_target_static = env.Library('#/lib/'+env['tolua_lib']+'_static', sources)
if env['shared']:
env.lib_target = env.SharedLibrary('#lib/'+env['tolua_lib'], sources)
else:
env.lib_target = env.Library('#/lib/'+env['tolua_lib'], sources)

552
3rdparty/toluapp/src/lib/tolua_event.c vendored Normal file
View File

@ -0,0 +1,552 @@
/* tolua: event functions
** Support code for Lua bindings.
** Written by Waldemar Celes
** TeCGraf/PUC-Rio
** Apr 2003
** $Id: $
*/
/* This code is free software; you can redistribute it and/or modify it.
** The software provided hereunder is on an "as is" basis, and
** the author has no obligation to provide maintenance, support, updates,
** enhancements, or modifications.
*/
#include <stdio.h>
#include "tolua++.h"
/* Store at ubox
* It stores, creating the corresponding table if needed,
* the pair key/value in the corresponding ubox table
*/
static void storeatubox (lua_State* L, int lo)
{
#ifdef LUA_VERSION_NUM
#if LUA_VERSION_NUM > 501
lua_getuservalue(L, lo);
#else
lua_getfenv(L, lo);
#endif
if (lua_rawequal(L, -1, TOLUA_NOPEER)) {
lua_pop(L, 1);
lua_newtable(L);
lua_pushvalue(L, -1);
#if LUA_VERSION_NUM > 501
lua_setuservalue(L, lo); /* stack: k,v,table */
#else
lua_setfenv(L, lo); /* stack: k,v,table */
#endif
};
lua_insert(L, -3);
lua_settable(L, -3); /* on lua 5.1, we trade the "tolua_peers" lookup for a settable call */
lua_pop(L, 1);
#else
/* stack: key value (to be stored) */
lua_pushstring(L,"tolua_peers");
lua_rawget(L,LUA_REGISTRYINDEX); /* stack: k v ubox */
lua_pushvalue(L,lo);
lua_rawget(L,-2); /* stack: k v ubox ubox[u] */
if (!lua_istable(L,-1))
{
lua_pop(L,1); /* stack: k v ubox */
lua_newtable(L); /* stack: k v ubox table */
lua_pushvalue(L,1);
lua_pushvalue(L,-2); /* stack: k v ubox table u table */
lua_rawset(L,-4); /* stack: k v ubox ubox[u]=table */
}
lua_insert(L,-4); /* put table before k */
lua_pop(L,1); /* pop ubox */
lua_rawset(L,-3); /* store at table */
lua_pop(L,1); /* pop ubox[u] */
#endif
}
/* Module index function
*/
static int module_index_event (lua_State* L)
{
lua_pushstring(L,".get");
lua_rawget(L,-3);
if (lua_istable(L,-1))
{
lua_pushvalue(L,2); /* key */
lua_rawget(L,-2);
if (lua_iscfunction(L,-1))
{
lua_call(L,0,1);
return 1;
}
else if (lua_istable(L,-1))
return 1;
}
/* call old index meta event */
if (lua_getmetatable(L,1))
{
lua_pushstring(L,"__index");
lua_rawget(L,-2);
lua_pushvalue(L,1);
lua_pushvalue(L,2);
if (lua_isfunction(L,-1))
{
lua_call(L,2,1);
return 1;
}
else if (lua_istable(L,-1))
{
lua_gettable(L,-3);
return 1;
}
}
lua_pushnil(L);
return 1;
}
/* Module newindex function
*/
static int module_newindex_event (lua_State* L)
{
lua_pushstring(L,".set");
lua_rawget(L,-4);
if (lua_istable(L,-1))
{
lua_pushvalue(L,2); /* key */
lua_rawget(L,-2);
if (lua_iscfunction(L,-1))
{
lua_pushvalue(L,1); /* only to be compatible with non-static vars */
lua_pushvalue(L,3); /* value */
lua_call(L,2,0);
return 0;
}
}
/* call old newindex meta event */
if (lua_getmetatable(L,1) && lua_getmetatable(L,-1))
{
lua_pushstring(L,"__newindex");
lua_rawget(L,-2);
if (lua_isfunction(L,-1))
{
lua_pushvalue(L,1);
lua_pushvalue(L,2);
lua_pushvalue(L,3);
lua_call(L,3,0);
}
}
lua_settop(L,3);
lua_rawset(L,-3);
return 0;
}
/* Class index function
* If the object is a userdata (ie, an object), it searches the field in
* the alternative table stored in the corresponding "ubox" table.
*/
static int class_index_event (lua_State* L)
{
int t = lua_type(L,1);
if (t == LUA_TUSERDATA)
{
/* Access alternative table */
#ifdef LUA_VERSION_NUM /* new macro on version 5.1 */
#if LUA_VERSION_NUM > 501
lua_getuservalue(L, 1);
#else
lua_getfenv(L,1);
#endif
if (!lua_rawequal(L, -1, TOLUA_NOPEER)) {
lua_pushvalue(L, 2); /* key */
lua_gettable(L, -2); /* on lua 5.1, we trade the "tolua_peers" lookup for a gettable call */
if (!lua_isnil(L, -1))
return 1;
};
#else
lua_pushstring(L,"tolua_peers");
lua_rawget(L,LUA_REGISTRYINDEX); /* stack: obj key ubox */
lua_pushvalue(L,1);
lua_rawget(L,-2); /* stack: obj key ubox ubox[u] */
if (lua_istable(L,-1))
{
lua_pushvalue(L,2); /* key */
lua_rawget(L,-2); /* stack: obj key ubox ubox[u] value */
if (!lua_isnil(L,-1))
return 1;
}
#endif
lua_settop(L,2); /* stack: obj key */
/* Try metatables */
lua_pushvalue(L,1); /* stack: obj key obj */
while (lua_getmetatable(L,-1))
{ /* stack: obj key obj mt */
lua_remove(L,-2); /* stack: obj key mt */
if (lua_isnumber(L,2)) /* check if key is a numeric value */
{
/* try operator[] */
lua_pushstring(L,".geti");
lua_rawget(L,-2); /* stack: obj key mt func */
if (lua_isfunction(L,-1))
{
lua_pushvalue(L,1);
lua_pushvalue(L,2);
lua_call(L,2,1);
return 1;
}
}
else
{
lua_pushvalue(L,2); /* stack: obj key mt key */
lua_rawget(L,-2); /* stack: obj key mt value */
if (!lua_isnil(L,-1))
return 1;
else
lua_pop(L,1);
/* try C/C++ variable */
lua_pushstring(L,".get");
lua_rawget(L,-2); /* stack: obj key mt tget */
if (lua_istable(L,-1))
{
lua_pushvalue(L,2);
lua_rawget(L,-2); /* stack: obj key mt value */
if (lua_iscfunction(L,-1))
{
lua_pushvalue(L,1);
lua_pushvalue(L,2);
lua_call(L,2,1);
return 1;
}
else if (lua_istable(L,-1))
{
/* deal with array: create table to be returned and cache it in ubox */
void* u = *((void**)lua_touserdata(L,1));
lua_newtable(L); /* stack: obj key mt value table */
lua_pushstring(L,".self");
lua_pushlightuserdata(L,u);
lua_rawset(L,-3); /* store usertype in ".self" */
lua_insert(L,-2); /* stack: obj key mt table value */
lua_setmetatable(L,-2); /* set stored value as metatable */
lua_pushvalue(L,-1); /* stack: obj key met table table */
lua_pushvalue(L,2); /* stack: obj key mt table table key */
lua_insert(L,-2); /* stack: obj key mt table key table */
storeatubox(L,1); /* stack: obj key mt table */
return 1;
}
}
}
lua_settop(L,3);
}
lua_pushnil(L);
return 1;
}
else if (t== LUA_TTABLE)
{
module_index_event(L);
return 1;
}
lua_pushnil(L);
return 1;
}
/* Newindex function
* It first searches for a C/C++ varaible to be set.
* Then, it either stores it in the alternative ubox table (in the case it is
* an object) or in the own table (that represents the class or module).
*/
static int class_newindex_event (lua_State* L)
{
int t = lua_type(L,1);
if (t == LUA_TUSERDATA)
{
/* Try accessing a C/C++ variable to be set */
lua_getmetatable(L,1);
while (lua_istable(L,-1)) /* stack: t k v mt */
{
if (lua_isnumber(L,2)) /* check if key is a numeric value */
{
/* try operator[] */
lua_pushstring(L,".seti");
lua_rawget(L,-2); /* stack: obj key mt func */
if (lua_isfunction(L,-1))
{
lua_pushvalue(L,1);
lua_pushvalue(L,2);
lua_pushvalue(L,3);
lua_call(L,3,0);
return 0;
}
}
else
{
lua_pushstring(L,".set");
lua_rawget(L,-2); /* stack: t k v mt tset */
if (lua_istable(L,-1))
{
lua_pushvalue(L,2);
lua_rawget(L,-2); /* stack: t k v mt tset func */
if (lua_iscfunction(L,-1))
{
lua_pushvalue(L,1);
lua_pushvalue(L,3);
lua_call(L,2,0);
return 0;
}
lua_pop(L,1); /* stack: t k v mt tset */
}
lua_pop(L,1); /* stack: t k v mt */
if (!lua_getmetatable(L,-1)) /* stack: t k v mt mt */
lua_pushnil(L);
lua_remove(L,-2); /* stack: t k v mt */
}
}
lua_settop(L,3); /* stack: t k v */
/* then, store as a new field */
storeatubox(L,1);
}
else if (t== LUA_TTABLE)
{
module_newindex_event(L);
}
return 0;
}
static int class_call_event(lua_State* L) {
if (lua_istable(L, 1)) {
lua_pushstring(L, ".call");
lua_rawget(L, 1);
if (lua_isfunction(L, -1)) {
lua_insert(L, 1);
lua_call(L, lua_gettop(L)-1, 1);
return 1;
};
};
tolua_error(L,"Attempt to call a non-callable object.",NULL);
return 0;
};
static int do_operator (lua_State* L, const char* op)
{
if (lua_isuserdata(L,1))
{
/* Try metatables */
lua_pushvalue(L,1); /* stack: op1 op2 */
while (lua_getmetatable(L,-1))
{ /* stack: op1 op2 op1 mt */
lua_remove(L,-2); /* stack: op1 op2 mt */
lua_pushstring(L,op); /* stack: op1 op2 mt key */
lua_rawget(L,-2); /* stack: obj key mt func */
if (lua_isfunction(L,-1))
{
lua_pushvalue(L,1);
lua_pushvalue(L,2);
lua_call(L,2,1);
return 1;
}
lua_settop(L,3);
}
}
tolua_error(L,"Attempt to perform operation on an invalid operand",NULL);
return 0;
}
static int class_add_event (lua_State* L)
{
return do_operator(L,".add");
}
static int class_sub_event (lua_State* L)
{
return do_operator(L,".sub");
}
static int class_mul_event (lua_State* L)
{
return do_operator(L,".mul");
}
static int class_div_event (lua_State* L)
{
return do_operator(L,".div");
}
static int class_lt_event (lua_State* L)
{
return do_operator(L,".lt");
}
static int class_le_event (lua_State* L)
{
return do_operator(L,".le");
}
static int class_eq_event (lua_State* L)
{
/* copying code from do_operator here to return false when no operator is found */
if (lua_isuserdata(L,1))
{
/* Try metatables */
lua_pushvalue(L,1); /* stack: op1 op2 */
while (lua_getmetatable(L,-1))
{ /* stack: op1 op2 op1 mt */
lua_remove(L,-2); /* stack: op1 op2 mt */
lua_pushstring(L,".eq"); /* stack: op1 op2 mt key */
lua_rawget(L,-2); /* stack: obj key mt func */
if (lua_isfunction(L,-1))
{
lua_pushvalue(L,1);
lua_pushvalue(L,2);
lua_call(L,2,1);
return 1;
}
lua_settop(L,3);
}
}
lua_settop(L, 3);
lua_pushboolean(L, 0);
return 1;
}
/*
static int class_gc_event (lua_State* L)
{
void* u = *((void**)lua_touserdata(L,1));
fprintf(stderr, "collecting: looking at %p\n", u);
lua_pushstring(L,"tolua_gc");
lua_rawget(L,LUA_REGISTRYINDEX);
lua_pushlightuserdata(L,u);
lua_rawget(L,-2);
if (lua_isfunction(L,-1))
{
lua_pushvalue(L,1);
lua_call(L,1,0);
lua_pushlightuserdata(L,u);
lua_pushnil(L);
lua_rawset(L,-3);
}
lua_pop(L,2);
return 0;
}
*/
TOLUA_API int class_gc_event (lua_State* L)
{
if (lua_type(L,1) == LUA_TUSERDATA)
{
void* u = *((void**)lua_touserdata(L,1));
int top;
/*fprintf(stderr, "collecting: looking at %p\n", u);*/
/*
lua_pushstring(L,"tolua_gc");
lua_rawget(L,LUA_REGISTRYINDEX);
*/
lua_pushstring(L,"tolua_gc");
lua_rawget(L,LUA_REGISTRYINDEX); /* gc */
lua_pushlightuserdata(L,u);
lua_rawget(L,-2); /* stack: gc umt */
lua_getmetatable(L,1); /* stack: gc umt mt */
/*fprintf(stderr, "checking type\n");*/
top = lua_gettop(L);
if (tolua_fast_isa(L,top,top-1, lua_upvalueindex(2))) /* make sure we collect correct type */
{
/*fprintf(stderr, "Found type!\n");*/
/* get gc function */
lua_pushliteral(L,".collector");
lua_rawget(L,-2); /* stack: gc umt mt collector */
if (lua_isfunction(L,-1)) {
/*fprintf(stderr, "Found .collector!\n");*/
}
else {
lua_pop(L,1);
/*fprintf(stderr, "Using default cleanup\n");*/
lua_pushcfunction(L,tolua_default_collect);
}
lua_pushvalue(L,1); /* stack: gc umt mt collector u */
lua_call(L,1,0);
lua_pushlightuserdata(L,u); /* stack: gc umt mt u */
lua_pushnil(L); /* stack: gc umt mt u nil */
lua_rawset(L,-5); /* stack: gc umt mt */
}
lua_pop(L,3);
}
return 0;
}
/* Register module events
* It expects the metatable on the top of the stack
*/
TOLUA_API void tolua_moduleevents (lua_State* L)
{
lua_pushstring(L,"__index");
lua_pushcfunction(L,module_index_event);
lua_rawset(L,-3);
lua_pushstring(L,"__newindex");
lua_pushcfunction(L,module_newindex_event);
lua_rawset(L,-3);
}
/* Check if the object on the top has a module metatable
*/
TOLUA_API int tolua_ismodulemetatable (lua_State* L)
{
int r = 0;
if (lua_getmetatable(L,-1))
{
lua_pushstring(L,"__index");
lua_rawget(L,-2);
r = (lua_tocfunction(L,-1) == module_index_event);
lua_pop(L,2);
}
return r;
}
/* Register class events
* It expects the metatable on the top of the stack
*/
TOLUA_API void tolua_classevents (lua_State* L)
{
lua_pushstring(L,"__index");
lua_pushcfunction(L,class_index_event);
lua_rawset(L,-3);
lua_pushstring(L,"__newindex");
lua_pushcfunction(L,class_newindex_event);
lua_rawset(L,-3);
lua_pushstring(L,"__add");
lua_pushcfunction(L,class_add_event);
lua_rawset(L,-3);
lua_pushstring(L,"__sub");
lua_pushcfunction(L,class_sub_event);
lua_rawset(L,-3);
lua_pushstring(L,"__mul");
lua_pushcfunction(L,class_mul_event);
lua_rawset(L,-3);
lua_pushstring(L,"__div");
lua_pushcfunction(L,class_div_event);
lua_rawset(L,-3);
lua_pushstring(L,"__lt");
lua_pushcfunction(L,class_lt_event);
lua_rawset(L,-3);
lua_pushstring(L,"__le");
lua_pushcfunction(L,class_le_event);
lua_rawset(L,-3);
lua_pushstring(L,"__eq");
lua_pushcfunction(L,class_eq_event);
lua_rawset(L,-3);
lua_pushstring(L,"__call");
lua_pushcfunction(L,class_call_event);
lua_rawset(L,-3);
lua_pushstring(L,"__gc");
lua_pushstring(L, "tolua_gc_event");
lua_rawget(L, LUA_REGISTRYINDEX);
/*lua_pushcfunction(L,class_gc_event);*/
lua_rawset(L,-3);
}

24
3rdparty/toluapp/src/lib/tolua_event.h vendored Normal file
View File

@ -0,0 +1,24 @@
/* tolua: event functions
** Support code for Lua bindings.
** Written by Waldemar Celes
** TeCGraf/PUC-Rio
** Apr 2003
** $Id: $
*/
/* This code is free software; you can redistribute it and/or modify it.
** The software provided hereunder is on an "as is" basis, and
** the author has no obligation to provide maintenance, support, updates,
** enhancements, or modifications.
*/
#ifndef TOLUA_EVENT_H
#define TOLUA_EVENT_H
#include "tolua++.h"
TOLUA_API void tolua_moduleevents (lua_State* L);
TOLUA_API int tolua_ismodulemetatable (lua_State* L);
TOLUA_API void tolua_classevents (lua_State* L);
#endif

621
3rdparty/toluapp/src/lib/tolua_is.c vendored Normal file
View File

@ -0,0 +1,621 @@
/* tolua: functions to check types.
** Support code for Lua bindings.
** Written by Waldemar Celes
** TeCGraf/PUC-Rio
** Apr 2003
** $Id: $
*/
/* This code is free software; you can redistribute it and/or modify it.
** The software provided hereunder is on an "as is" basis, and
** the author has no obligation to provide maintenance, support, updates,
** enhancements, or modifications.
*/
#include "tolua++.h"
#include "lauxlib.h"
#include <stdlib.h>
#include <string.h>
/* a fast check if a is b, without parameter validation
i.e. if b is equal to a or a superclass of a. */
TOLUA_API int tolua_fast_isa(lua_State *L, int mt_indexa, int mt_indexb, int super_index)
{
int result;
if (lua_rawequal(L,mt_indexa,mt_indexb))
result = 1;
else
{
if (super_index) {
lua_pushvalue(L, super_index);
} else {
lua_pushliteral(L,"tolua_super");
lua_rawget(L,LUA_REGISTRYINDEX); /* stack: super */
};
lua_pushvalue(L,mt_indexa); /* stack: super mta */
lua_rawget(L,-2); /* stack: super super[mta] */
lua_pushvalue(L,mt_indexb); /* stack: super super[mta] mtb */
lua_rawget(L,LUA_REGISTRYINDEX); /* stack: super super[mta] typenameB */
lua_rawget(L,-2); /* stack: super super[mta] bool */
result = lua_toboolean(L,-1);
lua_pop(L,3);
}
return result;
}
/* Push and returns the corresponding object typename */
TOLUA_API const char* tolua_typename (lua_State* L, int lo)
{
int tag = lua_type(L,lo);
if (tag == LUA_TNONE)
lua_pushstring(L,"[no object]");
else if (tag != LUA_TUSERDATA && tag != LUA_TTABLE)
lua_pushstring(L,lua_typename(L,tag));
else if (tag == LUA_TUSERDATA)
{
if (!lua_getmetatable(L,lo))
lua_pushstring(L,lua_typename(L,tag));
else
{
lua_rawget(L,LUA_REGISTRYINDEX);
if (!lua_isstring(L,-1))
{
lua_pop(L,1);
lua_pushstring(L,"[undefined]");
}
}
}
else /* is table */
{
lua_pushvalue(L,lo);
lua_rawget(L,LUA_REGISTRYINDEX);
if (!lua_isstring(L,-1))
{
lua_pop(L,1);
lua_pushstring(L,"table");
}
else
{
lua_pushstring(L,"class ");
lua_insert(L,-2);
lua_concat(L,2);
}
}
return lua_tostring(L,-1);
}
TOLUA_API void tolua_error (lua_State* L, const char* msg, tolua_Error* err)
{
if (msg[0] == '#')
{
const char* expected = err->type;
const char* provided = tolua_typename(L,err->index);
if (msg[1]=='f')
{
int narg = err->index;
if (err->array)
luaL_error(L,"%s\n argument #%d is array of '%s'; array of '%s' expected.\n",
msg+2,narg,provided,expected);
else
luaL_error(L,"%s\n argument #%d is '%s'; '%s' expected.\n",
msg+2,narg,provided,expected);
}
else if (msg[1]=='v')
{
if (err->array)
luaL_error(L,"%s\n value is array of '%s'; array of '%s' expected.\n",
msg+2,provided,expected);
else
luaL_error(L,"%s\n value is '%s'; '%s' expected.\n",
msg+2,provided,expected);
}
}
else
luaL_error(L,msg);
}
/* the equivalent of lua_is* for usertable */
static int lua_isusertable (lua_State* L, int lo, const const char* type)
{
int r = 0;
if (lo < 0) lo = lua_gettop(L)+lo+1;
lua_pushvalue(L,lo);
lua_rawget(L,LUA_REGISTRYINDEX); /* get registry[t] */
if (lua_isstring(L,-1))
{
r = strcmp(lua_tostring(L,-1),type)==0;
if (!r)
{
/* try const */
lua_pushstring(L,"const ");
lua_insert(L,-2);
lua_concat(L,2);
r = lua_isstring(L,-1) && strcmp(lua_tostring(L,-1),type)==0;
}
}
lua_pop(L, 1);
return r;
}
int push_table_instance(lua_State* L, int lo) {
if (lua_istable(L, lo)) {
lua_pushstring(L, ".c_instance");
lua_gettable(L, lo);
if (lua_isuserdata(L, -1)) {
lua_replace(L, lo);
return 1;
} else {
lua_pop(L, 1);
return 0;
};
} else {
return 0;
};
return 0;
};
/* the equivalent of lua_is* for usertype */
static int lua_isusertype (lua_State* L, int lo, const char* type)
{
if (!lua_isuserdata(L,lo)) {
if (!push_table_instance(L, lo)) {
return 0;
};
};
{
/* check if it is of the same type */
int r;
const char *tn;
if (lua_getmetatable(L,lo)) /* if metatable? */
{
lua_rawget(L,LUA_REGISTRYINDEX); /* get registry[mt] */
tn = lua_tostring(L,-1);
r = tn && (strcmp(tn,type) == 0);
lua_pop(L, 1);
if (r)
return 1;
else
{
/* check if it is a specialized class */
lua_pushstring(L,"tolua_super");
lua_rawget(L,LUA_REGISTRYINDEX); /* get super */
lua_getmetatable(L,lo);
lua_rawget(L,-2); /* get super[mt] */
if (lua_istable(L,-1))
{
int b;
lua_pushstring(L,type);
lua_rawget(L,-2); /* get super[mt][type] */
b = lua_toboolean(L,-1);
lua_pop(L,3);
if (b)
return 1;
}
}
}
}
return 0;
}
TOLUA_API int tolua_isnoobj (lua_State* L, int lo, tolua_Error* err)
{
if (lua_gettop(L)<abs(lo))
return 1;
err->index = lo;
err->array = 0;
err->type = "[no object]";
return 0;
}
TOLUA_API int tolua_isboolean (lua_State* L, int lo, int def, tolua_Error* err)
{
if (def && lua_gettop(L)<abs(lo))
return 1;
if (lua_isnil(L,lo) || lua_isboolean(L,lo))
return 1;
err->index = lo;
err->array = 0;
err->type = "boolean";
return 0;
}
TOLUA_API int tolua_isnumber (lua_State* L, int lo, int def, tolua_Error* err)
{
if (def && lua_gettop(L)<abs(lo))
return 1;
if (lua_isnumber(L,lo))
return 1;
err->index = lo;
err->array = 0;
err->type = "number";
return 0;
}
TOLUA_API int tolua_isstring (lua_State* L, int lo, int def, tolua_Error* err)
{
if (def && lua_gettop(L)<abs(lo))
return 1;
if (lua_isnil(L,lo) || lua_isstring(L,lo))
return 1;
err->index = lo;
err->array = 0;
err->type = "string";
return 0;
}
TOLUA_API int tolua_istable (lua_State* L, int lo, int def, tolua_Error* err)
{
if (def && lua_gettop(L)<abs(lo))
return 1;
if (lua_istable(L,lo))
return 1;
err->index = lo;
err->array = 0;
err->type = "table";
return 0;
}
TOLUA_API int tolua_isusertable (lua_State* L, int lo, const char* type, int def, tolua_Error* err)
{
if (def && lua_gettop(L)<abs(lo))
return 1;
if (lua_isusertable(L,lo,type))
return 1;
err->index = lo;
err->array = 0;
err->type = type;
return 0;
}
TOLUA_API int tolua_isuserdata (lua_State* L, int lo, int def, tolua_Error* err)
{
if (def && lua_gettop(L)<abs(lo))
return 1;
if (lua_isnil(L,lo) || lua_isuserdata(L,lo))
return 1;
err->index = lo;
err->array = 0;
err->type = "userdata";
return 0;
}
TOLUA_API int tolua_isvaluenil (lua_State* L, int lo, tolua_Error* err) {
if (lua_gettop(L)<abs(lo))
return 0; /* somebody else should chack this */
if (!lua_isnil(L, lo))
return 0;
err->index = lo;
err->array = 0;
err->type = "value";
return 1;
};
TOLUA_API int tolua_isvalue (lua_State* L, int lo, int def, tolua_Error* err)
{
if (def || abs(lo)<=lua_gettop(L)) /* any valid index */
return 1;
err->index = lo;
err->array = 0;
err->type = "value";
return 0;
}
TOLUA_API int tolua_isusertype (lua_State* L, int lo, const char* type, int def, tolua_Error* err)
{
if (def && lua_gettop(L)<abs(lo))
return 1;
if (lua_isnil(L,lo) || lua_isusertype(L,lo,type))
return 1;
err->index = lo;
err->array = 0;
err->type = type;
return 0;
}
TOLUA_API int tolua_isvaluearray
(lua_State* L, int lo, int dim, int def, tolua_Error* err)
{
if (!tolua_istable(L,lo,def,err))
return 0;
else
return 1;
}
TOLUA_API int tolua_isbooleanarray
(lua_State* L, int lo, int dim, int def, tolua_Error* err)
{
if (!tolua_istable(L,lo,def,err))
return 0;
else
{
int i;
for (i=1; i<=dim; ++i)
{
lua_pushnumber(L,i);
lua_gettable(L,lo);
if (!(lua_isnil(L,-1) || lua_isboolean(L,-1)) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->array = 1;
err->type = "boolean";
return 0;
}
lua_pop(L,1);
}
}
return 1;
}
TOLUA_API int tolua_isnumberarray
(lua_State* L, int lo, int dim, int def, tolua_Error* err)
{
if (!tolua_istable(L,lo,def,err))
return 0;
else
{
int i;
for (i=1; i<=dim; ++i)
{
lua_pushnumber(L,i);
lua_gettable(L,lo);
if (!lua_isnumber(L,-1) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->array = 1;
err->type = "number";
return 0;
}
lua_pop(L,1);
}
}
return 1;
}
TOLUA_API int tolua_isstringarray
(lua_State* L, int lo, int dim, int def, tolua_Error* err)
{
if (!tolua_istable(L,lo,def,err))
return 0;
else
{
int i;
for (i=1; i<=dim; ++i)
{
lua_pushnumber(L,i);
lua_gettable(L,lo);
if (!(lua_isnil(L,-1) || lua_isstring(L,-1)) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->array = 1;
err->type = "string";
return 0;
}
lua_pop(L,1);
}
}
return 1;
}
TOLUA_API int tolua_istablearray
(lua_State* L, int lo, int dim, int def, tolua_Error* err)
{
if (!tolua_istable(L,lo,def,err))
return 0;
else
{
int i;
for (i=1; i<=dim; ++i)
{
lua_pushnumber(L,i);
lua_gettable(L,lo);
if (! lua_istable(L,-1) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->array = 1;
err->type = "table";
return 0;
}
lua_pop(L,1);
}
}
return 1;
}
TOLUA_API int tolua_isuserdataarray
(lua_State* L, int lo, int dim, int def, tolua_Error* err)
{
if (!tolua_istable(L,lo,def,err))
return 0;
else
{
int i;
for (i=1; i<=dim; ++i)
{
lua_pushnumber(L,i);
lua_gettable(L,lo);
if (!(lua_isnil(L,-1) || lua_isuserdata(L,-1)) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->array = 1;
err->type = "userdata";
return 0;
}
lua_pop(L,1);
}
}
return 1;
}
TOLUA_API int tolua_isusertypearray
(lua_State* L, int lo, const char* type, int dim, int def, tolua_Error* err)
{
if (!tolua_istable(L,lo,def,err))
return 0;
else
{
int i;
for (i=1; i<=dim; ++i)
{
lua_pushnumber(L,i);
lua_gettable(L,lo);
if (!(lua_isnil(L,-1) || lua_isuserdata(L,-1)) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->type = type;
err->array = 1;
return 0;
}
lua_pop(L,1);
}
}
return 1;
}
#if 0
int tolua_isbooleanfield
(lua_State* L, int lo, int i, int def, tolua_Error* err)
{
lua_pushnumber(L,i);
lua_gettable(L,lo);
if (!(lua_isnil(L,-1) || lua_isboolean(L,-1)) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->array = 1;
err->type = "boolean";
return 0;
}
lua_pop(L,1);
return 1;
}
int tolua_isnumberfield
(lua_State* L, int lo, int i, int def, tolua_Error* err)
{
lua_pushnumber(L,i);
lua_gettable(L,lo);
if (!lua_isnumber(L,-1) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->array = 1;
err->type = "number";
return 0;
}
lua_pop(L,1);
return 1;
}
int tolua_isstringfield
(lua_State* L, int lo, int i, int def, tolua_Error* err)
{
lua_pushnumber(L,i);
lua_gettable(L,lo);
if (!(lua_isnil(L,-1) || lua_isstring(L,-1)) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->array = 1;
err->type = "string";
return 0;
}
lua_pop(L,1);
return 1;
}
int tolua_istablefield
(lua_State* L, int lo, int i, int def, tolua_Error* err)
{
lua_pushnumber(L,i+1);
lua_gettable(L,lo);
if (! lua_istable(L,-1) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->array = 1;
err->type = "table";
return 0;
}
lua_pop(L,1);
}
int tolua_isusertablefield
(lua_State* L, int lo, const char* type, int i, int def, tolua_Error* err)
{
lua_pushnumber(L,i);
lua_gettable(L,lo);
if (! lua_isusertable(L,-1,type) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->array = 1;
err->type = type;
return 0;
}
lua_pop(L,1);
return 1;
}
int tolua_isuserdatafield
(lua_State* L, int lo, int i, int def, tolua_Error* err)
{
lua_pushnumber(L,i);
lua_gettable(L,lo);
if (!(lua_isnil(L,-1) || lua_isuserdata(L,-1)) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->array = 1;
err->type = "userdata";
return 0;
}
lua_pop(L,1);
return 1;
}
int tolua_isusertypefield
(lua_State* L, int lo, const char* type, int i, int def, tolua_Error* err)
{
lua_pushnumber(L,i);
lua_gettable(L,lo);
if (!(lua_isnil(L,-1) || lua_isusertype(L,-1,type)) &&
!(def && lua_isnil(L,-1))
)
{
err->index = lo;
err->type = type;
err->array = 1;
return 0;
}
lua_pop(L,1);
return 1;
}
#endif

724
3rdparty/toluapp/src/lib/tolua_map.c vendored Normal file
View File

@ -0,0 +1,724 @@
/* tolua: functions to map features
** Support code for Lua bindings.
** Written by Waldemar Celes
** TeCGraf/PUC-Rio
** Apr 2003
** $Id: $
*/
/* This code is free software; you can redistribute it and/or modify it.
** The software provided hereunder is on an "as is" basis, and
** the author has no obligation to provide maintenance, support, updates,
** enhancements, or modifications.
*/
#include "tolua++.h"
#include "tolua_event.h"
#include "lauxlib.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
/* Create metatable
* Create and register new metatable
*/
static int tolua_newmetatable (lua_State* L, char* name)
{
int r = luaL_newmetatable(L,name);
#ifdef LUA_VERSION_NUM /* only lua 5.1 */
if (r) {
lua_pushvalue(L, -1);
lua_pushstring(L, name);
lua_settable(L, LUA_REGISTRYINDEX); /* reg[mt] = type_name */
};
#endif
if (r)
tolua_classevents(L); /* set meta events */
lua_pop(L,1);
return r;
}
/* Map super classes
* It sets 'name' as being also a 'base', mapping all super classes of 'base' in 'name'
*/
static void mapsuper (lua_State* L, const char* name, const char* base)
{
/* push registry.super */
lua_pushstring(L,"tolua_super");
lua_rawget(L,LUA_REGISTRYINDEX); /* stack: super */
luaL_getmetatable(L,name); /* stack: super mt */
lua_rawget(L,-2); /* stack: super table */
if (lua_isnil(L,-1))
{
/* create table */
lua_pop(L,1);
lua_newtable(L); /* stack: super table */
luaL_getmetatable(L,name); /* stack: super table mt */
lua_pushvalue(L,-2); /* stack: super table mt table */
lua_rawset(L,-4); /* stack: super table */
}
/* set base as super class */
lua_pushstring(L,base);
lua_pushboolean(L,1);
lua_rawset(L,-3); /* stack: super table */
/* set all super class of base as super class of name */
luaL_getmetatable(L,base); /* stack: super table base_mt */
lua_rawget(L,-3); /* stack: super table base_table */
if (lua_istable(L,-1))
{
/* traverse base table */
lua_pushnil(L); /* first key */
while (lua_next(L,-2) != 0)
{
/* stack: ... base_table key value */
lua_pushvalue(L,-2); /* stack: ... base_table key value key */
lua_insert(L,-2); /* stack: ... base_table key key value */
lua_rawset(L,-5); /* stack: ... base_table key */
}
}
lua_pop(L,3); /* stack: <empty> */
}
/* creates a 'tolua_ubox' table for base clases, and
// expects the metatable and base metatable on the stack */
static void set_ubox(lua_State* L) {
/* mt basemt */
if (!lua_isnil(L, -1)) {
lua_pushstring(L, "tolua_ubox");
lua_rawget(L,-2);
} else {
lua_pushnil(L);
};
/* mt basemt base_ubox */
if (!lua_isnil(L,-1)) {
lua_pushstring(L, "tolua_ubox");
lua_insert(L, -2);
/* mt basemt key ubox */
lua_rawset(L,-4);
/* (mt with ubox) basemt */
} else {
/* mt basemt nil */
lua_pop(L, 1);
lua_pushstring(L,"tolua_ubox"); lua_newtable(L);
/* make weak value metatable for ubox table to allow userdata to be
garbage-collected */
lua_newtable(L); lua_pushliteral(L, "__mode"); lua_pushliteral(L, "v"); lua_rawset(L, -3); /* stack: string ubox mt */
lua_setmetatable(L, -2); /* stack:mt basemt string ubox */
lua_rawset(L,-4);
};
};
/* Map inheritance
* It sets 'name' as derived from 'base' by setting 'base' as metatable of 'name'
*/
static void mapinheritance (lua_State* L, const char* name, const char* base)
{
/* set metatable inheritance */
luaL_getmetatable(L,name);
if (base && *base)
luaL_getmetatable(L,base);
else {
if (lua_getmetatable(L, -1)) { /* already has a mt, we don't overwrite it */
lua_pop(L, 2);
return;
};
luaL_getmetatable(L,"tolua_commonclass");
};
set_ubox(L);
lua_setmetatable(L,-2);
lua_pop(L,1);
}
/* Object type
*/
static int tolua_bnd_type (lua_State* L)
{
tolua_typename(L,lua_gettop(L));
return 1;
}
/* Take ownership
*/
static int tolua_bnd_takeownership (lua_State* L)
{
int success = 0;
if (lua_isuserdata(L,1))
{
if (lua_getmetatable(L,1)) /* if metatable? */
{
lua_pop(L,1); /* clear metatable off stack */
/* force garbage collection to avoid C to reuse a to-be-collected address */
#ifdef LUA_VERSION_NUM
lua_gc(L, LUA_GCCOLLECT, 0);
#else
lua_setgcthreshold(L,0);
#endif
success = tolua_register_gc(L,1);
}
}
lua_pushboolean(L,success!=0);
return 1;
}
/* Release ownership
*/
static int tolua_bnd_releaseownership (lua_State* L)
{
int done = 0;
if (lua_isuserdata(L,1))
{
void* u = *((void**)lua_touserdata(L,1));
/* force garbage collection to avoid releasing a to-be-collected address */
#ifdef LUA_VERSION_NUM
lua_gc(L, LUA_GCCOLLECT, 0);
#else
lua_setgcthreshold(L,0);
#endif
lua_pushstring(L,"tolua_gc");
lua_rawget(L,LUA_REGISTRYINDEX);
lua_pushlightuserdata(L,u);
lua_rawget(L,-2);
lua_getmetatable(L,1);
if (lua_rawequal(L,-1,-2)) /* check that we are releasing the correct type */
{
lua_pushlightuserdata(L,u);
lua_pushnil(L);
lua_rawset(L,-5);
done = 1;
}
}
lua_pushboolean(L,done!=0);
return 1;
}
/* Type casting
*/
static int tolua_bnd_cast (lua_State* L)
{
/* // old code
void* v = tolua_tousertype(L,1,NULL);
const char* s = tolua_tostring(L,2,NULL);
if (v && s)
tolua_pushusertype(L,v,s);
else
lua_pushnil(L);
return 1;
*/
void* v;
const char* s;
if (lua_islightuserdata(L, 1)) {
v = tolua_touserdata(L, 1, NULL);
} else {
v = tolua_tousertype(L, 1, 0);
};
s = tolua_tostring(L,2,NULL);
if (v && s)
tolua_pushusertype(L,v,s);
else
lua_pushnil(L);
return 1;
}
/* Inheritance
*/
static int tolua_bnd_inherit (lua_State* L) {
/* stack: lua object, c object */
lua_pushstring(L, ".c_instance");
lua_pushvalue(L, -2);
lua_rawset(L, -4);
/* l_obj[".c_instance"] = c_obj */
return 0;
};
#ifdef LUA_VERSION_NUM /* lua 5.1 */
static int tolua_bnd_setpeer(lua_State* L) {
/* stack: userdata, table */
if (!lua_isuserdata(L, -2)) {
lua_pushstring(L, "Invalid argument #1 to setpeer: userdata expected.");
lua_error(L);
};
if (lua_isnil(L, -1)) {
lua_pop(L, 1);
lua_pushvalue(L, TOLUA_NOPEER);
}
#if LUA_VERSION_NUM > 501
lua_setuservalue(L, -2);
#else
lua_setfenv(L, -2);
#endif
return 0;
};
static int tolua_bnd_getpeer(lua_State* L) {
/* stack: userdata */
#if LUA_VERSION_NUM > 501
lua_getuservalue(L, -1);
#else
lua_getfenv(L, -1);
#endif
if (lua_rawequal(L, -1, TOLUA_NOPEER)) {
lua_pop(L, 1);
lua_pushnil(L);
};
return 1;
};
#endif
/* static int class_gc_event (lua_State* L); */
TOLUA_API void tolua_open (lua_State* L)
{
int top = lua_gettop(L);
lua_pushstring(L,"tolua_opened");
lua_rawget(L,LUA_REGISTRYINDEX);
if (!lua_isboolean(L,-1))
{
lua_pushstring(L,"tolua_opened"); lua_pushboolean(L,1); lua_rawset(L,LUA_REGISTRYINDEX);
#ifndef LUA_VERSION_NUM /* only prior to lua 5.1 */
/* create peer object table */
lua_pushstring(L, "tolua_peers"); lua_newtable(L);
/* make weak key metatable for peers indexed by userdata object */
lua_newtable(L); lua_pushliteral(L, "__mode"); lua_pushliteral(L, "k"); lua_rawset(L, -3); /* stack: string peers mt */
lua_setmetatable(L, -2); /* stack: string peers */
lua_rawset(L,LUA_REGISTRYINDEX);
#endif
/* create object ptr -> udata mapping table */
lua_pushstring(L,"tolua_ubox"); lua_newtable(L);
/* make weak value metatable for ubox table to allow userdata to be
garbage-collected */
lua_newtable(L); lua_pushliteral(L, "__mode"); lua_pushliteral(L, "v"); lua_rawset(L, -3); /* stack: string ubox mt */
lua_setmetatable(L, -2); /* stack: string ubox */
lua_rawset(L,LUA_REGISTRYINDEX);
lua_pushstring(L,"tolua_super"); lua_newtable(L); lua_rawset(L,LUA_REGISTRYINDEX);
lua_pushstring(L,"tolua_gc"); lua_newtable(L);lua_rawset(L,LUA_REGISTRYINDEX);
/* create gc_event closure */
lua_pushstring(L, "tolua_gc_event");
lua_pushstring(L, "tolua_gc");
lua_rawget(L, LUA_REGISTRYINDEX);
lua_pushstring(L, "tolua_super");
lua_rawget(L, LUA_REGISTRYINDEX);
lua_pushcclosure(L, class_gc_event, 2);
lua_rawset(L, LUA_REGISTRYINDEX);
tolua_newmetatable(L,"tolua_commonclass");
tolua_module(L,NULL,0);
tolua_beginmodule(L,NULL);
tolua_module(L,"tolua",0);
tolua_beginmodule(L,"tolua");
tolua_function(L,"type",tolua_bnd_type);
tolua_function(L,"takeownership",tolua_bnd_takeownership);
tolua_function(L,"releaseownership",tolua_bnd_releaseownership);
tolua_function(L,"cast",tolua_bnd_cast);
tolua_function(L,"inherit", tolua_bnd_inherit);
#ifdef LUA_VERSION_NUM /* lua 5.1 */
tolua_function(L, "setpeer", tolua_bnd_setpeer);
tolua_function(L, "getpeer", tolua_bnd_getpeer);
#endif
tolua_endmodule(L);
tolua_endmodule(L);
}
lua_settop(L,top);
}
/* Copy a C object
*/
TOLUA_API void* tolua_copy (lua_State* L, void* value, unsigned int size)
{
void* clone = (void*)malloc(size);
if (clone)
memcpy(clone,value,size);
else
tolua_error(L,"insuficient memory",NULL);
return clone;
}
/* Default collect function
*/
TOLUA_API int tolua_default_collect (lua_State* tolua_S)
{
void* self = tolua_tousertype(tolua_S,1,0);
free(self);
return 0;
}
/* Do clone
*/
TOLUA_API int tolua_register_gc (lua_State* L, int lo)
{
int success = 1;
void *value = *(void **)lua_touserdata(L,lo);
lua_pushstring(L,"tolua_gc");
lua_rawget(L,LUA_REGISTRYINDEX);
lua_pushlightuserdata(L,value);
lua_rawget(L,-2);
if (!lua_isnil(L,-1)) /* make sure that object is not already owned */
success = 0;
else
{
lua_pushlightuserdata(L,value);
lua_getmetatable(L,lo);
lua_rawset(L,-4);
}
lua_pop(L,2);
return success;
}
/* Register a usertype
* It creates the correspoding metatable in the registry, for both 'type' and 'const type'.
* It maps 'const type' as being also a 'type'
*/
TOLUA_API void tolua_usertype (lua_State* L, const char* type)
{
char ctype[128] = "const ";
strncat(ctype,type,120);
/* create both metatables */
if (tolua_newmetatable(L,ctype) && tolua_newmetatable(L,type))
mapsuper(L,type,ctype); /* 'type' is also a 'const type' */
}
/* Begin module
* It pushes the module (or class) table on the stack
*/
TOLUA_API void tolua_beginmodule (lua_State* L, const char* name)
{
if (name)
{
lua_pushstring(L,name);
lua_rawget(L,-2);
}
else
#if LUA_VERSION_NUM > 501
lua_pushglobaltable(L);
#else
lua_pushvalue(L,LUA_GLOBALSINDEX);
#endif
}
/* End module
* It pops the module (or class) from the stack
*/
TOLUA_API void tolua_endmodule (lua_State* L)
{
lua_pop(L,1);
}
/* Map module
* It creates a new module
*/
#if 1
TOLUA_API void tolua_module (lua_State* L, const char* name, int hasvar)
{
if (name)
{
/* tolua module */
lua_pushstring(L,name);
lua_rawget(L,-2);
if (!lua_istable(L,-1)) /* check if module already exists */
{
lua_pop(L,1);
lua_newtable(L);
lua_pushstring(L,name);
lua_pushvalue(L,-2);
lua_rawset(L,-4); /* assing module into module */
}
}
else
{
/* global table */
#if LUA_VERSION_NUM > 501
lua_pushglobaltable(L);
#else
lua_pushvalue(L,LUA_GLOBALSINDEX);
#endif
}
if (hasvar)
{
if (!tolua_ismodulemetatable(L)) /* check if it already has a module metatable */
{
/* create metatable to get/set C/C++ variable */
lua_newtable(L);
tolua_moduleevents(L);
if (lua_getmetatable(L,-2))
lua_setmetatable(L,-2); /* set old metatable as metatable of metatable */
lua_setmetatable(L,-2);
}
}
lua_pop(L,1); /* pop module */
}
#else
TOLUA_API void tolua_module (lua_State* L, const char* name, int hasvar)
{
if (name)
{
/* tolua module */
lua_pushstring(L,name);
lua_newtable(L);
}
else
{
/* global table */
#if LUA_VERSION_NUM > 501
lua_pushglobaltable(L);
#else
lua_pushvalue(L,LUA_GLOBALSINDEX);
#endif
}
if (hasvar)
{
/* create metatable to get/set C/C++ variable */
lua_newtable(L);
tolua_moduleevents(L);
if (lua_getmetatable(L,-2))
lua_setmetatable(L,-2); /* set old metatable as metatable of metatable */
lua_setmetatable(L,-2);
}
if (name)
lua_rawset(L,-3); /* assing module into module */
else
lua_pop(L,1); /* pop global table */
}
#endif
static void push_collector(lua_State* L, const char* type, lua_CFunction col) {
/* push collector function, but only if it's not NULL, or if there's no
collector already */
if (!col) return;
luaL_getmetatable(L,type);
lua_pushstring(L,".collector");
/*
if (!col) {
lua_pushvalue(L, -1);
lua_rawget(L, -3);
if (!lua_isnil(L, -1)) {
lua_pop(L, 3);
return;
};
lua_pop(L, 1);
};
// */
lua_pushcfunction(L,col);
lua_rawset(L,-3);
lua_pop(L, 1);
};
/* Map C class
* It maps a C class, setting the appropriate inheritance and super classes.
*/
TOLUA_API void tolua_cclass (lua_State* L, const char* lname, const char* name, const char* base, lua_CFunction col)
{
char cname[128] = "const ";
char cbase[128] = "const ";
strncat(cname,name,120);
strncat(cbase,base,120);
mapinheritance(L,name,base);
mapinheritance(L,cname,name);
mapsuper(L,cname,cbase);
mapsuper(L,name,base);
lua_pushstring(L,lname);
push_collector(L, name, col);
/*
luaL_getmetatable(L,name);
lua_pushstring(L,".collector");
lua_pushcfunction(L,col);
lua_rawset(L,-3);
*/
luaL_getmetatable(L,name);
lua_rawset(L,-3); /* assign class metatable to module */
/* now we also need to store the collector table for the const
instances of the class */
push_collector(L, cname, col);
/*
luaL_getmetatable(L,cname);
lua_pushstring(L,".collector");
lua_pushcfunction(L,col);
lua_rawset(L,-3);
lua_pop(L,1);
*/
}
/* Add base
* It adds additional base classes to a class (for multiple inheritance)
* (not for now)
TOLUA_API void tolua_addbase(lua_State* L, char* name, char* base) {
char cname[128] = "const ";
char cbase[128] = "const ";
strncat(cname,name,120);
strncat(cbase,base,120);
mapsuper(L,cname,cbase);
mapsuper(L,name,base);
};
*/
/* Map function
* It assigns a function into the current module (or class)
*/
TOLUA_API void tolua_function (lua_State* L, const char* name, lua_CFunction func)
{
lua_pushstring(L,name);
lua_pushcfunction(L,func);
lua_rawset(L,-3);
}
/* sets the __call event for the class (expects the class' main table on top) */
/* never really worked :(
TOLUA_API void tolua_set_call_event(lua_State* L, lua_CFunction func, char* type) {
lua_getmetatable(L, -1);
//luaL_getmetatable(L, type);
lua_pushstring(L,"__call");
lua_pushcfunction(L,func);
lua_rawset(L,-3);
lua_pop(L, 1);
};
*/
/* Map constant number
* It assigns a constant number into the current module (or class)
*/
TOLUA_API void tolua_constant (lua_State* L, const char* name, lua_Number value)
{
lua_pushstring(L,name);
tolua_pushnumber(L,value);
lua_rawset(L,-3);
}
/* Map variable
* It assigns a variable into the current module (or class)
*/
TOLUA_API void tolua_variable (lua_State* L, const char* name, lua_CFunction get, lua_CFunction set)
{
/* get func */
lua_pushstring(L,".get");
lua_rawget(L,-2);
if (!lua_istable(L,-1))
{
/* create .get table, leaving it at the top */
lua_pop(L,1);
lua_newtable(L);
lua_pushstring(L,".get");
lua_pushvalue(L,-2);
lua_rawset(L,-4);
}
lua_pushstring(L,name);
lua_pushcfunction(L,get);
lua_rawset(L,-3); /* store variable */
lua_pop(L,1); /* pop .get table */
/* set func */
if (set)
{
lua_pushstring(L,".set");
lua_rawget(L,-2);
if (!lua_istable(L,-1))
{
/* create .set table, leaving it at the top */
lua_pop(L,1);
lua_newtable(L);
lua_pushstring(L,".set");
lua_pushvalue(L,-2);
lua_rawset(L,-4);
}
lua_pushstring(L,name);
lua_pushcfunction(L,set);
lua_rawset(L,-3); /* store variable */
lua_pop(L,1); /* pop .set table */
}
}
/* Access const array
* It reports an error when trying to write into a const array
*/
static int const_array (lua_State* L)
{
luaL_error(L,"value of const array cannot be changed");
return 0;
}
/* Map an array
* It assigns an array into the current module (or class)
*/
TOLUA_API void tolua_array (lua_State* L, const char* name, lua_CFunction get, lua_CFunction set)
{
lua_pushstring(L,".get");
lua_rawget(L,-2);
if (!lua_istable(L,-1))
{
/* create .get table, leaving it at the top */
lua_pop(L,1);
lua_newtable(L);
lua_pushstring(L,".get");
lua_pushvalue(L,-2);
lua_rawset(L,-4);
}
lua_pushstring(L,name);
lua_newtable(L); /* create array metatable */
lua_pushvalue(L,-1);
lua_setmetatable(L,-2); /* set the own table as metatable (for modules) */
lua_pushstring(L,"__index");
lua_pushcfunction(L,get);
lua_rawset(L,-3);
lua_pushstring(L,"__newindex");
lua_pushcfunction(L,set?set:const_array);
lua_rawset(L,-3);
lua_rawset(L,-3); /* store variable */
lua_pop(L,1); /* pop .get table */
}
TOLUA_API void tolua_dobuffer(lua_State* L, char* B, unsigned int size, const char* name) {
#ifdef LUA_VERSION_NUM /* lua 5.1 */
luaL_loadbuffer(L, B, size, name) || lua_pcall(L, 0, 0, 0);
#else
lua_dobuffer(L, B, size, name);
#endif
};

175
3rdparty/toluapp/src/lib/tolua_push.c vendored Normal file
View File

@ -0,0 +1,175 @@
/* tolua: functions to push C values.
** Support code for Lua bindings.
** Written by Waldemar Celes
** TeCGraf/PUC-Rio
** Apr 2003
** $Id: $
*/
/* This code is free software; you can redistribute it and/or modify it.
** The software provided hereunder is on an "as is" basis, and
** the author has no obligation to provide maintenance, support, updates,
** enhancements, or modifications.
*/
#include "tolua++.h"
#include "lauxlib.h"
#include <stdlib.h>
TOLUA_API void tolua_pushvalue (lua_State* L, int lo)
{
lua_pushvalue(L,lo);
}
TOLUA_API void tolua_pushboolean (lua_State* L, int value)
{
lua_pushboolean(L,value);
}
TOLUA_API void tolua_pushnumber (lua_State* L, lua_Number value)
{
lua_pushnumber(L,value);
}
TOLUA_API void tolua_pushstring (lua_State* L, const char* value)
{
if (value == NULL)
lua_pushnil(L);
else
lua_pushstring(L,value);
}
TOLUA_API void tolua_pushuserdata (lua_State* L, void* value)
{
if (value == NULL)
lua_pushnil(L);
else
lua_pushlightuserdata(L,value);
}
TOLUA_API void tolua_pushusertype (lua_State* L, void* value, const char* type)
{
if (value == NULL)
lua_pushnil(L);
else
{
luaL_getmetatable(L, type);
lua_pushstring(L,"tolua_ubox");
lua_rawget(L,-2); /* stack: mt ubox */
if (lua_isnil(L, -1)) {
lua_pop(L, 1);
lua_pushstring(L, "tolua_ubox");
lua_rawget(L, LUA_REGISTRYINDEX);
};
lua_pushlightuserdata(L,value);
lua_rawget(L,-2); /* stack: mt ubox ubox[u] */
if (lua_isnil(L,-1))
{
lua_pop(L,1); /* stack: mt ubox */
lua_pushlightuserdata(L,value);
*(void**)lua_newuserdata(L,sizeof(void *)) = value; /* stack: mt ubox u newud */
lua_pushvalue(L,-1); /* stack: mt ubox u newud newud */
lua_insert(L,-4); /* stack: mt newud ubox u newud */
lua_rawset(L,-3); /* stack: mt newud ubox */
lua_pop(L,1); /* stack: mt newud */
/*luaL_getmetatable(L,type);*/
lua_pushvalue(L, -2); /* stack: mt newud mt */
lua_setmetatable(L,-2); /* stack: mt newud */
#ifdef LUA_VERSION_NUM
lua_pushvalue(L, TOLUA_NOPEER);
#if LUA_VERSION_NUM > 501
lua_setuservalue(L, -2);
#else
lua_setfenv(L, -2);
#endif
#endif
}
else
{
/* check the need of updating the metatable to a more specialized class */
lua_insert(L,-2); /* stack: mt ubox[u] ubox */
lua_pop(L,1); /* stack: mt ubox[u] */
lua_pushstring(L,"tolua_super");
lua_rawget(L,LUA_REGISTRYINDEX); /* stack: mt ubox[u] super */
lua_getmetatable(L,-2); /* stack: mt ubox[u] super mt */
lua_rawget(L,-2); /* stack: mt ubox[u] super super[mt] */
if (lua_istable(L,-1))
{
lua_pushstring(L,type); /* stack: mt ubox[u] super super[mt] type */
lua_rawget(L,-2); /* stack: mt ubox[u] super super[mt] flag */
if (lua_toboolean(L,-1) == 1) /* if true */
{
lua_pop(L,3); /* mt ubox[u]*/
lua_remove(L, -2);
return;
}
}
/* type represents a more specilized type */
/*luaL_getmetatable(L,type); // stack: mt ubox[u] super super[mt] flag mt */
lua_pushvalue(L, -5); /* stack: mt ubox[u] super super[mt] flag mt */
lua_setmetatable(L,-5); /* stack: mt ubox[u] super super[mt] flag */
lua_pop(L,3); /* stack: mt ubox[u] */
}
lua_remove(L, -2); /* stack: ubox[u]*/
}
}
TOLUA_API void tolua_pushusertype_and_takeownership (lua_State* L, void* value, const char* type)
{
tolua_pushusertype(L,value,type);
tolua_register_gc(L,lua_gettop(L));
}
TOLUA_API void tolua_pushfieldvalue (lua_State* L, int lo, int index, int v)
{
lua_pushnumber(L,index);
lua_pushvalue(L,v);
lua_settable(L,lo);
}
TOLUA_API void tolua_pushfieldboolean (lua_State* L, int lo, int index, int v)
{
lua_pushnumber(L,index);
lua_pushboolean(L,v);
lua_settable(L,lo);
}
TOLUA_API void tolua_pushfieldnumber (lua_State* L, int lo, int index, lua_Number v)
{
lua_pushnumber(L,index);
tolua_pushnumber(L,v);
lua_settable(L,lo);
}
TOLUA_API void tolua_pushfieldstring (lua_State* L, int lo, int index, const char* v)
{
lua_pushnumber(L,index);
tolua_pushstring(L,v);
lua_settable(L,lo);
}
TOLUA_API void tolua_pushfielduserdata (lua_State* L, int lo, int index, void* v)
{
lua_pushnumber(L,index);
tolua_pushuserdata(L,v);
lua_settable(L,lo);
}
TOLUA_API void tolua_pushfieldusertype (lua_State* L, int lo, int index, void* v, const char* type)
{
lua_pushnumber(L,index);
tolua_pushusertype(L,v,type);
lua_settable(L,lo);
}
TOLUA_API void tolua_pushfieldusertype_and_takeownership (lua_State* L, int lo, int index, void* v, const char* type)
{
lua_pushnumber(L,index);
tolua_pushusertype(L,v,type);
tolua_register_gc(L,lua_gettop(L));
lua_settable(L,lo);
}

133
3rdparty/toluapp/src/lib/tolua_to.c vendored Normal file
View File

@ -0,0 +1,133 @@
/* tolua: funcitons to convert to C types
** Support code for Lua bindings.
** Written by Waldemar Celes
** TeCGraf/PUC-Rio
** Apr 2003
** $Id: $
*/
/* This code is free software; you can redistribute it and/or modify it.
** The software provided hereunder is on an "as is" basis, and
** the author has no obligation to provide maintenance, support, updates,
** enhancements, or modifications.
*/
#include "tolua++.h"
#include <string.h>
#include <stdlib.h>
TOLUA_API lua_Number tolua_tonumber (lua_State* L, int narg, lua_Number def)
{
return lua_gettop(L)<abs(narg) ? def : lua_tonumber(L,narg);
}
TOLUA_API const char* tolua_tostring (lua_State* L, int narg, const char* def)
{
return lua_gettop(L)<abs(narg) ? def : lua_tostring(L,narg);
}
TOLUA_API void* tolua_touserdata (lua_State* L, int narg, void* def)
{
/* return lua_gettop(L)<abs(narg) ? def : lua_touserdata(L,narg); */
if (lua_gettop(L)<abs(narg)) {
return def;
};
if (lua_islightuserdata(L, narg)) {
return lua_touserdata(L,narg);
};
return tolua_tousertype(L, narg, def);
}
extern int push_table_instance(lua_State* L, int lo);
TOLUA_API void* tolua_tousertype (lua_State* L, int narg, void* def)
{
if (lua_gettop(L)<abs(narg))
return def;
else
{
void* u;
if (!lua_isuserdata(L, narg)) {
if (!push_table_instance(L, narg)) return NULL;
};
u = lua_touserdata(L,narg);
return (u==NULL) ? NULL : *((void**)u); /* nil represents NULL */
}
}
TOLUA_API int tolua_tovalue (lua_State* L, int narg, int def)
{
return lua_gettop(L)<abs(narg) ? def : narg;
}
TOLUA_API int tolua_toboolean (lua_State* L, int narg, int def)
{
return lua_gettop(L)<abs(narg) ? def : lua_toboolean(L,narg);
}
TOLUA_API lua_Number tolua_tofieldnumber (lua_State* L, int lo, int index, lua_Number def)
{
double v;
lua_pushnumber(L,index);
lua_gettable(L,lo);
v = lua_isnil(L,-1) ? def : lua_tonumber(L,-1);
lua_pop(L,1);
return v;
}
TOLUA_API const char* tolua_tofieldstring
(lua_State* L, int lo, int index, const char* def)
{
const char* v;
lua_pushnumber(L,index);
lua_gettable(L,lo);
v = lua_isnil(L,-1) ? def : lua_tostring(L,-1);
lua_pop(L,1);
return v;
}
TOLUA_API void* tolua_tofielduserdata (lua_State* L, int lo, int index, void* def)
{
void* v;
lua_pushnumber(L,index);
lua_gettable(L,lo);
v = lua_isnil(L,-1) ? def : lua_touserdata(L,-1);
lua_pop(L,1);
return v;
}
TOLUA_API void* tolua_tofieldusertype (lua_State* L, int lo, int index, void* def)
{
void* v;
lua_pushnumber(L,index);
lua_gettable(L,lo);
v = lua_isnil(L,-1) ? def : (*(void **)(lua_touserdata(L, -1))); /* lua_unboxpointer(L,-1); */
lua_pop(L,1);
return v;
}
TOLUA_API int tolua_tofieldvalue (lua_State* L, int lo, int index, int def)
{
int v;
lua_pushnumber(L,index);
lua_gettable(L,lo);
v = lua_isnil(L,-1) ? def : lo;
lua_pop(L,1);
return v;
}
TOLUA_API int tolua_getfieldboolean (lua_State* L, int lo, int index, int def)
{
int v;
lua_pushnumber(L,index);
lua_gettable(L,lo);
v = lua_isnil(L,-1) ? 0 : lua_toboolean(L,-1);
lua_pop(L,1);
return v;
}

18
3rdparty/toluapp/src/tests/SCsub vendored Normal file
View File

@ -0,0 +1,18 @@
Import('env')
env_tests = env.Copy()
env_tests.LuaBinding('tclassbind.cpp', 'tclass.pkg', 'tclass', use_own=1, use_typeid=1)
env_tests.Append(CXXFLAGS='-DTOLUA_API="extern \\\"C\\\""')
test_class_so = env_tests.SharedLibrary('tclass', ['tclassbind.cpp'],
LIBS=['$tolua_lib']+env['LIBS'], )
env_tests.Append(LIBPATH=".")
test_class = env_tests.Program('tclass', ['tclass.cpp'],
LIBS=env['LIBS']+['tclass']+['$tolua_lib'], )
env.test_targets = [test_class]

45
3rdparty/toluapp/src/tests/tarray.c vendored Normal file
View File

@ -0,0 +1,45 @@
#include "lualib.h"
#include "lauxlib.h"
#include "tarray.h"
int a[10] = {1,2,3,4,5,6,7,8,9,10};
Point p[10] = {{0,1},{1,2},{2,3},{3,4},{4,5},{5,6},{6,7},{7,8},{8,9},{9,10}};
Point* pp[10];
int ma[10];
Point mp[10];
Point* mpp[10];
Array array;
Array* parray = &array;
int main (void)
{
int tolua_tarray_open (lua_State*);
lua_State* L = lua_open();
int i;
for (i=0; i<10; ++i)
{
pp[i] = &p[i];
ma[i] = a[i];
mp[i] = p[i];
mpp[i] = pp[i];
array.a[i] = a[i];
array.p[i] = p[i];
array.pp[i] = pp[i];
}
luaopen_base(L);
tolua_tarray_open(L);
lua_dofile(L,"tarray.lua");
lua_close(L);
return 0;
}

28
3rdparty/toluapp/src/tests/tarray.h vendored Normal file
View File

@ -0,0 +1,28 @@
typedef struct Point Point;
struct Point
{
float x;
float y;
};
extern int a[10];
extern Point p[10];
extern Point* pp[10];
extern int ma[10];
extern Point mp[10];
extern Point* mpp[10];
typedef struct Array Array;
struct Array
{
int a[10];
Point p[10];
Point* pp[10];
};
extern Array array;
extern Array* parray;

37
3rdparty/toluapp/src/tests/tarray.lua vendored Normal file
View File

@ -0,0 +1,37 @@
for i=1,10 do
assert(a[i]==i)
end
for i=2,10 do
assert(p[i-1].y==p[i].x)
end
for i=1,10 do
assert(M.a[i]==i)
end
for i=2,10 do
assert(M.p[i-1].y==M.p[i].x)
end
for i=1,10 do
assert(pp[i].x==M.p[i].x and p[i].y == M.pp[i].y)
end
for i=1,10 do
assert(array.a[i] == parray.a[i])
assert(array.p[i].x == parray.pp[i].x and array.p[i].y == parray.pp[i].y)
end
for i=1,10 do
array.a[i] = a[10-i+1]
M.a[i] = 10-i+1
assert(array.a[i]==M.a[i])
end
for i=2,10 do
array.p[i] = array.pp[1]
assert(array.p[i].x==0 and array.p[i].y==1)
end
print("Array test OK")

29
3rdparty/toluapp/src/tests/tarray.pkg vendored Normal file
View File

@ -0,0 +1,29 @@
$#include "tarray.h"
struct Point
{
float x;
float y;
};
extern int a[10];
extern const Point p[10];
extern Point* pp[10];
module M {
extern int ma[10]@a;
extern const Point mp[10]@p;
extern Point* mpp[10]@pp;
}
struct Array
{
int a[10];
Point p[10];
Point* pp[10];
};
extern Array array;
extern Array* parray;

504
3rdparty/toluapp/src/tests/tarraybind.c vendored Normal file
View File

@ -0,0 +1,504 @@
/*
** Lua binding: tarray
** Generated automatically by tolua 5.0a-CDLVS2 on 08/08/03 17:06:22.
*/
#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"
#include "tolua.h"
/* Exported function */
TOLUA_API int tolua_tarray_open (lua_State* tolua_S);
#include "tarray.h"
/* function to release collected object via destructor */
#ifdef __cplusplus
static int tolua_collect_Point (lua_State* tolua_S)
{
Point* self = (Point*) tolua_tousertype(tolua_S,1,0);
delete self;
return 0;
}
#endif
/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
tolua_usertype(tolua_S,"Array");
tolua_usertype(tolua_S,"Point");
}
/* get function: x of class Point */
static int tolua_get_Point_x(lua_State* tolua_S)
{
Point* self = (Point*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
#endif
tolua_pushnumber(tolua_S,(double)self->x);
return 1;
}
/* set function: x of class Point */
static int tolua_set_Point_x(lua_State* tolua_S)
{
Point* self = (Point*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
self->x = ((float) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: y of class Point */
static int tolua_get_Point_y(lua_State* tolua_S)
{
Point* self = (Point*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
#endif
tolua_pushnumber(tolua_S,(double)self->y);
return 1;
}
/* set function: y of class Point */
static int tolua_set_Point_y(lua_State* tolua_S)
{
Point* self = (Point*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
self->y = ((float) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: a */
static int tolua_get_tarray_a(lua_State* tolua_S)
{
int tolua_index;
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
tolua_pushnumber(tolua_S,(double)a[tolua_index]);
return 1;
}
/* set function: a */
static int tolua_set_tarray_a(lua_State* tolua_S)
{
int tolua_index;
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
a[tolua_index] = ((int) tolua_tonumber(tolua_S,3,0));
return 0;
}
/* get function: p */
static int tolua_get_tarray_p(lua_State* tolua_S)
{
int tolua_index;
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
tolua_pushusertype(tolua_S,(void*)&p[tolua_index],"const Point");
return 1;
}
/* get function: pp */
static int tolua_get_tarray_pp(lua_State* tolua_S)
{
int tolua_index;
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
tolua_pushusertype(tolua_S,(void*)pp[tolua_index],"Point");
return 1;
}
/* set function: pp */
static int tolua_set_tarray_pp(lua_State* tolua_S)
{
int tolua_index;
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
pp[tolua_index] = ((Point*) tolua_tousertype(tolua_S,3,0));
return 0;
}
/* get function: ma */
static int tolua_get_tarray_M_ma(lua_State* tolua_S)
{
int tolua_index;
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
tolua_pushnumber(tolua_S,(double)ma[tolua_index]);
return 1;
}
/* set function: ma */
static int tolua_set_tarray_M_ma(lua_State* tolua_S)
{
int tolua_index;
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
ma[tolua_index] = ((int) tolua_tonumber(tolua_S,3,0));
return 0;
}
/* get function: mp */
static int tolua_get_tarray_M_mp(lua_State* tolua_S)
{
int tolua_index;
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
tolua_pushusertype(tolua_S,(void*)&mp[tolua_index],"const Point");
return 1;
}
/* get function: mpp */
static int tolua_get_tarray_M_mpp(lua_State* tolua_S)
{
int tolua_index;
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
tolua_pushusertype(tolua_S,(void*)mpp[tolua_index],"Point");
return 1;
}
/* set function: mpp */
static int tolua_set_tarray_M_mpp(lua_State* tolua_S)
{
int tolua_index;
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
mpp[tolua_index] = ((Point*) tolua_tousertype(tolua_S,3,0));
return 0;
}
/* get function: a of class Array */
static int tolua_get_tarray_Array_a(lua_State* tolua_S)
{
int tolua_index;
Array* self;
lua_pushstring(tolua_S,".self");
lua_rawget(tolua_S,1);
self = (Array*) lua_touserdata(tolua_S,-1);
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
tolua_pushnumber(tolua_S,(double)self->a[tolua_index]);
return 1;
}
/* set function: a of class Array */
static int tolua_set_tarray_Array_a(lua_State* tolua_S)
{
int tolua_index;
Array* self;
lua_pushstring(tolua_S,".self");
lua_rawget(tolua_S,1);
self = (Array*) lua_touserdata(tolua_S,-1);
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
self->a[tolua_index] = ((int) tolua_tonumber(tolua_S,3,0));
return 0;
}
/* get function: p of class Array */
static int tolua_get_tarray_Array_p(lua_State* tolua_S)
{
int tolua_index;
Array* self;
lua_pushstring(tolua_S,".self");
lua_rawget(tolua_S,1);
self = (Array*) lua_touserdata(tolua_S,-1);
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
tolua_pushusertype(tolua_S,(void*)&self->p[tolua_index],"Point");
return 1;
}
/* set function: p of class Array */
static int tolua_set_tarray_Array_p(lua_State* tolua_S)
{
int tolua_index;
Array* self;
lua_pushstring(tolua_S,".self");
lua_rawget(tolua_S,1);
self = (Array*) lua_touserdata(tolua_S,-1);
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
self->p[tolua_index] = *((Point*) tolua_tousertype(tolua_S,3,0));
return 0;
}
/* get function: pp of class Array */
static int tolua_get_tarray_Array_pp(lua_State* tolua_S)
{
int tolua_index;
Array* self;
lua_pushstring(tolua_S,".self");
lua_rawget(tolua_S,1);
self = (Array*) lua_touserdata(tolua_S,-1);
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
tolua_pushusertype(tolua_S,(void*)self->pp[tolua_index],"Point");
return 1;
}
/* set function: pp of class Array */
static int tolua_set_tarray_Array_pp(lua_State* tolua_S)
{
int tolua_index;
Array* self;
lua_pushstring(tolua_S,".self");
lua_rawget(tolua_S,1);
self = (Array*) lua_touserdata(tolua_S,-1);
#ifndef TOLUA_RELEASE
{
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
}
#endif
tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;
#ifndef TOLUA_RELEASE
if (tolua_index<0 || tolua_index>=10)
tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
self->pp[tolua_index] = ((Point*) tolua_tousertype(tolua_S,3,0));
return 0;
}
/* get function: array */
static int tolua_get_array(lua_State* tolua_S)
{
tolua_pushusertype(tolua_S,(void*)&array,"Array");
return 1;
}
/* set function: array */
static int tolua_set_array(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isusertype(tolua_S,2,"Array",0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
array = *((Array*) tolua_tousertype(tolua_S,2,0));
return 0;
}
/* get function: parray */
static int tolua_get_parray_ptr(lua_State* tolua_S)
{
tolua_pushusertype(tolua_S,(void*)parray,"Array");
return 1;
}
/* set function: parray */
static int tolua_set_parray_ptr(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isusertype(tolua_S,2,"Array",0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
parray = ((Array*) tolua_tousertype(tolua_S,2,0));
return 0;
}
/* Open function */
TOLUA_API int tolua_tarray_open (lua_State* tolua_S)
{
tolua_open(tolua_S);
tolua_reg_types(tolua_S);
tolua_module(tolua_S,NULL,1);
tolua_beginmodule(tolua_S,NULL);
#ifdef __cplusplus
tolua_cclass(tolua_S,"Point","Point","",tolua_collect_Point);
#else
tolua_cclass(tolua_S,"Point","Point","",NULL);
#endif
tolua_beginmodule(tolua_S,"Point");
tolua_variable(tolua_S,"x",tolua_get_Point_x,tolua_set_Point_x);
tolua_variable(tolua_S,"y",tolua_get_Point_y,tolua_set_Point_y);
tolua_endmodule(tolua_S);
tolua_array(tolua_S,"a",tolua_get_tarray_a,tolua_set_tarray_a);
tolua_array(tolua_S,"p",tolua_get_tarray_p,NULL);
tolua_array(tolua_S,"pp",tolua_get_tarray_pp,tolua_set_tarray_pp);
tolua_module(tolua_S,"M",1);
tolua_beginmodule(tolua_S,"M");
tolua_array(tolua_S,"a",tolua_get_tarray_M_ma,tolua_set_tarray_M_ma);
tolua_array(tolua_S,"p",tolua_get_tarray_M_mp,NULL);
tolua_array(tolua_S,"pp",tolua_get_tarray_M_mpp,tolua_set_tarray_M_mpp);
tolua_endmodule(tolua_S);
tolua_cclass(tolua_S,"Array","Array","",NULL);
tolua_beginmodule(tolua_S,"Array");
tolua_array(tolua_S,"a",tolua_get_tarray_Array_a,tolua_set_tarray_Array_a);
tolua_array(tolua_S,"p",tolua_get_tarray_Array_p,tolua_set_tarray_Array_p);
tolua_array(tolua_S,"pp",tolua_get_tarray_Array_pp,tolua_set_tarray_Array_pp);
tolua_endmodule(tolua_S);
tolua_variable(tolua_S,"array",tolua_get_array,tolua_set_array);
tolua_variable(tolua_S,"parray",tolua_get_parray_ptr,tolua_set_parray_ptr);
tolua_endmodule(tolua_S);
return 1;
}

32
3rdparty/toluapp/src/tests/tclass.cpp vendored Normal file
View File

@ -0,0 +1,32 @@
extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
#include "tclass.h"
//Test::Tst_A* Test::Tst_A::last;
//Test::Tst_B* Test::Tst_B::last;
//Test::Tst_C* Test::Tst_C::last;
extern "C" {
int tolua_tclass_open (lua_State*);
}
int main ()
{
Test::Tst_B* b = new Test::Tst_B; // instance used in Lua code
lua_State* L = lua_open();
luaL_openlibs(L);
tolua_tclass_open(L);
luaL_dofile(L,"tclass.lua");
lua_close(L);
delete b;
return 0;
}

121
3rdparty/toluapp/src/tests/tclass.h vendored Normal file
View File

@ -0,0 +1,121 @@
#ifndef TCLASS_H
#define TCLASS_H
#include <stdio.h>
namespace Test {
class Tst_Dummy
{
};
class Tst_A
{
int number;
public:
static Tst_A* last;
Tst_A () {last = this;}
virtual char* a () { return "A"; }
class Tst_AA
{
public:
Tst_AA () {}
~Tst_AA () { }
char* aa () { return "AA"; }
};
class Tst_BB : public Tst_AA
{
public:
Tst_BB () {}
~Tst_BB () {}
Tst_AA* Base () { return this; }
};
void set_number(int p_number) { number = p_number;};
int get_number() {return number*2;};
virtual ~Tst_A() {};
};
class Tst_B : public Tst_A
{
public:
static Tst_B* last;
Tst_B () {last = this;}
virtual char* b () { return "B"; }
static Tst_A* create() {return new Tst_B;};
static void* create_void() {return new Tst_B;};
virtual ~Tst_B() {};
};
class Tst_C : public Tst_B
{
int i;
public:
static Tst_C* last;
Tst_C (int n) : i(n) {last = this;}
virtual ~Tst_C () { printf("deleting C: %d\n",i); }
virtual char* c () { return "C"; }
};
inline Tst_A::Tst_AA* Tst_create_aa ()
{
return new Tst_A::Tst_AA();
}
inline bool Tst_is_aa (Tst_A::Tst_AA* obj)
{
return true;
}
class Tst_E {
void* ptr;
public:
enum Pete {
ONE,
TWO,
} pete;
void get_pete(Pete p) {};
template <class T>
T get_t() {T a=0; return a;};
Tst_E& operator+(const Tst_E& rvalue) {return *this;};
void pars(int a=0, int b=0) {};
void get_pointer(void* a) {};
Tst_A a;
void set_ptr(void* p_ptr) {
printf("this is %p, ptr is %p\n", this, p_ptr);
ptr = p_ptr;
};
void* get_ptr() {return ptr;};
Tst_E(int) {};
};
class Tst_Outside {
public:
Tst_Outside() {};
};
}; // end of namespace
static void outside_func(Test::Tst_Outside* p_out, lua_State* ls) {
if (p_out) printf("method!\n");
else printf("static!\n");
//printf("luastate: %i\n", ls);
};
#endif

131
3rdparty/toluapp/src/tests/tclass.lua vendored Normal file
View File

@ -0,0 +1,131 @@
if not Test then
local loadlib
if not package then
loadlib = _G['loadlib']
else
loadlib = package.loadlib
end
f, e, eo = loadlib("./libtclass.so", "luaopen_tclass")
if f then
f()
else
print(eo, e)
os.exit()
end
end
a = {}
rawset(a, ".c_instance", "something")
function hello()
print("hello world")
end
rawset(Test.B, "hello", hello)
-- type convertion tests
--print(Test.A)
--print(tolua.type(Test.A.last))
--assert(tolua.type(Test.A.last) == 'Test::Tst_A') -- first time the object is mapped
--assert(tolua.type(Test.B.last) == 'Test::Tst_B') -- type convertion to specialized type
--assert(tolua.type(Test.A.last) == 'Test::Tst_B') -- no convertion: obj already mapped as B
local a = Test.A:new()
assert(tolua.type(Test.A.last) == 'Test::Tst_A') -- no type convertion: same type
local b = Test.B:new()
assert(tolua.type(Test.A.last) == 'Test::Tst_B') -- no convertion: obj already mapped as B
local c = Test.luaC:new(0)
assert(tolua.type(Test.A.last) == 'Test::Tst_C') -- no convertion: obj already mapped as C
assert(tolua.type(Test.luaC.last) == 'Test::Tst_C')
local aa = Test.A.AA:new()
local bb = Test.A.BB:new()
local xx = Test.create_aa()
-- method calling tests
assert(a:a() == 'A')
assert(b:a() == 'A')
assert(b:b() == 'B')
assert(c:a() == 'A')
assert(c:b() == 'B')
assert(c:c() == 'C')
assert(aa:aa() == 'AA')
assert(bb:aa() == bb:Base():aa())
assert(xx:aa() == 'AA')
assert(Test.is_aa(bb) == true)
-- test ownershipping handling
-- should delete objects: 6 7 8 9 10 (it may vary!)
local set = {}
for i=1,10 do
local c = Test.luaC:new(i)
if i>5 then
tolua.takeownership(c)
end
--set[i] = c
end
e = Test.B:new_local()
print("e is type "..tolua.type(e))
print("ae is type "..tolua.type(ae))
--e:delete()
b:hello()
----------
local out = Test.Outside:new_local()
out:outside()
Test.Outside:outside_static(nil)
print "***** cast"
local acast = Test.B:create_void()
print("type is "..tolua.type(acast))
local bcast = tolua.cast(acast, "Test::Tst_B")
print("bcast is "..tostring(bcast))
print("type is "..tolua.type(bcast))
print(bcast:b())
-- test properies
local n = 7
a.number = n
assert(a.number == n*2)
-- constructors
print(getmetatable(Test.A))
print(getmetatable(Test.B))
print(getmetatable(Test.E))
local a = Test.A()
local b = Test.B()
local e = Test.E(5)
--print(e+5)
print(tostring(getmetatable(Test.B).__call))
print(tostring(Test.B.__call))
print(tostring(Test.B.__call(Test.B)))
print(tolua.type(b))
e:set_ptr(e)
local ve = tolua.cast(e:get_ptr(), "Test::Tst_E")
ve:set_ptr(ve)
print"1"
Test.A.pete = {}
print"2"
table.insert(Test.A.pete, a)
print"3"
for i=1,100000 do
la = {}
tolua.inherit(la, a)
end
print("Class test OK")

97
3rdparty/toluapp/src/tests/tclass.pkg vendored Normal file
View File

@ -0,0 +1,97 @@
$#include "tclass.h"
$Test::Tst_A* Test::Tst_A::last;
$Test::Tst_B* Test::Tst_B::last;
$Test::Tst_C* Test::Tst_C::last;
$renaming ^Tst_ @
namespace Test {
class Tst_Dummy;
class Tst_A
{
static Tst_A* last;
Tst_A ();
virtual char* a ();
class Tst_AA
{
Tst_AA () {}
~Tst_AA () {}
char* aa () { return "AA"; }
};
class Tst_BB : public Tst_AA
{
Tst_BB () {}
~Tst_BB () {}
Tst_AA* Base () { return this; }
};
tolua_property int number;
};
class Tst_E {
public:
typedef enum{
ONE,
TWO,
} Pete;
Pete pete;
float get_t<float>();
void get_pete(Pete p);
Tst_E& operator+(const Tst_E& rvalue);
void pars(int a=0xa, int b=GetNumber(GetNumber(1,2)));
void get_pointer(void* a=NULL);
void set_ptr(void* p_ptr) {
printf("this is %p, ptr is %p\n", this, p_ptr);
ptr = p_ptr;
};
void* get_ptr() {return ptr;};
Tst_A a;
Tst_E(int);
//~Tst_E();
};
class Tst_B : public Tst_A
{
static Tst_B* last;
Tst_B ();
virtual char* b ();
static Tst_A* create();
static void* create_void() {return new Tst_B;};
};
class Tst_C@luaC : public Tst_B
{
static Tst_C* last;
Tst_C (int n);
~Tst_C ();
virtual char* c ();
};
Tst_A::Tst_AA* Tst_create_aa ();
bool Tst_is_aa (Tst_A::Tst_AA* obj);
class Tst_Outside {
tolua_outside void outside_func@outside(lua_State* ls);
static tolua_outside void outside_func@outside_static(Tst_Outside* instance, lua_State* ls);
Tst_Outside() {};
};
}; // end of namespace

29
3rdparty/toluapp/src/tests/tconstant.h vendored Normal file
View File

@ -0,0 +1,29 @@
#define FIRST 1
#define SECOND 2
enum {
ONE = 1,
TWO = 2
};
#define M_FIRST 1
#define M_SECOND 2
enum {
M_ONE = 1,
M_TWO = 2
};
class A {
public:
#define FIRST 1
#define SECOND 2
enum {
ONE = 1,
TWO = 2
};
};

11
3rdparty/toluapp/src/tests/tconstant.lua vendored Normal file
View File

@ -0,0 +1,11 @@
assert(FIRST==M.FIRST)
assert(FIRST==A.FIRST)
assert(SECOND==M.SECOND)
assert(SECOND==A.SECOND)
assert(ONE==M.ONE)
assert(ONE==A.ONE)
assert(TWO==M.TWO)
assert(TWO==A.TWO)
print("Constant test OK")

34
3rdparty/toluapp/src/tests/tconstant.pkg vendored Normal file
View File

@ -0,0 +1,34 @@
$#include "tconstant.h"
#define FIRST 1
#define SECOND 2
enum {
ONE = 1,
TWO = 2
};
module M {
#define M_FIRST@FIRST 1
#define M_SECOND@SECOND 2
enum {
M_ONE@ONE = 1,
M_TWO@TWO = 2
};
}
class A {
public:
#define FIRST 1
#define SECOND 2
enum {
ONE = 1,
TWO = 2
};
};

6
3rdparty/toluapp/src/tests/tdirective.lua vendored Normal file
View File

@ -0,0 +1,6 @@
assert(a==3)
assert(A==4)
assert(func()==5)
print("Directive test OK")

28
3rdparty/toluapp/src/tests/tdirective.pkg vendored Normal file
View File

@ -0,0 +1,28 @@
$#include "lualib.h"
$#include "lauxlib.h"
$int a;
$extern int a;
$int main (void)
${
$ lua_State* L = lua_open();
$ luaopen_base(L);
$ tolua_tdirective_open(L);
$ lua_dofile(L,"tdirective.lua");
$ lua_close(L);
$ return 0;
$}
$pfile "tdirectivepkg.pkg"
$<
a = 3;
$>
$[
A = 4
$]
$lfile "tdirectivelua.lua"

Some files were not shown because too many files have changed in this diff Show More