other/osgos_conky
5
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

Пересобранный и видоизмененный conky для ОСГОС

Browse source
This commit is contained in:
Галанский Сергей Александрович 2025-06-09 14:13:23 +05:00
commit 3a48cf8c86
738 changed files with 217718 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

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

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

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

@ -0,0 +1,31 @@
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.."ordered_pairs.lua")
dofile(path.."package.lua")
dofile(path.."module.lua")
dofile(path.."namespace.lua")
dofile(path.."define.lua")
dofile(path.."enumerate.lua")
dofile(path.."declaration.lua")
dofile(path.."variable.lua")
dofile(path.."array.lua")
dofile(path.."function.lua")
dofile(path.."operator.lua")
dofile(path.."template_class.lua")
dofile(path.."class.lua")
dofile(path.."clean.lua")
--dofile(path.."custom.lua")
dofile(path.."doit.lua")
local err,msg = xpcall(doit, debug.traceback)
if not err then
--print("**** msg is "..tostring(msg))
local _,_,label,msg = strfind(msg,"(.-:.-:%s*)(.*)")
tolua_error(msg,label)
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

18
3rdparty/toluapp/src/bin/lua/ordered_pairs.lua vendored Normal file
View file

@ -0,0 +1,18 @@
local P = {}
op = P
function P:ordered_pairs(t)
local i = {}
for k in next, t do
table.insert(i, k)
end
table.sort(i)
return function()
local k = table.remove(i)
if k ~= nil then
return k, t[k]
end
end
end
return op

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

@ -0,0 +1,343 @@
-- 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 .. '.\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 op:ordered_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 op:ordered_pairs(_usertype) do
if (not _global_classes[v]) or _global_classes[v]:check_public_access() then
output(' tolua_usertype(tolua_S,"', v, '");')
if flags.t then
output(' Mtolua_typeid(tolua_S,typeid(', v, '), "', v, '");')
end
end
end
output('}')
output('\n')
end
-- register package
-- write package open function
function classPackage:register(pre)
pre = pre or ''
push(self)
output(pre .. "/* Open function */")
output(pre .. "TOLUA_API int tolua_" .. self.name .. "_open (lua_State* tolua_S)")
output(pre .. "{")
output(pre .. " tolua_open(tolua_S);")
output(pre .. " tolua_reg_types(tolua_S);")
output(pre .. " tolua_module(tolua_S,NULL,", self:hasvar(), ");")
output(pre .. " tolua_beginmodule(tolua_S,NULL);")
local i = 1
while self[i] do
self[i]:register(pre .. " ")
i = i + 1
end
output(pre .. " tolua_endmodule(tolua_S);")
output(pre .. " return 1;")
output(pre .. "}")
output("\n\n")
output("#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501\n");
output(pre .. "TOLUA_API int luaopen_" .. self.name .. " (lua_State* tolua_S) {")
output(pre .. " return tolua_" .. self.name .. "_open(tolua_S);")
output(pre .. "}")
output("#endif\n\n")
pop()
end
-- write header file
function classPackage:header()
output('/*\n')
output('** Lua binding: ' .. self.name .. '\n')
output('** Generated automatically by ' .. TOLUA_VERSION .. ' on ' .. date() .. '.\n')
output('*/\n\n')
if not flags.h then
output('/* Exported function */')
output('TOLUA_API int tolua_' .. self.name .. '_open (lua_State* tolua_S);')
output('\n')
end
end
-- Internal constructor
function _Package(self)
setmetatable(self, classPackage)
return self
end
-- Parse C header file with tolua directives
-- *** Thanks to Ariel Manzur for fixing bugs in nested directives ***
function extract_code(fn, s)
local code = '\n$#include "' .. fn .. '"\n'
s = "\n" .. s .. "\n" -- add blank lines as sentinels
local _, e, c, t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n")
while e do
t = strlower(t)
if t == "begin" then
_, e, c = strfind(s, "(.-)\n[^\n]*[Tt][Oo][Ll][Uu][Aa]_[Ee][Nn][Dd][^\n]*\n", e)
if not e then
tolua_error("Unbalanced 'tolua_begin' directive in header file")
end
end
code = code .. c .. "\n"
_, e, c, t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n", e)
end
return code
end
-- Constructor
-- Expects the package name, the file extension, and the file text.
function Package(name, fn)
local ext = "pkg"
-- open input file, if any
local st, msg
if fn then
st, msg = readfrom(flags.f)
if not st then
error('#' .. msg)
end
local _; _, _, ext = strfind(fn, ".*%.(.*)$")
end
local code
if ext == 'pkg' then
code = prep(st)
else
code = "\n" .. read('*a')
if ext == 'h' or ext == 'hpp' then
code = extract_code(fn, code)
end
end
-- close file
if fn then
readfrom()
end
-- deal with include directive
local nsubst
repeat
code, nsubst = gsub(code, '\n%s*%$(.)file%s*"(.-)"([^\n]*)\n',
function(kind, fn, extra)
local _, _, ext = strfind(fn, ".*%.(.*)$")
local fp, msg = openfile(fn, 'r')
if not fp then
error('#' .. msg .. ': ' .. fn)
end
if kind == 'p' then
local s = prep(fp)
closefile(fp)
return s
end
local s = read(fp, '*a')
closefile(fp)
if kind == 'c' or kind == 'h' then
return extract_code(fn, s)
elseif kind == 'l' then
return "\n$[--##" .. fn .. "\n" .. s .. "\n$]\n"
elseif kind == 'i' then
local t = { code = s }
extra = string.gsub(extra, "^%s*,%s*", "")
local pars = split_c_tokens(extra, ",")
include_file_hook(t, fn, table.unpack(pars))
return "\n\n" .. t.code
else
error('#Invalid include directive (use $cfile, $pfile, $lfile or $ifile)')
end
end)
until nsubst == 0
-- deal with renaming directive
repeat -- I don't know why this is necesary
code, nsubst = gsub(code, '\n%s*%$renaming%s*(.-)%s*\n', function(r)
appendrenaming(r)
return "\n"
end)
until nsubst == 0
local t = _Package(_Container { name = name, code = code })
push(t)
preprocess_hook(t)
t:preprocess()
preparse_hook(t)
t:parse(t.code)
pop()
return t
end
setmetatable(_extra_parameters, { __index = _G })
function prep(file)
local chunk = { 'local __ret = {"\\n"}\n' }
for line in file:lines() do
if string.find(line, "^##") then
table.insert(chunk, string.sub(line, 3) .. "\n")
else
local last = 1
for text, expr, index in string.gmatch(line, "(.-)$(%b())()") do
last = index
if text ~= "" then
table.insert(chunk, string.format('table.insert(__ret, %q )', text))
end
table.insert(chunk, string.format('table.insert(__ret, %s )', expr))
end
table.insert(chunk, string.format('table.insert(__ret, %q)\n',
string.sub(line, last) .. "\n"))
end
end
table.insert(chunk, '\nreturn table.concat(__ret)\n')
local f, e = load(table.concat(chunk), nil, "t", _extra_parameters)
if e then
error("#" .. e)
end
return f()
end

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

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

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

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

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

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

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

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

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

