mirror of
https://github.com/Llewellynvdm/conky.git
synced 2024-12-25 04:06:03 +00:00
Get build working with -Wall.
Enable `MAINTAINER_MODE` on travis builds.
This commit is contained in:
parent
bb8723dd36
commit
4b36d526a3
13
.travis.yml
13
.travis.yml
@ -10,6 +10,7 @@ matrix:
|
||||
packages:
|
||||
- g++-5
|
||||
- cmake
|
||||
- docbook2x
|
||||
- libxdamage-dev
|
||||
- libx11-dev
|
||||
- libxft-dev
|
||||
@ -47,6 +48,7 @@ matrix:
|
||||
packages:
|
||||
- g++-6
|
||||
- cmake
|
||||
- docbook2x
|
||||
- libxdamage-dev
|
||||
- libx11-dev
|
||||
- libxft-dev
|
||||
@ -84,6 +86,7 @@ matrix:
|
||||
packages:
|
||||
- g++-7
|
||||
- cmake
|
||||
- docbook2x
|
||||
- libxdamage-dev
|
||||
- libx11-dev
|
||||
- libxft-dev
|
||||
@ -121,6 +124,7 @@ matrix:
|
||||
packages:
|
||||
- g++-8
|
||||
- cmake
|
||||
- docbook2x
|
||||
- libxdamage-dev
|
||||
- libx11-dev
|
||||
- libxft-dev
|
||||
@ -158,6 +162,7 @@ matrix:
|
||||
packages:
|
||||
- clang-6.0
|
||||
- cmake
|
||||
- docbook2x
|
||||
- libxdamage-dev
|
||||
- libx11-dev
|
||||
- libxft-dev
|
||||
@ -196,6 +201,7 @@ matrix:
|
||||
- clang-7
|
||||
- libc++-7-dev
|
||||
- cmake
|
||||
- docbook2x
|
||||
- libxdamage-dev
|
||||
- libx11-dev
|
||||
- libxft-dev
|
||||
@ -238,7 +244,7 @@ before_install:
|
||||
- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then eval "${MATRIX_EVAL}" ; fi
|
||||
- |
|
||||
if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
|
||||
HOMEBREW_NO_AUTO_UPDATE=1 brew install freetype gettext lua imlib2 librsvg ccache;
|
||||
HOMEBREW_NO_AUTO_UPDATE=1 brew install freetype gettext lua imlib2 librsvg ccache docbook2x ;
|
||||
export PATH="/usr/local/opt/ccache/libexec:$PATH";
|
||||
fi
|
||||
- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew link gettext --force ; fi
|
||||
@ -248,6 +254,7 @@ before_script:
|
||||
mkdir build && cd build
|
||||
|
||||
cmake \
|
||||
-DMAINTAINER_MODE=ON \
|
||||
-DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
|
||||
-DBUILD_MYSQL=ON \
|
||||
-DBUILD_LUA_IMLIB2=ON \
|
||||
@ -268,6 +275,7 @@ before_script:
|
||||
cd build-no-x11
|
||||
|
||||
cmake \
|
||||
-DMAINTAINER_MODE=ON \
|
||||
-DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
|
||||
-DBUILD_X11=OFF \
|
||||
-DBUILD_MYSQL=ON \
|
||||
@ -288,6 +296,7 @@ before_script:
|
||||
elif [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
|
||||
mkdir build && cd build
|
||||
cmake \
|
||||
-DMAINTAINER_MODE=ON \
|
||||
-DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
|
||||
-DBUILD_LUA_RSVG=ON \
|
||||
-DBUILD_LUA_IMLIB2=ON \
|
||||
@ -297,6 +306,8 @@ before_script:
|
||||
mkdir build-no-x11
|
||||
cd build-no-x11
|
||||
cmake \
|
||||
-DMAINTAINER_MODE=ON \
|
||||
-DBUILD_X11=OFF \
|
||||
-DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
|
||||
-DBUILD_X11=OFF \
|
||||
-DBUILD_LUA_RSVG=ON \
|
||||
|
100
3rdparty/toluapp/.travis.yml
vendored
100
3rdparty/toluapp/.travis.yml
vendored
@ -1,100 +0,0 @@
|
||||
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
42
3rdparty/toluapp/CMakeLists.txt
vendored
@ -1,42 +0,0 @@
|
||||
# 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
33
3rdparty/toluapp/COPYRIGHT
vendored
@ -1,33 +0,0 @@
|
||||
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
42
3rdparty/toluapp/INSTALL
vendored
@ -1,42 +0,0 @@
|
||||
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
5
3rdparty/toluapp/Makefile
vendored
@ -1,5 +0,0 @@
|
||||
# makefile for tolua hierarchy
|
||||
|
||||
all:
|
||||
@echo "Makefile is deprecated ;)"
|
||||
@echo "see INSTALL for details on how to build tolua++"
|
30
3rdparty/toluapp/README
vendored
30
3rdparty/toluapp/README
vendored
@ -1,30 +0,0 @@
|
||||
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
50
3rdparty/toluapp/README-5.1
vendored
@ -1,50 +0,0 @@
|
||||
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
182
3rdparty/toluapp/SConstruct
vendored
@ -1,182 +0,0 @@
|
||||
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
308
3rdparty/toluapp/cmake/dist.cmake
vendored
@ -1,308 +0,0 @@
|
||||
# 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
293
3rdparty/toluapp/cmake/lua.cmake
vendored
@ -1,293 +0,0 @@
|
||||
# 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
22
3rdparty/toluapp/config_linux.py
vendored
@ -1,22 +0,0 @@
|
||||
|
||||
## 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
28
3rdparty/toluapp/config_msvc.py
vendored
@ -1,28 +0,0 @@
|
||||
|
||||
## 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
23
3rdparty/toluapp/config_posix.py
vendored
@ -1,23 +0,0 @@
|
||||
|
||||
## 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
9
3rdparty/toluapp/custom-5.1.py
vendored
@ -1,9 +0,0 @@
|
||||
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
6
3rdparty/toluapp/debian/README
vendored
@ -1,6 +0,0 @@
|
||||
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
6
3rdparty/toluapp/debian/README.Debian
vendored
@ -1,6 +0,0 @@
|
||||
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
121
3rdparty/toluapp/debian/changelog
vendored
@ -1,121 +0,0 @@
|
||||
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
1
3rdparty/toluapp/debian/compat
vendored
@ -1 +0,0 @@
|
||||
4
|
7
3rdparty/toluapp/debian/conffiles.ex
vendored
7
3rdparty/toluapp/debian/conffiles.ex
vendored
@ -1,7 +0,0 @@
|
||||
#
|
||||
# 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
13
3rdparty/toluapp/debian/control
vendored
@ -1,13 +0,0 @@
|
||||
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
16
3rdparty/toluapp/debian/copyright
vendored
@ -1,16 +0,0 @@
|
||||
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
4
3rdparty/toluapp/debian/cron.d.ex
vendored
@ -1,4 +0,0 @@
|
||||
#
|
||||
# Regular cron jobs for the tolua++ package
|
||||
#
|
||||
0 4 * * * root tolua++_maintenance
|
4
3rdparty/toluapp/debian/dirs
vendored
4
3rdparty/toluapp/debian/dirs
vendored
@ -1,4 +0,0 @@
|
||||
usr/bin
|
||||
usr/lib
|
||||
usr/include
|
||||
|
1
3rdparty/toluapp/debian/docs
vendored
1
3rdparty/toluapp/debian/docs
vendored
@ -1 +0,0 @@
|
||||
README
|
45
3rdparty/toluapp/debian/emacsen-install.ex
vendored
45
3rdparty/toluapp/debian/emacsen-install.ex
vendored
@ -1,45 +0,0 @@
|
||||
#! /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
15
3rdparty/toluapp/debian/emacsen-remove.ex
vendored
@ -1,15 +0,0 @@
|
||||
#!/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
19
3rdparty/toluapp/debian/emacsen-startup.ex
vendored
@ -1,19 +0,0 @@
|
||||
;; -*-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
74
3rdparty/toluapp/debian/init.d.ex
vendored
@ -1,74 +0,0 @@
|
||||
#! /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
59
3rdparty/toluapp/debian/manpage.1.ex
vendored
@ -1,59 +0,0 @@
|
||||
.\" 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
156
3rdparty/toluapp/debian/manpage.sgml.ex
vendored
@ -1,156 +0,0 @@
|
||||
<!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
148
3rdparty/toluapp/debian/manpage.xml.ex
vendored
@ -1,148 +0,0 @@
|
||||
<?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
2
3rdparty/toluapp/debian/menu.ex
vendored
@ -1,2 +0,0 @@
|
||||
?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
42
3rdparty/toluapp/debian/postinst.ex
vendored
@ -1,42 +0,0 @@
|
||||
#! /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
38
3rdparty/toluapp/debian/postrm.ex
vendored
@ -1,38 +0,0 @@
|
||||
#! /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
44
3rdparty/toluapp/debian/preinst.ex
vendored
@ -1,44 +0,0 @@
|
||||
#! /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
39
3rdparty/toluapp/debian/prerm.ex
vendored
@ -1,39 +0,0 @@
|
||||
#! /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
102
3rdparty/toluapp/debian/rules
vendored
@ -1,102 +0,0 @@
|
||||
#!/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
10
3rdparty/toluapp/debian/tolua++-default.ex
vendored
@ -1,10 +0,0 @@
|
||||
# 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
22
3rdparty/toluapp/debian/tolua++.doc-base.EX
vendored
@ -1,22 +0,0 @@
|
||||
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
6
3rdparty/toluapp/debian/watch.ex
vendored
@ -1,6 +0,0 @@
|
||||
# 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
14
3rdparty/toluapp/dist.info
vendored
@ -1,14 +0,0 @@
|
||||
--- 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
226
3rdparty/toluapp/doc/index.html
vendored
@ -1,226 +0,0 @@
|
||||
<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
1956
3rdparty/toluapp/doc/tolua++.html
vendored
File diff suppressed because it is too large
Load Diff
BIN
3rdparty/toluapp/doc/toluapp.gif
vendored
BIN
3rdparty/toluapp/doc/toluapp.gif
vendored
Binary file not shown.
Before Width: | Height: | Size: 5.8 KiB |
186
3rdparty/toluapp/include/tolua++.h
vendored
186
3rdparty/toluapp/include/tolua++.h
vendored
@ -1,186 +0,0 @@
|
||||
/* 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
65
3rdparty/toluapp/libtoluapp.def
vendored
@ -1,65 +0,0 @@
|
||||
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
12
3rdparty/toluapp/src/bin/SCsub
vendored
@ -1,12 +0,0 @@
|
||||
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
30
3rdparty/toluapp/src/bin/lua/all.lua
vendored
@ -1,30 +0,0 @@
|
||||
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
233
3rdparty/toluapp/src/bin/lua/array.lua
vendored
@ -1,233 +0,0 @@
|
||||
-- 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
417
3rdparty/toluapp/src/bin/lua/basic.lua
vendored
@ -1,417 +0,0 @@
|
||||
-- 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
202
3rdparty/toluapp/src/bin/lua/class.lua
vendored
@ -1,202 +0,0 @@
|
||||
-- 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
79
3rdparty/toluapp/src/bin/lua/clean.lua
vendored
@ -1,79 +0,0 @@
|
||||
-- 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
105
3rdparty/toluapp/src/bin/lua/code.lua
vendored
@ -1,105 +0,0 @@
|
||||
-- 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
57
3rdparty/toluapp/src/bin/lua/compat-5.1.lua
vendored
@ -1,57 +0,0 @@
|
||||
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
193
3rdparty/toluapp/src/bin/lua/compat.lua
vendored
@ -1,193 +0,0 @@
|
||||
-------------------------------------------------------------------
|
||||
-- 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
786
3rdparty/toluapp/src/bin/lua/container.lua
vendored
@ -1,786 +0,0 @@
|
||||
-- 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
45
3rdparty/toluapp/src/bin/lua/custom.lua
vendored
@ -1,45 +0,0 @@
|
||||
|
||||
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
579
3rdparty/toluapp/src/bin/lua/declaration.lua
vendored
@ -1,579 +0,0 @@
|
||||
-- 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
63
3rdparty/toluapp/src/bin/lua/define.lua
vendored
@ -1,63 +0,0 @@
|
||||
-- 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
101
3rdparty/toluapp/src/bin/lua/doit.lua
vendored
@ -1,101 +0,0 @@
|
||||
-- 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
106
3rdparty/toluapp/src/bin/lua/enumerate.lua
vendored
@ -1,106 +0,0 @@
|
||||
-- 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
139
3rdparty/toluapp/src/bin/lua/feature.lua
vendored
@ -1,139 +0,0 @@
|
||||
-- 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
577
3rdparty/toluapp/src/bin/lua/function.lua
vendored
@ -1,577 +0,0 @@
|
||||
-- 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
68
3rdparty/toluapp/src/bin/lua/module.lua
vendored
@ -1,68 +0,0 @@
|
||||
-- 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
52
3rdparty/toluapp/src/bin/lua/namespace.lua
vendored
@ -1,52 +0,0 @@
|
||||
-- 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
220
3rdparty/toluapp/src/bin/lua/operator.lua
vendored
@ -1,220 +0,0 @@
|
||||
-- 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
342
3rdparty/toluapp/src/bin/lua/package.lua
vendored
@ -1,342 +0,0 @@
|
||||
-- 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
82
3rdparty/toluapp/src/bin/lua/template_class.lua
vendored
@ -1,82 +0,0 @@
|
||||
|
||||
_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
71
3rdparty/toluapp/src/bin/lua/typedef.lua
vendored
@ -1,71 +0,0 @@
|
||||
-- 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
300
3rdparty/toluapp/src/bin/lua/variable.lua
vendored
@ -1,300 +0,0 @@
|
||||
-- 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
78
3rdparty/toluapp/src/bin/lua/verbatim.lua
vendored
@ -1,78 +0,0 @@
|
||||
-- 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
181
3rdparty/toluapp/src/bin/tolua.c
vendored
@ -1,181 +0,0 @@
|
||||
/* 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
31
3rdparty/toluapp/src/bin/tolua_scons.pkg
vendored
@ -1,31 +0,0 @@
|
||||
$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
8072
3rdparty/toluapp/src/bin/toluabind.c
vendored
File diff suppressed because it is too large
Load Diff
8
3rdparty/toluapp/src/bin/toluabind.h
vendored
8
3rdparty/toluapp/src/bin/toluabind.h
vendored
@ -1,8 +0,0 @@
|
||||
/*
|
||||
** 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
8009
3rdparty/toluapp/src/bin/toluabind_default.c
vendored
File diff suppressed because it is too large
Load Diff
8
3rdparty/toluapp/src/bin/toluabind_default.h
vendored
8
3rdparty/toluapp/src/bin/toluabind_default.h
vendored
@ -1,8 +0,0 @@
|
||||
/*
|
||||
** 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
18
3rdparty/toluapp/src/lib/SCsub
vendored
@ -1,18 +0,0 @@
|
||||
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
552
3rdparty/toluapp/src/lib/tolua_event.c
vendored
@ -1,552 +0,0 @@
|
||||
/* 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
24
3rdparty/toluapp/src/lib/tolua_event.h
vendored
@ -1,24 +0,0 @@
|
||||
/* 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
621
3rdparty/toluapp/src/lib/tolua_is.c
vendored
@ -1,621 +0,0 @@
|
||||
/* 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
724
3rdparty/toluapp/src/lib/tolua_map.c
vendored
@ -1,724 +0,0 @@
|
||||
/* 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
175
3rdparty/toluapp/src/lib/tolua_push.c
vendored
@ -1,175 +0,0 @@
|
||||
/* 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
133
3rdparty/toluapp/src/lib/tolua_to.c
vendored
@ -1,133 +0,0 @@
|
||||
/* 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
18
3rdparty/toluapp/src/tests/SCsub
vendored
@ -1,18 +0,0 @@
|
||||
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
45
3rdparty/toluapp/src/tests/tarray.c
vendored
@ -1,45 +0,0 @@
|
||||
#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
28
3rdparty/toluapp/src/tests/tarray.h
vendored
@ -1,28 +0,0 @@
|
||||
|
||||
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
37
3rdparty/toluapp/src/tests/tarray.lua
vendored
@ -1,37 +0,0 @@
|
||||
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
29
3rdparty/toluapp/src/tests/tarray.pkg
vendored
@ -1,29 +0,0 @@
|
||||
$#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
504
3rdparty/toluapp/src/tests/tarraybind.c
vendored
@ -1,504 +0,0 @@
|
||||
/*
|
||||
** 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
32
3rdparty/toluapp/src/tests/tclass.cpp
vendored
@ -1,32 +0,0 @@
|
||||
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
121
3rdparty/toluapp/src/tests/tclass.h
vendored
@ -1,121 +0,0 @@
|
||||
#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
131
3rdparty/toluapp/src/tests/tclass.lua
vendored
@ -1,131 +0,0 @@
|
||||
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
97
3rdparty/toluapp/src/tests/tclass.pkg
vendored
@ -1,97 +0,0 @@
|
||||
$#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
29
3rdparty/toluapp/src/tests/tconstant.h
vendored
@ -1,29 +0,0 @@
|
||||
#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
11
3rdparty/toluapp/src/tests/tconstant.lua
vendored
@ -1,11 +0,0 @@
|
||||
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
34
3rdparty/toluapp/src/tests/tconstant.pkg
vendored
@ -1,34 +0,0 @@
|
||||
$#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
6
3rdparty/toluapp/src/tests/tdirective.lua
vendored
@ -1,6 +0,0 @@
|
||||
assert(a==3)
|
||||
assert(A==4)
|
||||
assert(func()==5)
|
||||
|
||||
print("Directive test OK")
|
||||
|
28
3rdparty/toluapp/src/tests/tdirective.pkg
vendored
28
3rdparty/toluapp/src/tests/tdirective.pkg
vendored
@ -1,28 +0,0 @@
|
||||
$#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
Loading…
Reference in New Issue
Block a user