@ -0,0 +1,211 @@
/* 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 "lauxlib.h"
#include "lua.h"
#include "lualib.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, const char *f, const char *v) {
lua_pushstring(L, f);
lua_pushstring(L, v);
lua_settable(L, table);
}
static void add_extra(lua_State *L, const 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) __attribute__((noreturn));
static void error(char *o) {
fprintf(stderr, "tolua: unknown option '%s'\n", o);
help();
exit(1);
}
int main(int argc, char *argv[]) {
#ifdef LUA_VERSION_NUM /* lua 5.1 */
lua_State *L = luaL_newstate();
luaL_openlibs(L);
#else
lua_State *L = lua_open();
luaopen_base(L);
luaopen_io(L);
luaopen_string(L);
luaopen_table(L);
luaopen_math(L);
luaopen_debug(L);
#endif
lua_pushstring(L, TOLUA_VERSION);
lua_setglobal(L, "TOLUA_VERSION");
lua_pushstring(L, LUA_VERSION);
lua_setglobal(L, "TOLUA_LUA_VERSION");
if (argc == 1) {
help();
return 0;
} else {
int i, t;
lua_newtable(L);
lua_setglobal(L, "_extra_parameters");
lua_newtable(L);
lua_pushvalue(L, -1);
lua_setglobal(L, "flags");
t = lua_gettop(L);
// Ignore the last arg in the arg list.
for (i = 1; i < argc - 1; ++i) {
if (*argv[i] == '-') {
switch (argv[i][1]) {
case 'v':
version();
return 0;
case 'h':
help();
return 0;
case 'p':
setfield(L, t, "p", "");
break;
case 'P':
setfield(L, t, "P", "");
break;
case 'o':
setfield(L, t, "o", argv[++i]);
break;
case 'n':
setfield(L, t, "n", argv[++i]);
break;
case 'H':
setfield(L, t, "H", argv[++i]);
break;
case 'S':
setfield(L, t, "S", "");
break;
case '1':
setfield(L, t, "1", "");
break;
case 'L':
setfield(L, t, "L", argv[++i]);
break;
case 'D':
setfield(L, t, "D", "");
break;
case 'W':
setfield(L, t, "W", "");
break;
case 'C':
setfield(L, t, "C", "");
break;
case 'E':
add_extra(L, argv[++i]);
break;
case 't':
setfield(L, t, "t", "");
break;
case 'q':
setfield(L, t, "q", "");
break;
default:
error(argv[i]);
break;
}
} else {
setfield(L, t, "f", argv[i]);
break;
}
}
lua_pop(L, 1);
}
#define TOLUA_SCRIPT_RUN
#ifndef TOLUA_SCRIPT_RUN
{
int tolua_tolua_open(lua_State * L);
tolua_tolua_open(L);
}
#else
{
// Take the path to the Lua sources from the last arg.
char *pkg_path = argv[argc - 1];
char full_path[1024];
strcpy(full_path, pkg_path);
strcat(full_path, "all.lua");
lua_pushstring(L, pkg_path);
lua_setglobal(L, "path");
if (luaL_loadfile(L, full_path) != 0) {
fprintf(stderr, "luaL_loadfile failed\n");
return 1;
}
if (lua_pcall(L, 0, 0, 0) != 0) {
const char *errmsg = lua_tostring(L, -1);
fprintf(stderr, "lua_pcall failed: %s\n", errmsg);
lua_pop(L, 1);
return 1;
}
}
#endif
return 0;
}

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

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

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

File diff suppressed because it is too large Load diff

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

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

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

File diff suppressed because it is too large Load diff

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

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

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

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

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

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

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

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

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

@ -0,0 +1,622 @@
/* 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 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)
{
(void)dim;
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

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

@ -0,0 +1,759 @@
/* 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, const 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 */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-value"
luaL_loadbuffer(L, B, size, name) || lua_pcall(L, 0, 0, 0);
#pragma GCC diagnostic pop
#else
lua_dobuffer(L, B, size, name);
#endif
}

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

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

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

@ -0,0 +1,137 @@
/* 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;
(void)def;
lua_pushnumber(L, index);
lua_gettable(L, lo);
v = lua_isnil(L, -1) ? 0 : lua_toboolean(L, -1);
lua_pop(L, 1);
return v;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

85
3rdparty/toluapp/src/tests/tdirectivebind.c vendored Normal file
View file

@ -0,0 +1,85 @@
/*
** Lua binding: tdirective
** Generated automatically by tolua 5.0a-CDLVS2 on 08/08/03 17:06:24.
*/
#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"
#include "tolua.h"
/* Exported function */
TOLUA_API int tolua_tdirective_open (lua_State* tolua_S);
#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;
}
/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
}
/* get function: a */
static int tolua_get_a(lua_State* tolua_S)
{
tolua_pushnumber(tolua_S,(double)a);
return 1;
}
/* set function: a */
static int tolua_set_a(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
a = ((int) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* Open function */
TOLUA_API int tolua_tdirective_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);
tolua_variable(tolua_S,"a",tolua_get_a,tolua_set_a);
{
a = 3;
}
{ /* begin embedded lua code */
static unsigned char B[] = {
10, 65, 32, 61, 32, 52,32
};
lua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code");
} /* end of embedded lua code */
{ /* begin embedded lua code */
static unsigned char B[] = {
10,102,117,110, 99,116,105,111,110, 32,102,117,110, 99, 32,
40, 41, 10,114,101,116,117,114,110, 32, 53, 10,101,110,100,
32
};
lua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code");
} /* end of embedded lua code */
tolua_endmodule(tolua_S);
return 1;
}

3
3rdparty/toluapp/src/tests/tdirectivelua.lua vendored Normal file
View file

@ -0,0 +1,3 @@
function func ()
return 5
end

2
3rdparty/toluapp/src/tests/tdirectivepkg.pkg vendored Normal file
View file

@ -0,0 +1,2 @@
extern int a;

220
3rdparty/toluapp/src/tests/tfunction.h vendored Normal file
View file

@ -0,0 +1,220 @@
#ifndef tfunction_h
#define tfunction_h
#include <stdio.h>
#include <string.h>
typedef enum {
FIRST = 1,
SECOND = 2
} Order;
class Point
{
char m_s[64];
float m_x;
float m_y;
public:
enum Error {
SUCCESS = 0,
ERROR = 1
};
Point (float x=0, float y=0)
: m_x(x), m_y(y)
{
}
virtual ~Point ()
{
}
void set (float x, float y)
{
m_x = x, m_y = y;
}
void set (float v[2]=0)
{
m_x = v[0], m_y=v[1];
}
void setpointer (Point* p)
{
*this = *p;
}
void setref (Point& p)
{
*this = p;
}
void setvalue (Point p)
{
*this = p;
}
void setconst (const Point* p)
{
*this = *p;
}
void setname (const char* s)
{
strncpy(m_s,s,63);
}
void get (float* x, float* y) const
{
*x = m_x, *y = m_y;
}
void get (float v[2]) const
{
v[0] = m_x, v[1] = m_y;
}
Point* getpointer ()
{
return this;
}
Point& getref ()
{
return *this;
}
Point getvalue ()
{
return *this;
}
const Point* getconst () const
{
return this;
}
const char* getname () const
{
return m_s;
}
Point operator+ (const Point& p) const
{
return Point(m_x+p.m_x,m_y+p.m_y);
}
Point operator- (const Point& p) const
{
return Point(m_x-p.m_x,m_y-p.m_y);
}
Point operator* (const Point& p) const
{
return Point(m_x*p.m_x,m_y*p.m_y);
}
Point operator/ (float n) const
{
return Point(m_x/n,m_y/n);
}
bool operator< (const Point& p) const
{
if (m_x < p.m_x) return true;
else if (m_x > p.m_x) return false;
else return m_y < p.m_y;
}
bool operator<= (const Point& p) const
{
return operator<(p) || operator==(p);
}
bool operator== (const Point& p) const
{
return m_x==p.m_x && m_y==p.m_y;
}
float operator[] (int i) const
{
return (i==0) ? m_x : m_y;
}
float& operator[] (int i)
{
return (i==0) ? m_x : m_y;
}
static Error echo (Error e)
{
return e;
}
};
inline Point add (const Point& p1, const Point& p2)
{
return p1+p2;
}
inline Point sub (const Point& p1, const Point& p2)
{
return p1-p2;
}
inline Point mult (const Point& p1, const Point& p2)
{
return p1*p2;
}
inline Point div (const Point& p1, float n)
{
return p1/n;
}
inline void getpoint (const Point* p, float* x, float* y)
{
p->get(x,y);
}
inline void setpoint (Point* p, float x=0, float y=0)
{
p->set(x,y);
}
inline Point average (int n, Point v[])
{
Point p(0,0);
for (int i=0; i<n; ++i)
p = p+v[i];
return p/n;
}
inline Point averagepointer (int n, Point* v[])
{
Point p(0,0);
for (int i=0; i<n; ++i)
p = p+(*v[i]);
return p/n;
}
inline void copyvector (int n, const Point v[], Point u[])
{
for (int i=0; i<n; ++i)
u[i] = v[i];
}
inline Order invert (Order o)
{
if (o==FIRST)
return SECOND;
else
return FIRST;
}
class ColorPoint : public Point //tolua_export
{ //tolua_export
float r, g, b;
public:
//tolua_begin
ColorPoint (float px, float py, float cr=0.0f, float cg=0.0f, float cb=0.0f)
: Point(px,py), r(cr), g(cg), b(cb)
{
}
virtual ~ColorPoint () { }
virtual void getcolor (float* red, float *green, float *blue) const
{
*red = r;
*green = g;
*blue = b;
}
static ColorPoint* MakeRed (float x, float y)
{
return new ColorPoint(x,y,1,0,0);
}
};
//tolua_end
#endif

104
3rdparty/toluapp/src/tests/tfunction.lua vendored Normal file
View file

@ -0,0 +1,104 @@
local p = Point:new(1,2)
local q = Point:new()
local x, y = p:get()
local c = {}; q:get(c)
assert(x==1 and y==2)
assert(c[1]==0 and c[2]==0)
q:set(4,5)
q:setname("mypoint")
p:setconst(q)
local r = p:getpointer();
x,y = r:get()
assert(x==4 and y==5)
assert(r:getname()=="mypoint")
local s = Point:new()
s:setref(r)
local t = s:getref()
t:set(5,6) -- t is s
x,y = s:get()
assert(x==5 and y==6)
local u = s:getvalue()
u:set(4,1) -- u represents a copy of s
x,y = s:get()
assert(x~=4 and y~=1)
local x1,y1 = getpoint(u)
local x2,y2 = getpoint(s)
local p1 = alg.add(u,s)
x,y = p1:get()
assert(x==x1+x2 and y==y1+y2)
local p2 = alg.sub(u,s)
x,y = p2:get()
assert(x==x1-x2 and y==y1-y2)
local p3 = alg.mult(u,s)
x,y = p3:get()
assert(x==x1*x2 and y==y1*y2)
local p4 = alg.div(s,2)
x,y = p4:get()
assert(x==x2/2 and y==y2/2)
setpoint(p4)
x,y = p4:get()
assert(x==0 and y==0)
local cp = ColorPoint:MakeRed(3,4)
local p = cp+cp
x,y = p:get()
assert(x==6 and y==8)
local q = p-cp
x,y = q:get()
assert(x==3 and y==4)
local r = p/2
x,y = r:get()
assert(x==3 and y==4)
local t = r*cp
x,y = t:get()
assert(x==9 and y==16)
assert(t==r*r)
-- assert(q==cp) -- the eq does not deal with different metatables
assert(t~=q)
assert(q<t)
assert(q<=t)
assert(t>q)
assert(t>=q)
local p = Point:new(1,2)
assert(p[1]==1 and p[2]==2)
p[1]=3; p[2] = p[2]+2
local x, y = p:get()
assert(x==3 and y==4)
local n = 3
local v = {Point:new(0,1), Point:new(2,3), Point:new(4,5)}
local m = average(n,v)
local c = averagepointer(n,v)
local t = {}
copyvector(n,v,t)
local l = Point:new()
for i=1,n do
assert(v[i]==t[i])
l[1] = l[1] + v[i][1]
l[2] = l[2] + v[i][2]
end
l = l/n
assert(m==l)
assert(c==l)
assert(Point.SUCCESS==Point:echo(Point.SUCCESS))
assert(Point.ERROR==Point:echo(Point.ERROR))
assert(FIRST==invert(SECOND))
assert(SECOND==invert(FIRST))
print("Function test OK")

74
3rdparty/toluapp/src/tests/tfunction.pkg vendored Normal file
View file

@ -0,0 +1,74 @@
$#include "tfunction.h"
typedef enum {
FIRST = 1,
SECOND = 2
} Order;
class Point
{
enum Error {
SUCCESS = 0,
ERROR = 1
};
Point (float x=0, float y=0);
virtual ~Point ();
void set (float x, float y);
void set (float v[2]=0);
void setpointer (Point* p);
void setref (Point& p);
void setvalue (Point p);
void setconst (const Point* p);
void setname (const char* s);
void get (float* x=0, float* y=0) const;
void get (float v[2]=0) const;
Point* getpointer ();
Point& getref ();
Point getvalue ();
const Point* getconst () const;
const char* getname () const;
Point operator+ (const Point& p) const;
Point operator- (const Point& p) const;
Point operator* (const Point& p) const;
Point operator/ (float n) const;
bool operator< (const Point& p) const;
bool operator<= (const Point& p) const;
bool operator== (const Point& p) const;
float operator[] (int i) const;
float& operator[] (int i);
static Error echo (Error e);
};
module alg
{
Point add (const Point& p1, const Point& p2);
Point sub (const Point& p1, const Point& p2);
Point mult (const Point& p1, const Point& p2);
Point div (const Point& p1, float n);
}
void getpoint (const Point* p, float* x=0, float* y=0);
void setpoint (Point* p, float x=0, float y=0);
inline Point average (int n, Point v[n]);
inline Point averagepointer (int n, Point* v[n]);
inline void copyvector (int n, const Point v[n], Point u[n]=(u+i));
inline Order invert (Order o);
$cfile "tfunction.h"
/*
class ColorPoint : public Point
{
ColorPoint (float px, float py, float cr=0.0f, float cg=0.0f, float cb=0.0f);
virtual ~ColorPoint ();
virtual void getcolor (float* red, float *green, float *blue) const;
static const Point* MakeRed (float x, float y);
};
*/

24
3rdparty/toluapp/src/tests/tmodule.c vendored Normal file
View file

@ -0,0 +1,24 @@
#include "lualib.h"
#include "lauxlib.h"
#include "tmodule.h"
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int main ()
{
int tolua_tmodule_open (lua_State*);
lua_State* L = lua_open();
luaopen_base(L);
tolua_tmodule_open(L);
lua_dofile(L,"tmodule.lua");
lua_close(L);
return 0;
}

7
3rdparty/toluapp/src/tests/tmodule.h vendored Normal file
View file

@ -0,0 +1,7 @@
#include <stdio.h>
extern int a;
extern int b;
extern int c;
extern int d;

17
3rdparty/toluapp/src/tests/tmodule.lua vendored Normal file
View file

@ -0,0 +1,17 @@
-- test valid access
assert(A.a==1)
assert(A.B.b==2)
assert(A.B.C.c==3)
-- test invalid access
assert(A.B.a==nil) -- no inheritance
assert(A.B.C.a==nil)
assert(A.b==nil) -- no access the inner module
assert(A.c==nil)
assert(A.B.c==nil)
-- test variables appended to existing modules
assert(A.d==4)
print("Module test OK")

16
3rdparty/toluapp/src/tests/tmodule.pkg vendored Normal file
View file

@ -0,0 +1,16 @@
$#include "tmodule.h"
module A {
extern int a;
module B {
extern int b;
module C {
extern int c;
}
}
}
module A {
extern int d;
}

124
3rdparty/toluapp/src/tests/tmodulebind.c vendored Normal file
View file

@ -0,0 +1,124 @@
/*
** Lua binding: tmodule
** Generated automatically by tolua 5.0a-CDLVS2 on 08/08/03 17:06:13.
*/
#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"
#include "tolua.h"
/* Exported function */
TOLUA_API int tolua_tmodule_open (lua_State* tolua_S);
#include "tmodule.h"
/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
}
/* get function: a */
static int tolua_get_A_a(lua_State* tolua_S)
{
tolua_pushnumber(tolua_S,(double)a);
return 1;
}
/* set function: a */
static int tolua_set_A_a(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
a = ((int) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: b */
static int tolua_get_B_b(lua_State* tolua_S)
{
tolua_pushnumber(tolua_S,(double)b);
return 1;
}
/* set function: b */
static int tolua_set_B_b(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
b = ((int) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: c */
static int tolua_get_C_c(lua_State* tolua_S)
{
tolua_pushnumber(tolua_S,(double)c);
return 1;
}
/* set function: c */
static int tolua_set_C_c(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
c = ((int) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: d */
static int tolua_get_A_d(lua_State* tolua_S)
{
tolua_pushnumber(tolua_S,(double)d);
return 1;
}
/* set function: d */
static int tolua_set_A_d(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
d = ((int) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* Open function */
TOLUA_API int tolua_tmodule_open (lua_State* tolua_S)
{
tolua_open(tolua_S);
tolua_reg_types(tolua_S);
tolua_module(tolua_S,NULL,0);
tolua_beginmodule(tolua_S,NULL);
tolua_module(tolua_S,"A",1);
tolua_beginmodule(tolua_S,"A");
tolua_variable(tolua_S,"a",tolua_get_A_a,tolua_set_A_a);
tolua_module(tolua_S,"B",1);
tolua_beginmodule(tolua_S,"B");
tolua_variable(tolua_S,"b",tolua_get_B_b,tolua_set_B_b);
tolua_module(tolua_S,"C",1);
tolua_beginmodule(tolua_S,"C");
tolua_variable(tolua_S,"c",tolua_get_C_c,tolua_set_C_c);
tolua_endmodule(tolua_S);
tolua_endmodule(tolua_S);
tolua_endmodule(tolua_S);
tolua_module(tolua_S,"A",1);
tolua_beginmodule(tolua_S,"A");
tolua_variable(tolua_S,"d",tolua_get_A_d,tolua_set_A_d);
tolua_endmodule(tolua_S);
tolua_endmodule(tolua_S);
return 1;
}

11
3rdparty/toluapp/src/tests/tnamespace.h vendored Normal file
View file

@ -0,0 +1,11 @@
namespace A {
enum {FIRST=1};
extern int a;
namespace B {
extern int b;
namespace C {
extern int c;
}
}
}

14
3rdparty/toluapp/src/tests/tnamespace.lua vendored Normal file
View file

@ -0,0 +1,14 @@
-- test valid access
assert(A.a==1)
assert(A.B.b==2)
assert(A.B.C.c==3)
-- test invalid access
assert(A.B.a==nil) -- no inheritance
assert(A.B.C.a==nil)
assert(A.b==nil) -- no access the inner module
assert(A.c==nil)
assert(A.B.c==nil)
print("Namespace test OK")

13
3rdparty/toluapp/src/tests/tnamespace.pkg vendored Normal file
View file

@ -0,0 +1,13 @@
$#include "tnamespace.h"
namespace A {
int a;
namespace B {
int b;
namespace C {
int c;
}
}
}

46
3rdparty/toluapp/src/tests/tvariable.c vendored Normal file
View file

@ -0,0 +1,46 @@
#include "lualib.h"
#include "lauxlib.h"
#include "tvariable.h"
int i = 1;
float f = 2.0f;;
double d = 3.0;
char* s = "Hello world";
void* v = (void*)1;
char n[64] = "Hi there";
A a = {11,12.0f,13.0,"Hello world from class",(void*)1,"Hi there from class"};
B* b;
U u;
int mi = 21;
float mf = 22.0f;
double md = 23.0;
char* ms = "Hello world in module";
void* mv = NULL;
char mn[64] = "Hi there in module";
A ma = {31,32.0f,33.0,"Hello world from class in module",
NULL,"Hi there from class in module"};
B* mb;
int main (void)
{
int tolua_tvariable_open (lua_State*);
lua_State* L = lua_open();
B bb = {a,NULL};
B bbb = {ma,&bb};
b = &bb;
mb = &bbb;
luaopen_base(L);
tolua_tvariable_open(L);
lua_dofile(L,"tvariable.lua");
lua_close(L);
return 0;
}

44
3rdparty/toluapp/src/tests/tvariable.h vendored Normal file
View file

@ -0,0 +1,44 @@
typedef struct A A;
typedef struct B B;
typedef union U U;
struct A
{
int i;
float f;
double d;
char* s;
void* v;
char n[64];
};
union U
{
int i;
float f;
};
struct B
{
A a;
B* b;
};
extern int i;
extern float f;
extern double d;
extern char* s;
extern void* v;
extern char n[64];
extern A a;
extern B* b;
extern U u;
extern int mi;
extern float mf;
extern double md;
extern char* ms;
extern void* mv;
extern char mn[64];
extern A ma;
extern B* mb;

73
3rdparty/toluapp/src/tests/tvariable.lua vendored Normal file
View file

@ -0,0 +1,73 @@
assert(i==1)
assert(f==2)
assert(d==3)
assert(s=="Hello world")
assert(n=="Hi there")
n = "Hello"
assert(n=="Hello")
assert(a.i==11)
assert(a.f==12)
assert(a.d==13)
assert(a.s=="Hello world from class")
assert(a.n=="Hi there from class")
a.n = "Hello from class"
assert(a.n=="Hello from class")
assert(v==a.v)
u.i = 2
assert(u.i==2)
u.f = 2
assert(u.f==2)
assert(u.i~=2)
assert(M.mi==21)
assert(M.mf==22)
assert(M.md==23)
assert(M.ms=="Hello world in module")
assert(M.mn=="Hi there in module")
M.mn = "Hello in module"
assert(M.mn=="Hello in module")
assert(M.mv==nil)
assert(M.ma.i==31)
assert(M.ma.f==32)
assert(M.ma.d==33)
assert(M.ma.s=="Hello world from class in module")
assert(M.ma.n=="Hi there from class in module")
M.ma.n = "Hello from class in module"
assert(M.ma.n=="Hello from class in module")
assert(M.ma.v==nil)
assert(a.i==b.a.i)
assert(a.f==b.a.f)
assert(a.d==b.a.d)
assert(a.s==b.a.s)
assert(a.v==b.a.v)
assert(b.b==nil)
assert(M.ma.i==M.mb.a.i)
assert(M.ma.f==M.mb.a.f)
assert(M.ma.d==M.mb.a.d)
assert(M.ma.s==M.mb.a.s)
assert(M.ma.v==M.mb.a.v)
assert(a.i==M.mb.b.a.i)
assert(a.f==M.mb.b.a.f)
assert(a.d==M.mb.b.a.d)
assert(a.s==M.mb.b.a.s)
assert(a.v==M.mb.b.a.v)
assert(M.mb.b.b==nil)
assert(s~=rawget(_G,"s")) -- because s represents a C variable
s = "Hello"
assert(s==rawget(_G,"s")) -- because s is mapped as const
f = 25.0
assert(f~=rawget(_G,"f")) -- because f represents a C variable
b.a.i = 5
assert(b.a.i==M.mb.b.a.i)
print("Variable test OK")

45
3rdparty/toluapp/src/tests/tvariable.pkg vendored Normal file
View file

@ -0,0 +1,45 @@
$#include "tvariable.h"
struct A
{
int i;
float f;
double d;
char* s;
void* v;
char n[64];
};
struct B
{
A a;
B* b;
};
union U
{
int i;
float f;
};
extern int i;
extern float f;
extern double d;
extern const char* s;
extern void* v;
extern char n[64];
extern A a;
extern B* b;
extern U u;
module M {
extern int mi;
extern float mf;
extern double md;
extern const char* ms;
extern void* mv;
extern const char mn[64];
extern A a;
extern A ma;
extern B* mb;
}

631
3rdparty/toluapp/src/tests/tvariablebind.c vendored Normal file
View file

@ -0,0 +1,631 @@
/*
** Lua binding: tvariable
** Generated automatically by tolua 5.0a-CDLVS2 on 08/08/03 17:06:18.
*/
#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"
#include "tolua.h"
/* Exported function */
TOLUA_API int tolua_tvariable_open (lua_State* tolua_S);
#include "tvariable.h"
/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
tolua_usertype(tolua_S,"A");
tolua_usertype(tolua_S,"U");
tolua_usertype(tolua_S,"B");
}
/* get function: i of class A */
static int tolua_get_A_i(lua_State* tolua_S)
{
A* self = (A*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'i'",NULL);
#endif
tolua_pushnumber(tolua_S,(double)self->i);
return 1;
}
/* set function: i of class A */
static int tolua_set_A_i(lua_State* tolua_S)
{
A* self = (A*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'i'",NULL);
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
self->i = ((int) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: f of class A */
static int tolua_get_A_f(lua_State* tolua_S)
{
A* self = (A*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'f'",NULL);
#endif
tolua_pushnumber(tolua_S,(double)self->f);
return 1;
}
/* set function: f of class A */
static int tolua_set_A_f(lua_State* tolua_S)
{
A* self = (A*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'f'",NULL);
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
self->f = ((float) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: d of class A */
static int tolua_get_A_d(lua_State* tolua_S)
{
A* self = (A*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd'",NULL);
#endif
tolua_pushnumber(tolua_S,(double)self->d);
return 1;
}
/* set function: d of class A */
static int tolua_set_A_d(lua_State* tolua_S)
{
A* self = (A*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd'",NULL);
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
self->d = ((double) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: s of class A */
static int tolua_get_A_s(lua_State* tolua_S)
{
A* self = (A*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 's'",NULL);
#endif
tolua_pushstring(tolua_S,(const char*)self->s);
return 1;
}
/* set function: s of class A */
static int tolua_set_A_s(lua_State* tolua_S)
{
A* self = (A*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 's'",NULL);
if (!tolua_isstring(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
self->s = ((char*) tolua_tostring(tolua_S,2,0));
return 0;
}
/* get function: v of class A */
static int tolua_get_A_v(lua_State* tolua_S)
{
A* self = (A*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'v'",NULL);
#endif
tolua_pushuserdata(tolua_S,(void*)self->v);
return 1;
}
/* set function: v of class A */
static int tolua_set_A_v(lua_State* tolua_S)
{
A* self = (A*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'v'",NULL);
if (!tolua_isuserdata(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
self->v = ((void*) tolua_touserdata(tolua_S,2,0));
return 0;
}
/* get function: n of class A */
static int tolua_get_A_n(lua_State* tolua_S)
{
A* self = (A*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'n'",NULL);
#endif
tolua_pushstring(tolua_S,(const char*)self->n);
return 1;
}
/* set function: n of class A */
static int tolua_set_A_n(lua_State* tolua_S)
{
A* self = (A*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'n'",NULL);
if (!tolua_isstring(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
strncpy(self->n,tolua_tostring(tolua_S,2,0),64-1);
return 0;
}
/* get function: a of class B */
static int tolua_get_B_a(lua_State* tolua_S)
{
B* self = (B*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'a'",NULL);
#endif
tolua_pushusertype(tolua_S,(void*)&self->a,"A");
return 1;
}
/* set function: a of class B */
static int tolua_set_B_a(lua_State* tolua_S)
{
B* self = (B*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'a'",NULL);
if (!tolua_isusertype(tolua_S,2,"A",0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
self->a = *((A*) tolua_tousertype(tolua_S,2,0));
return 0;
}
/* get function: b of class B */
static int tolua_get_B_b_ptr(lua_State* tolua_S)
{
B* self = (B*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'b'",NULL);
#endif
tolua_pushusertype(tolua_S,(void*)self->b,"B");
return 1;
}
/* set function: b of class B */
static int tolua_set_B_b_ptr(lua_State* tolua_S)
{
B* self = (B*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'b'",NULL);
if (!tolua_isusertype(tolua_S,2,"B",0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
self->b = ((B*) tolua_tousertype(tolua_S,2,0));
return 0;
}
/* get function: i of class U */
static int tolua_get_U_i(lua_State* tolua_S)
{
U* self = (U*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'i'",NULL);
#endif
tolua_pushnumber(tolua_S,(double)self->i);
return 1;
}
/* set function: i of class U */
static int tolua_set_U_i(lua_State* tolua_S)
{
U* self = (U*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'i'",NULL);
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
self->i = ((int) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: f of class U */
static int tolua_get_U_f(lua_State* tolua_S)
{
U* self = (U*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'f'",NULL);
#endif
tolua_pushnumber(tolua_S,(double)self->f);
return 1;
}
/* set function: f of class U */
static int tolua_set_U_f(lua_State* tolua_S)
{
U* self = (U*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'f'",NULL);
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
self->f = ((float) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: i */
static int tolua_get_i(lua_State* tolua_S)
{
tolua_pushnumber(tolua_S,(double)i);
return 1;
}
/* set function: i */
static int tolua_set_i(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
i = ((int) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: f */
static int tolua_get_f(lua_State* tolua_S)
{
tolua_pushnumber(tolua_S,(double)f);
return 1;
}
/* set function: f */
static int tolua_set_f(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
f = ((float) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: d */
static int tolua_get_d(lua_State* tolua_S)
{
tolua_pushnumber(tolua_S,(double)d);
return 1;
}
/* set function: d */
static int tolua_set_d(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
d = ((double) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: s */
static int tolua_get_s(lua_State* tolua_S)
{
tolua_pushstring(tolua_S,(const char*)s);
return 1;
}
/* get function: v */
static int tolua_get_v(lua_State* tolua_S)
{
tolua_pushuserdata(tolua_S,(void*)v);
return 1;
}
/* set function: v */
static int tolua_set_v(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isuserdata(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
v = ((void*) tolua_touserdata(tolua_S,2,0));
return 0;
}
/* get function: n */
static int tolua_get_n(lua_State* tolua_S)
{
tolua_pushstring(tolua_S,(const char*)n);
return 1;
}
/* set function: n */
static int tolua_set_n(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isstring(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
strncpy(n,tolua_tostring(tolua_S,2,0),64-1);
return 0;
}
/* get function: a */
static int tolua_get_a(lua_State* tolua_S)
{
tolua_pushusertype(tolua_S,(void*)&a,"A");
return 1;
}
/* set function: a */
static int tolua_set_a(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isusertype(tolua_S,2,"A",0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
a = *((A*) tolua_tousertype(tolua_S,2,0));
return 0;
}
/* get function: b */
static int tolua_get_b_ptr(lua_State* tolua_S)
{
tolua_pushusertype(tolua_S,(void*)b,"B");
return 1;
}
/* set function: b */
static int tolua_set_b_ptr(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isusertype(tolua_S,2,"B",0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
b = ((B*) tolua_tousertype(tolua_S,2,0));
return 0;
}
/* get function: u */
static int tolua_get_u(lua_State* tolua_S)
{
tolua_pushusertype(tolua_S,(void*)&u,"U");
return 1;
}
/* set function: u */
static int tolua_set_u(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isusertype(tolua_S,2,"U",0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
u = *((U*) tolua_tousertype(tolua_S,2,0));
return 0;
}
/* get function: mi */
static int tolua_get_M_mi(lua_State* tolua_S)
{
tolua_pushnumber(tolua_S,(double)mi);
return 1;
}
/* set function: mi */
static int tolua_set_M_mi(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
mi = ((int) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: mf */
static int tolua_get_M_mf(lua_State* tolua_S)
{
tolua_pushnumber(tolua_S,(double)mf);
return 1;
}
/* set function: mf */
static int tolua_set_M_mf(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
mf = ((float) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: md */
static int tolua_get_M_md(lua_State* tolua_S)
{
tolua_pushnumber(tolua_S,(double)md);
return 1;
}
/* set function: md */
static int tolua_set_M_md(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
md = ((double) tolua_tonumber(tolua_S,2,0));
return 0;
}
/* get function: ms */
static int tolua_get_M_ms(lua_State* tolua_S)
{
tolua_pushstring(tolua_S,(const char*)ms);
return 1;
}
/* get function: mv */
static int tolua_get_M_mv(lua_State* tolua_S)
{
tolua_pushuserdata(tolua_S,(void*)mv);
return 1;
}
/* set function: mv */
static int tolua_set_M_mv(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isuserdata(tolua_S,2,0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
mv = ((void*) tolua_touserdata(tolua_S,2,0));
return 0;
}
/* get function: mn */
static int tolua_get_M_mn(lua_State* tolua_S)
{
tolua_pushstring(tolua_S,(const char*)mn);
return 1;
}
/* get function: a */
static int tolua_get_M_a(lua_State* tolua_S)
{
tolua_pushusertype(tolua_S,(void*)&a,"A");
return 1;
}
/* set function: a */
static int tolua_set_M_a(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isusertype(tolua_S,2,"A",0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
a = *((A*) tolua_tousertype(tolua_S,2,0));
return 0;
}
/* get function: ma */
static int tolua_get_M_ma(lua_State* tolua_S)
{
tolua_pushusertype(tolua_S,(void*)&ma,"A");
return 1;
}
/* set function: ma */
static int tolua_set_M_ma(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isusertype(tolua_S,2,"A",0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
ma = *((A*) tolua_tousertype(tolua_S,2,0));
return 0;
}
/* get function: mb */
static int tolua_get_M_mb_ptr(lua_State* tolua_S)
{
tolua_pushusertype(tolua_S,(void*)mb,"B");
return 1;
}
/* set function: mb */
static int tolua_set_M_mb_ptr(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (!tolua_isusertype(tolua_S,2,"B",0,&tolua_err))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
mb = ((B*) tolua_tousertype(tolua_S,2,0));
return 0;
}
/* Open function */
TOLUA_API int tolua_tvariable_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);
tolua_cclass(tolua_S,"A","A","",NULL);
tolua_beginmodule(tolua_S,"A");
tolua_variable(tolua_S,"i",tolua_get_A_i,tolua_set_A_i);
tolua_variable(tolua_S,"f",tolua_get_A_f,tolua_set_A_f);
tolua_variable(tolua_S,"d",tolua_get_A_d,tolua_set_A_d);
tolua_variable(tolua_S,"s",tolua_get_A_s,tolua_set_A_s);
tolua_variable(tolua_S,"v",tolua_get_A_v,tolua_set_A_v);
tolua_variable(tolua_S,"n",tolua_get_A_n,tolua_set_A_n);
tolua_endmodule(tolua_S);
tolua_cclass(tolua_S,"B","B","",NULL);
tolua_beginmodule(tolua_S,"B");
tolua_variable(tolua_S,"a",tolua_get_B_a,tolua_set_B_a);
tolua_variable(tolua_S,"b",tolua_get_B_b_ptr,tolua_set_B_b_ptr);
tolua_endmodule(tolua_S);
tolua_cclass(tolua_S,"U","U","",NULL);
tolua_beginmodule(tolua_S,"U");
tolua_variable(tolua_S,"i",tolua_get_U_i,tolua_set_U_i);
tolua_variable(tolua_S,"f",tolua_get_U_f,tolua_set_U_f);
tolua_endmodule(tolua_S);
tolua_variable(tolua_S,"i",tolua_get_i,tolua_set_i);
tolua_variable(tolua_S,"f",tolua_get_f,tolua_set_f);
tolua_variable(tolua_S,"d",tolua_get_d,tolua_set_d);
tolua_variable(tolua_S,"s",tolua_get_s,NULL);
tolua_variable(tolua_S,"v",tolua_get_v,tolua_set_v);
tolua_variable(tolua_S,"n",tolua_get_n,tolua_set_n);
tolua_variable(tolua_S,"a",tolua_get_a,tolua_set_a);
tolua_variable(tolua_S,"b",tolua_get_b_ptr,tolua_set_b_ptr);
tolua_variable(tolua_S,"u",tolua_get_u,tolua_set_u);
tolua_module(tolua_S,"M",1);
tolua_beginmodule(tolua_S,"M");
tolua_variable(tolua_S,"mi",tolua_get_M_mi,tolua_set_M_mi);
tolua_variable(tolua_S,"mf",tolua_get_M_mf,tolua_set_M_mf);
tolua_variable(tolua_S,"md",tolua_get_M_md,tolua_set_M_md);
tolua_variable(tolua_S,"ms",tolua_get_M_ms,NULL);
tolua_variable(tolua_S,"mv",tolua_get_M_mv,tolua_set_M_mv);
tolua_variable(tolua_S,"mn",tolua_get_M_mn,NULL);
tolua_variable(tolua_S,"a",tolua_get_M_a,tolua_set_M_a);
tolua_variable(tolua_S,"ma",tolua_get_M_ma,tolua_set_M_ma);
tolua_variable(tolua_S,"mb",tolua_get_M_mb_ptr,tolua_set_M_mb_ptr);
tolua_endmodule(tolua_S);
tolua_endmodule(tolua_S);
return 1;
}