From 60d76a58de0e41e87dabb11b35b737696982b83a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Steffen=20F=C3=BCndgens?= Date: Fri, 9 Jan 2015 16:51:28 +0100 Subject: [PATCH] Integrated Lua into our project. Triggers are now able to call a Lua Script. Havent figured out how to let the Script do anything usefull yet. --- CMakeLists.txt | 16 +- Levels/scripts/Level1/deleteRandomObject.lua | 10 + extern/lua/README | 6 + extern/lua/doc/contents.html | 533 + extern/lua/doc/logo.gif | Bin 0 -> 4232 bytes extern/lua/doc/lua.1 | 116 + extern/lua/doc/lua.css | 96 + extern/lua/doc/luac.1 | 118 + extern/lua/doc/manual.css | 27 + extern/lua/doc/manual.html | 10507 +++++++++++++++++ extern/lua/doc/osi-certified-72x60.png | Bin 0 -> 3774 bytes extern/lua/doc/readme.html | 413 + extern/lua/src/lapi.c | 1284 ++ extern/lua/src/lapi.h | 24 + extern/lua/src/lapi.o | Bin 0 -> 22792 bytes extern/lua/src/lauxlib.c | 959 ++ extern/lua/src/lauxlib.h | 212 + extern/lua/src/lauxlib.o | Bin 0 -> 27248 bytes extern/lua/src/lbaselib.c | 458 + extern/lua/src/lbaselib.o | Bin 0 -> 18624 bytes extern/lua/src/lbitlib.c | 212 + extern/lua/src/lbitlib.o | Bin 0 -> 6960 bytes extern/lua/src/lcode.c | 881 ++ extern/lua/src/lcode.h | 83 + extern/lua/src/lcode.o | Bin 0 -> 17664 bytes extern/lua/src/lcorolib.c | 155 + extern/lua/src/lcorolib.o | Bin 0 -> 6496 bytes extern/lua/src/lctype.c | 52 + extern/lua/src/lctype.h | 95 + extern/lua/src/lctype.o | Bin 0 -> 1310 bytes extern/lua/src/ldblib.c | 398 + extern/lua/src/ldblib.o | Bin 0 -> 17048 bytes extern/lua/src/ldebug.c | 593 + extern/lua/src/ldebug.h | 34 + extern/lua/src/ldebug.o | Bin 0 -> 12968 bytes extern/lua/src/ldo.c | 681 ++ extern/lua/src/ldo.h | 46 + extern/lua/src/ldo.o | Bin 0 -> 10768 bytes extern/lua/src/ldump.c | 173 + extern/lua/src/ldump.o | Bin 0 -> 3536 bytes extern/lua/src/lfunc.c | 161 + extern/lua/src/lfunc.h | 33 + extern/lua/src/lfunc.o | Bin 0 -> 3632 bytes extern/lua/src/lgc.c | 1220 ++ extern/lua/src/lgc.h | 157 + extern/lua/src/lgc.o | Bin 0 -> 17720 bytes extern/lua/src/liblua.a | Bin 0 -> 384420 bytes extern/lua/src/linit.c | 67 + extern/lua/src/linit.o | Bin 0 -> 3200 bytes extern/lua/src/liolib.c | 666 ++ extern/lua/src/liolib.o | Bin 0 -> 19896 bytes extern/lua/src/llex.c | 530 + extern/lua/src/llex.h | 78 + extern/lua/src/llex.o | Bin 0 -> 20848 bytes extern/lua/src/llimits.h | 309 + extern/lua/src/lmathlib.c | 279 + extern/lua/src/lmathlib.o | Bin 0 -> 13128 bytes extern/lua/src/lmem.c | 99 + extern/lua/src/lmem.h | 57 + extern/lua/src/lmem.o | Bin 0 -> 2480 bytes extern/lua/src/loadlib.c | 725 ++ extern/lua/src/loadlib.o | Bin 0 -> 16944 bytes extern/lua/src/lobject.c | 287 + extern/lua/src/lobject.h | 607 + extern/lua/src/lobject.o | Bin 0 -> 6512 bytes extern/lua/src/lopcodes.c | 107 + extern/lua/src/lopcodes.h | 288 + extern/lua/src/lopcodes.o | Bin 0 -> 2880 bytes extern/lua/src/loslib.c | 323 + extern/lua/src/loslib.o | Bin 0 -> 11384 bytes extern/lua/src/lparser.c | 1638 +++ extern/lua/src/lparser.h | 119 + extern/lua/src/lparser.o | Bin 0 -> 26776 bytes extern/lua/src/lstate.c | 323 + extern/lua/src/lstate.h | 228 + extern/lua/src/lstate.o | Bin 0 -> 5504 bytes extern/lua/src/lstring.c | 185 + extern/lua/src/lstring.h | 46 + extern/lua/src/lstring.o | Bin 0 -> 3736 bytes extern/lua/src/lstrlib.c | 1019 ++ extern/lua/src/lstrlib.o | Bin 0 -> 25192 bytes extern/lua/src/ltable.c | 588 + extern/lua/src/ltable.h | 45 + extern/lua/src/ltable.o | Bin 0 -> 9744 bytes extern/lua/src/ltablib.c | 283 + extern/lua/src/ltablib.o | Bin 0 -> 10280 bytes extern/lua/src/ltm.c | 77 + extern/lua/src/ltm.h | 57 + extern/lua/src/ltm.o | Bin 0 -> 3648 bytes extern/lua/src/lua | Bin 0 -> 223339 bytes extern/lua/src/lua.c | 497 + extern/lua/src/lua.h | 444 + extern/lua/src/lua.hpp | 9 + extern/lua/src/lua.o | Bin 0 -> 13816 bytes extern/lua/src/luac | Bin 0 -> 153265 bytes extern/lua/src/luac.c | 432 + extern/lua/src/luac.o | Bin 0 -> 18904 bytes extern/lua/src/luaconf.h | 551 + extern/lua/src/lualib.h | 55 + extern/lua/src/lundump.c | 258 + extern/lua/src/lundump.h | 28 + extern/lua/src/lundump.o | Bin 0 -> 5216 bytes extern/lua/src/lvm.c | 867 ++ extern/lua/src/lvm.h | 44 + extern/lua/src/lvm.o | Bin 0 -> 20840 bytes extern/lua/src/lzio.c | 76 + extern/lua/src/lzio.h | 65 + extern/lua/src/lzio.o | Bin 0 -> 2280 bytes extern/luabridge/LuaBridge.h | 142 + extern/luabridge/RefCountedObject.h | 363 + extern/luabridge/RefCountedPtr.h | 251 + extern/luabridge/detail/CFunctions.h | 442 + extern/luabridge/detail/ClassInfo.h | 73 + extern/luabridge/detail/Constructor.h | 204 + extern/luabridge/detail/FuncTraits.h | 852 ++ extern/luabridge/detail/Iterator.h | 114 + extern/luabridge/detail/LuaException.h | 113 + extern/luabridge/detail/LuaHelpers.h | 143 + extern/luabridge/detail/LuaRef.h | 1215 ++ extern/luabridge/detail/Namespace.h | 1136 ++ extern/luabridge/detail/Stack.h | 469 + extern/luabridge/detail/TypeList.h | 174 + extern/luabridge/detail/TypeTraits.h | 125 + extern/luabridge/detail/Userdata.h | 817 ++ extern/luabridge/detail/dump.h | 28 + level.cc | 28 +- trigger.cc | 27 +- trigger.hh | 10 +- 128 files changed, 38824 insertions(+), 11 deletions(-) create mode 100644 Levels/scripts/Level1/deleteRandomObject.lua create mode 100644 extern/lua/README create mode 100644 extern/lua/doc/contents.html create mode 100644 extern/lua/doc/logo.gif create mode 100644 extern/lua/doc/lua.1 create mode 100644 extern/lua/doc/lua.css create mode 100644 extern/lua/doc/luac.1 create mode 100644 extern/lua/doc/manual.css create mode 100644 extern/lua/doc/manual.html create mode 100644 extern/lua/doc/osi-certified-72x60.png create mode 100644 extern/lua/doc/readme.html create mode 100644 extern/lua/src/lapi.c create mode 100644 extern/lua/src/lapi.h create mode 100644 extern/lua/src/lapi.o create mode 100644 extern/lua/src/lauxlib.c create mode 100644 extern/lua/src/lauxlib.h create mode 100644 extern/lua/src/lauxlib.o create mode 100644 extern/lua/src/lbaselib.c create mode 100644 extern/lua/src/lbaselib.o create mode 100644 extern/lua/src/lbitlib.c create mode 100644 extern/lua/src/lbitlib.o create mode 100644 extern/lua/src/lcode.c create mode 100644 extern/lua/src/lcode.h create mode 100644 extern/lua/src/lcode.o create mode 100644 extern/lua/src/lcorolib.c create mode 100644 extern/lua/src/lcorolib.o create mode 100644 extern/lua/src/lctype.c create mode 100644 extern/lua/src/lctype.h create mode 100644 extern/lua/src/lctype.o create mode 100644 extern/lua/src/ldblib.c create mode 100644 extern/lua/src/ldblib.o create mode 100644 extern/lua/src/ldebug.c create mode 100644 extern/lua/src/ldebug.h create mode 100644 extern/lua/src/ldebug.o create mode 100644 extern/lua/src/ldo.c create mode 100644 extern/lua/src/ldo.h create mode 100644 extern/lua/src/ldo.o create mode 100644 extern/lua/src/ldump.c create mode 100644 extern/lua/src/ldump.o create mode 100644 extern/lua/src/lfunc.c create mode 100644 extern/lua/src/lfunc.h create mode 100644 extern/lua/src/lfunc.o create mode 100644 extern/lua/src/lgc.c create mode 100644 extern/lua/src/lgc.h create mode 100644 extern/lua/src/lgc.o create mode 100644 extern/lua/src/liblua.a create mode 100644 extern/lua/src/linit.c create mode 100644 extern/lua/src/linit.o create mode 100644 extern/lua/src/liolib.c create mode 100644 extern/lua/src/liolib.o create mode 100644 extern/lua/src/llex.c create mode 100644 extern/lua/src/llex.h create mode 100644 extern/lua/src/llex.o create mode 100644 extern/lua/src/llimits.h create mode 100644 extern/lua/src/lmathlib.c create mode 100644 extern/lua/src/lmathlib.o create mode 100644 extern/lua/src/lmem.c create mode 100644 extern/lua/src/lmem.h create mode 100644 extern/lua/src/lmem.o create mode 100644 extern/lua/src/loadlib.c create mode 100644 extern/lua/src/loadlib.o create mode 100644 extern/lua/src/lobject.c create mode 100644 extern/lua/src/lobject.h create mode 100644 extern/lua/src/lobject.o create mode 100644 extern/lua/src/lopcodes.c create mode 100644 extern/lua/src/lopcodes.h create mode 100644 extern/lua/src/lopcodes.o create mode 100644 extern/lua/src/loslib.c create mode 100644 extern/lua/src/loslib.o create mode 100644 extern/lua/src/lparser.c create mode 100644 extern/lua/src/lparser.h create mode 100644 extern/lua/src/lparser.o create mode 100644 extern/lua/src/lstate.c create mode 100644 extern/lua/src/lstate.h create mode 100644 extern/lua/src/lstate.o create mode 100644 extern/lua/src/lstring.c create mode 100644 extern/lua/src/lstring.h create mode 100644 extern/lua/src/lstring.o create mode 100644 extern/lua/src/lstrlib.c create mode 100644 extern/lua/src/lstrlib.o create mode 100644 extern/lua/src/ltable.c create mode 100644 extern/lua/src/ltable.h create mode 100644 extern/lua/src/ltable.o create mode 100644 extern/lua/src/ltablib.c create mode 100644 extern/lua/src/ltablib.o create mode 100644 extern/lua/src/ltm.c create mode 100644 extern/lua/src/ltm.h create mode 100644 extern/lua/src/ltm.o create mode 100755 extern/lua/src/lua create mode 100644 extern/lua/src/lua.c create mode 100644 extern/lua/src/lua.h create mode 100644 extern/lua/src/lua.hpp create mode 100644 extern/lua/src/lua.o create mode 100755 extern/lua/src/luac create mode 100644 extern/lua/src/luac.c create mode 100644 extern/lua/src/luac.o create mode 100644 extern/lua/src/luaconf.h create mode 100644 extern/lua/src/lualib.h create mode 100644 extern/lua/src/lundump.c create mode 100644 extern/lua/src/lundump.h create mode 100644 extern/lua/src/lundump.o create mode 100644 extern/lua/src/lvm.c create mode 100644 extern/lua/src/lvm.h create mode 100644 extern/lua/src/lvm.o create mode 100644 extern/lua/src/lzio.c create mode 100644 extern/lua/src/lzio.h create mode 100644 extern/lua/src/lzio.o create mode 100644 extern/luabridge/LuaBridge.h create mode 100644 extern/luabridge/RefCountedObject.h create mode 100644 extern/luabridge/RefCountedPtr.h create mode 100644 extern/luabridge/detail/CFunctions.h create mode 100644 extern/luabridge/detail/ClassInfo.h create mode 100644 extern/luabridge/detail/Constructor.h create mode 100644 extern/luabridge/detail/FuncTraits.h create mode 100644 extern/luabridge/detail/Iterator.h create mode 100644 extern/luabridge/detail/LuaException.h create mode 100644 extern/luabridge/detail/LuaHelpers.h create mode 100644 extern/luabridge/detail/LuaRef.h create mode 100644 extern/luabridge/detail/Namespace.h create mode 100644 extern/luabridge/detail/Stack.h create mode 100644 extern/luabridge/detail/TypeList.h create mode 100644 extern/luabridge/detail/TypeTraits.h create mode 100644 extern/luabridge/detail/Userdata.h create mode 100644 extern/luabridge/detail/dump.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 6d051df..c6c779f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -106,7 +106,7 @@ ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") # Linux: # IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux") - SET(LIBRARIES ${LIBRARIES} -lXrandr -lGL -lXi -pthread -lm -lX11 -lXxf86vm) + SET(LIBRARIES ${LIBRARIES} -lXrandr -lGL -lXi -pthread -lm -lX11 -lXxf86vm -ldl) ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "Linux") # # @@ -131,6 +131,20 @@ else() SET (LIBRARIES ${LIBRARIES} ${CMAKE_SOURCE_DIR}/extern/bullet/build/src/BulletSoftBody/libBulletSoftBody.a) endif() +# Include Lua + +FILE(GLOB_RECURSE HEADER_FILES_LUA ${CMAKE_SOURCE_DIR}/extern/lua/src/*.h) + +INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/extern/lua/src) +SET(HEADER_FILES ${HEADER_FILES} ${HEADER_FILES_LUA}) + +FILE(GLOB_RECURSE HEADER_FILES_LUA_BRIDGE ${CMAKE_SOURCE_DIR}/extern/luabridge/*.h) + +INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/extern/luabridge) +SET(HEADER_FILES ${HEADER_FILES} ${HEADER_FILES_LUA_BRIDGE}) + +SET (LIBRARIES ${LIBRARIES} ${CMAKE_SOURCE_DIR}/extern/lua/src/liblua.a) + ADD_EXECUTABLE(MarbleRaceGroupC ${SOURCE_FILES} ${HEADER_FILES} ${SHADER_FILES} ${README_FILES}) TARGET_LINK_LIBRARIES(MarbleRaceGroupC ${LIBRARIES}) diff --git a/Levels/scripts/Level1/deleteRandomObject.lua b/Levels/scripts/Level1/deleteRandomObject.lua new file mode 100644 index 0000000..b24c44d --- /dev/null +++ b/Levels/scripts/Level1/deleteRandomObject.lua @@ -0,0 +1,10 @@ +function trigger() + print("Hello from Lua!") + if(not Level) then + print("No Level found!") + return + end + --a = table.getn(Level.getObjects()) + --rand = math.random(0, table.getn(Level->getObjects()) - 1) + --Level->getObjects()->erase(level->getObjects()->begin() + rand) +end diff --git a/extern/lua/README b/extern/lua/README new file mode 100644 index 0000000..49033ad --- /dev/null +++ b/extern/lua/README @@ -0,0 +1,6 @@ + +This is Lua 5.2.3, released on 11 Nov 2013. + +For installation instructions, license details, and +further information about Lua, see doc/readme.html. + diff --git a/extern/lua/doc/contents.html b/extern/lua/doc/contents.html new file mode 100644 index 0000000..0ce297d --- /dev/null +++ b/extern/lua/doc/contents.html @@ -0,0 +1,533 @@ + + + +Lua 5.2 Reference Manual - contents + + + + + + + +
+

+ +Lua 5.2 Reference Manual +

+ +

+The reference manual is the official definition of the Lua language. +For a complete introduction to Lua programming, see the book +Programming in Lua. + +

+start +· +contents +· +index +

+ +Copyright © 2011–2013 Lua.org, PUC-Rio. +Freely available under the terms of the +Lua license. + + +

Contents

+ + +

Index

+ + + + + + + +
+

Lua functions

+

+_G
+_VERSION
+ +

+assert
+collectgarbage
+dofile
+error
+getmetatable
+ipairs
+load
+loadfile
+next
+pairs
+pcall
+print
+rawequal
+rawget
+rawlen
+rawset
+require
+select
+setmetatable
+tonumber
+tostring
+type
+xpcall
+ +

+bit32.arshift
+bit32.band
+bit32.bnot
+bit32.bor
+bit32.btest
+bit32.bxor
+bit32.extract
+bit32.lrotate
+bit32.lshift
+bit32.replace
+bit32.rrotate
+bit32.rshift
+ +

+coroutine.create
+coroutine.resume
+coroutine.running
+coroutine.status
+coroutine.wrap
+coroutine.yield
+ +

+debug.debug
+debug.getuservalue
+debug.gethook
+debug.getinfo
+debug.getlocal
+debug.getmetatable
+debug.getregistry
+debug.getupvalue
+debug.setuservalue
+debug.sethook
+debug.setlocal
+debug.setmetatable
+debug.setupvalue
+debug.traceback
+debug.upvalueid
+debug.upvaluejoin
+ +

+file:close
+file:flush
+file:lines
+file:read
+file:seek
+file:setvbuf
+file:write
+ +

+io.close
+io.flush
+io.input
+io.lines
+io.open
+io.output
+io.popen
+io.read
+io.stderr
+io.stdin
+io.stdout
+io.tmpfile
+io.type
+io.write
+ +

 +

 

+

+math.abs
+math.acos
+math.asin
+math.atan
+math.atan2
+math.ceil
+math.cos
+math.cosh
+math.deg
+math.exp
+math.floor
+math.fmod
+math.frexp
+math.huge
+math.ldexp
+math.log
+math.max
+math.min
+math.modf
+math.pi
+math.pow
+math.rad
+math.random
+math.randomseed
+math.sin
+math.sinh
+math.sqrt
+math.tan
+math.tanh
+ +

+os.clock
+os.date
+os.difftime
+os.execute
+os.exit
+os.getenv
+os.remove
+os.rename
+os.setlocale
+os.time
+os.tmpname
+ +

+package.config
+package.cpath
+package.loaded
+package.loadlib
+package.path
+package.preload
+package.searchers
+package.searchpath
+ +

+string.byte
+string.char
+string.dump
+string.find
+string.format
+string.gmatch
+string.gsub
+string.len
+string.lower
+string.match
+string.rep
+string.reverse
+string.sub
+string.upper
+ +

+table.concat
+table.insert
+table.pack
+table.remove
+table.sort
+table.unpack
+ +

 +

C API

+

+lua_Alloc
+lua_CFunction
+lua_Debug
+lua_Hook
+lua_Integer
+lua_Number
+lua_Reader
+lua_State
+lua_Unsigned
+lua_Writer
+ +

+lua_absindex
+lua_arith
+lua_atpanic
+lua_call
+lua_callk
+lua_checkstack
+lua_close
+lua_compare
+lua_concat
+lua_copy
+lua_createtable
+lua_dump
+lua_error
+lua_gc
+lua_getallocf
+lua_getctx
+lua_getfield
+lua_getglobal
+lua_gethook
+lua_gethookcount
+lua_gethookmask
+lua_getinfo
+lua_getlocal
+lua_getmetatable
+lua_getstack
+lua_gettable
+lua_gettop
+lua_getupvalue
+lua_getuservalue
+lua_insert
+lua_isboolean
+lua_iscfunction
+lua_isfunction
+lua_islightuserdata
+lua_isnil
+lua_isnone
+lua_isnoneornil
+lua_isnumber
+lua_isstring
+lua_istable
+lua_isthread
+lua_isuserdata
+lua_len
+lua_load
+lua_newstate
+lua_newtable
+lua_newthread
+lua_newuserdata
+lua_next
+lua_pcall
+lua_pcallk
+lua_pop
+lua_pushboolean
+lua_pushcclosure
+lua_pushcfunction
+lua_pushfstring
+lua_pushglobaltable
+lua_pushinteger
+lua_pushlightuserdata
+lua_pushliteral
+lua_pushlstring
+lua_pushnil
+lua_pushnumber
+lua_pushstring
+lua_pushthread
+lua_pushunsigned
+lua_pushvalue
+lua_pushvfstring
+lua_rawequal
+lua_rawget
+lua_rawgeti
+lua_rawgetp
+lua_rawlen
+lua_rawset
+lua_rawseti
+lua_rawsetp
+lua_register
+lua_remove
+lua_replace
+lua_resume
+lua_setallocf
+lua_setfield
+lua_setglobal
+lua_sethook
+lua_setlocal
+lua_setmetatable
+lua_settable
+lua_settop
+lua_setupvalue
+lua_setuservalue
+lua_status
+lua_toboolean
+lua_tocfunction
+lua_tointeger
+lua_tointegerx
+lua_tolstring
+lua_tonumber
+lua_tonumberx
+lua_topointer
+lua_tostring
+lua_tothread
+lua_tounsigned
+lua_tounsignedx
+lua_touserdata
+lua_type
+lua_typename
+lua_upvalueid
+lua_upvalueindex
+lua_upvaluejoin
+lua_version
+lua_xmove
+lua_yield
+lua_yieldk
+ +

 +

auxiliary library

+

+luaL_Buffer
+luaL_Reg
+ +

+luaL_addchar
+luaL_addlstring
+luaL_addsize
+luaL_addstring
+luaL_addvalue
+luaL_argcheck
+luaL_argerror
+luaL_buffinit
+luaL_buffinitsize
+luaL_callmeta
+luaL_checkany
+luaL_checkint
+luaL_checkinteger
+luaL_checklong
+luaL_checklstring
+luaL_checknumber
+luaL_checkoption
+luaL_checkstack
+luaL_checkstring
+luaL_checktype
+luaL_checkudata
+luaL_checkunsigned
+luaL_checkversion
+luaL_dofile
+luaL_dostring
+luaL_error
+luaL_execresult
+luaL_fileresult
+luaL_getmetafield
+luaL_getmetatable
+luaL_getsubtable
+luaL_gsub
+luaL_len
+luaL_loadbuffer
+luaL_loadbufferx
+luaL_loadfile
+luaL_loadfilex
+luaL_loadstring
+luaL_newlib
+luaL_newlibtable
+luaL_newmetatable
+luaL_newstate
+luaL_openlibs
+luaL_optint
+luaL_optinteger
+luaL_optlong
+luaL_optlstring
+luaL_optnumber
+luaL_optstring
+luaL_optunsigned
+luaL_prepbuffer
+luaL_prepbuffsize
+luaL_pushresult
+luaL_pushresultsize
+luaL_ref
+luaL_requiref
+luaL_setfuncs
+luaL_setmetatable
+luaL_testudata
+luaL_tolstring
+luaL_traceback
+luaL_typename
+luaL_unref
+luaL_where
+ +

+ +
+ +Last update: +Tue Mar 12 11:22:18 BRT 2013 + + + + + diff --git a/extern/lua/doc/logo.gif b/extern/lua/doc/logo.gif new file mode 100644 index 0000000000000000000000000000000000000000..2f5e4ac2e742fbb7675e739879211553758aea9c GIT binary patch literal 4232 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 PWz_J}_#7St0k8iB@FZjZ literal 0 HcmV?d00001 diff --git a/extern/lua/doc/lua.1 b/extern/lua/doc/lua.1 new file mode 100644 index 0000000..1dbf043 --- /dev/null +++ b/extern/lua/doc/lua.1 @@ -0,0 +1,116 @@ +.\" $Id: lua.man,v 1.13 2011/11/16 17:16:53 lhf Exp $ +.TH LUA 1 "$Date: 2011/11/16 17:16:53 $" +.SH NAME +lua \- Lua interpreter +.SH SYNOPSIS +.B lua +[ +.I options +] +[ +.I script +[ +.I args +] +] +.SH DESCRIPTION +.B lua +is the standalone Lua interpreter. +It loads and executes Lua programs, +either in textual source form or +in precompiled binary form. +(Precompiled binaries are output by +.BR luac , +the Lua compiler.) +.B lua +can be used as a batch interpreter and also interactively. +.LP +The given +.I options +are handled in order and then +the Lua program in file +.I script +is loaded and executed. +The given +.I args +are available to +.I script +as strings in a global table named +.BR arg . +If no options or arguments are given, +then +.B "\-v \-i" +is assumed when the standard input is a terminal; +otherwise, +.B "\-" +is assumed. +.LP +In interactive mode, +.B lua +prompts the user, +reads lines from the standard input, +and executes them as they are read. +If a line does not contain a complete statement, +then a secondary prompt is displayed and +lines are read until a complete statement is formed or +a syntax error is found. +If a line starts with +.BR '=' , +then +.B lua +evaluates and displays +the values of the expressions in the remainder of the line. +.LP +At the very start, +before even handling the command line, +.B lua +checks the contents of the environment variables +.B LUA_INIT_5_2 +or +.BR LUA_INIT , +in that order. +If the contents is of the form +.RI '@ filename ', +then +.I filename +is executed. +Otherwise, the string is assumed to be a Lua statement and is executed. +.SH OPTIONS +.TP +.BI \-e " stat" +execute statement +.IR stat . +.TP +.B \-i +enter interactive mode after executing +.IR script . +.TP +.BI \-l " name" +execute the equivalent of +.IB name =require(' name ') +before executing +.IR script . +.TP +.B \-v +show version information. +.TP +.B \-E +ignore environment variables. +.TP +.B \-\- +stop handling options. +.TP +.B \- +stop handling options and execute the standard input as a file. +.SH "SEE ALSO" +.BR luac (1) +.br +The documentation at lua.org, +especially section 7 of the reference manual. +.SH DIAGNOSTICS +Error messages should be self explanatory. +.SH AUTHORS +R. Ierusalimschy, +L. H. de Figueiredo, +W. Celes +.\" EOF diff --git a/extern/lua/doc/lua.css b/extern/lua/doc/lua.css new file mode 100644 index 0000000..3d2443a --- /dev/null +++ b/extern/lua/doc/lua.css @@ -0,0 +1,96 @@ +html { + background-color: #F8F8F8 ; +} + +body { + border: solid #a0a0a0 1px ; + border-radius: 20px ; + padding: 26px ; + margin: 16px ; + color: #000000 ; + background-color: #FFFFFF ; + font-family: Helvetica, Arial, sans-serif ; + text-align: justify ; +} + +h1, h2, h3, h4 { + font-family: Verdana, Geneva, sans-serif ; + font-weight: normal ; + font-style: normal ; +} + +h2 { + padding-top: 0.4em ; + padding-bottom: 0.4em ; + padding-left: 0.8em ; + padding-right: 0.8em ; + background-color: #D0D0FF ; + border-radius: 8px ; + border: solid #a0a0a0 1px ; +} + +h3 { + padding-left: 0.5em ; + border-left: solid #D0D0FF 1em ; +} + +table h3 { + padding-left: 0px ; + border-left: none ; +} + +a:link { + color: #000080 ; + background-color: inherit ; + text-decoration: none ; +} + +a:visited { + background-color: inherit ; + text-decoration: none ; +} + +a:link:hover, a:visited:hover { + color: #000080 ; + background-color: #D0D0FF ; +} + +a:link:active, a:visited:active { + color: #FF0000 ; +} + +hr { + border: 0 ; + height: 1px ; + color: #a0a0a0 ; + background-color: #a0a0a0 ; + display: none ; +} + +table hr { + display: block ; +} + +:target { + background-color: #F8F8F8 ; + padding: 8px ; + border: solid #a0a0a0 2px ; + border-radius: 8px ; +} + +.footer { + color: gray ; + font-size: x-small ; +} + +input[type=text] { + border: solid #a0a0a0 2px ; + border-radius: 2em ; + -moz-border-radius: 2em ; + background-image: url('images/search.png') ; + background-repeat: no-repeat; + background-position: 4px center ; + padding-left: 20px ; + height: 2em ; +} + diff --git a/extern/lua/doc/luac.1 b/extern/lua/doc/luac.1 new file mode 100644 index 0000000..33a4ed0 --- /dev/null +++ b/extern/lua/doc/luac.1 @@ -0,0 +1,118 @@ +.\" $Id: luac.man,v 1.29 2011/11/16 13:53:40 lhf Exp $ +.TH LUAC 1 "$Date: 2011/11/16 13:53:40 $" +.SH NAME +luac \- Lua compiler +.SH SYNOPSIS +.B luac +[ +.I options +] [ +.I filenames +] +.SH DESCRIPTION +.B luac +is the Lua compiler. +It translates programs written in the Lua programming language +into binary files containing precompiled chunks +that can be later loaded and executed. +.LP +The main advantages of precompiling chunks are: +faster loading, +protecting source code from accidental user changes, +and +off-line syntax checking. +Precompiling does not imply faster execution +because in Lua chunks are always compiled into bytecodes before being executed. +.B luac +simply allows those bytecodes to be saved in a file for later execution. +Precompiled chunks are not necessarily smaller than the corresponding source. +The main goal in precompiling is faster loading. +.LP +In the command line, +you can mix +text files containing Lua source and +binary files containing precompiled chunks. +.B luac +produces a single output file containing the combined bytecodes +for all files given. +Executing the combined file is equivalent to executing the given files. +By default, +the output file is named +.BR luac.out , +but you can change this with the +.B \-o +option. +.LP +Precompiled chunks are +.I not +portable across different architectures. +Moreover, +the internal format of precompiled chunks +is likely to change when a new version of Lua is released. +Make sure you save the source files of all Lua programs that you precompile. +.LP +.SH OPTIONS +.TP +.B \-l +produce a listing of the compiled bytecode for Lua's virtual machine. +Listing bytecodes is useful to learn about Lua's virtual machine. +If no files are given, then +.B luac +loads +.B luac.out +and lists its contents. +Use +.B \-l \-l +for a full listing. +.TP +.BI \-o " file" +output to +.IR file , +instead of the default +.BR luac.out . +(You can use +.B "'\-'" +for standard output, +but not on platforms that open standard output in text mode.) +The output file may be one of the given files because +all files are loaded before the output file is written. +Be careful not to overwrite precious files. +.TP +.B \-p +load files but do not generate any output file. +Used mainly for syntax checking and for testing precompiled chunks: +corrupted files will probably generate errors when loaded. +If no files are given, then +.B luac +loads +.B luac.out +and tests its contents. +No messages are displayed if the file loads without errors. +.TP +.B \-s +strip debug information before writing the output file. +This saves some space in very large chunks, +but if errors occur when running a stripped chunk, +then the error messages may not contain the full information they usually do. +In particular, +line numbers and names of local variables are lost. +.TP +.B \-v +show version information. +.TP +.B \-\- +stop handling options. +.TP +.B \- +stop handling options and process standard input. +.SH "SEE ALSO" +.BR lua (1) +.br +The documentation at lua.org. +.SH DIAGNOSTICS +Error messages should be self explanatory. +.SH AUTHORS +R. Ierusalimschy, +L. H. de Figueiredo, +W. Celes +.\" EOF diff --git a/extern/lua/doc/manual.css b/extern/lua/doc/manual.css new file mode 100644 index 0000000..ca613cd --- /dev/null +++ b/extern/lua/doc/manual.css @@ -0,0 +1,27 @@ +h3 code { + font-family: inherit ; + font-size: inherit ; +} + +pre, code { + font-size: 12pt ; +} + +span.apii { + float: right ; + font-family: inherit ; + font-style: normal ; + font-size: small ; + color: gray ; +} + +p+h1, ul+h1 { + font-style: normal ; + padding-top: 0.4em ; + padding-bottom: 0.4em ; + padding-left: 16px ; + margin-left: -16px ; + background-color: #D0D0FF ; + border-radius: 8px ; + border: solid #000080 1px ; +} diff --git a/extern/lua/doc/manual.html b/extern/lua/doc/manual.html new file mode 100644 index 0000000..8536536 --- /dev/null +++ b/extern/lua/doc/manual.html @@ -0,0 +1,10507 @@ + + + + +Lua 5.2 Reference Manual + + + + + + + +
+

+ +Lua 5.2 Reference Manual +

+ +by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes +

+ +Copyright © 2011–2013 Lua.org, PUC-Rio. +Freely available under the terms of the +Lua license. + +

+

+ +contents +· +index + + +

+ + + + + + +

1 – Introduction

+ +

+Lua is an extension programming language designed to support +general procedural programming with data description +facilities. +It also offers good support for object-oriented programming, +functional programming, and data-driven programming. +Lua is intended to be used as a powerful, lightweight, +embeddable scripting language for any program that needs one. +Lua is implemented as a library, written in clean C, +the common subset of Standard C and C++. + + +

+Being an extension language, Lua has no notion of a "main" program: +it only works embedded in a host client, +called the embedding program or simply the host. +The host program can invoke functions to execute a piece of Lua code, +can write and read Lua variables, +and can register C functions to be called by Lua code. +Through the use of C functions, Lua can be augmented to cope with +a wide range of different domains, +thus creating customized programming languages sharing a syntactical framework. +The Lua distribution includes a sample host program called lua, +which uses the Lua library to offer a complete, standalone Lua interpreter, +for interactive or batch use. + + +

+Lua is free software, +and is provided as usual with no guarantees, +as stated in its license. +The implementation described in this manual is available +at Lua's official web site, www.lua.org. + + +

+Like any other reference manual, +this document is dry in places. +For a discussion of the decisions behind the design of Lua, +see the technical papers available at Lua's web site. +For a detailed introduction to programming in Lua, +see Roberto's book, Programming in Lua. + + + +

2 – Basic Concepts

+ +

+This section describes the basic concepts of the language. + + + +

2.1 – Values and Types

+ +

+Lua is a dynamically typed language. +This means that +variables do not have types; only values do. +There are no type definitions in the language. +All values carry their own type. + + +

+All values in Lua are first-class values. +This means that all values can be stored in variables, +passed as arguments to other functions, and returned as results. + + +

+There are eight basic types in Lua: +nil, boolean, number, +string, function, userdata, +thread, and table. +Nil is the type of the value nil, +whose main property is to be different from any other value; +it usually represents the absence of a useful value. +Boolean is the type of the values false and true. +Both nil and false make a condition false; +any other value makes it true. +Number represents real (double-precision floating-point) numbers. +Operations on numbers follow the same rules of +the underlying C implementation, +which, in turn, usually follows the IEEE 754 standard. +(It is easy to build Lua interpreters that use other +internal representations for numbers, +such as single-precision floats or long integers; +see file luaconf.h.) +String represents immutable sequences of bytes. + +Lua is 8-bit clean: +strings can contain any 8-bit value, +including embedded zeros ('\0'). + + +

+Lua can call (and manipulate) functions written in Lua and +functions written in C +(see §3.4.9). + + +

+The type userdata is provided to allow arbitrary C data to +be stored in Lua variables. +A userdata value is a pointer to a block of raw memory. +There are two kinds of userdata: +full userdata, where the block of memory is managed by Lua, +and light userdata, where the block of memory is managed by the host. +Userdata has no predefined operations in Lua, +except assignment and identity test. +By using metatables, +the programmer can define operations for full userdata values +(see §2.4). +Userdata values cannot be created or modified in Lua, +only through the C API. +This guarantees the integrity of data owned by the host program. + + +

+The type thread represents independent threads of execution +and it is used to implement coroutines (see §2.6). +Do not confuse Lua threads with operating-system threads. +Lua supports coroutines on all systems, +even those that do not support threads. + + +

+The type table implements associative arrays, +that is, arrays that can be indexed not only with numbers, +but with any Lua value except nil and NaN +(Not a Number, a special numeric value used to represent +undefined or unrepresentable results, such as 0/0). +Tables can be heterogeneous; +that is, they can contain values of all types (except nil). +Any key with value nil is not considered part of the table. +Conversely, any key that is not part of a table has +an associated value nil. + + +

+Tables are the sole data structuring mechanism in Lua; +they can be used to represent ordinary arrays, sequences, +symbol tables, sets, records, graphs, trees, etc. +To represent records, Lua uses the field name as an index. +The language supports this representation by +providing a.name as syntactic sugar for a["name"]. +There are several convenient ways to create tables in Lua +(see §3.4.8). + + +

+We use the term sequence to denote a table where +the set of all positive numeric keys is equal to {1..n} +for some integer n, +which is called the length of the sequence (see §3.4.6). + + +

+Like indices, +the values of table fields can be of any type. +In particular, +because functions are first-class values, +table fields can contain functions. +Thus tables can also carry methods (see §3.4.10). + + +

+The indexing of tables follows +the definition of raw equality in the language. +The expressions a[i] and a[j] +denote the same table element +if and only if i and j are raw equal +(that is, equal without metamethods). + + +

+Tables, functions, threads, and (full) userdata values are objects: +variables do not actually contain these values, +only references to them. +Assignment, parameter passing, and function returns +always manipulate references to such values; +these operations do not imply any kind of copy. + + +

+The library function type returns a string describing the type +of a given value (see §6.1). + + + + + +

2.2 – Environments and the Global Environment

+ +

+As will be discussed in §3.2 and §3.3.3, +any reference to a global name var is syntactically translated +to _ENV.var. +Moreover, every chunk is compiled in the scope of +an external local variable called _ENV (see §3.3.2), +so _ENV itself is never a global name in a chunk. + + +

+Despite the existence of this external _ENV variable and +the translation of global names, +_ENV is a completely regular name. +In particular, +you can define new variables and parameters with that name. +Each reference to a global name uses the _ENV that is +visible at that point in the program, +following the usual visibility rules of Lua (see §3.5). + + +

+Any table used as the value of _ENV is called an environment. + + +

+Lua keeps a distinguished environment called the global environment. +This value is kept at a special index in the C registry (see §4.5). +In Lua, the variable _G is initialized with this same value. + + +

+When Lua compiles a chunk, +it initializes the value of its _ENV upvalue +with the global environment (see load). +Therefore, by default, +global variables in Lua code refer to entries in the global environment. +Moreover, all standard libraries are loaded in the global environment +and several functions there operate on that environment. +You can use load (or loadfile) +to load a chunk with a different environment. +(In C, you have to load the chunk and then change the value +of its first upvalue.) + + +

+If you change the global environment in the registry +(through C code or the debug library), +all chunks loaded after the change will get the new environment. +Previously loaded chunks are not affected, however, +as each has its own reference to the environment in its _ENV variable. +Moreover, the variable _G +(which is stored in the original global environment) +is never updated by Lua. + + + + + +

2.3 – Error Handling

+ +

+Because Lua is an embedded extension language, +all Lua actions start from C code in the host program +calling a function from the Lua library (see lua_pcall). +Whenever an error occurs during +the compilation or execution of a Lua chunk, +control returns to the host, +which can take appropriate measures +(such as printing an error message). + + +

+Lua code can explicitly generate an error by calling the +error function. +If you need to catch errors in Lua, +you can use pcall or xpcall +to call a given function in protected mode. + + +

+Whenever there is an error, +an error object (also called an error message) +is propagated with information about the error. +Lua itself only generates errors where the error object is a string, +but programs may generate errors with +any value for the error object. + + +

+When you use xpcall or lua_pcall, +you may give a message handler +to be called in case of errors. +This function is called with the original error message +and returns a new error message. +It is called before the error unwinds the stack, +so that it can gather more information about the error, +for instance by inspecting the stack and creating a stack traceback. +This message handler is still protected by the protected call; +so, an error inside the message handler +will call the message handler again. +If this loop goes on, Lua breaks it and returns an appropriate message. + + + + + +

2.4 – Metatables and Metamethods

+ +

+Every value in Lua can have a metatable. +This metatable is an ordinary Lua table +that defines the behavior of the original value +under certain special operations. +You can change several aspects of the behavior +of operations over a value by setting specific fields in its metatable. +For instance, when a non-numeric value is the operand of an addition, +Lua checks for a function in the field "__add" of the value's metatable. +If it finds one, +Lua calls this function to perform the addition. + + +

+The keys in a metatable are derived from the event names; +the corresponding values are called metamethods. +In the previous example, the event is "add" +and the metamethod is the function that performs the addition. + + +

+You can query the metatable of any value +using the getmetatable function. + + +

+You can replace the metatable of tables +using the setmetatable function. +You cannot change the metatable of other types from Lua +(except by using the debug library); +you must use the C API for that. + + +

+Tables and full userdata have individual metatables +(although multiple tables and userdata can share their metatables). +Values of all other types share one single metatable per type; +that is, there is one single metatable for all numbers, +one for all strings, etc. +By default, a value has no metatable, +but the string library sets a metatable for the string type (see §6.4). + + +

+A metatable controls how an object behaves in arithmetic operations, +order comparisons, concatenation, length operation, and indexing. +A metatable also can define a function to be called +when a userdata or a table is garbage collected. +When Lua performs one of these operations over a value, +it checks whether this value has a metatable with the corresponding event. +If so, the value associated with that key (the metamethod) +controls how Lua will perform the operation. + + +

+Metatables control the operations listed next. +Each operation is identified by its corresponding name. +The key for each operation is a string with its name prefixed by +two underscores, '__'; +for instance, the key for operation "add" is the +string "__add". + + +

+The semantics of these operations is better explained by a Lua function +describing how the interpreter executes the operation. +The code shown here in Lua is only illustrative; +the real behavior is hard coded in the interpreter +and it is much more efficient than this simulation. +All functions used in these descriptions +(rawget, tonumber, etc.) +are described in §6.1. +In particular, to retrieve the metamethod of a given object, +we use the expression + +

+     metatable(obj)[event]
+

+This should be read as + +

+     rawget(getmetatable(obj) or {}, event)
+

+This means that the access to a metamethod does not invoke other metamethods, +and access to objects with no metatables does not fail +(it simply results in nil). + + +

+For the unary - and # operators, +the metamethod is called with a dummy second argument. +This extra argument is only to simplify Lua's internals; +it may be removed in future versions and therefore it is not present +in the following code. +(For most uses this extra argument is irrelevant.) + + + +

    + +
  • "add": +the + operation. + + + +

    +The function getbinhandler below defines how Lua chooses a handler +for a binary operation. +First, Lua tries the first operand. +If its type does not define a handler for the operation, +then Lua tries the second operand. + +

    +     function getbinhandler (op1, op2, event)
+       return metatable(op1)[event] or metatable(op2)[event]
+     end
+

    +By using this function, +the behavior of the op1 + op2 is + +

    +     function add_event (op1, op2)
+       local o1, o2 = tonumber(op1), tonumber(op2)
+       if o1 and o2 then  -- both operands are numeric?
+         return o1 + o2   -- '+' here is the primitive 'add'
+       else  -- at least one of the operands is not numeric
+         local h = getbinhandler(op1, op2, "__add")
+         if h then
+           -- call the handler with both operands
+           return (h(op1, op2))
+         else  -- no handler available: default behavior
+           error(···)
+         end
+       end
+     end
+

    +

    • + +
  • "sub": +the - operation. + +Behavior similar to the "add" operation. +
    • + +
  • "mul": +the * operation. + +Behavior similar to the "add" operation. +
    • + +
  • "div": +the / operation. + +Behavior similar to the "add" operation. +
    • + +
  • "mod": +the % operation. + +Behavior similar to the "add" operation, +with the operation +o1 - floor(o1/o2)*o2 as the primitive operation. +
    • + +
  • "pow": +the ^ (exponentiation) operation. + +Behavior similar to the "add" operation, +with the function pow (from the C math library) +as the primitive operation. +
    • + +
  • "unm": +the unary - operation. + + +
    +     function unm_event (op)
+       local o = tonumber(op)
+       if o then  -- operand is numeric?
+         return -o  -- '-' here is the primitive 'unm'
+       else  -- the operand is not numeric.
+         -- Try to get a handler from the operand
+         local h = metatable(op).__unm
+         if h then
+           -- call the handler with the operand
+           return (h(op))
+         else  -- no handler available: default behavior
+           error(···)
+         end
+       end
+     end
+

    +

    • + +
  • "concat": +the .. (concatenation) operation. + + +
    +     function concat_event (op1, op2)
+       if (type(op1) == "string" or type(op1) == "number") and
+          (type(op2) == "string" or type(op2) == "number") then
+         return op1 .. op2  -- primitive string concatenation
+       else
+         local h = getbinhandler(op1, op2, "__concat")
+         if h then
+           return (h(op1, op2))
+         else
+           error(···)
+         end
+       end
+     end
+

    +

    • + +
  • "len": +the # operation. + + +
    +     function len_event (op)
+       if type(op) == "string" then
+         return strlen(op)      -- primitive string length
+       else
+         local h = metatable(op).__len
+         if h then
+           return (h(op))       -- call handler with the operand
+         elseif type(op) == "table" then
+           return #op              -- primitive table length
+         else  -- no handler available: error
+           error(···)
+         end
+       end
+     end
+

    +See §3.4.6 for a description of the length of a table. +

    • + +
  • "eq": +the == operation. + +The function getequalhandler defines how Lua chooses a metamethod +for equality. +A metamethod is selected only when both values +being compared have the same type +and the same metamethod for the selected operation, +and the values are either tables or full userdata. + +
    +     function getequalhandler (op1, op2)
+       if type(op1) ~= type(op2) or
+          (type(op1) ~= "table" and type(op1) ~= "userdata") then
+         return nil     -- different values
+       end
+       local mm1 = metatable(op1).__eq
+       local mm2 = metatable(op2).__eq
+       if mm1 == mm2 then return mm1 else return nil end
+     end
+

    +The "eq" event is defined as follows: + +

    +     function eq_event (op1, op2)
+       if op1 == op2 then   -- primitive equal?
+         return true   -- values are equal
+       end
+       -- try metamethod
+       local h = getequalhandler(op1, op2)
+       if h then
+         return not not h(op1, op2)
+       else
+         return false
+       end
+     end
+

    +Note that the result is always a boolean. +

    • + +
  • "lt": +the < operation. + + +
    +     function lt_event (op1, op2)
+       if type(op1) == "number" and type(op2) == "number" then
+         return op1 < op2   -- numeric comparison
+       elseif type(op1) == "string" and type(op2) == "string" then
+         return op1 < op2   -- lexicographic comparison
+       else
+         local h = getbinhandler(op1, op2, "__lt")
+         if h then
+           return not not h(op1, op2)
+         else
+           error(···)
+         end
+       end
+     end
+

    +Note that the result is always a boolean. +

    • + +
  • "le": +the <= operation. + + +
    +     function le_event (op1, op2)
+       if type(op1) == "number" and type(op2) == "number" then
+         return op1 <= op2   -- numeric comparison
+       elseif type(op1) == "string" and type(op2) == "string" then
+         return op1 <= op2   -- lexicographic comparison
+       else
+         local h = getbinhandler(op1, op2, "__le")
+         if h then
+           return not not h(op1, op2)
+         else
+           h = getbinhandler(op1, op2, "__lt")
+           if h then
+             return not h(op2, op1)
+           else
+             error(···)
+           end
+         end
+       end
+     end
+

    +Note that, in the absence of a "le" metamethod, +Lua tries the "lt", assuming that a <= b is +equivalent to not (b < a). + + +

    +As with the other comparison operators, +the result is always a boolean. +

    • + +
  • "index": +The indexing access table[key]. +Note that the metamethod is tried only +when key is not present in table. +(When table is not a table, +no key is ever present, +so the metamethod is always tried.) + + +
    +     function gettable_event (table, key)
+       local h
+       if type(table) == "table" then
+         local v = rawget(table, key)
+         -- if key is present, return raw value
+         if v ~= nil then return v end
+         h = metatable(table).__index
+         if h == nil then return nil end
+       else
+         h = metatable(table).__index
+         if h == nil then
+           error(···)
+         end
+       end
+       if type(h) == "function" then
+         return (h(table, key))     -- call the handler
+       else return h[key]           -- or repeat operation on it
+       end
+     end
+

    +

    • + +
  • "newindex": +The indexing assignment table[key] = value. +Note that the metamethod is tried only +when key is not present in table. + + +
    +     function settable_event (table, key, value)
+       local h
+       if type(table) == "table" then
+         local v = rawget(table, key)
+         -- if key is present, do raw assignment
+         if v ~= nil then rawset(table, key, value); return end
+         h = metatable(table).__newindex
+         if h == nil then rawset(table, key, value); return end
+       else
+         h = metatable(table).__newindex
+         if h == nil then
+           error(···)
+         end
+       end
+       if type(h) == "function" then
+         h(table, key,value)           -- call the handler
+       else h[key] = value             -- or repeat operation on it
+       end
+     end
+

    +

    • + +
  • "call": +called when Lua calls a value. + + +
    +     function function_event (func, ...)
+       if type(func) == "function" then
+         return func(...)   -- primitive call
+       else
+         local h = metatable(func).__call
+         if h then
+           return h(func, ...)
+         else
+           error(···)
+         end
+       end
+     end
+

    +

    • + +
+ + + + +

2.5 – Garbage Collection

+ +

+Lua performs automatic memory management. +This means that +you have to worry neither about allocating memory for new objects +nor about freeing it when the objects are no longer needed. +Lua manages memory automatically by running +a garbage collector to collect all dead objects +(that is, objects that are no longer accessible from Lua). +All memory used by Lua is subject to automatic management: +strings, tables, userdata, functions, threads, internal structures, etc. + + +

+Lua implements an incremental mark-and-sweep collector. +It uses two numbers to control its garbage-collection cycles: +the garbage-collector pause and +the garbage-collector step multiplier. +Both use percentage points as units +(e.g., a value of 100 means an internal value of 1). + + +

+The garbage-collector pause +controls how long the collector waits before starting a new cycle. +Larger values make the collector less aggressive. +Values smaller than 100 mean the collector will not wait to +start a new cycle. +A value of 200 means that the collector waits for the total memory in use +to double before starting a new cycle. + + +

+The garbage-collector step multiplier +controls the relative speed of the collector relative to +memory allocation. +Larger values make the collector more aggressive but also increase +the size of each incremental step. +Values smaller than 100 make the collector too slow and +can result in the collector never finishing a cycle. +The default is 200, +which means that the collector runs at "twice" +the speed of memory allocation. + + +

+If you set the step multiplier to a very large number +(larger than 10% of the maximum number of +bytes that the program may use), +the collector behaves like a stop-the-world collector. +If you then set the pause to 200, +the collector behaves as in old Lua versions, +doing a complete collection every time Lua doubles its +memory usage. + + +

+You can change these numbers by calling lua_gc in C +or collectgarbage in Lua. +You can also use these functions to control +the collector directly (e.g., stop and restart it). + + +

+As an experimental feature in Lua 5.2, +you can change the collector's operation mode +from incremental to generational. +A generational collector assumes that most objects die young, +and therefore it traverses only young (recently created) objects. +This behavior can reduce the time used by the collector, +but also increases memory usage (as old dead objects may accumulate). +To mitigate this second problem, +from time to time the generational collector performs a full collection. +Remember that this is an experimental feature; +you are welcome to try it, +but check your gains. + + + +

2.5.1 – Garbage-Collection Metamethods

+ +

+You can set garbage-collector metamethods for tables +and, using the C API, +for full userdata (see §2.4). +These metamethods are also called finalizers. +Finalizers allow you to coordinate Lua's garbage collection +with external resource management +(such as closing files, network or database connections, +or freeing your own memory). + + +

+For an object (table or userdata) to be finalized when collected, +you must mark it for finalization. + +You mark an object for finalization when you set its metatable +and the metatable has a field indexed by the string "__gc". +Note that if you set a metatable without a __gc field +and later create that field in the metatable, +the object will not be marked for finalization. +However, after an object is marked, +you can freely change the __gc field of its metatable. + + +

+When a marked object becomes garbage, +it is not collected immediately by the garbage collector. +Instead, Lua puts it in a list. +After the collection, +Lua does the equivalent of the following function +for each object in that list: + +

+     function gc_event (obj)
+       local h = metatable(obj).__gc
+       if type(h) == "function" then
+         h(obj)
+       end
+     end
+
+ +

+At the end of each garbage-collection cycle, +the finalizers for objects are called in +the reverse order that they were marked for collection, +among those collected in that cycle; +that is, the first finalizer to be called is the one associated +with the object marked last in the program. +The execution of each finalizer may occur at any point during +the execution of the regular code. + + +

+Because the object being collected must still be used by the finalizer, +it (and other objects accessible only through it) +must be resurrected by Lua. +Usually, this resurrection is transient, +and the object memory is freed in the next garbage-collection cycle. +However, if the finalizer stores the object in some global place +(e.g., a global variable), +then there is a permanent resurrection. +In any case, +the object memory is freed only when it becomes completely inaccessible; +its finalizer will never be called twice. + + +

+When you close a state (see lua_close), +Lua calls the finalizers of all objects marked for finalization, +following the reverse order that they were marked. +If any finalizer marks new objects for collection during that phase, +these new objects will not be finalized. + + + + + +

2.5.2 – Weak Tables

+ +

+A weak table is a table whose elements are +weak references. +A weak reference is ignored by the garbage collector. +In other words, +if the only references to an object are weak references, +then the garbage collector will collect that object. + + +

+A weak table can have weak keys, weak values, or both. +A table with weak keys allows the collection of its keys, +but prevents the collection of its values. +A table with both weak keys and weak values allows the collection of +both keys and values. +In any case, if either the key or the value is collected, +the whole pair is removed from the table. +The weakness of a table is controlled by the +__mode field of its metatable. +If the __mode field is a string containing the character 'k', +the keys in the table are weak. +If __mode contains 'v', +the values in the table are weak. + + +

+A table with weak keys and strong values +is also called an ephemeron table. +In an ephemeron table, +a value is considered reachable only if its key is reachable. +In particular, +if the only reference to a key comes through its value, +the pair is removed. + + +

+Any change in the weakness of a table may take effect only +at the next collect cycle. +In particular, if you change the weakness to a stronger mode, +Lua may still collect some items from that table +before the change takes effect. + + +

+Only objects that have an explicit construction +are removed from weak tables. +Values, such as numbers and light C functions, +are not subject to garbage collection, +and therefore are not removed from weak tables +(unless its associated value is collected). +Although strings are subject to garbage collection, +they do not have an explicit construction, +and therefore are not removed from weak tables. + + +

+Resurrected objects +(that is, objects being finalized +and objects accessible only through objects being finalized) +have a special behavior in weak tables. +They are removed from weak values before running their finalizers, +but are removed from weak keys only in the next collection +after running their finalizers, when such objects are actually freed. +This behavior allows the finalizer to access properties +associated with the object through weak tables. + + +

+If a weak table is among the resurrected objects in a collection cycle, +it may not be properly cleared until the next cycle. + + + + + + + +

2.6 – Coroutines

+ +

+Lua supports coroutines, +also called collaborative multithreading. +A coroutine in Lua represents an independent thread of execution. +Unlike threads in multithread systems, however, +a coroutine only suspends its execution by explicitly calling +a yield function. + + +

+You create a coroutine by calling coroutine.create. +Its sole argument is a function +that is the main function of the coroutine. +The create function only creates a new coroutine and +returns a handle to it (an object of type thread); +it does not start the coroutine. + + +

+You execute a coroutine by calling coroutine.resume. +When you first call coroutine.resume, +passing as its first argument +a thread returned by coroutine.create, +the coroutine starts its execution, +at the first line of its main function. +Extra arguments passed to coroutine.resume are passed on +to the coroutine main function. +After the coroutine starts running, +it runs until it terminates or yields. + + +

+A coroutine can terminate its execution in two ways: +normally, when its main function returns +(explicitly or implicitly, after the last instruction); +and abnormally, if there is an unprotected error. +In the first case, coroutine.resume returns true, +plus any values returned by the coroutine main function. +In case of errors, coroutine.resume returns false +plus an error message. + + +

+A coroutine yields by calling coroutine.yield. +When a coroutine yields, +the corresponding coroutine.resume returns immediately, +even if the yield happens inside nested function calls +(that is, not in the main function, +but in a function directly or indirectly called by the main function). +In the case of a yield, coroutine.resume also returns true, +plus any values passed to coroutine.yield. +The next time you resume the same coroutine, +it continues its execution from the point where it yielded, +with the call to coroutine.yield returning any extra +arguments passed to coroutine.resume. + + +

+Like coroutine.create, +the coroutine.wrap function also creates a coroutine, +but instead of returning the coroutine itself, +it returns a function that, when called, resumes the coroutine. +Any arguments passed to this function +go as extra arguments to coroutine.resume. +coroutine.wrap returns all the values returned by coroutine.resume, +except the first one (the boolean error code). +Unlike coroutine.resume, +coroutine.wrap does not catch errors; +any error is propagated to the caller. + + +

+As an example of how coroutines work, +consider the following code: + +

+     function foo (a)
+       print("foo", a)
+       return coroutine.yield(2*a)
+     end
+     
+     co = coroutine.create(function (a,b)
+           print("co-body", a, b)
+           local r = foo(a+1)
+           print("co-body", r)
+           local r, s = coroutine.yield(a+b, a-b)
+           print("co-body", r, s)
+           return b, "end"
+     end)
+     
+     print("main", coroutine.resume(co, 1, 10))
+     print("main", coroutine.resume(co, "r"))
+     print("main", coroutine.resume(co, "x", "y"))
+     print("main", coroutine.resume(co, "x", "y"))
+

+When you run it, it produces the following output: + +

+     co-body 1       10
+     foo     2
+     main    true    4
+     co-body r
+     main    true    11      -9
+     co-body x       y
+     main    true    10      end
+     main    false   cannot resume dead coroutine
+
+ +

+You can also create and manipulate coroutines through the C API: +see functions lua_newthread, lua_resume, +and lua_yield. + + + + + +

3 – The Language

+ +

+This section describes the lexis, the syntax, and the semantics of Lua. +In other words, +this section describes +which tokens are valid, +how they can be combined, +and what their combinations mean. + + +

+Language constructs will be explained using the usual extended BNF notation, +in which +{a} means 0 or more a's, and +[a] means an optional a. +Non-terminals are shown like non-terminal, +keywords are shown like kword, +and other terminal symbols are shown like ‘=’. +The complete syntax of Lua can be found in §9 +at the end of this manual. + + + +

3.1 – Lexical Conventions

+ +

+Lua is a free-form language. +It ignores spaces (including new lines) and comments +between lexical elements (tokens), +except as delimiters between names and keywords. + + +

+Names +(also called identifiers) +in Lua can be any string of letters, +digits, and underscores, +not beginning with a digit. +Identifiers are used to name variables, table fields, and labels. + + +

+The following keywords are reserved +and cannot be used as names: + + +

+     and       break     do        else      elseif    end
+     false     for       function  goto      if        in
+     local     nil       not       or        repeat    return
+     then      true      until     while
+
+ +

+Lua is a case-sensitive language: +and is a reserved word, but And and AND +are two different, valid names. +As a convention, names starting with an underscore followed by +uppercase letters (such as _VERSION) +are reserved for variables used by Lua. + + +

+The following strings denote other tokens: + +

+     +     -     *     /     %     ^     #
+     ==    ~=    <=    >=    <     >     =
+     (     )     {     }     [     ]     ::
+     ;     :     ,     .     ..    ...
+
+ +

+Literal strings +can be delimited by matching single or double quotes, +and can contain the following C-like escape sequences: +'\a' (bell), +'\b' (backspace), +'\f' (form feed), +'\n' (newline), +'\r' (carriage return), +'\t' (horizontal tab), +'\v' (vertical tab), +'\\' (backslash), +'\"' (quotation mark [double quote]), +and '\'' (apostrophe [single quote]). +A backslash followed by a real newline +results in a newline in the string. +The escape sequence '\z' skips the following span +of white-space characters, +including line breaks; +it is particularly useful to break and indent a long literal string +into multiple lines without adding the newlines and spaces +into the string contents. + + +

+A byte in a literal string can also be specified by its numerical value. +This can be done with the escape sequence \xXX, +where XX is a sequence of exactly two hexadecimal digits, +or with the escape sequence \ddd, +where ddd is a sequence of up to three decimal digits. +(Note that if a decimal escape is to be followed by a digit, +it must be expressed using exactly three digits.) +Strings in Lua can contain any 8-bit value, including embedded zeros, +which can be specified as '\0'. + + +

+Literal strings can also be defined using a long format +enclosed by long brackets. +We define an opening long bracket of level n as an opening +square bracket followed by n equal signs followed by another +opening square bracket. +So, an opening long bracket of level 0 is written as [[, +an opening long bracket of level 1 is written as [=[, +and so on. +A closing long bracket is defined similarly; +for instance, a closing long bracket of level 4 is written as ]====]. +A long literal starts with an opening long bracket of any level and +ends at the first closing long bracket of the same level. +It can contain any text except a closing bracket of the proper level. +Literals in this bracketed form can run for several lines, +do not interpret any escape sequences, +and ignore long brackets of any other level. +Any kind of end-of-line sequence +(carriage return, newline, carriage return followed by newline, +or newline followed by carriage return) +is converted to a simple newline. + + +

+Any byte in a literal string not +explicitly affected by the previous rules represents itself. +However, Lua opens files for parsing in text mode, +and the system file functions may have problems with +some control characters. +So, it is safer to represent +non-text data as a quoted literal with +explicit escape sequences for non-text characters. + + +

+For convenience, +when the opening long bracket is immediately followed by a newline, +the newline is not included in the string. +As an example, in a system using ASCII +(in which 'a' is coded as 97, +newline is coded as 10, and '1' is coded as 49), +the five literal strings below denote the same string: + +

+     a = 'alo\n123"'
+     a = "alo\n123\""
+     a = '\97lo\10\04923"'
+     a = [[alo
+     123"]]
+     a = [==[
+     alo
+     123"]==]
+
+ +

+A numerical constant can be written with an optional fractional part +and an optional decimal exponent, +marked by a letter 'e' or 'E'. +Lua also accepts hexadecimal constants, +which start with 0x or 0X. +Hexadecimal constants also accept an optional fractional part +plus an optional binary exponent, +marked by a letter 'p' or 'P'. +Examples of valid numerical constants are + +

+     3     3.0     3.1416     314.16e-2     0.31416E1
+     0xff  0x0.1E  0xA23p-4   0X1.921FB54442D18P+1
+
+ +

+A comment starts with a double hyphen (--) +anywhere outside a string. +If the text immediately after -- is not an opening long bracket, +the comment is a short comment, +which runs until the end of the line. +Otherwise, it is a long comment, +which runs until the corresponding closing long bracket. +Long comments are frequently used to disable code temporarily. + + + + + +

3.2 – Variables

+ +

+Variables are places that store values. +There are three kinds of variables in Lua: +global variables, local variables, and table fields. + + +

+A single name can denote a global variable or a local variable +(or a function's formal parameter, +which is a particular kind of local variable): + +

+	var ::= Name
+

+Name denotes identifiers, as defined in §3.1. + + +

+Any variable name is assumed to be global unless explicitly declared +as a local (see §3.3.7). +Local variables are lexically scoped: +local variables can be freely accessed by functions +defined inside their scope (see §3.5). + + +

+Before the first assignment to a variable, its value is nil. + + +

+Square brackets are used to index a table: + +

+	var ::= prefixexp ‘[’ exp ‘]’
+

+The meaning of accesses to table fields can be changed via metatables. +An access to an indexed variable t[i] is equivalent to +a call gettable_event(t,i). +(See §2.4 for a complete description of the +gettable_event function. +This function is not defined or callable in Lua. +We use it here only for explanatory purposes.) + + +

+The syntax var.Name is just syntactic sugar for +var["Name"]: + +

+	var ::= prefixexp ‘.’ Name
+
+ +

+An access to a global variable x +is equivalent to _ENV.x. +Due to the way that chunks are compiled, +_ENV is never a global name (see §2.2). + + + + + +

3.3 – Statements

+ +

+Lua supports an almost conventional set of statements, +similar to those in Pascal or C. +This set includes +assignments, control structures, function calls, +and variable declarations. + + + +

3.3.1 – Blocks

+ +

+A block is a list of statements, +which are executed sequentially: + +

+	block ::= {stat}
+

+Lua has empty statements +that allow you to separate statements with semicolons, +start a block with a semicolon +or write two semicolons in sequence: + +

+	stat ::= ‘;’
+
+ +

+Function calls and assignments +can start with an open parenthesis. +This possibility leads to an ambiguity in Lua's grammar. +Consider the following fragment: + +

+     a = b + c
+     (print or io.write)('done')
+

+The grammar could see it in two ways: + +

+     a = b + c(print or io.write)('done')
+     
+     a = b + c; (print or io.write)('done')
+

+The current parser always sees such constructions +in the first way, +interpreting the open parenthesis +as the start of the arguments to a call. +To avoid this ambiguity, +it is a good practice to always precede with a semicolon +statements that start with a parenthesis: + +

+     ;(print or io.write)('done')
+
+ +

+A block can be explicitly delimited to produce a single statement: + +

+	stat ::= do block end
+

+Explicit blocks are useful +to control the scope of variable declarations. +Explicit blocks are also sometimes used to +add a return statement in the middle +of another block (see §3.3.4). + + + + + +

3.3.2 – Chunks

+ +

+The unit of compilation of Lua is called a chunk. +Syntactically, +a chunk is simply a block: + +

+	chunk ::= block
+
+ +

+Lua handles a chunk as the body of an anonymous function +with a variable number of arguments +(see §3.4.10). +As such, chunks can define local variables, +receive arguments, and return values. +Moreover, such anonymous function is compiled as in the +scope of an external local variable called _ENV (see §2.2). +The resulting function always has _ENV as its only upvalue, +even if it does not use that variable. + + +

+A chunk can be stored in a file or in a string inside the host program. +To execute a chunk, +Lua first precompiles the chunk into instructions for a virtual machine, +and then it executes the compiled code +with an interpreter for the virtual machine. + + +

+Chunks can also be precompiled into binary form; +see program luac for details. +Programs in source and compiled forms are interchangeable; +Lua automatically detects the file type and acts accordingly. + + + + + + +

3.3.3 – Assignment

+ +

+Lua allows multiple assignments. +Therefore, the syntax for assignment +defines a list of variables on the left side +and a list of expressions on the right side. +The elements in both lists are separated by commas: + +

+	stat ::= varlist ‘=’ explist
+	varlist ::= var {‘,’ var}
+	explist ::= exp {‘,’ exp}
+

+Expressions are discussed in §3.4. + + +

+Before the assignment, +the list of values is adjusted to the length of +the list of variables. +If there are more values than needed, +the excess values are thrown away. +If there are fewer values than needed, +the list is extended with as many nil's as needed. +If the list of expressions ends with a function call, +then all values returned by that call enter the list of values, +before the adjustment +(except when the call is enclosed in parentheses; see §3.4). + + +

+The assignment statement first evaluates all its expressions +and only then are the assignments performed. +Thus the code + +

+     i = 3
+     i, a[i] = i+1, 20
+

+sets a[3] to 20, without affecting a[4] +because the i in a[i] is evaluated (to 3) +before it is assigned 4. +Similarly, the line + +

+     x, y = y, x
+

+exchanges the values of x and y, +and + +

+     x, y, z = y, z, x
+

+cyclically permutes the values of x, y, and z. + + +

+The meaning of assignments to global variables +and table fields can be changed via metatables. +An assignment to an indexed variable t[i] = val is equivalent to +settable_event(t,i,val). +(See §2.4 for a complete description of the +settable_event function. +This function is not defined or callable in Lua. +We use it here only for explanatory purposes.) + + +

+An assignment to a global variable x = val +is equivalent to the assignment +_ENV.x = val (see §2.2). + + + + + +

3.3.4 – Control Structures

+The control structures +if, while, and repeat have the usual meaning and +familiar syntax: + + + + +

+	stat ::= while exp do block end
+	stat ::= repeat block until exp
+	stat ::= if exp then block {elseif exp then block} [else block] end
+

+Lua also has a for statement, in two flavors (see §3.3.5). + + +

+The condition expression of a +control structure can return any value. +Both false and nil are considered false. +All values different from nil and false are considered true +(in particular, the number 0 and the empty string are also true). + + +

+In the repeat–until loop, +the inner block does not end at the until keyword, +but only after the condition. +So, the condition can refer to local variables +declared inside the loop block. + + +

+The goto statement transfers the program control to a label. +For syntactical reasons, +labels in Lua are considered statements too: + + + +

+	stat ::= goto Name
+	stat ::= label
+	label ::= ‘::’ Name ‘::’
+
+ +

+A label is visible in the entire block where it is defined, +except +inside nested blocks where a label with the same name is defined and +inside nested functions. +A goto may jump to any visible label as long as it does not +enter into the scope of a local variable. + + +

+Labels and empty statements are called void statements, +as they perform no actions. + + +

+The break statement terminates the execution of a +while, repeat, or for loop, +skipping to the next statement after the loop: + + +

+	stat ::= break
+

+A break ends the innermost enclosing loop. + + +

+The return statement is used to return values +from a function or a chunk (which is a function in disguise). + +Functions can return more than one value, +so the syntax for the return statement is + +

+	stat ::= return [explist] [‘;’]
+
+ +

+The return statement can only be written +as the last statement of a block. +If it is really necessary to return in the middle of a block, +then an explicit inner block can be used, +as in the idiom do return end, +because now return is the last statement in its (inner) block. + + + + + +

3.3.5 – For Statement

+ +

+ +The for statement has two forms: +one numeric and one generic. + + +

+The numeric for loop repeats a block of code while a +control variable runs through an arithmetic progression. +It has the following syntax: + +

+	stat ::= for Name ‘=’ exp ‘,’ exp [‘,’ exp] do block end
+

+The block is repeated for name starting at the value of +the first exp, until it passes the second exp by steps of the +third exp. +More precisely, a for statement like + +

+     for v = e1, e2, e3 do block end
+

+is equivalent to the code: + +

+     do
+       local var, limit, step = tonumber(e1), tonumber(e2), tonumber(e3)
+       if not (var and limit and step) then error() end
+       while (step > 0 and var <= limit) or (step <= 0 and var >= limit) do
+         local v = var
+         block
+         var = var + step
+       end
+     end
+

+Note the following: + +

    + +
  • +All three control expressions are evaluated only once, +before the loop starts. +They must all result in numbers. +
    • + +
  • +var, limit, and step are invisible variables. +The names shown here are for explanatory purposes only. +
    • + +
  • +If the third expression (the step) is absent, +then a step of 1 is used. +
    • + +
  • +You can use break to exit a for loop. +
    • + +
  • +The loop variable v is local to the loop; +you cannot use its value after the for ends or is broken. +If you need this value, +assign it to another variable before breaking or exiting the loop. +
    • + +
+ +

+The generic for statement works over functions, +called iterators. +On each iteration, the iterator function is called to produce a new value, +stopping when this new value is nil. +The generic for loop has the following syntax: + +

+	stat ::= for namelist in explist do block end
+	namelist ::= Name {‘,’ Name}
+

+A for statement like + +

+     for var_1, ···, var_n in explist do block end
+

+is equivalent to the code: + +

+     do
+       local f, s, var = explist
+       while true do
+         local var_1, ···, var_n = f(s, var)
+         if var_1 == nil then break end
+         var = var_1
+         block
+       end
+     end
+

+Note the following: + +

    + +
  • +explist is evaluated only once. +Its results are an iterator function, +a state, +and an initial value for the first iterator variable. +
    • + +
  • +f, s, and var are invisible variables. +The names are here for explanatory purposes only. +
    • + +
  • +You can use break to exit a for loop. +
    • + +
  • +The loop variables var_i are local to the loop; +you cannot use their values after the for ends. +If you need these values, +then assign them to other variables before breaking or exiting the loop. +
    • + +
+ + + + +

3.3.6 – Function Calls as Statements

+To allow possible side-effects, +function calls can be executed as statements: + +

+	stat ::= functioncall
+

+In this case, all returned values are thrown away. +Function calls are explained in §3.4.9. + + + + + +

3.3.7 – Local Declarations

+Local variables can be declared anywhere inside a block. +The declaration can include an initial assignment: + +

+	stat ::= local namelist [‘=’ explist]
+

+If present, an initial assignment has the same semantics +of a multiple assignment (see §3.3.3). +Otherwise, all variables are initialized with nil. + + +

+A chunk is also a block (see §3.3.2), +and so local variables can be declared in a chunk outside any explicit block. + + +

+The visibility rules for local variables are explained in §3.5. + + + + + + + +

3.4 – Expressions

+ +

+The basic expressions in Lua are the following: + +

+	exp ::= prefixexp
+	exp ::= nil | false | true
+	exp ::= Number
+	exp ::= String
+	exp ::= functiondef
+	exp ::= tableconstructor
+	exp ::= ‘...’
+	exp ::= exp binop exp
+	exp ::= unop exp
+	prefixexp ::= var | functioncall | ‘(’ exp ‘)’
+
+ +

+Numbers and literal strings are explained in §3.1; +variables are explained in §3.2; +function definitions are explained in §3.4.10; +function calls are explained in §3.4.9; +table constructors are explained in §3.4.8. +Vararg expressions, +denoted by three dots ('...'), can only be used when +directly inside a vararg function; +they are explained in §3.4.10. + + +

+Binary operators comprise arithmetic operators (see §3.4.1), +relational operators (see §3.4.3), logical operators (see §3.4.4), +and the concatenation operator (see §3.4.5). +Unary operators comprise the unary minus (see §3.4.1), +the unary not (see §3.4.4), +and the unary length operator (see §3.4.6). + + +

+Both function calls and vararg expressions can result in multiple values. +If a function call is used as a statement (see §3.3.6), +then its return list is adjusted to zero elements, +thus discarding all returned values. +If an expression is used as the last (or the only) element +of a list of expressions, +then no adjustment is made +(unless the expression is enclosed in parentheses). +In all other contexts, +Lua adjusts the result list to one element, +either discarding all values except the first one +or adding a single nil if there are no values. + + +

+Here are some examples: + +

+     f()                -- adjusted to 0 results
+     g(f(), x)          -- f() is adjusted to 1 result
+     g(x, f())          -- g gets x plus all results from f()
+     a,b,c = f(), x     -- f() is adjusted to 1 result (c gets nil)
+     a,b = ...          -- a gets the first vararg parameter, b gets
+                        -- the second (both a and b can get nil if there
+                        -- is no corresponding vararg parameter)
+     
+     a,b,c = x, f()     -- f() is adjusted to 2 results
+     a,b,c = f()        -- f() is adjusted to 3 results
+     return f()         -- returns all results from f()
+     return ...         -- returns all received vararg parameters
+     return x,y,f()     -- returns x, y, and all results from f()
+     {f()}              -- creates a list with all results from f()
+     {...}              -- creates a list with all vararg parameters
+     {f(), nil}         -- f() is adjusted to 1 result
+
+ +

+Any expression enclosed in parentheses always results in only one value. +Thus, +(f(x,y,z)) is always a single value, +even if f returns several values. +(The value of (f(x,y,z)) is the first value returned by f +or nil if f does not return any values.) + + + +

3.4.1 – Arithmetic Operators

+Lua supports the usual arithmetic operators: +the binary + (addition), +- (subtraction), * (multiplication), +/ (division), % (modulo), and ^ (exponentiation); +and unary - (mathematical negation). +If the operands are numbers, or strings that can be converted to +numbers (see §3.4.2), +then all operations have the usual meaning. +Exponentiation works for any exponent. +For instance, x^(-0.5) computes the inverse of the square root of x. +Modulo is defined as + +

+     a % b == a - math.floor(a/b)*b
+

+That is, it is the remainder of a division that rounds +the quotient towards minus infinity. + + + + + +

3.4.2 – Coercion

+ +

+Lua provides automatic conversion between +string and number values at run time. +Any arithmetic operation applied to a string tries to convert +this string to a number, following the rules of the Lua lexer. +(The string may have leading and trailing spaces and a sign.) +Conversely, whenever a number is used where a string is expected, +the number is converted to a string, in a reasonable format. +For complete control over how numbers are converted to strings, +use the format function from the string library +(see string.format). + + + + + +

3.4.3 – Relational Operators

+The relational operators in Lua are + +

+     ==    ~=    <     >     <=    >=
+

+These operators always result in false or true. + + +

+Equality (==) first compares the type of its operands. +If the types are different, then the result is false. +Otherwise, the values of the operands are compared. +Numbers and strings are compared in the usual way. +Tables, userdata, and threads +are compared by reference: +two objects are considered equal only if they are the same object. +Every time you create a new object +(a table, userdata, or thread), +this new object is different from any previously existing object. +Closures with the same reference are always equal. +Closures with any detectable difference +(different behavior, different definition) are always different. + + +

+You can change the way that Lua compares tables and userdata +by using the "eq" metamethod (see §2.4). + + +

+The conversion rules of §3.4.2 +do not apply to equality comparisons. +Thus, "0"==0 evaluates to false, +and t[0] and t["0"] denote different +entries in a table. + + +

+The operator ~= is exactly the negation of equality (==). + + +

+The order operators work as follows. +If both arguments are numbers, then they are compared as such. +Otherwise, if both arguments are strings, +then their values are compared according to the current locale. +Otherwise, Lua tries to call the "lt" or the "le" +metamethod (see §2.4). +A comparison a > b is translated to b < a +and a >= b is translated to b <= a. + + + + + +

3.4.4 – Logical Operators

+The logical operators in Lua are +and, or, and not. +Like the control structures (see §3.3.4), +all logical operators consider both false and nil as false +and anything else as true. + + +

+The negation operator not always returns false or true. +The conjunction operator and returns its first argument +if this value is false or nil; +otherwise, and returns its second argument. +The disjunction operator or returns its first argument +if this value is different from nil and false; +otherwise, or returns its second argument. +Both and and or use short-cut evaluation; +that is, +the second operand is evaluated only if necessary. +Here are some examples: + +

+     10 or 20            --> 10
+     10 or error()       --> 10
+     nil or "a"          --> "a"
+     nil and 10          --> nil
+     false and error()   --> false
+     false and nil       --> false
+     false or nil        --> nil
+     10 and 20           --> 20
+

+(In this manual, +--> indicates the result of the preceding expression.) + + + + + +

3.4.5 – Concatenation

+The string concatenation operator in Lua is +denoted by two dots ('..'). +If both operands are strings or numbers, then they are converted to +strings according to the rules mentioned in §3.4.2. +Otherwise, the __concat metamethod is called (see §2.4). + + + + + +

3.4.6 – The Length Operator

+ +

+The length operator is denoted by the unary prefix operator #. +The length of a string is its number of bytes +(that is, the usual meaning of string length when each +character is one byte). + + +

+A program can modify the behavior of the length operator for +any value but strings through the __len metamethod (see §2.4). + + +

+Unless a __len metamethod is given, +the length of a table t is only defined if the +table is a sequence, +that is, +the set of its positive numeric keys is equal to {1..n} +for some integer n. +In that case, n is its length. +Note that a table like + +

+     {10, 20, nil, 40}
+

+is not a sequence, because it has the key 4 +but does not have the key 3. +(So, there is no n such that the set {1..n} is equal +to the set of positive numeric keys of that table.) +Note, however, that non-numeric keys do not interfere +with whether a table is a sequence. + + + + + +

3.4.7 – Precedence

+Operator precedence in Lua follows the table below, +from lower to higher priority: + +

+     or
+     and
+     <     >     <=    >=    ~=    ==
+     ..
+     +     -
+     *     /     %
+     not   #     - (unary)
+     ^
+

+As usual, +you can use parentheses to change the precedences of an expression. +The concatenation ('..') and exponentiation ('^') +operators are right associative. +All other binary operators are left associative. + + + + + +

3.4.8 – Table Constructors

+Table constructors are expressions that create tables. +Every time a constructor is evaluated, a new table is created. +A constructor can be used to create an empty table +or to create a table and initialize some of its fields. +The general syntax for constructors is + +

+	tableconstructor ::= ‘{’ [fieldlist] ‘}’
+	fieldlist ::= field {fieldsep field} [fieldsep]
+	field ::= ‘[’ exp ‘]’ ‘=’ exp | Name ‘=’ exp | exp
+	fieldsep ::= ‘,’ | ‘;’
+
+ +

+Each field of the form [exp1] = exp2 adds to the new table an entry +with key exp1 and value exp2. +A field of the form name = exp is equivalent to +["name"] = exp. +Finally, fields of the form exp are equivalent to +[i] = exp, where i are consecutive numerical integers, +starting with 1. +Fields in the other formats do not affect this counting. +For example, + +

+     a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
+

+is equivalent to + +

+     do
+       local t = {}
+       t[f(1)] = g
+       t[1] = "x"         -- 1st exp
+       t[2] = "y"         -- 2nd exp
+       t.x = 1            -- t["x"] = 1
+       t[3] = f(x)        -- 3rd exp
+       t[30] = 23
+       t[4] = 45          -- 4th exp
+       a = t
+     end
+
+ +

+If the last field in the list has the form exp +and the expression is a function call or a vararg expression, +then all values returned by this expression enter the list consecutively +(see §3.4.9). + + +

+The field list can have an optional trailing separator, +as a convenience for machine-generated code. + + + + + +

3.4.9 – Function Calls

+A function call in Lua has the following syntax: + +

+	functioncall ::= prefixexp args
+

+In a function call, +first prefixexp and args are evaluated. +If the value of prefixexp has type function, +then this function is called +with the given arguments. +Otherwise, the prefixexp "call" metamethod is called, +having as first parameter the value of prefixexp, +followed by the original call arguments +(see §2.4). + + +

+The form + +

+	functioncall ::= prefixexp ‘:’ Name args
+

+can be used to call "methods". +A call v:name(args) +is syntactic sugar for v.name(v,args), +except that v is evaluated only once. + + +

+Arguments have the following syntax: + +

+	args ::= ‘(’ [explist] ‘)’
+	args ::= tableconstructor
+	args ::= String
+

+All argument expressions are evaluated before the call. +A call of the form f{fields} is +syntactic sugar for f({fields}); +that is, the argument list is a single new table. +A call of the form f'string' +(or f"string" or f[[string]]) +is syntactic sugar for f('string'); +that is, the argument list is a single literal string. + + +

+A call of the form return functioncall is called +a tail call. +Lua implements proper tail calls +(or proper tail recursion): +in a tail call, +the called function reuses the stack entry of the calling function. +Therefore, there is no limit on the number of nested tail calls that +a program can execute. +However, a tail call erases any debug information about the +calling function. +Note that a tail call only happens with a particular syntax, +where the return has one single function call as argument; +this syntax makes the calling function return exactly +the returns of the called function. +So, none of the following examples are tail calls: + +

+     return (f(x))        -- results adjusted to 1
+     return 2 * f(x)
+     return x, f(x)       -- additional results
+     f(x); return         -- results discarded
+     return x or f(x)     -- results adjusted to 1
+
+ + + + +

3.4.10 – Function Definitions

+ +

+The syntax for function definition is + +

+	functiondef ::= function funcbody
+	funcbody ::= ‘(’ [parlist] ‘)’ block end
+
+ +

+The following syntactic sugar simplifies function definitions: + +

+	stat ::= function funcname funcbody
+	stat ::= local function Name funcbody
+	funcname ::= Name {‘.’ Name} [‘:’ Name]
+

+The statement + +

+     function f () body end
+

+translates to + +

+     f = function () body end
+

+The statement + +

+     function t.a.b.c.f () body end
+

+translates to + +

+     t.a.b.c.f = function () body end
+

+The statement + +

+     local function f () body end
+

+translates to + +

+     local f; f = function () body end
+

+not to + +

+     local f = function () body end
+

+(This only makes a difference when the body of the function +contains references to f.) + + +

+A function definition is an executable expression, +whose value has type function. +When Lua precompiles a chunk, +all its function bodies are precompiled too. +Then, whenever Lua executes the function definition, +the function is instantiated (or closed). +This function instance (or closure) +is the final value of the expression. + + +

+Parameters act as local variables that are +initialized with the argument values: + +

+	parlist ::= namelist [‘,’ ‘...’] | ‘...’
+

+When a function is called, +the list of arguments is adjusted to +the length of the list of parameters, +unless the function is a vararg function, +which is indicated by three dots ('...') +at the end of its parameter list. +A vararg function does not adjust its argument list; +instead, it collects all extra arguments and supplies them +to the function through a vararg expression, +which is also written as three dots. +The value of this expression is a list of all actual extra arguments, +similar to a function with multiple results. +If a vararg expression is used inside another expression +or in the middle of a list of expressions, +then its return list is adjusted to one element. +If the expression is used as the last element of a list of expressions, +then no adjustment is made +(unless that last expression is enclosed in parentheses). + + +

+As an example, consider the following definitions: + +

+     function f(a, b) end
+     function g(a, b, ...) end
+     function r() return 1,2,3 end
+

+Then, we have the following mapping from arguments to parameters and +to the vararg expression: + +

+     CALL            PARAMETERS
+     
+     f(3)             a=3, b=nil
+     f(3, 4)          a=3, b=4
+     f(3, 4, 5)       a=3, b=4
+     f(r(), 10)       a=1, b=10
+     f(r())           a=1, b=2
+     
+     g(3)             a=3, b=nil, ... -->  (nothing)
+     g(3, 4)          a=3, b=4,   ... -->  (nothing)
+     g(3, 4, 5, 8)    a=3, b=4,   ... -->  5  8
+     g(5, r())        a=5, b=1,   ... -->  2  3
+
+ +

+Results are returned using the return statement (see §3.3.4). +If control reaches the end of a function +without encountering a return statement, +then the function returns with no results. + + +

+ +There is a system-dependent limit on the number of values +that a function may return. +This limit is guaranteed to be larger than 1000. + + +

+The colon syntax +is used for defining methods, +that is, functions that have an implicit extra parameter self. +Thus, the statement + +

+     function t.a.b.c:f (params) body end
+

+is syntactic sugar for + +

+     t.a.b.c.f = function (self, params) body end
+
+ + + + + + +

3.5 – Visibility Rules

+ +

+ +Lua is a lexically scoped language. +The scope of a local variable begins at the first statement after +its declaration and lasts until the last non-void statement +of the innermost block that includes the declaration. +Consider the following example: + +

+     x = 10                -- global variable
+     do                    -- new block
+       local x = x         -- new 'x', with value 10
+       print(x)            --> 10
+       x = x+1
+       do                  -- another block
+         local x = x+1     -- another 'x'
+         print(x)          --> 12
+       end
+       print(x)            --> 11
+     end
+     print(x)              --> 10  (the global one)
+
+ +

+Notice that, in a declaration like local x = x, +the new x being declared is not in scope yet, +and so the second x refers to the outside variable. + + +

+Because of the lexical scoping rules, +local variables can be freely accessed by functions +defined inside their scope. +A local variable used by an inner function is called +an upvalue, or external local variable, +inside the inner function. + + +

+Notice that each execution of a local statement +defines new local variables. +Consider the following example: + +

+     a = {}
+     local x = 20
+     for i=1,10 do
+       local y = 0
+       a[i] = function () y=y+1; return x+y end
+     end
+

+The loop creates ten closures +(that is, ten instances of the anonymous function). +Each of these closures uses a different y variable, +while all of them share the same x. + + + + + +

4 – The Application Program Interface

+ +

+ +This section describes the C API for Lua, that is, +the set of C functions available to the host program to communicate +with Lua. +All API functions and related types and constants +are declared in the header file lua.h. + + +

+Even when we use the term "function", +any facility in the API may be provided as a macro instead. +Except where stated otherwise, +all such macros use each of their arguments exactly once +(except for the first argument, which is always a Lua state), +and so do not generate any hidden side-effects. + + +

+As in most C libraries, +the Lua API functions do not check their arguments for validity or consistency. +However, you can change this behavior by compiling Lua +with the macro LUA_USE_APICHECK defined. + + + +

4.1 – The Stack

+ +

+Lua uses a virtual stack to pass values to and from C. +Each element in this stack represents a Lua value +(nil, number, string, etc.). + + +

+Whenever Lua calls C, the called function gets a new stack, +which is independent of previous stacks and of stacks of +C functions that are still active. +This stack initially contains any arguments to the C function +and it is where the C function pushes its results +to be returned to the caller (see lua_CFunction). + + +

+For convenience, +most query operations in the API do not follow a strict stack discipline. +Instead, they can refer to any element in the stack +by using an index: +A positive index represents an absolute stack position +(starting at 1); +a negative index represents an offset relative to the top of the stack. +More specifically, if the stack has n elements, +then index 1 represents the first element +(that is, the element that was pushed onto the stack first) +and +index n represents the last element; +index -1 also represents the last element +(that is, the element at the top) +and index -n represents the first element. + + + + + +

4.2 – Stack Size

+ +

+When you interact with the Lua API, +you are responsible for ensuring consistency. +In particular, +you are responsible for controlling stack overflow. +You can use the function lua_checkstack +to ensure that the stack has extra slots when pushing new elements. + + +

+Whenever Lua calls C, +it ensures that the stack has at least LUA_MINSTACK extra slots. +LUA_MINSTACK is defined as 20, +so that usually you do not have to worry about stack space +unless your code has loops pushing elements onto the stack. + + +

+When you call a Lua function +without a fixed number of results (see lua_call), +Lua ensures that the stack has enough size for all results, +but it does not ensure any extra space. +So, before pushing anything in the stack after such a call +you should use lua_checkstack. + + + + + +

4.3 – Valid and Acceptable Indices

+ +

+Any function in the API that receives stack indices +works only with valid indices or acceptable indices. + + +

+A valid index is an index that refers to a +real position within the stack, that is, +its position lies between 1 and the stack top +(1 ≤ abs(index) ≤ top). + +Usually, functions that can modify the value at an index +require valid indices. + + +

+Unless otherwise noted, +any function that accepts valid indices also accepts pseudo-indices, +which represent some Lua values that are accessible to C code +but which are not in the stack. +Pseudo-indices are used to access the registry +and the upvalues of a C function (see §4.4). + + +

+Functions that do not need a specific stack position, +but only a value in the stack (e.g., query functions), +can be called with acceptable indices. +An acceptable index can be any valid index, +including the pseudo-indices, +but it also can be any positive index after the stack top +within the space allocated for the stack, +that is, indices up to the stack size. +(Note that 0 is never an acceptable index.) +Except when noted otherwise, +functions in the API work with acceptable indices. + + +

+Acceptable indices serve to avoid extra tests +against the stack top when querying the stack. +For instance, a C function can query its third argument +without the need to first check whether there is a third argument, +that is, without the need to check whether 3 is a valid index. + + +

+For functions that can be called with acceptable indices, +any non-valid index is treated as if it +contains a value of a virtual type LUA_TNONE, +which behaves like a nil value. + + + + + +

4.4 – C Closures

+ +

+When a C function is created, +it is possible to associate some values with it, +thus creating a C closure +(see lua_pushcclosure); +these values are called upvalues and are +accessible to the function whenever it is called. + + +

+Whenever a C function is called, +its upvalues are located at specific pseudo-indices. +These pseudo-indices are produced by the macro +lua_upvalueindex. +The first value associated with a function is at position +lua_upvalueindex(1), and so on. +Any access to lua_upvalueindex(n), +where n is greater than the number of upvalues of the +current function (but not greater than 256), +produces an acceptable but invalid index. + + + + + +

4.5 – Registry

+ +

+Lua provides a registry, +a predefined table that can be used by any C code to +store whatever Lua values it needs to store. +The registry table is always located at pseudo-index +LUA_REGISTRYINDEX, +which is a valid index. +Any C library can store data into this table, +but it should take care to choose keys +that are different from those used +by other libraries, to avoid collisions. +Typically, you should use as key a string containing your library name, +or a light userdata with the address of a C object in your code, +or any Lua object created by your code. +As with global names, +string keys starting with an underscore followed by +uppercase letters are reserved for Lua. + + +

+The integer keys in the registry are used by the reference mechanism, +implemented by the auxiliary library, +and by some predefined values. +Therefore, integer keys should not be used for other purposes. + + +

+When you create a new Lua state, +its registry comes with some predefined values. +These predefined values are indexed with integer keys +defined as constants in lua.h. +The following constants are defined: + +

    +
  • LUA_RIDX_MAINTHREAD: At this index the registry has +the main thread of the state. +(The main thread is the one created together with the state.) +
    • + +
  • LUA_RIDX_GLOBALS: At this index the registry has +the global environment. +
    • +
+ + + + +

4.6 – Error Handling in C

+ +

+Internally, Lua uses the C longjmp facility to handle errors. +(You can also choose to use exceptions if you compile Lua as C++; +search for LUAI_THROW in the source code.) +When Lua faces any error +(such as a memory allocation error, type errors, syntax errors, +and runtime errors) +it raises an error; +that is, it does a long jump. +A protected environment uses setjmp +to set a recovery point; +any error jumps to the most recent active recovery point. + + +

+If an error happens outside any protected environment, +Lua calls a panic function (see lua_atpanic) +and then calls abort, +thus exiting the host application. +Your panic function can avoid this exit by +never returning +(e.g., doing a long jump to your own recovery point outside Lua). + + +

+The panic function runs as if it were a message handler (see §2.3); +in particular, the error message is at the top of the stack. +However, there is no guarantees about stack space. +To push anything on the stack, +the panic function should first check the available space (see §4.2). + + +

+Most functions in the API can throw an error, +for instance due to a memory allocation error. +The documentation for each function indicates whether +it can throw errors. + + +

+Inside a C function you can throw an error by calling lua_error. + + + + + +

4.7 – Handling Yields in C

+ +

+Internally, Lua uses the C longjmp facility to yield a coroutine. +Therefore, if a function foo calls an API function +and this API function yields +(directly or indirectly by calling another function that yields), +Lua cannot return to foo any more, +because the longjmp removes its frame from the C stack. + + +

+To avoid this kind of problem, +Lua raises an error whenever it tries to yield across an API call, +except for three functions: +lua_yieldk, lua_callk, and lua_pcallk. +All those functions receive a continuation function +(as a parameter called k) to continue execution after a yield. + + +

+We need to set some terminology to explain continuations. +We have a C function called from Lua which we will call +the original function. +This original function then calls one of those three functions in the C API, +which we will call the callee function, +that then yields the current thread. +(This can happen when the callee function is lua_yieldk, +or when the callee function is either lua_callk or lua_pcallk +and the function called by them yields.) + + +

+Suppose the running thread yields while executing the callee function. +After the thread resumes, +it eventually will finish running the callee function. +However, +the callee function cannot return to the original function, +because its frame in the C stack was destroyed by the yield. +Instead, Lua calls a continuation function, +which was given as an argument to the callee function. +As the name implies, +the continuation function should continue the task +of the original function. + + +

+Lua treats the continuation function as if it were the original function. +The continuation function receives the same Lua stack +from the original function, +in the same state it would be if the callee function had returned. +(For instance, +after a lua_callk the function and its arguments are +removed from the stack and replaced by the results from the call.) +It also has the same upvalues. +Whatever it returns is handled by Lua as if it were the return +of the original function. + + +

+The only difference in the Lua state between the original function +and its continuation is the result of a call to lua_getctx. + + + + + +

4.8 – Functions and Types

+ +

+Here we list all functions and types from the C API in +alphabetical order. +Each function has an indicator like this: +[-o, +p, x] + + +

+The first field, o, +is how many elements the function pops from the stack. +The second field, p, +is how many elements the function pushes onto the stack. +(Any function always pushes its results after popping its arguments.) +A field in the form x|y means the function can push (or pop) +x or y elements, +depending on the situation; +an interrogation mark '?' means that +we cannot know how many elements the function pops/pushes +by looking only at its arguments +(e.g., they may depend on what is on the stack). +The third field, x, +tells whether the function may throw errors: +'-' means the function never throws any error; +'e' means the function may throw errors; +'v' means the function may throw an error on purpose. + + + +

lua_absindex

+[-0, +0, –] +

int lua_absindex (lua_State *L, int idx);
+ +

+Converts the acceptable index idx into an absolute index +(that is, one that does not depend on the stack top). + + + + + +

lua_Alloc

+
typedef void * (*lua_Alloc) (void *ud,
+                             void *ptr,
+                             size_t osize,
+                             size_t nsize);
+ +

+The type of the memory-allocation function used by Lua states. +The allocator function must provide a +functionality similar to realloc, +but not exactly the same. +Its arguments are +ud, an opaque pointer passed to lua_newstate; +ptr, a pointer to the block being allocated/reallocated/freed; +osize, the original size of the block or some code about what +is being allocated; +nsize, the new size of the block. + + +

+When ptr is not NULL, +osize is the size of the block pointed by ptr, +that is, the size given when it was allocated or reallocated. + + +

+When ptr is NULL, +osize encodes the kind of object that Lua is allocating. +osize is any of +LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, +LUA_TUSERDATA, or LUA_TTHREAD when (and only when) +Lua is creating a new object of that type. +When osize is some other value, +Lua is allocating memory for something else. + + +

+Lua assumes the following behavior from the allocator function: + + +

+When nsize is zero, +the allocator should behave like free +and return NULL. + + +

+When nsize is not zero, +the allocator should behave like realloc. +The allocator returns NULL +if and only if it cannot fulfill the request. +Lua assumes that the allocator never fails when +osize >= nsize. + + +

+Here is a simple implementation for the allocator function. +It is used in the auxiliary library by luaL_newstate. + +

+     static void *l_alloc (void *ud, void *ptr, size_t osize,
+                                                size_t nsize) {
+       (void)ud;  (void)osize;  /* not used */
+       if (nsize == 0) {
+         free(ptr);
+         return NULL;
+       }
+       else
+         return realloc(ptr, nsize);
+     }
+

+Note that Standard C ensures +that free(NULL) has no effect and that +realloc(NULL, size) is equivalent to malloc(size). +This code assumes that realloc does not fail when shrinking a block. +(Although Standard C does not ensure this behavior, +it seems to be a safe assumption.) + + + + + +

lua_arith

+[-(2|1), +1, e] +

void lua_arith (lua_State *L, int op);
+ +

+Performs an arithmetic operation over the two values +(or one, in the case of negation) +at the top of the stack, +with the value at the top being the second operand, +pops these values, and pushes the result of the operation. +The function follows the semantics of the corresponding Lua operator +(that is, it may call metamethods). + + +

+The value of op must be one of the following constants: + +

+ + + + +

lua_atpanic

+[-0, +0, –] +

lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);
+ +

+Sets a new panic function and returns the old one (see §4.6). + + + + + +

lua_call

+[-(nargs+1), +nresults, e] +

void lua_call (lua_State *L, int nargs, int nresults);
+ +

+Calls a function. + + +

+To call a function you must use the following protocol: +first, the function to be called is pushed onto the stack; +then, the arguments to the function are pushed +in direct order; +that is, the first argument is pushed first. +Finally you call lua_call; +nargs is the number of arguments that you pushed onto the stack. +All arguments and the function value are popped from the stack +when the function is called. +The function results are pushed onto the stack when the function returns. +The number of results is adjusted to nresults, +unless nresults is LUA_MULTRET. +In this case, all results from the function are pushed. +Lua takes care that the returned values fit into the stack space. +The function results are pushed onto the stack in direct order +(the first result is pushed first), +so that after the call the last result is on the top of the stack. + + +

+Any error inside the called function is propagated upwards +(with a longjmp). + + +

+The following example shows how the host program can do the +equivalent to this Lua code: + +

+     a = f("how", t.x, 14)
+

+Here it is in C: + +

+     lua_getglobal(L, "f");                  /* function to be called */
+     lua_pushstring(L, "how");                        /* 1st argument */
+     lua_getglobal(L, "t");                    /* table to be indexed */
+     lua_getfield(L, -1, "x");        /* push result of t.x (2nd arg) */
+     lua_remove(L, -2);                  /* remove 't' from the stack */
+     lua_pushinteger(L, 14);                          /* 3rd argument */
+     lua_call(L, 3, 1);     /* call 'f' with 3 arguments and 1 result */
+     lua_setglobal(L, "a");                         /* set global 'a' */
+

+Note that the code above is "balanced": +at its end, the stack is back to its original configuration. +This is considered good programming practice. + + + + + +

lua_callk

+[-(nargs + 1), +nresults, e] +

void lua_callk (lua_State *L, int nargs, int nresults, int ctx,
+                lua_CFunction k);
+ +

+This function behaves exactly like lua_call, +but allows the called function to yield (see §4.7). + + + + + +

lua_CFunction

+
typedef int (*lua_CFunction) (lua_State *L);
+ +

+Type for C functions. + + +

+In order to communicate properly with Lua, +a C function must use the following protocol, +which defines the way parameters and results are passed: +a C function receives its arguments from Lua in its stack +in direct order (the first argument is pushed first). +So, when the function starts, +lua_gettop(L) returns the number of arguments received by the function. +The first argument (if any) is at index 1 +and its last argument is at index lua_gettop(L). +To return values to Lua, a C function just pushes them onto the stack, +in direct order (the first result is pushed first), +and returns the number of results. +Any other value in the stack below the results will be properly +discarded by Lua. +Like a Lua function, a C function called by Lua can also return +many results. + + +

+As an example, the following function receives a variable number +of numerical arguments and returns their average and sum: + +

+     static int foo (lua_State *L) {
+       int n = lua_gettop(L);    /* number of arguments */
+       lua_Number sum = 0;
+       int i;
+       for (i = 1; i <= n; i++) {
+         if (!lua_isnumber(L, i)) {
+           lua_pushstring(L, "incorrect argument");
+           lua_error(L);
+         }
+         sum += lua_tonumber(L, i);
+       }
+       lua_pushnumber(L, sum/n);        /* first result */
+       lua_pushnumber(L, sum);         /* second result */
+       return 2;                   /* number of results */
+     }
+
+ + + + +

lua_checkstack

+[-0, +0, –] +

int lua_checkstack (lua_State *L, int extra);
+ +

+Ensures that there are at least extra free stack slots in the stack. +It returns false if it cannot fulfill the request, +because it would cause the stack to be larger than a fixed maximum size +(typically at least a few thousand elements) or +because it cannot allocate memory for the new stack size. +This function never shrinks the stack; +if the stack is already larger than the new size, +it is left unchanged. + + + + + +

lua_close

+[-0, +0, –] +

void lua_close (lua_State *L);
+ +

+Destroys all objects in the given Lua state +(calling the corresponding garbage-collection metamethods, if any) +and frees all dynamic memory used by this state. +On several platforms, you may not need to call this function, +because all resources are naturally released when the host program ends. +On the other hand, long-running programs that create multiple states, +such as daemons or web servers, +might need to close states as soon as they are not needed. + + + + + +

lua_compare

+[-0, +0, e] +

int lua_compare (lua_State *L, int index1, int index2, int op);
+ +

+Compares two Lua values. +Returns 1 if the value at index index1 satisfies op +when compared with the value at index index2, +following the semantics of the corresponding Lua operator +(that is, it may call metamethods). +Otherwise returns 0. +Also returns 0 if any of the indices is non valid. + + +

+The value of op must be one of the following constants: + +

    + +
  • LUA_OPEQ: compares for equality (==)
    • +
  • LUA_OPLT: compares for less than (<)
    • +
  • LUA_OPLE: compares for less or equal (<=)
    • + +
+ + + + +

lua_concat

+[-n, +1, e] +

void lua_concat (lua_State *L, int n);
+ +

+Concatenates the n values at the top of the stack, +pops them, and leaves the result at the top. +If n is 1, the result is the single value on the stack +(that is, the function does nothing); +if n is 0, the result is the empty string. +Concatenation is performed following the usual semantics of Lua +(see §3.4.5). + + + + + +

lua_copy

+[-0, +0, –] +

void lua_copy (lua_State *L, int fromidx, int toidx);
+ +

+Moves the element at index fromidx +into the valid index toidx +without shifting any element +(therefore replacing the value at that position). + + + + + +

lua_createtable

+[-0, +1, e] +

void lua_createtable (lua_State *L, int narr, int nrec);
+ +

+Creates a new empty table and pushes it onto the stack. +Parameter narr is a hint for how many elements the table +will have as a sequence; +parameter nrec is a hint for how many other elements +the table will have. +Lua may use these hints to preallocate memory for the new table. +This pre-allocation is useful for performance when you know in advance +how many elements the table will have. +Otherwise you can use the function lua_newtable. + + + + + +

lua_dump

+[-0, +0, e] +

int lua_dump (lua_State *L, lua_Writer writer, void *data);
+ +

+Dumps a function as a binary chunk. +Receives a Lua function on the top of the stack +and produces a binary chunk that, +if loaded again, +results in a function equivalent to the one dumped. +As it produces parts of the chunk, +lua_dump calls function writer (see lua_Writer) +with the given data +to write them. + + +

+The value returned is the error code returned by the last +call to the writer; +0 means no errors. + + +

+This function does not pop the Lua function from the stack. + + + + + +

lua_error

+[-1, +0, v] +

int lua_error (lua_State *L);
+ +

+Generates a Lua error. +The error message (which can actually be a Lua value of any type) +must be on the stack top. +This function does a long jump, +and therefore never returns +(see luaL_error). + + + + + +

lua_gc

+[-0, +0, e] +

int lua_gc (lua_State *L, int what, int data);
+ +

+Controls the garbage collector. + + +

+This function performs several tasks, +according to the value of the parameter what: + +

    + +
  • LUA_GCSTOP: +stops the garbage collector. +
    • + +
  • LUA_GCRESTART: +restarts the garbage collector. +
    • + +
  • LUA_GCCOLLECT: +performs a full garbage-collection cycle. +
    • + +
  • LUA_GCCOUNT: +returns the current amount of memory (in Kbytes) in use by Lua. +
    • + +
  • LUA_GCCOUNTB: +returns the remainder of dividing the current amount of bytes of +memory in use by Lua by 1024. +
    • + +
  • LUA_GCSTEP: +performs an incremental step of garbage collection. +The step "size" is controlled by data +(larger values mean more steps) in a non-specified way. +If you want to control the step size +you must experimentally tune the value of data. +The function returns 1 if the step finished a +garbage-collection cycle. +
    • + +
  • LUA_GCSETPAUSE: +sets data as the new value +for the pause of the collector (see §2.5). +The function returns the previous value of the pause. +
    • + +
  • LUA_GCSETSTEPMUL: +sets data as the new value for the step multiplier of +the collector (see §2.5). +The function returns the previous value of the step multiplier. +
    • + +
  • LUA_GCISRUNNING: +returns a boolean that tells whether the collector is running +(i.e., not stopped). +
    • + +
  • LUA_GCGEN: +changes the collector to generational mode +(see §2.5). +
    • + +
  • LUA_GCINC: +changes the collector to incremental mode. +This is the default mode. +
    • + +
+ +

+For more details about these options, +see collectgarbage. + + + + + +

lua_getallocf

+[-0, +0, –] +

lua_Alloc lua_getallocf (lua_State *L, void **ud);
+ +

+Returns the memory-allocation function of a given state. +If ud is not NULL, Lua stores in *ud the +opaque pointer passed to lua_newstate. + + + + + +

lua_getctx

+[-0, +0, –] +

int lua_getctx (lua_State *L, int *ctx);
+ +

+This function is called by a continuation function (see §4.7) +to retrieve the status of the thread and a context information. + + +

+When called in the original function, +lua_getctx always returns LUA_OK +and does not change the value of its argument ctx. +When called inside a continuation function, +lua_getctx returns LUA_YIELD and sets +the value of ctx to be the context information +(the value passed as the ctx argument +to the callee together with the continuation function). + + +

+When the callee is lua_pcallk, +Lua may also call its continuation function +to handle errors during the call. +That is, upon an error in the function called by lua_pcallk, +Lua may not return to the original function +but instead may call the continuation function. +In that case, a call to lua_getctx will return the error code +(the value that would be returned by lua_pcallk); +the value of ctx will be set to the context information, +as in the case of a yield. + + + + + +

lua_getfield

+[-0, +1, e] +

void lua_getfield (lua_State *L, int index, const char *k);
+ +

+Pushes onto the stack the value t[k], +where t is the value at the given index. +As in Lua, this function may trigger a metamethod +for the "index" event (see §2.4). + + + + + +

lua_getglobal

+[-0, +1, e] +

void lua_getglobal (lua_State *L, const char *name);
+ +

+Pushes onto the stack the value of the global name. + + + + + +

lua_getmetatable

+[-0, +(0|1), –] +

int lua_getmetatable (lua_State *L, int index);
+ +

+Pushes onto the stack the metatable of the value at the given index. +If the value does not have a metatable, +the function returns 0 and pushes nothing on the stack. + + + + + +

lua_gettable

+[-1, +1, e] +

void lua_gettable (lua_State *L, int index);
+ +

+Pushes onto the stack the value t[k], +where t is the value at the given index +and k is the value at the top of the stack. + + +

+This function pops the key from the stack +(putting the resulting value in its place). +As in Lua, this function may trigger a metamethod +for the "index" event (see §2.4). + + + + + +

lua_gettop

+[-0, +0, –] +

int lua_gettop (lua_State *L);
+ +

+Returns the index of the top element in the stack. +Because indices start at 1, +this result is equal to the number of elements in the stack +(and so 0 means an empty stack). + + + + + +

lua_getuservalue

+[-0, +1, –] +

void lua_getuservalue (lua_State *L, int index);
+ +

+Pushes onto the stack the Lua value associated with the userdata +at the given index. +This Lua value must be a table or nil. + + + + + +

lua_insert

+[-1, +1, –] +

void lua_insert (lua_State *L, int index);
+ +

+Moves the top element into the given valid index, +shifting up the elements above this index to open space. +This function cannot be called with a pseudo-index, +because a pseudo-index is not an actual stack position. + + + + + +

lua_Integer

+
typedef ptrdiff_t lua_Integer;
+ +

+The type used by the Lua API to represent signed integral values. + + +

+By default it is a ptrdiff_t, +which is usually the largest signed integral type the machine handles +"comfortably". + + + + + +

lua_isboolean

+[-0, +0, –] +

int lua_isboolean (lua_State *L, int index);
+ +

+Returns 1 if the value at the given index is a boolean, +and 0 otherwise. + + + + + +

lua_iscfunction

+[-0, +0, –] +

int lua_iscfunction (lua_State *L, int index);
+ +

+Returns 1 if the value at the given index is a C function, +and 0 otherwise. + + + + + +

lua_isfunction

+[-0, +0, –] +

int lua_isfunction (lua_State *L, int index);
+ +

+Returns 1 if the value at the given index is a function +(either C or Lua), and 0 otherwise. + + + + + +

lua_islightuserdata

+[-0, +0, –] +

int lua_islightuserdata (lua_State *L, int index);
+ +

+Returns 1 if the value at the given index is a light userdata, +and 0 otherwise. + + + + + +

lua_isnil

+[-0, +0, –] +

int lua_isnil (lua_State *L, int index);
+ +

+Returns 1 if the value at the given index is nil, +and 0 otherwise. + + + + + +

lua_isnone

+[-0, +0, –] +

int lua_isnone (lua_State *L, int index);
+ +

+Returns 1 if the given index is not valid, +and 0 otherwise. + + + + + +

lua_isnoneornil

+[-0, +0, –] +

int lua_isnoneornil (lua_State *L, int index);
+ +

+Returns 1 if the given index is not valid +or if the value at this index is nil, +and 0 otherwise. + + + + + +

lua_isnumber

+[-0, +0, –] +

int lua_isnumber (lua_State *L, int index);
+ +

+Returns 1 if the value at the given index is a number +or a string convertible to a number, +and 0 otherwise. + + + + + +

lua_isstring

+[-0, +0, –] +

int lua_isstring (lua_State *L, int index);
+ +

+Returns 1 if the value at the given index is a string +or a number (which is always convertible to a string), +and 0 otherwise. + + + + + +

lua_istable

+[-0, +0, –] +

int lua_istable (lua_State *L, int index);
+ +

+Returns 1 if the value at the given index is a table, +and 0 otherwise. + + + + + +

lua_isthread

+[-0, +0, –] +

int lua_isthread (lua_State *L, int index);
+ +

+Returns 1 if the value at the given index is a thread, +and 0 otherwise. + + + + + +

lua_isuserdata

+[-0, +0, –] +

int lua_isuserdata (lua_State *L, int index);
+ +

+Returns 1 if the value at the given index is a userdata +(either full or light), and 0 otherwise. + + + + + +

lua_len

+[-0, +1, e] +

void lua_len (lua_State *L, int index);
+ +

+Returns the "length" of the value at the given index; +it is equivalent to the '#' operator in Lua (see §3.4.6). +The result is pushed on the stack. + + + + + +

lua_load

+[-0, +1, –] +

int lua_load (lua_State *L,
+              lua_Reader reader,
+              void *data,
+              const char *source,
+              const char *mode);
+ +

+Loads a Lua chunk (without running it). +If there are no errors, +lua_load pushes the compiled chunk as a Lua +function on top of the stack. +Otherwise, it pushes an error message. + + +

+The return values of lua_load are: + +

    + +
  • LUA_OK: no errors;
    • + +
  • LUA_ERRSYNTAX: +syntax error during precompilation;
    • + +
  • LUA_ERRMEM: +memory allocation error;
    • + +
  • LUA_ERRGCMM: +error while running a __gc metamethod. +(This error has no relation with the chunk being loaded. +It is generated by the garbage collector.) +
    • + +
+ +

+The lua_load function uses a user-supplied reader function +to read the chunk (see lua_Reader). +The data argument is an opaque value passed to the reader function. + + +

+The source argument gives a name to the chunk, +which is used for error messages and in debug information (see §4.9). + + +

+lua_load automatically detects whether the chunk is text or binary +and loads it accordingly (see program luac). +The string mode works as in function load, +with the addition that +a NULL value is equivalent to the string "bt". + + +

+lua_load uses the stack internally, +so the reader function should always leave the stack +unmodified when returning. + + +

+If the resulting function has one upvalue, +this upvalue is set to the value of the global environment +stored at index LUA_RIDX_GLOBALS in the registry (see §4.5). +When loading main chunks, +this upvalue will be the _ENV variable (see §2.2). + + + + + +

lua_newstate

+[-0, +0, –] +

lua_State *lua_newstate (lua_Alloc f, void *ud);
+ +

+Creates a new thread running in a new, independent state. +Returns NULL if cannot create the thread or the state +(due to lack of memory). +The argument f is the allocator function; +Lua does all memory allocation for this state through this function. +The second argument, ud, is an opaque pointer that Lua +passes to the allocator in every call. + + + + + +

lua_newtable

+[-0, +1, e] +

void lua_newtable (lua_State *L);
+ +

+Creates a new empty table and pushes it onto the stack. +It is equivalent to lua_createtable(L, 0, 0). + + + + + +

lua_newthread

+[-0, +1, e] +

lua_State *lua_newthread (lua_State *L);
+ +

+Creates a new thread, pushes it on the stack, +and returns a pointer to a lua_State that represents this new thread. +The new thread returned by this function shares with the original thread +its global environment, +but has an independent execution stack. + + +

+There is no explicit function to close or to destroy a thread. +Threads are subject to garbage collection, +like any Lua object. + + + + + +

lua_newuserdata

+[-0, +1, e] +

void *lua_newuserdata (lua_State *L, size_t size);
+ +

+This function allocates a new block of memory with the given size, +pushes onto the stack a new full userdata with the block address, +and returns this address. +The host program can freely use this memory. + + + + + +

lua_next

+[-1, +(2|0), e] +

int lua_next (lua_State *L, int index);
+ +

+Pops a key from the stack, +and pushes a key–value pair from the table at the given index +(the "next" pair after the given key). +If there are no more elements in the table, +then lua_next returns 0 (and pushes nothing). + + +

+A typical traversal looks like this: + +

+     /* table is in the stack at index 't' */
+     lua_pushnil(L);  /* first key */
+     while (lua_next(L, t) != 0) {
+       /* uses 'key' (at index -2) and 'value' (at index -1) */
+       printf("%s - %s\n",
+              lua_typename(L, lua_type(L, -2)),
+              lua_typename(L, lua_type(L, -1)));
+       /* removes 'value'; keeps 'key' for next iteration */
+       lua_pop(L, 1);
+     }
+
+ +

+While traversing a table, +do not call lua_tolstring directly on a key, +unless you know that the key is actually a string. +Recall that lua_tolstring may change +the value at the given index; +this confuses the next call to lua_next. + + +

+See function next for the caveats of modifying +the table during its traversal. + + + + + +

lua_Number

+
typedef double lua_Number;
+ +

+The type of numbers in Lua. +By default, it is double, but that can be changed in luaconf.h. +Through this configuration file you can change +Lua to operate with another type for numbers (e.g., float or long). + + + + + +

lua_pcall

+[-(nargs + 1), +(nresults|1), –] +

int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);
+ +

+Calls a function in protected mode. + + +

+Both nargs and nresults have the same meaning as +in lua_call. +If there are no errors during the call, +lua_pcall behaves exactly like lua_call. +However, if there is any error, +lua_pcall catches it, +pushes a single value on the stack (the error message), +and returns an error code. +Like lua_call, +lua_pcall always removes the function +and its arguments from the stack. + + +

+If msgh is 0, +then the error message returned on the stack +is exactly the original error message. +Otherwise, msgh is the stack index of a +message handler. +(In the current implementation, this index cannot be a pseudo-index.) +In case of runtime errors, +this function will be called with the error message +and its return value will be the message +returned on the stack by lua_pcall. + + +

+Typically, the message handler is used to add more debug +information to the error message, such as a stack traceback. +Such information cannot be gathered after the return of lua_pcall, +since by then the stack has unwound. + + +

+The lua_pcall function returns one of the following codes +(defined in lua.h): + +

    + +
  • LUA_OK (0): +success.
    • + +
  • LUA_ERRRUN: +a runtime error. +
    • + +
  • LUA_ERRMEM: +memory allocation error. +For such errors, Lua does not call the message handler. +
    • + +
  • LUA_ERRERR: +error while running the message handler. +
    • + +
  • LUA_ERRGCMM: +error while running a __gc metamethod. +(This error typically has no relation with the function being called. +It is generated by the garbage collector.) +
    • + +
+ + + + +

lua_pcallk

+[-(nargs + 1), +(nresults|1), –] +

int lua_pcallk (lua_State *L,
+                int nargs,
+                int nresults,
+                int errfunc,
+                int ctx,
+                lua_CFunction k);
+ +

+This function behaves exactly like lua_pcall, +but allows the called function to yield (see §4.7). + + + + + +

lua_pop

+[-n, +0, –] +

void lua_pop (lua_State *L, int n);
+ +

+Pops n elements from the stack. + + + + + +

lua_pushboolean

+[-0, +1, –] +

void lua_pushboolean (lua_State *L, int b);
+ +

+Pushes a boolean value with value b onto the stack. + + + + + +

lua_pushcclosure

+[-n, +1, e] +

void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
+ +

+Pushes a new C closure onto the stack. + + +

+When a C function is created, +it is possible to associate some values with it, +thus creating a C closure (see §4.4); +these values are then accessible to the function whenever it is called. +To associate values with a C function, +first these values should be pushed onto the stack +(when there are multiple values, the first value is pushed first). +Then lua_pushcclosure +is called to create and push the C function onto the stack, +with the argument n telling how many values should be +associated with the function. +lua_pushcclosure also pops these values from the stack. + + +

+The maximum value for n is 255. + + +

+When n is zero, +this function creates a light C function, +which is just a pointer to the C function. +In that case, it never throws a memory error. + + + + + +

lua_pushcfunction

+[-0, +1, –] +

void lua_pushcfunction (lua_State *L, lua_CFunction f);
+ +

+Pushes a C function onto the stack. +This function receives a pointer to a C function +and pushes onto the stack a Lua value of type function that, +when called, invokes the corresponding C function. + + +

+Any function to be registered in Lua must +follow the correct protocol to receive its parameters +and return its results (see lua_CFunction). + + +

+lua_pushcfunction is defined as a macro: + +

+     #define lua_pushcfunction(L,f)  lua_pushcclosure(L,f,0)
+

+Note that f is used twice. + + + + + +

lua_pushfstring

+[-0, +1, e] +

const char *lua_pushfstring (lua_State *L, const char *fmt, ...);
+ +

+Pushes onto the stack a formatted string +and returns a pointer to this string. +It is similar to the ANSI C function sprintf, +but has some important differences: + +

    + +
  • +You do not have to allocate space for the result: +the result is a Lua string and Lua takes care of memory allocation +(and deallocation, through garbage collection). +
    • + +
  • +The conversion specifiers are quite restricted. +There are no flags, widths, or precisions. +The conversion specifiers can only be +'%%' (inserts a '%' in the string), +'%s' (inserts a zero-terminated string, with no size restrictions), +'%f' (inserts a lua_Number), +'%p' (inserts a pointer as a hexadecimal numeral), +'%d' (inserts an int), and +'%c' (inserts an int as a byte). +
    • + +
+ + + + +

lua_pushglobaltable

+[-0, +1, –] +

void lua_pushglobaltable (lua_State *L);
+ +

+Pushes the global environment onto the stack. + + + + + +

lua_pushinteger

+[-0, +1, –] +

void lua_pushinteger (lua_State *L, lua_Integer n);
+ +

+Pushes a number with value n onto the stack. + + + + + +

lua_pushlightuserdata

+[-0, +1, –] +

void lua_pushlightuserdata (lua_State *L, void *p);
+ +

+Pushes a light userdata onto the stack. + + +

+Userdata represent C values in Lua. +A light userdata represents a pointer, a void*. +It is a value (like a number): +you do not create it, it has no individual metatable, +and it is not collected (as it was never created). +A light userdata is equal to "any" +light userdata with the same C address. + + + + + +

lua_pushliteral

+[-0, +1, e] +

const char *lua_pushliteral (lua_State *L, const char *s);
+ +

+This macro is equivalent to lua_pushlstring, +but can be used only when s is a literal string. +It automatically provides the string length. + + + + + +

lua_pushlstring

+[-0, +1, e] +

const char *lua_pushlstring (lua_State *L, const char *s, size_t len);
+ +

+Pushes the string pointed to by s with size len +onto the stack. +Lua makes (or reuses) an internal copy of the given string, +so the memory at s can be freed or reused immediately after +the function returns. +The string can contain any binary data, +including embedded zeros. + + +

+Returns a pointer to the internal copy of the string. + + + + + +

lua_pushnil

+[-0, +1, –] +

void lua_pushnil (lua_State *L);
+ +

+Pushes a nil value onto the stack. + + + + + +

lua_pushnumber

+[-0, +1, –] +

void lua_pushnumber (lua_State *L, lua_Number n);
+ +

+Pushes a number with value n onto the stack. + + + + + +

lua_pushstring

+[-0, +1, e] +

const char *lua_pushstring (lua_State *L, const char *s);
+ +

+Pushes the zero-terminated string pointed to by s +onto the stack. +Lua makes (or reuses) an internal copy of the given string, +so the memory at s can be freed or reused immediately after +the function returns. + + +

+Returns a pointer to the internal copy of the string. + + +

+If s is NULL, pushes nil and returns NULL. + + + + + +

lua_pushthread

+[-0, +1, –] +

int lua_pushthread (lua_State *L);
+ +

+Pushes the thread represented by L onto the stack. +Returns 1 if this thread is the main thread of its state. + + + + + +

lua_pushunsigned

+[-0, +1, –] +

void lua_pushunsigned (lua_State *L, lua_Unsigned n);
+ +

+Pushes a number with value n onto the stack. + + + + + +

lua_pushvalue

+[-0, +1, –] +

void lua_pushvalue (lua_State *L, int index);
+ +

+Pushes a copy of the element at the given index +onto the stack. + + + + + +

lua_pushvfstring

+[-0, +1, e] +

const char *lua_pushvfstring (lua_State *L,
+                              const char *fmt,
+                              va_list argp);
+ +

+Equivalent to lua_pushfstring, except that it receives a va_list +instead of a variable number of arguments. + + + + + +

lua_rawequal

+[-0, +0, –] +

int lua_rawequal (lua_State *L, int index1, int index2);
+ +

+Returns 1 if the two values in indices index1 and +index2 are primitively equal +(that is, without calling metamethods). +Otherwise returns 0. +Also returns 0 if any of the indices are non valid. + + + + + +

lua_rawget

+[-1, +1, –] +

void lua_rawget (lua_State *L, int index);
+ +

+Similar to lua_gettable, but does a raw access +(i.e., without metamethods). + + + + + +

lua_rawgeti

+[-0, +1, –] +

void lua_rawgeti (lua_State *L, int index, int n);
+ +

+Pushes onto the stack the value t[n], +where t is the table at the given index. +The access is raw; +that is, it does not invoke metamethods. + + + + + +

lua_rawgetp

+[-0, +1, –] +

void lua_rawgetp (lua_State *L, int index, const void *p);
+ +

+Pushes onto the stack the value t[k], +where t is the table at the given index and +k is the pointer p represented as a light userdata. +The access is raw; +that is, it does not invoke metamethods. + + + + + +

lua_rawlen

+[-0, +0, –] +

size_t lua_rawlen (lua_State *L, int index);
+ +

+Returns the raw "length" of the value at the given index: +for strings, this is the string length; +for tables, this is the result of the length operator ('#') +with no metamethods; +for userdata, this is the size of the block of memory allocated +for the userdata; +for other values, it is 0. + + + + + +

lua_rawset

+[-2, +0, e] +

void lua_rawset (lua_State *L, int index);
+ +

+Similar to lua_settable, but does a raw assignment +(i.e., without metamethods). + + + + + +

lua_rawseti

+[-1, +0, e] +

void lua_rawseti (lua_State *L, int index, int n);
+ +

+Does the equivalent of t[n] = v, +where t is the table at the given index +and v is the value at the top of the stack. + + +

+This function pops the value from the stack. +The assignment is raw; +that is, it does not invoke metamethods. + + + + + +

lua_rawsetp

+[-1, +0, e] +

void lua_rawsetp (lua_State *L, int index, const void *p);
+ +

+Does the equivalent of t[k] = v, +where t is the table at the given index, +k is the pointer p represented as a light userdata, +and v is the value at the top of the stack. + + +

+This function pops the value from the stack. +The assignment is raw; +that is, it does not invoke metamethods. + + + + + +

lua_Reader

+
typedef const char * (*lua_Reader) (lua_State *L,
+                                    void *data,
+                                    size_t *size);
+ +

+The reader function used by lua_load. +Every time it needs another piece of the chunk, +lua_load calls the reader, +passing along its data parameter. +The reader must return a pointer to a block of memory +with a new piece of the chunk +and set size to the block size. +The block must exist until the reader function is called again. +To signal the end of the chunk, +the reader must return NULL or set size to zero. +The reader function may return pieces of any size greater than zero. + + + + + +

lua_register

+[-0, +0, e] +

void lua_register (lua_State *L, const char *name, lua_CFunction f);
+ +

+Sets the C function f as the new value of global name. +It is defined as a macro: + +

+     #define lua_register(L,n,f) \
+            (lua_pushcfunction(L, f), lua_setglobal(L, n))
+
+ + + + +

lua_remove

+[-1, +0, –] +

void lua_remove (lua_State *L, int index);
+ +

+Removes the element at the given valid index, +shifting down the elements above this index to fill the gap. +This function cannot be called with a pseudo-index, +because a pseudo-index is not an actual stack position. + + + + + +

lua_replace

+[-1, +0, –] +

void lua_replace (lua_State *L, int index);
+ +

+Moves the top element into the given valid index +without shifting any element +(therefore replacing the value at the given index), +and then pops the top element. + + + + + +

lua_resume

+[-?, +?, –] +

int lua_resume (lua_State *L, lua_State *from, int nargs);
+ +

+Starts and resumes a coroutine in a given thread. + + +

+To start a coroutine, +you push onto the thread stack the main function plus any arguments; +then you call lua_resume, +with nargs being the number of arguments. +This call returns when the coroutine suspends or finishes its execution. +When it returns, the stack contains all values passed to lua_yield, +or all values returned by the body function. +lua_resume returns +LUA_YIELD if the coroutine yields, +LUA_OK if the coroutine finishes its execution +without errors, +or an error code in case of errors (see lua_pcall). + + +

+In case of errors, +the stack is not unwound, +so you can use the debug API over it. +The error message is on the top of the stack. + + +

+To resume a coroutine, +you remove any results from the last lua_yield, +put on its stack only the values to +be passed as results from yield, +and then call lua_resume. + + +

+The parameter from represents the coroutine that is resuming L. +If there is no such coroutine, +this parameter can be NULL. + + + + + +

lua_setallocf

+[-0, +0, –] +

void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
+ +

+Changes the allocator function of a given state to f +with user data ud. + + + + + +

lua_setfield

+[-1, +0, e] +

void lua_setfield (lua_State *L, int index, const char *k);
+ +

+Does the equivalent to t[k] = v, +where t is the value at the given index +and v is the value at the top of the stack. + + +

+This function pops the value from the stack. +As in Lua, this function may trigger a metamethod +for the "newindex" event (see §2.4). + + + + + +

lua_setglobal

+[-1, +0, e] +

void lua_setglobal (lua_State *L, const char *name);
+ +

+Pops a value from the stack and +sets it as the new value of global name. + + + + + +

lua_setmetatable

+[-1, +0, –] +

void lua_setmetatable (lua_State *L, int index);
+ +

+Pops a table from the stack and +sets it as the new metatable for the value at the given index. + + + + + +

lua_settable

+[-2, +0, e] +

void lua_settable (lua_State *L, int index);
+ +

+Does the equivalent to t[k] = v, +where t is the value at the given index, +v is the value at the top of the stack, +and k is the value just below the top. + + +

+This function pops both the key and the value from the stack. +As in Lua, this function may trigger a metamethod +for the "newindex" event (see §2.4). + + + + + +

lua_settop

+[-?, +?, –] +

void lua_settop (lua_State *L, int index);
+ +

+Accepts any index, or 0, +and sets the stack top to this index. +If the new top is larger than the old one, +then the new elements are filled with nil. +If index is 0, then all stack elements are removed. + + + + + +

lua_setuservalue

+[-1, +0, –] +

void lua_setuservalue (lua_State *L, int index);
+ +

+Pops a table or nil from the stack and sets it as +the new value associated to the userdata at the given index. + + + + + +

lua_State

+
typedef struct lua_State lua_State;
+ +

+An opaque structure that points to a thread and indirectly +(through the thread) to the whole state of a Lua interpreter. +The Lua library is fully reentrant: +it has no global variables. +All information about a state is accessible through this structure. + + +

+A pointer to this structure must be passed as the first argument to +every function in the library, except to lua_newstate, +which creates a Lua state from scratch. + + + + + +

lua_status

+[-0, +0, –] +

int lua_status (lua_State *L);
+ +

+Returns the status of the thread L. + + +

+The status can be 0 (LUA_OK) for a normal thread, +an error code if the thread finished the execution +of a lua_resume with an error, +or LUA_YIELD if the thread is suspended. + + +

+You can only call functions in threads with status LUA_OK. +You can resume threads with status LUA_OK +(to start a new coroutine) or LUA_YIELD +(to resume a coroutine). + + + + + +

lua_toboolean

+[-0, +0, –] +

int lua_toboolean (lua_State *L, int index);
+ +

+Converts the Lua value at the given index to a C boolean +value (0 or 1). +Like all tests in Lua, +lua_toboolean returns true for any Lua value +different from false and nil; +otherwise it returns false. +(If you want to accept only actual boolean values, +use lua_isboolean to test the value's type.) + + + + + +

lua_tocfunction

+[-0, +0, –] +

lua_CFunction lua_tocfunction (lua_State *L, int index);
+ +

+Converts a value at the given index to a C function. +That value must be a C function; +otherwise, returns NULL. + + + + + +

lua_tointeger

+[-0, +0, –] +

lua_Integer lua_tointeger (lua_State *L, int index);
+ +

+Equivalent to lua_tointegerx with isnum equal to NULL. + + + + + +

lua_tointegerx

+[-0, +0, –] +

lua_Integer lua_tointegerx (lua_State *L, int index, int *isnum);
+ +

+Converts the Lua value at the given index +to the signed integral type lua_Integer. +The Lua value must be a number or a string convertible to a number +(see §3.4.2); +otherwise, lua_tointegerx returns 0. + + +

+If the number is not an integer, +it is truncated in some non-specified way. + + +

+If isnum is not NULL, +its referent is assigned a boolean value that +indicates whether the operation succeeded. + + + + + +

lua_tolstring

+[-0, +0, e] +

const char *lua_tolstring (lua_State *L, int index, size_t *len);
+ +

+Converts the Lua value at the given index to a C string. +If len is not NULL, +it also sets *len with the string length. +The Lua value must be a string or a number; +otherwise, the function returns NULL. +If the value is a number, +then lua_tolstring also +changes the actual value in the stack to a string. +(This change confuses lua_next +when lua_tolstring is applied to keys during a table traversal.) + + +

+lua_tolstring returns a fully aligned pointer +to a string inside the Lua state. +This string always has a zero ('\0') +after its last character (as in C), +but can contain other zeros in its body. +Because Lua has garbage collection, +there is no guarantee that the pointer returned by lua_tolstring +will be valid after the corresponding value is removed from the stack. + + + + + +

lua_tonumber

+[-0, +0, –] +

lua_Number lua_tonumber (lua_State *L, int index);
+ +

+Equivalent to lua_tonumberx with isnum equal to NULL. + + + + + +

lua_tonumberx

+[-0, +0, –] +

lua_Number lua_tonumberx (lua_State *L, int index, int *isnum);
+ +

+Converts the Lua value at the given index +to the C type lua_Number (see lua_Number). +The Lua value must be a number or a string convertible to a number +(see §3.4.2); +otherwise, lua_tonumberx returns 0. + + +

+If isnum is not NULL, +its referent is assigned a boolean value that +indicates whether the operation succeeded. + + + + + +

lua_topointer

+[-0, +0, –] +

const void *lua_topointer (lua_State *L, int index);
+ +

+Converts the value at the given index to a generic +C pointer (void*). +The value can be a userdata, a table, a thread, or a function; +otherwise, lua_topointer returns NULL. +Different objects will give different pointers. +There is no way to convert the pointer back to its original value. + + +

+Typically this function is used only for debug information. + + + + + +

lua_tostring

+[-0, +0, e] +

const char *lua_tostring (lua_State *L, int index);
+ +

+Equivalent to lua_tolstring with len equal to NULL. + + + + + +

lua_tothread

+[-0, +0, –] +

lua_State *lua_tothread (lua_State *L, int index);
+ +

+Converts the value at the given index to a Lua thread +(represented as lua_State*). +This value must be a thread; +otherwise, the function returns NULL. + + + + + +

lua_tounsigned

+[-0, +0, –] +

lua_Unsigned lua_tounsigned (lua_State *L, int index);
+ +

+Equivalent to lua_tounsignedx with isnum equal to NULL. + + + + + +

lua_tounsignedx

+[-0, +0, –] +

lua_Unsigned lua_tounsignedx (lua_State *L, int index, int *isnum);
+ +

+Converts the Lua value at the given index +to the unsigned integral type lua_Unsigned. +The Lua value must be a number or a string convertible to a number +(see §3.4.2); +otherwise, lua_tounsignedx returns 0. + + +

+If the number is not an integer, +it is truncated in some non-specified way. +If the number is outside the range of representable values, +it is normalized to the remainder of its division by +one more than the maximum representable value. + + +

+If isnum is not NULL, +its referent is assigned a boolean value that +indicates whether the operation succeeded. + + + + + +

lua_touserdata

+[-0, +0, –] +

void *lua_touserdata (lua_State *L, int index);
+ +

+If the value at the given index is a full userdata, +returns its block address. +If the value is a light userdata, +returns its pointer. +Otherwise, returns NULL. + + + + + +

lua_type

+[-0, +0, –] +

int lua_type (lua_State *L, int index);
+ +

+Returns the type of the value in the given valid index, +or LUA_TNONE for a non-valid (but acceptable) index. +The types returned by lua_type are coded by the following constants +defined in lua.h: +LUA_TNIL, +LUA_TNUMBER, +LUA_TBOOLEAN, +LUA_TSTRING, +LUA_TTABLE, +LUA_TFUNCTION, +LUA_TUSERDATA, +LUA_TTHREAD, +and +LUA_TLIGHTUSERDATA. + + + + + +

lua_typename

+[-0, +0, –] +

const char *lua_typename (lua_State *L, int tp);
+ +

+Returns the name of the type encoded by the value tp, +which must be one the values returned by lua_type. + + + + + +

lua_Unsigned

+
typedef unsigned long lua_Unsigned;
+ +

+The type used by the Lua API to represent unsigned integral values. +It must have at least 32 bits. + + +

+By default it is an unsigned int or an unsigned long, +whichever can hold 32-bit values. + + + + + +

lua_upvalueindex

+[-0, +0, –] +

int lua_upvalueindex (int i);
+ +

+Returns the pseudo-index that represents the i-th upvalue of +the running function (see §4.4). + + + + + +

lua_version

+[-0, +0, v] +

const lua_Number *lua_version (lua_State *L);
+ +

+Returns the address of the version number stored in the Lua core. +When called with a valid lua_State, +returns the address of the version used to create that state. +When called with NULL, +returns the address of the version running the call. + + + + + +

lua_Writer

+
typedef int (*lua_Writer) (lua_State *L,
+                           const void* p,
+                           size_t sz,
+                           void* ud);
+ +

+The type of the writer function used by lua_dump. +Every time it produces another piece of chunk, +lua_dump calls the writer, +passing along the buffer to be written (p), +its size (sz), +and the data parameter supplied to lua_dump. + + +

+The writer returns an error code: +0 means no errors; +any other value means an error and stops lua_dump from +calling the writer again. + + + + + +

lua_xmove

+[-?, +?, –] +

void lua_xmove (lua_State *from, lua_State *to, int n);
+ +

+Exchange values between different threads of the same state. + + +

+This function pops n values from the stack from, +and pushes them onto the stack to. + + + + + +

lua_yield

+[-?, +?, –] +

int lua_yield (lua_State *L, int nresults);
+ +

+This function is equivalent to lua_yieldk, +but it has no continuation (see §4.7). +Therefore, when the thread resumes, +it returns to the function that called +the function calling lua_yield. + + + + + +

lua_yieldk

+[-?, +?, –] +

int lua_yieldk (lua_State *L, int nresults, int ctx, lua_CFunction k);
+ +

+Yields a coroutine. + + +

+This function should only be called as the +return expression of a C function, as follows: + +

+     return lua_yieldk (L, n, i, k);
+

+When a C function calls lua_yieldk in that way, +the running coroutine suspends its execution, +and the call to lua_resume that started this coroutine returns. +The parameter nresults is the number of values from the stack +that are passed as results to lua_resume. + + +

+When the coroutine is resumed again, +Lua calls the given continuation function k to continue +the execution of the C function that yielded (see §4.7). +This continuation function receives the same stack +from the previous function, +with the results removed and +replaced by the arguments passed to lua_resume. +Moreover, +the continuation function may access the value ctx +by calling lua_getctx. + + + + + + + +

4.9 – The Debug Interface

+ +

+Lua has no built-in debugging facilities. +Instead, it offers a special interface +by means of functions and hooks. +This interface allows the construction of different +kinds of debuggers, profilers, and other tools +that need "inside information" from the interpreter. + + + +

lua_Debug

+
typedef struct lua_Debug {
+  int event;
+  const char *name;           /* (n) */
+  const char *namewhat;       /* (n) */
+  const char *what;           /* (S) */
+  const char *source;         /* (S) */
+  int currentline;            /* (l) */
+  int linedefined;            /* (S) */
+  int lastlinedefined;        /* (S) */
+  unsigned char nups;         /* (u) number of upvalues */
+  unsigned char nparams;      /* (u) number of parameters */
+  char isvararg;              /* (u) */
+  char istailcall;            /* (t) */
+  char short_src[LUA_IDSIZE]; /* (S) */
+  /* private part */
+  other fields
+} lua_Debug;
+ +

+A structure used to carry different pieces of +information about a function or an activation record. +lua_getstack fills only the private part +of this structure, for later use. +To fill the other fields of lua_Debug with useful information, +call lua_getinfo. + + +

+The fields of lua_Debug have the following meaning: + +

    + +
  • source: +the source of the chunk that created the function. +If source starts with a '@', +it means that the function was defined in a file where +the file name follows the '@'. +If source starts with a '=', +the remainder of its contents describe the source in a user-dependent manner. +Otherwise, +the function was defined in a string where +source is that string. +
    • + +
  • short_src: +a "printable" version of source, to be used in error messages. +
    • + +
  • linedefined: +the line number where the definition of the function starts. +
    • + +
  • lastlinedefined: +the line number where the definition of the function ends. +
    • + +
  • what: +the string "Lua" if the function is a Lua function, +"C" if it is a C function, +"main" if it is the main part of a chunk. +
    • + +
  • currentline: +the current line where the given function is executing. +When no line information is available, +currentline is set to -1. +
    • + +
  • name: +a reasonable name for the given function. +Because functions in Lua are first-class values, +they do not have a fixed name: +some functions can be the value of multiple global variables, +while others can be stored only in a table field. +The lua_getinfo function checks how the function was +called to find a suitable name. +If it cannot find a name, +then name is set to NULL. +
    • + +
  • namewhat: +explains the name field. +The value of namewhat can be +"global", "local", "method", +"field", "upvalue", or "" (the empty string), +according to how the function was called. +(Lua uses the empty string when no other option seems to apply.) +
    • + +
  • istailcall: +true if this function invocation was called by a tail call. +In this case, the caller of this level is not in the stack. +
    • + +
  • nups: +the number of upvalues of the function. +
    • + +
  • nparams: +the number of fixed parameters of the function +(always 0 for C functions). +
    • + +
  • isvararg: +true if the function is a vararg function +(always true for C functions). +
    • + +
+ + + + +

lua_gethook

+[-0, +0, –] +

lua_Hook lua_gethook (lua_State *L);
+ +

+Returns the current hook function. + + + + + +

lua_gethookcount

+[-0, +0, –] +

int lua_gethookcount (lua_State *L);
+ +

+Returns the current hook count. + + + + + +

lua_gethookmask

+[-0, +0, –] +

int lua_gethookmask (lua_State *L);
+ +

+Returns the current hook mask. + + + + + +

lua_getinfo

+[-(0|1), +(0|1|2), e] +

int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
+ +

+Gets information about a specific function or function invocation. + + +

+To get information about a function invocation, +the parameter ar must be a valid activation record that was +filled by a previous call to lua_getstack or +given as argument to a hook (see lua_Hook). + + +

+To get information about a function you push it onto the stack +and start the what string with the character '>'. +(In that case, +lua_getinfo pops the function from the top of the stack.) +For instance, to know in which line a function f was defined, +you can write the following code: + +

+     lua_Debug ar;
+     lua_getglobal(L, "f");  /* get global 'f' */
+     lua_getinfo(L, ">S", &ar);
+     printf("%d\n", ar.linedefined);
+
+ +

+Each character in the string what +selects some fields of the structure ar to be filled or +a value to be pushed on the stack: + +

    + +
  • 'n': fills in the field name and namewhat; +
    • + +
  • 'S': +fills in the fields source, short_src, +linedefined, lastlinedefined, and what; +
    • + +
  • 'l': fills in the field currentline; +
    • + +
  • 't': fills in the field istailcall; +
    • + +
  • 'u': fills in the fields +nups, nparams, and isvararg; +
    • + +
  • 'f': +pushes onto the stack the function that is +running at the given level; +
    • + +
  • 'L': +pushes onto the stack a table whose indices are the +numbers of the lines that are valid on the function. +(A valid line is a line with some associated code, +that is, a line where you can put a break point. +Non-valid lines include empty lines and comments.) +
    • + +
+ +

+This function returns 0 on error +(for instance, an invalid option in what). + + + + + +

lua_getlocal

+[-0, +(0|1), –] +

const char *lua_getlocal (lua_State *L, lua_Debug *ar, int n);
+ +

+Gets information about a local variable of +a given activation record or a given function. + + +

+In the first case, +the parameter ar must be a valid activation record that was +filled by a previous call to lua_getstack or +given as argument to a hook (see lua_Hook). +The index n selects which local variable to inspect; +see debug.getlocal for details about variable indices +and names. + + +

+lua_getlocal pushes the variable's value onto the stack +and returns its name. + + +

+In the second case, ar should be NULL and the function +to be inspected must be at the top of the stack. +In this case, only parameters of Lua functions are visible +(as there is no information about what variables are active) +and no values are pushed onto the stack. + + +

+Returns NULL (and pushes nothing) +when the index is greater than +the number of active local variables. + + + + + +

lua_getstack

+[-0, +0, –] +

int lua_getstack (lua_State *L, int level, lua_Debug *ar);
+ +

+Gets information about the interpreter runtime stack. + + +

+This function fills parts of a lua_Debug structure with +an identification of the activation record +of the function executing at a given level. +Level 0 is the current running function, +whereas level n+1 is the function that has called level n +(except for tail calls, which do not count on the stack). +When there are no errors, lua_getstack returns 1; +when called with a level greater than the stack depth, +it returns 0. + + + + + +

lua_getupvalue

+[-0, +(0|1), –] +

const char *lua_getupvalue (lua_State *L, int funcindex, int n);
+ +

+Gets information about a closure's upvalue. +(For Lua functions, +upvalues are the external local variables that the function uses, +and that are consequently included in its closure.) +lua_getupvalue gets the index n of an upvalue, +pushes the upvalue's value onto the stack, +and returns its name. +funcindex points to the closure in the stack. +(Upvalues have no particular order, +as they are active through the whole function. +So, they are numbered in an arbitrary order.) + + +

+Returns NULL (and pushes nothing) +when the index is greater than the number of upvalues. +For C functions, this function uses the empty string "" +as a name for all upvalues. + + + + + +

lua_Hook

+
typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
+ +

+Type for debugging hook functions. + + +

+Whenever a hook is called, its ar argument has its field +event set to the specific event that triggered the hook. +Lua identifies these events with the following constants: +LUA_HOOKCALL, LUA_HOOKRET, +LUA_HOOKTAILCALL, LUA_HOOKLINE, +and LUA_HOOKCOUNT. +Moreover, for line events, the field currentline is also set. +To get the value of any other field in ar, +the hook must call lua_getinfo. + + +

+For call events, event can be LUA_HOOKCALL, +the normal value, or LUA_HOOKTAILCALL, for a tail call; +in this case, there will be no corresponding return event. + + +

+While Lua is running a hook, it disables other calls to hooks. +Therefore, if a hook calls back Lua to execute a function or a chunk, +this execution occurs without any calls to hooks. + + +

+Hook functions cannot have continuations, +that is, they cannot call lua_yieldk, +lua_pcallk, or lua_callk with a non-null k. + + +

+Hook functions can yield under the following conditions: +Only count and line events can yield +and they cannot yield any value; +to yield a hook function must finish its execution +calling lua_yield with nresults equal to zero. + + + + + +

lua_sethook

+[-0, +0, –] +

int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);
+ +

+Sets the debugging hook function. + + +

+Argument f is the hook function. +mask specifies on which events the hook will be called: +it is formed by a bitwise or of the constants +LUA_MASKCALL, +LUA_MASKRET, +LUA_MASKLINE, +and LUA_MASKCOUNT. +The count argument is only meaningful when the mask +includes LUA_MASKCOUNT. +For each event, the hook is called as explained below: + +

    + +
  • The call hook: is called when the interpreter calls a function. +The hook is called just after Lua enters the new function, +before the function gets its arguments. +
    • + +
  • The return hook: is called when the interpreter returns from a function. +The hook is called just before Lua leaves the function. +There is no standard way to access the values +to be returned by the function. +
    • + +
  • The line hook: is called when the interpreter is about to +start the execution of a new line of code, +or when it jumps back in the code (even to the same line). +(This event only happens while Lua is executing a Lua function.) +
    • + +
  • The count hook: is called after the interpreter executes every +count instructions. +(This event only happens while Lua is executing a Lua function.) +
    • + +
+ +

+A hook is disabled by setting mask to zero. + + + + + +

lua_setlocal

+[-(0|1), +0, –] +

const char *lua_setlocal (lua_State *L, lua_Debug *ar, int n);
+ +

+Sets the value of a local variable of a given activation record. +Parameters ar and n are as in lua_getlocal +(see lua_getlocal). +lua_setlocal assigns the value at the top of the stack +to the variable and returns its name. +It also pops the value from the stack. + + +

+Returns NULL (and pops nothing) +when the index is greater than +the number of active local variables. + + + + + +

lua_setupvalue

+[-(0|1), +0, –] +

const char *lua_setupvalue (lua_State *L, int funcindex, int n);
+ +

+Sets the value of a closure's upvalue. +It assigns the value at the top of the stack +to the upvalue and returns its name. +It also pops the value from the stack. +Parameters funcindex and n are as in the lua_getupvalue +(see lua_getupvalue). + + +

+Returns NULL (and pops nothing) +when the index is greater than the number of upvalues. + + + + + +

lua_upvalueid

+[-0, +0, –] +

void *lua_upvalueid (lua_State *L, int funcindex, int n);
+ +

+Returns an unique identifier for the upvalue numbered n +from the closure at index funcindex. +Parameters funcindex and n are as in the lua_getupvalue +(see lua_getupvalue) +(but n cannot be greater than the number of upvalues). + + +

+These unique identifiers allow a program to check whether different +closures share upvalues. +Lua closures that share an upvalue +(that is, that access a same external local variable) +will return identical ids for those upvalue indices. + + + + + +

lua_upvaluejoin

+[-0, +0, –] +

void lua_upvaluejoin (lua_State *L, int funcindex1, int n1,
+                                    int funcindex2, int n2);
+ +

+Make the n1-th upvalue of the Lua closure at index funcindex1 +refer to the n2-th upvalue of the Lua closure at index funcindex2. + + + + + + + +

5 – The Auxiliary Library

+ +

+ +The auxiliary library provides several convenient functions +to interface C with Lua. +While the basic API provides the primitive functions for all +interactions between C and Lua, +the auxiliary library provides higher-level functions for some +common tasks. + + +

+All functions and types from the auxiliary library +are defined in header file lauxlib.h and +have a prefix luaL_. + + +

+All functions in the auxiliary library are built on +top of the basic API, +and so they provide nothing that cannot be done with that API. +Nevertheless, the use of the auxiliary library ensures +more consistency to your code. + + +

+Several functions in the auxiliary library use internally some +extra stack slots. +When a function in the auxiliary library uses less than five slots, +it does not check the stack size; +it simply assumes that there are enough slots. + + +

+Several functions in the auxiliary library are used to +check C function arguments. +Because the error message is formatted for arguments +(e.g., "bad argument #1"), +you should not use these functions for other stack values. + + +

+Functions called luaL_check* +always throw an error if the check is not satisfied. + + + +

5.1 – Functions and Types

+ +

+Here we list all functions and types from the auxiliary library +in alphabetical order. + + + +

luaL_addchar

+[-?, +?, e] +

void luaL_addchar (luaL_Buffer *B, char c);
+ +

+Adds the byte c to the buffer B +(see luaL_Buffer). + + + + + +

luaL_addlstring

+[-?, +?, e] +

void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);
+ +

+Adds the string pointed to by s with length l to +the buffer B +(see luaL_Buffer). +The string can contain embedded zeros. + + + + + +

luaL_addsize

+[-?, +?, e] +

void luaL_addsize (luaL_Buffer *B, size_t n);
+ +

+Adds to the buffer B (see luaL_Buffer) +a string of length n previously copied to the +buffer area (see luaL_prepbuffer). + + + + + +

luaL_addstring

+[-?, +?, e] +

void luaL_addstring (luaL_Buffer *B, const char *s);
+ +

+Adds the zero-terminated string pointed to by s +to the buffer B +(see luaL_Buffer). +The string cannot contain embedded zeros. + + + + + +

luaL_addvalue

+[-1, +?, e] +

void luaL_addvalue (luaL_Buffer *B);
+ +

+Adds the value at the top of the stack +to the buffer B +(see luaL_Buffer). +Pops the value. + + +

+This is the only function on string buffers that can (and must) +be called with an extra element on the stack, +which is the value to be added to the buffer. + + + + + +

luaL_argcheck

+[-0, +0, v] +

void luaL_argcheck (lua_State *L,
+                    int cond,
+                    int arg,
+                    const char *extramsg);
+ +

+Checks whether cond is true. +If not, raises an error with a standard message. + + + + + +

luaL_argerror

+[-0, +0, v] +

int luaL_argerror (lua_State *L, int arg, const char *extramsg);
+ +

+Raises an error with a standard message +that includes extramsg as a comment. + + +

+This function never returns, +but it is an idiom to use it in C functions +as return luaL_argerror(args). + + + + + +

luaL_Buffer

+
typedef struct luaL_Buffer luaL_Buffer;
+ +

+Type for a string buffer. + + +

+A string buffer allows C code to build Lua strings piecemeal. +Its pattern of use is as follows: + +

    + +
  • First declare a variable b of type luaL_Buffer.
    • + +
  • Then initialize it with a call luaL_buffinit(L, &b).
    • + +
  • +Then add string pieces to the buffer calling any of +the luaL_add* functions. +
    • + +
  • +Finish by calling luaL_pushresult(&b). +This call leaves the final string on the top of the stack. +
    • + +
+ +

+If you know beforehand the total size of the resulting string, +you can use the buffer like this: + +

    + +
  • First declare a variable b of type luaL_Buffer.
    • + +
  • Then initialize it and preallocate a space of +size sz with a call luaL_buffinitsize(L, &b, sz).
    • + +
  • Then copy the string into that space.
    • + +
  • +Finish by calling luaL_pushresultsize(&b, sz), +where sz is the total size of the resulting string +copied into that space. +
    • + +
+ +

+During its normal operation, +a string buffer uses a variable number of stack slots. +So, while using a buffer, you cannot assume that you know where +the top of the stack is. +You can use the stack between successive calls to buffer operations +as long as that use is balanced; +that is, +when you call a buffer operation, +the stack is at the same level +it was immediately after the previous buffer operation. +(The only exception to this rule is luaL_addvalue.) +After calling luaL_pushresult the stack is back to its +level when the buffer was initialized, +plus the final string on its top. + + + + + +

luaL_buffinit

+[-0, +0, –] +

void luaL_buffinit (lua_State *L, luaL_Buffer *B);
+ +

+Initializes a buffer B. +This function does not allocate any space; +the buffer must be declared as a variable +(see luaL_Buffer). + + + + + +

luaL_buffinitsize

+[-?, +?, e] +

char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz);
+ +

+Equivalent to the sequence +luaL_buffinit, luaL_prepbuffsize. + + + + + +

luaL_callmeta

+[-0, +(0|1), e] +

int luaL_callmeta (lua_State *L, int obj, const char *e);
+ +

+Calls a metamethod. + + +

+If the object at index obj has a metatable and this +metatable has a field e, +this function calls this field passing the object as its only argument. +In this case this function returns true and pushes onto the +stack the value returned by the call. +If there is no metatable or no metamethod, +this function returns false (without pushing any value on the stack). + + + + + +

luaL_checkany

+[-0, +0, v] +

void luaL_checkany (lua_State *L, int arg);
+ +

+Checks whether the function has an argument +of any type (including nil) at position arg. + + + + + +

luaL_checkint

+[-0, +0, v] +

int luaL_checkint (lua_State *L, int arg);
+ +

+Checks whether the function argument arg is a number +and returns this number cast to an int. + + + + + +

luaL_checkinteger

+[-0, +0, v] +

lua_Integer luaL_checkinteger (lua_State *L, int arg);
+ +

+Checks whether the function argument arg is a number +and returns this number cast to a lua_Integer. + + + + + +

luaL_checklong

+[-0, +0, v] +

long luaL_checklong (lua_State *L, int arg);
+ +

+Checks whether the function argument arg is a number +and returns this number cast to a long. + + + + + +

luaL_checklstring

+[-0, +0, v] +

const char *luaL_checklstring (lua_State *L, int arg, size_t *l);
+ +

+Checks whether the function argument arg is a string +and returns this string; +if l is not NULL fills *l +with the string's length. + + +

+This function uses lua_tolstring to get its result, +so all conversions and caveats of that function apply here. + + + + + +

luaL_checknumber

+[-0, +0, v] +

lua_Number luaL_checknumber (lua_State *L, int arg);
+ +

+Checks whether the function argument arg is a number +and returns this number. + + + + + +

luaL_checkoption

+[-0, +0, v] +

int luaL_checkoption (lua_State *L,
+                      int arg,
+                      const char *def,
+                      const char *const lst[]);
+ +

+Checks whether the function argument arg is a string and +searches for this string in the array lst +(which must be NULL-terminated). +Returns the index in the array where the string was found. +Raises an error if the argument is not a string or +if the string cannot be found. + + +

+If def is not NULL, +the function uses def as a default value when +there is no argument arg or when this argument is nil. + + +

+This is a useful function for mapping strings to C enums. +(The usual convention in Lua libraries is +to use strings instead of numbers to select options.) + + + + + +

luaL_checkstack

+[-0, +0, v] +

void luaL_checkstack (lua_State *L, int sz, const char *msg);
+ +

+Grows the stack size to top + sz elements, +raising an error if the stack cannot grow to that size. +msg is an additional text to go into the error message +(or NULL for no additional text). + + + + + +

luaL_checkstring

+[-0, +0, v] +

const char *luaL_checkstring (lua_State *L, int arg);
+ +

+Checks whether the function argument arg is a string +and returns this string. + + +

+This function uses lua_tolstring to get its result, +so all conversions and caveats of that function apply here. + + + + + +

luaL_checktype

+[-0, +0, v] +

void luaL_checktype (lua_State *L, int arg, int t);
+ +

+Checks whether the function argument arg has type t. +See lua_type for the encoding of types for t. + + + + + +

luaL_checkudata

+[-0, +0, v] +

void *luaL_checkudata (lua_State *L, int arg, const char *tname);
+ +

+Checks whether the function argument arg is a userdata +of the type tname (see luaL_newmetatable) and +returns the userdata address (see lua_touserdata). + + + + + +

luaL_checkunsigned

+[-0, +0, v] +

lua_Unsigned luaL_checkunsigned (lua_State *L, int arg);
+ +

+Checks whether the function argument arg is a number +and returns this number cast to a lua_Unsigned. + + + + + +

luaL_checkversion

+[-0, +0, –] +

void luaL_checkversion (lua_State *L);
+ +

+Checks whether the core running the call, +the core that created the Lua state, +and the code making the call are all using the same version of Lua. +Also checks whether the core running the call +and the core that created the Lua state +are using the same address space. + + + + + +

luaL_dofile

+[-0, +?, e] +

int luaL_dofile (lua_State *L, const char *filename);
+ +

+Loads and runs the given file. +It is defined as the following macro: + +

+     (luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))
+

+It returns false if there are no errors +or true in case of errors. + + + + + +

luaL_dostring

+[-0, +?, –] +

int luaL_dostring (lua_State *L, const char *str);
+ +

+Loads and runs the given string. +It is defined as the following macro: + +

+     (luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))
+

+It returns false if there are no errors +or true in case of errors. + + + + + +

luaL_error

+[-0, +0, v] +

int luaL_error (lua_State *L, const char *fmt, ...);
+ +

+Raises an error. +The error message format is given by fmt +plus any extra arguments, +following the same rules of lua_pushfstring. +It also adds at the beginning of the message the file name and +the line number where the error occurred, +if this information is available. + + +

+This function never returns, +but it is an idiom to use it in C functions +as return luaL_error(args). + + + + + +

luaL_execresult

+[-0, +3, e] +

int luaL_execresult (lua_State *L, int stat);
+ +

+This function produces the return values for +process-related functions in the standard library +(os.execute and io.close). + + + + + +

luaL_fileresult

+[-0, +(1|3), e] +

int luaL_fileresult (lua_State *L, int stat, const char *fname);
+ +

+This function produces the return values for +file-related functions in the standard library +(io.open, os.rename, file:seek, etc.). + + + + + +

luaL_getmetafield

+[-0, +(0|1), e] +

int luaL_getmetafield (lua_State *L, int obj, const char *e);
+ +

+Pushes onto the stack the field e from the metatable +of the object at index obj. +If the object does not have a metatable, +or if the metatable does not have this field, +returns false and pushes nothing. + + + + + +

luaL_getmetatable

+[-0, +1, –] +

void luaL_getmetatable (lua_State *L, const char *tname);
+ +

+Pushes onto the stack the metatable associated with name tname +in the registry (see luaL_newmetatable). + + + + + +

luaL_getsubtable

+[-0, +1, e] +

int luaL_getsubtable (lua_State *L, int idx, const char *fname);
+ +

+Ensures that the value t[fname], +where t is the value at index idx, +is a table, +and pushes that table onto the stack. +Returns true if it finds a previous table there +and false if it creates a new table. + + + + + +

luaL_gsub

+[-0, +1, e] +

const char *luaL_gsub (lua_State *L,
+                       const char *s,
+                       const char *p,
+                       const char *r);
+ +

+Creates a copy of string s by replacing +any occurrence of the string p +with the string r. +Pushes the resulting string on the stack and returns it. + + + + + +

luaL_len

+[-0, +0, e] +

int luaL_len (lua_State *L, int index);
+ +

+Returns the "length" of the value at the given index +as a number; +it is equivalent to the '#' operator in Lua (see §3.4.6). +Raises an error if the result of the operation is not a number. +(This case only can happen through metamethods.) + + + + + +

luaL_loadbuffer

+[-0, +1, –] +

int luaL_loadbuffer (lua_State *L,
+                     const char *buff,
+                     size_t sz,
+                     const char *name);
+ +

+Equivalent to luaL_loadbufferx with mode equal to NULL. + + + + + +

luaL_loadbufferx

+[-0, +1, –] +

int luaL_loadbufferx (lua_State *L,
+                      const char *buff,
+                      size_t sz,
+                      const char *name,
+                      const char *mode);
+ +

+Loads a buffer as a Lua chunk. +This function uses lua_load to load the chunk in the +buffer pointed to by buff with size sz. + + +

+This function returns the same results as lua_load. +name is the chunk name, +used for debug information and error messages. +The string mode works as in function lua_load. + + + + + +

luaL_loadfile

+[-0, +1, e] +

int luaL_loadfile (lua_State *L, const char *filename);
+ +

+Equivalent to luaL_loadfilex with mode equal to NULL. + + + + + +

luaL_loadfilex

+[-0, +1, e] +

int luaL_loadfilex (lua_State *L, const char *filename,
+                                            const char *mode);
+ +

+Loads a file as a Lua chunk. +This function uses lua_load to load the chunk in the file +named filename. +If filename is NULL, +then it loads from the standard input. +The first line in the file is ignored if it starts with a #. + + +

+The string mode works as in function lua_load. + + +

+This function returns the same results as lua_load, +but it has an extra error code LUA_ERRFILE +if it cannot open/read the file or the file has a wrong mode. + + +

+As lua_load, this function only loads the chunk; +it does not run it. + + + + + +

luaL_loadstring

+[-0, +1, –] +

int luaL_loadstring (lua_State *L, const char *s);
+ +

+Loads a string as a Lua chunk. +This function uses lua_load to load the chunk in +the zero-terminated string s. + + +

+This function returns the same results as lua_load. + + +

+Also as lua_load, this function only loads the chunk; +it does not run it. + + + + + +

luaL_newlib

+[-0, +1, e] +

void luaL_newlib (lua_State *L, const luaL_Reg *l);
+ +

+Creates a new table and registers there +the functions in list l. +It is implemented as the following macro: + +

+     (luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+
+ + + + +

luaL_newlibtable

+[-0, +1, e] +

void luaL_newlibtable (lua_State *L, const luaL_Reg l[]);
+ +

+Creates a new table with a size optimized +to store all entries in the array l +(but does not actually store them). +It is intended to be used in conjunction with luaL_setfuncs +(see luaL_newlib). + + +

+It is implemented as a macro. +The array l must be the actual array, +not a pointer to it. + + + + + +

luaL_newmetatable

+[-0, +1, e] +

int luaL_newmetatable (lua_State *L, const char *tname);
+ +

+If the registry already has the key tname, +returns 0. +Otherwise, +creates a new table to be used as a metatable for userdata, +adds it to the registry with key tname, +and returns 1. + + +

+In both cases pushes onto the stack the final value associated +with tname in the registry. + + + + + +

luaL_newstate

+[-0, +0, –] +

lua_State *luaL_newstate (void);
+ +

+Creates a new Lua state. +It calls lua_newstate with an +allocator based on the standard C realloc function +and then sets a panic function (see §4.6) that prints +an error message to the standard error output in case of fatal +errors. + + +

+Returns the new state, +or NULL if there is a memory allocation error. + + + + + +

luaL_openlibs

+[-0, +0, e] +

void luaL_openlibs (lua_State *L);
+ +

+Opens all standard Lua libraries into the given state. + + + + + +

luaL_optint

+[-0, +0, v] +

int luaL_optint (lua_State *L, int arg, int d);
+ +

+If the function argument arg is a number, +returns this number cast to an int. +If this argument is absent or is nil, +returns d. +Otherwise, raises an error. + + + + + +

luaL_optinteger

+[-0, +0, v] +

lua_Integer luaL_optinteger (lua_State *L,
+                             int arg,
+                             lua_Integer d);
+ +

+If the function argument arg is a number, +returns this number cast to a lua_Integer. +If this argument is absent or is nil, +returns d. +Otherwise, raises an error. + + + + + +

luaL_optlong

+[-0, +0, v] +

long luaL_optlong (lua_State *L, int arg, long d);
+ +

+If the function argument arg is a number, +returns this number cast to a long. +If this argument is absent or is nil, +returns d. +Otherwise, raises an error. + + + + + +

luaL_optlstring

+[-0, +0, v] +

const char *luaL_optlstring (lua_State *L,
+                             int arg,
+                             const char *d,
+                             size_t *l);
+ +

+If the function argument arg is a string, +returns this string. +If this argument is absent or is nil, +returns d. +Otherwise, raises an error. + + +

+If l is not NULL, +fills the position *l with the result's length. + + + + + +

luaL_optnumber

+[-0, +0, v] +

lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number d);
+ +

+If the function argument arg is a number, +returns this number. +If this argument is absent or is nil, +returns d. +Otherwise, raises an error. + + + + + +

luaL_optstring

+[-0, +0, v] +

const char *luaL_optstring (lua_State *L,
+                            int arg,
+                            const char *d);
+ +

+If the function argument arg is a string, +returns this string. +If this argument is absent or is nil, +returns d. +Otherwise, raises an error. + + + + + +

luaL_optunsigned

+[-0, +0, v] +

lua_Unsigned luaL_optunsigned (lua_State *L,
+                               int arg,
+                               lua_Unsigned u);
+ +

+If the function argument arg is a number, +returns this number cast to a lua_Unsigned. +If this argument is absent or is nil, +returns u. +Otherwise, raises an error. + + + + + +

luaL_prepbuffer

+[-?, +?, e] +

char *luaL_prepbuffer (luaL_Buffer *B);
+ +

+Equivalent to luaL_prepbuffsize +with the predefined size LUAL_BUFFERSIZE. + + + + + +

luaL_prepbuffsize

+[-?, +?, e] +

char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz);
+ +

+Returns an address to a space of size sz +where you can copy a string to be added to buffer B +(see luaL_Buffer). +After copying the string into this space you must call +luaL_addsize with the size of the string to actually add +it to the buffer. + + + + + +

luaL_pushresult

+[-?, +1, e] +

void luaL_pushresult (luaL_Buffer *B);
+ +

+Finishes the use of buffer B leaving the final string on +the top of the stack. + + + + + +

luaL_pushresultsize

+[-?, +1, e] +

void luaL_pushresultsize (luaL_Buffer *B, size_t sz);
+ +

+Equivalent to the sequence luaL_addsize, luaL_pushresult. + + + + + +

luaL_ref

+[-1, +0, e] +

int luaL_ref (lua_State *L, int t);
+ +

+Creates and returns a reference, +in the table at index t, +for the object at the top of the stack (and pops the object). + + +

+A reference is a unique integer key. +As long as you do not manually add integer keys into table t, +luaL_ref ensures the uniqueness of the key it returns. +You can retrieve an object referred by reference r +by calling lua_rawgeti(L, t, r). +Function luaL_unref frees a reference and its associated object. + + +

+If the object at the top of the stack is nil, +luaL_ref returns the constant LUA_REFNIL. +The constant LUA_NOREF is guaranteed to be different +from any reference returned by luaL_ref. + + + + + +

luaL_Reg

+
typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+ +

+Type for arrays of functions to be registered by +luaL_setfuncs. +name is the function name and func is a pointer to +the function. +Any array of luaL_Reg must end with an sentinel entry +in which both name and func are NULL. + + + + + +

luaL_requiref

+[-0, +1, e] +

void luaL_requiref (lua_State *L, const char *modname,
+                    lua_CFunction openf, int glb);
+ +

+Calls function openf with string modname as an argument +and sets the call result in package.loaded[modname], +as if that function has been called through require. + + +

+If glb is true, +also stores the result into global modname. + + +

+Leaves a copy of that result on the stack. + + + + + +

luaL_setfuncs

+[-nup, +0, e] +

void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup);
+ +

+Registers all functions in the array l +(see luaL_Reg) into the table on the top of the stack +(below optional upvalues, see next). + + +

+When nup is not zero, +all functions are created sharing nup upvalues, +which must be previously pushed on the stack +on top of the library table. +These values are popped from the stack after the registration. + + + + + +

luaL_setmetatable

+[-0, +0, –] +

void luaL_setmetatable (lua_State *L, const char *tname);
+ +

+Sets the metatable of the object at the top of the stack +as the metatable associated with name tname +in the registry (see luaL_newmetatable). + + + + + +

luaL_testudata

+[-0, +0, e] +

void *luaL_testudata (lua_State *L, int arg, const char *tname);
+ +

+This function works like luaL_checkudata, +except that, when the test fails, +it returns NULL instead of throwing an error. + + + + + +

luaL_tolstring

+[-0, +1, e] +

const char *luaL_tolstring (lua_State *L, int idx, size_t *len);
+ +

+Converts any Lua value at the given index to a C string +in a reasonable format. +The resulting string is pushed onto the stack and also +returned by the function. +If len is not NULL, +the function also sets *len with the string length. + + +

+If the value has a metatable with a "__tostring" field, +then luaL_tolstring calls the corresponding metamethod +with the value as argument, +and uses the result of the call as its result. + + + + + +

luaL_traceback

+[-0, +1, e] +

void luaL_traceback (lua_State *L, lua_State *L1, const char *msg,
+                     int level);
+ +

+Creates and pushes a traceback of the stack L1. +If msg is not NULL it is appended +at the beginning of the traceback. +The level parameter tells at which level +to start the traceback. + + + + + +

luaL_typename

+[-0, +0, –] +

const char *luaL_typename (lua_State *L, int index);
+ +

+Returns the name of the type of the value at the given index. + + + + + +

luaL_unref

+[-0, +0, –] +

void luaL_unref (lua_State *L, int t, int ref);
+ +

+Releases reference ref from the table at index t +(see luaL_ref). +The entry is removed from the table, +so that the referred object can be collected. +The reference ref is also freed to be used again. + + +

+If ref is LUA_NOREF or LUA_REFNIL, +luaL_unref does nothing. + + + + + +

luaL_where

+[-0, +1, e] +

void luaL_where (lua_State *L, int lvl);
+ +

+Pushes onto the stack a string identifying the current position +of the control at level lvl in the call stack. +Typically this string has the following format: + +

+     chunkname:currentline:
+

+Level 0 is the running function, +level 1 is the function that called the running function, +etc. + + +

+This function is used to build a prefix for error messages. + + + + + + + +

6 – Standard Libraries

+ +

+The standard Lua libraries provide useful functions +that are implemented directly through the C API. +Some of these functions provide essential services to the language +(e.g., type and getmetatable); +others provide access to "outside" services (e.g., I/O); +and others could be implemented in Lua itself, +but are quite useful or have critical performance requirements that +deserve an implementation in C (e.g., table.sort). + + +

+All libraries are implemented through the official C API +and are provided as separate C modules. +Currently, Lua has the following standard libraries: + +

    + +
  • basic library (§6.1);
    • + +
  • coroutine library (§6.2);
    • + +
  • package library (§6.3);
    • + +
  • string manipulation (§6.4);
    • + +
  • table manipulation (§6.5);
    • + +
  • mathematical functions (§6.6) (sin, log, etc.);
    • + +
  • bitwise operations (§6.7);
    • + +
  • input and output (§6.8);
    • + +
  • operating system facilities (§6.9);
    • + +
  • debug facilities (§6.10).
    • + +

+Except for the basic and the package libraries, +each library provides all its functions as fields of a global table +or as methods of its objects. + + +

+To have access to these libraries, +the C host program should call the luaL_openlibs function, +which opens all standard libraries. +Alternatively, +the host program can open them individually by using +luaL_requiref to call +luaopen_base (for the basic library), +luaopen_package (for the package library), +luaopen_coroutine (for the coroutine library), +luaopen_string (for the string library), +luaopen_table (for the table library), +luaopen_math (for the mathematical library), +luaopen_bit32 (for the bit library), +luaopen_io (for the I/O library), +luaopen_os (for the Operating System library), +and luaopen_debug (for the debug library). +These functions are declared in lualib.h. + + + +

6.1 – Basic Functions

+ +

+The basic library provides core functions to Lua. +If you do not include this library in your application, +you should check carefully whether you need to provide +implementations for some of its facilities. + + +

+

assert (v [, message])

+Issues an error when +the value of its argument v is false (i.e., nil or false); +otherwise, returns all its arguments. +message is an error message; +when absent, it defaults to "assertion failed!" + + + + +

+

collectgarbage ([opt [, arg]])

+ + +

+This function is a generic interface to the garbage collector. +It performs different functions according to its first argument, opt: + +

    + +
  • "collect": +performs a full garbage-collection cycle. +This is the default option. +
    • + +
  • "stop": +stops automatic execution of the garbage collector. +The collector will run only when explicitly invoked, +until a call to restart it. +
    • + +
  • "restart": +restarts automatic execution of the garbage collector. +
    • + +
  • "count": +returns the total memory in use by Lua (in Kbytes) and +a second value with the total memory in bytes modulo 1024. +The first value has a fractional part, +so the following equality is always true: + +
    +     k, b = collectgarbage("count")
+     assert(k*1024 == math.floor(k)*1024 + b)
+

    +(The second result is useful when Lua is compiled +with a non floating-point type for numbers.) +

    • + +
  • "step": +performs a garbage-collection step. +The step "size" is controlled by arg +(larger values mean more steps) in a non-specified way. +If you want to control the step size +you must experimentally tune the value of arg. +Returns true if the step finished a collection cycle. +
    • + +
  • "setpause": +sets arg as the new value for the pause of +the collector (see §2.5). +Returns the previous value for pause. +
    • + +
  • "setstepmul": +sets arg as the new value for the step multiplier of +the collector (see §2.5). +Returns the previous value for step. +
    • + +
  • "isrunning": +returns a boolean that tells whether the collector is running +(i.e., not stopped). +
    • + +
  • "generational": +changes the collector to generational mode. +This is an experimental feature (see §2.5). +
    • + +
  • "incremental": +changes the collector to incremental mode. +This is the default mode. +
    • + +
+ + + +

+

dofile ([filename])

+Opens the named file and executes its contents as a Lua chunk. +When called without arguments, +dofile executes the contents of the standard input (stdin). +Returns all values returned by the chunk. +In case of errors, dofile propagates the error +to its caller (that is, dofile does not run in protected mode). + + + + +

+

error (message [, level])

+Terminates the last protected function called +and returns message as the error message. +Function error never returns. + + +

+Usually, error adds some information about the error position +at the beginning of the message, if the message is a string. +The level argument specifies how to get the error position. +With level 1 (the default), the error position is where the +error function was called. +Level 2 points the error to where the function +that called error was called; and so on. +Passing a level 0 avoids the addition of error position information +to the message. + + + + +

+

_G

+A global variable (not a function) that +holds the global environment (see §2.2). +Lua itself does not use this variable; +changing its value does not affect any environment, +nor vice-versa. + + + + +

+

getmetatable (object)

+ + +

+If object does not have a metatable, returns nil. +Otherwise, +if the object's metatable has a "__metatable" field, +returns the associated value. +Otherwise, returns the metatable of the given object. + + + + +

+

ipairs (t)

+ + +

+If t has a metamethod __ipairs, +calls it with t as argument and returns the first three +results from the call. + + +

+Otherwise, +returns three values: an iterator function, the table t, and 0, +so that the construction + +

+     for i,v in ipairs(t) do body end
+

+will iterate over the pairs (1,t[1]), (2,t[2]), ..., +up to the first integer key absent from the table. + + + + +

+

load (ld [, source [, mode [, env]]])

+ + +

+Loads a chunk. + + +

+If ld is a string, the chunk is this string. +If ld is a function, +load calls it repeatedly to get the chunk pieces. +Each call to ld must return a string that concatenates +with previous results. +A return of an empty string, nil, or no value signals the end of the chunk. + + +

+If there are no syntactic errors, +returns the compiled chunk as a function; +otherwise, returns nil plus the error message. + + +

+If the resulting function has upvalues, +the first upvalue is set to the value of env, +if that parameter is given, +or to the value of the global environment. +(When you load a main chunk, +the resulting function will always have exactly one upvalue, +the _ENV variable (see §2.2). +When you load a binary chunk created from a function (see string.dump), +the resulting function can have arbitrary upvalues.) + + +

+source is used as the source of the chunk for error messages +and debug information (see §4.9). +When absent, +it defaults to ld, if ld is a string, +or to "=(load)" otherwise. + + +

+The string mode controls whether the chunk can be text or binary +(that is, a precompiled chunk). +It may be the string "b" (only binary chunks), +"t" (only text chunks), +or "bt" (both binary and text). +The default is "bt". + + + + +

+

loadfile ([filename [, mode [, env]]])

+ + +

+Similar to load, +but gets the chunk from file filename +or from the standard input, +if no file name is given. + + + + +

+

next (table [, index])

+ + +

+Allows a program to traverse all fields of a table. +Its first argument is a table and its second argument +is an index in this table. +next returns the next index of the table +and its associated value. +When called with nil as its second argument, +next returns an initial index +and its associated value. +When called with the last index, +or with nil in an empty table, +next returns nil. +If the second argument is absent, then it is interpreted as nil. +In particular, +you can use next(t) to check whether a table is empty. + + +

+The order in which the indices are enumerated is not specified, +even for numeric indices. +(To traverse a table in numeric order, +use a numerical for.) + + +

+The behavior of next is undefined if, +during the traversal, +you assign any value to a non-existent field in the table. +You may however modify existing fields. +In particular, you may clear existing fields. + + + + +

+

pairs (t)

+ + +

+If t has a metamethod __pairs, +calls it with t as argument and returns the first three +results from the call. + + +

+Otherwise, +returns three values: the next function, the table t, and nil, +so that the construction + +

+     for k,v in pairs(t) do body end
+

+will iterate over all key–value pairs of table t. + + +

+See function next for the caveats of modifying +the table during its traversal. + + + + +

+

pcall (f [, arg1, ···])

+ + +

+Calls function f with +the given arguments in protected mode. +This means that any error inside f is not propagated; +instead, pcall catches the error +and returns a status code. +Its first result is the status code (a boolean), +which is true if the call succeeds without errors. +In such case, pcall also returns all results from the call, +after this first result. +In case of any error, pcall returns false plus the error message. + + + + +

+

print (···)

+Receives any number of arguments +and prints their values to stdout, +using the tostring function to convert each argument to a string. +print is not intended for formatted output, +but only as a quick way to show a value, +for instance for debugging. +For complete control over the output, +use string.format and io.write. + + + + +

+

rawequal (v1, v2)

+Checks whether v1 is equal to v2, +without invoking any metamethod. +Returns a boolean. + + + + +

+

rawget (table, index)

+Gets the real value of table[index], +without invoking any metamethod. +table must be a table; +index may be any value. + + + + +

+

rawlen (v)

+Returns the length of the object v, +which must be a table or a string, +without invoking any metamethod. +Returns an integer number. + + + + +

+

rawset (table, index, value)

+Sets the real value of table[index] to value, +without invoking any metamethod. +table must be a table, +index any value different from nil and NaN, +and value any Lua value. + + +

+This function returns table. + + + + +

+

select (index, ···)

+ + +

+If index is a number, +returns all arguments after argument number index; +a negative number indexes from the end (-1 is the last argument). +Otherwise, index must be the string "#", +and select returns the total number of extra arguments it received. + + + + +

+

setmetatable (table, metatable)

+ + +

+Sets the metatable for the given table. +(You cannot change the metatable of other types from Lua, only from C.) +If metatable is nil, +removes the metatable of the given table. +If the original metatable has a "__metatable" field, +raises an error. + + +

+This function returns table. + + + + +

+

tonumber (e [, base])

+ + +

+When called with no base, +tonumber tries to convert its argument to a number. +If the argument is already a number or +a string convertible to a number (see §3.4.2), +then tonumber returns this number; +otherwise, it returns nil. + + +

+When called with base, +then e should be a string to be interpreted as +an integer numeral in that base. +The base may be any integer between 2 and 36, inclusive. +In bases above 10, the letter 'A' (in either upper or lower case) +represents 10, 'B' represents 11, and so forth, +with 'Z' representing 35. +If the string e is not a valid numeral in the given base, +the function returns nil. + + + + +

+

tostring (v)

+Receives a value of any type and +converts it to a string in a reasonable format. +(For complete control of how numbers are converted, +use string.format.) + + +

+If the metatable of v has a "__tostring" field, +then tostring calls the corresponding value +with v as argument, +and uses the result of the call as its result. + + + + +

+

type (v)

+Returns the type of its only argument, coded as a string. +The possible results of this function are +"nil" (a string, not the value nil), +"number", +"string", +"boolean", +"table", +"function", +"thread", +and "userdata". + + + + +

+

_VERSION

+A global variable (not a function) that +holds a string containing the current interpreter version. +The current contents of this variable is "Lua 5.2". + + + + +

+

xpcall (f, msgh [, arg1, ···])

+ + +

+This function is similar to pcall, +except that it sets a new message handler msgh. + + + + + + + +

6.2 – Coroutine Manipulation

+ +

+The operations related to coroutines comprise a sub-library of +the basic library and come inside the table coroutine. +See §2.6 for a general description of coroutines. + + +

+

coroutine.create (f)

+ + +

+Creates a new coroutine, with body f. +f must be a Lua function. +Returns this new coroutine, +an object with type "thread". + + + + +

+

coroutine.resume (co [, val1, ···])

+ + +

+Starts or continues the execution of coroutine co. +The first time you resume a coroutine, +it starts running its body. +The values val1, ... are passed +as the arguments to the body function. +If the coroutine has yielded, +resume restarts it; +the values val1, ... are passed +as the results from the yield. + + +

+If the coroutine runs without any errors, +resume returns true plus any values passed to yield +(if the coroutine yields) or any values returned by the body function +(if the coroutine terminates). +If there is any error, +resume returns false plus the error message. + + + + +

+

coroutine.running ()

+ + +

+Returns the running coroutine plus a boolean, +true when the running coroutine is the main one. + + + + +

+

coroutine.status (co)

+ + +

+Returns the status of coroutine co, as a string: +"running", +if the coroutine is running (that is, it called status); +"suspended", if the coroutine is suspended in a call to yield, +or if it has not started running yet; +"normal" if the coroutine is active but not running +(that is, it has resumed another coroutine); +and "dead" if the coroutine has finished its body function, +or if it has stopped with an error. + + + + +

+

coroutine.wrap (f)

+ + +

+Creates a new coroutine, with body f. +f must be a Lua function. +Returns a function that resumes the coroutine each time it is called. +Any arguments passed to the function behave as the +extra arguments to resume. +Returns the same values returned by resume, +except the first boolean. +In case of error, propagates the error. + + + + +

+

coroutine.yield (···)

+ + +

+Suspends the execution of the calling coroutine. +Any arguments to yield are passed as extra results to resume. + + + + + + + +

6.3 – Modules

+ +

+The package library provides basic +facilities for loading modules in Lua. +It exports one function directly in the global environment: +require. +Everything else is exported in a table package. + + +

+

require (modname)

+ + +

+Loads the given module. +The function starts by looking into the package.loaded table +to determine whether modname is already loaded. +If it is, then require returns the value stored +at package.loaded[modname]. +Otherwise, it tries to find a loader for the module. + + +

+To find a loader, +require is guided by the package.searchers sequence. +By changing this sequence, +we can change how require looks for a module. +The following explanation is based on the default configuration +for package.searchers. + + +

+First require queries package.preload[modname]. +If it has a value, +this value (which should be a function) is the loader. +Otherwise require searches for a Lua loader using the +path stored in package.path. +If that also fails, it searches for a C loader using the +path stored in package.cpath. +If that also fails, +it tries an all-in-one loader (see package.searchers). + + +

+Once a loader is found, +require calls the loader with two arguments: +modname and an extra value dependent on how it got the loader. +(If the loader came from a file, +this extra value is the file name.) +If the loader returns any non-nil value, +require assigns the returned value to package.loaded[modname]. +If the loader does not return a non-nil value and +has not assigned any value to package.loaded[modname], +then require assigns true to this entry. +In any case, require returns the +final value of package.loaded[modname]. + + +

+If there is any error loading or running the module, +or if it cannot find any loader for the module, +then require raises an error. + + + + +

+

package.config

+ + +

+A string describing some compile-time configurations for packages. +This string is a sequence of lines: + +

    + +
  • The first line is the directory separator string. +Default is '\' for Windows and '/' for all other systems.
    • + +
  • The second line is the character that separates templates in a path. +Default is ';'.
    • + +
  • The third line is the string that marks the +substitution points in a template. +Default is '?'.
    • + +
  • The fourth line is a string that, in a path in Windows, +is replaced by the executable's directory. +Default is '!'.
    • + +
  • The fifth line is a mark to ignore all text before it +when building the luaopen_ function name. +Default is '-'.
    • + +
+ + + +

+

package.cpath

+ + +

+The path used by require to search for a C loader. + + +

+Lua initializes the C path package.cpath in the same way +it initializes the Lua path package.path, +using the environment variable LUA_CPATH_5_2 +or the environment variable LUA_CPATH +or a default path defined in luaconf.h. + + + + +

+

package.loaded

+ + +

+A table used by require to control which +modules are already loaded. +When you require a module modname and +package.loaded[modname] is not false, +require simply returns the value stored there. + + +

+This variable is only a reference to the real table; +assignments to this variable do not change the +table used by require. + + + + +

+

package.loadlib (libname, funcname)

+ + +

+Dynamically links the host program with the C library libname. + + +

+If funcname is "*", +then it only links with the library, +making the symbols exported by the library +available to other dynamically linked libraries. +Otherwise, +it looks for a function funcname inside the library +and returns this function as a C function. +So, funcname must follow the lua_CFunction prototype +(see lua_CFunction). + + +

+This is a low-level function. +It completely bypasses the package and module system. +Unlike require, +it does not perform any path searching and +does not automatically adds extensions. +libname must be the complete file name of the C library, +including if necessary a path and an extension. +funcname must be the exact name exported by the C library +(which may depend on the C compiler and linker used). + + +

+This function is not supported by Standard C. +As such, it is only available on some platforms +(Windows, Linux, Mac OS X, Solaris, BSD, +plus other Unix systems that support the dlfcn standard). + + + + +

+

package.path

+ + +

+The path used by require to search for a Lua loader. + + +

+At start-up, Lua initializes this variable with +the value of the environment variable LUA_PATH_5_2 or +the environment variable LUA_PATH or +with a default path defined in luaconf.h, +if those environment variables are not defined. +Any ";;" in the value of the environment variable +is replaced by the default path. + + + + +

+

package.preload

+ + +

+A table to store loaders for specific modules +(see require). + + +

+This variable is only a reference to the real table; +assignments to this variable do not change the +table used by require. + + + + +

+

package.searchers

+ + +

+A table used by require to control how to load modules. + + +

+Each entry in this table is a searcher function. +When looking for a module, +require calls each of these searchers in ascending order, +with the module name (the argument given to require) as its +sole parameter. +The function can return another function (the module loader) +plus an extra value that will be passed to that loader, +or a string explaining why it did not find that module +(or nil if it has nothing to say). + + +

+Lua initializes this table with four searcher functions. + + +

+The first searcher simply looks for a loader in the +package.preload table. + + +

+The second searcher looks for a loader as a Lua library, +using the path stored at package.path. +The search is done as described in function package.searchpath. + + +

+The third searcher looks for a loader as a C library, +using the path given by the variable package.cpath. +Again, +the search is done as described in function package.searchpath. +For instance, +if the C path is the string + +

+     "./?.so;./?.dll;/usr/local/?/init.so"
+

+the searcher for module foo +will try to open the files ./foo.so, ./foo.dll, +and /usr/local/foo/init.so, in that order. +Once it finds a C library, +this searcher first uses a dynamic link facility to link the +application with the library. +Then it tries to find a C function inside the library to +be used as the loader. +The name of this C function is the string "luaopen_" +concatenated with a copy of the module name where each dot +is replaced by an underscore. +Moreover, if the module name has a hyphen, +its prefix up to (and including) the first hyphen is removed. +For instance, if the module name is a.v1-b.c, +the function name will be luaopen_b_c. + + +

+The fourth searcher tries an all-in-one loader. +It searches the C path for a library for +the root name of the given module. +For instance, when requiring a.b.c, +it will search for a C library for a. +If found, it looks into it for an open function for +the submodule; +in our example, that would be luaopen_a_b_c. +With this facility, a package can pack several C submodules +into one single library, +with each submodule keeping its original open function. + + +

+All searchers except the first one (preload) return as the extra value +the file name where the module was found, +as returned by package.searchpath. +The first searcher returns no extra value. + + + + +

+

package.searchpath (name, path [, sep [, rep]])

+ + +

+Searches for the given name in the given path. + + +

+A path is a string containing a sequence of +templates separated by semicolons. +For each template, +the function replaces each interrogation mark (if any) +in the template with a copy of name +wherein all occurrences of sep +(a dot, by default) +were replaced by rep +(the system's directory separator, by default), +and then tries to open the resulting file name. + + +

+For instance, if the path is the string + +

+     "./?.lua;./?.lc;/usr/local/?/init.lua"
+

+the search for the name foo.a +will try to open the files +./foo/a.lua, ./foo/a.lc, and +/usr/local/foo/a/init.lua, in that order. + + +

+Returns the resulting name of the first file that it can +open in read mode (after closing the file), +or nil plus an error message if none succeeds. +(This error message lists all file names it tried to open.) + + + + + + + +

6.4 – String Manipulation

+ +

+This library provides generic functions for string manipulation, +such as finding and extracting substrings, and pattern matching. +When indexing a string in Lua, the first character is at position 1 +(not at 0, as in C). +Indices are allowed to be negative and are interpreted as indexing backwards, +from the end of the string. +Thus, the last character is at position -1, and so on. + + +

+The string library provides all its functions inside the table +string. +It also sets a metatable for strings +where the __index field points to the string table. +Therefore, you can use the string functions in object-oriented style. +For instance, string.byte(s,i) +can be written as s:byte(i). + + +

+The string library assumes one-byte character encodings. + + +

+

string.byte (s [, i [, j]])

+Returns the internal numerical codes of the characters s[i], +s[i+1], ..., s[j]. +The default value for i is 1; +the default value for j is i. +These indices are corrected +following the same rules of function string.sub. + + +

+Numerical codes are not necessarily portable across platforms. + + + + +

+

string.char (···)

+Receives zero or more integers. +Returns a string with length equal to the number of arguments, +in which each character has the internal numerical code equal +to its corresponding argument. + + +

+Numerical codes are not necessarily portable across platforms. + + + + +

+

string.dump (function)

+ + +

+Returns a string containing a binary representation of the given function, +so that a later load on this string returns +a copy of the function (but with new upvalues). + + + + +

+

string.find (s, pattern [, init [, plain]])

+ + +

+Looks for the first match of +pattern in the string s. +If it finds a match, then find returns the indices of s +where this occurrence starts and ends; +otherwise, it returns nil. +A third, optional numerical argument init specifies +where to start the search; +its default value is 1 and can be negative. +A value of true as a fourth, optional argument plain +turns off the pattern matching facilities, +so the function does a plain "find substring" operation, +with no characters in pattern being considered magic. +Note that if plain is given, then init must be given as well. + + +

+If the pattern has captures, +then in a successful match +the captured values are also returned, +after the two indices. + + + + +

+

string.format (formatstring, ···)

+ + +

+Returns a formatted version of its variable number of arguments +following the description given in its first argument (which must be a string). +The format string follows the same rules as the ANSI C function sprintf. +The only differences are that the options/modifiers +*, h, L, l, n, +and p are not supported +and that there is an extra option, q. +The q option formats a string between double quotes, +using escape sequences when necessary to ensure that +it can safely be read back by the Lua interpreter. +For instance, the call + +

+     string.format('%q', 'a string with "quotes" and \n new line')
+

+may produce the string: + +

+     "a string with \"quotes\" and \
+      new line"
+
+ +

+Options +A and a (when available), +E, e, f, +G, and g all expect a number as argument. +Options c, d, +i, o, u, X, and x +also expect a number, +but the range of that number may be limited by +the underlying C implementation. +For options o, u, X, and x, +the number cannot be negative. +Option q expects a string; +option s expects a string without embedded zeros. +If the argument to option s is not a string, +it is converted to one following the same rules of tostring. + + + + +

+

string.gmatch (s, pattern)

+Returns an iterator function that, +each time it is called, +returns the next captures from pattern over the string s. +If pattern specifies no captures, +then the whole match is produced in each call. + + +

+As an example, the following loop +will iterate over all the words from string s, +printing one per line: + +

+     s = "hello world from Lua"
+     for w in string.gmatch(s, "%a+") do
+       print(w)
+     end
+

+The next example collects all pairs key=value from the +given string into a table: + +

+     t = {}
+     s = "from=world, to=Lua"
+     for k, v in string.gmatch(s, "(%w+)=(%w+)") do
+       t[k] = v
+     end
+
+ +

+For this function, a caret '^' at the start of a pattern does not +work as an anchor, as this would prevent the iteration. + + + + +

+

string.gsub (s, pattern, repl [, n])

+Returns a copy of s +in which all (or the first n, if given) +occurrences of the pattern have been +replaced by a replacement string specified by repl, +which can be a string, a table, or a function. +gsub also returns, as its second value, +the total number of matches that occurred. +The name gsub comes from Global SUBstitution. + + +

+If repl is a string, then its value is used for replacement. +The character % works as an escape character: +any sequence in repl of the form %d, +with d between 1 and 9, +stands for the value of the d-th captured substring. +The sequence %0 stands for the whole match. +The sequence %% stands for a single %. + + +

+If repl is a table, then the table is queried for every match, +using the first capture as the key. + + +

+If repl is a function, then this function is called every time a +match occurs, with all captured substrings passed as arguments, +in order. + + +

+In any case, +if the pattern specifies no captures, +then it behaves as if the whole pattern was inside a capture. + + +

+If the value returned by the table query or by the function call +is a string or a number, +then it is used as the replacement string; +otherwise, if it is false or nil, +then there is no replacement +(that is, the original match is kept in the string). + + +

+Here are some examples: + +

+     x = string.gsub("hello world", "(%w+)", "%1 %1")
+     --> x="hello hello world world"
+     
+     x = string.gsub("hello world", "%w+", "%0 %0", 1)
+     --> x="hello hello world"
+     
+     x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
+     --> x="world hello Lua from"
+     
+     x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
+     --> x="home = /home/roberto, user = roberto"
+     
+     x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
+           return load(s)()
+         end)
+     --> x="4+5 = 9"
+     
+     local t = {name="lua", version="5.2"}
+     x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
+     --> x="lua-5.2.tar.gz"
+
+ + + +

+

string.len (s)

+Receives a string and returns its length. +The empty string "" has length 0. +Embedded zeros are counted, +so "a\000bc\000" has length 5. + + + + +

+

string.lower (s)

+Receives a string and returns a copy of this string with all +uppercase letters changed to lowercase. +All other characters are left unchanged. +The definition of what an uppercase letter is depends on the current locale. + + + + +

+

string.match (s, pattern [, init])

+Looks for the first match of +pattern in the string s. +If it finds one, then match returns +the captures from the pattern; +otherwise it returns nil. +If pattern specifies no captures, +then the whole match is returned. +A third, optional numerical argument init specifies +where to start the search; +its default value is 1 and can be negative. + + + + +

+

string.rep (s, n [, sep])

+Returns a string that is the concatenation of n copies of +the string s separated by the string sep. +The default value for sep is the empty string +(that is, no separator). + + + + +

+

string.reverse (s)

+Returns a string that is the string s reversed. + + + + +

+

string.sub (s, i [, j])

+Returns the substring of s that +starts at i and continues until j; +i and j can be negative. +If j is absent, then it is assumed to be equal to -1 +(which is the same as the string length). +In particular, +the call string.sub(s,1,j) returns a prefix of s +with length j, +and string.sub(s, -i) returns a suffix of s +with length i. + + +

+If, after the translation of negative indices, +i is less than 1, +it is corrected to 1. +If j is greater than the string length, +it is corrected to that length. +If, after these corrections, +i is greater than j, +the function returns the empty string. + + + + +

+

string.upper (s)

+Receives a string and returns a copy of this string with all +lowercase letters changed to uppercase. +All other characters are left unchanged. +The definition of what a lowercase letter is depends on the current locale. + + + +

6.4.1 – Patterns

+ + +

Character Class:

+A character class is used to represent a set of characters. +The following combinations are allowed in describing a character class: + +

    + +
  • x: +(where x is not one of the magic characters +^$()%.[]*+-?) +represents the character x itself. +
    • + +
  • .: (a dot) represents all characters.
    • + +
  • %a: represents all letters.
    • + +
  • %c: represents all control characters.
    • + +
  • %d: represents all digits.
    • + +
  • %g: represents all printable characters except space.
    • + +
  • %l: represents all lowercase letters.
    • + +
  • %p: represents all punctuation characters.
    • + +
  • %s: represents all space characters.
    • + +
  • %u: represents all uppercase letters.
    • + +
  • %w: represents all alphanumeric characters.
    • + +
  • %x: represents all hexadecimal digits.
    • + +
  • %x: (where x is any non-alphanumeric character) +represents the character x. +This is the standard way to escape the magic characters. +Any punctuation character (even the non magic) +can be preceded by a '%' +when used to represent itself in a pattern. +
    • + +
  • [set]: +represents the class which is the union of all +characters in set. +A range of characters can be specified by +separating the end characters of the range, +in ascending order, with a '-', +All classes %x described above can also be used as +components in set. +All other characters in set represent themselves. +For example, [%w_] (or [_%w]) +represents all alphanumeric characters plus the underscore, +[0-7] represents the octal digits, +and [0-7%l%-] represents the octal digits plus +the lowercase letters plus the '-' character. + + +

    +The interaction between ranges and classes is not defined. +Therefore, patterns like [%a-z] or [a-%%] +have no meaning. +

    • + +
  • [^set]: +represents the complement of set, +where set is interpreted as above. +
    • + +

+For all classes represented by single letters (%a, %c, etc.), +the corresponding uppercase letter represents the complement of the class. +For instance, %S represents all non-space characters. + + +

+The definitions of letter, space, and other character groups +depend on the current locale. +In particular, the class [a-z] may not be equivalent to %l. + + + + + +

Pattern Item:

+A pattern item can be + +

    + +
  • +a single character class, +which matches any single character in the class; +
    • + +
  • +a single character class followed by '*', +which matches 0 or more repetitions of characters in the class. +These repetition items will always match the longest possible sequence; +
    • + +
  • +a single character class followed by '+', +which matches 1 or more repetitions of characters in the class. +These repetition items will always match the longest possible sequence; +
    • + +
  • +a single character class followed by '-', +which also matches 0 or more repetitions of characters in the class. +Unlike '*', +these repetition items will always match the shortest possible sequence; +
    • + +
  • +a single character class followed by '?', +which matches 0 or 1 occurrence of a character in the class; +
    • + +
  • +%n, for n between 1 and 9; +such item matches a substring equal to the n-th captured string +(see below); +
    • + +
  • +%bxy, where x and y are two distinct characters; +such item matches strings that start with x, end with y, +and where the x and y are balanced. +This means that, if one reads the string from left to right, +counting +1 for an x and -1 for a y, +the ending y is the first y where the count reaches 0. +For instance, the item %b() matches expressions with +balanced parentheses. +
    • + +
  • +%f[set], a frontier pattern; +such item matches an empty string at any position such that +the next character belongs to set +and the previous character does not belong to set. +The set set is interpreted as previously described. +The beginning and the end of the subject are handled as if +they were the character '\0'. +
    • + +
+ + + + +

Pattern:

+A pattern is a sequence of pattern items. +A caret '^' at the beginning of a pattern anchors the match at the +beginning of the subject string. +A '$' at the end of a pattern anchors the match at the +end of the subject string. +At other positions, +'^' and '$' have no special meaning and represent themselves. + + + + + +

Captures:

+A pattern can contain sub-patterns enclosed in parentheses; +they describe captures. +When a match succeeds, the substrings of the subject string +that match captures are stored (captured) for future use. +Captures are numbered according to their left parentheses. +For instance, in the pattern "(a*(.)%w(%s*))", +the part of the string matching "a*(.)%w(%s*)" is +stored as the first capture (and therefore has number 1); +the character matching "." is captured with number 2, +and the part matching "%s*" has number 3. + + +

+As a special case, the empty capture () captures +the current string position (a number). +For instance, if we apply the pattern "()aa()" on the +string "flaaap", there will be two captures: 3 and 5. + + + + + + + + + + + +

6.5 – Table Manipulation

+ +

+This library provides generic functions for table manipulation. +It provides all its functions inside the table table. + + +

+Remember that, whenever an operation needs the length of a table, +the table should be a proper sequence +or have a __len metamethod (see §3.4.6). +All functions ignore non-numeric keys +in tables given as arguments. + + +

+For performance reasons, +all table accesses (get/set) performed by these functions are raw. + + +

+

table.concat (list [, sep [, i [, j]]])

+ + +

+Given a list where all elements are strings or numbers, +returns the string list[i]..sep..list[i+1] ··· sep..list[j]. +The default value for sep is the empty string, +the default for i is 1, +and the default for j is #list. +If i is greater than j, returns the empty string. + + + + +

+

table.insert (list, [pos,] value)

+ + +

+Inserts element value at position pos in list, +shifting up the elements +list[pos], list[pos+1], ···, list[#list]. +The default value for pos is #list+1, +so that a call table.insert(t,x) inserts x at the end +of list t. + + + + +

+

table.pack (···)

+ + +

+Returns a new table with all parameters stored into keys 1, 2, etc. +and with a field "n" with the total number of parameters. +Note that the resulting table may not be a sequence. + + + + +

+

table.remove (list [, pos])

+ + +

+Removes from list the element at position pos, +returning the value of the removed element. +When pos is an integer between 1 and #list, +it shifts down the elements +list[pos+1], list[pos+2], ···, list[#list] +and erases element list[#list]; +The index pos can also be 0 when #list is 0, +or #list + 1; +in those cases, the function erases the element list[pos]. + + +

+The default value for pos is #list, +so that a call table.remove(t) removes the last element +of list t. + + + + +

+

table.sort (list [, comp])

+ + +

+Sorts list elements in a given order, in-place, +from list[1] to list[#list]. +If comp is given, +then it must be a function that receives two list elements +and returns true when the first element must come +before the second in the final order +(so that not comp(list[i+1],list[i]) will be true after the sort). +If comp is not given, +then the standard Lua operator < is used instead. + + +

+The sort algorithm is not stable; +that is, elements considered equal by the given order +may have their relative positions changed by the sort. + + + + +

+

table.unpack (list [, i [, j]])

+ + +

+Returns the elements from the given table. +This function is equivalent to + +

+     return list[i], list[i+1], ···, list[j]
+

+By default, i is 1 and j is #list. + + + + + + + +

6.6 – Mathematical Functions

+ +

+This library is an interface to the standard C math library. +It provides all its functions inside the table math. + + +

+

math.abs (x)

+ + +

+Returns the absolute value of x. + + + + +

+

math.acos (x)

+ + +

+Returns the arc cosine of x (in radians). + + + + +

+

math.asin (x)

+ + +

+Returns the arc sine of x (in radians). + + + + +

+

math.atan (x)

+ + +

+Returns the arc tangent of x (in radians). + + + + +

+

math.atan2 (y, x)

+ + +

+Returns the arc tangent of y/x (in radians), +but uses the signs of both parameters to find the +quadrant of the result. +(It also handles correctly the case of x being zero.) + + + + +

+

math.ceil (x)

+ + +

+Returns the smallest integer larger than or equal to x. + + + + +

+

math.cos (x)

+ + +

+Returns the cosine of x (assumed to be in radians). + + + + +

+

math.cosh (x)

+ + +

+Returns the hyperbolic cosine of x. + + + + +

+

math.deg (x)

+ + +

+Returns the angle x (given in radians) in degrees. + + + + +

+

math.exp (x)

+ + +

+Returns the value ex. + + + + +

+

math.floor (x)

+ + +

+Returns the largest integer smaller than or equal to x. + + + + +

+

math.fmod (x, y)

+ + +

+Returns the remainder of the division of x by y +that rounds the quotient towards zero. + + + + +

+

math.frexp (x)

+ + +

+Returns m and e such that x = m2e, +e is an integer and the absolute value of m is +in the range [0.5, 1) +(or zero when x is zero). + + + + +

+

math.huge

+ + +

+The value HUGE_VAL, +a value larger than or equal to any other numerical value. + + + + +

+

math.ldexp (m, e)

+ + +

+Returns m2e (e should be an integer). + + + + +

+

math.log (x [, base])

+ + +

+Returns the logarithm of x in the given base. +The default for base is e +(so that the function returns the natural logarithm of x). + + + + +

+

math.max (x, ···)

+ + +

+Returns the maximum value among its arguments. + + + + +

+

math.min (x, ···)

+ + +

+Returns the minimum value among its arguments. + + + + +

+

math.modf (x)

+ + +

+Returns two numbers, +the integral part of x and the fractional part of x. + + + + +

+

math.pi

+ + +

+The value of π. + + + + +

+

math.pow (x, y)

+ + +

+Returns xy. +(You can also use the expression x^y to compute this value.) + + + + +

+

math.rad (x)

+ + +

+Returns the angle x (given in degrees) in radians. + + + + +

+

math.random ([m [, n]])

+ + +

+This function is an interface to the simple +pseudo-random generator function rand provided by Standard C. +(No guarantees can be given for its statistical properties.) + + +

+When called without arguments, +returns a uniform pseudo-random real number +in the range [0,1). +When called with an integer number m, +math.random returns +a uniform pseudo-random integer in the range [1, m]. +When called with two integer numbers m and n, +math.random returns a uniform pseudo-random +integer in the range [m, n]. + + + + +

+

math.randomseed (x)

+ + +

+Sets x as the "seed" +for the pseudo-random generator: +equal seeds produce equal sequences of numbers. + + + + +

+

math.sin (x)

+ + +

+Returns the sine of x (assumed to be in radians). + + + + +

+

math.sinh (x)

+ + +

+Returns the hyperbolic sine of x. + + + + +

+

math.sqrt (x)

+ + +

+Returns the square root of x. +(You can also use the expression x^0.5 to compute this value.) + + + + +

+

math.tan (x)

+ + +

+Returns the tangent of x (assumed to be in radians). + + + + +

+

math.tanh (x)

+ + +

+Returns the hyperbolic tangent of x. + + + + + + + +

6.7 – Bitwise Operations

+ +

+This library provides bitwise operations. +It provides all its functions inside the table bit32. + + +

+Unless otherwise stated, +all functions accept numeric arguments in the range +(-251,+251); +each argument is normalized to +the remainder of its division by 232 +and truncated to an integer (in some unspecified way), +so that its final value falls in the range [0,232 - 1]. +Similarly, all results are in the range [0,232 - 1]. +Note that bit32.bnot(0) is 0xFFFFFFFF, +which is different from -1. + + +

+

bit32.arshift (x, disp)

+ + +

+Returns the number x shifted disp bits to the right. +The number disp may be any representable integer. +Negative displacements shift to the left. + + +

+This shift operation is what is called arithmetic shift. +Vacant bits on the left are filled +with copies of the higher bit of x; +vacant bits on the right are filled with zeros. +In particular, +displacements with absolute values higher than 31 +result in zero or 0xFFFFFFFF (all original bits are shifted out). + + + + +

+

bit32.band (···)

+ + +

+Returns the bitwise and of its operands. + + + + +

+

bit32.bnot (x)

+ + +

+Returns the bitwise negation of x. +For any integer x, +the following identity holds: + +

+     assert(bit32.bnot(x) == (-1 - x) % 2^32)
+
+ + + +

+

bit32.bor (···)

+ + +

+Returns the bitwise or of its operands. + + + + +

+

bit32.btest (···)

+ + +

+Returns a boolean signaling +whether the bitwise and of its operands is different from zero. + + + + +

+

bit32.bxor (···)

+ + +

+Returns the bitwise exclusive or of its operands. + + + + +

+

bit32.extract (n, field [, width])

+ + +

+Returns the unsigned number formed by the bits +field to field + width - 1 from n. +Bits are numbered from 0 (least significant) to 31 (most significant). +All accessed bits must be in the range [0, 31]. + + +

+The default for width is 1. + + + + +

+

bit32.replace (n, v, field [, width])

+ + +

+Returns a copy of n with +the bits field to field + width - 1 +replaced by the value v. +See bit32.extract for details about field and width. + + + + +

+

bit32.lrotate (x, disp)

+ + +

+Returns the number x rotated disp bits to the left. +The number disp may be any representable integer. + + +

+For any valid displacement, +the following identity holds: + +

+     assert(bit32.lrotate(x, disp) == bit32.lrotate(x, disp % 32))
+

+In particular, +negative displacements rotate to the right. + + + + +

+

bit32.lshift (x, disp)

+ + +

+Returns the number x shifted disp bits to the left. +The number disp may be any representable integer. +Negative displacements shift to the right. +In any direction, vacant bits are filled with zeros. +In particular, +displacements with absolute values higher than 31 +result in zero (all bits are shifted out). + + +

+For positive displacements, +the following equality holds: + +

+     assert(bit32.lshift(b, disp) == (b * 2^disp) % 2^32)
+
+ + + +

+

bit32.rrotate (x, disp)

+ + +

+Returns the number x rotated disp bits to the right. +The number disp may be any representable integer. + + +

+For any valid displacement, +the following identity holds: + +

+     assert(bit32.rrotate(x, disp) == bit32.rrotate(x, disp % 32))
+

+In particular, +negative displacements rotate to the left. + + + + +

+

bit32.rshift (x, disp)

+ + +

+Returns the number x shifted disp bits to the right. +The number disp may be any representable integer. +Negative displacements shift to the left. +In any direction, vacant bits are filled with zeros. +In particular, +displacements with absolute values higher than 31 +result in zero (all bits are shifted out). + + +

+For positive displacements, +the following equality holds: + +

+     assert(bit32.rshift(b, disp) == math.floor(b % 2^32 / 2^disp))
+
+ +

+This shift operation is what is called logical shift. + + + + + + + +

6.8 – Input and Output Facilities

+ +

+The I/O library provides two different styles for file manipulation. +The first one uses implicit file descriptors; +that is, there are operations to set a default input file and a +default output file, +and all input/output operations are over these default files. +The second style uses explicit file descriptors. + + +

+When using implicit file descriptors, +all operations are supplied by table io. +When using explicit file descriptors, +the operation io.open returns a file descriptor +and then all operations are supplied as methods of the file descriptor. + + +

+The table io also provides +three predefined file descriptors with their usual meanings from C: +io.stdin, io.stdout, and io.stderr. +The I/O library never closes these files. + + +

+Unless otherwise stated, +all I/O functions return nil on failure +(plus an error message as a second result and +a system-dependent error code as a third result) +and some value different from nil on success. +On non-Posix systems, +the computation of the error message and error code +in case of errors +may be not thread safe, +because they rely on the global C variable errno. + + +

+

io.close ([file])

+ + +

+Equivalent to file:close(). +Without a file, closes the default output file. + + + + +

+

io.flush ()

+ + +

+Equivalent to io.output():flush(). + + + + +

+

io.input ([file])

+ + +

+When called with a file name, it opens the named file (in text mode), +and sets its handle as the default input file. +When called with a file handle, +it simply sets this file handle as the default input file. +When called without parameters, +it returns the current default input file. + + +

+In case of errors this function raises the error, +instead of returning an error code. + + + + +

+

io.lines ([filename ···])

+ + +

+Opens the given file name in read mode +and returns an iterator function that +works like file:lines(···) over the opened file. +When the iterator function detects the end of file, +it returns nil (to finish the loop) and automatically closes the file. + + +

+The call io.lines() (with no file name) is equivalent +to io.input():lines(); +that is, it iterates over the lines of the default input file. +In this case it does not close the file when the loop ends. + + +

+In case of errors this function raises the error, +instead of returning an error code. + + + + +

+

io.open (filename [, mode])

+ + +

+This function opens a file, +in the mode specified in the string mode. +It returns a new file handle, +or, in case of errors, nil plus an error message. + + +

+The mode string can be any of the following: + +

    +
  • "r": read mode (the default);
    • +
  • "w": write mode;
    • +
  • "a": append mode;
    • +
  • "r+": update mode, all previous data is preserved;
    • +
  • "w+": update mode, all previous data is erased;
    • +
  • "a+": append update mode, previous data is preserved, + writing is only allowed at the end of file.
    • +

+The mode string can also have a 'b' at the end, +which is needed in some systems to open the file in binary mode. + + + + +

+

io.output ([file])

+ + +

+Similar to io.input, but operates over the default output file. + + + + +

+

io.popen (prog [, mode])

+ + +

+This function is system dependent and is not available +on all platforms. + + +

+Starts program prog in a separated process and returns +a file handle that you can use to read data from this program +(if mode is "r", the default) +or to write data to this program +(if mode is "w"). + + + + +

+

io.read (···)

+ + +

+Equivalent to io.input():read(···). + + + + +

+

io.tmpfile ()

+ + +

+Returns a handle for a temporary file. +This file is opened in update mode +and it is automatically removed when the program ends. + + + + +

+

io.type (obj)

+ + +

+Checks whether obj is a valid file handle. +Returns the string "file" if obj is an open file handle, +"closed file" if obj is a closed file handle, +or nil if obj is not a file handle. + + + + +

+

io.write (···)

+ + +

+Equivalent to io.output():write(···). + + + + +

+

file:close ()

+ + +

+Closes file. +Note that files are automatically closed when +their handles are garbage collected, +but that takes an unpredictable amount of time to happen. + + +

+When closing a file handle created with io.popen, +file:close returns the same values +returned by os.execute. + + + + +

+

file:flush ()

+ + +

+Saves any written data to file. + + + + +

+

file:lines (···)

+ + +

+Returns an iterator function that, +each time it is called, +reads the file according to the given formats. +When no format is given, +uses "*l" as a default. +As an example, the construction + +

+     for c in file:lines(1) do body end
+

+will iterate over all characters of the file, +starting at the current position. +Unlike io.lines, this function does not close the file +when the loop ends. + + +

+In case of errors this function raises the error, +instead of returning an error code. + + + + +

+

file:read (···)

+ + +

+Reads the file file, +according to the given formats, which specify what to read. +For each format, +the function returns a string (or a number) with the characters read, +or nil if it cannot read data with the specified format. +When called without formats, +it uses a default format that reads the next line +(see below). + + +

+The available formats are + +

    + +
  • "*n": +reads a number; +this is the only format that returns a number instead of a string. +
    • + +
  • "*a": +reads the whole file, starting at the current position. +On end of file, it returns the empty string. +
    • + +
  • "*l": +reads the next line skipping the end of line, +returning nil on end of file. +This is the default format. +
    • + +
  • "*L": +reads the next line keeping the end of line (if present), +returning nil on end of file. +
    • + +
  • number: +reads a string with up to this number of bytes, +returning nil on end of file. +If number is zero, +it reads nothing and returns an empty string, +or nil on end of file. +
    • + +
+ + + +

+

file:seek ([whence [, offset]])

+ + +

+Sets and gets the file position, +measured from the beginning of the file, +to the position given by offset plus a base +specified by the string whence, as follows: + +

    +
  • "set": base is position 0 (beginning of the file);
    • +
  • "cur": base is current position;
    • +
  • "end": base is end of file;
    • +

+In case of success, seek returns the final file position, +measured in bytes from the beginning of the file. +If seek fails, it returns nil, +plus a string describing the error. + + +

+The default value for whence is "cur", +and for offset is 0. +Therefore, the call file:seek() returns the current +file position, without changing it; +the call file:seek("set") sets the position to the +beginning of the file (and returns 0); +and the call file:seek("end") sets the position to the +end of the file, and returns its size. + + + + +

+

file:setvbuf (mode [, size])

+ + +

+Sets the buffering mode for an output file. +There are three available modes: + +

    + +
  • "no": +no buffering; the result of any output operation appears immediately. +
    • + +
  • "full": +full buffering; output operation is performed only +when the buffer is full or when +you explicitly flush the file (see io.flush). +
    • + +
  • "line": +line buffering; output is buffered until a newline is output +or there is any input from some special files +(such as a terminal device). +
    • + +

+For the last two cases, size +specifies the size of the buffer, in bytes. +The default is an appropriate size. + + + + +

+

file:write (···)

+ + +

+Writes the value of each of its arguments to file. +The arguments must be strings or numbers. + + +

+In case of success, this function returns file. +Otherwise it returns nil plus a string describing the error. + + + + + + + +

6.9 – Operating System Facilities

+ +

+This library is implemented through table os. + + +

+

os.clock ()

+ + +

+Returns an approximation of the amount in seconds of CPU time +used by the program. + + + + +

+

os.date ([format [, time]])

+ + +

+Returns a string or a table containing date and time, +formatted according to the given string format. + + +

+If the time argument is present, +this is the time to be formatted +(see the os.time function for a description of this value). +Otherwise, date formats the current time. + + +

+If format starts with '!', +then the date is formatted in Coordinated Universal Time. +After this optional character, +if format is the string "*t", +then date returns a table with the following fields: +year (four digits), month (1–12), day (1–31), +hour (0–23), min (0–59), sec (0–61), +wday (weekday, Sunday is 1), +yday (day of the year), +and isdst (daylight saving flag, a boolean). +This last field may be absent +if the information is not available. + + +

+If format is not "*t", +then date returns the date as a string, +formatted according to the same rules as the ANSI C function strftime. + + +

+When called without arguments, +date returns a reasonable date and time representation that depends on +the host system and on the current locale +(that is, os.date() is equivalent to os.date("%c")). + + +

+On non-Posix systems, +this function may be not thread safe +because of its reliance on C function gmtime and C function localtime. + + + + +

+

os.difftime (t2, t1)

+ + +

+Returns the number of seconds from time t1 to time t2. +In POSIX, Windows, and some other systems, +this value is exactly t2-t1. + + + + +

+

os.execute ([command])

+ + +

+This function is equivalent to the ANSI C function system. +It passes command to be executed by an operating system shell. +Its first result is true +if the command terminated successfully, +or nil otherwise. +After this first result +the function returns a string and a number, +as follows: + +

    + +
  • "exit": +the command terminated normally; +the following number is the exit status of the command. +
    • + +
  • "signal": +the command was terminated by a signal; +the following number is the signal that terminated the command. +
    • + +
+ +

+When called without a command, +os.execute returns a boolean that is true if a shell is available. + + + + +

+

os.exit ([code [, close])

+ + +

+Calls the ANSI C function exit to terminate the host program. +If code is true, +the returned status is EXIT_SUCCESS; +if code is false, +the returned status is EXIT_FAILURE; +if code is a number, +the returned status is this number. +The default value for code is true. + + +

+If the optional second argument close is true, +closes the Lua state before exiting. + + + + +

+

os.getenv (varname)

+ + +

+Returns the value of the process environment variable varname, +or nil if the variable is not defined. + + + + +

+

os.remove (filename)

+ + +

+Deletes the file (or empty directory, on POSIX systems) +with the given name. +If this function fails, it returns nil, +plus a string describing the error and the error code. + + + + +

+

os.rename (oldname, newname)

+ + +

+Renames file or directory named oldname to newname. +If this function fails, it returns nil, +plus a string describing the error and the error code. + + + + +

+

os.setlocale (locale [, category])

+ + +

+Sets the current locale of the program. +locale is a system-dependent string specifying a locale; +category is an optional string describing which category to change: +"all", "collate", "ctype", +"monetary", "numeric", or "time"; +the default category is "all". +The function returns the name of the new locale, +or nil if the request cannot be honored. + + +

+If locale is the empty string, +the current locale is set to an implementation-defined native locale. +If locale is the string "C", +the current locale is set to the standard C locale. + + +

+When called with nil as the first argument, +this function only returns the name of the current locale +for the given category. + + +

+This function may be not thread safe +because of its reliance on C function setlocale. + + + + +

+

os.time ([table])

+ + +

+Returns the current time when called without arguments, +or a time representing the date and time specified by the given table. +This table must have fields year, month, and day, +and may have fields +hour (default is 12), +min (default is 0), +sec (default is 0), +and isdst (default is nil). +For a description of these fields, see the os.date function. + + +

+The returned value is a number, whose meaning depends on your system. +In POSIX, Windows, and some other systems, +this number counts the number +of seconds since some given start time (the "epoch"). +In other systems, the meaning is not specified, +and the number returned by time can be used only as an argument to +os.date and os.difftime. + + + + +

+

os.tmpname ()

+ + +

+Returns a string with a file name that can +be used for a temporary file. +The file must be explicitly opened before its use +and explicitly removed when no longer needed. + + +

+On POSIX systems, +this function also creates a file with that name, +to avoid security risks. +(Someone else might create the file with wrong permissions +in the time between getting the name and creating the file.) +You still have to open the file to use it +and to remove it (even if you do not use it). + + +

+When possible, +you may prefer to use io.tmpfile, +which automatically removes the file when the program ends. + + + + + + + +

6.10 – The Debug Library

+ +

+This library provides +the functionality of the debug interface (§4.9) to Lua programs. +You should exert care when using this library. +Several of its functions +violate basic assumptions about Lua code +(e.g., that variables local to a function +cannot be accessed from outside; +that userdata metatables cannot be changed by Lua code; +that Lua programs do not crash) +and therefore can compromise otherwise secure code. +Moreover, some functions in this library may be slow. + + +

+All functions in this library are provided +inside the debug table. +All functions that operate over a thread +have an optional first argument which is the +thread to operate over. +The default is always the current thread. + + +

+

debug.debug ()

+ + +

+Enters an interactive mode with the user, +running each string that the user enters. +Using simple commands and other debug facilities, +the user can inspect global and local variables, +change their values, evaluate expressions, and so on. +A line containing only the word cont finishes this function, +so that the caller continues its execution. + + +

+Note that commands for debug.debug are not lexically nested +within any function and so have no direct access to local variables. + + + + +

+

debug.gethook ([thread])

+ + +

+Returns the current hook settings of the thread, as three values: +the current hook function, the current hook mask, +and the current hook count +(as set by the debug.sethook function). + + + + +

+

debug.getinfo ([thread,] f [, what])

+ + +

+Returns a table with information about a function. +You can give the function directly +or you can give a number as the value of f, +which means the function running at level f of the call stack +of the given thread: +level 0 is the current function (getinfo itself); +level 1 is the function that called getinfo +(except for tail calls, which do not count on the stack); +and so on. +If f is a number larger than the number of active functions, +then getinfo returns nil. + + +

+The returned table can contain all the fields returned by lua_getinfo, +with the string what describing which fields to fill in. +The default for what is to get all information available, +except the table of valid lines. +If present, +the option 'f' +adds a field named func with the function itself. +If present, +the option 'L' +adds a field named activelines with the table of +valid lines. + + +

+For instance, the expression debug.getinfo(1,"n").name returns +a table with a name for the current function, +if a reasonable name can be found, +and the expression debug.getinfo(print) +returns a table with all available information +about the print function. + + + + +

+

debug.getlocal ([thread,] f, local)

+ + +

+This function returns the name and the value of the local variable +with index local of the function at level f of the stack. +This function accesses not only explicit local variables, +but also parameters, temporaries, etc. + + +

+The first parameter or local variable has index 1, and so on, +until the last active variable. +Negative indices refer to vararg parameters; +-1 is the first vararg parameter. +The function returns nil if there is no variable with the given index, +and raises an error when called with a level out of range. +(You can call debug.getinfo to check whether the level is valid.) + + +

+Variable names starting with '(' (open parenthesis) +represent internal variables +(loop control variables, temporaries, varargs, and C function locals). + + +

+The parameter f may also be a function. +In that case, getlocal returns only the name of function parameters. + + + + +

+

debug.getmetatable (value)

+ + +

+Returns the metatable of the given value +or nil if it does not have a metatable. + + + + +

+

debug.getregistry ()

+ + +

+Returns the registry table (see §4.5). + + + + +

+

debug.getupvalue (f, up)

+ + +

+This function returns the name and the value of the upvalue +with index up of the function f. +The function returns nil if there is no upvalue with the given index. + + + + +

+

debug.getuservalue (u)

+ + +

+Returns the Lua value associated to u. +If u is not a userdata, +returns nil. + + + + +

+

debug.sethook ([thread,] hook, mask [, count])

+ + +

+Sets the given function as a hook. +The string mask and the number count describe +when the hook will be called. +The string mask may have the following characters, +with the given meaning: + +

    +
  • 'c': the hook is called every time Lua calls a function;
    • +
  • 'r': the hook is called every time Lua returns from a function;
    • +
  • 'l': the hook is called every time Lua enters a new line of code.
    • +

+With a count different from zero, +the hook is called after every count instructions. + + +

+When called without arguments, +debug.sethook turns off the hook. + + +

+When the hook is called, its first parameter is a string +describing the event that has triggered its call: +"call" (or "tail call"), +"return", +"line", and "count". +For line events, +the hook also gets the new line number as its second parameter. +Inside a hook, +you can call getinfo with level 2 to get more information about +the running function +(level 0 is the getinfo function, +and level 1 is the hook function). + + + + +

+

debug.setlocal ([thread,] level, local, value)

+ + +

+This function assigns the value value to the local variable +with index local of the function at level level of the stack. +The function returns nil if there is no local +variable with the given index, +and raises an error when called with a level out of range. +(You can call getinfo to check whether the level is valid.) +Otherwise, it returns the name of the local variable. + + +

+See debug.getlocal for more information about +variable indices and names. + + + + +

+

debug.setmetatable (value, table)

+ + +

+Sets the metatable for the given value to the given table +(which can be nil). +Returns value. + + + + +

+

debug.setupvalue (f, up, value)

+ + +

+This function assigns the value value to the upvalue +with index up of the function f. +The function returns nil if there is no upvalue +with the given index. +Otherwise, it returns the name of the upvalue. + + + + +

+

debug.setuservalue (udata, value)

+ + +

+Sets the given value as +the Lua value associated to the given udata. +value must be a table or nil; +udata must be a full userdata. + + +

+Returns udata. + + + + +

+

debug.traceback ([thread,] [message [, level]])

+ + +

+If message is present but is neither a string nor nil, +this function returns message without further processing. +Otherwise, +it returns a string with a traceback of the call stack. +An optional message string is appended +at the beginning of the traceback. +An optional level number tells at which level +to start the traceback +(default is 1, the function calling traceback). + + + + +

+

debug.upvalueid (f, n)

+ + +

+Returns an unique identifier (as a light userdata) +for the upvalue numbered n +from the given function. + + +

+These unique identifiers allow a program to check whether different +closures share upvalues. +Lua closures that share an upvalue +(that is, that access a same external local variable) +will return identical ids for those upvalue indices. + + + + +

+

debug.upvaluejoin (f1, n1, f2, n2)

+ + +

+Make the n1-th upvalue of the Lua closure f1 +refer to the n2-th upvalue of the Lua closure f2. + + + + + + + +

7 – Lua Standalone

+ +

+Although Lua has been designed as an extension language, +to be embedded in a host C program, +it is also frequently used as a standalone language. +An interpreter for Lua as a standalone language, +called simply lua, +is provided with the standard distribution. +The standalone interpreter includes +all standard libraries, including the debug library. +Its usage is: + +

+     lua [options] [script [args]]
+

+The options are: + +

    +
  • -e stat: executes string stat;
    • +
  • -l mod: "requires" mod;
    • +
  • -i: enters interactive mode after running script;
    • +
  • -v: prints version information;
    • +
  • -E: ignores environment variables;
    • +
  • --: stops handling options;
    • +
  • -: executes stdin as a file and stops handling options.
    • +

+After handling its options, lua runs the given script, +passing to it the given args as string arguments. +When called without arguments, +lua behaves as lua -v -i +when the standard input (stdin) is a terminal, +and as lua - otherwise. + + +

+When called without option -E, +the interpreter checks for an environment variable LUA_INIT_5_2 +(or LUA_INIT if it is not defined) +before running any argument. +If the variable content has the format @filename, +then lua executes the file. +Otherwise, lua executes the string itself. + + +

+When called with option -E, +besides ignoring LUA_INIT, +Lua also ignores +the values of LUA_PATH and LUA_CPATH, +setting the values of +package.path and package.cpath +with the default paths defined in luaconf.h. + + +

+All options are handled in order, except -i and -E. +For instance, an invocation like + +

+     $ lua -e'a=1' -e 'print(a)' script.lua
+

+will first set a to 1, then print the value of a, +and finally run the file script.lua with no arguments. +(Here $ is the shell prompt. Your prompt may be different.) + + +

+Before starting to run the script, +lua collects all arguments in the command line +in a global table called arg. +The script name is stored at index 0, +the first argument after the script name goes to index 1, +and so on. +Any arguments before the script name +(that is, the interpreter name plus the options) +go to negative indices. +For instance, in the call + +

+     $ lua -la b.lua t1 t2
+

+the interpreter first runs the file a.lua, +then creates a table + +

+     arg = { [-2] = "lua", [-1] = "-la",
+             [0] = "b.lua",
+             [1] = "t1", [2] = "t2" }
+

+and finally runs the file b.lua. +The script is called with arg[1], arg[2], ... +as arguments; +it can also access these arguments with the vararg expression '...'. + + +

+In interactive mode, +if you write an incomplete statement, +the interpreter waits for its completion +by issuing a different prompt. + + +

+In case of unprotected errors in the script, +the interpreter reports the error to the standard error stream. +If the error object is a string, +the interpreter adds a stack traceback to it. +Otherwise, if the error object has a metamethod __tostring, +the interpreter calls this metamethod to produce the final message. +Finally, if the error object is nil, +the interpreter does not report the error. + + +

+When finishing normally, +the interpreter closes its main Lua state +(see lua_close). +The script can avoid this step by +calling os.exit to terminate. + + +

+To allow the use of Lua as a +script interpreter in Unix systems, +the standalone interpreter skips +the first line of a chunk if it starts with #. +Therefore, Lua scripts can be made into executable programs +by using chmod +x and the #! form, +as in + +

+     #!/usr/local/bin/lua
+

+(Of course, +the location of the Lua interpreter may be different in your machine. +If lua is in your PATH, +then + +

+     #!/usr/bin/env lua
+

+is a more portable solution.) + + + +

8 – Incompatibilities with the Previous Version

+ +

+Here we list the incompatibilities that you may find when moving a program +from Lua 5.1 to Lua 5.2. +You can avoid some incompatibilities by compiling Lua with +appropriate options (see file luaconf.h). +However, +all these compatibility options will be removed in the next version of Lua. +Similarly, +all features marked as deprecated in Lua 5.1 +have been removed in Lua 5.2. + + + +

8.1 – Changes in the Language

+
    + +
  • +The concept of environment changed. +Only Lua functions have environments. +To set the environment of a Lua function, +use the variable _ENV or the function load. + + +

    +C functions no longer have environments. +Use an upvalue with a shared table if you need to keep +shared state among several C functions. +(You may use luaL_setfuncs to open a C library +with all functions sharing a common upvalue.) + + +

    +To manipulate the "environment" of a userdata +(which is now called user value), +use the new functions +lua_getuservalue and lua_setuservalue. +

    • + +
  • +Lua identifiers cannot use locale-dependent letters. +
    • + +
  • +Doing a step or a full collection in the garbage collector +does not restart the collector if it has been stopped. +
    • + +
  • +Weak tables with weak keys now perform like ephemeron tables. +
    • + +
  • +The event tail return in debug hooks was removed. +Instead, tail calls generate a special new event, +tail call, so that the debugger can know that +there will not be a corresponding return event. +
    • + +
  • +Equality between function values has changed. +Now, a function definition may not create a new value; +it may reuse some previous value if there is no +observable difference to the new function. +
    • + +
+ + + + +

8.2 – Changes in the Libraries

+
    + +
  • +Function module is deprecated. +It is easy to set up a module with regular Lua code. +Modules are not expected to set global variables. +
    • + +
  • +Functions setfenv and getfenv were removed, +because of the changes in environments. +
    • + +
  • +Function math.log10 is deprecated. +Use math.log with 10 as its second argument, instead. +
    • + +
  • +Function loadstring is deprecated. +Use load instead; it now accepts string arguments +and are exactly equivalent to loadstring. +
    • + +
  • +Function table.maxn is deprecated. +Write it in Lua if you really need it. +
    • + +
  • +Function os.execute now returns true when command +terminates successfully and nil plus error information +otherwise. +
    • + +
  • +Function unpack was moved into the table library +and therefore must be called as table.unpack. +
    • + +
  • +Character class %z in patterns is deprecated, +as now patterns may contain '\0' as a regular character. +
    • + +
  • +The table package.loaders was renamed package.searchers. +
    • + +
  • +Lua does not have bytecode verification anymore. +So, all functions that load code +(load and loadfile) +are potentially insecure when loading untrusted binary data. +(Actually, those functions were already insecure because +of flaws in the verification algorithm.) +When in doubt, +use the mode argument of those functions +to restrict them to loading textual chunks. +
    • + +
  • +The standard paths in the official distribution may +change between versions. +
    • + +
+ + + + +

8.3 – Changes in the API

+
    + +
  • +Pseudoindex LUA_GLOBALSINDEX was removed. +You must get the global environment from the registry +(see §4.5). +
    • + +
  • +Pseudoindex LUA_ENVIRONINDEX +and functions lua_getfenv/lua_setfenv +were removed, +as C functions no longer have environments. +
    • + +
  • +Function luaL_register is deprecated. +Use luaL_setfuncs so that your module does not create globals. +(Modules are not expected to set global variables anymore.) +
    • + +
  • +The osize argument to the allocation function +may not be zero when creating a new block, +that is, when ptr is NULL +(see lua_Alloc). +Use only the test ptr == NULL to check whether +the block is new. +
    • + +
  • +Finalizers (__gc metamethods) for userdata are called in the +reverse order that they were marked for finalization, +not that they were created (see §2.5.1). +(Most userdata are marked immediately after they are created.) +Moreover, +if the metatable does not have a __gc field when set, +the finalizer will not be called, +even if it is set later. +
    • + +
  • +luaL_typerror was removed. +Write your own version if you need it. +
    • + +
  • +Function lua_cpcall is deprecated. +You can simply push the function with lua_pushcfunction +and call it with lua_pcall. +
    • + +
  • +Functions lua_equal and lua_lessthan are deprecated. +Use the new lua_compare with appropriate options instead. +
    • + +
  • +Function lua_objlen was renamed lua_rawlen. +
    • + +
  • +Function lua_load has an extra parameter, mode. +Pass NULL to simulate the old behavior. +
    • + +
  • +Function lua_resume has an extra parameter, from. +Pass NULL or the thread doing the call. +
    • + +
+ + + + +

9 – The Complete Syntax of Lua

+ +

+Here is the complete syntax of Lua in extended BNF. +(It does not describe operator precedences.) + + + + +

+
+	chunk ::= block
+
+	block ::= {stat} [retstat]
+
+	stat ::=  ‘;’ | 
+		 varlist ‘=’ explist | 
+		 functioncall | 
+		 label | 
+		 break | 
+		 goto Name | 
+		 do block end | 
+		 while exp do block end | 
+		 repeat block until exp | 
+		 if exp then block {elseif exp then block} [else block] end | 
+		 for Name ‘=’ exp ‘,’ exp [‘,’ exp] do block end | 
+		 for namelist in explist do block end | 
+		 function funcname funcbody | 
+		 local function Name funcbody | 
+		 local namelist [‘=’ explist] 
+
+	retstat ::= return [explist] [‘;’]
+
+	label ::= ‘::’ Name ‘::’
+
+	funcname ::= Name {‘.’ Name} [‘:’ Name]
+
+	varlist ::= var {‘,’ var}
+
+	var ::=  Name | prefixexp ‘[’ exp ‘]’ | prefixexp ‘.’ Name 
+
+	namelist ::= Name {‘,’ Name}
+
+	explist ::= exp {‘,’ exp}
+
+	exp ::=  nil | false | true | Number | String | ‘...’ | functiondef | 
+		 prefixexp | tableconstructor | exp binop exp | unop exp 
+
+	prefixexp ::= var | functioncall | ‘(’ exp ‘)’
+
+	functioncall ::=  prefixexp args | prefixexp ‘:’ Name args 
+
+	args ::=  ‘(’ [explist] ‘)’ | tableconstructor | String 
+
+	functiondef ::= function funcbody
+
+	funcbody ::= ‘(’ [parlist] ‘)’ block end
+
+	parlist ::= namelist [‘,’ ‘...’] | ‘...’
+
+	tableconstructor ::= ‘{’ [fieldlist] ‘}’
+
+	fieldlist ::= field {fieldsep field} [fieldsep]
+
+	field ::= ‘[’ exp ‘]’ ‘=’ exp | Name ‘=’ exp | exp
+
+	fieldsep ::= ‘,’ | ‘;’
+
+	binop ::= ‘+’ | ‘-’ | ‘*’ | ‘/’ | ‘^’ | ‘%’ | ‘..’ | 
+		 ‘<’ | ‘<=’ | ‘>’ | ‘>=’ | ‘==’ | ‘~=’ | 
+		 and | or
+
+	unop ::= ‘-’ | not | ‘#’
+
+
+ +

+ + + + + + + +

+ +Last update: +Thu Mar 21 12:58:59 BRT 2013 + + + + + diff --git a/extern/lua/doc/osi-certified-72x60.png b/extern/lua/doc/osi-certified-72x60.png new file mode 100644 index 0000000000000000000000000000000000000000..07df5f6ee7a7a8b2108025dcd815f73f145a83af GIT binary patch literal 3774 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 + + +Lua 5.2 readme + + + + + + + +
+

+Lua +Welcome to Lua 5.2 +

+ +

+about +· +installation +· +changes +· +license +· +reference manual + +

About Lua

+ +

+Lua is a powerful, fast, lightweight, embeddable scripting language +developed by a +team +at +PUC-Rio, +the Pontifical Catholic University of Rio de Janeiro in Brazil. +Lua is +free software +used in many products and projects around the world. + +

+Lua's +official web site +provides complete information +about Lua, +including +an +executive summary +and +updated +documentation, +especially the +reference manual, +which may differ slightly from the +local copy +distributed in this package. + +

Installing Lua

+ +

+Lua is distributed in +source +form. +You need to build it before using it. +Building Lua should be straightforward +because +Lua is implemented in pure ANSI C and compiles unmodified in all known +platforms that have an ANSI C compiler. +Lua also compiles unmodified as C++. +The instructions given below for building Lua are for Unix-like platforms. +See also +instructions for other systems +and +customization options. + +

+If you don't have the time or the inclination to compile Lua yourself, +get a binary from +LuaBinaries. +Try also +Lua for Windows, +an easy-to-use distribution of Lua that includes many useful libraries. + +

Building Lua

+ +

+In most Unix-like platforms, simply do "make" with a suitable target. +Here are the details. + +

    +
  1. +Open a terminal window and move to +the top-level directory, which is named lua-5.2.3. +The Makefile there controls both the build process and the installation process. +

    +

  2. + Do "make" and see if your platform is listed. + The platforms currently supported are: +

    +

    + aix ansi bsd freebsd generic linux macosx mingw posix solaris +

    +

    + If your platform is listed, just do "make xxx", where xxx + is your platform name. +

    + If your platform is not listed, try the closest one or posix, generic, + ansi, in this order. +

    +

  3. +The compilation takes only a few moments +and produces three files in the src directory: +lua (the interpreter), +luac (the compiler), +and liblua.a (the library). +

    +

  4. + To check that Lua has been built correctly, do "make test" + after building Lua. This will run the interpreter and print its version string. +
+

+If you're running Linux and get compilation errors, +make sure you have installed the readline development package. +If you get link errors after that, +then try "make linux MYLIBS=-ltermcap". + +

Installing Lua

+

+ Once you have built Lua, you may want to install it in an official + place in your system. In this case, do "make install". The official + place and the way to install files are defined in the Makefile. You'll + probably need the right permissions to install files. + +

+ To build and install Lua in one step, do "make xxx install", + where xxx is your platform name. + +

+ To install Lua locally, do "make local". + This will create a directory install with subdirectories + bin, include, lib, man, + and install Lua as listed below. + + To install Lua locally, but in some other directory, do + "make install INSTALL_TOP=xxx", where xxx is your chosen directory. + +

+
+ bin: +
+ lua luac +
+ include: +
+ lua.h luaconf.h lualib.h lauxlib.h lua.hpp +
+ lib: +
+ liblua.a +
+ man/man1: +
+ lua.1 luac.1 +
+ +

+ These are the only directories you need for development. + If you only want to run Lua programs, + you only need the files in bin and man. + The files in include and lib are needed for + embedding Lua in C or C++ programs. + +

Customization

+

+ Three kinds of things can be customized by editing a file: +

    +
  • Where and how to install Lua — edit Makefile. +
  • How to build Lua — edit src/Makefile. +
  • Lua features — edit src/luaconf.h. +
+ +

+ You don't actually need to edit the Makefiles because you may set the + relevant variables in the command line when invoking make. + Nevertheless, it's probably best to edit and save the Makefiles to + record the changes you need. + +

+ On the other hand, if you need to customize some Lua features, you'll need + to edit src/luaconf.h before building and installing Lua. + The edited file will be the one installed, and + it will be used by any Lua clients that you build, to ensure consistency. + Further customization is available to experts by editing the Lua sources. + +

+ We strongly recommend that you enable dynamic loading in src/luaconf.h. + This is done automatically for all platforms listed above that have + this feature and also for Windows. + +

Building Lua on other systems

+ +

+ If you're not using the usual Unix tools, then the instructions for + building Lua depend on the compiler you use. You'll need to create + projects (or whatever your compiler uses) for building the library, + the interpreter, and the compiler, as follows: + +

+
+library: +
+lapi.c lcode.c lctype.c ldebug.c ldo.c ldump.c lfunc.c lgc.c llex.c +lmem.c lobject.c lopcodes.c lparser.c lstate.c lstring.c ltable.c +ltm.c lundump.c lvm.c lzio.c +lauxlib.c lbaselib.c lbitlib.c lcorolib.c ldblib.c liolib.c +lmathlib.c loslib.c lstrlib.c ltablib.c loadlib.c linit.c +
+interpreter: +
+ library, lua.c +
+compiler: +
+ library, luac.c +
+ +

+ To use Lua as a library in your own programs you'll need to know how to + create and use libraries with your compiler. Moreover, to dynamically load + C libraries for Lua you'll need to know how to create dynamic libraries + and you'll need to make sure that the Lua API functions are accessible to + those dynamic libraries — but don't link the Lua library + into each dynamic library. For Unix, we recommend that the Lua library + be linked statically into the host program and its symbols exported for + dynamic linking; src/Makefile does this for the Lua interpreter. + For Windows, we recommend that the Lua library be a DLL. + +

+ As mentioned above, you may edit src/luaconf.h to customize + some features before building Lua. + +

Changes since Lua 5.1

+ +

+Here are the main changes introduced in Lua 5.2. +The +reference manual +lists the +incompatibilities that had to be introduced. + +

Main changes

+
    +
  • yieldable pcall and metamethods +
  • new lexical scheme for globals +
  • ephemeron tables +
  • new library for bitwise operations +
  • light C functions +
  • emergency garbage collector +
  • goto statement +
  • finalizers for tables +
+ +Here are the other changes introduced in Lua 5.2: +

Language

+
    +
  • no more fenv for threads or functions +
  • tables honor the __len metamethod +
  • hex and \z escapes in strings +
  • support for hexadecimal floats +
  • order metamethods work for different types +
  • no more verification of opcode consistency +
  • hook event "tail return" replaced by "tail call" +
  • empty statement +
  • break statement may appear in the middle of a block +
+ +

Libraries

+
    +
  • arguments for function called through xpcall +
  • optional 'mode' argument to load and loadfile (to control binary x text) +
  • optional 'env' argument to load and loadfile (environment for loaded chunk) +
  • loadlib may load libraries with global names (RTLD_GLOBAL) +
  • new function package.searchpath +
  • modules receive their paths when loaded +
  • optional base in math.log +
  • optional separator in string.rep +
  • file:write returns file +
  • closing a pipe returns exit status +
  • os.exit may close state +
  • new metamethods __pairs and __ipairs +
  • new option 'isrunning' for collectgarbage and lua_gc +
  • frontier patterns +
  • \0 in patterns +
  • new option *L for io.read +
  • options for io.lines +
  • debug.getlocal can access function varargs +
+ +

C API

+
    +
  • main thread predefined in the registry +
  • new functions +lua_absindex, +lua_arith, +lua_compare, +lua_copy, +lua_len, +lua_rawgetp, +lua_rawsetp, +lua_upvalueid, +lua_upvaluejoin, +lua_version. +
  • new functions +luaL_checkversion, +luaL_setmetatable, +luaL_testudata, +luaL_tolstring. +
  • lua_pushstring and pushlstring return string +
  • nparams and isvararg available in debug API +
  • new lua_Unsigned +
+ +

Implementation

+
    +
  • max constants per function raised to 226 +
  • generational mode for garbage collection (experimental) +
  • NaN trick (experimental) +
  • internal (immutable) version of ctypes +
  • simpler implementation for string buffers +
  • parser uses much less C-stack space (no more auto arrays) +
+ +

Lua standalone interpreter

+
    +
  • new -E option to avoid environment variables +
  • handling of non-string error messages +
+ +

License

+ +[osi certified] + + +

+Lua is free software distributed under the terms of the +MIT license +reproduced below; +it may be used for any purpose, including commercial purposes, +at absolutely no cost without having to ask us. + +The only requirement is that if you do use Lua, +then you should give us credit by including the appropriate copyright notice somewhere in your product or its documentation. + +For details, see +this. + +

+Copyright © 1994–2013 Lua.org, PUC-Rio. + +

+Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +

+The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +

+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +

+

+ +

+ +Last update: +Sat Nov 9 22:39:16 BRST 2013 + + + + + diff --git a/extern/lua/src/lapi.c b/extern/lua/src/lapi.c new file mode 100644 index 0000000..d011431 --- /dev/null +++ b/extern/lua/src/lapi.c @@ -0,0 +1,1284 @@ +/* +** $Id: lapi.c,v 2.171.1.1 2013/04/12 18:48:47 roberto Exp $ +** Lua API +** See Copyright Notice in lua.h +*/ + + +#include +#include + +#define lapi_c +#define LUA_CORE + +#include "lua.h" + +#include "lapi.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lundump.h" +#include "lvm.h" + + + +const char lua_ident[] = + "$LuaVersion: " LUA_COPYRIGHT " $" + "$LuaAuthors: " LUA_AUTHORS " $"; + + +/* value at a non-valid index */ +#define NONVALIDVALUE cast(TValue *, luaO_nilobject) + +/* corresponding test */ +#define isvalid(o) ((o) != luaO_nilobject) + +/* test for pseudo index */ +#define ispseudo(i) ((i) <= LUA_REGISTRYINDEX) + +/* test for valid but not pseudo index */ +#define isstackindex(i, o) (isvalid(o) && !ispseudo(i)) + +#define api_checkvalidindex(L, o) api_check(L, isvalid(o), "invalid index") + +#define api_checkstackindex(L, i, o) \ + api_check(L, isstackindex(i, o), "index not in the stack") + + +static TValue *index2addr (lua_State *L, int idx) { + CallInfo *ci = L->ci; + if (idx > 0) { + TValue *o = ci->func + idx; + api_check(L, idx <= ci->top - (ci->func + 1), "unacceptable index"); + if (o >= L->top) return NONVALIDVALUE; + else return o; + } + else if (!ispseudo(idx)) { /* negative index */ + api_check(L, idx != 0 && -idx <= L->top - (ci->func + 1), "invalid index"); + return L->top + idx; + } + else if (idx == LUA_REGISTRYINDEX) + return &G(L)->l_registry; + else { /* upvalues */ + idx = LUA_REGISTRYINDEX - idx; + api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large"); + if (ttislcf(ci->func)) /* light C function? */ + return NONVALIDVALUE; /* it has no upvalues */ + else { + CClosure *func = clCvalue(ci->func); + return (idx <= func->nupvalues) ? &func->upvalue[idx-1] : NONVALIDVALUE; + } + } +} + + +/* +** to be called by 'lua_checkstack' in protected mode, to grow stack +** capturing memory errors +*/ +static void growstack (lua_State *L, void *ud) { + int size = *(int *)ud; + luaD_growstack(L, size); +} + + +LUA_API int lua_checkstack (lua_State *L, int size) { + int res; + CallInfo *ci = L->ci; + lua_lock(L); + if (L->stack_last - L->top > size) /* stack large enough? */ + res = 1; /* yes; check is OK */ + else { /* no; need to grow stack */ + int inuse = cast_int(L->top - L->stack) + EXTRA_STACK; + if (inuse > LUAI_MAXSTACK - size) /* can grow without overflow? */ + res = 0; /* no */ + else /* try to grow stack */ + res = (luaD_rawrunprotected(L, &growstack, &size) == LUA_OK); + } + if (res && ci->top < L->top + size) + ci->top = L->top + size; /* adjust frame top */ + lua_unlock(L); + return res; +} + + +LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) { + int i; + if (from == to) return; + lua_lock(to); + api_checknelems(from, n); + api_check(from, G(from) == G(to), "moving among independent states"); + api_check(from, to->ci->top - to->top >= n, "not enough elements to move"); + from->top -= n; + for (i = 0; i < n; i++) { + setobj2s(to, to->top++, from->top + i); + } + lua_unlock(to); +} + + +LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) { + lua_CFunction old; + lua_lock(L); + old = G(L)->panic; + G(L)->panic = panicf; + lua_unlock(L); + return old; +} + + +LUA_API const lua_Number *lua_version (lua_State *L) { + static const lua_Number version = LUA_VERSION_NUM; + if (L == NULL) return &version; + else return G(L)->version; +} + + + +/* +** basic stack manipulation +*/ + + +/* +** convert an acceptable stack index into an absolute index +*/ +LUA_API int lua_absindex (lua_State *L, int idx) { + return (idx > 0 || ispseudo(idx)) + ? idx + : cast_int(L->top - L->ci->func + idx); +} + + +LUA_API int lua_gettop (lua_State *L) { + return cast_int(L->top - (L->ci->func + 1)); +} + + +LUA_API void lua_settop (lua_State *L, int idx) { + StkId func = L->ci->func; + lua_lock(L); + if (idx >= 0) { + api_check(L, idx <= L->stack_last - (func + 1), "new top too large"); + while (L->top < (func + 1) + idx) + setnilvalue(L->top++); + L->top = (func + 1) + idx; + } + else { + api_check(L, -(idx+1) <= (L->top - (func + 1)), "invalid new top"); + L->top += idx+1; /* `subtract' index (index is negative) */ + } + lua_unlock(L); +} + + +LUA_API void lua_remove (lua_State *L, int idx) { + StkId p; + lua_lock(L); + p = index2addr(L, idx); + api_checkstackindex(L, idx, p); + while (++p < L->top) setobjs2s(L, p-1, p); + L->top--; + lua_unlock(L); +} + + +LUA_API void lua_insert (lua_State *L, int idx) { + StkId p; + StkId q; + lua_lock(L); + p = index2addr(L, idx); + api_checkstackindex(L, idx, p); + for (q = L->top; q > p; q--) /* use L->top as a temporary */ + setobjs2s(L, q, q - 1); + setobjs2s(L, p, L->top); + lua_unlock(L); +} + + +static void moveto (lua_State *L, TValue *fr, int idx) { + TValue *to = index2addr(L, idx); + api_checkvalidindex(L, to); + setobj(L, to, fr); + if (idx < LUA_REGISTRYINDEX) /* function upvalue? */ + luaC_barrier(L, clCvalue(L->ci->func), fr); + /* LUA_REGISTRYINDEX does not need gc barrier + (collector revisits it before finishing collection) */ +} + + +LUA_API void lua_replace (lua_State *L, int idx) { + lua_lock(L); + api_checknelems(L, 1); + moveto(L, L->top - 1, idx); + L->top--; + lua_unlock(L); +} + + +LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) { + TValue *fr; + lua_lock(L); + fr = index2addr(L, fromidx); + moveto(L, fr, toidx); + lua_unlock(L); +} + + +LUA_API void lua_pushvalue (lua_State *L, int idx) { + lua_lock(L); + setobj2s(L, L->top, index2addr(L, idx)); + api_incr_top(L); + lua_unlock(L); +} + + + +/* +** access functions (stack -> C) +*/ + + +LUA_API int lua_type (lua_State *L, int idx) { + StkId o = index2addr(L, idx); + return (isvalid(o) ? ttypenv(o) : LUA_TNONE); +} + + +LUA_API const char *lua_typename (lua_State *L, int t) { + UNUSED(L); + return ttypename(t); +} + + +LUA_API int lua_iscfunction (lua_State *L, int idx) { + StkId o = index2addr(L, idx); + return (ttislcf(o) || (ttisCclosure(o))); +} + + +LUA_API int lua_isnumber (lua_State *L, int idx) { + TValue n; + const TValue *o = index2addr(L, idx); + return tonumber(o, &n); +} + + +LUA_API int lua_isstring (lua_State *L, int idx) { + int t = lua_type(L, idx); + return (t == LUA_TSTRING || t == LUA_TNUMBER); +} + + +LUA_API int lua_isuserdata (lua_State *L, int idx) { + const TValue *o = index2addr(L, idx); + return (ttisuserdata(o) || ttislightuserdata(o)); +} + + +LUA_API int lua_rawequal (lua_State *L, int index1, int index2) { + StkId o1 = index2addr(L, index1); + StkId o2 = index2addr(L, index2); + return (isvalid(o1) && isvalid(o2)) ? luaV_rawequalobj(o1, o2) : 0; +} + + +LUA_API void lua_arith (lua_State *L, int op) { + StkId o1; /* 1st operand */ + StkId o2; /* 2nd operand */ + lua_lock(L); + if (op != LUA_OPUNM) /* all other operations expect two operands */ + api_checknelems(L, 2); + else { /* for unary minus, add fake 2nd operand */ + api_checknelems(L, 1); + setobjs2s(L, L->top, L->top - 1); + L->top++; + } + o1 = L->top - 2; + o2 = L->top - 1; + if (ttisnumber(o1) && ttisnumber(o2)) { + setnvalue(o1, luaO_arith(op, nvalue(o1), nvalue(o2))); + } + else + luaV_arith(L, o1, o1, o2, cast(TMS, op - LUA_OPADD + TM_ADD)); + L->top--; + lua_unlock(L); +} + + +LUA_API int lua_compare (lua_State *L, int index1, int index2, int op) { + StkId o1, o2; + int i = 0; + lua_lock(L); /* may call tag method */ + o1 = index2addr(L, index1); + o2 = index2addr(L, index2); + if (isvalid(o1) && isvalid(o2)) { + switch (op) { + case LUA_OPEQ: i = equalobj(L, o1, o2); break; + case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break; + case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break; + default: api_check(L, 0, "invalid option"); + } + } + lua_unlock(L); + return i; +} + + +LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *isnum) { + TValue n; + const TValue *o = index2addr(L, idx); + if (tonumber(o, &n)) { + if (isnum) *isnum = 1; + return nvalue(o); + } + else { + if (isnum) *isnum = 0; + return 0; + } +} + + +LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *isnum) { + TValue n; + const TValue *o = index2addr(L, idx); + if (tonumber(o, &n)) { + lua_Integer res; + lua_Number num = nvalue(o); + lua_number2integer(res, num); + if (isnum) *isnum = 1; + return res; + } + else { + if (isnum) *isnum = 0; + return 0; + } +} + + +LUA_API lua_Unsigned lua_tounsignedx (lua_State *L, int idx, int *isnum) { + TValue n; + const TValue *o = index2addr(L, idx); + if (tonumber(o, &n)) { + lua_Unsigned res; + lua_Number num = nvalue(o); + lua_number2unsigned(res, num); + if (isnum) *isnum = 1; + return res; + } + else { + if (isnum) *isnum = 0; + return 0; + } +} + + +LUA_API int lua_toboolean (lua_State *L, int idx) { + const TValue *o = index2addr(L, idx); + return !l_isfalse(o); +} + + +LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) { + StkId o = index2addr(L, idx); + if (!ttisstring(o)) { + lua_lock(L); /* `luaV_tostring' may create a new string */ + if (!luaV_tostring(L, o)) { /* conversion failed? */ + if (len != NULL) *len = 0; + lua_unlock(L); + return NULL; + } + luaC_checkGC(L); + o = index2addr(L, idx); /* previous call may reallocate the stack */ + lua_unlock(L); + } + if (len != NULL) *len = tsvalue(o)->len; + return svalue(o); +} + + +LUA_API size_t lua_rawlen (lua_State *L, int idx) { + StkId o = index2addr(L, idx); + switch (ttypenv(o)) { + case LUA_TSTRING: return tsvalue(o)->len; + case LUA_TUSERDATA: return uvalue(o)->len; + case LUA_TTABLE: return luaH_getn(hvalue(o)); + default: return 0; + } +} + + +LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) { + StkId o = index2addr(L, idx); + if (ttislcf(o)) return fvalue(o); + else if (ttisCclosure(o)) + return clCvalue(o)->f; + else return NULL; /* not a C function */ +} + + +LUA_API void *lua_touserdata (lua_State *L, int idx) { + StkId o = index2addr(L, idx); + switch (ttypenv(o)) { + case LUA_TUSERDATA: return (rawuvalue(o) + 1); + case LUA_TLIGHTUSERDATA: return pvalue(o); + default: return NULL; + } +} + + +LUA_API lua_State *lua_tothread (lua_State *L, int idx) { + StkId o = index2addr(L, idx); + return (!ttisthread(o)) ? NULL : thvalue(o); +} + + +LUA_API const void *lua_topointer (lua_State *L, int idx) { + StkId o = index2addr(L, idx); + switch (ttype(o)) { + case LUA_TTABLE: return hvalue(o); + case LUA_TLCL: return clLvalue(o); + case LUA_TCCL: return clCvalue(o); + case LUA_TLCF: return cast(void *, cast(size_t, fvalue(o))); + case LUA_TTHREAD: return thvalue(o); + case LUA_TUSERDATA: + case LUA_TLIGHTUSERDATA: + return lua_touserdata(L, idx); + default: return NULL; + } +} + + + +/* +** push functions (C -> stack) +*/ + + +LUA_API void lua_pushnil (lua_State *L) { + lua_lock(L); + setnilvalue(L->top); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushnumber (lua_State *L, lua_Number n) { + lua_lock(L); + setnvalue(L->top, n); + luai_checknum(L, L->top, + luaG_runerror(L, "C API - attempt to push a signaling NaN")); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) { + lua_lock(L); + setnvalue(L->top, cast_num(n)); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushunsigned (lua_State *L, lua_Unsigned u) { + lua_Number n; + lua_lock(L); + n = lua_unsigned2number(u); + setnvalue(L->top, n); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) { + TString *ts; + lua_lock(L); + luaC_checkGC(L); + ts = luaS_newlstr(L, s, len); + setsvalue2s(L, L->top, ts); + api_incr_top(L); + lua_unlock(L); + return getstr(ts); +} + + +LUA_API const char *lua_pushstring (lua_State *L, const char *s) { + if (s == NULL) { + lua_pushnil(L); + return NULL; + } + else { + TString *ts; + lua_lock(L); + luaC_checkGC(L); + ts = luaS_new(L, s); + setsvalue2s(L, L->top, ts); + api_incr_top(L); + lua_unlock(L); + return getstr(ts); + } +} + + +LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt, + va_list argp) { + const char *ret; + lua_lock(L); + luaC_checkGC(L); + ret = luaO_pushvfstring(L, fmt, argp); + lua_unlock(L); + return ret; +} + + +LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) { + const char *ret; + va_list argp; + lua_lock(L); + luaC_checkGC(L); + va_start(argp, fmt); + ret = luaO_pushvfstring(L, fmt, argp); + va_end(argp); + lua_unlock(L); + return ret; +} + + +LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) { + lua_lock(L); + if (n == 0) { + setfvalue(L->top, fn); + } + else { + Closure *cl; + api_checknelems(L, n); + api_check(L, n <= MAXUPVAL, "upvalue index too large"); + luaC_checkGC(L); + cl = luaF_newCclosure(L, n); + cl->c.f = fn; + L->top -= n; + while (n--) + setobj2n(L, &cl->c.upvalue[n], L->top + n); + setclCvalue(L, L->top, cl); + } + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushboolean (lua_State *L, int b) { + lua_lock(L); + setbvalue(L->top, (b != 0)); /* ensure that true is 1 */ + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushlightuserdata (lua_State *L, void *p) { + lua_lock(L); + setpvalue(L->top, p); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API int lua_pushthread (lua_State *L) { + lua_lock(L); + setthvalue(L, L->top, L); + api_incr_top(L); + lua_unlock(L); + return (G(L)->mainthread == L); +} + + + +/* +** get functions (Lua -> stack) +*/ + + +LUA_API void lua_getglobal (lua_State *L, const char *var) { + Table *reg = hvalue(&G(L)->l_registry); + const TValue *gt; /* global table */ + lua_lock(L); + gt = luaH_getint(reg, LUA_RIDX_GLOBALS); + setsvalue2s(L, L->top++, luaS_new(L, var)); + luaV_gettable(L, gt, L->top - 1, L->top - 1); + lua_unlock(L); +} + + +LUA_API void lua_gettable (lua_State *L, int idx) { + StkId t; + lua_lock(L); + t = index2addr(L, idx); + luaV_gettable(L, t, L->top - 1, L->top - 1); + lua_unlock(L); +} + + +LUA_API void lua_getfield (lua_State *L, int idx, const char *k) { + StkId t; + lua_lock(L); + t = index2addr(L, idx); + setsvalue2s(L, L->top, luaS_new(L, k)); + api_incr_top(L); + luaV_gettable(L, t, L->top - 1, L->top - 1); + lua_unlock(L); +} + + +LUA_API void lua_rawget (lua_State *L, int idx) { + StkId t; + lua_lock(L); + t = index2addr(L, idx); + api_check(L, ttistable(t), "table expected"); + setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1)); + lua_unlock(L); +} + + +LUA_API void lua_rawgeti (lua_State *L, int idx, int n) { + StkId t; + lua_lock(L); + t = index2addr(L, idx); + api_check(L, ttistable(t), "table expected"); + setobj2s(L, L->top, luaH_getint(hvalue(t), n)); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_rawgetp (lua_State *L, int idx, const void *p) { + StkId t; + TValue k; + lua_lock(L); + t = index2addr(L, idx); + api_check(L, ttistable(t), "table expected"); + setpvalue(&k, cast(void *, p)); + setobj2s(L, L->top, luaH_get(hvalue(t), &k)); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_createtable (lua_State *L, int narray, int nrec) { + Table *t; + lua_lock(L); + luaC_checkGC(L); + t = luaH_new(L); + sethvalue(L, L->top, t); + api_incr_top(L); + if (narray > 0 || nrec > 0) + luaH_resize(L, t, narray, nrec); + lua_unlock(L); +} + + +LUA_API int lua_getmetatable (lua_State *L, int objindex) { + const TValue *obj; + Table *mt = NULL; + int res; + lua_lock(L); + obj = index2addr(L, objindex); + switch (ttypenv(obj)) { + case LUA_TTABLE: + mt = hvalue(obj)->metatable; + break; + case LUA_TUSERDATA: + mt = uvalue(obj)->metatable; + break; + default: + mt = G(L)->mt[ttypenv(obj)]; + break; + } + if (mt == NULL) + res = 0; + else { + sethvalue(L, L->top, mt); + api_incr_top(L); + res = 1; + } + lua_unlock(L); + return res; +} + + +LUA_API void lua_getuservalue (lua_State *L, int idx) { + StkId o; + lua_lock(L); + o = index2addr(L, idx); + api_check(L, ttisuserdata(o), "userdata expected"); + if (uvalue(o)->env) { + sethvalue(L, L->top, uvalue(o)->env); + } else + setnilvalue(L->top); + api_incr_top(L); + lua_unlock(L); +} + + +/* +** set functions (stack -> Lua) +*/ + + +LUA_API void lua_setglobal (lua_State *L, const char *var) { + Table *reg = hvalue(&G(L)->l_registry); + const TValue *gt; /* global table */ + lua_lock(L); + api_checknelems(L, 1); + gt = luaH_getint(reg, LUA_RIDX_GLOBALS); + setsvalue2s(L, L->top++, luaS_new(L, var)); + luaV_settable(L, gt, L->top - 1, L->top - 2); + L->top -= 2; /* pop value and key */ + lua_unlock(L); +} + + +LUA_API void lua_settable (lua_State *L, int idx) { + StkId t; + lua_lock(L); + api_checknelems(L, 2); + t = index2addr(L, idx); + luaV_settable(L, t, L->top - 2, L->top - 1); + L->top -= 2; /* pop index and value */ + lua_unlock(L); +} + + +LUA_API void lua_setfield (lua_State *L, int idx, const char *k) { + StkId t; + lua_lock(L); + api_checknelems(L, 1); + t = index2addr(L, idx); + setsvalue2s(L, L->top++, luaS_new(L, k)); + luaV_settable(L, t, L->top - 1, L->top - 2); + L->top -= 2; /* pop value and key */ + lua_unlock(L); +} + + +LUA_API void lua_rawset (lua_State *L, int idx) { + StkId t; + lua_lock(L); + api_checknelems(L, 2); + t = index2addr(L, idx); + api_check(L, ttistable(t), "table expected"); + setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1); + invalidateTMcache(hvalue(t)); + luaC_barrierback(L, gcvalue(t), L->top-1); + L->top -= 2; + lua_unlock(L); +} + + +LUA_API void lua_rawseti (lua_State *L, int idx, int n) { + StkId t; + lua_lock(L); + api_checknelems(L, 1); + t = index2addr(L, idx); + api_check(L, ttistable(t), "table expected"); + luaH_setint(L, hvalue(t), n, L->top - 1); + luaC_barrierback(L, gcvalue(t), L->top-1); + L->top--; + lua_unlock(L); +} + + +LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) { + StkId t; + TValue k; + lua_lock(L); + api_checknelems(L, 1); + t = index2addr(L, idx); + api_check(L, ttistable(t), "table expected"); + setpvalue(&k, cast(void *, p)); + setobj2t(L, luaH_set(L, hvalue(t), &k), L->top - 1); + luaC_barrierback(L, gcvalue(t), L->top - 1); + L->top--; + lua_unlock(L); +} + + +LUA_API int lua_setmetatable (lua_State *L, int objindex) { + TValue *obj; + Table *mt; + lua_lock(L); + api_checknelems(L, 1); + obj = index2addr(L, objindex); + if (ttisnil(L->top - 1)) + mt = NULL; + else { + api_check(L, ttistable(L->top - 1), "table expected"); + mt = hvalue(L->top - 1); + } + switch (ttypenv(obj)) { + case LUA_TTABLE: { + hvalue(obj)->metatable = mt; + if (mt) { + luaC_objbarrierback(L, gcvalue(obj), mt); + luaC_checkfinalizer(L, gcvalue(obj), mt); + } + break; + } + case LUA_TUSERDATA: { + uvalue(obj)->metatable = mt; + if (mt) { + luaC_objbarrier(L, rawuvalue(obj), mt); + luaC_checkfinalizer(L, gcvalue(obj), mt); + } + break; + } + default: { + G(L)->mt[ttypenv(obj)] = mt; + break; + } + } + L->top--; + lua_unlock(L); + return 1; +} + + +LUA_API void lua_setuservalue (lua_State *L, int idx) { + StkId o; + lua_lock(L); + api_checknelems(L, 1); + o = index2addr(L, idx); + api_check(L, ttisuserdata(o), "userdata expected"); + if (ttisnil(L->top - 1)) + uvalue(o)->env = NULL; + else { + api_check(L, ttistable(L->top - 1), "table expected"); + uvalue(o)->env = hvalue(L->top - 1); + luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1)); + } + L->top--; + lua_unlock(L); +} + + +/* +** `load' and `call' functions (run Lua code) +*/ + + +#define checkresults(L,na,nr) \ + api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)), \ + "results from function overflow current stack size") + + +LUA_API int lua_getctx (lua_State *L, int *ctx) { + if (L->ci->callstatus & CIST_YIELDED) { + if (ctx) *ctx = L->ci->u.c.ctx; + return L->ci->u.c.status; + } + else return LUA_OK; +} + + +LUA_API void lua_callk (lua_State *L, int nargs, int nresults, int ctx, + lua_CFunction k) { + StkId func; + lua_lock(L); + api_check(L, k == NULL || !isLua(L->ci), + "cannot use continuations inside hooks"); + api_checknelems(L, nargs+1); + api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread"); + checkresults(L, nargs, nresults); + func = L->top - (nargs+1); + if (k != NULL && L->nny == 0) { /* need to prepare continuation? */ + L->ci->u.c.k = k; /* save continuation */ + L->ci->u.c.ctx = ctx; /* save context */ + luaD_call(L, func, nresults, 1); /* do the call */ + } + else /* no continuation or no yieldable */ + luaD_call(L, func, nresults, 0); /* just do the call */ + adjustresults(L, nresults); + lua_unlock(L); +} + + + +/* +** Execute a protected call. +*/ +struct CallS { /* data to `f_call' */ + StkId func; + int nresults; +}; + + +static void f_call (lua_State *L, void *ud) { + struct CallS *c = cast(struct CallS *, ud); + luaD_call(L, c->func, c->nresults, 0); +} + + + +LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc, + int ctx, lua_CFunction k) { + struct CallS c; + int status; + ptrdiff_t func; + lua_lock(L); + api_check(L, k == NULL || !isLua(L->ci), + "cannot use continuations inside hooks"); + api_checknelems(L, nargs+1); + api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread"); + checkresults(L, nargs, nresults); + if (errfunc == 0) + func = 0; + else { + StkId o = index2addr(L, errfunc); + api_checkstackindex(L, errfunc, o); + func = savestack(L, o); + } + c.func = L->top - (nargs+1); /* function to be called */ + if (k == NULL || L->nny > 0) { /* no continuation or no yieldable? */ + c.nresults = nresults; /* do a 'conventional' protected call */ + status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func); + } + else { /* prepare continuation (call is already protected by 'resume') */ + CallInfo *ci = L->ci; + ci->u.c.k = k; /* save continuation */ + ci->u.c.ctx = ctx; /* save context */ + /* save information for error recovery */ + ci->extra = savestack(L, c.func); + ci->u.c.old_allowhook = L->allowhook; + ci->u.c.old_errfunc = L->errfunc; + L->errfunc = func; + /* mark that function may do error recovery */ + ci->callstatus |= CIST_YPCALL; + luaD_call(L, c.func, nresults, 1); /* do the call */ + ci->callstatus &= ~CIST_YPCALL; + L->errfunc = ci->u.c.old_errfunc; + status = LUA_OK; /* if it is here, there were no errors */ + } + adjustresults(L, nresults); + lua_unlock(L); + return status; +} + + +LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data, + const char *chunkname, const char *mode) { + ZIO z; + int status; + lua_lock(L); + if (!chunkname) chunkname = "?"; + luaZ_init(L, &z, reader, data); + status = luaD_protectedparser(L, &z, chunkname, mode); + if (status == LUA_OK) { /* no errors? */ + LClosure *f = clLvalue(L->top - 1); /* get newly created function */ + if (f->nupvalues == 1) { /* does it have one upvalue? */ + /* get global table from registry */ + Table *reg = hvalue(&G(L)->l_registry); + const TValue *gt = luaH_getint(reg, LUA_RIDX_GLOBALS); + /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */ + setobj(L, f->upvals[0]->v, gt); + luaC_barrier(L, f->upvals[0], gt); + } + } + lua_unlock(L); + return status; +} + + +LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) { + int status; + TValue *o; + lua_lock(L); + api_checknelems(L, 1); + o = L->top - 1; + if (isLfunction(o)) + status = luaU_dump(L, getproto(o), writer, data, 0); + else + status = 1; + lua_unlock(L); + return status; +} + + +LUA_API int lua_status (lua_State *L) { + return L->status; +} + + +/* +** Garbage-collection function +*/ + +LUA_API int lua_gc (lua_State *L, int what, int data) { + int res = 0; + global_State *g; + lua_lock(L); + g = G(L); + switch (what) { + case LUA_GCSTOP: { + g->gcrunning = 0; + break; + } + case LUA_GCRESTART: { + luaE_setdebt(g, 0); + g->gcrunning = 1; + break; + } + case LUA_GCCOLLECT: { + luaC_fullgc(L, 0); + break; + } + case LUA_GCCOUNT: { + /* GC values are expressed in Kbytes: #bytes/2^10 */ + res = cast_int(gettotalbytes(g) >> 10); + break; + } + case LUA_GCCOUNTB: { + res = cast_int(gettotalbytes(g) & 0x3ff); + break; + } + case LUA_GCSTEP: { + if (g->gckind == KGC_GEN) { /* generational mode? */ + res = (g->GCestimate == 0); /* true if it will do major collection */ + luaC_forcestep(L); /* do a single step */ + } + else { + lu_mem debt = cast(lu_mem, data) * 1024 - GCSTEPSIZE; + if (g->gcrunning) + debt += g->GCdebt; /* include current debt */ + luaE_setdebt(g, debt); + luaC_forcestep(L); + if (g->gcstate == GCSpause) /* end of cycle? */ + res = 1; /* signal it */ + } + break; + } + case LUA_GCSETPAUSE: { + res = g->gcpause; + g->gcpause = data; + break; + } + case LUA_GCSETMAJORINC: { + res = g->gcmajorinc; + g->gcmajorinc = data; + break; + } + case LUA_GCSETSTEPMUL: { + res = g->gcstepmul; + g->gcstepmul = data; + break; + } + case LUA_GCISRUNNING: { + res = g->gcrunning; + break; + } + case LUA_GCGEN: { /* change collector to generational mode */ + luaC_changemode(L, KGC_GEN); + break; + } + case LUA_GCINC: { /* change collector to incremental mode */ + luaC_changemode(L, KGC_NORMAL); + break; + } + default: res = -1; /* invalid option */ + } + lua_unlock(L); + return res; +} + + + +/* +** miscellaneous functions +*/ + + +LUA_API int lua_error (lua_State *L) { + lua_lock(L); + api_checknelems(L, 1); + luaG_errormsg(L); + /* code unreachable; will unlock when control actually leaves the kernel */ + return 0; /* to avoid warnings */ +} + + +LUA_API int lua_next (lua_State *L, int idx) { + StkId t; + int more; + lua_lock(L); + t = index2addr(L, idx); + api_check(L, ttistable(t), "table expected"); + more = luaH_next(L, hvalue(t), L->top - 1); + if (more) { + api_incr_top(L); + } + else /* no more elements */ + L->top -= 1; /* remove key */ + lua_unlock(L); + return more; +} + + +LUA_API void lua_concat (lua_State *L, int n) { + lua_lock(L); + api_checknelems(L, n); + if (n >= 2) { + luaC_checkGC(L); + luaV_concat(L, n); + } + else if (n == 0) { /* push empty string */ + setsvalue2s(L, L->top, luaS_newlstr(L, "", 0)); + api_incr_top(L); + } + /* else n == 1; nothing to do */ + lua_unlock(L); +} + + +LUA_API void lua_len (lua_State *L, int idx) { + StkId t; + lua_lock(L); + t = index2addr(L, idx); + luaV_objlen(L, L->top, t); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) { + lua_Alloc f; + lua_lock(L); + if (ud) *ud = G(L)->ud; + f = G(L)->frealloc; + lua_unlock(L); + return f; +} + + +LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) { + lua_lock(L); + G(L)->ud = ud; + G(L)->frealloc = f; + lua_unlock(L); +} + + +LUA_API void *lua_newuserdata (lua_State *L, size_t size) { + Udata *u; + lua_lock(L); + luaC_checkGC(L); + u = luaS_newudata(L, size, NULL); + setuvalue(L, L->top, u); + api_incr_top(L); + lua_unlock(L); + return u + 1; +} + + + +static const char *aux_upvalue (StkId fi, int n, TValue **val, + GCObject **owner) { + switch (ttype(fi)) { + case LUA_TCCL: { /* C closure */ + CClosure *f = clCvalue(fi); + if (!(1 <= n && n <= f->nupvalues)) return NULL; + *val = &f->upvalue[n-1]; + if (owner) *owner = obj2gco(f); + return ""; + } + case LUA_TLCL: { /* Lua closure */ + LClosure *f = clLvalue(fi); + TString *name; + Proto *p = f->p; + if (!(1 <= n && n <= p->sizeupvalues)) return NULL; + *val = f->upvals[n-1]->v; + if (owner) *owner = obj2gco(f->upvals[n - 1]); + name = p->upvalues[n-1].name; + return (name == NULL) ? "" : getstr(name); + } + default: return NULL; /* not a closure */ + } +} + + +LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) { + const char *name; + TValue *val = NULL; /* to avoid warnings */ + lua_lock(L); + name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL); + if (name) { + setobj2s(L, L->top, val); + api_incr_top(L); + } + lua_unlock(L); + return name; +} + + +LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) { + const char *name; + TValue *val = NULL; /* to avoid warnings */ + GCObject *owner = NULL; /* to avoid warnings */ + StkId fi; + lua_lock(L); + fi = index2addr(L, funcindex); + api_checknelems(L, 1); + name = aux_upvalue(fi, n, &val, &owner); + if (name) { + L->top--; + setobj(L, val, L->top); + luaC_barrier(L, owner, L->top); + } + lua_unlock(L); + return name; +} + + +static UpVal **getupvalref (lua_State *L, int fidx, int n, LClosure **pf) { + LClosure *f; + StkId fi = index2addr(L, fidx); + api_check(L, ttisLclosure(fi), "Lua function expected"); + f = clLvalue(fi); + api_check(L, (1 <= n && n <= f->p->sizeupvalues), "invalid upvalue index"); + if (pf) *pf = f; + return &f->upvals[n - 1]; /* get its upvalue pointer */ +} + + +LUA_API void *lua_upvalueid (lua_State *L, int fidx, int n) { + StkId fi = index2addr(L, fidx); + switch (ttype(fi)) { + case LUA_TLCL: { /* lua closure */ + return *getupvalref(L, fidx, n, NULL); + } + case LUA_TCCL: { /* C closure */ + CClosure *f = clCvalue(fi); + api_check(L, 1 <= n && n <= f->nupvalues, "invalid upvalue index"); + return &f->upvalue[n - 1]; + } + default: { + api_check(L, 0, "closure expected"); + return NULL; + } + } +} + + +LUA_API void lua_upvaluejoin (lua_State *L, int fidx1, int n1, + int fidx2, int n2) { + LClosure *f1; + UpVal **up1 = getupvalref(L, fidx1, n1, &f1); + UpVal **up2 = getupvalref(L, fidx2, n2, NULL); + *up1 = *up2; + luaC_objbarrier(L, f1, *up2); +} + diff --git a/extern/lua/src/lapi.h b/extern/lua/src/lapi.h new file mode 100644 index 0000000..c7d34ad --- /dev/null +++ b/extern/lua/src/lapi.h @@ -0,0 +1,24 @@ +/* +** $Id: lapi.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $ +** Auxiliary functions from Lua API +** See Copyright Notice in lua.h +*/ + +#ifndef lapi_h +#define lapi_h + + +#include "llimits.h" +#include "lstate.h" + +#define api_incr_top(L) {L->top++; api_check(L, L->top <= L->ci->top, \ + "stack overflow");} + +#define adjustresults(L,nres) \ + { if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; } + +#define api_checknelems(L,n) api_check(L, (n) < (L->top - L->ci->func), \ + "not enough elements in the stack") + + +#endif diff --git a/extern/lua/src/lapi.o b/extern/lua/src/lapi.o new file mode 100644 index 0000000000000000000000000000000000000000..1afe573149b416fb558674f2417fba72c5e973e3 GIT binary patch literal 22792 zcmeHve{@{MmFCkA+l}O?+u(o($kGE%EMX%gVlt9}(Cuzn)v}CbWZ51JNOG%X3(Jz| zevM_oww$&c-ZYw{IdLY=9{%u|$;>b_%#3ypaR^~^+Ssv8Hp_~i;|(DQ0;G)`BMd0U zV6@+@cdNVftj=Wi%s+e1);X>B-dDG7-MV$_-dk0M-Stf?3JVGhRSJx67`ZQn8b6{imIQcT5;=kk8m$Pc4W^N|NBRi(>ukUFHYiV zwu_YU482vJO%Av&H~k{zk`3I4c9hhe-+jx||3;OQA~GqG#|kCO;o_PjUG8i4%3f7J z)}$zE@EjSDjX%=rQ`^hM@CyGC_cepmAocZA^vJePt#gUg*K3}asQVftu(ma9ecmFh zkF3|MS2H(GPfv@~WqU4=jKcDyT3lAMYiH$D(B(I;L(SCkONz`Z!>N$Zi=l{A_0)<> ziW3X6{5RekxCeb38=I`(;MMNDtE)=M-`XM~FNoyna;VKCQtPWN(>GtF+PtFjIdS-W zv8emm?v-M3L+vyEq3T} zL+QjDBGN?M>OEO`#NoG!MZsZFx6<`A&1?L}!dmIdGBQNn@5~mFTI~@L^gmuKDi066 zB&-v{TJ71jEct#xJ-SWZ=@EzDE}kgq8X>X6$+V}bARV@z7sO@EN4ik5`Vd3Y=4D_CqCpSU^1R7;J<>HY{FjSX zxD9J^&v|-oUjR{|`1KyKcmb)aU<@72;0J3IDQFhjO+M!lm1Cqq-98$;uvu7Z${1KC zhSwDc>owcV7FNqvbx-7X6)#UrGI? z8nGhY2UVjd)#$Ps%SoJ5B6T@g={mB~jZ!WQyu~^TDa3I9WacXuAW3qo2b^INn2**L z>s6{uo_1yY)J^iJ%X(i}Z*II-SjSHN7SIfRN_no3^0Yv!E=;wsN=UWV@^iv!A;!A? zGZUYI>FuO1a~_D3wCRtpVd1^4_ZYFO>Z^IQoZw2w1O3Ei3?Kh`RnM)Rifse)e3TQJBl@0SoIn^QM|K zrl)R|%bX)!fw0chO!NA5e1 z62tLvF}!lpyeg1P&xK(K>jTMIB)55BRYzU$4atYk6(!z0>-Mai3|YtV430~hs`Z@x;3QnRMD~L&L^Gu8=e-&sAtPNPNl31Tv|5KXHCFe;GXTsJ| z(!*z;PEUvTd@l9yP)-kh$qNPMUC9fD=9g>IL%%f_+42SM39$cyxJ{%?7#@MjA47S8 zx+b41@xScaoa&&tiDyQL&1~%muSwgy9P9CANbSkAKu)qD6GKI}w)wz#%&&-{*Uh=d zi^#U1FRbjNFlse^RCc*PNSmjQlll-xK1ffzF>}4!{69MPd-$If?j?rmM0GGo45{-H zn|Dom;vM|PXV@q7PW-)@Z!7+nieb}-LF7iT7-G+1W@p_SXp)P4sbZhjp;xW{nf<+s z{@$9=UuH4-!Fn8e$t+2pFEHJ5%~@m0FQ<%}mw3ei@>Bc_SRX@5@+z4#ze8i;O1|Yz zep+k>;8Dm#NHj#Jg#vc4S{$#ZZ^NFfBO(4h5bCo1BwVUrt{OQG z8O;4&G9&)3<+XLxB@X1)Yo^p5BG!8H)5}dyO*;8$S7M$>6@p#)M;MO`aM^f}d3`D; zOQBf~SrVnxSu$Nga=;%+zfA2&pP7FIea%a-RFNp6U;)+ZQ<+_^pdp(A3^CQWyH$Pj~JRVSCV%lt&;KNI+|ni zmm1`*5Ym4SXY#)^Mu$Er`jv<{K9JTi6$%L zYi`2Z26LIaGURJ_S2p?j-Ie=&gP?R*KJFWl&+q#V%IA~5QTcqzmzK|GePej$7UQMp zSs*oa@xbvWhWGj=i3pizIjWC`eB~Z|<9T&8;Sj+qhC{w;daJM-?m0S+D(QUe{C()9 zz}m3&aVw%+i}kX5FQHDATfb6~t;uRfVwmtWMUI4#oDR24H&q@BCo@n?!ZR^X=0&J2 zI3^-LL#`@P-=KU~5)>erKnB0Vn|jb?Jy4N&O{7}Utnm19R~Pk}tVdGBu0-akNEoeZ zOx@)(YH2><@un!ppoyg@!M4roR<$e4)oAuh?S)l~mV)Y~6=MmBx~GX1k`0;akr5k1J@>o znBlyT;Wd-0-j>IX|I)XXf|f+E`-dPG^*poJ6w=1w z)0R9dB?^=#zeE=(oGSR6q32ZmA5&W`wM_I1LZnLy0)aO5>IK`R-&chRiYNPz+f_ zF@ypbGMJmBuB2&G2Xdb$d)asd@c{8P@{&mH9eV->2lB*=2)*diUXS+tgTKwMocLYG z{K$r|Tx_9f&k~f0(ICkt>-4x`*BSq5_B)FeHICB`$eteTX}mdO%FTxy&*l$kJg^^W z&th0^oxHh*nm@Y8z89nIAGpN+!y>}Zz+R+?N6(OmTVdkWkdkug;Z{3Sho73HJzXny zhpup{*muld0(G}|rk0=cn+rv1`Q(%zhY%%U1U-5Ba2eF%m3uMGpK&rJ)i9$P(OvUT z%6{PmYDgq(ZZPX1>utDQxb!#0u*j`PrvyY}pMTg}Q|tyw0_iEclZ!UR*@~Pza(1M1xRykL z+Eb0^hMqUukk*RS{gX1ao#WoSA8R1_>AXZYtAKfw7kI9LtLHh7#x7Qk-F$&5L9?702FOvj=IMi%#o9UjjEQQg^{9*B}@pN~G3I%44ug zFcvxeH{{MQY`M!xZucnbSYccDyy|spZ$Y%reT&=A@QaTXWrqmWMyG z?J6?WDvqb&u%=t&`3nrEauT}_O5L#CDBA8>1s682E4e#ln1Pz-G0uqipB9`G=`?i_e4<~B4b{$t0TD| zhTLm}^`Th2647w2&%>vDZ(2RR^6Ws|5VOLLq_$pCEf@zTr>@Zz|20mDXdF2L11`;r zBLgWv=3o^BtE~seYO%PbHjMnB!hNVE9C&oCPe2_5g!r4R;DGghV6e$|E$0_F_Vfn^ zJAK!FfM76ClRou;v>wfV;7{by9qj0TtfCWw3z(T|LF0Q-xI-u9vBi6G7{dBRll7L| zjoarKLuu;>S$;jv6x$~QgOB)13Sb4vqt(_)b}TTe`f@ujQu$CgWztzJOmrPwMhO-Y z20!J;c`aNSoF-i5vvL6(Qd#B1le)b%c#;F>R+w|;Izs;LhoQeHXY(v=>2kq%kc`@W zsG&qZUubQSr(5JPl3!qB*H^y%YHJFXFzu5kTs2d2tTkz6PxcXRHh+*~VUmfryGD-H zuctlQNfn=Kz{}PSY6?*E6Z;%5%Xi|RI1jD&h@$#(aX3>l@n7}v)q4P6KaJhn#5cP} z26wJ2bnpEZMnYM^;kQc$cdkcD|E~wJpEPlNpTL0mREgbFO?q%=>l|dNr~H`g)DZ0f ztnbj@Q#S$NaixYnmN@-Abwv($AF5w}YF_R;HAH8r)_3UdsSm!uUNk4!x5<-i)EVF08P>fgtjMU{gQqzh{!K8*GU=aXg@iANAlcUb5-)( zR}=oB*LU3pZ(LG$WcSkHmD3cEl813mL$?es%9StoS*e;-7&6{04~iSl;p_$x7y`q# z?dQ!PuEcVF)^FW$YkRNY+lHLo|=*S{myy?Kl2tq4|nYwGHj-gt9$&DV&esxP*A ziMP2mc;j8&eO@1N2qerceX;m5?_E{ia5R>Pcl2~`i$}KXSmJG}@`@^NXVkl*dvhY% z9gBAME%C0e@&=W%J&t8 z%Dlunc2vyi+0Ua|a#Sf`?9gP^#z;W~&=qiME1qT~D_$CdUC9KYq=OZN|HE-V@nr z50p0J-JbVGGJznQfKh>F`u=nCujl7YHv;#Tk;L}?o zCngM;yr^5tG%ZA^X!>j#!88L*6VYg@3;i}xL#fpH<4m)JXi#WfjWV{E0LQx0^&8LX zy0MgWDsMaSTu<$w`1TT7d@J#{p8qyw?Pp;z5g7*ABNaLSj44?NyNxmBL#VEqu@E)P z&D|z@U@J>kTO^h3uf`agF+YVX<@}HyCb^!@ zybY`;_AjulN8nP9fbN*o1NpwI=Ma%${0aS0^Vn7934y{3=r*qZVYa@pY_g#6AM90X z&sRIsj1mp>{#aos=Lf%;our1+waO*h<2}Ib)Y>8)Jjs~SH(_bUt|$H|WFxOI)=$7} zYoe*Fx-eW;QLmXd`KG?cdHltArVqzse?=#N8ph2d4oF9^&Ki*qkTzVKgj)lLhW-lKu!N1z1k5E{*dhDNv3^} zX%TNR4}sDRayD9}?r2TC!gMruRA_t|#!>`e9qua>lvgyDdAHbuLtt$zU6*|)KivdU z?m)NvwtuAQ#IrXCSr=Itq5xrlkH^%!3Zm;@N z)#_V4yHP>ys}%u1$GAN|vbCyT^^BoLy=RH=a>m(^E1k68;`R3_o-n_`sXIq9GLplYxD<5_@}bbyDT^hwo47kNRuQBhXw z_P6?5WUzBn06&XVP`d~x3z}JK{pC?cv1NAP307R#HX2Yc`gL(W5!1qSNlDXN_w^5SMprK_&C!m{0hcB zZ0d@Sm+@-G$&XOE5%_HSyq)R&4nC_GZ)aSd4}s6!dH8H$`VppAawZs0JNWNqe4KHz z4=R6=hyOvQZ{{WZs7-GCLmv7cJ;evdNlW&9SV zf0gle#?`#M3w$>HoMrkn(|0kS0<5>$=u3dpJXUj@mwP9)xhfC+jZELq^gm?&w<|vE zqE$S(GY_9OrXOc|wch&}H#iU}{SPtjW&C>XcR%CJjQ2DCSHNc*??30kpJhI2=Hq2P z&oe&G_(}V%={(Se&gIy+;==2+i$`{<>sEz;4`V{GetFlzQ058Btu zRbQ)F`gNnKDR^_O(Ua&{-PYUP)3@pVXvA!z?@(K=z5J9c@D^;_)DeqyM`Mz#EwUvV z*=lzq$zmPbV~O7W7!H3TX0(%7wGB|u@~y+{@96E0$aj{*#y7>KiOHiGFZZjYlo z9_dQ-Moe71OCH_v-o&;|(HMQKYcuf`aq(i$8IKH zp;Wtzj##(3#jeP{u5Qb|w&CQgzau8aTi1r$__)T2KFuv1wron80V#pm*WGJIH%DXY zGtnFG-rO7QRNtHW`g)?-rad{~Xvw$XYOIvSrJAG#>a|4idS^UAST+M3P zkB&${qmbW`NKaopVb8z{>L{oIl0sJ{jiiVENyZE{5UMEx+S`m}WgCQ4CPqs#t|P_b zAhyT0P3K2fceKY=CFTN^)I>Iy)>mx839!8gAUZ0g=z=)2I%whGE4%7vNEo!e zOjma={vFFh_L`)&Go{8bBBpKgkV1REjw*SH8*@r$-g zI{hw=Z-iq@WgNth%09*ky8=J_m-MpyDFG-%Pg^5(K6VB2LMnvm{FiC?^^(H=^DyJY zt^z;B|GOH!&c{HWLB+}6l?VSSon>zn(mJ2jk9u zpV4rAyjSwMf>RIb&e@4u8a-_}l>9#4_Y-}shOgG}It~A&hTp2;f5wR>jhB9^?4$`t zA^tj_KiBYj)G2x1&~TkTqv5m%RP?L3GbjJI^59o;;z;zAD=I$C8m{+yw}v-q^u4^_ zB|d93+|qDe&LZBw61|SMYWO;h&pr*;`M;v!I(<3sQ=NM7YWUq6|0>>hI^_>*xGra0 z!`n1IPv*f-Yq-wma^8mHT+!-@6zzAdGQl}oxWegb^cFjxK3Ze zj*|G$7F5~E9U9)P;ZJF}&Sxp_Yn^=lPQ&R{@&609@QAq}Tktn~9e4cGZUq2WUseHrg-o&6rlgP&!bt3eyZXOD*8tl>{^d?EgHx1#7HnxEJG`LmiIzDuM3WgdK) z=2vz44VwSlsPTDMv-7xyk8AV3Tf?v6123mOK_UyOiRwmqoE&Cx5;7BKx0=NdGCg;j z#T6ef+Ea1zsj%TJKEiye^We1(T=naB;EIoM;7Xq6Jott@czYgvOCFqj7ZvAt2W_$9fh&DJ?ZA~j(|Pa{dGN73_{lu@cpf~H2cOJ?pUZ>G z2|=B6zFY*%g46#qZ8p3-5AMx_SLDIfy);$RdQ|#X@k-&%96$UHKJAPP2R^`fvjcyW z@eL0AAmi;0e3Wszf2BeXl5>*reg|G%PE>|5;J{ss4?1u!*(vhyrG%lAtMy_X13lzl3CKjX#RPT}p0 zE4xzo2;)l}^rMU`dr3RnLgV2J})_x?(MieBCOuXWI?d;bFtT;1=}{Vo;7XMB$R zy%hItNZuU4qV-*mlw~JN8Ot*ao}E#r%JC% z{$|G4I_Ucu-|N8Bj302|r~_B`+D9F@y4ODGz}3CBI#*G0s(b1sT0Tj2>YlpOfvbD! zK?knxqn~i#>OOkRfvfvy*F352tlg^n>V-DQlIQ6*$Z|8XDVS88dsQb`r2d?ft`yIHt-+au0t9#6Y4qV-1KIOpG gJ?1M8T-{d|Yx^CNwV(HCw>fZiU)kxv)qUmv0d +#include +#include +#include +#include + + +/* This file uses only the official API of Lua. +** Any function declared here could be written as an application function. +*/ + +#define lauxlib_c +#define LUA_LIB + +#include "lua.h" + +#include "lauxlib.h" + + +/* +** {====================================================== +** Traceback +** ======================================================= +*/ + + +#define LEVELS1 12 /* size of the first part of the stack */ +#define LEVELS2 10 /* size of the second part of the stack */ + + + +/* +** search for 'objidx' in table at index -1. +** return 1 + string at top if find a good name. +*/ +static int findfield (lua_State *L, int objidx, int level) { + if (level == 0 || !lua_istable(L, -1)) + return 0; /* not found */ + lua_pushnil(L); /* start 'next' loop */ + while (lua_next(L, -2)) { /* for each pair in table */ + if (lua_type(L, -2) == LUA_TSTRING) { /* ignore non-string keys */ + if (lua_rawequal(L, objidx, -1)) { /* found object? */ + lua_pop(L, 1); /* remove value (but keep name) */ + return 1; + } + else if (findfield(L, objidx, level - 1)) { /* try recursively */ + lua_remove(L, -2); /* remove table (but keep name) */ + lua_pushliteral(L, "."); + lua_insert(L, -2); /* place '.' between the two names */ + lua_concat(L, 3); + return 1; + } + } + lua_pop(L, 1); /* remove value */ + } + return 0; /* not found */ +} + + +static int pushglobalfuncname (lua_State *L, lua_Debug *ar) { + int top = lua_gettop(L); + lua_getinfo(L, "f", ar); /* push function */ + lua_pushglobaltable(L); + if (findfield(L, top + 1, 2)) { + lua_copy(L, -1, top + 1); /* move name to proper place */ + lua_pop(L, 2); /* remove pushed values */ + return 1; + } + else { + lua_settop(L, top); /* remove function and global table */ + return 0; + } +} + + +static void pushfuncname (lua_State *L, lua_Debug *ar) { + if (*ar->namewhat != '\0') /* is there a name? */ + lua_pushfstring(L, "function " LUA_QS, ar->name); + else if (*ar->what == 'm') /* main? */ + lua_pushliteral(L, "main chunk"); + else if (*ar->what == 'C') { + if (pushglobalfuncname(L, ar)) { + lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1)); + lua_remove(L, -2); /* remove name */ + } + else + lua_pushliteral(L, "?"); + } + else + lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined); +} + + +static int countlevels (lua_State *L) { + lua_Debug ar; + int li = 1, le = 1; + /* find an upper bound */ + while (lua_getstack(L, le, &ar)) { li = le; le *= 2; } + /* do a binary search */ + while (li < le) { + int m = (li + le)/2; + if (lua_getstack(L, m, &ar)) li = m + 1; + else le = m; + } + return le - 1; +} + + +LUALIB_API void luaL_traceback (lua_State *L, lua_State *L1, + const char *msg, int level) { + lua_Debug ar; + int top = lua_gettop(L); + int numlevels = countlevels(L1); + int mark = (numlevels > LEVELS1 + LEVELS2) ? LEVELS1 : 0; + if (msg) lua_pushfstring(L, "%s\n", msg); + lua_pushliteral(L, "stack traceback:"); + while (lua_getstack(L1, level++, &ar)) { + if (level == mark) { /* too many levels? */ + lua_pushliteral(L, "\n\t..."); /* add a '...' */ + level = numlevels - LEVELS2; /* and skip to last ones */ + } + else { + lua_getinfo(L1, "Slnt", &ar); + lua_pushfstring(L, "\n\t%s:", ar.short_src); + if (ar.currentline > 0) + lua_pushfstring(L, "%d:", ar.currentline); + lua_pushliteral(L, " in "); + pushfuncname(L, &ar); + if (ar.istailcall) + lua_pushliteral(L, "\n\t(...tail calls...)"); + lua_concat(L, lua_gettop(L) - top); + } + } + lua_concat(L, lua_gettop(L) - top); +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Error-report functions +** ======================================================= +*/ + +LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) { + lua_Debug ar; + if (!lua_getstack(L, 0, &ar)) /* no stack frame? */ + return luaL_error(L, "bad argument #%d (%s)", narg, extramsg); + lua_getinfo(L, "n", &ar); + if (strcmp(ar.namewhat, "method") == 0) { + narg--; /* do not count `self' */ + if (narg == 0) /* error is in the self argument itself? */ + return luaL_error(L, "calling " LUA_QS " on bad self (%s)", + ar.name, extramsg); + } + if (ar.name == NULL) + ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?"; + return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)", + narg, ar.name, extramsg); +} + + +static int typeerror (lua_State *L, int narg, const char *tname) { + const char *msg = lua_pushfstring(L, "%s expected, got %s", + tname, luaL_typename(L, narg)); + return luaL_argerror(L, narg, msg); +} + + +static void tag_error (lua_State *L, int narg, int tag) { + typeerror(L, narg, lua_typename(L, tag)); +} + + +LUALIB_API void luaL_where (lua_State *L, int level) { + lua_Debug ar; + if (lua_getstack(L, level, &ar)) { /* check function at level */ + lua_getinfo(L, "Sl", &ar); /* get info about it */ + if (ar.currentline > 0) { /* is there info? */ + lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline); + return; + } + } + lua_pushliteral(L, ""); /* else, no information available... */ +} + + +LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) { + va_list argp; + va_start(argp, fmt); + luaL_where(L, 1); + lua_pushvfstring(L, fmt, argp); + va_end(argp); + lua_concat(L, 2); + return lua_error(L); +} + + +LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) { + int en = errno; /* calls to Lua API may change this value */ + if (stat) { + lua_pushboolean(L, 1); + return 1; + } + else { + lua_pushnil(L); + if (fname) + lua_pushfstring(L, "%s: %s", fname, strerror(en)); + else + lua_pushstring(L, strerror(en)); + lua_pushinteger(L, en); + return 3; + } +} + + +#if !defined(inspectstat) /* { */ + +#if defined(LUA_USE_POSIX) + +#include + +/* +** use appropriate macros to interpret 'pclose' return status +*/ +#define inspectstat(stat,what) \ + if (WIFEXITED(stat)) { stat = WEXITSTATUS(stat); } \ + else if (WIFSIGNALED(stat)) { stat = WTERMSIG(stat); what = "signal"; } + +#else + +#define inspectstat(stat,what) /* no op */ + +#endif + +#endif /* } */ + + +LUALIB_API int luaL_execresult (lua_State *L, int stat) { + const char *what = "exit"; /* type of termination */ + if (stat == -1) /* error? */ + return luaL_fileresult(L, 0, NULL); + else { + inspectstat(stat, what); /* interpret result */ + if (*what == 'e' && stat == 0) /* successful termination? */ + lua_pushboolean(L, 1); + else + lua_pushnil(L); + lua_pushstring(L, what); + lua_pushinteger(L, stat); + return 3; /* return true/nil,what,code */ + } +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Userdata's metatable manipulation +** ======================================================= +*/ + +LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) { + luaL_getmetatable(L, tname); /* try to get metatable */ + if (!lua_isnil(L, -1)) /* name already in use? */ + return 0; /* leave previous value on top, but return 0 */ + lua_pop(L, 1); + lua_newtable(L); /* create metatable */ + lua_pushvalue(L, -1); + lua_setfield(L, LUA_REGISTRYINDEX, tname); /* registry.name = metatable */ + return 1; +} + + +LUALIB_API void luaL_setmetatable (lua_State *L, const char *tname) { + luaL_getmetatable(L, tname); + lua_setmetatable(L, -2); +} + + +LUALIB_API void *luaL_testudata (lua_State *L, int ud, const char *tname) { + void *p = lua_touserdata(L, ud); + if (p != NULL) { /* value is a userdata? */ + if (lua_getmetatable(L, ud)) { /* does it have a metatable? */ + luaL_getmetatable(L, tname); /* get correct metatable */ + if (!lua_rawequal(L, -1, -2)) /* not the same? */ + p = NULL; /* value is a userdata with wrong metatable */ + lua_pop(L, 2); /* remove both metatables */ + return p; + } + } + return NULL; /* value is not a userdata with a metatable */ +} + + +LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) { + void *p = luaL_testudata(L, ud, tname); + if (p == NULL) typeerror(L, ud, tname); + return p; +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Argument check functions +** ======================================================= +*/ + +LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def, + const char *const lst[]) { + const char *name = (def) ? luaL_optstring(L, narg, def) : + luaL_checkstring(L, narg); + int i; + for (i=0; lst[i]; i++) + if (strcmp(lst[i], name) == 0) + return i; + return luaL_argerror(L, narg, + lua_pushfstring(L, "invalid option " LUA_QS, name)); +} + + +LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) { + /* keep some extra space to run error routines, if needed */ + const int extra = LUA_MINSTACK; + if (!lua_checkstack(L, space + extra)) { + if (msg) + luaL_error(L, "stack overflow (%s)", msg); + else + luaL_error(L, "stack overflow"); + } +} + + +LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) { + if (lua_type(L, narg) != t) + tag_error(L, narg, t); +} + + +LUALIB_API void luaL_checkany (lua_State *L, int narg) { + if (lua_type(L, narg) == LUA_TNONE) + luaL_argerror(L, narg, "value expected"); +} + + +LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) { + const char *s = lua_tolstring(L, narg, len); + if (!s) tag_error(L, narg, LUA_TSTRING); + return s; +} + + +LUALIB_API const char *luaL_optlstring (lua_State *L, int narg, + const char *def, size_t *len) { + if (lua_isnoneornil(L, narg)) { + if (len) + *len = (def ? strlen(def) : 0); + return def; + } + else return luaL_checklstring(L, narg, len); +} + + +LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) { + int isnum; + lua_Number d = lua_tonumberx(L, narg, &isnum); + if (!isnum) + tag_error(L, narg, LUA_TNUMBER); + return d; +} + + +LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) { + return luaL_opt(L, luaL_checknumber, narg, def); +} + + +LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) { + int isnum; + lua_Integer d = lua_tointegerx(L, narg, &isnum); + if (!isnum) + tag_error(L, narg, LUA_TNUMBER); + return d; +} + + +LUALIB_API lua_Unsigned luaL_checkunsigned (lua_State *L, int narg) { + int isnum; + lua_Unsigned d = lua_tounsignedx(L, narg, &isnum); + if (!isnum) + tag_error(L, narg, LUA_TNUMBER); + return d; +} + + +LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg, + lua_Integer def) { + return luaL_opt(L, luaL_checkinteger, narg, def); +} + + +LUALIB_API lua_Unsigned luaL_optunsigned (lua_State *L, int narg, + lua_Unsigned def) { + return luaL_opt(L, luaL_checkunsigned, narg, def); +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Generic Buffer manipulation +** ======================================================= +*/ + +/* +** check whether buffer is using a userdata on the stack as a temporary +** buffer +*/ +#define buffonstack(B) ((B)->b != (B)->initb) + + +/* +** returns a pointer to a free area with at least 'sz' bytes +*/ +LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) { + lua_State *L = B->L; + if (B->size - B->n < sz) { /* not enough space? */ + char *newbuff; + size_t newsize = B->size * 2; /* double buffer size */ + if (newsize - B->n < sz) /* not big enough? */ + newsize = B->n + sz; + if (newsize < B->n || newsize - B->n < sz) + luaL_error(L, "buffer too large"); + /* create larger buffer */ + newbuff = (char *)lua_newuserdata(L, newsize * sizeof(char)); + /* move content to new buffer */ + memcpy(newbuff, B->b, B->n * sizeof(char)); + if (buffonstack(B)) + lua_remove(L, -2); /* remove old buffer */ + B->b = newbuff; + B->size = newsize; + } + return &B->b[B->n]; +} + + +LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { + char *b = luaL_prepbuffsize(B, l); + memcpy(b, s, l * sizeof(char)); + luaL_addsize(B, l); +} + + +LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) { + luaL_addlstring(B, s, strlen(s)); +} + + +LUALIB_API void luaL_pushresult (luaL_Buffer *B) { + lua_State *L = B->L; + lua_pushlstring(L, B->b, B->n); + if (buffonstack(B)) + lua_remove(L, -2); /* remove old buffer */ +} + + +LUALIB_API void luaL_pushresultsize (luaL_Buffer *B, size_t sz) { + luaL_addsize(B, sz); + luaL_pushresult(B); +} + + +LUALIB_API void luaL_addvalue (luaL_Buffer *B) { + lua_State *L = B->L; + size_t l; + const char *s = lua_tolstring(L, -1, &l); + if (buffonstack(B)) + lua_insert(L, -2); /* put value below buffer */ + luaL_addlstring(B, s, l); + lua_remove(L, (buffonstack(B)) ? -2 : -1); /* remove value */ +} + + +LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) { + B->L = L; + B->b = B->initb; + B->n = 0; + B->size = LUAL_BUFFERSIZE; +} + + +LUALIB_API char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz) { + luaL_buffinit(L, B); + return luaL_prepbuffsize(B, sz); +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Reference system +** ======================================================= +*/ + +/* index of free-list header */ +#define freelist 0 + + +LUALIB_API int luaL_ref (lua_State *L, int t) { + int ref; + if (lua_isnil(L, -1)) { + lua_pop(L, 1); /* remove from stack */ + return LUA_REFNIL; /* `nil' has a unique fixed reference */ + } + t = lua_absindex(L, t); + lua_rawgeti(L, t, freelist); /* get first free element */ + ref = (int)lua_tointeger(L, -1); /* ref = t[freelist] */ + lua_pop(L, 1); /* remove it from stack */ + if (ref != 0) { /* any free element? */ + lua_rawgeti(L, t, ref); /* remove it from list */ + lua_rawseti(L, t, freelist); /* (t[freelist] = t[ref]) */ + } + else /* no free elements */ + ref = (int)lua_rawlen(L, t) + 1; /* get a new reference */ + lua_rawseti(L, t, ref); + return ref; +} + + +LUALIB_API void luaL_unref (lua_State *L, int t, int ref) { + if (ref >= 0) { + t = lua_absindex(L, t); + lua_rawgeti(L, t, freelist); + lua_rawseti(L, t, ref); /* t[ref] = t[freelist] */ + lua_pushinteger(L, ref); + lua_rawseti(L, t, freelist); /* t[freelist] = ref */ + } +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Load functions +** ======================================================= +*/ + +typedef struct LoadF { + int n; /* number of pre-read characters */ + FILE *f; /* file being read */ + char buff[LUAL_BUFFERSIZE]; /* area for reading file */ +} LoadF; + + +static const char *getF (lua_State *L, void *ud, size_t *size) { + LoadF *lf = (LoadF *)ud; + (void)L; /* not used */ + if (lf->n > 0) { /* are there pre-read characters to be read? */ + *size = lf->n; /* return them (chars already in buffer) */ + lf->n = 0; /* no more pre-read characters */ + } + else { /* read a block from file */ + /* 'fread' can return > 0 *and* set the EOF flag. If next call to + 'getF' called 'fread', it might still wait for user input. + The next check avoids this problem. */ + if (feof(lf->f)) return NULL; + *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f); /* read block */ + } + return lf->buff; +} + + +static int errfile (lua_State *L, const char *what, int fnameindex) { + const char *serr = strerror(errno); + const char *filename = lua_tostring(L, fnameindex) + 1; + lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr); + lua_remove(L, fnameindex); + return LUA_ERRFILE; +} + + +static int skipBOM (LoadF *lf) { + const char *p = "\xEF\xBB\xBF"; /* Utf8 BOM mark */ + int c; + lf->n = 0; + do { + c = getc(lf->f); + if (c == EOF || c != *(const unsigned char *)p++) return c; + lf->buff[lf->n++] = c; /* to be read by the parser */ + } while (*p != '\0'); + lf->n = 0; /* prefix matched; discard it */ + return getc(lf->f); /* return next character */ +} + + +/* +** reads the first character of file 'f' and skips an optional BOM mark +** in its beginning plus its first line if it starts with '#'. Returns +** true if it skipped the first line. In any case, '*cp' has the +** first "valid" character of the file (after the optional BOM and +** a first-line comment). +*/ +static int skipcomment (LoadF *lf, int *cp) { + int c = *cp = skipBOM(lf); + if (c == '#') { /* first line is a comment (Unix exec. file)? */ + do { /* skip first line */ + c = getc(lf->f); + } while (c != EOF && c != '\n') ; + *cp = getc(lf->f); /* skip end-of-line, if present */ + return 1; /* there was a comment */ + } + else return 0; /* no comment */ +} + + +LUALIB_API int luaL_loadfilex (lua_State *L, const char *filename, + const char *mode) { + LoadF lf; + int status, readstatus; + int c; + int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */ + if (filename == NULL) { + lua_pushliteral(L, "=stdin"); + lf.f = stdin; + } + else { + lua_pushfstring(L, "@%s", filename); + lf.f = fopen(filename, "r"); + if (lf.f == NULL) return errfile(L, "open", fnameindex); + } + if (skipcomment(&lf, &c)) /* read initial portion */ + lf.buff[lf.n++] = '\n'; /* add line to correct line numbers */ + if (c == LUA_SIGNATURE[0] && filename) { /* binary file? */ + lf.f = freopen(filename, "rb", lf.f); /* reopen in binary mode */ + if (lf.f == NULL) return errfile(L, "reopen", fnameindex); + skipcomment(&lf, &c); /* re-read initial portion */ + } + if (c != EOF) + lf.buff[lf.n++] = c; /* 'c' is the first character of the stream */ + status = lua_load(L, getF, &lf, lua_tostring(L, -1), mode); + readstatus = ferror(lf.f); + if (filename) fclose(lf.f); /* close file (even in case of errors) */ + if (readstatus) { + lua_settop(L, fnameindex); /* ignore results from `lua_load' */ + return errfile(L, "read", fnameindex); + } + lua_remove(L, fnameindex); + return status; +} + + +typedef struct LoadS { + const char *s; + size_t size; +} LoadS; + + +static const char *getS (lua_State *L, void *ud, size_t *size) { + LoadS *ls = (LoadS *)ud; + (void)L; /* not used */ + if (ls->size == 0) return NULL; + *size = ls->size; + ls->size = 0; + return ls->s; +} + + +LUALIB_API int luaL_loadbufferx (lua_State *L, const char *buff, size_t size, + const char *name, const char *mode) { + LoadS ls; + ls.s = buff; + ls.size = size; + return lua_load(L, getS, &ls, name, mode); +} + + +LUALIB_API int luaL_loadstring (lua_State *L, const char *s) { + return luaL_loadbuffer(L, s, strlen(s), s); +} + +/* }====================================================== */ + + + +LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) { + if (!lua_getmetatable(L, obj)) /* no metatable? */ + return 0; + lua_pushstring(L, event); + lua_rawget(L, -2); + if (lua_isnil(L, -1)) { + lua_pop(L, 2); /* remove metatable and metafield */ + return 0; + } + else { + lua_remove(L, -2); /* remove only metatable */ + return 1; + } +} + + +LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) { + obj = lua_absindex(L, obj); + if (!luaL_getmetafield(L, obj, event)) /* no metafield? */ + return 0; + lua_pushvalue(L, obj); + lua_call(L, 1, 1); + return 1; +} + + +LUALIB_API int luaL_len (lua_State *L, int idx) { + int l; + int isnum; + lua_len(L, idx); + l = (int)lua_tointegerx(L, -1, &isnum); + if (!isnum) + luaL_error(L, "object length is not a number"); + lua_pop(L, 1); /* remove object */ + return l; +} + + +LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) { + if (!luaL_callmeta(L, idx, "__tostring")) { /* no metafield? */ + switch (lua_type(L, idx)) { + case LUA_TNUMBER: + case LUA_TSTRING: + lua_pushvalue(L, idx); + break; + case LUA_TBOOLEAN: + lua_pushstring(L, (lua_toboolean(L, idx) ? "true" : "false")); + break; + case LUA_TNIL: + lua_pushliteral(L, "nil"); + break; + default: + lua_pushfstring(L, "%s: %p", luaL_typename(L, idx), + lua_topointer(L, idx)); + break; + } + } + return lua_tolstring(L, -1, len); +} + + +/* +** {====================================================== +** Compatibility with 5.1 module functions +** ======================================================= +*/ +#if defined(LUA_COMPAT_MODULE) + +static const char *luaL_findtable (lua_State *L, int idx, + const char *fname, int szhint) { + const char *e; + if (idx) lua_pushvalue(L, idx); + do { + e = strchr(fname, '.'); + if (e == NULL) e = fname + strlen(fname); + lua_pushlstring(L, fname, e - fname); + lua_rawget(L, -2); + if (lua_isnil(L, -1)) { /* no such field? */ + lua_pop(L, 1); /* remove this nil */ + lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */ + lua_pushlstring(L, fname, e - fname); + lua_pushvalue(L, -2); + lua_settable(L, -4); /* set new table into field */ + } + else if (!lua_istable(L, -1)) { /* field has a non-table value? */ + lua_pop(L, 2); /* remove table and value */ + return fname; /* return problematic part of the name */ + } + lua_remove(L, -2); /* remove previous table */ + fname = e + 1; + } while (*e == '.'); + return NULL; +} + + +/* +** Count number of elements in a luaL_Reg list. +*/ +static int libsize (const luaL_Reg *l) { + int size = 0; + for (; l && l->name; l++) size++; + return size; +} + + +/* +** Find or create a module table with a given name. The function +** first looks at the _LOADED table and, if that fails, try a +** global variable with that name. In any case, leaves on the stack +** the module table. +*/ +LUALIB_API void luaL_pushmodule (lua_State *L, const char *modname, + int sizehint) { + luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1); /* get _LOADED table */ + lua_getfield(L, -1, modname); /* get _LOADED[modname] */ + if (!lua_istable(L, -1)) { /* not found? */ + lua_pop(L, 1); /* remove previous result */ + /* try global variable (and create one if it does not exist) */ + lua_pushglobaltable(L); + if (luaL_findtable(L, 0, modname, sizehint) != NULL) + luaL_error(L, "name conflict for module " LUA_QS, modname); + lua_pushvalue(L, -1); + lua_setfield(L, -3, modname); /* _LOADED[modname] = new table */ + } + lua_remove(L, -2); /* remove _LOADED table */ +} + + +LUALIB_API void luaL_openlib (lua_State *L, const char *libname, + const luaL_Reg *l, int nup) { + luaL_checkversion(L); + if (libname) { + luaL_pushmodule(L, libname, libsize(l)); /* get/create library table */ + lua_insert(L, -(nup + 1)); /* move library table to below upvalues */ + } + if (l) + luaL_setfuncs(L, l, nup); + else + lua_pop(L, nup); /* remove upvalues */ +} + +#endif +/* }====================================================== */ + +/* +** set functions from list 'l' into table at top - 'nup'; each +** function gets the 'nup' elements at the top as upvalues. +** Returns with only the table at the stack. +*/ +LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) { + luaL_checkversion(L); + luaL_checkstack(L, nup, "too many upvalues"); + for (; l->name != NULL; l++) { /* fill the table with given functions */ + int i; + for (i = 0; i < nup; i++) /* copy upvalues to the top */ + lua_pushvalue(L, -nup); + lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */ + lua_setfield(L, -(nup + 2), l->name); + } + lua_pop(L, nup); /* remove upvalues */ +} + + +/* +** ensure that stack[idx][fname] has a table and push that table +** into the stack +*/ +LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) { + lua_getfield(L, idx, fname); + if (lua_istable(L, -1)) return 1; /* table already there */ + else { + lua_pop(L, 1); /* remove previous result */ + idx = lua_absindex(L, idx); + lua_newtable(L); + lua_pushvalue(L, -1); /* copy to be left at top */ + lua_setfield(L, idx, fname); /* assign new table to field */ + return 0; /* false, because did not find table there */ + } +} + + +/* +** stripped-down 'require'. Calls 'openf' to open a module, +** registers the result in 'package.loaded' table and, if 'glb' +** is true, also registers the result in the global table. +** Leaves resulting module on the top. +*/ +LUALIB_API void luaL_requiref (lua_State *L, const char *modname, + lua_CFunction openf, int glb) { + lua_pushcfunction(L, openf); + lua_pushstring(L, modname); /* argument to open function */ + lua_call(L, 1, 1); /* open module */ + luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED"); + lua_pushvalue(L, -2); /* make copy of module (call result) */ + lua_setfield(L, -2, modname); /* _LOADED[modname] = module */ + lua_pop(L, 1); /* remove _LOADED table */ + if (glb) { + lua_pushvalue(L, -1); /* copy of 'mod' */ + lua_setglobal(L, modname); /* _G[modname] = module */ + } +} + + +LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p, + const char *r) { + const char *wild; + size_t l = strlen(p); + luaL_Buffer b; + luaL_buffinit(L, &b); + while ((wild = strstr(s, p)) != NULL) { + luaL_addlstring(&b, s, wild - s); /* push prefix */ + luaL_addstring(&b, r); /* push replacement in place of pattern */ + s = wild + l; /* continue after `p' */ + } + luaL_addstring(&b, s); /* push last suffix */ + luaL_pushresult(&b); + return lua_tostring(L, -1); +} + + +static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { + (void)ud; (void)osize; /* not used */ + if (nsize == 0) { + free(ptr); + return NULL; + } + else + return realloc(ptr, nsize); +} + + +static int panic (lua_State *L) { + luai_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n", + lua_tostring(L, -1)); + return 0; /* return to Lua to abort */ +} + + +LUALIB_API lua_State *luaL_newstate (void) { + lua_State *L = lua_newstate(l_alloc, NULL); + if (L) lua_atpanic(L, &panic); + return L; +} + + +LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver) { + const lua_Number *v = lua_version(L); + if (v != lua_version(NULL)) + luaL_error(L, "multiple Lua VMs detected"); + else if (*v != ver) + luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f", + ver, *v); + /* check conversions number -> integer types */ + lua_pushnumber(L, -(lua_Number)0x1234); + if (lua_tointeger(L, -1) != -0x1234 || + lua_tounsigned(L, -1) != (lua_Unsigned)-0x1234) + luaL_error(L, "bad conversion number->int;" + " must recompile Lua with proper settings"); + lua_pop(L, 1); +} + diff --git a/extern/lua/src/lauxlib.h b/extern/lua/src/lauxlib.h new file mode 100644 index 0000000..0fb023b --- /dev/null +++ b/extern/lua/src/lauxlib.h @@ -0,0 +1,212 @@ +/* +** $Id: lauxlib.h,v 1.120.1.1 2013/04/12 18:48:47 roberto Exp $ +** Auxiliary functions for building Lua libraries +** See Copyright Notice in lua.h +*/ + + +#ifndef lauxlib_h +#define lauxlib_h + + +#include +#include + +#include "lua.h" + + + +/* extra error code for `luaL_load' */ +#define LUA_ERRFILE (LUA_ERRERR+1) + + +typedef struct luaL_Reg { + const char *name; + lua_CFunction func; +} luaL_Reg; + + +LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver); +#define luaL_checkversion(L) luaL_checkversion_(L, LUA_VERSION_NUM) + +LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e); +LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e); +LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len); +LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg); +LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg, + size_t *l); +LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg, + const char *def, size_t *l); +LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg); +LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def); + +LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg); +LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg, + lua_Integer def); +LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int numArg); +LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int numArg, + lua_Unsigned def); + +LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg); +LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t); +LUALIB_API void (luaL_checkany) (lua_State *L, int narg); + +LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname); +LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname); +LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname); +LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname); + +LUALIB_API void (luaL_where) (lua_State *L, int lvl); +LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...); + +LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def, + const char *const lst[]); + +LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname); +LUALIB_API int (luaL_execresult) (lua_State *L, int stat); + +/* pre-defined references */ +#define LUA_NOREF (-2) +#define LUA_REFNIL (-1) + +LUALIB_API int (luaL_ref) (lua_State *L, int t); +LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref); + +LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename, + const char *mode); + +#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) + +LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz, + const char *name, const char *mode); +LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s); + +LUALIB_API lua_State *(luaL_newstate) (void); + +LUALIB_API int (luaL_len) (lua_State *L, int idx); + +LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p, + const char *r); + +LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup); + +LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname); + +LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1, + const char *msg, int level); + +LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname, + lua_CFunction openf, int glb); + +/* +** =============================================================== +** some useful macros +** =============================================================== +*/ + + +#define luaL_newlibtable(L,l) \ + lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1) + +#define luaL_newlib(L,l) (luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) + +#define luaL_argcheck(L, cond,numarg,extramsg) \ + ((void)((cond) || luaL_argerror(L, (numarg), (extramsg)))) +#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) +#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) +#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) +#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) +#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) +#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) + +#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) + +#define luaL_dofile(L, fn) \ + (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0)) + +#define luaL_dostring(L, s) \ + (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0)) + +#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) + +#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) + +#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL) + + +/* +** {====================================================== +** Generic Buffer manipulation +** ======================================================= +*/ + +typedef struct luaL_Buffer { + char *b; /* buffer address */ + size_t size; /* buffer size */ + size_t n; /* number of characters in buffer */ + lua_State *L; + char initb[LUAL_BUFFERSIZE]; /* initial buffer */ +} luaL_Buffer; + + +#define luaL_addchar(B,c) \ + ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ + ((B)->b[(B)->n++] = (c))) + +#define luaL_addsize(B,s) ((B)->n += (s)) + +LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B); +LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz); +LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l); +LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s); +LUALIB_API void (luaL_addvalue) (luaL_Buffer *B); +LUALIB_API void (luaL_pushresult) (luaL_Buffer *B); +LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz); +LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz); + +#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) + +/* }====================================================== */ + + + +/* +** {====================================================== +** File handles for IO library +** ======================================================= +*/ + +/* +** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and +** initial structure 'luaL_Stream' (it may contain other fields +** after that initial structure). +*/ + +#define LUA_FILEHANDLE "FILE*" + + +typedef struct luaL_Stream { + FILE *f; /* stream (NULL for incompletely created streams) */ + lua_CFunction closef; /* to close stream (NULL for closed streams) */ +} luaL_Stream; + +/* }====================================================== */ + + + +/* compatibility with old module system */ +#if defined(LUA_COMPAT_MODULE) + +LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname, + int sizehint); +LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname, + const luaL_Reg *l, int nup); + +#define luaL_register(L,n,l) (luaL_openlib(L,(n),(l),0)) + +#endif + + +#endif + + diff --git a/extern/lua/src/lauxlib.o b/extern/lua/src/lauxlib.o new file mode 100644 index 0000000000000000000000000000000000000000..3cbe3471b758879e9f2d8a8caddbb7a71b54a8a8 GIT binary patch literal 27248 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 +#include +#include +#include + +#define lbaselib_c +#define LUA_LIB + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +static int luaB_print (lua_State *L) { + int n = lua_gettop(L); /* number of arguments */ + int i; + lua_getglobal(L, "tostring"); + for (i=1; i<=n; i++) { + const char *s; + size_t l; + lua_pushvalue(L, -1); /* function to be called */ + lua_pushvalue(L, i); /* value to print */ + lua_call(L, 1, 1); + s = lua_tolstring(L, -1, &l); /* get result */ + if (s == NULL) + return luaL_error(L, + LUA_QL("tostring") " must return a string to " LUA_QL("print")); + if (i>1) luai_writestring("\t", 1); + luai_writestring(s, l); + lua_pop(L, 1); /* pop result */ + } + luai_writeline(); + return 0; +} + + +#define SPACECHARS " \f\n\r\t\v" + +static int luaB_tonumber (lua_State *L) { + if (lua_isnoneornil(L, 2)) { /* standard conversion */ + int isnum; + lua_Number n = lua_tonumberx(L, 1, &isnum); + if (isnum) { + lua_pushnumber(L, n); + return 1; + } /* else not a number; must be something */ + luaL_checkany(L, 1); + } + else { + size_t l; + const char *s = luaL_checklstring(L, 1, &l); + const char *e = s + l; /* end point for 's' */ + int base = luaL_checkint(L, 2); + int neg = 0; + luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range"); + s += strspn(s, SPACECHARS); /* skip initial spaces */ + if (*s == '-') { s++; neg = 1; } /* handle signal */ + else if (*s == '+') s++; + if (isalnum((unsigned char)*s)) { + lua_Number n = 0; + do { + int digit = (isdigit((unsigned char)*s)) ? *s - '0' + : toupper((unsigned char)*s) - 'A' + 10; + if (digit >= base) break; /* invalid numeral; force a fail */ + n = n * (lua_Number)base + (lua_Number)digit; + s++; + } while (isalnum((unsigned char)*s)); + s += strspn(s, SPACECHARS); /* skip trailing spaces */ + if (s == e) { /* no invalid trailing characters? */ + lua_pushnumber(L, (neg) ? -n : n); + return 1; + } /* else not a number */ + } /* else not a number */ + } + lua_pushnil(L); /* not a number */ + return 1; +} + + +static int luaB_error (lua_State *L) { + int level = luaL_optint(L, 2, 1); + lua_settop(L, 1); + if (lua_isstring(L, 1) && level > 0) { /* add extra information? */ + luaL_where(L, level); + lua_pushvalue(L, 1); + lua_concat(L, 2); + } + return lua_error(L); +} + + +static int luaB_getmetatable (lua_State *L) { + luaL_checkany(L, 1); + if (!lua_getmetatable(L, 1)) { + lua_pushnil(L); + return 1; /* no metatable */ + } + luaL_getmetafield(L, 1, "__metatable"); + return 1; /* returns either __metatable field (if present) or metatable */ +} + + +static int luaB_setmetatable (lua_State *L) { + int t = lua_type(L, 2); + luaL_checktype(L, 1, LUA_TTABLE); + luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2, + "nil or table expected"); + if (luaL_getmetafield(L, 1, "__metatable")) + return luaL_error(L, "cannot change a protected metatable"); + lua_settop(L, 2); + lua_setmetatable(L, 1); + return 1; +} + + +static int luaB_rawequal (lua_State *L) { + luaL_checkany(L, 1); + luaL_checkany(L, 2); + lua_pushboolean(L, lua_rawequal(L, 1, 2)); + return 1; +} + + +static int luaB_rawlen (lua_State *L) { + int t = lua_type(L, 1); + luaL_argcheck(L, t == LUA_TTABLE || t == LUA_TSTRING, 1, + "table or string expected"); + lua_pushinteger(L, lua_rawlen(L, 1)); + return 1; +} + + +static int luaB_rawget (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + luaL_checkany(L, 2); + lua_settop(L, 2); + lua_rawget(L, 1); + return 1; +} + +static int luaB_rawset (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + luaL_checkany(L, 2); + luaL_checkany(L, 3); + lua_settop(L, 3); + lua_rawset(L, 1); + return 1; +} + + +static int luaB_collectgarbage (lua_State *L) { + static const char *const opts[] = {"stop", "restart", "collect", + "count", "step", "setpause", "setstepmul", + "setmajorinc", "isrunning", "generational", "incremental", NULL}; + static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT, + LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL, + LUA_GCSETMAJORINC, LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC}; + int o = optsnum[luaL_checkoption(L, 1, "collect", opts)]; + int ex = luaL_optint(L, 2, 0); + int res = lua_gc(L, o, ex); + switch (o) { + case LUA_GCCOUNT: { + int b = lua_gc(L, LUA_GCCOUNTB, 0); + lua_pushnumber(L, res + ((lua_Number)b/1024)); + lua_pushinteger(L, b); + return 2; + } + case LUA_GCSTEP: case LUA_GCISRUNNING: { + lua_pushboolean(L, res); + return 1; + } + default: { + lua_pushinteger(L, res); + return 1; + } + } +} + + +static int luaB_type (lua_State *L) { + luaL_checkany(L, 1); + lua_pushstring(L, luaL_typename(L, 1)); + return 1; +} + + +static int pairsmeta (lua_State *L, const char *method, int iszero, + lua_CFunction iter) { + if (!luaL_getmetafield(L, 1, method)) { /* no metamethod? */ + luaL_checktype(L, 1, LUA_TTABLE); /* argument must be a table */ + lua_pushcfunction(L, iter); /* will return generator, */ + lua_pushvalue(L, 1); /* state, */ + if (iszero) lua_pushinteger(L, 0); /* and initial value */ + else lua_pushnil(L); + } + else { + lua_pushvalue(L, 1); /* argument 'self' to metamethod */ + lua_call(L, 1, 3); /* get 3 values from metamethod */ + } + return 3; +} + + +static int luaB_next (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + lua_settop(L, 2); /* create a 2nd argument if there isn't one */ + if (lua_next(L, 1)) + return 2; + else { + lua_pushnil(L); + return 1; + } +} + + +static int luaB_pairs (lua_State *L) { + return pairsmeta(L, "__pairs", 0, luaB_next); +} + + +static int ipairsaux (lua_State *L) { + int i = luaL_checkint(L, 2); + luaL_checktype(L, 1, LUA_TTABLE); + i++; /* next value */ + lua_pushinteger(L, i); + lua_rawgeti(L, 1, i); + return (lua_isnil(L, -1)) ? 1 : 2; +} + + +static int luaB_ipairs (lua_State *L) { + return pairsmeta(L, "__ipairs", 1, ipairsaux); +} + + +static int load_aux (lua_State *L, int status, int envidx) { + if (status == LUA_OK) { + if (envidx != 0) { /* 'env' parameter? */ + lua_pushvalue(L, envidx); /* environment for loaded function */ + if (!lua_setupvalue(L, -2, 1)) /* set it as 1st upvalue */ + lua_pop(L, 1); /* remove 'env' if not used by previous call */ + } + return 1; + } + else { /* error (message is on top of the stack) */ + lua_pushnil(L); + lua_insert(L, -2); /* put before error message */ + return 2; /* return nil plus error message */ + } +} + + +static int luaB_loadfile (lua_State *L) { + const char *fname = luaL_optstring(L, 1, NULL); + const char *mode = luaL_optstring(L, 2, NULL); + int env = (!lua_isnone(L, 3) ? 3 : 0); /* 'env' index or 0 if no 'env' */ + int status = luaL_loadfilex(L, fname, mode); + return load_aux(L, status, env); +} + + +/* +** {====================================================== +** Generic Read function +** ======================================================= +*/ + + +/* +** reserved slot, above all arguments, to hold a copy of the returned +** string to avoid it being collected while parsed. 'load' has four +** optional arguments (chunk, source name, mode, and environment). +*/ +#define RESERVEDSLOT 5 + + +/* +** Reader for generic `load' function: `lua_load' uses the +** stack for internal stuff, so the reader cannot change the +** stack top. Instead, it keeps its resulting string in a +** reserved slot inside the stack. +*/ +static const char *generic_reader (lua_State *L, void *ud, size_t *size) { + (void)(ud); /* not used */ + luaL_checkstack(L, 2, "too many nested functions"); + lua_pushvalue(L, 1); /* get function */ + lua_call(L, 0, 1); /* call it */ + if (lua_isnil(L, -1)) { + lua_pop(L, 1); /* pop result */ + *size = 0; + return NULL; + } + else if (!lua_isstring(L, -1)) + luaL_error(L, "reader function must return a string"); + lua_replace(L, RESERVEDSLOT); /* save string in reserved slot */ + return lua_tolstring(L, RESERVEDSLOT, size); +} + + +static int luaB_load (lua_State *L) { + int status; + size_t l; + const char *s = lua_tolstring(L, 1, &l); + const char *mode = luaL_optstring(L, 3, "bt"); + int env = (!lua_isnone(L, 4) ? 4 : 0); /* 'env' index or 0 if no 'env' */ + if (s != NULL) { /* loading a string? */ + const char *chunkname = luaL_optstring(L, 2, s); + status = luaL_loadbufferx(L, s, l, chunkname, mode); + } + else { /* loading from a reader function */ + const char *chunkname = luaL_optstring(L, 2, "=(load)"); + luaL_checktype(L, 1, LUA_TFUNCTION); + lua_settop(L, RESERVEDSLOT); /* create reserved slot */ + status = lua_load(L, generic_reader, NULL, chunkname, mode); + } + return load_aux(L, status, env); +} + +/* }====================================================== */ + + +static int dofilecont (lua_State *L) { + return lua_gettop(L) - 1; +} + + +static int luaB_dofile (lua_State *L) { + const char *fname = luaL_optstring(L, 1, NULL); + lua_settop(L, 1); + if (luaL_loadfile(L, fname) != LUA_OK) + return lua_error(L); + lua_callk(L, 0, LUA_MULTRET, 0, dofilecont); + return dofilecont(L); +} + + +static int luaB_assert (lua_State *L) { + if (!lua_toboolean(L, 1)) + return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!")); + return lua_gettop(L); +} + + +static int luaB_select (lua_State *L) { + int n = lua_gettop(L); + if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') { + lua_pushinteger(L, n-1); + return 1; + } + else { + int i = luaL_checkint(L, 1); + if (i < 0) i = n + i; + else if (i > n) i = n; + luaL_argcheck(L, 1 <= i, 1, "index out of range"); + return n - i; + } +} + + +static int finishpcall (lua_State *L, int status) { + if (!lua_checkstack(L, 1)) { /* no space for extra boolean? */ + lua_settop(L, 0); /* create space for return values */ + lua_pushboolean(L, 0); + lua_pushstring(L, "stack overflow"); + return 2; /* return false, msg */ + } + lua_pushboolean(L, status); /* first result (status) */ + lua_replace(L, 1); /* put first result in first slot */ + return lua_gettop(L); +} + + +static int pcallcont (lua_State *L) { + int status = lua_getctx(L, NULL); + return finishpcall(L, (status == LUA_YIELD)); +} + + +static int luaB_pcall (lua_State *L) { + int status; + luaL_checkany(L, 1); + lua_pushnil(L); + lua_insert(L, 1); /* create space for status result */ + status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, pcallcont); + return finishpcall(L, (status == LUA_OK)); +} + + +static int luaB_xpcall (lua_State *L) { + int status; + int n = lua_gettop(L); + luaL_argcheck(L, n >= 2, 2, "value expected"); + lua_pushvalue(L, 1); /* exchange function... */ + lua_copy(L, 2, 1); /* ...and error handler */ + lua_replace(L, 2); + status = lua_pcallk(L, n - 2, LUA_MULTRET, 1, 0, pcallcont); + return finishpcall(L, (status == LUA_OK)); +} + + +static int luaB_tostring (lua_State *L) { + luaL_checkany(L, 1); + luaL_tolstring(L, 1, NULL); + return 1; +} + + +static const luaL_Reg base_funcs[] = { + {"assert", luaB_assert}, + {"collectgarbage", luaB_collectgarbage}, + {"dofile", luaB_dofile}, + {"error", luaB_error}, + {"getmetatable", luaB_getmetatable}, + {"ipairs", luaB_ipairs}, + {"loadfile", luaB_loadfile}, + {"load", luaB_load}, +#if defined(LUA_COMPAT_LOADSTRING) + {"loadstring", luaB_load}, +#endif + {"next", luaB_next}, + {"pairs", luaB_pairs}, + {"pcall", luaB_pcall}, + {"print", luaB_print}, + {"rawequal", luaB_rawequal}, + {"rawlen", luaB_rawlen}, + {"rawget", luaB_rawget}, + {"rawset", luaB_rawset}, + {"select", luaB_select}, + {"setmetatable", luaB_setmetatable}, + {"tonumber", luaB_tonumber}, + {"tostring", luaB_tostring}, + {"type", luaB_type}, + {"xpcall", luaB_xpcall}, + {NULL, NULL} +}; + + +LUAMOD_API int luaopen_base (lua_State *L) { + /* set global _G */ + lua_pushglobaltable(L); + lua_pushglobaltable(L); + lua_setfield(L, -2, "_G"); + /* open lib into global table */ + luaL_setfuncs(L, base_funcs, 0); + lua_pushliteral(L, LUA_VERSION); + lua_setfield(L, -2, "_VERSION"); /* set global _VERSION */ + return 1; +} + diff --git a/extern/lua/src/lbaselib.o b/extern/lua/src/lbaselib.o new file mode 100644 index 0000000000000000000000000000000000000000..1ae86a9cbdace4112dec06ff99a4e8221b5e5fad GIT binary patch literal 18624 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 literal 0 HcmV?d00001 diff --git a/extern/lua/src/lbitlib.c b/extern/lua/src/lbitlib.c new file mode 100644 index 0000000..31c7b66 --- /dev/null +++ b/extern/lua/src/lbitlib.c @@ -0,0 +1,212 @@ +/* +** $Id: lbitlib.c,v 1.18.1.2 2013/07/09 18:01:41 roberto Exp $ +** Standard library for bitwise operations +** See Copyright Notice in lua.h +*/ + +#define lbitlib_c +#define LUA_LIB + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +/* number of bits to consider in a number */ +#if !defined(LUA_NBITS) +#define LUA_NBITS 32 +#endif + + +#define ALLONES (~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1)) + +/* macro to trim extra bits */ +#define trim(x) ((x) & ALLONES) + + +/* builds a number with 'n' ones (1 <= n <= LUA_NBITS) */ +#define mask(n) (~((ALLONES << 1) << ((n) - 1))) + + +typedef lua_Unsigned b_uint; + + + +static b_uint andaux (lua_State *L) { + int i, n = lua_gettop(L); + b_uint r = ~(b_uint)0; + for (i = 1; i <= n; i++) + r &= luaL_checkunsigned(L, i); + return trim(r); +} + + +static int b_and (lua_State *L) { + b_uint r = andaux(L); + lua_pushunsigned(L, r); + return 1; +} + + +static int b_test (lua_State *L) { + b_uint r = andaux(L); + lua_pushboolean(L, r != 0); + return 1; +} + + +static int b_or (lua_State *L) { + int i, n = lua_gettop(L); + b_uint r = 0; + for (i = 1; i <= n; i++) + r |= luaL_checkunsigned(L, i); + lua_pushunsigned(L, trim(r)); + return 1; +} + + +static int b_xor (lua_State *L) { + int i, n = lua_gettop(L); + b_uint r = 0; + for (i = 1; i <= n; i++) + r ^= luaL_checkunsigned(L, i); + lua_pushunsigned(L, trim(r)); + return 1; +} + + +static int b_not (lua_State *L) { + b_uint r = ~luaL_checkunsigned(L, 1); + lua_pushunsigned(L, trim(r)); + return 1; +} + + +static int b_shift (lua_State *L, b_uint r, int i) { + if (i < 0) { /* shift right? */ + i = -i; + r = trim(r); + if (i >= LUA_NBITS) r = 0; + else r >>= i; + } + else { /* shift left */ + if (i >= LUA_NBITS) r = 0; + else r <<= i; + r = trim(r); + } + lua_pushunsigned(L, r); + return 1; +} + + +static int b_lshift (lua_State *L) { + return b_shift(L, luaL_checkunsigned(L, 1), luaL_checkint(L, 2)); +} + + +static int b_rshift (lua_State *L) { + return b_shift(L, luaL_checkunsigned(L, 1), -luaL_checkint(L, 2)); +} + + +static int b_arshift (lua_State *L) { + b_uint r = luaL_checkunsigned(L, 1); + int i = luaL_checkint(L, 2); + if (i < 0 || !(r & ((b_uint)1 << (LUA_NBITS - 1)))) + return b_shift(L, r, -i); + else { /* arithmetic shift for 'negative' number */ + if (i >= LUA_NBITS) r = ALLONES; + else + r = trim((r >> i) | ~(~(b_uint)0 >> i)); /* add signal bit */ + lua_pushunsigned(L, r); + return 1; + } +} + + +static int b_rot (lua_State *L, int i) { + b_uint r = luaL_checkunsigned(L, 1); + i &= (LUA_NBITS - 1); /* i = i % NBITS */ + r = trim(r); + if (i != 0) /* avoid undefined shift of LUA_NBITS when i == 0 */ + r = (r << i) | (r >> (LUA_NBITS - i)); + lua_pushunsigned(L, trim(r)); + return 1; +} + + +static int b_lrot (lua_State *L) { + return b_rot(L, luaL_checkint(L, 2)); +} + + +static int b_rrot (lua_State *L) { + return b_rot(L, -luaL_checkint(L, 2)); +} + + +/* +** get field and width arguments for field-manipulation functions, +** checking whether they are valid. +** ('luaL_error' called without 'return' to avoid later warnings about +** 'width' being used uninitialized.) +*/ +static int fieldargs (lua_State *L, int farg, int *width) { + int f = luaL_checkint(L, farg); + int w = luaL_optint(L, farg + 1, 1); + luaL_argcheck(L, 0 <= f, farg, "field cannot be negative"); + luaL_argcheck(L, 0 < w, farg + 1, "width must be positive"); + if (f + w > LUA_NBITS) + luaL_error(L, "trying to access non-existent bits"); + *width = w; + return f; +} + + +static int b_extract (lua_State *L) { + int w; + b_uint r = luaL_checkunsigned(L, 1); + int f = fieldargs(L, 2, &w); + r = (r >> f) & mask(w); + lua_pushunsigned(L, r); + return 1; +} + + +static int b_replace (lua_State *L) { + int w; + b_uint r = luaL_checkunsigned(L, 1); + b_uint v = luaL_checkunsigned(L, 2); + int f = fieldargs(L, 3, &w); + int m = mask(w); + v &= m; /* erase bits outside given width */ + r = (r & ~(m << f)) | (v << f); + lua_pushunsigned(L, r); + return 1; +} + + +static const luaL_Reg bitlib[] = { + {"arshift", b_arshift}, + {"band", b_and}, + {"bnot", b_not}, + {"bor", b_or}, + {"bxor", b_xor}, + {"btest", b_test}, + {"extract", b_extract}, + {"lrotate", b_lrot}, + {"lshift", b_lshift}, + {"replace", b_replace}, + {"rrotate", b_rrot}, + {"rshift", b_rshift}, + {NULL, NULL} +}; + + + +LUAMOD_API int luaopen_bit32 (lua_State *L) { + luaL_newlib(L, bitlib); + return 1; +} + diff --git a/extern/lua/src/lbitlib.o b/extern/lua/src/lbitlib.o new file mode 100644 index 0000000000000000000000000000000000000000..a5ed39f3970a91e0a31226f47d0a1e54ff22e881 GIT binary patch literal 6960 zcmd^DU2Ggz6~6X5jq}6UEePCSkK0fTB8xW-Z3+eLIJV;`R${OX4QaB>uE+M0&91dO z1{;yo)y8Q@jay3aLy_D-BPUKGKth-pg{Bk|DwL)qanc83pef5ach1>8 zJ6S_p9y!v^z4yD{`MKx*%-nsly{n_Ts!Fj`sV}Qii&3SzSC;BgU5%>Sm7zNGS86BD zj5d3}okn#2V*a0vb=$6A!p1Zj>dc?4ogE0*HSR}95pVI_{6hX86_|ZJ$Es1wdlxNh zGo9Y~W7?8;%5Q^3@2`OF*tz(+clzzILZL9g_CJ_DXnzs4OY!yfbb9akA(Z@I>-1)I z2-?4Q&O6=dUCaNuaeijvmv!y_U~!y!z&m!%3VS^i`ny_naSp=vPV2f)1};i5KM=n^ z*3$TOG~OxD)Or(FJH6v$j~u_$xPNA(1(J9SMo`%Iaqce*WNLn4{_5h{6$_UyK#JP@ z>F^eG^1NRyzW(-O|H9#y{99kQzP8!>z13%Vf3te~dfF#Psy2H!i<5EGk8ZZjyV2#n zBa~PKQ+K!#p6V^^^mld1!<2i~% zVeInH%kTwua`}*tLrgkBFin`DdTkztLrL}uO{1ngDHI4&UVV*Ai5KKjGOw2$S(Yo)KEkE7= zv>#$%VQN3H5FnnLeLaz@Wx<@~)chb$_ z?EfFiri~lFU^cfo@uZzL*M}bsN7hExf7-7>IzC1zsrv3$Rn=&H)!nO?*G|E%x(9Il zp>*S;&8W9m8ns(i#f(~Lu7TfUh=V+W56h@OP;D6v`B0Z(ZZ{e_jCu>0$m_>`kk8}e zKkyD>KS(=1%6OTgy$0xd8T&z+@BzGhwI5RpH0KZlaq&@RV{|1O*|@5gtEv-dHF%1E z`~V-VM*Z{EtwzIhp?1TZtZ6rz4=%HemIJq0#)kazEk?Aub)~UkqtRj+&8>zBOwedG zYB#M?p9S@9vNb}s4q{FYggOi}U$e<*sor6j9YzBL1}d1FapLzNU&hMsDViG%QhP=X`^|gVS+zDB89oSKzb(X>0Is7^M`#msqe00-{ZOu z{Waj>4YCyFM#wJeav+9x&!3#Cs6x{&@Oz%qpB4 z+vD1CDBY}I4sk8(r0lQ@M~Vvf+pev`@mx-6AUu*zC3iciF%`~cun)B(;YfLN12oZu zPf_7SX3ritRa6)bE+@QcYv0hpHqWBEPkL^H+nmc9qDu>B9 z?mK*62K}R(O8z(8;p?vrI1Ds>QiUh-YScT03SHo@vXxN9NH9J+1OmoF>efxZ3OLom zemCjhae_Fv^)~@vm=naOh^M~+p#Dk1=Lm1763+|dn>2(b!g2p;`-J1VWC`7JI{G~! zwVWx%62Do{&K%j%?|i^I2p^`&*6(k?a6HJrPPl$g1NIHVyJ>RudkZj|@I!=~&_)@8 zAKIBAT)%SxOA~&9aQ(go49AE37MdEy#|R%Moc)diUR7LurSBksVSag4Vyh$}g|m69 zg!E3Tgo{5tsQYOs>u;s17ni_)v;_X@68Nu|z+YPezqkbc&JsBO)pG}AZjSQ#An;J? z0IxKz#wBo-f;&bk84o8^JVuwB7~gVYbbX1(@IC_sedCGoEocC5Pj+@N2R(eliO2W~ z1Xm<`WE8se#V8)rSEiW0D#h@=6vNAq^1Z9nh#eaq$qkL9bIHN9(~m$`EHUIHb|=%W zGw5UmQclVYyJZvy>=GMdE4E^Tj_YQIi=N_{Ov%?YxU_Rc;F4bucq7Ei`Qh(-+|eJw zfsovf0|LRqgdg)Q!jX^fS$h4dF2QdS{OtigbZO~dg8!7jWge!Mz~==n^H31DwDS<1 zuh=d534z}aeLUW$1TO9TRNxN?{%-^>?OzwTw7-JR8;nQVzf0iKPE_F1&US%IJKqwx zwDY{cj5#*bm$1_i~i_nUCKQD4l+x z$A$L!{oXBb9PbutKQ3_OAEI^hO@Sl-E7TqmIP&@XWLV(H-%jmOfg^v8+T#L8zD@0C z1djYEYIDis5>ilS;(!#}cIq + +#define lcode_c +#define LUA_CORE + +#include "lua.h" + +#include "lcode.h" +#include "ldebug.h" +#include "ldo.h" +#include "lgc.h" +#include "llex.h" +#include "lmem.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lparser.h" +#include "lstring.h" +#include "ltable.h" +#include "lvm.h" + + +#define hasjumps(e) ((e)->t != (e)->f) + + +static int isnumeral(expdesc *e) { + return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP); +} + + +void luaK_nil (FuncState *fs, int from, int n) { + Instruction *previous; + int l = from + n - 1; /* last register to set nil */ + if (fs->pc > fs->lasttarget) { /* no jumps to current position? */ + previous = &fs->f->code[fs->pc-1]; + if (GET_OPCODE(*previous) == OP_LOADNIL) { + int pfrom = GETARG_A(*previous); + int pl = pfrom + GETARG_B(*previous); + if ((pfrom <= from && from <= pl + 1) || + (from <= pfrom && pfrom <= l + 1)) { /* can connect both? */ + if (pfrom < from) from = pfrom; /* from = min(from, pfrom) */ + if (pl > l) l = pl; /* l = max(l, pl) */ + SETARG_A(*previous, from); + SETARG_B(*previous, l - from); + return; + } + } /* else go through */ + } + luaK_codeABC(fs, OP_LOADNIL, from, n - 1, 0); /* else no optimization */ +} + + +int luaK_jump (FuncState *fs) { + int jpc = fs->jpc; /* save list of jumps to here */ + int j; + fs->jpc = NO_JUMP; + j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP); + luaK_concat(fs, &j, jpc); /* keep them on hold */ + return j; +} + + +void luaK_ret (FuncState *fs, int first, int nret) { + luaK_codeABC(fs, OP_RETURN, first, nret+1, 0); +} + + +static int condjump (FuncState *fs, OpCode op, int A, int B, int C) { + luaK_codeABC(fs, op, A, B, C); + return luaK_jump(fs); +} + + +static void fixjump (FuncState *fs, int pc, int dest) { + Instruction *jmp = &fs->f->code[pc]; + int offset = dest-(pc+1); + lua_assert(dest != NO_JUMP); + if (abs(offset) > MAXARG_sBx) + luaX_syntaxerror(fs->ls, "control structure too long"); + SETARG_sBx(*jmp, offset); +} + + +/* +** returns current `pc' and marks it as a jump target (to avoid wrong +** optimizations with consecutive instructions not in the same basic block). +*/ +int luaK_getlabel (FuncState *fs) { + fs->lasttarget = fs->pc; + return fs->pc; +} + + +static int getjump (FuncState *fs, int pc) { + int offset = GETARG_sBx(fs->f->code[pc]); + if (offset == NO_JUMP) /* point to itself represents end of list */ + return NO_JUMP; /* end of list */ + else + return (pc+1)+offset; /* turn offset into absolute position */ +} + + +static Instruction *getjumpcontrol (FuncState *fs, int pc) { + Instruction *pi = &fs->f->code[pc]; + if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1)))) + return pi-1; + else + return pi; +} + + +/* +** check whether list has any jump that do not produce a value +** (or produce an inverted value) +*/ +static int need_value (FuncState *fs, int list) { + for (; list != NO_JUMP; list = getjump(fs, list)) { + Instruction i = *getjumpcontrol(fs, list); + if (GET_OPCODE(i) != OP_TESTSET) return 1; + } + return 0; /* not found */ +} + + +static int patchtestreg (FuncState *fs, int node, int reg) { + Instruction *i = getjumpcontrol(fs, node); + if (GET_OPCODE(*i) != OP_TESTSET) + return 0; /* cannot patch other instructions */ + if (reg != NO_REG && reg != GETARG_B(*i)) + SETARG_A(*i, reg); + else /* no register to put value or register already has the value */ + *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i)); + + return 1; +} + + +static void removevalues (FuncState *fs, int list) { + for (; list != NO_JUMP; list = getjump(fs, list)) + patchtestreg(fs, list, NO_REG); +} + + +static void patchlistaux (FuncState *fs, int list, int vtarget, int reg, + int dtarget) { + while (list != NO_JUMP) { + int next = getjump(fs, list); + if (patchtestreg(fs, list, reg)) + fixjump(fs, list, vtarget); + else + fixjump(fs, list, dtarget); /* jump to default target */ + list = next; + } +} + + +static void dischargejpc (FuncState *fs) { + patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc); + fs->jpc = NO_JUMP; +} + + +void luaK_patchlist (FuncState *fs, int list, int target) { + if (target == fs->pc) + luaK_patchtohere(fs, list); + else { + lua_assert(target < fs->pc); + patchlistaux(fs, list, target, NO_REG, target); + } +} + + +LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level) { + level++; /* argument is +1 to reserve 0 as non-op */ + while (list != NO_JUMP) { + int next = getjump(fs, list); + lua_assert(GET_OPCODE(fs->f->code[list]) == OP_JMP && + (GETARG_A(fs->f->code[list]) == 0 || + GETARG_A(fs->f->code[list]) >= level)); + SETARG_A(fs->f->code[list], level); + list = next; + } +} + + +void luaK_patchtohere (FuncState *fs, int list) { + luaK_getlabel(fs); + luaK_concat(fs, &fs->jpc, list); +} + + +void luaK_concat (FuncState *fs, int *l1, int l2) { + if (l2 == NO_JUMP) return; + else if (*l1 == NO_JUMP) + *l1 = l2; + else { + int list = *l1; + int next; + while ((next = getjump(fs, list)) != NO_JUMP) /* find last element */ + list = next; + fixjump(fs, list, l2); + } +} + + +static int luaK_code (FuncState *fs, Instruction i) { + Proto *f = fs->f; + dischargejpc(fs); /* `pc' will change */ + /* put new instruction in code array */ + luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction, + MAX_INT, "opcodes"); + f->code[fs->pc] = i; + /* save corresponding line information */ + luaM_growvector(fs->ls->L, f->lineinfo, fs->pc, f->sizelineinfo, int, + MAX_INT, "opcodes"); + f->lineinfo[fs->pc] = fs->ls->lastline; + return fs->pc++; +} + + +int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) { + lua_assert(getOpMode(o) == iABC); + lua_assert(getBMode(o) != OpArgN || b == 0); + lua_assert(getCMode(o) != OpArgN || c == 0); + lua_assert(a <= MAXARG_A && b <= MAXARG_B && c <= MAXARG_C); + return luaK_code(fs, CREATE_ABC(o, a, b, c)); +} + + +int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) { + lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx); + lua_assert(getCMode(o) == OpArgN); + lua_assert(a <= MAXARG_A && bc <= MAXARG_Bx); + return luaK_code(fs, CREATE_ABx(o, a, bc)); +} + + +static int codeextraarg (FuncState *fs, int a) { + lua_assert(a <= MAXARG_Ax); + return luaK_code(fs, CREATE_Ax(OP_EXTRAARG, a)); +} + + +int luaK_codek (FuncState *fs, int reg, int k) { + if (k <= MAXARG_Bx) + return luaK_codeABx(fs, OP_LOADK, reg, k); + else { + int p = luaK_codeABx(fs, OP_LOADKX, reg, 0); + codeextraarg(fs, k); + return p; + } +} + + +void luaK_checkstack (FuncState *fs, int n) { + int newstack = fs->freereg + n; + if (newstack > fs->f->maxstacksize) { + if (newstack >= MAXSTACK) + luaX_syntaxerror(fs->ls, "function or expression too complex"); + fs->f->maxstacksize = cast_byte(newstack); + } +} + + +void luaK_reserveregs (FuncState *fs, int n) { + luaK_checkstack(fs, n); + fs->freereg += n; +} + + +static void freereg (FuncState *fs, int reg) { + if (!ISK(reg) && reg >= fs->nactvar) { + fs->freereg--; + lua_assert(reg == fs->freereg); + } +} + + +static void freeexp (FuncState *fs, expdesc *e) { + if (e->k == VNONRELOC) + freereg(fs, e->u.info); +} + + +static int addk (FuncState *fs, TValue *key, TValue *v) { + lua_State *L = fs->ls->L; + TValue *idx = luaH_set(L, fs->h, key); + Proto *f = fs->f; + int k, oldsize; + if (ttisnumber(idx)) { + lua_Number n = nvalue(idx); + lua_number2int(k, n); + if (luaV_rawequalobj(&f->k[k], v)) + return k; + /* else may be a collision (e.g., between 0.0 and "\0\0\0\0\0\0\0\0"); + go through and create a new entry for this value */ + } + /* constant not found; create a new entry */ + oldsize = f->sizek; + k = fs->nk; + /* numerical value does not need GC barrier; + table has no metatable, so it does not need to invalidate cache */ + setnvalue(idx, cast_num(k)); + luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants"); + while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]); + setobj(L, &f->k[k], v); + fs->nk++; + luaC_barrier(L, f, v); + return k; +} + + +int luaK_stringK (FuncState *fs, TString *s) { + TValue o; + setsvalue(fs->ls->L, &o, s); + return addk(fs, &o, &o); +} + + +int luaK_numberK (FuncState *fs, lua_Number r) { + int n; + lua_State *L = fs->ls->L; + TValue o; + setnvalue(&o, r); + if (r == 0 || luai_numisnan(NULL, r)) { /* handle -0 and NaN */ + /* use raw representation as key to avoid numeric problems */ + setsvalue(L, L->top++, luaS_newlstr(L, (char *)&r, sizeof(r))); + n = addk(fs, L->top - 1, &o); + L->top--; + } + else + n = addk(fs, &o, &o); /* regular case */ + return n; +} + + +static int boolK (FuncState *fs, int b) { + TValue o; + setbvalue(&o, b); + return addk(fs, &o, &o); +} + + +static int nilK (FuncState *fs) { + TValue k, v; + setnilvalue(&v); + /* cannot use nil as key; instead use table itself to represent nil */ + sethvalue(fs->ls->L, &k, fs->h); + return addk(fs, &k, &v); +} + + +void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) { + if (e->k == VCALL) { /* expression is an open function call? */ + SETARG_C(getcode(fs, e), nresults+1); + } + else if (e->k == VVARARG) { + SETARG_B(getcode(fs, e), nresults+1); + SETARG_A(getcode(fs, e), fs->freereg); + luaK_reserveregs(fs, 1); + } +} + + +void luaK_setoneret (FuncState *fs, expdesc *e) { + if (e->k == VCALL) { /* expression is an open function call? */ + e->k = VNONRELOC; + e->u.info = GETARG_A(getcode(fs, e)); + } + else if (e->k == VVARARG) { + SETARG_B(getcode(fs, e), 2); + e->k = VRELOCABLE; /* can relocate its simple result */ + } +} + + +void luaK_dischargevars (FuncState *fs, expdesc *e) { + switch (e->k) { + case VLOCAL: { + e->k = VNONRELOC; + break; + } + case VUPVAL: { + e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0); + e->k = VRELOCABLE; + break; + } + case VINDEXED: { + OpCode op = OP_GETTABUP; /* assume 't' is in an upvalue */ + freereg(fs, e->u.ind.idx); + if (e->u.ind.vt == VLOCAL) { /* 't' is in a register? */ + freereg(fs, e->u.ind.t); + op = OP_GETTABLE; + } + e->u.info = luaK_codeABC(fs, op, 0, e->u.ind.t, e->u.ind.idx); + e->k = VRELOCABLE; + break; + } + case VVARARG: + case VCALL: { + luaK_setoneret(fs, e); + break; + } + default: break; /* there is one value available (somewhere) */ + } +} + + +static int code_label (FuncState *fs, int A, int b, int jump) { + luaK_getlabel(fs); /* those instructions may be jump targets */ + return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump); +} + + +static void discharge2reg (FuncState *fs, expdesc *e, int reg) { + luaK_dischargevars(fs, e); + switch (e->k) { + case VNIL: { + luaK_nil(fs, reg, 1); + break; + } + case VFALSE: case VTRUE: { + luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0); + break; + } + case VK: { + luaK_codek(fs, reg, e->u.info); + break; + } + case VKNUM: { + luaK_codek(fs, reg, luaK_numberK(fs, e->u.nval)); + break; + } + case VRELOCABLE: { + Instruction *pc = &getcode(fs, e); + SETARG_A(*pc, reg); + break; + } + case VNONRELOC: { + if (reg != e->u.info) + luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0); + break; + } + default: { + lua_assert(e->k == VVOID || e->k == VJMP); + return; /* nothing to do... */ + } + } + e->u.info = reg; + e->k = VNONRELOC; +} + + +static void discharge2anyreg (FuncState *fs, expdesc *e) { + if (e->k != VNONRELOC) { + luaK_reserveregs(fs, 1); + discharge2reg(fs, e, fs->freereg-1); + } +} + + +static void exp2reg (FuncState *fs, expdesc *e, int reg) { + discharge2reg(fs, e, reg); + if (e->k == VJMP) + luaK_concat(fs, &e->t, e->u.info); /* put this jump in `t' list */ + if (hasjumps(e)) { + int final; /* position after whole expression */ + int p_f = NO_JUMP; /* position of an eventual LOAD false */ + int p_t = NO_JUMP; /* position of an eventual LOAD true */ + if (need_value(fs, e->t) || need_value(fs, e->f)) { + int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs); + p_f = code_label(fs, reg, 0, 1); + p_t = code_label(fs, reg, 1, 0); + luaK_patchtohere(fs, fj); + } + final = luaK_getlabel(fs); + patchlistaux(fs, e->f, final, reg, p_f); + patchlistaux(fs, e->t, final, reg, p_t); + } + e->f = e->t = NO_JUMP; + e->u.info = reg; + e->k = VNONRELOC; +} + + +void luaK_exp2nextreg (FuncState *fs, expdesc *e) { + luaK_dischargevars(fs, e); + freeexp(fs, e); + luaK_reserveregs(fs, 1); + exp2reg(fs, e, fs->freereg - 1); +} + + +int luaK_exp2anyreg (FuncState *fs, expdesc *e) { + luaK_dischargevars(fs, e); + if (e->k == VNONRELOC) { + if (!hasjumps(e)) return e->u.info; /* exp is already in a register */ + if (e->u.info >= fs->nactvar) { /* reg. is not a local? */ + exp2reg(fs, e, e->u.info); /* put value on it */ + return e->u.info; + } + } + luaK_exp2nextreg(fs, e); /* default */ + return e->u.info; +} + + +void luaK_exp2anyregup (FuncState *fs, expdesc *e) { + if (e->k != VUPVAL || hasjumps(e)) + luaK_exp2anyreg(fs, e); +} + + +void luaK_exp2val (FuncState *fs, expdesc *e) { + if (hasjumps(e)) + luaK_exp2anyreg(fs, e); + else + luaK_dischargevars(fs, e); +} + + +int luaK_exp2RK (FuncState *fs, expdesc *e) { + luaK_exp2val(fs, e); + switch (e->k) { + case VTRUE: + case VFALSE: + case VNIL: { + if (fs->nk <= MAXINDEXRK) { /* constant fits in RK operand? */ + e->u.info = (e->k == VNIL) ? nilK(fs) : boolK(fs, (e->k == VTRUE)); + e->k = VK; + return RKASK(e->u.info); + } + else break; + } + case VKNUM: { + e->u.info = luaK_numberK(fs, e->u.nval); + e->k = VK; + /* go through */ + } + case VK: { + if (e->u.info <= MAXINDEXRK) /* constant fits in argC? */ + return RKASK(e->u.info); + else break; + } + default: break; + } + /* not a constant in the right range: put it in a register */ + return luaK_exp2anyreg(fs, e); +} + + +void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) { + switch (var->k) { + case VLOCAL: { + freeexp(fs, ex); + exp2reg(fs, ex, var->u.info); + return; + } + case VUPVAL: { + int e = luaK_exp2anyreg(fs, ex); + luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0); + break; + } + case VINDEXED: { + OpCode op = (var->u.ind.vt == VLOCAL) ? OP_SETTABLE : OP_SETTABUP; + int e = luaK_exp2RK(fs, ex); + luaK_codeABC(fs, op, var->u.ind.t, var->u.ind.idx, e); + break; + } + default: { + lua_assert(0); /* invalid var kind to store */ + break; + } + } + freeexp(fs, ex); +} + + +void luaK_self (FuncState *fs, expdesc *e, expdesc *key) { + int ereg; + luaK_exp2anyreg(fs, e); + ereg = e->u.info; /* register where 'e' was placed */ + freeexp(fs, e); + e->u.info = fs->freereg; /* base register for op_self */ + e->k = VNONRELOC; + luaK_reserveregs(fs, 2); /* function and 'self' produced by op_self */ + luaK_codeABC(fs, OP_SELF, e->u.info, ereg, luaK_exp2RK(fs, key)); + freeexp(fs, key); +} + + +static void invertjump (FuncState *fs, expdesc *e) { + Instruction *pc = getjumpcontrol(fs, e->u.info); + lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET && + GET_OPCODE(*pc) != OP_TEST); + SETARG_A(*pc, !(GETARG_A(*pc))); +} + + +static int jumponcond (FuncState *fs, expdesc *e, int cond) { + if (e->k == VRELOCABLE) { + Instruction ie = getcode(fs, e); + if (GET_OPCODE(ie) == OP_NOT) { + fs->pc--; /* remove previous OP_NOT */ + return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond); + } + /* else go through */ + } + discharge2anyreg(fs, e); + freeexp(fs, e); + return condjump(fs, OP_TESTSET, NO_REG, e->u.info, cond); +} + + +void luaK_goiftrue (FuncState *fs, expdesc *e) { + int pc; /* pc of last jump */ + luaK_dischargevars(fs, e); + switch (e->k) { + case VJMP: { + invertjump(fs, e); + pc = e->u.info; + break; + } + case VK: case VKNUM: case VTRUE: { + pc = NO_JUMP; /* always true; do nothing */ + break; + } + default: { + pc = jumponcond(fs, e, 0); + break; + } + } + luaK_concat(fs, &e->f, pc); /* insert last jump in `f' list */ + luaK_patchtohere(fs, e->t); + e->t = NO_JUMP; +} + + +void luaK_goiffalse (FuncState *fs, expdesc *e) { + int pc; /* pc of last jump */ + luaK_dischargevars(fs, e); + switch (e->k) { + case VJMP: { + pc = e->u.info; + break; + } + case VNIL: case VFALSE: { + pc = NO_JUMP; /* always false; do nothing */ + break; + } + default: { + pc = jumponcond(fs, e, 1); + break; + } + } + luaK_concat(fs, &e->t, pc); /* insert last jump in `t' list */ + luaK_patchtohere(fs, e->f); + e->f = NO_JUMP; +} + + +static void codenot (FuncState *fs, expdesc *e) { + luaK_dischargevars(fs, e); + switch (e->k) { + case VNIL: case VFALSE: { + e->k = VTRUE; + break; + } + case VK: case VKNUM: case VTRUE: { + e->k = VFALSE; + break; + } + case VJMP: { + invertjump(fs, e); + break; + } + case VRELOCABLE: + case VNONRELOC: { + discharge2anyreg(fs, e); + freeexp(fs, e); + e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0); + e->k = VRELOCABLE; + break; + } + default: { + lua_assert(0); /* cannot happen */ + break; + } + } + /* interchange true and false lists */ + { int temp = e->f; e->f = e->t; e->t = temp; } + removevalues(fs, e->f); + removevalues(fs, e->t); +} + + +void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { + lua_assert(!hasjumps(t)); + t->u.ind.t = t->u.info; + t->u.ind.idx = luaK_exp2RK(fs, k); + t->u.ind.vt = (t->k == VUPVAL) ? VUPVAL + : check_exp(vkisinreg(t->k), VLOCAL); + t->k = VINDEXED; +} + + +static int constfolding (OpCode op, expdesc *e1, expdesc *e2) { + lua_Number r; + if (!isnumeral(e1) || !isnumeral(e2)) return 0; + if ((op == OP_DIV || op == OP_MOD) && e2->u.nval == 0) + return 0; /* do not attempt to divide by 0 */ + r = luaO_arith(op - OP_ADD + LUA_OPADD, e1->u.nval, e2->u.nval); + e1->u.nval = r; + return 1; +} + + +static void codearith (FuncState *fs, OpCode op, + expdesc *e1, expdesc *e2, int line) { + if (constfolding(op, e1, e2)) + return; + else { + int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0; + int o1 = luaK_exp2RK(fs, e1); + if (o1 > o2) { + freeexp(fs, e1); + freeexp(fs, e2); + } + else { + freeexp(fs, e2); + freeexp(fs, e1); + } + e1->u.info = luaK_codeABC(fs, op, 0, o1, o2); + e1->k = VRELOCABLE; + luaK_fixline(fs, line); + } +} + + +static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1, + expdesc *e2) { + int o1 = luaK_exp2RK(fs, e1); + int o2 = luaK_exp2RK(fs, e2); + freeexp(fs, e2); + freeexp(fs, e1); + if (cond == 0 && op != OP_EQ) { + int temp; /* exchange args to replace by `<' or `<=' */ + temp = o1; o1 = o2; o2 = temp; /* o1 <==> o2 */ + cond = 1; + } + e1->u.info = condjump(fs, op, cond, o1, o2); + e1->k = VJMP; +} + + +void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) { + expdesc e2; + e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0; + switch (op) { + case OPR_MINUS: { + if (isnumeral(e)) /* minus constant? */ + e->u.nval = luai_numunm(NULL, e->u.nval); /* fold it */ + else { + luaK_exp2anyreg(fs, e); + codearith(fs, OP_UNM, e, &e2, line); + } + break; + } + case OPR_NOT: codenot(fs, e); break; + case OPR_LEN: { + luaK_exp2anyreg(fs, e); /* cannot operate on constants */ + codearith(fs, OP_LEN, e, &e2, line); + break; + } + default: lua_assert(0); + } +} + + +void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) { + switch (op) { + case OPR_AND: { + luaK_goiftrue(fs, v); + break; + } + case OPR_OR: { + luaK_goiffalse(fs, v); + break; + } + case OPR_CONCAT: { + luaK_exp2nextreg(fs, v); /* operand must be on the `stack' */ + break; + } + case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV: + case OPR_MOD: case OPR_POW: { + if (!isnumeral(v)) luaK_exp2RK(fs, v); + break; + } + default: { + luaK_exp2RK(fs, v); + break; + } + } +} + + +void luaK_posfix (FuncState *fs, BinOpr op, + expdesc *e1, expdesc *e2, int line) { + switch (op) { + case OPR_AND: { + lua_assert(e1->t == NO_JUMP); /* list must be closed */ + luaK_dischargevars(fs, e2); + luaK_concat(fs, &e2->f, e1->f); + *e1 = *e2; + break; + } + case OPR_OR: { + lua_assert(e1->f == NO_JUMP); /* list must be closed */ + luaK_dischargevars(fs, e2); + luaK_concat(fs, &e2->t, e1->t); + *e1 = *e2; + break; + } + case OPR_CONCAT: { + luaK_exp2val(fs, e2); + if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) { + lua_assert(e1->u.info == GETARG_B(getcode(fs, e2))-1); + freeexp(fs, e1); + SETARG_B(getcode(fs, e2), e1->u.info); + e1->k = VRELOCABLE; e1->u.info = e2->u.info; + } + else { + luaK_exp2nextreg(fs, e2); /* operand must be on the 'stack' */ + codearith(fs, OP_CONCAT, e1, e2, line); + } + break; + } + case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV: + case OPR_MOD: case OPR_POW: { + codearith(fs, cast(OpCode, op - OPR_ADD + OP_ADD), e1, e2, line); + break; + } + case OPR_EQ: case OPR_LT: case OPR_LE: { + codecomp(fs, cast(OpCode, op - OPR_EQ + OP_EQ), 1, e1, e2); + break; + } + case OPR_NE: case OPR_GT: case OPR_GE: { + codecomp(fs, cast(OpCode, op - OPR_NE + OP_EQ), 0, e1, e2); + break; + } + default: lua_assert(0); + } +} + + +void luaK_fixline (FuncState *fs, int line) { + fs->f->lineinfo[fs->pc - 1] = line; +} + + +void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) { + int c = (nelems - 1)/LFIELDS_PER_FLUSH + 1; + int b = (tostore == LUA_MULTRET) ? 0 : tostore; + lua_assert(tostore != 0); + if (c <= MAXARG_C) + luaK_codeABC(fs, OP_SETLIST, base, b, c); + else if (c <= MAXARG_Ax) { + luaK_codeABC(fs, OP_SETLIST, base, b, 0); + codeextraarg(fs, c); + } + else + luaX_syntaxerror(fs->ls, "constructor too long"); + fs->freereg = base + 1; /* free registers with list values */ +} + diff --git a/extern/lua/src/lcode.h b/extern/lua/src/lcode.h new file mode 100644 index 0000000..6a1424c --- /dev/null +++ b/extern/lua/src/lcode.h @@ -0,0 +1,83 @@ +/* +** $Id: lcode.h,v 1.58.1.1 2013/04/12 18:48:47 roberto Exp $ +** Code generator for Lua +** See Copyright Notice in lua.h +*/ + +#ifndef lcode_h +#define lcode_h + +#include "llex.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lparser.h" + + +/* +** Marks the end of a patch list. It is an invalid value both as an absolute +** address, and as a list link (would link an element to itself). +*/ +#define NO_JUMP (-1) + + +/* +** grep "ORDER OPR" if you change these enums (ORDER OP) +*/ +typedef enum BinOpr { + OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW, + OPR_CONCAT, + OPR_EQ, OPR_LT, OPR_LE, + OPR_NE, OPR_GT, OPR_GE, + OPR_AND, OPR_OR, + OPR_NOBINOPR +} BinOpr; + + +typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr; + + +#define getcode(fs,e) ((fs)->f->code[(e)->u.info]) + +#define luaK_codeAsBx(fs,o,A,sBx) luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx) + +#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) + +#define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t) + +LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx); +LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C); +LUAI_FUNC int luaK_codek (FuncState *fs, int reg, int k); +LUAI_FUNC void luaK_fixline (FuncState *fs, int line); +LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n); +LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n); +LUAI_FUNC void luaK_checkstack (FuncState *fs, int n); +LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s); +LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r); +LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e); +LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e); +LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e); +LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e); +LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e); +LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e); +LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key); +LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k); +LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e); +LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e); +LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e); +LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults); +LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e); +LUAI_FUNC int luaK_jump (FuncState *fs); +LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret); +LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target); +LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list); +LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level); +LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2); +LUAI_FUNC int luaK_getlabel (FuncState *fs); +LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line); +LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v); +LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, + expdesc *v2, int line); +LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore); + + +#endif diff --git a/extern/lua/src/lcode.o b/extern/lua/src/lcode.o new file mode 100644 index 0000000000000000000000000000000000000000..c3b53b3cceeab2c41d92ac1f5ce031e1094d681b GIT binary patch literal 17664 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 xK6#(n>A>ZE=3WOb?=yeuz#F-a_u9_yf + + +#define lcorolib_c +#define LUA_LIB + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +static int auxresume (lua_State *L, lua_State *co, int narg) { + int status; + if (!lua_checkstack(co, narg)) { + lua_pushliteral(L, "too many arguments to resume"); + return -1; /* error flag */ + } + if (lua_status(co) == LUA_OK && lua_gettop(co) == 0) { + lua_pushliteral(L, "cannot resume dead coroutine"); + return -1; /* error flag */ + } + lua_xmove(L, co, narg); + status = lua_resume(co, L, narg); + if (status == LUA_OK || status == LUA_YIELD) { + int nres = lua_gettop(co); + if (!lua_checkstack(L, nres + 1)) { + lua_pop(co, nres); /* remove results anyway */ + lua_pushliteral(L, "too many results to resume"); + return -1; /* error flag */ + } + lua_xmove(co, L, nres); /* move yielded values */ + return nres; + } + else { + lua_xmove(co, L, 1); /* move error message */ + return -1; /* error flag */ + } +} + + +static int luaB_coresume (lua_State *L) { + lua_State *co = lua_tothread(L, 1); + int r; + luaL_argcheck(L, co, 1, "coroutine expected"); + r = auxresume(L, co, lua_gettop(L) - 1); + if (r < 0) { + lua_pushboolean(L, 0); + lua_insert(L, -2); + return 2; /* return false + error message */ + } + else { + lua_pushboolean(L, 1); + lua_insert(L, -(r + 1)); + return r + 1; /* return true + `resume' returns */ + } +} + + +static int luaB_auxwrap (lua_State *L) { + lua_State *co = lua_tothread(L, lua_upvalueindex(1)); + int r = auxresume(L, co, lua_gettop(L)); + if (r < 0) { + if (lua_isstring(L, -1)) { /* error object is a string? */ + luaL_where(L, 1); /* add extra info */ + lua_insert(L, -2); + lua_concat(L, 2); + } + return lua_error(L); /* propagate error */ + } + return r; +} + + +static int luaB_cocreate (lua_State *L) { + lua_State *NL; + luaL_checktype(L, 1, LUA_TFUNCTION); + NL = lua_newthread(L); + lua_pushvalue(L, 1); /* move function to top */ + lua_xmove(L, NL, 1); /* move function from L to NL */ + return 1; +} + + +static int luaB_cowrap (lua_State *L) { + luaB_cocreate(L); + lua_pushcclosure(L, luaB_auxwrap, 1); + return 1; +} + + +static int luaB_yield (lua_State *L) { + return lua_yield(L, lua_gettop(L)); +} + + +static int luaB_costatus (lua_State *L) { + lua_State *co = lua_tothread(L, 1); + luaL_argcheck(L, co, 1, "coroutine expected"); + if (L == co) lua_pushliteral(L, "running"); + else { + switch (lua_status(co)) { + case LUA_YIELD: + lua_pushliteral(L, "suspended"); + break; + case LUA_OK: { + lua_Debug ar; + if (lua_getstack(co, 0, &ar) > 0) /* does it have frames? */ + lua_pushliteral(L, "normal"); /* it is running */ + else if (lua_gettop(co) == 0) + lua_pushliteral(L, "dead"); + else + lua_pushliteral(L, "suspended"); /* initial state */ + break; + } + default: /* some error occurred */ + lua_pushliteral(L, "dead"); + break; + } + } + return 1; +} + + +static int luaB_corunning (lua_State *L) { + int ismain = lua_pushthread(L); + lua_pushboolean(L, ismain); + return 2; +} + + +static const luaL_Reg co_funcs[] = { + {"create", luaB_cocreate}, + {"resume", luaB_coresume}, + {"running", luaB_corunning}, + {"status", luaB_costatus}, + {"wrap", luaB_cowrap}, + {"yield", luaB_yield}, + {NULL, NULL} +}; + + + +LUAMOD_API int luaopen_coroutine (lua_State *L) { + luaL_newlib(L, co_funcs); + return 1; +} + diff --git a/extern/lua/src/lcorolib.o b/extern/lua/src/lcorolib.o new file mode 100644 index 0000000000000000000000000000000000000000..1bf51532c2afac48e05e914fb15718f2ea9987c5 GIT binary patch literal 6496 zcmd59b7>jn}++ce7l09p-cYqn_tA(g^9%K6=Q zu6^>7S0Th79O?O;^Si(Eaqm0t-Ru1u@*Cr^m@*Pm52?0gP^B(j-PW^O&8lwoakVw) ze|R2t&Oe*^b>{UU|K$aksh(-vRNuD2NBm2~`kQ}-DE{v>`OvA<^!I6$5VpO?{daTz zpYr}Y8t~uE`)`}ksf)2a1!Ekm#fapeHhxboq59{CcJw_lKbkiAjoYD9&1Yv_Tje7>FPIe`Qv`koUqXzN2syN4 zp61b>ulH)ICrkF?>@`>RIY7fIb0O!y)pmaJ7jV4lN{*wco&ii`aTcv{g_;h~u$sjW zPkm9>zHlQg%Z%(F|7AUJGEUT?`5^w_R$T>kS>QbNerGUq?i?yP=bzSNjN^gmry1B& zFLkz;CmZzZk14ZZwF?hu^P`Yf|IqXL{quhz_J=uvNQj z9z@%Jj#43)rc)E9z#w~Qhki|FNR`E(o%=D1V!8kXl;b*DjwD%#bm>#=2xIQEEDbn9-@D_0%W@&viE z)X$JCXQJj5J!eGKo7HN$x=S^hjha&(A*AZo$L)$jR8_1yw&y5L+wg3!*-(4xc1=x| zoyrJ0_Ww^dJ^b*4)?EY6aM`X}>(URTGxuiJ^#&SMdlOe2+xuk|o9K?+dfnBXGxT{_ zML0fx5a_Be**z8ClI$e)9=g^8Bk9Daq(9kxG~Sn7bvQAQw5B@ZW7j5E5x+m#`Dhmn z=jkfZ1xbNVV~4??N^DLZkHrUwzA@R|m+TzqD!24p*H>HmrmnBF^jsI}If-B-_=E zhCJv~2-X&Ybp@V)A!K(buNmUUVNBigi22|8XUKP@`TwW+v+RE#-K7}+A4!mOQ@^=y zV+@;wlq|1XO@gFnL-uB}S6ctlCj+9ziLn0I-^1(w1Yw}8rAx{Q&i@$+l5XlYcXXlA zCH1%LFEQw0?q0^i^M957kB1yg{U&acl$GXxgd6NlCSv~h<{5v}e`wQi@4%(T=j3S^ zLPF)}`Gji+{UVZ)tmi&Xk$w|h;ruw$t(1Q)zi6+75{69jURl8FP=CF=(r9AYQwUgz z6)Qn~Jc&@Sgj)WPuOm)e#5d~<*Tk}~j8bS*@GTHX^u9&++vozmmM5(DC&E6@c$ODk z?=yrw#Q09e^&UeQ?uc`O@ik;aw$lat9OHUFAq@Qtyv7ej?-ztM=!)q#h!hg}UM2({ zj0V36b*(g8dO~+%%WNqLg>G0X`^e;0STgYS2>hE7`1d04pGM$6kHCK!fxi}k{~-cj zh`=vI;2qQlE3Lzg5%}#9_da$WEtZ_(Sa8+>shzwqG4AemG^br(q1J4aDs+OvUjxl= z2lZU9M1KoLG)~D{LGuOruj16}Ze0%{gkZuPcHN3&S23I~=!(3_T9CWy>e4@)Li>*r<`t|noiZyra=y@T zykIF?UtoO3u)okhMJ?t$0{jyK?!e-IyM zTND2VdXFF`&VzxeZecuJPrtxd6W7GScLM^xT>oY${z1)BYOmnSI-eG}TsM3NAf`^U zPyI~rWt`Upjx{!Qz7>kIS4UOq9l@7zuEB&zOx{vpswCs#_2~`q2bq7r;N$FR>e(Rh z9)WKbxFv8;;I|2UpTO4${HVZh7x*&*mwojj4Y(MS=GUe80eDJx>W-)^kGOmWcC$z-8Vu0+;+h3taO5!MN!k z(+^kiK8JOX{jgf#cZ+)NWE^qidEsuszen&fM+oBIOqc1mFNiv^#~PeeEqD#^T{;|? zt#dta#M+4;5>tcW9}D2t|6jv5=S_>p4d1*+SSyI(XF2}b0Mu$^Zg`atZt8p?gq!)k8N$sv>jj`Olh@S0 X8Ve@yb6nK65N_5V=Pt=N=d6DN+sU9k literal 0 HcmV?d00001 diff --git a/extern/lua/src/lctype.c b/extern/lua/src/lctype.c new file mode 100644 index 0000000..93f8cad --- /dev/null +++ b/extern/lua/src/lctype.c @@ -0,0 +1,52 @@ +/* +** $Id: lctype.c,v 1.11.1.1 2013/04/12 18:48:47 roberto Exp $ +** 'ctype' functions for Lua +** See Copyright Notice in lua.h +*/ + +#define lctype_c +#define LUA_CORE + +#include "lctype.h" + +#if !LUA_USE_CTYPE /* { */ + +#include + +LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = { + 0x00, /* EOZ */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0. */ + 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 1. */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, /* 2. */ + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, /* 3. */ + 0x16, 0x16, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 4. */ + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 5. */ + 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x05, + 0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 6. */ + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 7. */ + 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 8. */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 9. */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* a. */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* b. */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* c. */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* d. */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* e. */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* f. */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +#endif /* } */ diff --git a/extern/lua/src/lctype.h b/extern/lua/src/lctype.h new file mode 100644 index 0000000..b09b21a --- /dev/null +++ b/extern/lua/src/lctype.h @@ -0,0 +1,95 @@ +/* +** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $ +** 'ctype' functions for Lua +** See Copyright Notice in lua.h +*/ + +#ifndef lctype_h +#define lctype_h + +#include "lua.h" + + +/* +** WARNING: the functions defined here do not necessarily correspond +** to the similar functions in the standard C ctype.h. They are +** optimized for the specific needs of Lua +*/ + +#if !defined(LUA_USE_CTYPE) + +#if 'A' == 65 && '0' == 48 +/* ASCII case: can use its own tables; faster and fixed */ +#define LUA_USE_CTYPE 0 +#else +/* must use standard C ctype */ +#define LUA_USE_CTYPE 1 +#endif + +#endif + + +#if !LUA_USE_CTYPE /* { */ + +#include + +#include "llimits.h" + + +#define ALPHABIT 0 +#define DIGITBIT 1 +#define PRINTBIT 2 +#define SPACEBIT 3 +#define XDIGITBIT 4 + + +#define MASK(B) (1 << (B)) + + +/* +** add 1 to char to allow index -1 (EOZ) +*/ +#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) + +/* +** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_' +*/ +#define lislalpha(c) testprop(c, MASK(ALPHABIT)) +#define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT))) +#define lisdigit(c) testprop(c, MASK(DIGITBIT)) +#define lisspace(c) testprop(c, MASK(SPACEBIT)) +#define lisprint(c) testprop(c, MASK(PRINTBIT)) +#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) + +/* +** this 'ltolower' only works for alphabetic characters +*/ +#define ltolower(c) ((c) | ('A' ^ 'a')) + + +/* two more entries for 0 and -1 (EOZ) */ +LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2]; + + +#else /* }{ */ + +/* +** use standard C ctypes +*/ + +#include + + +#define lislalpha(c) (isalpha(c) || (c) == '_') +#define lislalnum(c) (isalnum(c) || (c) == '_') +#define lisdigit(c) (isdigit(c)) +#define lisspace(c) (isspace(c)) +#define lisprint(c) (isprint(c)) +#define lisxdigit(c) (isxdigit(c)) + +#define ltolower(c) (tolower(c)) + +#endif /* } */ + +#endif + diff --git a/extern/lua/src/lctype.o b/extern/lua/src/lctype.o new file mode 100644 index 0000000000000000000000000000000000000000..283e4a236a2cc39631803660dc7f0bfdf9934e78 GIT binary patch literal 1310 zcmcgr!AiqG5S=uM*5aiHiy%lnsbH5Da#2tsReMoyomW_Pli*URgxmg4}K182}6VgcSXGOXzkIfUpt+zDA zZ`I~o35tsjc-#7IUkZ9kN6uWIc+;cKgO5*> zN9l&0^9xZ7&_Ebq%K<%_3`r7(Mrr%??e_yUZQ BHFf|1 literal 0 HcmV?d00001 diff --git a/extern/lua/src/ldblib.c b/extern/lua/src/ldblib.c new file mode 100644 index 0000000..84fe3c7 --- /dev/null +++ b/extern/lua/src/ldblib.c @@ -0,0 +1,398 @@ +/* +** $Id: ldblib.c,v 1.132.1.1 2013/04/12 18:48:47 roberto Exp $ +** Interface from Lua to its debug API +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include + +#define ldblib_c +#define LUA_LIB + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +#define HOOKKEY "_HKEY" + + + +static int db_getregistry (lua_State *L) { + lua_pushvalue(L, LUA_REGISTRYINDEX); + return 1; +} + + +static int db_getmetatable (lua_State *L) { + luaL_checkany(L, 1); + if (!lua_getmetatable(L, 1)) { + lua_pushnil(L); /* no metatable */ + } + return 1; +} + + +static int db_setmetatable (lua_State *L) { + int t = lua_type(L, 2); + luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2, + "nil or table expected"); + lua_settop(L, 2); + lua_setmetatable(L, 1); + return 1; /* return 1st argument */ +} + + +static int db_getuservalue (lua_State *L) { + if (lua_type(L, 1) != LUA_TUSERDATA) + lua_pushnil(L); + else + lua_getuservalue(L, 1); + return 1; +} + + +static int db_setuservalue (lua_State *L) { + if (lua_type(L, 1) == LUA_TLIGHTUSERDATA) + luaL_argerror(L, 1, "full userdata expected, got light userdata"); + luaL_checktype(L, 1, LUA_TUSERDATA); + if (!lua_isnoneornil(L, 2)) + luaL_checktype(L, 2, LUA_TTABLE); + lua_settop(L, 2); + lua_setuservalue(L, 1); + return 1; +} + + +static void settabss (lua_State *L, const char *i, const char *v) { + lua_pushstring(L, v); + lua_setfield(L, -2, i); +} + + +static void settabsi (lua_State *L, const char *i, int v) { + lua_pushinteger(L, v); + lua_setfield(L, -2, i); +} + + +static void settabsb (lua_State *L, const char *i, int v) { + lua_pushboolean(L, v); + lua_setfield(L, -2, i); +} + + +static lua_State *getthread (lua_State *L, int *arg) { + if (lua_isthread(L, 1)) { + *arg = 1; + return lua_tothread(L, 1); + } + else { + *arg = 0; + return L; + } +} + + +static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) { + if (L == L1) { + lua_pushvalue(L, -2); + lua_remove(L, -3); + } + else + lua_xmove(L1, L, 1); + lua_setfield(L, -2, fname); +} + + +static int db_getinfo (lua_State *L) { + lua_Debug ar; + int arg; + lua_State *L1 = getthread(L, &arg); + const char *options = luaL_optstring(L, arg+2, "flnStu"); + if (lua_isnumber(L, arg+1)) { + if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) { + lua_pushnil(L); /* level out of range */ + return 1; + } + } + else if (lua_isfunction(L, arg+1)) { + lua_pushfstring(L, ">%s", options); + options = lua_tostring(L, -1); + lua_pushvalue(L, arg+1); + lua_xmove(L, L1, 1); + } + else + return luaL_argerror(L, arg+1, "function or level expected"); + if (!lua_getinfo(L1, options, &ar)) + return luaL_argerror(L, arg+2, "invalid option"); + lua_createtable(L, 0, 2); + if (strchr(options, 'S')) { + settabss(L, "source", ar.source); + settabss(L, "short_src", ar.short_src); + settabsi(L, "linedefined", ar.linedefined); + settabsi(L, "lastlinedefined", ar.lastlinedefined); + settabss(L, "what", ar.what); + } + if (strchr(options, 'l')) + settabsi(L, "currentline", ar.currentline); + if (strchr(options, 'u')) { + settabsi(L, "nups", ar.nups); + settabsi(L, "nparams", ar.nparams); + settabsb(L, "isvararg", ar.isvararg); + } + if (strchr(options, 'n')) { + settabss(L, "name", ar.name); + settabss(L, "namewhat", ar.namewhat); + } + if (strchr(options, 't')) + settabsb(L, "istailcall", ar.istailcall); + if (strchr(options, 'L')) + treatstackoption(L, L1, "activelines"); + if (strchr(options, 'f')) + treatstackoption(L, L1, "func"); + return 1; /* return table */ +} + + +static int db_getlocal (lua_State *L) { + int arg; + lua_State *L1 = getthread(L, &arg); + lua_Debug ar; + const char *name; + int nvar = luaL_checkint(L, arg+2); /* local-variable index */ + if (lua_isfunction(L, arg + 1)) { /* function argument? */ + lua_pushvalue(L, arg + 1); /* push function */ + lua_pushstring(L, lua_getlocal(L, NULL, nvar)); /* push local name */ + return 1; + } + else { /* stack-level argument */ + if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */ + return luaL_argerror(L, arg+1, "level out of range"); + name = lua_getlocal(L1, &ar, nvar); + if (name) { + lua_xmove(L1, L, 1); /* push local value */ + lua_pushstring(L, name); /* push name */ + lua_pushvalue(L, -2); /* re-order */ + return 2; + } + else { + lua_pushnil(L); /* no name (nor value) */ + return 1; + } + } +} + + +static int db_setlocal (lua_State *L) { + int arg; + lua_State *L1 = getthread(L, &arg); + lua_Debug ar; + if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */ + return luaL_argerror(L, arg+1, "level out of range"); + luaL_checkany(L, arg+3); + lua_settop(L, arg+3); + lua_xmove(L, L1, 1); + lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2))); + return 1; +} + + +static int auxupvalue (lua_State *L, int get) { + const char *name; + int n = luaL_checkint(L, 2); + luaL_checktype(L, 1, LUA_TFUNCTION); + name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n); + if (name == NULL) return 0; + lua_pushstring(L, name); + lua_insert(L, -(get+1)); + return get + 1; +} + + +static int db_getupvalue (lua_State *L) { + return auxupvalue(L, 1); +} + + +static int db_setupvalue (lua_State *L) { + luaL_checkany(L, 3); + return auxupvalue(L, 0); +} + + +static int checkupval (lua_State *L, int argf, int argnup) { + lua_Debug ar; + int nup = luaL_checkint(L, argnup); + luaL_checktype(L, argf, LUA_TFUNCTION); + lua_pushvalue(L, argf); + lua_getinfo(L, ">u", &ar); + luaL_argcheck(L, 1 <= nup && nup <= ar.nups, argnup, "invalid upvalue index"); + return nup; +} + + +static int db_upvalueid (lua_State *L) { + int n = checkupval(L, 1, 2); + lua_pushlightuserdata(L, lua_upvalueid(L, 1, n)); + return 1; +} + + +static int db_upvaluejoin (lua_State *L) { + int n1 = checkupval(L, 1, 2); + int n2 = checkupval(L, 3, 4); + luaL_argcheck(L, !lua_iscfunction(L, 1), 1, "Lua function expected"); + luaL_argcheck(L, !lua_iscfunction(L, 3), 3, "Lua function expected"); + lua_upvaluejoin(L, 1, n1, 3, n2); + return 0; +} + + +#define gethooktable(L) luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY) + + +static void hookf (lua_State *L, lua_Debug *ar) { + static const char *const hooknames[] = + {"call", "return", "line", "count", "tail call"}; + gethooktable(L); + lua_pushthread(L); + lua_rawget(L, -2); + if (lua_isfunction(L, -1)) { + lua_pushstring(L, hooknames[(int)ar->event]); + if (ar->currentline >= 0) + lua_pushinteger(L, ar->currentline); + else lua_pushnil(L); + lua_assert(lua_getinfo(L, "lS", ar)); + lua_call(L, 2, 0); + } +} + + +static int makemask (const char *smask, int count) { + int mask = 0; + if (strchr(smask, 'c')) mask |= LUA_MASKCALL; + if (strchr(smask, 'r')) mask |= LUA_MASKRET; + if (strchr(smask, 'l')) mask |= LUA_MASKLINE; + if (count > 0) mask |= LUA_MASKCOUNT; + return mask; +} + + +static char *unmakemask (int mask, char *smask) { + int i = 0; + if (mask & LUA_MASKCALL) smask[i++] = 'c'; + if (mask & LUA_MASKRET) smask[i++] = 'r'; + if (mask & LUA_MASKLINE) smask[i++] = 'l'; + smask[i] = '\0'; + return smask; +} + + +static int db_sethook (lua_State *L) { + int arg, mask, count; + lua_Hook func; + lua_State *L1 = getthread(L, &arg); + if (lua_isnoneornil(L, arg+1)) { + lua_settop(L, arg+1); + func = NULL; mask = 0; count = 0; /* turn off hooks */ + } + else { + const char *smask = luaL_checkstring(L, arg+2); + luaL_checktype(L, arg+1, LUA_TFUNCTION); + count = luaL_optint(L, arg+3, 0); + func = hookf; mask = makemask(smask, count); + } + if (gethooktable(L) == 0) { /* creating hook table? */ + lua_pushstring(L, "k"); + lua_setfield(L, -2, "__mode"); /** hooktable.__mode = "k" */ + lua_pushvalue(L, -1); + lua_setmetatable(L, -2); /* setmetatable(hooktable) = hooktable */ + } + lua_pushthread(L1); lua_xmove(L1, L, 1); + lua_pushvalue(L, arg+1); + lua_rawset(L, -3); /* set new hook */ + lua_sethook(L1, func, mask, count); /* set hooks */ + return 0; +} + + +static int db_gethook (lua_State *L) { + int arg; + lua_State *L1 = getthread(L, &arg); + char buff[5]; + int mask = lua_gethookmask(L1); + lua_Hook hook = lua_gethook(L1); + if (hook != NULL && hook != hookf) /* external hook? */ + lua_pushliteral(L, "external hook"); + else { + gethooktable(L); + lua_pushthread(L1); lua_xmove(L1, L, 1); + lua_rawget(L, -2); /* get hook */ + lua_remove(L, -2); /* remove hook table */ + } + lua_pushstring(L, unmakemask(mask, buff)); + lua_pushinteger(L, lua_gethookcount(L1)); + return 3; +} + + +static int db_debug (lua_State *L) { + for (;;) { + char buffer[250]; + luai_writestringerror("%s", "lua_debug> "); + if (fgets(buffer, sizeof(buffer), stdin) == 0 || + strcmp(buffer, "cont\n") == 0) + return 0; + if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") || + lua_pcall(L, 0, 0, 0)) + luai_writestringerror("%s\n", lua_tostring(L, -1)); + lua_settop(L, 0); /* remove eventual returns */ + } +} + + +static int db_traceback (lua_State *L) { + int arg; + lua_State *L1 = getthread(L, &arg); + const char *msg = lua_tostring(L, arg + 1); + if (msg == NULL && !lua_isnoneornil(L, arg + 1)) /* non-string 'msg'? */ + lua_pushvalue(L, arg + 1); /* return it untouched */ + else { + int level = luaL_optint(L, arg + 2, (L == L1) ? 1 : 0); + luaL_traceback(L, L1, msg, level); + } + return 1; +} + + +static const luaL_Reg dblib[] = { + {"debug", db_debug}, + {"getuservalue", db_getuservalue}, + {"gethook", db_gethook}, + {"getinfo", db_getinfo}, + {"getlocal", db_getlocal}, + {"getregistry", db_getregistry}, + {"getmetatable", db_getmetatable}, + {"getupvalue", db_getupvalue}, + {"upvaluejoin", db_upvaluejoin}, + {"upvalueid", db_upvalueid}, + {"setuservalue", db_setuservalue}, + {"sethook", db_sethook}, + {"setlocal", db_setlocal}, + {"setmetatable", db_setmetatable}, + {"setupvalue", db_setupvalue}, + {"traceback", db_traceback}, + {NULL, NULL} +}; + + +LUAMOD_API int luaopen_debug (lua_State *L) { + luaL_newlib(L, dblib); + return 1; +} + diff --git a/extern/lua/src/ldblib.o b/extern/lua/src/ldblib.o new file mode 100644 index 0000000000000000000000000000000000000000..e293486836be613b53dffa9f4111989e879b60d4 GIT binary patch literal 17048 zcmeI2eUMbumB8P0gNzLJv__GvROqZj90VuRD^XBGx?zTCVH9*2&>##wJ>4@cJ>9e2 zuW{J82C8R_T{r~G#AVlHL#k4SklhVcYy4o{Nec+;R|P58xU3t@s*x`RHW66AX3shI zobEG^c~*9}YX90>_4>X0yXT&B?ztcD_U-;=bL&D+Rh1>F%9>|YazZWZ+~t+$5Iu&h zi!GlODV(Ste*NiFBS#QEg;gVkz14earwx!)cv*Y#gSKH0^5RD%wCe)M43lK>@Xf`& z1P9-1D*n4bJ4h^2+!riG2G7`+M~a7u6yJxZv#-(fP;=GFRpGn#BxY1H z4=)QBf8X9#d=2^|T>R(A#uE>KF%qSoX)68}{E8HxBV=;)7=aGLFo@TK@7;G{?GsIP zv*$i{pP%eDQU4g>je8#e+2RrGqwuQocxci9}NMCyXc3 zP>Ji+pkmiJu*E%n7(Aa0j01l-EF-LxpD!Y$z0$8{h?wv<7vC%%10SA7Sn+CQu!Mtc z%NX(9q2pWe3#yk#Ior!uOYEd&TiV;88zRsR#j`k-B6ELd&)Q|W@7GidXH$ecTDfZY zQ)t&wR1AaF%r8(#lw^lLG2x`l@#ku%g{;y36wXbsFLU}p^9S{yS*pt3VSR{q_!*qA z;O8eWR&a5M6yG}fkASfJ7jOsg>(=6Le)m}Iz%j}lYTD$96n2jb4{aFv^wUqnXAd-e zu{3=HB>SD>vmhNQo_zMG|0f$ZfRd(XBSVWkk=mwLtkTn@t#HWO3=@CGA#!H0l%LWZ zd>%;f`QX9e8K}$L4h9bnLyKVq85G&{RZ;-M3GcxY2{NVUO7+O5i%@1)4SZ0`sU_!C zh-|tH#fCqG4+&gkuv9zfMY|jKVmyK+T8Jo)*qCZ$?eDJVuJI zuf#bKvH((VQ!gKeF2n%}q^plY$4qqoKYkjB+e%a0Jq5++P&T!)($QvMML6|@j&0bT%NI@?^YxMfEBD@^eNQwFs)2QjtD31E5=%81% zo3DpX8|w2=e+1tn{WqHk(2A;Rpgeb*Y36VYoNFzfyt%kPEDabe4QCAv)qdA3!^LC6 zDT4|xcyRnRA0soxV}%#SnSAr$NbTmAL8$O@br`3oW!5TuIZF^>F3laah8q!FRz!p+ zlnFX5EmG22e3xv>@+A3k&+tHml?2xzl5HxUE*@(wzAv({noTj&CA=!UI^40x^hD_86oF)SK-_R6<=!y9s&jA=sX>!p&G@5USnF!1RrUtPR(XoT)_3&#rTk_I zn8oWw2ojiy6!((@Fxq6pip%=I_b`04tEnBpxxWi{E#f)V2%p(oW%tm6wXdnpA2Z9- z(5+Qa;IStac317I%0^-@M5<1Q3vZ9JFCvnP#12M=CQaT~RdHP=CM-CyQ^uRZ-oR71 z5iYM^WCz!R)5m{+`xi4`^*cu9i*uQTo>V(k{mMBymsa-;V8?22BaO5v{(!z%mN!u{ z6h## zG?nZMBj|YRH)kbt>);{VZKb2Varz+nWX_HzQ?Y0&WksRs&xHr@@!v+MD> zH*QC%pD@GSV)6a%OfoIc$u29W^+SgA!`{6+N(Io% zF0fke>sf*Bj2%cNyL;?%A&LM0$NzN%S{5w0AyD5G?@UJ1f!Pgn8-mvaXU{NC;LD}# zPt~8@ZdLXBtFD+dp?V8!2$4_avMG3P^7-3*)z&O{oXs3J_11i!|3OdKH|2is0$-po z&U42^-;}V=Ki^l~f?q|kZWqcy`aFI>S;2#vEDKkj4RB$aXl^9`9e!Sfcarx+umbwC zlgkDwW!)2f)e*Ec2d)EL-j8?iZOAjBU89BHA_L)o2+Zv==hM|yIs^bn6(;m>wDq-0(U!W?mhC9ji;gwHoWSr27DV>4V}51MW7*{ zP9@jIQ|qmUYzE7)cCaBhIy(olsKSU?4Y)0U7qHck&e-vWmRsAefj2C?cZ^iLry~Kc z<2ZTszy1h-1`I784eAu)%;Z{4&Dy2O6_CNOg*1fc{uu^r{hYa@8nlCB9TToQm@wAJ zxyukyTJEqb9A$OFH41h9PwNMv?pW>rL+yvS{-3~IC#gS~=b@B||8idf1^Dc&-*>U8 zF;gn?UE(M8W5Ds*Va6(P{iPzv^+SA@+iG|itN;A;T?P7)1B=~(w#B~m-&$a30_Unu ze(v`#Xb8{Zj@)g-5O^C1`JKE#5IbL3xK0tki3bKTkdGhdfHZ#2NQc$OBx1_F(W_$9x-e z+H1ix&L@;FF-N_UyyvZUmKB0Rls~{iv`64)uZ6$#jZRA;Oa5>u2Do?)^PSB5nd3Y` z`9|(++G_#Ba^!u?X`cb?Tg?63xwM}GhVL|#4>6~`6tL~gw=t)E6R@Y4zsa2TOTeCG z?&mI$_P)q`4Ri75b>0e*qd-UZl6=1YC>0EynkaQ^@z;a*jq4X{t8TJSz$9^$;8@4E1_F5C;R{IUA$b1uBjg@4(F&jo%7ya7(}`vt#8 zU}|xZw^Ci5sbptE%Se7~IVL5Vu=GjgNLDhGosTRx_Y^~7UqNf-@qEjVke zWatpmD6Oc0Bh08x-|qOh)(BLNKOtW}6t#Omnp9TKBB8u|a%rCFG!s7(+*EU{X%y2D zs(CES;c0HJ;o9r3n+p{nMiw4e_vLdv<^UFQtsT_7WZI5*$Fo?@#9rSQCvkP=Dz)L8 zZZh3XrO7nJ$)-mY;EI}PdOa12y4DUjWsYaF8M1{9v@?BDy%IdMg!;;zfB-z9M&fg& z8!(4WqN7jMD#L!Myi9`ylT8VqINgK}c?JhXa zPJrqhSL2ZZwp%-JAnA^(j1_K z^d3+|p1_@k6y2;4~k8b1?w|bE-vTzB7|a z#iQ^m0=tt?qYd0eCwikf6IITaWwjq%W`2i2WzZO4BwOy6OkX_Bvk*jDF>E+wa=6~e z_X>Dz(f2d>3j?JuV<9Bub#Mu9LI?>tenk_02SP~5aV-;mH$q6ruYybXI)spr{A##_A3_KT`AoQkA3+ES+lQAV+`nT&c|3a&c@ON%Fd@GNF5$I` z<98V0S1YdVh85TGxm9s3-=(;g|5L@aKldq)eI))o#2nj--}5E?wUXEEeO__hzi%k6 z{drgMD?z!~J;_|+JedujRq~BW{z42eB$1czyO%O|_RFn`<5`#3y;E`gt}Og9#jjQT zNf%yXF8;{4e_6@vxV^17eg_u2r(N`Xs^qnvKZ1P+CM>=hF41$9;$KnxTE(wZe3jzY zD_&ImO2r>he6Hd<6xZVu_g|RMPi^-V#czNz@xKc8FPJ2rx0$T9#KBiEU(Fo#-w2oJ zS*JLj1qd%Hjz@gLwv==*kdl8(@%f6MQhb5pe>@&CkTCwb-v<@fasH9w=)3s& zxZ(>H|5wGe{`VEXQpwlxISl$!r}(vswt-K@BN zulviBi71!~(bb_geakv>SiStawrz?Jw;?0ULQGAi&F&F*~7rvD_ zwhMidbFuF$j%DA33)2pzXEEf(|G#(050bQH{ezOfO39ZT^50_lmzDe+C4We9J+9tW zT))RpD&DH}j3}m}gyruXO#YYs^ahS;GoY>y0l>Ft2>-fxJj_txr=0!-!>v?gT;#$vY#kHSF z#kD^JitG2+$p?o8A}AP`nMw zME`Y)FH*c!aoyhAnBxtvJ#b-Kt>pE5xm$6qC&L_Xc)fs1Al=Ix{nvVmiZ6pQ@qaUO zyy5jKT$mnJ@>O&E+wz^>{nd3>m}xR!|N0(f%Gp*UhDa-;)_5| z+I3EG?dK=V@rIXt-Q-R6xaG2n2Ub=-2u~$N?!Xp z;?Q#e>-oBio^Hk4L6`WMa_I4~p7lyz`*XkIy1iQ!*ZuW(^dC}O?=w#*uGjyM z71!^hNf#MI7*D;du}spNH>ON#4w{zh>QNR4|zCm%6$KQ)FJz#ES{e2wBEsCT3_gH?b;;3KJHhw@cl;6(s z+Z9K7`QO7%#Zms}EdP|^C|}~d+(mzh<^PGxF^lr@e~SZ(qyCpz{&mGsUjDc7rs637 z8p|J19OVPdPbrS_Z!tfoILgcaCn&&>M=_K?&hpiK#~aGa|1jkL4I(f9ah>9jmv)L@ zB40(yD*y8p{oBw6Bzb>|{3Mp2BA0dGZya3K6Y&>i@sjuZlyQ)OB>WVw%l`%P C_Uz06 literal 0 HcmV?d00001 diff --git a/extern/lua/src/ldebug.c b/extern/lua/src/ldebug.c new file mode 100644 index 0000000..20d663e --- /dev/null +++ b/extern/lua/src/ldebug.c @@ -0,0 +1,593 @@ +/* +** $Id: ldebug.c,v 2.90.1.3 2013/05/16 16:04:15 roberto Exp $ +** Debug Interface +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include + + +#define ldebug_c +#define LUA_CORE + +#include "lua.h" + +#include "lapi.h" +#include "lcode.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lvm.h" + + + +#define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_TCCL) + + +static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name); + + +static int currentpc (CallInfo *ci) { + lua_assert(isLua(ci)); + return pcRel(ci->u.l.savedpc, ci_func(ci)->p); +} + + +static int currentline (CallInfo *ci) { + return getfuncline(ci_func(ci)->p, currentpc(ci)); +} + + +/* +** this function can be called asynchronous (e.g. during a signal) +*/ +LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) { + if (func == NULL || mask == 0) { /* turn off hooks? */ + mask = 0; + func = NULL; + } + if (isLua(L->ci)) + L->oldpc = L->ci->u.l.savedpc; + L->hook = func; + L->basehookcount = count; + resethookcount(L); + L->hookmask = cast_byte(mask); + return 1; +} + + +LUA_API lua_Hook lua_gethook (lua_State *L) { + return L->hook; +} + + +LUA_API int lua_gethookmask (lua_State *L) { + return L->hookmask; +} + + +LUA_API int lua_gethookcount (lua_State *L) { + return L->basehookcount; +} + + +LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) { + int status; + CallInfo *ci; + if (level < 0) return 0; /* invalid (negative) level */ + lua_lock(L); + for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous) + level--; + if (level == 0 && ci != &L->base_ci) { /* level found? */ + status = 1; + ar->i_ci = ci; + } + else status = 0; /* no such level */ + lua_unlock(L); + return status; +} + + +static const char *upvalname (Proto *p, int uv) { + TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name); + if (s == NULL) return "?"; + else return getstr(s); +} + + +static const char *findvararg (CallInfo *ci, int n, StkId *pos) { + int nparams = clLvalue(ci->func)->p->numparams; + if (n >= ci->u.l.base - ci->func - nparams) + return NULL; /* no such vararg */ + else { + *pos = ci->func + nparams + n; + return "(*vararg)"; /* generic name for any vararg */ + } +} + + +static const char *findlocal (lua_State *L, CallInfo *ci, int n, + StkId *pos) { + const char *name = NULL; + StkId base; + if (isLua(ci)) { + if (n < 0) /* access to vararg values? */ + return findvararg(ci, -n, pos); + else { + base = ci->u.l.base; + name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci)); + } + } + else + base = ci->func + 1; + if (name == NULL) { /* no 'standard' name? */ + StkId limit = (ci == L->ci) ? L->top : ci->next->func; + if (limit - base >= n && n > 0) /* is 'n' inside 'ci' stack? */ + name = "(*temporary)"; /* generic name for any valid slot */ + else + return NULL; /* no name */ + } + *pos = base + (n - 1); + return name; +} + + +LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) { + const char *name; + lua_lock(L); + if (ar == NULL) { /* information about non-active function? */ + if (!isLfunction(L->top - 1)) /* not a Lua function? */ + name = NULL; + else /* consider live variables at function start (parameters) */ + name = luaF_getlocalname(clLvalue(L->top - 1)->p, n, 0); + } + else { /* active function; get information through 'ar' */ + StkId pos = 0; /* to avoid warnings */ + name = findlocal(L, ar->i_ci, n, &pos); + if (name) { + setobj2s(L, L->top, pos); + api_incr_top(L); + } + } + lua_unlock(L); + return name; +} + + +LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) { + StkId pos = 0; /* to avoid warnings */ + const char *name = findlocal(L, ar->i_ci, n, &pos); + lua_lock(L); + if (name) + setobjs2s(L, pos, L->top - 1); + L->top--; /* pop value */ + lua_unlock(L); + return name; +} + + +static void funcinfo (lua_Debug *ar, Closure *cl) { + if (noLuaClosure(cl)) { + ar->source = "=[C]"; + ar->linedefined = -1; + ar->lastlinedefined = -1; + ar->what = "C"; + } + else { + Proto *p = cl->l.p; + ar->source = p->source ? getstr(p->source) : "=?"; + ar->linedefined = p->linedefined; + ar->lastlinedefined = p->lastlinedefined; + ar->what = (ar->linedefined == 0) ? "main" : "Lua"; + } + luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE); +} + + +static void collectvalidlines (lua_State *L, Closure *f) { + if (noLuaClosure(f)) { + setnilvalue(L->top); + api_incr_top(L); + } + else { + int i; + TValue v; + int *lineinfo = f->l.p->lineinfo; + Table *t = luaH_new(L); /* new table to store active lines */ + sethvalue(L, L->top, t); /* push it on stack */ + api_incr_top(L); + setbvalue(&v, 1); /* boolean 'true' to be the value of all indices */ + for (i = 0; i < f->l.p->sizelineinfo; i++) /* for all lines with code */ + luaH_setint(L, t, lineinfo[i], &v); /* table[line] = true */ + } +} + + +static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar, + Closure *f, CallInfo *ci) { + int status = 1; + for (; *what; what++) { + switch (*what) { + case 'S': { + funcinfo(ar, f); + break; + } + case 'l': { + ar->currentline = (ci && isLua(ci)) ? currentline(ci) : -1; + break; + } + case 'u': { + ar->nups = (f == NULL) ? 0 : f->c.nupvalues; + if (noLuaClosure(f)) { + ar->isvararg = 1; + ar->nparams = 0; + } + else { + ar->isvararg = f->l.p->is_vararg; + ar->nparams = f->l.p->numparams; + } + break; + } + case 't': { + ar->istailcall = (ci) ? ci->callstatus & CIST_TAIL : 0; + break; + } + case 'n': { + /* calling function is a known Lua function? */ + if (ci && !(ci->callstatus & CIST_TAIL) && isLua(ci->previous)) + ar->namewhat = getfuncname(L, ci->previous, &ar->name); + else + ar->namewhat = NULL; + if (ar->namewhat == NULL) { + ar->namewhat = ""; /* not found */ + ar->name = NULL; + } + break; + } + case 'L': + case 'f': /* handled by lua_getinfo */ + break; + default: status = 0; /* invalid option */ + } + } + return status; +} + + +LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { + int status; + Closure *cl; + CallInfo *ci; + StkId func; + lua_lock(L); + if (*what == '>') { + ci = NULL; + func = L->top - 1; + api_check(L, ttisfunction(func), "function expected"); + what++; /* skip the '>' */ + L->top--; /* pop function */ + } + else { + ci = ar->i_ci; + func = ci->func; + lua_assert(ttisfunction(ci->func)); + } + cl = ttisclosure(func) ? clvalue(func) : NULL; + status = auxgetinfo(L, what, ar, cl, ci); + if (strchr(what, 'f')) { + setobjs2s(L, L->top, func); + api_incr_top(L); + } + if (strchr(what, 'L')) + collectvalidlines(L, cl); + lua_unlock(L); + return status; +} + + +/* +** {====================================================== +** Symbolic Execution +** ======================================================= +*/ + +static const char *getobjname (Proto *p, int lastpc, int reg, + const char **name); + + +/* +** find a "name" for the RK value 'c' +*/ +static void kname (Proto *p, int pc, int c, const char **name) { + if (ISK(c)) { /* is 'c' a constant? */ + TValue *kvalue = &p->k[INDEXK(c)]; + if (ttisstring(kvalue)) { /* literal constant? */ + *name = svalue(kvalue); /* it is its own name */ + return; + } + /* else no reasonable name found */ + } + else { /* 'c' is a register */ + const char *what = getobjname(p, pc, c, name); /* search for 'c' */ + if (what && *what == 'c') { /* found a constant name? */ + return; /* 'name' already filled */ + } + /* else no reasonable name found */ + } + *name = "?"; /* no reasonable name found */ +} + + +static int filterpc (int pc, int jmptarget) { + if (pc < jmptarget) /* is code conditional (inside a jump)? */ + return -1; /* cannot know who sets that register */ + else return pc; /* current position sets that register */ +} + + +/* +** try to find last instruction before 'lastpc' that modified register 'reg' +*/ +static int findsetreg (Proto *p, int lastpc, int reg) { + int pc; + int setreg = -1; /* keep last instruction that changed 'reg' */ + int jmptarget = 0; /* any code before this address is conditional */ + for (pc = 0; pc < lastpc; pc++) { + Instruction i = p->code[pc]; + OpCode op = GET_OPCODE(i); + int a = GETARG_A(i); + switch (op) { + case OP_LOADNIL: { + int b = GETARG_B(i); + if (a <= reg && reg <= a + b) /* set registers from 'a' to 'a+b' */ + setreg = filterpc(pc, jmptarget); + break; + } + case OP_TFORCALL: { + if (reg >= a + 2) /* affect all regs above its base */ + setreg = filterpc(pc, jmptarget); + break; + } + case OP_CALL: + case OP_TAILCALL: { + if (reg >= a) /* affect all registers above base */ + setreg = filterpc(pc, jmptarget); + break; + } + case OP_JMP: { + int b = GETARG_sBx(i); + int dest = pc + 1 + b; + /* jump is forward and do not skip `lastpc'? */ + if (pc < dest && dest <= lastpc) { + if (dest > jmptarget) + jmptarget = dest; /* update 'jmptarget' */ + } + break; + } + case OP_TEST: { + if (reg == a) /* jumped code can change 'a' */ + setreg = filterpc(pc, jmptarget); + break; + } + default: + if (testAMode(op) && reg == a) /* any instruction that set A */ + setreg = filterpc(pc, jmptarget); + break; + } + } + return setreg; +} + + +static const char *getobjname (Proto *p, int lastpc, int reg, + const char **name) { + int pc; + *name = luaF_getlocalname(p, reg + 1, lastpc); + if (*name) /* is a local? */ + return "local"; + /* else try symbolic execution */ + pc = findsetreg(p, lastpc, reg); + if (pc != -1) { /* could find instruction? */ + Instruction i = p->code[pc]; + OpCode op = GET_OPCODE(i); + switch (op) { + case OP_MOVE: { + int b = GETARG_B(i); /* move from 'b' to 'a' */ + if (b < GETARG_A(i)) + return getobjname(p, pc, b, name); /* get name for 'b' */ + break; + } + case OP_GETTABUP: + case OP_GETTABLE: { + int k = GETARG_C(i); /* key index */ + int t = GETARG_B(i); /* table index */ + const char *vn = (op == OP_GETTABLE) /* name of indexed variable */ + ? luaF_getlocalname(p, t + 1, pc) + : upvalname(p, t); + kname(p, pc, k, name); + return (vn && strcmp(vn, LUA_ENV) == 0) ? "global" : "field"; + } + case OP_GETUPVAL: { + *name = upvalname(p, GETARG_B(i)); + return "upvalue"; + } + case OP_LOADK: + case OP_LOADKX: { + int b = (op == OP_LOADK) ? GETARG_Bx(i) + : GETARG_Ax(p->code[pc + 1]); + if (ttisstring(&p->k[b])) { + *name = svalue(&p->k[b]); + return "constant"; + } + break; + } + case OP_SELF: { + int k = GETARG_C(i); /* key index */ + kname(p, pc, k, name); + return "method"; + } + default: break; /* go through to return NULL */ + } + } + return NULL; /* could not find reasonable name */ +} + + +static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) { + TMS tm; + Proto *p = ci_func(ci)->p; /* calling function */ + int pc = currentpc(ci); /* calling instruction index */ + Instruction i = p->code[pc]; /* calling instruction */ + switch (GET_OPCODE(i)) { + case OP_CALL: + case OP_TAILCALL: /* get function name */ + return getobjname(p, pc, GETARG_A(i), name); + case OP_TFORCALL: { /* for iterator */ + *name = "for iterator"; + return "for iterator"; + } + /* all other instructions can call only through metamethods */ + case OP_SELF: + case OP_GETTABUP: + case OP_GETTABLE: tm = TM_INDEX; break; + case OP_SETTABUP: + case OP_SETTABLE: tm = TM_NEWINDEX; break; + case OP_EQ: tm = TM_EQ; break; + case OP_ADD: tm = TM_ADD; break; + case OP_SUB: tm = TM_SUB; break; + case OP_MUL: tm = TM_MUL; break; + case OP_DIV: tm = TM_DIV; break; + case OP_MOD: tm = TM_MOD; break; + case OP_POW: tm = TM_POW; break; + case OP_UNM: tm = TM_UNM; break; + case OP_LEN: tm = TM_LEN; break; + case OP_LT: tm = TM_LT; break; + case OP_LE: tm = TM_LE; break; + case OP_CONCAT: tm = TM_CONCAT; break; + default: + return NULL; /* else no useful name can be found */ + } + *name = getstr(G(L)->tmname[tm]); + return "metamethod"; +} + +/* }====================================================== */ + + + +/* +** only ANSI way to check whether a pointer points to an array +** (used only for error messages, so efficiency is not a big concern) +*/ +static int isinstack (CallInfo *ci, const TValue *o) { + StkId p; + for (p = ci->u.l.base; p < ci->top; p++) + if (o == p) return 1; + return 0; +} + + +static const char *getupvalname (CallInfo *ci, const TValue *o, + const char **name) { + LClosure *c = ci_func(ci); + int i; + for (i = 0; i < c->nupvalues; i++) { + if (c->upvals[i]->v == o) { + *name = upvalname(c->p, i); + return "upvalue"; + } + } + return NULL; +} + + +l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) { + CallInfo *ci = L->ci; + const char *name = NULL; + const char *t = objtypename(o); + const char *kind = NULL; + if (isLua(ci)) { + kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */ + if (!kind && isinstack(ci, o)) /* no? try a register */ + kind = getobjname(ci_func(ci)->p, currentpc(ci), + cast_int(o - ci->u.l.base), &name); + } + if (kind) + luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)", + op, kind, name, t); + else + luaG_runerror(L, "attempt to %s a %s value", op, t); +} + + +l_noret luaG_concaterror (lua_State *L, StkId p1, StkId p2) { + if (ttisstring(p1) || ttisnumber(p1)) p1 = p2; + lua_assert(!ttisstring(p1) && !ttisnumber(p1)); + luaG_typeerror(L, p1, "concatenate"); +} + + +l_noret luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) { + TValue temp; + if (luaV_tonumber(p1, &temp) == NULL) + p2 = p1; /* first operand is wrong */ + luaG_typeerror(L, p2, "perform arithmetic on"); +} + + +l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) { + const char *t1 = objtypename(p1); + const char *t2 = objtypename(p2); + if (t1 == t2) + luaG_runerror(L, "attempt to compare two %s values", t1); + else + luaG_runerror(L, "attempt to compare %s with %s", t1, t2); +} + + +static void addinfo (lua_State *L, const char *msg) { + CallInfo *ci = L->ci; + if (isLua(ci)) { /* is Lua code? */ + char buff[LUA_IDSIZE]; /* add file:line information */ + int line = currentline(ci); + TString *src = ci_func(ci)->p->source; + if (src) + luaO_chunkid(buff, getstr(src), LUA_IDSIZE); + else { /* no source available; use "?" instead */ + buff[0] = '?'; buff[1] = '\0'; + } + luaO_pushfstring(L, "%s:%d: %s", buff, line, msg); + } +} + + +l_noret luaG_errormsg (lua_State *L) { + if (L->errfunc != 0) { /* is there an error handling function? */ + StkId errfunc = restorestack(L, L->errfunc); + if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR); + setobjs2s(L, L->top, L->top - 1); /* move argument */ + setobjs2s(L, L->top - 1, errfunc); /* push function */ + L->top++; + luaD_call(L, L->top - 2, 1, 0); /* call it */ + } + luaD_throw(L, LUA_ERRRUN); +} + + +l_noret luaG_runerror (lua_State *L, const char *fmt, ...) { + va_list argp; + va_start(argp, fmt); + addinfo(L, luaO_pushvfstring(L, fmt, argp)); + va_end(argp); + luaG_errormsg(L); +} + diff --git a/extern/lua/src/ldebug.h b/extern/lua/src/ldebug.h new file mode 100644 index 0000000..6445c76 --- /dev/null +++ b/extern/lua/src/ldebug.h @@ -0,0 +1,34 @@ +/* +** $Id: ldebug.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $ +** Auxiliary functions from Debug Interface module +** See Copyright Notice in lua.h +*/ + +#ifndef ldebug_h +#define ldebug_h + + +#include "lstate.h" + + +#define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1) + +#define getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : 0) + +#define resethookcount(L) (L->hookcount = L->basehookcount) + +/* Active Lua function (given call info) */ +#define ci_func(ci) (clLvalue((ci)->func)) + + +LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o, + const char *opname); +LUAI_FUNC l_noret luaG_concaterror (lua_State *L, StkId p1, StkId p2); +LUAI_FUNC l_noret luaG_aritherror (lua_State *L, const TValue *p1, + const TValue *p2); +LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1, + const TValue *p2); +LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...); +LUAI_FUNC l_noret luaG_errormsg (lua_State *L); + +#endif diff --git a/extern/lua/src/ldebug.o b/extern/lua/src/ldebug.o new file mode 100644 index 0000000000000000000000000000000000000000..b38a6069564714c5751a5d7753276356a2c954ea GIT binary patch literal 12968 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 literal 0 HcmV?d00001 diff --git a/extern/lua/src/ldo.c b/extern/lua/src/ldo.c new file mode 100644 index 0000000..e9dd5fa --- /dev/null +++ b/extern/lua/src/ldo.c @@ -0,0 +1,681 @@ +/* +** $Id: ldo.c,v 2.108.1.3 2013/11/08 18:22:50 roberto Exp $ +** Stack and Call structure of Lua +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include + +#define ldo_c +#define LUA_CORE + +#include "lua.h" + +#include "lapi.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lparser.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lundump.h" +#include "lvm.h" +#include "lzio.h" + + + + +/* +** {====================================================== +** Error-recovery functions +** ======================================================= +*/ + +/* +** LUAI_THROW/LUAI_TRY define how Lua does exception handling. By +** default, Lua handles errors with exceptions when compiling as +** C++ code, with _longjmp/_setjmp when asked to use them, and with +** longjmp/setjmp otherwise. +*/ +#if !defined(LUAI_THROW) + +#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP) +/* C++ exceptions */ +#define LUAI_THROW(L,c) throw(c) +#define LUAI_TRY(L,c,a) \ + try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; } +#define luai_jmpbuf int /* dummy variable */ + +#elif defined(LUA_USE_ULONGJMP) +/* in Unix, try _longjmp/_setjmp (more efficient) */ +#define LUAI_THROW(L,c) _longjmp((c)->b, 1) +#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a } +#define luai_jmpbuf jmp_buf + +#else +/* default handling with long jumps */ +#define LUAI_THROW(L,c) longjmp((c)->b, 1) +#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } +#define luai_jmpbuf jmp_buf + +#endif + +#endif + + + +/* chain list of long jump buffers */ +struct lua_longjmp { + struct lua_longjmp *previous; + luai_jmpbuf b; + volatile int status; /* error code */ +}; + + +static void seterrorobj (lua_State *L, int errcode, StkId oldtop) { + switch (errcode) { + case LUA_ERRMEM: { /* memory error? */ + setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */ + break; + } + case LUA_ERRERR: { + setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling")); + break; + } + default: { + setobjs2s(L, oldtop, L->top - 1); /* error message on current top */ + break; + } + } + L->top = oldtop + 1; +} + + +l_noret luaD_throw (lua_State *L, int errcode) { + if (L->errorJmp) { /* thread has an error handler? */ + L->errorJmp->status = errcode; /* set status */ + LUAI_THROW(L, L->errorJmp); /* jump to it */ + } + else { /* thread has no error handler */ + L->status = cast_byte(errcode); /* mark it as dead */ + if (G(L)->mainthread->errorJmp) { /* main thread has a handler? */ + setobjs2s(L, G(L)->mainthread->top++, L->top - 1); /* copy error obj. */ + luaD_throw(G(L)->mainthread, errcode); /* re-throw in main thread */ + } + else { /* no handler at all; abort */ + if (G(L)->panic) { /* panic function? */ + lua_unlock(L); + G(L)->panic(L); /* call it (last chance to jump out) */ + } + abort(); + } + } +} + + +int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) { + unsigned short oldnCcalls = L->nCcalls; + struct lua_longjmp lj; + lj.status = LUA_OK; + lj.previous = L->errorJmp; /* chain new error handler */ + L->errorJmp = &lj; + LUAI_TRY(L, &lj, + (*f)(L, ud); + ); + L->errorJmp = lj.previous; /* restore old error handler */ + L->nCcalls = oldnCcalls; + return lj.status; +} + +/* }====================================================== */ + + +static void correctstack (lua_State *L, TValue *oldstack) { + CallInfo *ci; + GCObject *up; + L->top = (L->top - oldstack) + L->stack; + for (up = L->openupval; up != NULL; up = up->gch.next) + gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack; + for (ci = L->ci; ci != NULL; ci = ci->previous) { + ci->top = (ci->top - oldstack) + L->stack; + ci->func = (ci->func - oldstack) + L->stack; + if (isLua(ci)) + ci->u.l.base = (ci->u.l.base - oldstack) + L->stack; + } +} + + +/* some space for error handling */ +#define ERRORSTACKSIZE (LUAI_MAXSTACK + 200) + + +void luaD_reallocstack (lua_State *L, int newsize) { + TValue *oldstack = L->stack; + int lim = L->stacksize; + lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE); + lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK); + luaM_reallocvector(L, L->stack, L->stacksize, newsize, TValue); + for (; lim < newsize; lim++) + setnilvalue(L->stack + lim); /* erase new segment */ + L->stacksize = newsize; + L->stack_last = L->stack + newsize - EXTRA_STACK; + correctstack(L, oldstack); +} + + +void luaD_growstack (lua_State *L, int n) { + int size = L->stacksize; + if (size > LUAI_MAXSTACK) /* error after extra size? */ + luaD_throw(L, LUA_ERRERR); + else { + int needed = cast_int(L->top - L->stack) + n + EXTRA_STACK; + int newsize = 2 * size; + if (newsize > LUAI_MAXSTACK) newsize = LUAI_MAXSTACK; + if (newsize < needed) newsize = needed; + if (newsize > LUAI_MAXSTACK) { /* stack overflow? */ + luaD_reallocstack(L, ERRORSTACKSIZE); + luaG_runerror(L, "stack overflow"); + } + else + luaD_reallocstack(L, newsize); + } +} + + +static int stackinuse (lua_State *L) { + CallInfo *ci; + StkId lim = L->top; + for (ci = L->ci; ci != NULL; ci = ci->previous) { + lua_assert(ci->top <= L->stack_last); + if (lim < ci->top) lim = ci->top; + } + return cast_int(lim - L->stack) + 1; /* part of stack in use */ +} + + +void luaD_shrinkstack (lua_State *L) { + int inuse = stackinuse(L); + int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK; + if (goodsize > LUAI_MAXSTACK) goodsize = LUAI_MAXSTACK; + if (inuse > LUAI_MAXSTACK || /* handling stack overflow? */ + goodsize >= L->stacksize) /* would grow instead of shrink? */ + condmovestack(L); /* don't change stack (change only for debugging) */ + else + luaD_reallocstack(L, goodsize); /* shrink it */ +} + + +void luaD_hook (lua_State *L, int event, int line) { + lua_Hook hook = L->hook; + if (hook && L->allowhook) { + CallInfo *ci = L->ci; + ptrdiff_t top = savestack(L, L->top); + ptrdiff_t ci_top = savestack(L, ci->top); + lua_Debug ar; + ar.event = event; + ar.currentline = line; + ar.i_ci = ci; + luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */ + ci->top = L->top + LUA_MINSTACK; + lua_assert(ci->top <= L->stack_last); + L->allowhook = 0; /* cannot call hooks inside a hook */ + ci->callstatus |= CIST_HOOKED; + lua_unlock(L); + (*hook)(L, &ar); + lua_lock(L); + lua_assert(!L->allowhook); + L->allowhook = 1; + ci->top = restorestack(L, ci_top); + L->top = restorestack(L, top); + ci->callstatus &= ~CIST_HOOKED; + } +} + + +static void callhook (lua_State *L, CallInfo *ci) { + int hook = LUA_HOOKCALL; + ci->u.l.savedpc++; /* hooks assume 'pc' is already incremented */ + if (isLua(ci->previous) && + GET_OPCODE(*(ci->previous->u.l.savedpc - 1)) == OP_TAILCALL) { + ci->callstatus |= CIST_TAIL; + hook = LUA_HOOKTAILCALL; + } + luaD_hook(L, hook, -1); + ci->u.l.savedpc--; /* correct 'pc' */ +} + + +static StkId adjust_varargs (lua_State *L, Proto *p, int actual) { + int i; + int nfixargs = p->numparams; + StkId base, fixed; + lua_assert(actual >= nfixargs); + /* move fixed parameters to final position */ + luaD_checkstack(L, p->maxstacksize); /* check again for new 'base' */ + fixed = L->top - actual; /* first fixed argument */ + base = L->top; /* final position of first argument */ + for (i=0; itop++, fixed + i); + setnilvalue(fixed + i); + } + return base; +} + + +static StkId tryfuncTM (lua_State *L, StkId func) { + const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL); + StkId p; + ptrdiff_t funcr = savestack(L, func); + if (!ttisfunction(tm)) + luaG_typeerror(L, func, "call"); + /* Open a hole inside the stack at `func' */ + for (p = L->top; p > func; p--) setobjs2s(L, p, p-1); + incr_top(L); + func = restorestack(L, funcr); /* previous call may change stack */ + setobj2s(L, func, tm); /* tag method is the new function to be called */ + return func; +} + + + +#define next_ci(L) (L->ci = (L->ci->next ? L->ci->next : luaE_extendCI(L))) + + +/* +** returns true if function has been executed (C function) +*/ +int luaD_precall (lua_State *L, StkId func, int nresults) { + lua_CFunction f; + CallInfo *ci; + int n; /* number of arguments (Lua) or returns (C) */ + ptrdiff_t funcr = savestack(L, func); + switch (ttype(func)) { + case LUA_TLCF: /* light C function */ + f = fvalue(func); + goto Cfunc; + case LUA_TCCL: { /* C closure */ + f = clCvalue(func)->f; + Cfunc: + luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */ + ci = next_ci(L); /* now 'enter' new function */ + ci->nresults = nresults; + ci->func = restorestack(L, funcr); + ci->top = L->top + LUA_MINSTACK; + lua_assert(ci->top <= L->stack_last); + ci->callstatus = 0; + luaC_checkGC(L); /* stack grow uses memory */ + if (L->hookmask & LUA_MASKCALL) + luaD_hook(L, LUA_HOOKCALL, -1); + lua_unlock(L); + n = (*f)(L); /* do the actual call */ + lua_lock(L); + api_checknelems(L, n); + luaD_poscall(L, L->top - n); + return 1; + } + case LUA_TLCL: { /* Lua function: prepare its call */ + StkId base; + Proto *p = clLvalue(func)->p; + n = cast_int(L->top - func) - 1; /* number of real arguments */ + luaD_checkstack(L, p->maxstacksize); + for (; n < p->numparams; n++) + setnilvalue(L->top++); /* complete missing arguments */ + if (!p->is_vararg) { + func = restorestack(L, funcr); + base = func + 1; + } + else { + base = adjust_varargs(L, p, n); + func = restorestack(L, funcr); /* previous call can change stack */ + } + ci = next_ci(L); /* now 'enter' new function */ + ci->nresults = nresults; + ci->func = func; + ci->u.l.base = base; + ci->top = base + p->maxstacksize; + lua_assert(ci->top <= L->stack_last); + ci->u.l.savedpc = p->code; /* starting point */ + ci->callstatus = CIST_LUA; + L->top = ci->top; + luaC_checkGC(L); /* stack grow uses memory */ + if (L->hookmask & LUA_MASKCALL) + callhook(L, ci); + return 0; + } + default: { /* not a function */ + func = tryfuncTM(L, func); /* retry with 'function' tag method */ + return luaD_precall(L, func, nresults); /* now it must be a function */ + } + } +} + + +int luaD_poscall (lua_State *L, StkId firstResult) { + StkId res; + int wanted, i; + CallInfo *ci = L->ci; + if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) { + if (L->hookmask & LUA_MASKRET) { + ptrdiff_t fr = savestack(L, firstResult); /* hook may change stack */ + luaD_hook(L, LUA_HOOKRET, -1); + firstResult = restorestack(L, fr); + } + L->oldpc = ci->previous->u.l.savedpc; /* 'oldpc' for caller function */ + } + res = ci->func; /* res == final position of 1st result */ + wanted = ci->nresults; + L->ci = ci = ci->previous; /* back to caller */ + /* move results to correct place */ + for (i = wanted; i != 0 && firstResult < L->top; i--) + setobjs2s(L, res++, firstResult++); + while (i-- > 0) + setnilvalue(res++); + L->top = res; + return (wanted - LUA_MULTRET); /* 0 iff wanted == LUA_MULTRET */ +} + + +/* +** Call a function (C or Lua). The function to be called is at *func. +** The arguments are on the stack, right after the function. +** When returns, all the results are on the stack, starting at the original +** function position. +*/ +void luaD_call (lua_State *L, StkId func, int nResults, int allowyield) { + if (++L->nCcalls >= LUAI_MAXCCALLS) { + if (L->nCcalls == LUAI_MAXCCALLS) + luaG_runerror(L, "C stack overflow"); + else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3))) + luaD_throw(L, LUA_ERRERR); /* error while handing stack error */ + } + if (!allowyield) L->nny++; + if (!luaD_precall(L, func, nResults)) /* is a Lua function? */ + luaV_execute(L); /* call it */ + if (!allowyield) L->nny--; + L->nCcalls--; +} + + +static void finishCcall (lua_State *L) { + CallInfo *ci = L->ci; + int n; + lua_assert(ci->u.c.k != NULL); /* must have a continuation */ + lua_assert(L->nny == 0); + if (ci->callstatus & CIST_YPCALL) { /* was inside a pcall? */ + ci->callstatus &= ~CIST_YPCALL; /* finish 'lua_pcall' */ + L->errfunc = ci->u.c.old_errfunc; + } + /* finish 'lua_callk'/'lua_pcall' */ + adjustresults(L, ci->nresults); + /* call continuation function */ + if (!(ci->callstatus & CIST_STAT)) /* no call status? */ + ci->u.c.status = LUA_YIELD; /* 'default' status */ + lua_assert(ci->u.c.status != LUA_OK); + ci->callstatus = (ci->callstatus & ~(CIST_YPCALL | CIST_STAT)) | CIST_YIELDED; + lua_unlock(L); + n = (*ci->u.c.k)(L); + lua_lock(L); + api_checknelems(L, n); + /* finish 'luaD_precall' */ + luaD_poscall(L, L->top - n); +} + + +static void unroll (lua_State *L, void *ud) { + UNUSED(ud); + for (;;) { + if (L->ci == &L->base_ci) /* stack is empty? */ + return; /* coroutine finished normally */ + if (!isLua(L->ci)) /* C function? */ + finishCcall(L); + else { /* Lua function */ + luaV_finishOp(L); /* finish interrupted instruction */ + luaV_execute(L); /* execute down to higher C 'boundary' */ + } + } +} + + +/* +** check whether thread has a suspended protected call +*/ +static CallInfo *findpcall (lua_State *L) { + CallInfo *ci; + for (ci = L->ci; ci != NULL; ci = ci->previous) { /* search for a pcall */ + if (ci->callstatus & CIST_YPCALL) + return ci; + } + return NULL; /* no pending pcall */ +} + + +static int recover (lua_State *L, int status) { + StkId oldtop; + CallInfo *ci = findpcall(L); + if (ci == NULL) return 0; /* no recovery point */ + /* "finish" luaD_pcall */ + oldtop = restorestack(L, ci->extra); + luaF_close(L, oldtop); + seterrorobj(L, status, oldtop); + L->ci = ci; + L->allowhook = ci->u.c.old_allowhook; + L->nny = 0; /* should be zero to be yieldable */ + luaD_shrinkstack(L); + L->errfunc = ci->u.c.old_errfunc; + ci->callstatus |= CIST_STAT; /* call has error status */ + ci->u.c.status = status; /* (here it is) */ + return 1; /* continue running the coroutine */ +} + + +/* +** signal an error in the call to 'resume', not in the execution of the +** coroutine itself. (Such errors should not be handled by any coroutine +** error handler and should not kill the coroutine.) +*/ +static l_noret resume_error (lua_State *L, const char *msg, StkId firstArg) { + L->top = firstArg; /* remove args from the stack */ + setsvalue2s(L, L->top, luaS_new(L, msg)); /* push error message */ + api_incr_top(L); + luaD_throw(L, -1); /* jump back to 'lua_resume' */ +} + + +/* +** do the work for 'lua_resume' in protected mode +*/ +static void resume (lua_State *L, void *ud) { + int nCcalls = L->nCcalls; + StkId firstArg = cast(StkId, ud); + CallInfo *ci = L->ci; + if (nCcalls >= LUAI_MAXCCALLS) + resume_error(L, "C stack overflow", firstArg); + if (L->status == LUA_OK) { /* may be starting a coroutine */ + if (ci != &L->base_ci) /* not in base level? */ + resume_error(L, "cannot resume non-suspended coroutine", firstArg); + /* coroutine is in base level; start running it */ + if (!luaD_precall(L, firstArg - 1, LUA_MULTRET)) /* Lua function? */ + luaV_execute(L); /* call it */ + } + else if (L->status != LUA_YIELD) + resume_error(L, "cannot resume dead coroutine", firstArg); + else { /* resuming from previous yield */ + L->status = LUA_OK; + ci->func = restorestack(L, ci->extra); + if (isLua(ci)) /* yielded inside a hook? */ + luaV_execute(L); /* just continue running Lua code */ + else { /* 'common' yield */ + if (ci->u.c.k != NULL) { /* does it have a continuation? */ + int n; + ci->u.c.status = LUA_YIELD; /* 'default' status */ + ci->callstatus |= CIST_YIELDED; + lua_unlock(L); + n = (*ci->u.c.k)(L); /* call continuation */ + lua_lock(L); + api_checknelems(L, n); + firstArg = L->top - n; /* yield results come from continuation */ + } + luaD_poscall(L, firstArg); /* finish 'luaD_precall' */ + } + unroll(L, NULL); + } + lua_assert(nCcalls == L->nCcalls); +} + + +LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) { + int status; + int oldnny = L->nny; /* save 'nny' */ + lua_lock(L); + luai_userstateresume(L, nargs); + L->nCcalls = (from) ? from->nCcalls + 1 : 1; + L->nny = 0; /* allow yields */ + api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs); + status = luaD_rawrunprotected(L, resume, L->top - nargs); + if (status == -1) /* error calling 'lua_resume'? */ + status = LUA_ERRRUN; + else { /* yield or regular error */ + while (status != LUA_OK && status != LUA_YIELD) { /* error? */ + if (recover(L, status)) /* recover point? */ + status = luaD_rawrunprotected(L, unroll, NULL); /* run continuation */ + else { /* unrecoverable error */ + L->status = cast_byte(status); /* mark thread as `dead' */ + seterrorobj(L, status, L->top); + L->ci->top = L->top; + break; + } + } + lua_assert(status == L->status); + } + L->nny = oldnny; /* restore 'nny' */ + L->nCcalls--; + lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0)); + lua_unlock(L); + return status; +} + + +LUA_API int lua_yieldk (lua_State *L, int nresults, int ctx, lua_CFunction k) { + CallInfo *ci = L->ci; + luai_userstateyield(L, nresults); + lua_lock(L); + api_checknelems(L, nresults); + if (L->nny > 0) { + if (L != G(L)->mainthread) + luaG_runerror(L, "attempt to yield across a C-call boundary"); + else + luaG_runerror(L, "attempt to yield from outside a coroutine"); + } + L->status = LUA_YIELD; + ci->extra = savestack(L, ci->func); /* save current 'func' */ + if (isLua(ci)) { /* inside a hook? */ + api_check(L, k == NULL, "hooks cannot continue after yielding"); + } + else { + if ((ci->u.c.k = k) != NULL) /* is there a continuation? */ + ci->u.c.ctx = ctx; /* save context */ + ci->func = L->top - nresults - 1; /* protect stack below results */ + luaD_throw(L, LUA_YIELD); + } + lua_assert(ci->callstatus & CIST_HOOKED); /* must be inside a hook */ + lua_unlock(L); + return 0; /* return to 'luaD_hook' */ +} + + +int luaD_pcall (lua_State *L, Pfunc func, void *u, + ptrdiff_t old_top, ptrdiff_t ef) { + int status; + CallInfo *old_ci = L->ci; + lu_byte old_allowhooks = L->allowhook; + unsigned short old_nny = L->nny; + ptrdiff_t old_errfunc = L->errfunc; + L->errfunc = ef; + status = luaD_rawrunprotected(L, func, u); + if (status != LUA_OK) { /* an error occurred? */ + StkId oldtop = restorestack(L, old_top); + luaF_close(L, oldtop); /* close possible pending closures */ + seterrorobj(L, status, oldtop); + L->ci = old_ci; + L->allowhook = old_allowhooks; + L->nny = old_nny; + luaD_shrinkstack(L); + } + L->errfunc = old_errfunc; + return status; +} + + + +/* +** Execute a protected parser. +*/ +struct SParser { /* data to `f_parser' */ + ZIO *z; + Mbuffer buff; /* dynamic structure used by the scanner */ + Dyndata dyd; /* dynamic structures used by the parser */ + const char *mode; + const char *name; +}; + + +static void checkmode (lua_State *L, const char *mode, const char *x) { + if (mode && strchr(mode, x[0]) == NULL) { + luaO_pushfstring(L, + "attempt to load a %s chunk (mode is " LUA_QS ")", x, mode); + luaD_throw(L, LUA_ERRSYNTAX); + } +} + + +static void f_parser (lua_State *L, void *ud) { + int i; + Closure *cl; + struct SParser *p = cast(struct SParser *, ud); + int c = zgetc(p->z); /* read first character */ + if (c == LUA_SIGNATURE[0]) { + checkmode(L, p->mode, "binary"); + cl = luaU_undump(L, p->z, &p->buff, p->name); + } + else { + checkmode(L, p->mode, "text"); + cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c); + } + lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues); + for (i = 0; i < cl->l.nupvalues; i++) { /* initialize upvalues */ + UpVal *up = luaF_newupval(L); + cl->l.upvals[i] = up; + luaC_objbarrier(L, cl, up); + } +} + + +int luaD_protectedparser (lua_State *L, ZIO *z, const char *name, + const char *mode) { + struct SParser p; + int status; + L->nny++; /* cannot yield during parsing */ + p.z = z; p.name = name; p.mode = mode; + p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0; + p.dyd.gt.arr = NULL; p.dyd.gt.size = 0; + p.dyd.label.arr = NULL; p.dyd.label.size = 0; + luaZ_initbuffer(L, &p.buff); + status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc); + luaZ_freebuffer(L, &p.buff); + luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size); + luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size); + luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size); + L->nny--; + return status; +} + + diff --git a/extern/lua/src/ldo.h b/extern/lua/src/ldo.h new file mode 100644 index 0000000..d3d3082 --- /dev/null +++ b/extern/lua/src/ldo.h @@ -0,0 +1,46 @@ +/* +** $Id: ldo.h,v 2.20.1.1 2013/04/12 18:48:47 roberto Exp $ +** Stack and Call structure of Lua +** See Copyright Notice in lua.h +*/ + +#ifndef ldo_h +#define ldo_h + + +#include "lobject.h" +#include "lstate.h" +#include "lzio.h" + + +#define luaD_checkstack(L,n) if (L->stack_last - L->top <= (n)) \ + luaD_growstack(L, n); else condmovestack(L); + + +#define incr_top(L) {L->top++; luaD_checkstack(L,0);} + +#define savestack(L,p) ((char *)(p) - (char *)L->stack) +#define restorestack(L,n) ((TValue *)((char *)L->stack + (n))) + + +/* type of protected functions, to be ran by `runprotected' */ +typedef void (*Pfunc) (lua_State *L, void *ud); + +LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name, + const char *mode); +LUAI_FUNC void luaD_hook (lua_State *L, int event, int line); +LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults); +LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults, + int allowyield); +LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u, + ptrdiff_t oldtop, ptrdiff_t ef); +LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult); +LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize); +LUAI_FUNC void luaD_growstack (lua_State *L, int n); +LUAI_FUNC void luaD_shrinkstack (lua_State *L); + +LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode); +LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud); + +#endif + diff --git a/extern/lua/src/ldo.o b/extern/lua/src/ldo.o new file mode 100644 index 0000000000000000000000000000000000000000..e56160a215e9ed15a992f4aecaebdedea09fe442 GIT binary patch literal 10768 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 dPZN2#Jg-+O`!bQpb9pQem*?^y + +#define ldump_c +#define LUA_CORE + +#include "lua.h" + +#include "lobject.h" +#include "lstate.h" +#include "lundump.h" + +typedef struct { + lua_State* L; + lua_Writer writer; + void* data; + int strip; + int status; +} DumpState; + +#define DumpMem(b,n,size,D) DumpBlock(b,(n)*(size),D) +#define DumpVar(x,D) DumpMem(&x,1,sizeof(x),D) + +static void DumpBlock(const void* b, size_t size, DumpState* D) +{ + if (D->status==0) + { + lua_unlock(D->L); + D->status=(*D->writer)(D->L,b,size,D->data); + lua_lock(D->L); + } +} + +static void DumpChar(int y, DumpState* D) +{ + char x=(char)y; + DumpVar(x,D); +} + +static void DumpInt(int x, DumpState* D) +{ + DumpVar(x,D); +} + +static void DumpNumber(lua_Number x, DumpState* D) +{ + DumpVar(x,D); +} + +static void DumpVector(const void* b, int n, size_t size, DumpState* D) +{ + DumpInt(n,D); + DumpMem(b,n,size,D); +} + +static void DumpString(const TString* s, DumpState* D) +{ + if (s==NULL) + { + size_t size=0; + DumpVar(size,D); + } + else + { + size_t size=s->tsv.len+1; /* include trailing '\0' */ + DumpVar(size,D); + DumpBlock(getstr(s),size*sizeof(char),D); + } +} + +#define DumpCode(f,D) DumpVector(f->code,f->sizecode,sizeof(Instruction),D) + +static void DumpFunction(const Proto* f, DumpState* D); + +static void DumpConstants(const Proto* f, DumpState* D) +{ + int i,n=f->sizek; + DumpInt(n,D); + for (i=0; ik[i]; + DumpChar(ttypenv(o),D); + switch (ttypenv(o)) + { + case LUA_TNIL: + break; + case LUA_TBOOLEAN: + DumpChar(bvalue(o),D); + break; + case LUA_TNUMBER: + DumpNumber(nvalue(o),D); + break; + case LUA_TSTRING: + DumpString(rawtsvalue(o),D); + break; + default: lua_assert(0); + } + } + n=f->sizep; + DumpInt(n,D); + for (i=0; ip[i],D); +} + +static void DumpUpvalues(const Proto* f, DumpState* D) +{ + int i,n=f->sizeupvalues; + DumpInt(n,D); + for (i=0; iupvalues[i].instack,D); + DumpChar(f->upvalues[i].idx,D); + } +} + +static void DumpDebug(const Proto* f, DumpState* D) +{ + int i,n; + DumpString((D->strip) ? NULL : f->source,D); + n= (D->strip) ? 0 : f->sizelineinfo; + DumpVector(f->lineinfo,n,sizeof(int),D); + n= (D->strip) ? 0 : f->sizelocvars; + DumpInt(n,D); + for (i=0; ilocvars[i].varname,D); + DumpInt(f->locvars[i].startpc,D); + DumpInt(f->locvars[i].endpc,D); + } + n= (D->strip) ? 0 : f->sizeupvalues; + DumpInt(n,D); + for (i=0; iupvalues[i].name,D); +} + +static void DumpFunction(const Proto* f, DumpState* D) +{ + DumpInt(f->linedefined,D); + DumpInt(f->lastlinedefined,D); + DumpChar(f->numparams,D); + DumpChar(f->is_vararg,D); + DumpChar(f->maxstacksize,D); + DumpCode(f,D); + DumpConstants(f,D); + DumpUpvalues(f,D); + DumpDebug(f,D); +} + +static void DumpHeader(DumpState* D) +{ + lu_byte h[LUAC_HEADERSIZE]; + luaU_header(h); + DumpBlock(h,LUAC_HEADERSIZE,D); +} + +/* +** dump Lua function as precompiled chunk +*/ +int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip) +{ + DumpState D; + D.L=L; + D.writer=w; + D.data=data; + D.strip=strip; + D.status=0; + DumpHeader(&D); + DumpFunction(f,&D); + return D.status; +} diff --git a/extern/lua/src/ldump.o b/extern/lua/src/ldump.o new file mode 100644 index 0000000000000000000000000000000000000000..670466afa9fa7847c7ae1dca5f512c635d8e790c GIT binary patch literal 3536 zcmbtWU2IcT96xOb6jtsnWDf-zsHW(MP`d<^Aq3m4Wp`}gvJb$F0cGplLf0+Zy~zMY zlI{|24ntpjfQWCtp}|Bk!H6SZ2+^P!@dXn=!$&9VK~RG7QGfq)@9nm`JrMmTz2}_Y z`Tf7oIoo^5`VDTEi`n90>)FK0Mj5O0PRwIs8e{X>Jl3QbR}{X{uNe0g{UyZ+=W1E8&qOU8Ga}1 zg|V~bFaL3&P~gd+!c~C7`vdxjc11CM&mRI_R1$vp=Ad#B#>l6BN&9rFoh{(sJx2E9 z&4?&>&(Ajo4K?i3FRAlk$lux)-!A;u8c#^orx-sQ56+fQ5R0rJ+8-$AZo3h}WrR>~ z+{rUD3R_vk5#JJTfe*!aio_qlQ#8SM1bIzYQvU_XmdHa_J&f_13}w!>Z3=%kpcq&4 z9pt1bnBYCl`e?$)g#Gf+F1SzXJ@TlH zxks=&>ZX-T9y*2zOw}T-O>6F{J)4Z%^&ZV1=Nr7a8?runI1vtO7b(jyJfEd*=U;nP zC|Cqo)INj${kZI(eP3RX2$$=l+ULYCCq9*!Z0B9jfdf#rj}XidaK;imy^9j)2>axr z9}!7Xzj@%5cCivWlZ78kYZfh$k&Bn%$vVp8q@A1%qlb_%`%k9L*2s4 z_<=!Z34E|)XW3eB+)zBp$^@?tCiM~dbj&OAygoJ0O-~DjdgC|6(^3f{@fznIZbm)6 zn!*$Ly#Oxq(>_V?xy0QZ zucMB3=$ELYVR@(lnCK`+A)M)y(fQ;tA5KQGd7Y?J)T&ed)DsGx(v0#3uhAS1p;qY4 z_Y^y-dDT3x-JmJFC5i;Ac=L-seFW5?c9K{@nBIByD2IYwpu2hqcx27QD= z4#-27sb%{3fma>jTK60ARZjHLpZ8fN@8DKN=~l(t;yccFM(p!}h~s>=c?e~F8_G4M z@cEOE#XT5Xj~%K@Rlim(cqqqPd2B zM9f<J(D!r}fIk6hj=rI||Mk z!mbZT6FA3}DE>Msex5!Y3p8z^GK`~pb|DZ2ujrY-DOr^c@b&yRlmcitJ+apFtfsp9 z^-y^ty}LV=4Xuu>iBznrSiQoWkwwPJ%z?S~H8R(r-?hXy$NK?FMlBCody8m{Oa7dD zt3)r*YWyk*gB+m`_71t@QXuEqC`H@mNdW+H$(tPeI5|0N-4)5)IguoAP@ZH^7UgSP~0Dq+ll$L5=Wxbm2yZNd-roy5jp!kql$kMR^a z;qYs35_ht!#DZ-8SN#g;&XoW2`j1)qQH+zt)?Ydq#N3YG9&0CIlc`@nXZ|}Zef({n zA|sZ*-*#l}+V!`|bbn^*-!`j%gBFqcN4mDY-MzOeUijOKh zT|8{oG?4OfPqHuGOkj&GJcN-%yq6f4<41h^JrnOCFnS{ixBD;NIbb9nW;MrL7Qdci zb&HUgc&5D$_|FqN3*D%ab%ZY$hCwY n{z3`~VNOE$ + +#define lfunc_c +#define LUA_CORE + +#include "lua.h" + +#include "lfunc.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" + + + +Closure *luaF_newCclosure (lua_State *L, int n) { + Closure *c = &luaC_newobj(L, LUA_TCCL, sizeCclosure(n), NULL, 0)->cl; + c->c.nupvalues = cast_byte(n); + return c; +} + + +Closure *luaF_newLclosure (lua_State *L, int n) { + Closure *c = &luaC_newobj(L, LUA_TLCL, sizeLclosure(n), NULL, 0)->cl; + c->l.p = NULL; + c->l.nupvalues = cast_byte(n); + while (n--) c->l.upvals[n] = NULL; + return c; +} + + +UpVal *luaF_newupval (lua_State *L) { + UpVal *uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), NULL, 0)->uv; + uv->v = &uv->u.value; + setnilvalue(uv->v); + return uv; +} + + +UpVal *luaF_findupval (lua_State *L, StkId level) { + global_State *g = G(L); + GCObject **pp = &L->openupval; + UpVal *p; + UpVal *uv; + while (*pp != NULL && (p = gco2uv(*pp))->v >= level) { + GCObject *o = obj2gco(p); + lua_assert(p->v != &p->u.value); + lua_assert(!isold(o) || isold(obj2gco(L))); + if (p->v == level) { /* found a corresponding upvalue? */ + if (isdead(g, o)) /* is it dead? */ + changewhite(o); /* resurrect it */ + return p; + } + pp = &p->next; + } + /* not found: create a new one */ + uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), pp, 0)->uv; + uv->v = level; /* current value lives in the stack */ + uv->u.l.prev = &g->uvhead; /* double link it in `uvhead' list */ + uv->u.l.next = g->uvhead.u.l.next; + uv->u.l.next->u.l.prev = uv; + g->uvhead.u.l.next = uv; + lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv); + return uv; +} + + +static void unlinkupval (UpVal *uv) { + lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv); + uv->u.l.next->u.l.prev = uv->u.l.prev; /* remove from `uvhead' list */ + uv->u.l.prev->u.l.next = uv->u.l.next; +} + + +void luaF_freeupval (lua_State *L, UpVal *uv) { + if (uv->v != &uv->u.value) /* is it open? */ + unlinkupval(uv); /* remove from open list */ + luaM_free(L, uv); /* free upvalue */ +} + + +void luaF_close (lua_State *L, StkId level) { + UpVal *uv; + global_State *g = G(L); + while (L->openupval != NULL && (uv = gco2uv(L->openupval))->v >= level) { + GCObject *o = obj2gco(uv); + lua_assert(!isblack(o) && uv->v != &uv->u.value); + L->openupval = uv->next; /* remove from `open' list */ + if (isdead(g, o)) + luaF_freeupval(L, uv); /* free upvalue */ + else { + unlinkupval(uv); /* remove upvalue from 'uvhead' list */ + setobj(L, &uv->u.value, uv->v); /* move value to upvalue slot */ + uv->v = &uv->u.value; /* now current value lives here */ + gch(o)->next = g->allgc; /* link upvalue into 'allgc' list */ + g->allgc = o; + luaC_checkupvalcolor(g, uv); + } + } +} + + +Proto *luaF_newproto (lua_State *L) { + Proto *f = &luaC_newobj(L, LUA_TPROTO, sizeof(Proto), NULL, 0)->p; + f->k = NULL; + f->sizek = 0; + f->p = NULL; + f->sizep = 0; + f->code = NULL; + f->cache = NULL; + f->sizecode = 0; + f->lineinfo = NULL; + f->sizelineinfo = 0; + f->upvalues = NULL; + f->sizeupvalues = 0; + f->numparams = 0; + f->is_vararg = 0; + f->maxstacksize = 0; + f->locvars = NULL; + f->sizelocvars = 0; + f->linedefined = 0; + f->lastlinedefined = 0; + f->source = NULL; + return f; +} + + +void luaF_freeproto (lua_State *L, Proto *f) { + luaM_freearray(L, f->code, f->sizecode); + luaM_freearray(L, f->p, f->sizep); + luaM_freearray(L, f->k, f->sizek); + luaM_freearray(L, f->lineinfo, f->sizelineinfo); + luaM_freearray(L, f->locvars, f->sizelocvars); + luaM_freearray(L, f->upvalues, f->sizeupvalues); + luaM_free(L, f); +} + + +/* +** Look for n-th local variable at line `line' in function `func'. +** Returns NULL if not found. +*/ +const char *luaF_getlocalname (const Proto *f, int local_number, int pc) { + int i; + for (i = 0; isizelocvars && f->locvars[i].startpc <= pc; i++) { + if (pc < f->locvars[i].endpc) { /* is variable active? */ + local_number--; + if (local_number == 0) + return getstr(f->locvars[i].varname); + } + } + return NULL; /* not found */ +} + diff --git a/extern/lua/src/lfunc.h b/extern/lua/src/lfunc.h new file mode 100644 index 0000000..ca0d3a3 --- /dev/null +++ b/extern/lua/src/lfunc.h @@ -0,0 +1,33 @@ +/* +** $Id: lfunc.h,v 2.8.1.1 2013/04/12 18:48:47 roberto Exp $ +** Auxiliary functions to manipulate prototypes and closures +** See Copyright Notice in lua.h +*/ + +#ifndef lfunc_h +#define lfunc_h + + +#include "lobject.h" + + +#define sizeCclosure(n) (cast(int, sizeof(CClosure)) + \ + cast(int, sizeof(TValue)*((n)-1))) + +#define sizeLclosure(n) (cast(int, sizeof(LClosure)) + \ + cast(int, sizeof(TValue *)*((n)-1))) + + +LUAI_FUNC Proto *luaF_newproto (lua_State *L); +LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems); +LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems); +LUAI_FUNC UpVal *luaF_newupval (lua_State *L); +LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level); +LUAI_FUNC void luaF_close (lua_State *L, StkId level); +LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f); +LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv); +LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number, + int pc); + + +#endif diff --git a/extern/lua/src/lfunc.o b/extern/lua/src/lfunc.o new file mode 100644 index 0000000000000000000000000000000000000000..efc077e81ad5a59e808baf60b0244d8f2bc1acf9 GIT binary patch literal 3632 zcmbVOU2Icj82;K0>HgYk7E;Byqgl)}(5!KWRg5{^Pxs9fthQT*1Jp7-bbJMFQ7V8Cjz5Fr-w7O8jwCFIeDiY+r!Cat82Xm`T{-a_%02JL}&Wg#Rj zzYK#k{_QGqPK`E=U714hINMLKsNwL!-gWIE!~nhR$4+GDZ`+rjLW76R-=QVhjdb}` zqDgf-+hrL0F282UKVGM${_7HsHFtio~=SgaMg5OSAf30y+8 zkPAbvVBXeE;5?xrPY0e>q`vPD9i_heIp^B@Q;XC$#0y9pI}fcu6^okKMn~9T?n|TFW^$!s6GN|1CS5XgRS*S-WAr#Eo4qP+xrReM~12P zFdWqP0pT(9uV5+~o)iw=j zYDbi1yrr(Mud{uHm1kRZ`8f2v+z2nDWJz{`O-gbE6&wf&bxDq*66XW7jDATTMFnoB z;qK;ckKu+;eI?JrGY8LMWOf-tlZHwdDv1gPDbsjJ*zq-=U)XN%3f2B$XC^)}O7(+o zTD)mB+Kz|e5M^Og{s2<(rcIy`Kw)VNv_YV|0qqoMIm0BNT>>q0LxA>Fq0k`Jegbf8 z4{ZH$XxiBNO27I$lk+PddEsz(Z4cRxbmnhaXz@k^wG`J{jrA|Md?EWW=k`#`(GB_E zEov+EUCXU{3u2$)eiqzU$Y5XJ8&YS#GO<6FlDa)Uk9VuL`xV22x^1{%AeO`L5zDO0 zvbklWeGxt+c#WTDBZRz!y3gUtTlYHbV0OU6HVAYW9^!YnPFnpAciuMakmek2@cqEV z+)*3{*@CZrhif0;-C)k54{{M-m3ZoqtcRLJhJof?W!v9O@L*j+KFF(vVtKD}`z-2S zhwEeP<)p3OA>|va)X325um_r97<>8?c_8QU1wC2MI_x;77MM561$#yqMrs}j#-OpOuGL^ewp;K`+u`wu9|IpT?@ zr>B(^P*Q1C@eJ-9-kMco@dL!eqLsw>R31^-2Jxygq!W|Y5T33)g69Zx{@-{n#A43s`9EoW zna8uQ5ZFRQ{0jo$TJ$gU5a7Z#Qv**p|GhlkY7PdQ@_1U6T&%yK?*gON{*AU8j2}1= z_YY%5yx6~|0jpkn3|Zv=GZN^Sq^cb@_v+q}-h;m&Adh%J3)l!%*GH^Y{Vsm~3NUV# z>iXs}vyHq4a&O&?3ENh4$FPrDogiL&Gi}85XG|mqZ6g~^Ud6PPXJ5h4vi;}u8f*28 zwK7}w%?9ps@VII$INn3#i*wAr + +#define lgc_c +#define LUA_CORE + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" + + + +/* +** cost of sweeping one element (the size of a small object divided +** by some adjust for the sweep speed) +*/ +#define GCSWEEPCOST ((sizeof(TString) + 4) / 4) + +/* maximum number of elements to sweep in each single step */ +#define GCSWEEPMAX (cast_int((GCSTEPSIZE / GCSWEEPCOST) / 4)) + +/* maximum number of finalizers to call in each GC step */ +#define GCFINALIZENUM 4 + + +/* +** macro to adjust 'stepmul': 'stepmul' is actually used like +** 'stepmul / STEPMULADJ' (value chosen by tests) +*/ +#define STEPMULADJ 200 + + +/* +** macro to adjust 'pause': 'pause' is actually used like +** 'pause / PAUSEADJ' (value chosen by tests) +*/ +#define PAUSEADJ 100 + + +/* +** 'makewhite' erases all color bits plus the old bit and then +** sets only the current white bit +*/ +#define maskcolors (~(bit2mask(BLACKBIT, OLDBIT) | WHITEBITS)) +#define makewhite(g,x) \ + (gch(x)->marked = cast_byte((gch(x)->marked & maskcolors) | luaC_white(g))) + +#define white2gray(x) resetbits(gch(x)->marked, WHITEBITS) +#define black2gray(x) resetbit(gch(x)->marked, BLACKBIT) + + +#define isfinalized(x) testbit(gch(x)->marked, FINALIZEDBIT) + +#define checkdeadkey(n) lua_assert(!ttisdeadkey(gkey(n)) || ttisnil(gval(n))) + + +#define checkconsistency(obj) \ + lua_longassert(!iscollectable(obj) || righttt(obj)) + + +#define markvalue(g,o) { checkconsistency(o); \ + if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } + +#define markobject(g,t) { if ((t) && iswhite(obj2gco(t))) \ + reallymarkobject(g, obj2gco(t)); } + +static void reallymarkobject (global_State *g, GCObject *o); + + +/* +** {====================================================== +** Generic functions +** ======================================================= +*/ + + +/* +** one after last element in a hash array +*/ +#define gnodelast(h) gnode(h, cast(size_t, sizenode(h))) + + +/* +** link table 'h' into list pointed by 'p' +*/ +#define linktable(h,p) ((h)->gclist = *(p), *(p) = obj2gco(h)) + + +/* +** if key is not marked, mark its entry as dead (therefore removing it +** from the table) +*/ +static void removeentry (Node *n) { + lua_assert(ttisnil(gval(n))); + if (valiswhite(gkey(n))) + setdeadvalue(gkey(n)); /* unused and unmarked key; remove it */ +} + + +/* +** tells whether a key or value can be cleared from a weak +** table. Non-collectable objects are never removed from weak +** tables. Strings behave as `values', so are never removed too. for +** other objects: if really collected, cannot keep them; for objects +** being finalized, keep them in keys, but not in values +*/ +static int iscleared (global_State *g, const TValue *o) { + if (!iscollectable(o)) return 0; + else if (ttisstring(o)) { + markobject(g, rawtsvalue(o)); /* strings are `values', so are never weak */ + return 0; + } + else return iswhite(gcvalue(o)); +} + + +/* +** barrier that moves collector forward, that is, mark the white object +** being pointed by a black object. +*/ +void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v) { + global_State *g = G(L); + lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o)); + lua_assert(g->gcstate != GCSpause); + lua_assert(gch(o)->tt != LUA_TTABLE); + if (keepinvariantout(g)) /* must keep invariant? */ + reallymarkobject(g, v); /* restore invariant */ + else { /* sweep phase */ + lua_assert(issweepphase(g)); + makewhite(g, o); /* mark main obj. as white to avoid other barriers */ + } +} + + +/* +** barrier that moves collector backward, that is, mark the black object +** pointing to a white object as gray again. (Current implementation +** only works for tables; access to 'gclist' is not uniform across +** different types.) +*/ +void luaC_barrierback_ (lua_State *L, GCObject *o) { + global_State *g = G(L); + lua_assert(isblack(o) && !isdead(g, o) && gch(o)->tt == LUA_TTABLE); + black2gray(o); /* make object gray (again) */ + gco2t(o)->gclist = g->grayagain; + g->grayagain = o; +} + + +/* +** barrier for prototypes. When creating first closure (cache is +** NULL), use a forward barrier; this may be the only closure of the +** prototype (if it is a "regular" function, with a single instance) +** and the prototype may be big, so it is better to avoid traversing +** it again. Otherwise, use a backward barrier, to avoid marking all +** possible instances. +*/ +LUAI_FUNC void luaC_barrierproto_ (lua_State *L, Proto *p, Closure *c) { + global_State *g = G(L); + lua_assert(isblack(obj2gco(p))); + if (p->cache == NULL) { /* first time? */ + luaC_objbarrier(L, p, c); + } + else { /* use a backward barrier */ + black2gray(obj2gco(p)); /* make prototype gray (again) */ + p->gclist = g->grayagain; + g->grayagain = obj2gco(p); + } +} + + +/* +** check color (and invariants) for an upvalue that was closed, +** i.e., moved into the 'allgc' list +*/ +void luaC_checkupvalcolor (global_State *g, UpVal *uv) { + GCObject *o = obj2gco(uv); + lua_assert(!isblack(o)); /* open upvalues are never black */ + if (isgray(o)) { + if (keepinvariant(g)) { + resetoldbit(o); /* see MOVE OLD rule */ + gray2black(o); /* it is being visited now */ + markvalue(g, uv->v); + } + else { + lua_assert(issweepphase(g)); + makewhite(g, o); + } + } +} + + +/* +** create a new collectable object (with given type and size) and link +** it to '*list'. 'offset' tells how many bytes to allocate before the +** object itself (used only by states). +*/ +GCObject *luaC_newobj (lua_State *L, int tt, size_t sz, GCObject **list, + int offset) { + global_State *g = G(L); + char *raw = cast(char *, luaM_newobject(L, novariant(tt), sz)); + GCObject *o = obj2gco(raw + offset); + if (list == NULL) + list = &g->allgc; /* standard list for collectable objects */ + gch(o)->marked = luaC_white(g); + gch(o)->tt = tt; + gch(o)->next = *list; + *list = o; + return o; +} + +/* }====================================================== */ + + + +/* +** {====================================================== +** Mark functions +** ======================================================= +*/ + + +/* +** mark an object. Userdata, strings, and closed upvalues are visited +** and turned black here. Other objects are marked gray and added +** to appropriate list to be visited (and turned black) later. (Open +** upvalues are already linked in 'headuv' list.) +*/ +static void reallymarkobject (global_State *g, GCObject *o) { + lu_mem size; + white2gray(o); + switch (gch(o)->tt) { + case LUA_TSHRSTR: + case LUA_TLNGSTR: { + size = sizestring(gco2ts(o)); + break; /* nothing else to mark; make it black */ + } + case LUA_TUSERDATA: { + Table *mt = gco2u(o)->metatable; + markobject(g, mt); + markobject(g, gco2u(o)->env); + size = sizeudata(gco2u(o)); + break; + } + case LUA_TUPVAL: { + UpVal *uv = gco2uv(o); + markvalue(g, uv->v); + if (uv->v != &uv->u.value) /* open? */ + return; /* open upvalues remain gray */ + size = sizeof(UpVal); + break; + } + case LUA_TLCL: { + gco2lcl(o)->gclist = g->gray; + g->gray = o; + return; + } + case LUA_TCCL: { + gco2ccl(o)->gclist = g->gray; + g->gray = o; + return; + } + case LUA_TTABLE: { + linktable(gco2t(o), &g->gray); + return; + } + case LUA_TTHREAD: { + gco2th(o)->gclist = g->gray; + g->gray = o; + return; + } + case LUA_TPROTO: { + gco2p(o)->gclist = g->gray; + g->gray = o; + return; + } + default: lua_assert(0); return; + } + gray2black(o); + g->GCmemtrav += size; +} + + +/* +** mark metamethods for basic types +*/ +static void markmt (global_State *g) { + int i; + for (i=0; i < LUA_NUMTAGS; i++) + markobject(g, g->mt[i]); +} + + +/* +** mark all objects in list of being-finalized +*/ +static void markbeingfnz (global_State *g) { + GCObject *o; + for (o = g->tobefnz; o != NULL; o = gch(o)->next) { + makewhite(g, o); + reallymarkobject(g, o); + } +} + + +/* +** mark all values stored in marked open upvalues. (See comment in +** 'lstate.h'.) +*/ +static void remarkupvals (global_State *g) { + UpVal *uv; + for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) { + if (isgray(obj2gco(uv))) + markvalue(g, uv->v); + } +} + + +/* +** mark root set and reset all gray lists, to start a new +** incremental (or full) collection +*/ +static void restartcollection (global_State *g) { + g->gray = g->grayagain = NULL; + g->weak = g->allweak = g->ephemeron = NULL; + markobject(g, g->mainthread); + markvalue(g, &g->l_registry); + markmt(g); + markbeingfnz(g); /* mark any finalizing object left from previous cycle */ +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Traverse functions +** ======================================================= +*/ + +static void traverseweakvalue (global_State *g, Table *h) { + Node *n, *limit = gnodelast(h); + /* if there is array part, assume it may have white values (do not + traverse it just to check) */ + int hasclears = (h->sizearray > 0); + for (n = gnode(h, 0); n < limit; n++) { + checkdeadkey(n); + if (ttisnil(gval(n))) /* entry is empty? */ + removeentry(n); /* remove it */ + else { + lua_assert(!ttisnil(gkey(n))); + markvalue(g, gkey(n)); /* mark key */ + if (!hasclears && iscleared(g, gval(n))) /* is there a white value? */ + hasclears = 1; /* table will have to be cleared */ + } + } + if (hasclears) + linktable(h, &g->weak); /* has to be cleared later */ + else /* no white values */ + linktable(h, &g->grayagain); /* no need to clean */ +} + + +static int traverseephemeron (global_State *g, Table *h) { + int marked = 0; /* true if an object is marked in this traversal */ + int hasclears = 0; /* true if table has white keys */ + int prop = 0; /* true if table has entry "white-key -> white-value" */ + Node *n, *limit = gnodelast(h); + int i; + /* traverse array part (numeric keys are 'strong') */ + for (i = 0; i < h->sizearray; i++) { + if (valiswhite(&h->array[i])) { + marked = 1; + reallymarkobject(g, gcvalue(&h->array[i])); + } + } + /* traverse hash part */ + for (n = gnode(h, 0); n < limit; n++) { + checkdeadkey(n); + if (ttisnil(gval(n))) /* entry is empty? */ + removeentry(n); /* remove it */ + else if (iscleared(g, gkey(n))) { /* key is not marked (yet)? */ + hasclears = 1; /* table must be cleared */ + if (valiswhite(gval(n))) /* value not marked yet? */ + prop = 1; /* must propagate again */ + } + else if (valiswhite(gval(n))) { /* value not marked yet? */ + marked = 1; + reallymarkobject(g, gcvalue(gval(n))); /* mark it now */ + } + } + if (prop) + linktable(h, &g->ephemeron); /* have to propagate again */ + else if (hasclears) /* does table have white keys? */ + linktable(h, &g->allweak); /* may have to clean white keys */ + else /* no white keys */ + linktable(h, &g->grayagain); /* no need to clean */ + return marked; +} + + +static void traversestrongtable (global_State *g, Table *h) { + Node *n, *limit = gnodelast(h); + int i; + for (i = 0; i < h->sizearray; i++) /* traverse array part */ + markvalue(g, &h->array[i]); + for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */ + checkdeadkey(n); + if (ttisnil(gval(n))) /* entry is empty? */ + removeentry(n); /* remove it */ + else { + lua_assert(!ttisnil(gkey(n))); + markvalue(g, gkey(n)); /* mark key */ + markvalue(g, gval(n)); /* mark value */ + } + } +} + + +static lu_mem traversetable (global_State *g, Table *h) { + const char *weakkey, *weakvalue; + const TValue *mode = gfasttm(g, h->metatable, TM_MODE); + markobject(g, h->metatable); + if (mode && ttisstring(mode) && /* is there a weak mode? */ + ((weakkey = strchr(svalue(mode), 'k')), + (weakvalue = strchr(svalue(mode), 'v')), + (weakkey || weakvalue))) { /* is really weak? */ + black2gray(obj2gco(h)); /* keep table gray */ + if (!weakkey) /* strong keys? */ + traverseweakvalue(g, h); + else if (!weakvalue) /* strong values? */ + traverseephemeron(g, h); + else /* all weak */ + linktable(h, &g->allweak); /* nothing to traverse now */ + } + else /* not weak */ + traversestrongtable(g, h); + return sizeof(Table) + sizeof(TValue) * h->sizearray + + sizeof(Node) * cast(size_t, sizenode(h)); +} + + +static int traverseproto (global_State *g, Proto *f) { + int i; + if (f->cache && iswhite(obj2gco(f->cache))) + f->cache = NULL; /* allow cache to be collected */ + markobject(g, f->source); + for (i = 0; i < f->sizek; i++) /* mark literals */ + markvalue(g, &f->k[i]); + for (i = 0; i < f->sizeupvalues; i++) /* mark upvalue names */ + markobject(g, f->upvalues[i].name); + for (i = 0; i < f->sizep; i++) /* mark nested protos */ + markobject(g, f->p[i]); + for (i = 0; i < f->sizelocvars; i++) /* mark local-variable names */ + markobject(g, f->locvars[i].varname); + return sizeof(Proto) + sizeof(Instruction) * f->sizecode + + sizeof(Proto *) * f->sizep + + sizeof(TValue) * f->sizek + + sizeof(int) * f->sizelineinfo + + sizeof(LocVar) * f->sizelocvars + + sizeof(Upvaldesc) * f->sizeupvalues; +} + + +static lu_mem traverseCclosure (global_State *g, CClosure *cl) { + int i; + for (i = 0; i < cl->nupvalues; i++) /* mark its upvalues */ + markvalue(g, &cl->upvalue[i]); + return sizeCclosure(cl->nupvalues); +} + +static lu_mem traverseLclosure (global_State *g, LClosure *cl) { + int i; + markobject(g, cl->p); /* mark its prototype */ + for (i = 0; i < cl->nupvalues; i++) /* mark its upvalues */ + markobject(g, cl->upvals[i]); + return sizeLclosure(cl->nupvalues); +} + + +static lu_mem traversestack (global_State *g, lua_State *th) { + int n = 0; + StkId o = th->stack; + if (o == NULL) + return 1; /* stack not completely built yet */ + for (; o < th->top; o++) /* mark live elements in the stack */ + markvalue(g, o); + if (g->gcstate == GCSatomic) { /* final traversal? */ + StkId lim = th->stack + th->stacksize; /* real end of stack */ + for (; o < lim; o++) /* clear not-marked stack slice */ + setnilvalue(o); + } + else { /* count call infos to compute size */ + CallInfo *ci; + for (ci = &th->base_ci; ci != th->ci; ci = ci->next) + n++; + } + return sizeof(lua_State) + sizeof(TValue) * th->stacksize + + sizeof(CallInfo) * n; +} + + +/* +** traverse one gray object, turning it to black (except for threads, +** which are always gray). +*/ +static void propagatemark (global_State *g) { + lu_mem size; + GCObject *o = g->gray; + lua_assert(isgray(o)); + gray2black(o); + switch (gch(o)->tt) { + case LUA_TTABLE: { + Table *h = gco2t(o); + g->gray = h->gclist; /* remove from 'gray' list */ + size = traversetable(g, h); + break; + } + case LUA_TLCL: { + LClosure *cl = gco2lcl(o); + g->gray = cl->gclist; /* remove from 'gray' list */ + size = traverseLclosure(g, cl); + break; + } + case LUA_TCCL: { + CClosure *cl = gco2ccl(o); + g->gray = cl->gclist; /* remove from 'gray' list */ + size = traverseCclosure(g, cl); + break; + } + case LUA_TTHREAD: { + lua_State *th = gco2th(o); + g->gray = th->gclist; /* remove from 'gray' list */ + th->gclist = g->grayagain; + g->grayagain = o; /* insert into 'grayagain' list */ + black2gray(o); + size = traversestack(g, th); + break; + } + case LUA_TPROTO: { + Proto *p = gco2p(o); + g->gray = p->gclist; /* remove from 'gray' list */ + size = traverseproto(g, p); + break; + } + default: lua_assert(0); return; + } + g->GCmemtrav += size; +} + + +static void propagateall (global_State *g) { + while (g->gray) propagatemark(g); +} + + +static void propagatelist (global_State *g, GCObject *l) { + lua_assert(g->gray == NULL); /* no grays left */ + g->gray = l; + propagateall(g); /* traverse all elements from 'l' */ +} + +/* +** retraverse all gray lists. Because tables may be reinserted in other +** lists when traversed, traverse the original lists to avoid traversing +** twice the same table (which is not wrong, but inefficient) +*/ +static void retraversegrays (global_State *g) { + GCObject *weak = g->weak; /* save original lists */ + GCObject *grayagain = g->grayagain; + GCObject *ephemeron = g->ephemeron; + g->weak = g->grayagain = g->ephemeron = NULL; + propagateall(g); /* traverse main gray list */ + propagatelist(g, grayagain); + propagatelist(g, weak); + propagatelist(g, ephemeron); +} + + +static void convergeephemerons (global_State *g) { + int changed; + do { + GCObject *w; + GCObject *next = g->ephemeron; /* get ephemeron list */ + g->ephemeron = NULL; /* tables will return to this list when traversed */ + changed = 0; + while ((w = next) != NULL) { + next = gco2t(w)->gclist; + if (traverseephemeron(g, gco2t(w))) { /* traverse marked some value? */ + propagateall(g); /* propagate changes */ + changed = 1; /* will have to revisit all ephemeron tables */ + } + } + } while (changed); +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Sweep Functions +** ======================================================= +*/ + + +/* +** clear entries with unmarked keys from all weaktables in list 'l' up +** to element 'f' +*/ +static void clearkeys (global_State *g, GCObject *l, GCObject *f) { + for (; l != f; l = gco2t(l)->gclist) { + Table *h = gco2t(l); + Node *n, *limit = gnodelast(h); + for (n = gnode(h, 0); n < limit; n++) { + if (!ttisnil(gval(n)) && (iscleared(g, gkey(n)))) { + setnilvalue(gval(n)); /* remove value ... */ + removeentry(n); /* and remove entry from table */ + } + } + } +} + + +/* +** clear entries with unmarked values from all weaktables in list 'l' up +** to element 'f' +*/ +static void clearvalues (global_State *g, GCObject *l, GCObject *f) { + for (; l != f; l = gco2t(l)->gclist) { + Table *h = gco2t(l); + Node *n, *limit = gnodelast(h); + int i; + for (i = 0; i < h->sizearray; i++) { + TValue *o = &h->array[i]; + if (iscleared(g, o)) /* value was collected? */ + setnilvalue(o); /* remove value */ + } + for (n = gnode(h, 0); n < limit; n++) { + if (!ttisnil(gval(n)) && iscleared(g, gval(n))) { + setnilvalue(gval(n)); /* remove value ... */ + removeentry(n); /* and remove entry from table */ + } + } + } +} + + +static void freeobj (lua_State *L, GCObject *o) { + switch (gch(o)->tt) { + case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break; + case LUA_TLCL: { + luaM_freemem(L, o, sizeLclosure(gco2lcl(o)->nupvalues)); + break; + } + case LUA_TCCL: { + luaM_freemem(L, o, sizeCclosure(gco2ccl(o)->nupvalues)); + break; + } + case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break; + case LUA_TTABLE: luaH_free(L, gco2t(o)); break; + case LUA_TTHREAD: luaE_freethread(L, gco2th(o)); break; + case LUA_TUSERDATA: luaM_freemem(L, o, sizeudata(gco2u(o))); break; + case LUA_TSHRSTR: + G(L)->strt.nuse--; + /* go through */ + case LUA_TLNGSTR: { + luaM_freemem(L, o, sizestring(gco2ts(o))); + break; + } + default: lua_assert(0); + } +} + + +#define sweepwholelist(L,p) sweeplist(L,p,MAX_LUMEM) +static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count); + + +/* +** sweep the (open) upvalues of a thread and resize its stack and +** list of call-info structures. +*/ +static void sweepthread (lua_State *L, lua_State *L1) { + if (L1->stack == NULL) return; /* stack not completely built yet */ + sweepwholelist(L, &L1->openupval); /* sweep open upvalues */ + luaE_freeCI(L1); /* free extra CallInfo slots */ + /* should not change the stack during an emergency gc cycle */ + if (G(L)->gckind != KGC_EMERGENCY) + luaD_shrinkstack(L1); +} + + +/* +** sweep at most 'count' elements from a list of GCObjects erasing dead +** objects, where a dead (not alive) object is one marked with the "old" +** (non current) white and not fixed. +** In non-generational mode, change all non-dead objects back to white, +** preparing for next collection cycle. +** In generational mode, keep black objects black, and also mark them as +** old; stop when hitting an old object, as all objects after that +** one will be old too. +** When object is a thread, sweep its list of open upvalues too. +*/ +static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) { + global_State *g = G(L); + int ow = otherwhite(g); + int toclear, toset; /* bits to clear and to set in all live objects */ + int tostop; /* stop sweep when this is true */ + if (isgenerational(g)) { /* generational mode? */ + toclear = ~0; /* clear nothing */ + toset = bitmask(OLDBIT); /* set the old bit of all surviving objects */ + tostop = bitmask(OLDBIT); /* do not sweep old generation */ + } + else { /* normal mode */ + toclear = maskcolors; /* clear all color bits + old bit */ + toset = luaC_white(g); /* make object white */ + tostop = 0; /* do not stop */ + } + while (*p != NULL && count-- > 0) { + GCObject *curr = *p; + int marked = gch(curr)->marked; + if (isdeadm(ow, marked)) { /* is 'curr' dead? */ + *p = gch(curr)->next; /* remove 'curr' from list */ + freeobj(L, curr); /* erase 'curr' */ + } + else { + if (testbits(marked, tostop)) + return NULL; /* stop sweeping this list */ + if (gch(curr)->tt == LUA_TTHREAD) + sweepthread(L, gco2th(curr)); /* sweep thread's upvalues */ + /* update marks */ + gch(curr)->marked = cast_byte((marked & toclear) | toset); + p = &gch(curr)->next; /* go to next element */ + } + } + return (*p == NULL) ? NULL : p; +} + + +/* +** sweep a list until a live object (or end of list) +*/ +static GCObject **sweeptolive (lua_State *L, GCObject **p, int *n) { + GCObject ** old = p; + int i = 0; + do { + i++; + p = sweeplist(L, p, 1); + } while (p == old); + if (n) *n += i; + return p; +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Finalization +** ======================================================= +*/ + +static void checkSizes (lua_State *L) { + global_State *g = G(L); + if (g->gckind != KGC_EMERGENCY) { /* do not change sizes in emergency */ + int hs = g->strt.size / 2; /* half the size of the string table */ + if (g->strt.nuse < cast(lu_int32, hs)) /* using less than that half? */ + luaS_resize(L, hs); /* halve its size */ + luaZ_freebuffer(L, &g->buff); /* free concatenation buffer */ + } +} + + +static GCObject *udata2finalize (global_State *g) { + GCObject *o = g->tobefnz; /* get first element */ + lua_assert(isfinalized(o)); + g->tobefnz = gch(o)->next; /* remove it from 'tobefnz' list */ + gch(o)->next = g->allgc; /* return it to 'allgc' list */ + g->allgc = o; + resetbit(gch(o)->marked, SEPARATED); /* mark that it is not in 'tobefnz' */ + lua_assert(!isold(o)); /* see MOVE OLD rule */ + if (!keepinvariantout(g)) /* not keeping invariant? */ + makewhite(g, o); /* "sweep" object */ + return o; +} + + +static void dothecall (lua_State *L, void *ud) { + UNUSED(ud); + luaD_call(L, L->top - 2, 0, 0); +} + + +static void GCTM (lua_State *L, int propagateerrors) { + global_State *g = G(L); + const TValue *tm; + TValue v; + setgcovalue(L, &v, udata2finalize(g)); + tm = luaT_gettmbyobj(L, &v, TM_GC); + if (tm != NULL && ttisfunction(tm)) { /* is there a finalizer? */ + int status; + lu_byte oldah = L->allowhook; + int running = g->gcrunning; + L->allowhook = 0; /* stop debug hooks during GC metamethod */ + g->gcrunning = 0; /* avoid GC steps */ + setobj2s(L, L->top, tm); /* push finalizer... */ + setobj2s(L, L->top + 1, &v); /* ... and its argument */ + L->top += 2; /* and (next line) call the finalizer */ + status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top - 2), 0); + L->allowhook = oldah; /* restore hooks */ + g->gcrunning = running; /* restore state */ + if (status != LUA_OK && propagateerrors) { /* error while running __gc? */ + if (status == LUA_ERRRUN) { /* is there an error object? */ + const char *msg = (ttisstring(L->top - 1)) + ? svalue(L->top - 1) + : "no message"; + luaO_pushfstring(L, "error in __gc metamethod (%s)", msg); + status = LUA_ERRGCMM; /* error in __gc metamethod */ + } + luaD_throw(L, status); /* re-throw error */ + } + } +} + + +/* +** move all unreachable objects (or 'all' objects) that need +** finalization from list 'finobj' to list 'tobefnz' (to be finalized) +*/ +static void separatetobefnz (lua_State *L, int all) { + global_State *g = G(L); + GCObject **p = &g->finobj; + GCObject *curr; + GCObject **lastnext = &g->tobefnz; + /* find last 'next' field in 'tobefnz' list (to add elements in its end) */ + while (*lastnext != NULL) + lastnext = &gch(*lastnext)->next; + while ((curr = *p) != NULL) { /* traverse all finalizable objects */ + lua_assert(!isfinalized(curr)); + lua_assert(testbit(gch(curr)->marked, SEPARATED)); + if (!(iswhite(curr) || all)) /* not being collected? */ + p = &gch(curr)->next; /* don't bother with it */ + else { + l_setbit(gch(curr)->marked, FINALIZEDBIT); /* won't be finalized again */ + *p = gch(curr)->next; /* remove 'curr' from 'finobj' list */ + gch(curr)->next = *lastnext; /* link at the end of 'tobefnz' list */ + *lastnext = curr; + lastnext = &gch(curr)->next; + } + } +} + + +/* +** if object 'o' has a finalizer, remove it from 'allgc' list (must +** search the list to find it) and link it in 'finobj' list. +*/ +void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) { + global_State *g = G(L); + if (testbit(gch(o)->marked, SEPARATED) || /* obj. is already separated... */ + isfinalized(o) || /* ... or is finalized... */ + gfasttm(g, mt, TM_GC) == NULL) /* or has no finalizer? */ + return; /* nothing to be done */ + else { /* move 'o' to 'finobj' list */ + GCObject **p; + GCheader *ho = gch(o); + if (g->sweepgc == &ho->next) { /* avoid removing current sweep object */ + lua_assert(issweepphase(g)); + g->sweepgc = sweeptolive(L, g->sweepgc, NULL); + } + /* search for pointer pointing to 'o' */ + for (p = &g->allgc; *p != o; p = &gch(*p)->next) { /* empty */ } + *p = ho->next; /* remove 'o' from root list */ + ho->next = g->finobj; /* link it in list 'finobj' */ + g->finobj = o; + l_setbit(ho->marked, SEPARATED); /* mark it as such */ + if (!keepinvariantout(g)) /* not keeping invariant? */ + makewhite(g, o); /* "sweep" object */ + else + resetoldbit(o); /* see MOVE OLD rule */ + } +} + +/* }====================================================== */ + + +/* +** {====================================================== +** GC control +** ======================================================= +*/ + + +/* +** set a reasonable "time" to wait before starting a new GC cycle; +** cycle will start when memory use hits threshold +*/ +static void setpause (global_State *g, l_mem estimate) { + l_mem debt, threshold; + estimate = estimate / PAUSEADJ; /* adjust 'estimate' */ + threshold = (g->gcpause < MAX_LMEM / estimate) /* overflow? */ + ? estimate * g->gcpause /* no overflow */ + : MAX_LMEM; /* overflow; truncate to maximum */ + debt = -cast(l_mem, threshold - gettotalbytes(g)); + luaE_setdebt(g, debt); +} + + +#define sweepphases \ + (bitmask(GCSsweepstring) | bitmask(GCSsweepudata) | bitmask(GCSsweep)) + + +/* +** enter first sweep phase (strings) and prepare pointers for other +** sweep phases. The calls to 'sweeptolive' make pointers point to an +** object inside the list (instead of to the header), so that the real +** sweep do not need to skip objects created between "now" and the start +** of the real sweep. +** Returns how many objects it swept. +*/ +static int entersweep (lua_State *L) { + global_State *g = G(L); + int n = 0; + g->gcstate = GCSsweepstring; + lua_assert(g->sweepgc == NULL && g->sweepfin == NULL); + /* prepare to sweep strings, finalizable objects, and regular objects */ + g->sweepstrgc = 0; + g->sweepfin = sweeptolive(L, &g->finobj, &n); + g->sweepgc = sweeptolive(L, &g->allgc, &n); + return n; +} + + +/* +** change GC mode +*/ +void luaC_changemode (lua_State *L, int mode) { + global_State *g = G(L); + if (mode == g->gckind) return; /* nothing to change */ + if (mode == KGC_GEN) { /* change to generational mode */ + /* make sure gray lists are consistent */ + luaC_runtilstate(L, bitmask(GCSpropagate)); + g->GCestimate = gettotalbytes(g); + g->gckind = KGC_GEN; + } + else { /* change to incremental mode */ + /* sweep all objects to turn them back to white + (as white has not changed, nothing extra will be collected) */ + g->gckind = KGC_NORMAL; + entersweep(L); + luaC_runtilstate(L, ~sweepphases); + } +} + + +/* +** call all pending finalizers +*/ +static void callallpendingfinalizers (lua_State *L, int propagateerrors) { + global_State *g = G(L); + while (g->tobefnz) { + resetoldbit(g->tobefnz); + GCTM(L, propagateerrors); + } +} + + +void luaC_freeallobjects (lua_State *L) { + global_State *g = G(L); + int i; + separatetobefnz(L, 1); /* separate all objects with finalizers */ + lua_assert(g->finobj == NULL); + callallpendingfinalizers(L, 0); + g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */ + g->gckind = KGC_NORMAL; + sweepwholelist(L, &g->finobj); /* finalizers can create objs. in 'finobj' */ + sweepwholelist(L, &g->allgc); + for (i = 0; i < g->strt.size; i++) /* free all string lists */ + sweepwholelist(L, &g->strt.hash[i]); + lua_assert(g->strt.nuse == 0); +} + + +static l_mem atomic (lua_State *L) { + global_State *g = G(L); + l_mem work = -cast(l_mem, g->GCmemtrav); /* start counting work */ + GCObject *origweak, *origall; + lua_assert(!iswhite(obj2gco(g->mainthread))); + markobject(g, L); /* mark running thread */ + /* registry and global metatables may be changed by API */ + markvalue(g, &g->l_registry); + markmt(g); /* mark basic metatables */ + /* remark occasional upvalues of (maybe) dead threads */ + remarkupvals(g); + propagateall(g); /* propagate changes */ + work += g->GCmemtrav; /* stop counting (do not (re)count grays) */ + /* traverse objects caught by write barrier and by 'remarkupvals' */ + retraversegrays(g); + work -= g->GCmemtrav; /* restart counting */ + convergeephemerons(g); + /* at this point, all strongly accessible objects are marked. */ + /* clear values from weak tables, before checking finalizers */ + clearvalues(g, g->weak, NULL); + clearvalues(g, g->allweak, NULL); + origweak = g->weak; origall = g->allweak; + work += g->GCmemtrav; /* stop counting (objects being finalized) */ + separatetobefnz(L, 0); /* separate objects to be finalized */ + markbeingfnz(g); /* mark objects that will be finalized */ + propagateall(g); /* remark, to propagate `preserveness' */ + work -= g->GCmemtrav; /* restart counting */ + convergeephemerons(g); + /* at this point, all resurrected objects are marked. */ + /* remove dead objects from weak tables */ + clearkeys(g, g->ephemeron, NULL); /* clear keys from all ephemeron tables */ + clearkeys(g, g->allweak, NULL); /* clear keys from all allweak tables */ + /* clear values from resurrected weak tables */ + clearvalues(g, g->weak, origweak); + clearvalues(g, g->allweak, origall); + g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */ + work += g->GCmemtrav; /* complete counting */ + return work; /* estimate of memory marked by 'atomic' */ +} + + +static lu_mem singlestep (lua_State *L) { + global_State *g = G(L); + switch (g->gcstate) { + case GCSpause: { + /* start to count memory traversed */ + g->GCmemtrav = g->strt.size * sizeof(GCObject*); + lua_assert(!isgenerational(g)); + restartcollection(g); + g->gcstate = GCSpropagate; + return g->GCmemtrav; + } + case GCSpropagate: { + if (g->gray) { + lu_mem oldtrav = g->GCmemtrav; + propagatemark(g); + return g->GCmemtrav - oldtrav; /* memory traversed in this step */ + } + else { /* no more `gray' objects */ + lu_mem work; + int sw; + g->gcstate = GCSatomic; /* finish mark phase */ + g->GCestimate = g->GCmemtrav; /* save what was counted */; + work = atomic(L); /* add what was traversed by 'atomic' */ + g->GCestimate += work; /* estimate of total memory traversed */ + sw = entersweep(L); + return work + sw * GCSWEEPCOST; + } + } + case GCSsweepstring: { + int i; + for (i = 0; i < GCSWEEPMAX && g->sweepstrgc + i < g->strt.size; i++) + sweepwholelist(L, &g->strt.hash[g->sweepstrgc + i]); + g->sweepstrgc += i; + if (g->sweepstrgc >= g->strt.size) /* no more strings to sweep? */ + g->gcstate = GCSsweepudata; + return i * GCSWEEPCOST; + } + case GCSsweepudata: { + if (g->sweepfin) { + g->sweepfin = sweeplist(L, g->sweepfin, GCSWEEPMAX); + return GCSWEEPMAX*GCSWEEPCOST; + } + else { + g->gcstate = GCSsweep; + return 0; + } + } + case GCSsweep: { + if (g->sweepgc) { + g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX); + return GCSWEEPMAX*GCSWEEPCOST; + } + else { + /* sweep main thread */ + GCObject *mt = obj2gco(g->mainthread); + sweeplist(L, &mt, 1); + checkSizes(L); + g->gcstate = GCSpause; /* finish collection */ + return GCSWEEPCOST; + } + } + default: lua_assert(0); return 0; + } +} + + +/* +** advances the garbage collector until it reaches a state allowed +** by 'statemask' +*/ +void luaC_runtilstate (lua_State *L, int statesmask) { + global_State *g = G(L); + while (!testbit(statesmask, g->gcstate)) + singlestep(L); +} + + +static void generationalcollection (lua_State *L) { + global_State *g = G(L); + lua_assert(g->gcstate == GCSpropagate); + if (g->GCestimate == 0) { /* signal for another major collection? */ + luaC_fullgc(L, 0); /* perform a full regular collection */ + g->GCestimate = gettotalbytes(g); /* update control */ + } + else { + lu_mem estimate = g->GCestimate; + luaC_runtilstate(L, bitmask(GCSpause)); /* run complete (minor) cycle */ + g->gcstate = GCSpropagate; /* skip restart */ + if (gettotalbytes(g) > (estimate / 100) * g->gcmajorinc) + g->GCestimate = 0; /* signal for a major collection */ + else + g->GCestimate = estimate; /* keep estimate from last major coll. */ + + } + setpause(g, gettotalbytes(g)); + lua_assert(g->gcstate == GCSpropagate); +} + + +static void incstep (lua_State *L) { + global_State *g = G(L); + l_mem debt = g->GCdebt; + int stepmul = g->gcstepmul; + if (stepmul < 40) stepmul = 40; /* avoid ridiculous low values (and 0) */ + /* convert debt from Kb to 'work units' (avoid zero debt and overflows) */ + debt = (debt / STEPMULADJ) + 1; + debt = (debt < MAX_LMEM / stepmul) ? debt * stepmul : MAX_LMEM; + do { /* always perform at least one single step */ + lu_mem work = singlestep(L); /* do some work */ + debt -= work; + } while (debt > -GCSTEPSIZE && g->gcstate != GCSpause); + if (g->gcstate == GCSpause) + setpause(g, g->GCestimate); /* pause until next cycle */ + else { + debt = (debt / stepmul) * STEPMULADJ; /* convert 'work units' to Kb */ + luaE_setdebt(g, debt); + } +} + + +/* +** performs a basic GC step +*/ +void luaC_forcestep (lua_State *L) { + global_State *g = G(L); + int i; + if (isgenerational(g)) generationalcollection(L); + else incstep(L); + /* run a few finalizers (or all of them at the end of a collect cycle) */ + for (i = 0; g->tobefnz && (i < GCFINALIZENUM || g->gcstate == GCSpause); i++) + GCTM(L, 1); /* call one finalizer */ +} + + +/* +** performs a basic GC step only if collector is running +*/ +void luaC_step (lua_State *L) { + global_State *g = G(L); + if (g->gcrunning) luaC_forcestep(L); + else luaE_setdebt(g, -GCSTEPSIZE); /* avoid being called too often */ +} + + + +/* +** performs a full GC cycle; if "isemergency", does not call +** finalizers (which could change stack positions) +*/ +void luaC_fullgc (lua_State *L, int isemergency) { + global_State *g = G(L); + int origkind = g->gckind; + lua_assert(origkind != KGC_EMERGENCY); + if (isemergency) /* do not run finalizers during emergency GC */ + g->gckind = KGC_EMERGENCY; + else { + g->gckind = KGC_NORMAL; + callallpendingfinalizers(L, 1); + } + if (keepinvariant(g)) { /* may there be some black objects? */ + /* must sweep all objects to turn them back to white + (as white has not changed, nothing will be collected) */ + entersweep(L); + } + /* finish any pending sweep phase to start a new cycle */ + luaC_runtilstate(L, bitmask(GCSpause)); + luaC_runtilstate(L, ~bitmask(GCSpause)); /* start new collection */ + luaC_runtilstate(L, bitmask(GCSpause)); /* run entire collection */ + if (origkind == KGC_GEN) { /* generational mode? */ + /* generational mode must be kept in propagate phase */ + luaC_runtilstate(L, bitmask(GCSpropagate)); + } + g->gckind = origkind; + setpause(g, gettotalbytes(g)); + if (!isemergency) /* do not run finalizers during emergency GC */ + callallpendingfinalizers(L, 1); +} + +/* }====================================================== */ + + diff --git a/extern/lua/src/lgc.h b/extern/lua/src/lgc.h new file mode 100644 index 0000000..84bb1cd --- /dev/null +++ b/extern/lua/src/lgc.h @@ -0,0 +1,157 @@ +/* +** $Id: lgc.h,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $ +** Garbage Collector +** See Copyright Notice in lua.h +*/ + +#ifndef lgc_h +#define lgc_h + + +#include "lobject.h" +#include "lstate.h" + +/* +** Collectable objects may have one of three colors: white, which +** means the object is not marked; gray, which means the +** object is marked, but its references may be not marked; and +** black, which means that the object and all its references are marked. +** The main invariant of the garbage collector, while marking objects, +** is that a black object can never point to a white one. Moreover, +** any gray object must be in a "gray list" (gray, grayagain, weak, +** allweak, ephemeron) so that it can be visited again before finishing +** the collection cycle. These lists have no meaning when the invariant +** is not being enforced (e.g., sweep phase). +*/ + + + +/* how much to allocate before next GC step */ +#if !defined(GCSTEPSIZE) +/* ~100 small strings */ +#define GCSTEPSIZE (cast_int(100 * sizeof(TString))) +#endif + + +/* +** Possible states of the Garbage Collector +*/ +#define GCSpropagate 0 +#define GCSatomic 1 +#define GCSsweepstring 2 +#define GCSsweepudata 3 +#define GCSsweep 4 +#define GCSpause 5 + + +#define issweepphase(g) \ + (GCSsweepstring <= (g)->gcstate && (g)->gcstate <= GCSsweep) + +#define isgenerational(g) ((g)->gckind == KGC_GEN) + +/* +** macros to tell when main invariant (white objects cannot point to black +** ones) must be kept. During a non-generational collection, the sweep +** phase may break the invariant, as objects turned white may point to +** still-black objects. The invariant is restored when sweep ends and +** all objects are white again. During a generational collection, the +** invariant must be kept all times. +*/ + +#define keepinvariant(g) (isgenerational(g) || g->gcstate <= GCSatomic) + + +/* +** Outside the collector, the state in generational mode is kept in +** 'propagate', so 'keepinvariant' is always true. +*/ +#define keepinvariantout(g) \ + check_exp(g->gcstate == GCSpropagate || !isgenerational(g), \ + g->gcstate <= GCSatomic) + + +/* +** some useful bit tricks +*/ +#define resetbits(x,m) ((x) &= cast(lu_byte, ~(m))) +#define setbits(x,m) ((x) |= (m)) +#define testbits(x,m) ((x) & (m)) +#define bitmask(b) (1<<(b)) +#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) +#define l_setbit(x,b) setbits(x, bitmask(b)) +#define resetbit(x,b) resetbits(x, bitmask(b)) +#define testbit(x,b) testbits(x, bitmask(b)) + + +/* Layout for bit use in `marked' field: */ +#define WHITE0BIT 0 /* object is white (type 0) */ +#define WHITE1BIT 1 /* object is white (type 1) */ +#define BLACKBIT 2 /* object is black */ +#define FINALIZEDBIT 3 /* object has been separated for finalization */ +#define SEPARATED 4 /* object is in 'finobj' list or in 'tobefnz' */ +#define FIXEDBIT 5 /* object is fixed (should not be collected) */ +#define OLDBIT 6 /* object is old (only in generational mode) */ +/* bit 7 is currently used by tests (luaL_checkmemory) */ + +#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) + + +#define iswhite(x) testbits((x)->gch.marked, WHITEBITS) +#define isblack(x) testbit((x)->gch.marked, BLACKBIT) +#define isgray(x) /* neither white nor black */ \ + (!testbits((x)->gch.marked, WHITEBITS | bitmask(BLACKBIT))) + +#define isold(x) testbit((x)->gch.marked, OLDBIT) + +/* MOVE OLD rule: whenever an object is moved to the beginning of + a GC list, its old bit must be cleared */ +#define resetoldbit(o) resetbit((o)->gch.marked, OLDBIT) + +#define otherwhite(g) (g->currentwhite ^ WHITEBITS) +#define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow))) +#define isdead(g,v) isdeadm(otherwhite(g), (v)->gch.marked) + +#define changewhite(x) ((x)->gch.marked ^= WHITEBITS) +#define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT) + +#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) + +#define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS) + + +#define luaC_condGC(L,c) \ + {if (G(L)->GCdebt > 0) {c;}; condchangemem(L);} +#define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);) + + +#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \ + luaC_barrier_(L,obj2gco(p),gcvalue(v)); } + +#define luaC_barrierback(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \ + luaC_barrierback_(L,p); } + +#define luaC_objbarrier(L,p,o) \ + { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \ + luaC_barrier_(L,obj2gco(p),obj2gco(o)); } + +#define luaC_objbarrierback(L,p,o) \ + { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) luaC_barrierback_(L,p); } + +#define luaC_barrierproto(L,p,c) \ + { if (isblack(obj2gco(p))) luaC_barrierproto_(L,p,c); } + +LUAI_FUNC void luaC_freeallobjects (lua_State *L); +LUAI_FUNC void luaC_step (lua_State *L); +LUAI_FUNC void luaC_forcestep (lua_State *L); +LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask); +LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency); +LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz, + GCObject **list, int offset); +LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v); +LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o); +LUAI_FUNC void luaC_barrierproto_ (lua_State *L, Proto *p, Closure *c); +LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt); +LUAI_FUNC void luaC_checkupvalcolor (global_State *g, UpVal *uv); +LUAI_FUNC void luaC_changemode (lua_State *L, int mode); + +#endif diff --git a/extern/lua/src/lgc.o b/extern/lua/src/lgc.o new file mode 100644 index 0000000000000000000000000000000000000000..52d8f7da21cc8bcec02891ea9a3649681e92ab4d GIT binary patch literal 17720 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 literal 0 HcmV?d00001 diff --git a/extern/lua/src/liblua.a b/extern/lua/src/liblua.a new file mode 100644 index 0000000000000000000000000000000000000000..41c657b9e2882cc49eb410b53469a5a901181a06 GIT binary patch literal 384420 zcmeFa4|r77nLmE>2N)8X8I?-vpE_!+p(0HXHBqcHWJ2!1Akh$@qD?}WKqMqFxdXup zgid0)drg~u>u%YtyUXs{uG@BZ>27P$cIgBV&?+0XQd(_|w%UpDPei2=|K$65&w0Xl^?>YC}d)|BDf`*R9^`FlBlz(CGz1=$Wp(jW*Aw2$nTZCMi%|X<{Q}!p3J{Z2aW7Z zzusL&_J{d>>(@rM{(Gq2$fn=X_de7w$G_W{@SAowvFu#9h^~{l23ZkSTZ@);N5kfpsJbvwUaM__R92g{z9ZVOR>*?d6M4$QP;Im}OL@h4 zx||ec;Y31;E9p{zE)WrD@=6Lc zZELvBNj)0Yw8*MPq^UXDBFl~HLR<(gPn)%KsZfomBr7^0{YFG503=FUeV~F`=A@9R z%n_N8IpQiqoTf6zc}klnW`-*hGlTezmeh;JhL#rDecIEfEp6PyYhxRkCxnl6ifq@( zeiiNLXp=498tsw-HMX@jHpo+@Psj-wv^6$~q!2`lwMI8jXb#ZE+9%YA9_909*#;cD z4GJhYH?NJhikz3!u@Ww+>yY)dqz;T*8rDRGZZ4^7Z?GEIld_1WT~e2pny*=H>!VVS z7-(tkWZt)NeNd{k(cr=g%3MW6h02JiQJhXNP$UtxIhd~#Rk@^2>hu!HMfPTnpsFB$ ztfN&?My2c(XRG+)D++@`4Q02x@D4hOf>3}I-)>@r^#

lQ3LyM|NVOpc2eNb^7(WYjuk>=LaX?t5|>KrF6 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 C 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 z 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

RI53nnY=7DioOwxs#gBaIZG@o~~&V#;g@IKb# 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 lib++) { + luaL_requiref(L, lib->name, lib->func, 1); + lua_pop(L, 1); /* remove lib */ + } + /* add open functions from 'preloadedlibs' into 'package.preload' table */ + luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD"); + for (lib = preloadedlibs; lib->func; lib++) { + lua_pushcfunction(L, lib->func); + lua_setfield(L, -2, lib->name); + } + lua_pop(L, 1); /* remove _PRELOAD table */ +} + diff --git a/extern/lua/src/linit.o b/extern/lua/src/linit.o new file mode 100644 index 0000000000000000000000000000000000000000..9fbf1f4bb089898729e948176837e39487abc556 GIT binary patch literal 3200 zcmds(O^g&(5XWnFP)3De#1EEWbYch~k(L3BXoSqlt~z*SJnYS*o(xyiaFL4_LO6g&j*^&wcVMi4cNP15JAKicmGo5Auj*C5_ximz z@9U|V565yjQpwSNTK1F@EsZVP)x@k)iPqAwqqW6HKLPxVpW4Eog>|n@vTE*UAQ&4&EVSaS04F|8Aj{B)@sns`a-;2$BOx~;?`{XsEh`fFX2k8~B zLP^{kblbsc(>}vdv`JIQYlfYU>2mXK7#nZ;lVdxgm_MdunO6N&-|rad<$qIUZjSZ$ zv{R-kzPlhwPTnT=SMgJI_}ynx@PqIoYrLl*{&*`d$r3qlPVSvV)rcwta=$ zqUJ7sY|;0BU_-X`{i>_N-1$p(qth0yw$sq3!mMK>4N2k^O%z>q{DbU|n*WQ>ripi@ z4(5L~Kkod0#tbPt`LX4Sw0qTtYzuy(u?m&hsW(Q!5xHlDx#Pbn?W=ZCwzdC?2W*TQ ze``&eq3aCee~uq*ul#vt?%F}il62@i9826`!FT(P^d(skJqfO3hAz49$2J-D{(|hE zI~=#geZL*EZRD+@zlJtbJ3sP^p&z4q0*)D8DS3KoC1jFcaheceIJsm6rcLa1owvAM zFi*0GZOC>$`H~JyxJ;TA!a2X*8n2#buQPYgGBkTDgYV1WwG4hDg9jP>s|>!F!N1Mm z-(~P0Gx#qV{I?8F?VuaPUX$9PKWk>&K_jB}z@MpyJ;Q%ysRz5>@FSCk`sT|)&^M>x z)gu$fVJ{8LnK&9W(pw3~l4g2qQGfaNqU4|Xe4Eh#-)hv9+l{*EEl0iNwxf>Rdi4Cp zid)N%3eF4&xb9u}+wjAJ?TxeLA>Y9uZv(P`W6vx97?1^Z>|Jvxp=mzWqvkg)Zr2f< ztZ3BH6|a56zPJ0YYaAT;ax9Xbf8aO+Rmx&$zTT5`yx{9Kne|R5U;i)mTKokoziM&x zXS4VBS^Q`u=M7>*ofBK@ fza#!di|gD1UA8#tzc2oh#W#u#RTdlT2an3%dT +#include +#include +#include + +#define liolib_c +#define LUA_LIB + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +#if !defined(lua_checkmode) + +/* +** Check whether 'mode' matches '[rwa]%+?b?'. +** Change this macro to accept other modes for 'fopen' besides +** the standard ones. +*/ +#define lua_checkmode(mode) \ + (*mode != '\0' && strchr("rwa", *(mode++)) != NULL && \ + (*mode != '+' || ++mode) && /* skip if char is '+' */ \ + (*mode != 'b' || ++mode) && /* skip if char is 'b' */ \ + (*mode == '\0')) + +#endif + +/* +** {====================================================== +** lua_popen spawns a new process connected to the current +** one through the file streams. +** ======================================================= +*/ + +#if !defined(lua_popen) /* { */ + +#if defined(LUA_USE_POPEN) /* { */ + +#define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m)) +#define lua_pclose(L,file) ((void)L, pclose(file)) + +#elif defined(LUA_WIN) /* }{ */ + +#define lua_popen(L,c,m) ((void)L, _popen(c,m)) +#define lua_pclose(L,file) ((void)L, _pclose(file)) + + +#else /* }{ */ + +#define lua_popen(L,c,m) ((void)((void)c, m), \ + luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0) +#define lua_pclose(L,file) ((void)((void)L, file), -1) + + +#endif /* } */ + +#endif /* } */ + +/* }====================================================== */ + + +/* +** {====================================================== +** lua_fseek: configuration for longer offsets +** ======================================================= +*/ + +#if !defined(lua_fseek) && !defined(LUA_ANSI) /* { */ + +#if defined(LUA_USE_POSIX) /* { */ + +#define l_fseek(f,o,w) fseeko(f,o,w) +#define l_ftell(f) ftello(f) +#define l_seeknum off_t + +#elif defined(LUA_WIN) && !defined(_CRTIMP_TYPEINFO) \ + && defined(_MSC_VER) && (_MSC_VER >= 1400) /* }{ */ +/* Windows (but not DDK) and Visual C++ 2005 or higher */ + +#define l_fseek(f,o,w) _fseeki64(f,o,w) +#define l_ftell(f) _ftelli64(f) +#define l_seeknum __int64 + +#endif /* } */ + +#endif /* } */ + + +#if !defined(l_fseek) /* default definitions */ +#define l_fseek(f,o,w) fseek(f,o,w) +#define l_ftell(f) ftell(f) +#define l_seeknum long +#endif + +/* }====================================================== */ + + +#define IO_PREFIX "_IO_" +#define IO_INPUT (IO_PREFIX "input") +#define IO_OUTPUT (IO_PREFIX "output") + + +typedef luaL_Stream LStream; + + +#define tolstream(L) ((LStream *)luaL_checkudata(L, 1, LUA_FILEHANDLE)) + +#define isclosed(p) ((p)->closef == NULL) + + +static int io_type (lua_State *L) { + LStream *p; + luaL_checkany(L, 1); + p = (LStream *)luaL_testudata(L, 1, LUA_FILEHANDLE); + if (p == NULL) + lua_pushnil(L); /* not a file */ + else if (isclosed(p)) + lua_pushliteral(L, "closed file"); + else + lua_pushliteral(L, "file"); + return 1; +} + + +static int f_tostring (lua_State *L) { + LStream *p = tolstream(L); + if (isclosed(p)) + lua_pushliteral(L, "file (closed)"); + else + lua_pushfstring(L, "file (%p)", p->f); + return 1; +} + + +static FILE *tofile (lua_State *L) { + LStream *p = tolstream(L); + if (isclosed(p)) + luaL_error(L, "attempt to use a closed file"); + lua_assert(p->f); + return p->f; +} + + +/* +** When creating file handles, always creates a `closed' file handle +** before opening the actual file; so, if there is a memory error, the +** file is not left opened. +*/ +static LStream *newprefile (lua_State *L) { + LStream *p = (LStream *)lua_newuserdata(L, sizeof(LStream)); + p->closef = NULL; /* mark file handle as 'closed' */ + luaL_setmetatable(L, LUA_FILEHANDLE); + return p; +} + + +static int aux_close (lua_State *L) { + LStream *p = tolstream(L); + lua_CFunction cf = p->closef; + p->closef = NULL; /* mark stream as closed */ + return (*cf)(L); /* close it */ +} + + +static int io_close (lua_State *L) { + if (lua_isnone(L, 1)) /* no argument? */ + lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT); /* use standard output */ + tofile(L); /* make sure argument is an open stream */ + return aux_close(L); +} + + +static int f_gc (lua_State *L) { + LStream *p = tolstream(L); + if (!isclosed(p) && p->f != NULL) + aux_close(L); /* ignore closed and incompletely open files */ + return 0; +} + + +/* +** function to close regular files +*/ +static int io_fclose (lua_State *L) { + LStream *p = tolstream(L); + int res = fclose(p->f); + return luaL_fileresult(L, (res == 0), NULL); +} + + +static LStream *newfile (lua_State *L) { + LStream *p = newprefile(L); + p->f = NULL; + p->closef = &io_fclose; + return p; +} + + +static void opencheck (lua_State *L, const char *fname, const char *mode) { + LStream *p = newfile(L); + p->f = fopen(fname, mode); + if (p->f == NULL) + luaL_error(L, "cannot open file " LUA_QS " (%s)", fname, strerror(errno)); +} + + +static int io_open (lua_State *L) { + const char *filename = luaL_checkstring(L, 1); + const char *mode = luaL_optstring(L, 2, "r"); + LStream *p = newfile(L); + const char *md = mode; /* to traverse/check mode */ + luaL_argcheck(L, lua_checkmode(md), 2, "invalid mode"); + p->f = fopen(filename, mode); + return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1; +} + + +/* +** function to close 'popen' files +*/ +static int io_pclose (lua_State *L) { + LStream *p = tolstream(L); + return luaL_execresult(L, lua_pclose(L, p->f)); +} + + +static int io_popen (lua_State *L) { + const char *filename = luaL_checkstring(L, 1); + const char *mode = luaL_optstring(L, 2, "r"); + LStream *p = newprefile(L); + p->f = lua_popen(L, filename, mode); + p->closef = &io_pclose; + return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1; +} + + +static int io_tmpfile (lua_State *L) { + LStream *p = newfile(L); + p->f = tmpfile(); + return (p->f == NULL) ? luaL_fileresult(L, 0, NULL) : 1; +} + + +static FILE *getiofile (lua_State *L, const char *findex) { + LStream *p; + lua_getfield(L, LUA_REGISTRYINDEX, findex); + p = (LStream *)lua_touserdata(L, -1); + if (isclosed(p)) + luaL_error(L, "standard %s file is closed", findex + strlen(IO_PREFIX)); + return p->f; +} + + +static int g_iofile (lua_State *L, const char *f, const char *mode) { + if (!lua_isnoneornil(L, 1)) { + const char *filename = lua_tostring(L, 1); + if (filename) + opencheck(L, filename, mode); + else { + tofile(L); /* check that it's a valid file handle */ + lua_pushvalue(L, 1); + } + lua_setfield(L, LUA_REGISTRYINDEX, f); + } + /* return current value */ + lua_getfield(L, LUA_REGISTRYINDEX, f); + return 1; +} + + +static int io_input (lua_State *L) { + return g_iofile(L, IO_INPUT, "r"); +} + + +static int io_output (lua_State *L) { + return g_iofile(L, IO_OUTPUT, "w"); +} + + +static int io_readline (lua_State *L); + + +static void aux_lines (lua_State *L, int toclose) { + int i; + int n = lua_gettop(L) - 1; /* number of arguments to read */ + /* ensure that arguments will fit here and into 'io_readline' stack */ + luaL_argcheck(L, n <= LUA_MINSTACK - 3, LUA_MINSTACK - 3, "too many options"); + lua_pushvalue(L, 1); /* file handle */ + lua_pushinteger(L, n); /* number of arguments to read */ + lua_pushboolean(L, toclose); /* close/not close file when finished */ + for (i = 1; i <= n; i++) lua_pushvalue(L, i + 1); /* copy arguments */ + lua_pushcclosure(L, io_readline, 3 + n); +} + + +static int f_lines (lua_State *L) { + tofile(L); /* check that it's a valid file handle */ + aux_lines(L, 0); + return 1; +} + + +static int io_lines (lua_State *L) { + int toclose; + if (lua_isnone(L, 1)) lua_pushnil(L); /* at least one argument */ + if (lua_isnil(L, 1)) { /* no file name? */ + lua_getfield(L, LUA_REGISTRYINDEX, IO_INPUT); /* get default input */ + lua_replace(L, 1); /* put it at index 1 */ + tofile(L); /* check that it's a valid file handle */ + toclose = 0; /* do not close it after iteration */ + } + else { /* open a new file */ + const char *filename = luaL_checkstring(L, 1); + opencheck(L, filename, "r"); + lua_replace(L, 1); /* put file at index 1 */ + toclose = 1; /* close it after iteration */ + } + aux_lines(L, toclose); + return 1; +} + + +/* +** {====================================================== +** READ +** ======================================================= +*/ + + +static int read_number (lua_State *L, FILE *f) { + lua_Number d; + if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) { + lua_pushnumber(L, d); + return 1; + } + else { + lua_pushnil(L); /* "result" to be removed */ + return 0; /* read fails */ + } +} + + +static int test_eof (lua_State *L, FILE *f) { + int c = getc(f); + ungetc(c, f); + lua_pushlstring(L, NULL, 0); + return (c != EOF); +} + + +static int read_line (lua_State *L, FILE *f, int chop) { + luaL_Buffer b; + luaL_buffinit(L, &b); + for (;;) { + size_t l; + char *p = luaL_prepbuffer(&b); + if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) { /* eof? */ + luaL_pushresult(&b); /* close buffer */ + return (lua_rawlen(L, -1) > 0); /* check whether read something */ + } + l = strlen(p); + if (l == 0 || p[l-1] != '\n') + luaL_addsize(&b, l); + else { + luaL_addsize(&b, l - chop); /* chop 'eol' if needed */ + luaL_pushresult(&b); /* close buffer */ + return 1; /* read at least an `eol' */ + } + } +} + + +#define MAX_SIZE_T (~(size_t)0) + +static void read_all (lua_State *L, FILE *f) { + size_t rlen = LUAL_BUFFERSIZE; /* how much to read in each cycle */ + luaL_Buffer b; + luaL_buffinit(L, &b); + for (;;) { + char *p = luaL_prepbuffsize(&b, rlen); + size_t nr = fread(p, sizeof(char), rlen, f); + luaL_addsize(&b, nr); + if (nr < rlen) break; /* eof? */ + else if (rlen <= (MAX_SIZE_T / 4)) /* avoid buffers too large */ + rlen *= 2; /* double buffer size at each iteration */ + } + luaL_pushresult(&b); /* close buffer */ +} + + +static int read_chars (lua_State *L, FILE *f, size_t n) { + size_t nr; /* number of chars actually read */ + char *p; + luaL_Buffer b; + luaL_buffinit(L, &b); + p = luaL_prepbuffsize(&b, n); /* prepare buffer to read whole block */ + nr = fread(p, sizeof(char), n, f); /* try to read 'n' chars */ + luaL_addsize(&b, nr); + luaL_pushresult(&b); /* close buffer */ + return (nr > 0); /* true iff read something */ +} + + +static int g_read (lua_State *L, FILE *f, int first) { + int nargs = lua_gettop(L) - 1; + int success; + int n; + clearerr(f); + if (nargs == 0) { /* no arguments? */ + success = read_line(L, f, 1); + n = first+1; /* to return 1 result */ + } + else { /* ensure stack space for all results and for auxlib's buffer */ + luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments"); + success = 1; + for (n = first; nargs-- && success; n++) { + if (lua_type(L, n) == LUA_TNUMBER) { + size_t l = (size_t)lua_tointeger(L, n); + success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l); + } + else { + const char *p = lua_tostring(L, n); + luaL_argcheck(L, p && p[0] == '*', n, "invalid option"); + switch (p[1]) { + case 'n': /* number */ + success = read_number(L, f); + break; + case 'l': /* line */ + success = read_line(L, f, 1); + break; + case 'L': /* line with end-of-line */ + success = read_line(L, f, 0); + break; + case 'a': /* file */ + read_all(L, f); /* read entire file */ + success = 1; /* always success */ + break; + default: + return luaL_argerror(L, n, "invalid format"); + } + } + } + } + if (ferror(f)) + return luaL_fileresult(L, 0, NULL); + if (!success) { + lua_pop(L, 1); /* remove last result */ + lua_pushnil(L); /* push nil instead */ + } + return n - first; +} + + +static int io_read (lua_State *L) { + return g_read(L, getiofile(L, IO_INPUT), 1); +} + + +static int f_read (lua_State *L) { + return g_read(L, tofile(L), 2); +} + + +static int io_readline (lua_State *L) { + LStream *p = (LStream *)lua_touserdata(L, lua_upvalueindex(1)); + int i; + int n = (int)lua_tointeger(L, lua_upvalueindex(2)); + if (isclosed(p)) /* file is already closed? */ + return luaL_error(L, "file is already closed"); + lua_settop(L , 1); + for (i = 1; i <= n; i++) /* push arguments to 'g_read' */ + lua_pushvalue(L, lua_upvalueindex(3 + i)); + n = g_read(L, p->f, 2); /* 'n' is number of results */ + lua_assert(n > 0); /* should return at least a nil */ + if (!lua_isnil(L, -n)) /* read at least one value? */ + return n; /* return them */ + else { /* first result is nil: EOF or error */ + if (n > 1) { /* is there error information? */ + /* 2nd result is error message */ + return luaL_error(L, "%s", lua_tostring(L, -n + 1)); + } + if (lua_toboolean(L, lua_upvalueindex(3))) { /* generator created file? */ + lua_settop(L, 0); + lua_pushvalue(L, lua_upvalueindex(1)); + aux_close(L); /* close it */ + } + return 0; + } +} + +/* }====================================================== */ + + +static int g_write (lua_State *L, FILE *f, int arg) { + int nargs = lua_gettop(L) - arg; + int status = 1; + for (; nargs--; arg++) { + if (lua_type(L, arg) == LUA_TNUMBER) { + /* optimization: could be done exactly as for strings */ + status = status && + fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0; + } + else { + size_t l; + const char *s = luaL_checklstring(L, arg, &l); + status = status && (fwrite(s, sizeof(char), l, f) == l); + } + } + if (status) return 1; /* file handle already on stack top */ + else return luaL_fileresult(L, status, NULL); +} + + +static int io_write (lua_State *L) { + return g_write(L, getiofile(L, IO_OUTPUT), 1); +} + + +static int f_write (lua_State *L) { + FILE *f = tofile(L); + lua_pushvalue(L, 1); /* push file at the stack top (to be returned) */ + return g_write(L, f, 2); +} + + +static int f_seek (lua_State *L) { + static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END}; + static const char *const modenames[] = {"set", "cur", "end", NULL}; + FILE *f = tofile(L); + int op = luaL_checkoption(L, 2, "cur", modenames); + lua_Number p3 = luaL_optnumber(L, 3, 0); + l_seeknum offset = (l_seeknum)p3; + luaL_argcheck(L, (lua_Number)offset == p3, 3, + "not an integer in proper range"); + op = l_fseek(f, offset, mode[op]); + if (op) + return luaL_fileresult(L, 0, NULL); /* error */ + else { + lua_pushnumber(L, (lua_Number)l_ftell(f)); + return 1; + } +} + + +static int f_setvbuf (lua_State *L) { + static const int mode[] = {_IONBF, _IOFBF, _IOLBF}; + static const char *const modenames[] = {"no", "full", "line", NULL}; + FILE *f = tofile(L); + int op = luaL_checkoption(L, 2, NULL, modenames); + lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE); + int res = setvbuf(f, NULL, mode[op], sz); + return luaL_fileresult(L, res == 0, NULL); +} + + + +static int io_flush (lua_State *L) { + return luaL_fileresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL); +} + + +static int f_flush (lua_State *L) { + return luaL_fileresult(L, fflush(tofile(L)) == 0, NULL); +} + + +/* +** functions for 'io' library +*/ +static const luaL_Reg iolib[] = { + {"close", io_close}, + {"flush", io_flush}, + {"input", io_input}, + {"lines", io_lines}, + {"open", io_open}, + {"output", io_output}, + {"popen", io_popen}, + {"read", io_read}, + {"tmpfile", io_tmpfile}, + {"type", io_type}, + {"write", io_write}, + {NULL, NULL} +}; + + +/* +** methods for file handles +*/ +static const luaL_Reg flib[] = { + {"close", io_close}, + {"flush", f_flush}, + {"lines", f_lines}, + {"read", f_read}, + {"seek", f_seek}, + {"setvbuf", f_setvbuf}, + {"write", f_write}, + {"__gc", f_gc}, + {"__tostring", f_tostring}, + {NULL, NULL} +}; + + +static void createmeta (lua_State *L) { + luaL_newmetatable(L, LUA_FILEHANDLE); /* create metatable for file handles */ + lua_pushvalue(L, -1); /* push metatable */ + lua_setfield(L, -2, "__index"); /* metatable.__index = metatable */ + luaL_setfuncs(L, flib, 0); /* add file methods to new metatable */ + lua_pop(L, 1); /* pop new metatable */ +} + + +/* +** function to (not) close the standard files stdin, stdout, and stderr +*/ +static int io_noclose (lua_State *L) { + LStream *p = tolstream(L); + p->closef = &io_noclose; /* keep file opened */ + lua_pushnil(L); + lua_pushliteral(L, "cannot close standard file"); + return 2; +} + + +static void createstdfile (lua_State *L, FILE *f, const char *k, + const char *fname) { + LStream *p = newprefile(L); + p->f = f; + p->closef = &io_noclose; + if (k != NULL) { + lua_pushvalue(L, -1); + lua_setfield(L, LUA_REGISTRYINDEX, k); /* add file to registry */ + } + lua_setfield(L, -2, fname); /* add file to module */ +} + + +LUAMOD_API int luaopen_io (lua_State *L) { + luaL_newlib(L, iolib); /* new module */ + createmeta(L); + /* create (and set) default files */ + createstdfile(L, stdin, IO_INPUT, "stdin"); + createstdfile(L, stdout, IO_OUTPUT, "stdout"); + createstdfile(L, stderr, NULL, "stderr"); + return 1; +} + diff --git a/extern/lua/src/liolib.o b/extern/lua/src/liolib.o new file mode 100644 index 0000000000000000000000000000000000000000..75117b999379646871d750eb55cc35802126301a GIT binary patch literal 19896 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 E2j4gf8UO$Q literal 0 HcmV?d00001 diff --git a/extern/lua/src/llex.c b/extern/lua/src/llex.c new file mode 100644 index 0000000..c4b820e --- /dev/null +++ b/extern/lua/src/llex.c @@ -0,0 +1,530 @@ +/* +** $Id: llex.c,v 2.63.1.2 2013/08/30 15:49:41 roberto Exp $ +** Lexical Analyzer +** See Copyright Notice in lua.h +*/ + + +#include +#include + +#define llex_c +#define LUA_CORE + +#include "lua.h" + +#include "lctype.h" +#include "ldo.h" +#include "llex.h" +#include "lobject.h" +#include "lparser.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "lzio.h" + + + +#define next(ls) (ls->current = zgetc(ls->z)) + + + +#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') + + +/* ORDER RESERVED */ +static const char *const luaX_tokens [] = { + "and", "break", "do", "else", "elseif", + "end", "false", "for", "function", "goto", "if", + "in", "local", "nil", "not", "or", "repeat", + "return", "then", "true", "until", "while", + "..", "...", "==", ">=", "<=", "~=", "::", "", + "", "", "" +}; + + +#define save_and_next(ls) (save(ls, ls->current), next(ls)) + + +static l_noret lexerror (LexState *ls, const char *msg, int token); + + +static void save (LexState *ls, int c) { + Mbuffer *b = ls->buff; + if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { + size_t newsize; + if (luaZ_sizebuffer(b) >= MAX_SIZET/2) + lexerror(ls, "lexical element too long", 0); + newsize = luaZ_sizebuffer(b) * 2; + luaZ_resizebuffer(ls->L, b, newsize); + } + b->buffer[luaZ_bufflen(b)++] = cast(char, c); +} + + +void luaX_init (lua_State *L) { + int i; + for (i=0; itsv.extra = cast_byte(i+1); /* reserved word */ + } +} + + +const char *luaX_token2str (LexState *ls, int token) { + if (token < FIRST_RESERVED) { /* single-byte symbols? */ + lua_assert(token == cast(unsigned char, token)); + return (lisprint(token)) ? luaO_pushfstring(ls->L, LUA_QL("%c"), token) : + luaO_pushfstring(ls->L, "char(%d)", token); + } + else { + const char *s = luaX_tokens[token - FIRST_RESERVED]; + if (token < TK_EOS) /* fixed format (symbols and reserved words)? */ + return luaO_pushfstring(ls->L, LUA_QS, s); + else /* names, strings, and numerals */ + return s; + } +} + + +static const char *txtToken (LexState *ls, int token) { + switch (token) { + case TK_NAME: + case TK_STRING: + case TK_NUMBER: + save(ls, '\0'); + return luaO_pushfstring(ls->L, LUA_QS, luaZ_buffer(ls->buff)); + default: + return luaX_token2str(ls, token); + } +} + + +static l_noret lexerror (LexState *ls, const char *msg, int token) { + char buff[LUA_IDSIZE]; + luaO_chunkid(buff, getstr(ls->source), LUA_IDSIZE); + msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg); + if (token) + luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token)); + luaD_throw(ls->L, LUA_ERRSYNTAX); +} + + +l_noret luaX_syntaxerror (LexState *ls, const char *msg) { + lexerror(ls, msg, ls->t.token); +} + + +/* +** creates a new string and anchors it in function's table so that +** it will not be collected until the end of the function's compilation +** (by that time it should be anchored in function's prototype) +*/ +TString *luaX_newstring (LexState *ls, const char *str, size_t l) { + lua_State *L = ls->L; + TValue *o; /* entry for `str' */ + TString *ts = luaS_newlstr(L, str, l); /* create new string */ + setsvalue2s(L, L->top++, ts); /* temporarily anchor it in stack */ + o = luaH_set(L, ls->fs->h, L->top - 1); + if (ttisnil(o)) { /* not in use yet? (see 'addK') */ + /* boolean value does not need GC barrier; + table has no metatable, so it does not need to invalidate cache */ + setbvalue(o, 1); /* t[string] = true */ + luaC_checkGC(L); + } + else { /* string already present */ + ts = rawtsvalue(keyfromval(o)); /* re-use value previously stored */ + } + L->top--; /* remove string from stack */ + return ts; +} + + +/* +** increment line number and skips newline sequence (any of +** \n, \r, \n\r, or \r\n) +*/ +static void inclinenumber (LexState *ls) { + int old = ls->current; + lua_assert(currIsNewline(ls)); + next(ls); /* skip `\n' or `\r' */ + if (currIsNewline(ls) && ls->current != old) + next(ls); /* skip `\n\r' or `\r\n' */ + if (++ls->linenumber >= MAX_INT) + luaX_syntaxerror(ls, "chunk has too many lines"); +} + + +void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source, + int firstchar) { + ls->decpoint = '.'; + ls->L = L; + ls->current = firstchar; + ls->lookahead.token = TK_EOS; /* no look-ahead token */ + ls->z = z; + ls->fs = NULL; + ls->linenumber = 1; + ls->lastline = 1; + ls->source = source; + ls->envn = luaS_new(L, LUA_ENV); /* create env name */ + luaS_fix(ls->envn); /* never collect this name */ + luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */ +} + + + +/* +** ======================================================= +** LEXICAL ANALYZER +** ======================================================= +*/ + + + +static int check_next (LexState *ls, const char *set) { + if (ls->current == '\0' || !strchr(set, ls->current)) + return 0; + save_and_next(ls); + return 1; +} + + +/* +** change all characters 'from' in buffer to 'to' +*/ +static void buffreplace (LexState *ls, char from, char to) { + size_t n = luaZ_bufflen(ls->buff); + char *p = luaZ_buffer(ls->buff); + while (n--) + if (p[n] == from) p[n] = to; +} + + +#if !defined(getlocaledecpoint) +#define getlocaledecpoint() (localeconv()->decimal_point[0]) +#endif + + +#define buff2d(b,e) luaO_str2d(luaZ_buffer(b), luaZ_bufflen(b) - 1, e) + +/* +** in case of format error, try to change decimal point separator to +** the one defined in the current locale and check again +*/ +static void trydecpoint (LexState *ls, SemInfo *seminfo) { + char old = ls->decpoint; + ls->decpoint = getlocaledecpoint(); + buffreplace(ls, old, ls->decpoint); /* try new decimal separator */ + if (!buff2d(ls->buff, &seminfo->r)) { + /* format error with correct decimal point: no more options */ + buffreplace(ls, ls->decpoint, '.'); /* undo change (for error message) */ + lexerror(ls, "malformed number", TK_NUMBER); + } +} + + +/* LUA_NUMBER */ +/* +** this function is quite liberal in what it accepts, as 'luaO_str2d' +** will reject ill-formed numerals. +*/ +static void read_numeral (LexState *ls, SemInfo *seminfo) { + const char *expo = "Ee"; + int first = ls->current; + lua_assert(lisdigit(ls->current)); + save_and_next(ls); + if (first == '0' && check_next(ls, "Xx")) /* hexadecimal? */ + expo = "Pp"; + for (;;) { + if (check_next(ls, expo)) /* exponent part? */ + check_next(ls, "+-"); /* optional exponent sign */ + if (lisxdigit(ls->current) || ls->current == '.') + save_and_next(ls); + else break; + } + save(ls, '\0'); + buffreplace(ls, '.', ls->decpoint); /* follow locale for decimal point */ + if (!buff2d(ls->buff, &seminfo->r)) /* format error? */ + trydecpoint(ls, seminfo); /* try to update decimal point separator */ +} + + +/* +** skip a sequence '[=*[' or ']=*]' and return its number of '='s or +** -1 if sequence is malformed +*/ +static int skip_sep (LexState *ls) { + int count = 0; + int s = ls->current; + lua_assert(s == '[' || s == ']'); + save_and_next(ls); + while (ls->current == '=') { + save_and_next(ls); + count++; + } + return (ls->current == s) ? count : (-count) - 1; +} + + +static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) { + save_and_next(ls); /* skip 2nd `[' */ + if (currIsNewline(ls)) /* string starts with a newline? */ + inclinenumber(ls); /* skip it */ + for (;;) { + switch (ls->current) { + case EOZ: + lexerror(ls, (seminfo) ? "unfinished long string" : + "unfinished long comment", TK_EOS); + break; /* to avoid warnings */ + case ']': { + if (skip_sep(ls) == sep) { + save_and_next(ls); /* skip 2nd `]' */ + goto endloop; + } + break; + } + case '\n': case '\r': { + save(ls, '\n'); + inclinenumber(ls); + if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */ + break; + } + default: { + if (seminfo) save_and_next(ls); + else next(ls); + } + } + } endloop: + if (seminfo) + seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep), + luaZ_bufflen(ls->buff) - 2*(2 + sep)); +} + + +static void escerror (LexState *ls, int *c, int n, const char *msg) { + int i; + luaZ_resetbuffer(ls->buff); /* prepare error message */ + save(ls, '\\'); + for (i = 0; i < n && c[i] != EOZ; i++) + save(ls, c[i]); + lexerror(ls, msg, TK_STRING); +} + + +static int readhexaesc (LexState *ls) { + int c[3], i; /* keep input for error message */ + int r = 0; /* result accumulator */ + c[0] = 'x'; /* for error message */ + for (i = 1; i < 3; i++) { /* read two hexadecimal digits */ + c[i] = next(ls); + if (!lisxdigit(c[i])) + escerror(ls, c, i + 1, "hexadecimal digit expected"); + r = (r << 4) + luaO_hexavalue(c[i]); + } + return r; +} + + +static int readdecesc (LexState *ls) { + int c[3], i; + int r = 0; /* result accumulator */ + for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */ + c[i] = ls->current; + r = 10*r + c[i] - '0'; + next(ls); + } + if (r > UCHAR_MAX) + escerror(ls, c, i, "decimal escape too large"); + return r; +} + + +static void read_string (LexState *ls, int del, SemInfo *seminfo) { + save_and_next(ls); /* keep delimiter (for error messages) */ + while (ls->current != del) { + switch (ls->current) { + case EOZ: + lexerror(ls, "unfinished string", TK_EOS); + break; /* to avoid warnings */ + case '\n': + case '\r': + lexerror(ls, "unfinished string", TK_STRING); + break; /* to avoid warnings */ + case '\\': { /* escape sequences */ + int c; /* final character to be saved */ + next(ls); /* do not save the `\' */ + switch (ls->current) { + case 'a': c = '\a'; goto read_save; + case 'b': c = '\b'; goto read_save; + case 'f': c = '\f'; goto read_save; + case 'n': c = '\n'; goto read_save; + case 'r': c = '\r'; goto read_save; + case 't': c = '\t'; goto read_save; + case 'v': c = '\v'; goto read_save; + case 'x': c = readhexaesc(ls); goto read_save; + case '\n': case '\r': + inclinenumber(ls); c = '\n'; goto only_save; + case '\\': case '\"': case '\'': + c = ls->current; goto read_save; + case EOZ: goto no_save; /* will raise an error next loop */ + case 'z': { /* zap following span of spaces */ + next(ls); /* skip the 'z' */ + while (lisspace(ls->current)) { + if (currIsNewline(ls)) inclinenumber(ls); + else next(ls); + } + goto no_save; + } + default: { + if (!lisdigit(ls->current)) + escerror(ls, &ls->current, 1, "invalid escape sequence"); + /* digital escape \ddd */ + c = readdecesc(ls); + goto only_save; + } + } + read_save: next(ls); /* read next character */ + only_save: save(ls, c); /* save 'c' */ + no_save: break; + } + default: + save_and_next(ls); + } + } + save_and_next(ls); /* skip delimiter */ + seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1, + luaZ_bufflen(ls->buff) - 2); +} + + +static int llex (LexState *ls, SemInfo *seminfo) { + luaZ_resetbuffer(ls->buff); + for (;;) { + switch (ls->current) { + case '\n': case '\r': { /* line breaks */ + inclinenumber(ls); + break; + } + case ' ': case '\f': case '\t': case '\v': { /* spaces */ + next(ls); + break; + } + case '-': { /* '-' or '--' (comment) */ + next(ls); + if (ls->current != '-') return '-'; + /* else is a comment */ + next(ls); + if (ls->current == '[') { /* long comment? */ + int sep = skip_sep(ls); + luaZ_resetbuffer(ls->buff); /* `skip_sep' may dirty the buffer */ + if (sep >= 0) { + read_long_string(ls, NULL, sep); /* skip long comment */ + luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */ + break; + } + } + /* else short comment */ + while (!currIsNewline(ls) && ls->current != EOZ) + next(ls); /* skip until end of line (or end of file) */ + break; + } + case '[': { /* long string or simply '[' */ + int sep = skip_sep(ls); + if (sep >= 0) { + read_long_string(ls, seminfo, sep); + return TK_STRING; + } + else if (sep == -1) return '['; + else lexerror(ls, "invalid long string delimiter", TK_STRING); + } + case '=': { + next(ls); + if (ls->current != '=') return '='; + else { next(ls); return TK_EQ; } + } + case '<': { + next(ls); + if (ls->current != '=') return '<'; + else { next(ls); return TK_LE; } + } + case '>': { + next(ls); + if (ls->current != '=') return '>'; + else { next(ls); return TK_GE; } + } + case '~': { + next(ls); + if (ls->current != '=') return '~'; + else { next(ls); return TK_NE; } + } + case ':': { + next(ls); + if (ls->current != ':') return ':'; + else { next(ls); return TK_DBCOLON; } + } + case '"': case '\'': { /* short literal strings */ + read_string(ls, ls->current, seminfo); + return TK_STRING; + } + case '.': { /* '.', '..', '...', or number */ + save_and_next(ls); + if (check_next(ls, ".")) { + if (check_next(ls, ".")) + return TK_DOTS; /* '...' */ + else return TK_CONCAT; /* '..' */ + } + else if (!lisdigit(ls->current)) return '.'; + /* else go through */ + } + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': { + read_numeral(ls, seminfo); + return TK_NUMBER; + } + case EOZ: { + return TK_EOS; + } + default: { + if (lislalpha(ls->current)) { /* identifier or reserved word? */ + TString *ts; + do { + save_and_next(ls); + } while (lislalnum(ls->current)); + ts = luaX_newstring(ls, luaZ_buffer(ls->buff), + luaZ_bufflen(ls->buff)); + seminfo->ts = ts; + if (isreserved(ts)) /* reserved word? */ + return ts->tsv.extra - 1 + FIRST_RESERVED; + else { + return TK_NAME; + } + } + else { /* single-char tokens (+ - / ...) */ + int c = ls->current; + next(ls); + return c; + } + } + } + } +} + + +void luaX_next (LexState *ls) { + ls->lastline = ls->linenumber; + if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */ + ls->t = ls->lookahead; /* use this one */ + ls->lookahead.token = TK_EOS; /* and discharge it */ + } + else + ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */ +} + + +int luaX_lookahead (LexState *ls) { + lua_assert(ls->lookahead.token == TK_EOS); + ls->lookahead.token = llex(ls, &ls->lookahead.seminfo); + return ls->lookahead.token; +} + diff --git a/extern/lua/src/llex.h b/extern/lua/src/llex.h new file mode 100644 index 0000000..a4acdd3 --- /dev/null +++ b/extern/lua/src/llex.h @@ -0,0 +1,78 @@ +/* +** $Id: llex.h,v 1.72.1.1 2013/04/12 18:48:47 roberto Exp $ +** Lexical Analyzer +** See Copyright Notice in lua.h +*/ + +#ifndef llex_h +#define llex_h + +#include "lobject.h" +#include "lzio.h" + + +#define FIRST_RESERVED 257 + + + +/* +* WARNING: if you change the order of this enumeration, +* grep "ORDER RESERVED" +*/ +enum RESERVED { + /* terminal symbols denoted by reserved words */ + TK_AND = FIRST_RESERVED, TK_BREAK, + TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION, + TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT, + TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE, + /* other terminal symbols */ + TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_DBCOLON, TK_EOS, + TK_NUMBER, TK_NAME, TK_STRING +}; + +/* number of reserved words */ +#define NUM_RESERVED (cast(int, TK_WHILE-FIRST_RESERVED+1)) + + +typedef union { + lua_Number r; + TString *ts; +} SemInfo; /* semantics information */ + + +typedef struct Token { + int token; + SemInfo seminfo; +} Token; + + +/* state of the lexer plus state of the parser when shared by all + functions */ +typedef struct LexState { + int current; /* current character (charint) */ + int linenumber; /* input line counter */ + int lastline; /* line of last token `consumed' */ + Token t; /* current token */ + Token lookahead; /* look ahead token */ + struct FuncState *fs; /* current function (parser) */ + struct lua_State *L; + ZIO *z; /* input stream */ + Mbuffer *buff; /* buffer for tokens */ + struct Dyndata *dyd; /* dynamic structures used by the parser */ + TString *source; /* current source name */ + TString *envn; /* environment variable name */ + char decpoint; /* locale decimal point */ +} LexState; + + +LUAI_FUNC void luaX_init (lua_State *L); +LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, + TString *source, int firstchar); +LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l); +LUAI_FUNC void luaX_next (LexState *ls); +LUAI_FUNC int luaX_lookahead (LexState *ls); +LUAI_FUNC l_noret luaX_syntaxerror (LexState *ls, const char *s); +LUAI_FUNC const char *luaX_token2str (LexState *ls, int token); + + +#endif diff --git a/extern/lua/src/llex.o b/extern/lua/src/llex.o new file mode 100644 index 0000000000000000000000000000000000000000..36d2106195f4ecb894f71ba84ac9f8feec10c170 GIT binary patch literal 20848 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 +#include + + +#include "lua.h" + + +typedef unsigned LUA_INT32 lu_int32; + +typedef LUAI_UMEM lu_mem; + +typedef LUAI_MEM l_mem; + + + +/* chars used as small naturals (so that `char' is reserved for characters) */ +typedef unsigned char lu_byte; + + +#define MAX_SIZET ((size_t)(~(size_t)0)-2) + +#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)-2) + +#define MAX_LMEM ((l_mem) ((MAX_LUMEM >> 1) - 2)) + + +#define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */ + +/* +** conversion of pointer to integer +** this is for hashing only; there is no problem if the integer +** cannot hold the whole pointer value +*/ +#define IntPoint(p) ((unsigned int)(lu_mem)(p)) + + + +/* type to ensure maximum alignment */ +#if !defined(LUAI_USER_ALIGNMENT_T) +#define LUAI_USER_ALIGNMENT_T union { double u; void *s; long l; } +#endif + +typedef LUAI_USER_ALIGNMENT_T L_Umaxalign; + + +/* result of a `usual argument conversion' over lua_Number */ +typedef LUAI_UACNUMBER l_uacNumber; + + +/* internal assertions for in-house debugging */ +#if defined(lua_assert) +#define check_exp(c,e) (lua_assert(c), (e)) +/* to avoid problems with conditions too long */ +#define lua_longassert(c) { if (!(c)) lua_assert(0); } +#else +#define lua_assert(c) ((void)0) +#define check_exp(c,e) (e) +#define lua_longassert(c) ((void)0) +#endif + +/* +** assertion for checking API calls +*/ +#if !defined(luai_apicheck) + +#if defined(LUA_USE_APICHECK) +#include +#define luai_apicheck(L,e) assert(e) +#else +#define luai_apicheck(L,e) lua_assert(e) +#endif + +#endif + +#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) + + +#if !defined(UNUSED) +#define UNUSED(x) ((void)(x)) /* to avoid warnings */ +#endif + + +#define cast(t, exp) ((t)(exp)) + +#define cast_byte(i) cast(lu_byte, (i)) +#define cast_num(i) cast(lua_Number, (i)) +#define cast_int(i) cast(int, (i)) +#define cast_uchar(i) cast(unsigned char, (i)) + + +/* +** non-return type +*/ +#if defined(__GNUC__) +#define l_noret void __attribute__((noreturn)) +#elif defined(_MSC_VER) +#define l_noret void __declspec(noreturn) +#else +#define l_noret void +#endif + + + +/* +** maximum depth for nested C calls and syntactical nested non-terminals +** in a program. (Value must fit in an unsigned short int.) +*/ +#if !defined(LUAI_MAXCCALLS) +#define LUAI_MAXCCALLS 200 +#endif + +/* +** maximum number of upvalues in a closure (both C and Lua). (Value +** must fit in an unsigned char.) +*/ +#define MAXUPVAL UCHAR_MAX + + +/* +** type for virtual-machine instructions +** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h) +*/ +typedef lu_int32 Instruction; + + + +/* maximum stack for a Lua function */ +#define MAXSTACK 250 + + + +/* minimum size for the string table (must be power of 2) */ +#if !defined(MINSTRTABSIZE) +#define MINSTRTABSIZE 32 +#endif + + +/* minimum size for string buffer */ +#if !defined(LUA_MINBUFFER) +#define LUA_MINBUFFER 32 +#endif + + +#if !defined(lua_lock) +#define lua_lock(L) ((void) 0) +#define lua_unlock(L) ((void) 0) +#endif + +#if !defined(luai_threadyield) +#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} +#endif + + +/* +** these macros allow user-specific actions on threads when you defined +** LUAI_EXTRASPACE and need to do something extra when a thread is +** created/deleted/resumed/yielded. +*/ +#if !defined(luai_userstateopen) +#define luai_userstateopen(L) ((void)L) +#endif + +#if !defined(luai_userstateclose) +#define luai_userstateclose(L) ((void)L) +#endif + +#if !defined(luai_userstatethread) +#define luai_userstatethread(L,L1) ((void)L) +#endif + +#if !defined(luai_userstatefree) +#define luai_userstatefree(L,L1) ((void)L) +#endif + +#if !defined(luai_userstateresume) +#define luai_userstateresume(L,n) ((void)L) +#endif + +#if !defined(luai_userstateyield) +#define luai_userstateyield(L,n) ((void)L) +#endif + +/* +** lua_number2int is a macro to convert lua_Number to int. +** lua_number2integer is a macro to convert lua_Number to lua_Integer. +** lua_number2unsigned is a macro to convert a lua_Number to a lua_Unsigned. +** lua_unsigned2number is a macro to convert a lua_Unsigned to a lua_Number. +** luai_hashnum is a macro to hash a lua_Number value into an integer. +** The hash must be deterministic and give reasonable values for +** both small and large values (outside the range of integers). +*/ + +#if defined(MS_ASMTRICK) || defined(LUA_MSASMTRICK) /* { */ +/* trick with Microsoft assembler for X86 */ + +#define lua_number2int(i,n) __asm {__asm fld n __asm fistp i} +#define lua_number2integer(i,n) lua_number2int(i, n) +#define lua_number2unsigned(i,n) \ + {__int64 l; __asm {__asm fld n __asm fistp l} i = (unsigned int)l;} + + +#elif defined(LUA_IEEE754TRICK) /* }{ */ +/* the next trick should work on any machine using IEEE754 with + a 32-bit int type */ + +union luai_Cast { double l_d; LUA_INT32 l_p[2]; }; + +#if !defined(LUA_IEEEENDIAN) /* { */ +#define LUAI_EXTRAIEEE \ + static const union luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)}; +#define LUA_IEEEENDIANLOC (ieeeendian.l_p[1] == 33) +#else +#define LUA_IEEEENDIANLOC LUA_IEEEENDIAN +#define LUAI_EXTRAIEEE /* empty */ +#endif /* } */ + +#define lua_number2int32(i,n,t) \ + { LUAI_EXTRAIEEE \ + volatile union luai_Cast u; u.l_d = (n) + 6755399441055744.0; \ + (i) = (t)u.l_p[LUA_IEEEENDIANLOC]; } + +#define luai_hashnum(i,n) \ + { volatile union luai_Cast u; u.l_d = (n) + 1.0; /* avoid -0 */ \ + (i) = u.l_p[0]; (i) += u.l_p[1]; } /* add double bits for his hash */ + +#define lua_number2int(i,n) lua_number2int32(i, n, int) +#define lua_number2unsigned(i,n) lua_number2int32(i, n, lua_Unsigned) + +/* the trick can be expanded to lua_Integer when it is a 32-bit value */ +#if defined(LUA_IEEELL) +#define lua_number2integer(i,n) lua_number2int32(i, n, lua_Integer) +#endif + +#endif /* } */ + + +/* the following definitions always work, but may be slow */ + +#if !defined(lua_number2int) +#define lua_number2int(i,n) ((i)=(int)(n)) +#endif + +#if !defined(lua_number2integer) +#define lua_number2integer(i,n) ((i)=(lua_Integer)(n)) +#endif + +#if !defined(lua_number2unsigned) /* { */ +/* the following definition assures proper modulo behavior */ +#if defined(LUA_NUMBER_DOUBLE) || defined(LUA_NUMBER_FLOAT) +#include +#define SUPUNSIGNED ((lua_Number)(~(lua_Unsigned)0) + 1) +#define lua_number2unsigned(i,n) \ + ((i)=(lua_Unsigned)((n) - floor((n)/SUPUNSIGNED)*SUPUNSIGNED)) +#else +#define lua_number2unsigned(i,n) ((i)=(lua_Unsigned)(n)) +#endif +#endif /* } */ + + +#if !defined(lua_unsigned2number) +/* on several machines, coercion from unsigned to double is slow, + so it may be worth to avoid */ +#define lua_unsigned2number(u) \ + (((u) <= (lua_Unsigned)INT_MAX) ? (lua_Number)(int)(u) : (lua_Number)(u)) +#endif + + + +#if defined(ltable_c) && !defined(luai_hashnum) + +#include +#include + +#define luai_hashnum(i,n) { int e; \ + n = l_mathop(frexp)(n, &e) * (lua_Number)(INT_MAX - DBL_MAX_EXP); \ + lua_number2int(i, n); i += e; } + +#endif + + + +/* +** macro to control inclusion of some hard tests on stack reallocation +*/ +#if !defined(HARDSTACKTESTS) +#define condmovestack(L) ((void)0) +#else +/* realloc stack keeping its size */ +#define condmovestack(L) luaD_reallocstack((L), (L)->stacksize) +#endif + +#if !defined(HARDMEMTESTS) +#define condchangemem(L) condmovestack(L) +#else +#define condchangemem(L) \ + ((void)(!(G(L)->gcrunning) || (luaC_fullgc(L, 0), 1))) +#endif + +#endif diff --git a/extern/lua/src/lmathlib.c b/extern/lua/src/lmathlib.c new file mode 100644 index 0000000..fe9fc54 --- /dev/null +++ b/extern/lua/src/lmathlib.c @@ -0,0 +1,279 @@ +/* +** $Id: lmathlib.c,v 1.83.1.1 2013/04/12 18:48:47 roberto Exp $ +** Standard mathematical library +** See Copyright Notice in lua.h +*/ + + +#include +#include + +#define lmathlib_c +#define LUA_LIB + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +#undef PI +#define PI ((lua_Number)(3.1415926535897932384626433832795)) +#define RADIANS_PER_DEGREE ((lua_Number)(PI/180.0)) + + + +static int math_abs (lua_State *L) { + lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_sin (lua_State *L) { + lua_pushnumber(L, l_mathop(sin)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_sinh (lua_State *L) { + lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_cos (lua_State *L) { + lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_cosh (lua_State *L) { + lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_tan (lua_State *L) { + lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_tanh (lua_State *L) { + lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_asin (lua_State *L) { + lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_acos (lua_State *L) { + lua_pushnumber(L, l_mathop(acos)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_atan (lua_State *L) { + lua_pushnumber(L, l_mathop(atan)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_atan2 (lua_State *L) { + lua_pushnumber(L, l_mathop(atan2)(luaL_checknumber(L, 1), + luaL_checknumber(L, 2))); + return 1; +} + +static int math_ceil (lua_State *L) { + lua_pushnumber(L, l_mathop(ceil)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_floor (lua_State *L) { + lua_pushnumber(L, l_mathop(floor)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_fmod (lua_State *L) { + lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1), + luaL_checknumber(L, 2))); + return 1; +} + +static int math_modf (lua_State *L) { + lua_Number ip; + lua_Number fp = l_mathop(modf)(luaL_checknumber(L, 1), &ip); + lua_pushnumber(L, ip); + lua_pushnumber(L, fp); + return 2; +} + +static int math_sqrt (lua_State *L) { + lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_pow (lua_State *L) { + lua_Number x = luaL_checknumber(L, 1); + lua_Number y = luaL_checknumber(L, 2); + lua_pushnumber(L, l_mathop(pow)(x, y)); + return 1; +} + +static int math_log (lua_State *L) { + lua_Number x = luaL_checknumber(L, 1); + lua_Number res; + if (lua_isnoneornil(L, 2)) + res = l_mathop(log)(x); + else { + lua_Number base = luaL_checknumber(L, 2); + if (base == (lua_Number)10.0) res = l_mathop(log10)(x); + else res = l_mathop(log)(x)/l_mathop(log)(base); + } + lua_pushnumber(L, res); + return 1; +} + +#if defined(LUA_COMPAT_LOG10) +static int math_log10 (lua_State *L) { + lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1))); + return 1; +} +#endif + +static int math_exp (lua_State *L) { + lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_deg (lua_State *L) { + lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE); + return 1; +} + +static int math_rad (lua_State *L) { + lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE); + return 1; +} + +static int math_frexp (lua_State *L) { + int e; + lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e)); + lua_pushinteger(L, e); + return 2; +} + +static int math_ldexp (lua_State *L) { + lua_Number x = luaL_checknumber(L, 1); + int ep = luaL_checkint(L, 2); + lua_pushnumber(L, l_mathop(ldexp)(x, ep)); + return 1; +} + + + +static int math_min (lua_State *L) { + int n = lua_gettop(L); /* number of arguments */ + lua_Number dmin = luaL_checknumber(L, 1); + int i; + for (i=2; i<=n; i++) { + lua_Number d = luaL_checknumber(L, i); + if (d < dmin) + dmin = d; + } + lua_pushnumber(L, dmin); + return 1; +} + + +static int math_max (lua_State *L) { + int n = lua_gettop(L); /* number of arguments */ + lua_Number dmax = luaL_checknumber(L, 1); + int i; + for (i=2; i<=n; i++) { + lua_Number d = luaL_checknumber(L, i); + if (d > dmax) + dmax = d; + } + lua_pushnumber(L, dmax); + return 1; +} + + +static int math_random (lua_State *L) { + /* the `%' avoids the (rare) case of r==1, and is needed also because on + some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */ + lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX; + switch (lua_gettop(L)) { /* check number of arguments */ + case 0: { /* no arguments */ + lua_pushnumber(L, r); /* Number between 0 and 1 */ + break; + } + case 1: { /* only upper limit */ + lua_Number u = luaL_checknumber(L, 1); + luaL_argcheck(L, (lua_Number)1.0 <= u, 1, "interval is empty"); + lua_pushnumber(L, l_mathop(floor)(r*u) + (lua_Number)(1.0)); /* [1, u] */ + break; + } + case 2: { /* lower and upper limits */ + lua_Number l = luaL_checknumber(L, 1); + lua_Number u = luaL_checknumber(L, 2); + luaL_argcheck(L, l <= u, 2, "interval is empty"); + lua_pushnumber(L, l_mathop(floor)(r*(u-l+1)) + l); /* [l, u] */ + break; + } + default: return luaL_error(L, "wrong number of arguments"); + } + return 1; +} + + +static int math_randomseed (lua_State *L) { + srand(luaL_checkunsigned(L, 1)); + (void)rand(); /* discard first value to avoid undesirable correlations */ + return 0; +} + + +static const luaL_Reg mathlib[] = { + {"abs", math_abs}, + {"acos", math_acos}, + {"asin", math_asin}, + {"atan2", math_atan2}, + {"atan", math_atan}, + {"ceil", math_ceil}, + {"cosh", math_cosh}, + {"cos", math_cos}, + {"deg", math_deg}, + {"exp", math_exp}, + {"floor", math_floor}, + {"fmod", math_fmod}, + {"frexp", math_frexp}, + {"ldexp", math_ldexp}, +#if defined(LUA_COMPAT_LOG10) + {"log10", math_log10}, +#endif + {"log", math_log}, + {"max", math_max}, + {"min", math_min}, + {"modf", math_modf}, + {"pow", math_pow}, + {"rad", math_rad}, + {"random", math_random}, + {"randomseed", math_randomseed}, + {"sinh", math_sinh}, + {"sin", math_sin}, + {"sqrt", math_sqrt}, + {"tanh", math_tanh}, + {"tan", math_tan}, + {NULL, NULL} +}; + + +/* +** Open math library +*/ +LUAMOD_API int luaopen_math (lua_State *L) { + luaL_newlib(L, mathlib); + lua_pushnumber(L, PI); + lua_setfield(L, -2, "pi"); + lua_pushnumber(L, HUGE_VAL); + lua_setfield(L, -2, "huge"); + return 1; +} + diff --git a/extern/lua/src/lmathlib.o b/extern/lua/src/lmathlib.o new file mode 100644 index 0000000000000000000000000000000000000000..8cb7fcbe74a9831a845f3c2c4cca49ee075fde45 GIT binary patch literal 13128 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 + +#define lmem_c +#define LUA_CORE + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" + + + +/* +** About the realloc function: +** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize); +** (`osize' is the old size, `nsize' is the new size) +** +** * frealloc(ud, NULL, x, s) creates a new block of size `s' (no +** matter 'x'). +** +** * frealloc(ud, p, x, 0) frees the block `p' +** (in this specific case, frealloc must return NULL); +** particularly, frealloc(ud, NULL, 0, 0) does nothing +** (which is equivalent to free(NULL) in ANSI C) +** +** frealloc returns NULL if it cannot create or reallocate the area +** (any reallocation to an equal or smaller size cannot fail!) +*/ + + + +#define MINSIZEARRAY 4 + + +void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems, + int limit, const char *what) { + void *newblock; + int newsize; + if (*size >= limit/2) { /* cannot double it? */ + if (*size >= limit) /* cannot grow even a little? */ + luaG_runerror(L, "too many %s (limit is %d)", what, limit); + newsize = limit; /* still have at least one free place */ + } + else { + newsize = (*size)*2; + if (newsize < MINSIZEARRAY) + newsize = MINSIZEARRAY; /* minimum size */ + } + newblock = luaM_reallocv(L, block, *size, newsize, size_elems); + *size = newsize; /* update only when everything else is OK */ + return newblock; +} + + +l_noret luaM_toobig (lua_State *L) { + luaG_runerror(L, "memory allocation error: block too big"); +} + + + +/* +** generic allocation routine. +*/ +void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) { + void *newblock; + global_State *g = G(L); + size_t realosize = (block) ? osize : 0; + lua_assert((realosize == 0) == (block == NULL)); +#if defined(HARDMEMTESTS) + if (nsize > realosize && g->gcrunning) + luaC_fullgc(L, 1); /* force a GC whenever possible */ +#endif + newblock = (*g->frealloc)(g->ud, block, osize, nsize); + if (newblock == NULL && nsize > 0) { + api_check(L, nsize > realosize, + "realloc cannot fail when shrinking a block"); + if (g->gcrunning) { + luaC_fullgc(L, 1); /* try to free some memory... */ + newblock = (*g->frealloc)(g->ud, block, osize, nsize); /* try again */ + } + if (newblock == NULL) + luaD_throw(L, LUA_ERRMEM); + } + lua_assert((nsize == 0) == (newblock == NULL)); + g->GCdebt = (g->GCdebt + nsize) - realosize; + return newblock; +} + diff --git a/extern/lua/src/lmem.h b/extern/lua/src/lmem.h new file mode 100644 index 0000000..bd4f4e0 --- /dev/null +++ b/extern/lua/src/lmem.h @@ -0,0 +1,57 @@ +/* +** $Id: lmem.h,v 1.40.1.1 2013/04/12 18:48:47 roberto Exp $ +** Interface to Memory Manager +** See Copyright Notice in lua.h +*/ + +#ifndef lmem_h +#define lmem_h + + +#include + +#include "llimits.h" +#include "lua.h" + + +/* +** This macro avoids the runtime division MAX_SIZET/(e), as 'e' is +** always constant. +** The macro is somewhat complex to avoid warnings: +** +1 avoids warnings of "comparison has constant result"; +** cast to 'void' avoids warnings of "value unused". +*/ +#define luaM_reallocv(L,b,on,n,e) \ + (cast(void, \ + (cast(size_t, (n)+1) > MAX_SIZET/(e)) ? (luaM_toobig(L), 0) : 0), \ + luaM_realloc_(L, (b), (on)*(e), (n)*(e))) + +#define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0) +#define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0) +#define luaM_freearray(L, b, n) luaM_reallocv(L, (b), n, 0, sizeof((b)[0])) + +#define luaM_malloc(L,s) luaM_realloc_(L, NULL, 0, (s)) +#define luaM_new(L,t) cast(t *, luaM_malloc(L, sizeof(t))) +#define luaM_newvector(L,n,t) \ + cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t))) + +#define luaM_newobject(L,tag,s) luaM_realloc_(L, NULL, tag, (s)) + +#define luaM_growvector(L,v,nelems,size,t,limit,e) \ + if ((nelems)+1 > (size)) \ + ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e))) + +#define luaM_reallocvector(L, v,oldn,n,t) \ + ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t)))) + +LUAI_FUNC l_noret luaM_toobig (lua_State *L); + +/* not to be called directly */ +LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize, + size_t size); +LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size, + size_t size_elem, int limit, + const char *what); + +#endif + diff --git a/extern/lua/src/lmem.o b/extern/lua/src/lmem.o new file mode 100644 index 0000000000000000000000000000000000000000..cf8d280edd75083740bb89af43feb40c0b0e9406 GIT binary patch literal 2480 zcmbtVPly{;82^&lc4J*%qId{yu|uIYi+0$^BD*a}CYv=AO>NP}9%>pU>2x>jBvU36 zx+`5;h`V%HS9{ar9=(YdQ7lVp1?~1=EhsDA^irq@7Sw`D{Jxp@nsE{@`oZM;eZTK- z-g`6e;#~2CXe0tcBJe!)Ex`iZkM?oKgBgg!7-*fJVq0XVyLU*bC)L*qZci<#C)BG% zlwK{kzZTqYHTNdPYU@@~Tm7vVpZh^uUy1cfpsjY>N3_-No#!sCoP;*p8o{ih+w;m@ z*`i^DMH!m=UD3T)bbt0!om<6;AGJt1sdYY&ohqxZt7Y}HTDczI_a=46_Br>uyQ8_^ z6x?kZpjeAuyR$E{^Ywjorh6fy&g`rl-*_pa)o!G3YhQH#>h*es-|uNNU)nEfwVOrv zvqJoXZG3Kf^SEXF$J7WLT%!838+)Pihjj7kC%e%4lxDyC5skPVToo^u!l7X_EPGkj zP1CCBPTgwChHYE+VY!OLqU>0fT&>Ro>4x51mJhV#lv!`o9l73;51g3*$j{CmmQy*S zTGyNMlrp2F52dFjd<5{g*99Q*#w!q6N<_xTMq^iS4HL-kZ>-rALClWV(GHr*LL$}-V1n^xJR%2HV-V<0AESuBOAOT5lHX_Y0` zqAE*vq+?8u&h24IWK8Crmi@~k^{;a-O)j*wpyUr78w+t zR;I!8EA6IPUo_0+e|poP)T~CsXkvk; zM{{?mNQT=_hh8FY%>%LHi0QCo0vy5jV?NRK6+D8PN^u&JoPUb*61Rm~4D}U!n0^Kw zRP(>)r!kjmK8sIK&hbVEgCt@xznCL~9O3Z#y(veYexN^%IjsM2 zK4=O3K?(N{`hu9^M&OrTkP}!Mx??oQut|ug6&@4`=vzN1(!goU$NUw@22xTw&C4?6|!;_XTi446P&G_ZJXviPoGCtZ!cA-tXOe6 z%K{TWMn5R@R|)@#_czHYB2kE^Gbs2vktoE+@e%x8B2kE^cSi8zd}*m~a2NM;KHT?U ffTwdW>d1&mD4rf6Qyd6h>Spa_ns!Td@ literal 0 HcmV?d00001 diff --git a/extern/lua/src/loadlib.c b/extern/lua/src/loadlib.c new file mode 100644 index 0000000..bedbea3 --- /dev/null +++ b/extern/lua/src/loadlib.c @@ -0,0 +1,725 @@ +/* +** $Id: loadlib.c,v 1.111.1.1 2013/04/12 18:48:47 roberto Exp $ +** Dynamic library loader for Lua +** See Copyright Notice in lua.h +** +** This module contains an implementation of loadlib for Unix systems +** that have dlfcn, an implementation for Windows, and a stub for other +** systems. +*/ + + +/* +** if needed, includes windows header before everything else +*/ +#if defined(_WIN32) +#include +#endif + + +#include +#include + + +#define loadlib_c +#define LUA_LIB + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +/* +** LUA_PATH and LUA_CPATH are the names of the environment +** variables that Lua check to set its paths. +*/ +#if !defined(LUA_PATH) +#define LUA_PATH "LUA_PATH" +#endif + +#if !defined(LUA_CPATH) +#define LUA_CPATH "LUA_CPATH" +#endif + +#define LUA_PATHSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR + +#define LUA_PATHVERSION LUA_PATH LUA_PATHSUFFIX +#define LUA_CPATHVERSION LUA_CPATH LUA_PATHSUFFIX + +/* +** LUA_PATH_SEP is the character that separates templates in a path. +** LUA_PATH_MARK is the string that marks the substitution points in a +** template. +** LUA_EXEC_DIR in a Windows path is replaced by the executable's +** directory. +** LUA_IGMARK is a mark to ignore all before it when building the +** luaopen_ function name. +*/ +#if !defined (LUA_PATH_SEP) +#define LUA_PATH_SEP ";" +#endif +#if !defined (LUA_PATH_MARK) +#define LUA_PATH_MARK "?" +#endif +#if !defined (LUA_EXEC_DIR) +#define LUA_EXEC_DIR "!" +#endif +#if !defined (LUA_IGMARK) +#define LUA_IGMARK "-" +#endif + + +/* +** LUA_CSUBSEP is the character that replaces dots in submodule names +** when searching for a C loader. +** LUA_LSUBSEP is the character that replaces dots in submodule names +** when searching for a Lua loader. +*/ +#if !defined(LUA_CSUBSEP) +#define LUA_CSUBSEP LUA_DIRSEP +#endif + +#if !defined(LUA_LSUBSEP) +#define LUA_LSUBSEP LUA_DIRSEP +#endif + + +/* prefix for open functions in C libraries */ +#define LUA_POF "luaopen_" + +/* separator for open functions in C libraries */ +#define LUA_OFSEP "_" + + +/* table (in the registry) that keeps handles for all loaded C libraries */ +#define CLIBS "_CLIBS" + +#define LIB_FAIL "open" + + +/* error codes for ll_loadfunc */ +#define ERRLIB 1 +#define ERRFUNC 2 + +#define setprogdir(L) ((void)0) + + +/* +** system-dependent functions +*/ +static void ll_unloadlib (void *lib); +static void *ll_load (lua_State *L, const char *path, int seeglb); +static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym); + + + +#if defined(LUA_USE_DLOPEN) +/* +** {======================================================================== +** This is an implementation of loadlib based on the dlfcn interface. +** The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD, +** NetBSD, AIX 4.2, HPUX 11, and probably most other Unix flavors, at least +** as an emulation layer on top of native functions. +** ========================================================================= +*/ + +#include + +static void ll_unloadlib (void *lib) { + dlclose(lib); +} + + +static void *ll_load (lua_State *L, const char *path, int seeglb) { + void *lib = dlopen(path, RTLD_NOW | (seeglb ? RTLD_GLOBAL : RTLD_LOCAL)); + if (lib == NULL) lua_pushstring(L, dlerror()); + return lib; +} + + +static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { + lua_CFunction f = (lua_CFunction)dlsym(lib, sym); + if (f == NULL) lua_pushstring(L, dlerror()); + return f; +} + +/* }====================================================== */ + + + +#elif defined(LUA_DL_DLL) +/* +** {====================================================================== +** This is an implementation of loadlib for Windows using native functions. +** ======================================================================= +*/ + +#undef setprogdir + +/* +** optional flags for LoadLibraryEx +*/ +#if !defined(LUA_LLE_FLAGS) +#define LUA_LLE_FLAGS 0 +#endif + + +static void setprogdir (lua_State *L) { + char buff[MAX_PATH + 1]; + char *lb; + DWORD nsize = sizeof(buff)/sizeof(char); + DWORD n = GetModuleFileNameA(NULL, buff, nsize); + if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL) + luaL_error(L, "unable to get ModuleFileName"); + else { + *lb = '\0'; + luaL_gsub(L, lua_tostring(L, -1), LUA_EXEC_DIR, buff); + lua_remove(L, -2); /* remove original string */ + } +} + + +static void pusherror (lua_State *L) { + int error = GetLastError(); + char buffer[128]; + if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM, + NULL, error, 0, buffer, sizeof(buffer)/sizeof(char), NULL)) + lua_pushstring(L, buffer); + else + lua_pushfstring(L, "system error %d\n", error); +} + +static void ll_unloadlib (void *lib) { + FreeLibrary((HMODULE)lib); +} + + +static void *ll_load (lua_State *L, const char *path, int seeglb) { + HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS); + (void)(seeglb); /* not used: symbols are 'global' by default */ + if (lib == NULL) pusherror(L); + return lib; +} + + +static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { + lua_CFunction f = (lua_CFunction)GetProcAddress((HMODULE)lib, sym); + if (f == NULL) pusherror(L); + return f; +} + +/* }====================================================== */ + + +#else +/* +** {====================================================== +** Fallback for other systems +** ======================================================= +*/ + +#undef LIB_FAIL +#define LIB_FAIL "absent" + + +#define DLMSG "dynamic libraries not enabled; check your Lua installation" + + +static void ll_unloadlib (void *lib) { + (void)(lib); /* not used */ +} + + +static void *ll_load (lua_State *L, const char *path, int seeglb) { + (void)(path); (void)(seeglb); /* not used */ + lua_pushliteral(L, DLMSG); + return NULL; +} + + +static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) { + (void)(lib); (void)(sym); /* not used */ + lua_pushliteral(L, DLMSG); + return NULL; +} + +/* }====================================================== */ +#endif + + +static void *ll_checkclib (lua_State *L, const char *path) { + void *plib; + lua_getfield(L, LUA_REGISTRYINDEX, CLIBS); + lua_getfield(L, -1, path); + plib = lua_touserdata(L, -1); /* plib = CLIBS[path] */ + lua_pop(L, 2); /* pop CLIBS table and 'plib' */ + return plib; +} + + +static void ll_addtoclib (lua_State *L, const char *path, void *plib) { + lua_getfield(L, LUA_REGISTRYINDEX, CLIBS); + lua_pushlightuserdata(L, plib); + lua_pushvalue(L, -1); + lua_setfield(L, -3, path); /* CLIBS[path] = plib */ + lua_rawseti(L, -2, luaL_len(L, -2) + 1); /* CLIBS[#CLIBS + 1] = plib */ + lua_pop(L, 1); /* pop CLIBS table */ +} + + +/* +** __gc tag method for CLIBS table: calls 'll_unloadlib' for all lib +** handles in list CLIBS +*/ +static int gctm (lua_State *L) { + int n = luaL_len(L, 1); + for (; n >= 1; n--) { /* for each handle, in reverse order */ + lua_rawgeti(L, 1, n); /* get handle CLIBS[n] */ + ll_unloadlib(lua_touserdata(L, -1)); + lua_pop(L, 1); /* pop handle */ + } + return 0; +} + + +static int ll_loadfunc (lua_State *L, const char *path, const char *sym) { + void *reg = ll_checkclib(L, path); /* check loaded C libraries */ + if (reg == NULL) { /* must load library? */ + reg = ll_load(L, path, *sym == '*'); + if (reg == NULL) return ERRLIB; /* unable to load library */ + ll_addtoclib(L, path, reg); + } + if (*sym == '*') { /* loading only library (no function)? */ + lua_pushboolean(L, 1); /* return 'true' */ + return 0; /* no errors */ + } + else { + lua_CFunction f = ll_sym(L, reg, sym); + if (f == NULL) + return ERRFUNC; /* unable to find function */ + lua_pushcfunction(L, f); /* else create new function */ + return 0; /* no errors */ + } +} + + +static int ll_loadlib (lua_State *L) { + const char *path = luaL_checkstring(L, 1); + const char *init = luaL_checkstring(L, 2); + int stat = ll_loadfunc(L, path, init); + if (stat == 0) /* no errors? */ + return 1; /* return the loaded function */ + else { /* error; error message is on stack top */ + lua_pushnil(L); + lua_insert(L, -2); + lua_pushstring(L, (stat == ERRLIB) ? LIB_FAIL : "init"); + return 3; /* return nil, error message, and where */ + } +} + + + +/* +** {====================================================== +** 'require' function +** ======================================================= +*/ + + +static int readable (const char *filename) { + FILE *f = fopen(filename, "r"); /* try to open file */ + if (f == NULL) return 0; /* open failed */ + fclose(f); + return 1; +} + + +static const char *pushnexttemplate (lua_State *L, const char *path) { + const char *l; + while (*path == *LUA_PATH_SEP) path++; /* skip separators */ + if (*path == '\0') return NULL; /* no more templates */ + l = strchr(path, *LUA_PATH_SEP); /* find next separator */ + if (l == NULL) l = path + strlen(path); + lua_pushlstring(L, path, l - path); /* template */ + return l; +} + + +static const char *searchpath (lua_State *L, const char *name, + const char *path, + const char *sep, + const char *dirsep) { + luaL_Buffer msg; /* to build error message */ + luaL_buffinit(L, &msg); + if (*sep != '\0') /* non-empty separator? */ + name = luaL_gsub(L, name, sep, dirsep); /* replace it by 'dirsep' */ + while ((path = pushnexttemplate(L, path)) != NULL) { + const char *filename = luaL_gsub(L, lua_tostring(L, -1), + LUA_PATH_MARK, name); + lua_remove(L, -2); /* remove path template */ + if (readable(filename)) /* does file exist and is readable? */ + return filename; /* return that file name */ + lua_pushfstring(L, "\n\tno file " LUA_QS, filename); + lua_remove(L, -2); /* remove file name */ + luaL_addvalue(&msg); /* concatenate error msg. entry */ + } + luaL_pushresult(&msg); /* create error message */ + return NULL; /* not found */ +} + + +static int ll_searchpath (lua_State *L) { + const char *f = searchpath(L, luaL_checkstring(L, 1), + luaL_checkstring(L, 2), + luaL_optstring(L, 3, "."), + luaL_optstring(L, 4, LUA_DIRSEP)); + if (f != NULL) return 1; + else { /* error message is on top of the stack */ + lua_pushnil(L); + lua_insert(L, -2); + return 2; /* return nil + error message */ + } +} + + +static const char *findfile (lua_State *L, const char *name, + const char *pname, + const char *dirsep) { + const char *path; + lua_getfield(L, lua_upvalueindex(1), pname); + path = lua_tostring(L, -1); + if (path == NULL) + luaL_error(L, LUA_QL("package.%s") " must be a string", pname); + return searchpath(L, name, path, ".", dirsep); +} + + +static int checkload (lua_State *L, int stat, const char *filename) { + if (stat) { /* module loaded successfully? */ + lua_pushstring(L, filename); /* will be 2nd argument to module */ + return 2; /* return open function and file name */ + } + else + return luaL_error(L, "error loading module " LUA_QS + " from file " LUA_QS ":\n\t%s", + lua_tostring(L, 1), filename, lua_tostring(L, -1)); +} + + +static int searcher_Lua (lua_State *L) { + const char *filename; + const char *name = luaL_checkstring(L, 1); + filename = findfile(L, name, "path", LUA_LSUBSEP); + if (filename == NULL) return 1; /* module not found in this path */ + return checkload(L, (luaL_loadfile(L, filename) == LUA_OK), filename); +} + + +static int loadfunc (lua_State *L, const char *filename, const char *modname) { + const char *funcname; + const char *mark; + modname = luaL_gsub(L, modname, ".", LUA_OFSEP); + mark = strchr(modname, *LUA_IGMARK); + if (mark) { + int stat; + funcname = lua_pushlstring(L, modname, mark - modname); + funcname = lua_pushfstring(L, LUA_POF"%s", funcname); + stat = ll_loadfunc(L, filename, funcname); + if (stat != ERRFUNC) return stat; + modname = mark + 1; /* else go ahead and try old-style name */ + } + funcname = lua_pushfstring(L, LUA_POF"%s", modname); + return ll_loadfunc(L, filename, funcname); +} + + +static int searcher_C (lua_State *L) { + const char *name = luaL_checkstring(L, 1); + const char *filename = findfile(L, name, "cpath", LUA_CSUBSEP); + if (filename == NULL) return 1; /* module not found in this path */ + return checkload(L, (loadfunc(L, filename, name) == 0), filename); +} + + +static int searcher_Croot (lua_State *L) { + const char *filename; + const char *name = luaL_checkstring(L, 1); + const char *p = strchr(name, '.'); + int stat; + if (p == NULL) return 0; /* is root */ + lua_pushlstring(L, name, p - name); + filename = findfile(L, lua_tostring(L, -1), "cpath", LUA_CSUBSEP); + if (filename == NULL) return 1; /* root not found */ + if ((stat = loadfunc(L, filename, name)) != 0) { + if (stat != ERRFUNC) + return checkload(L, 0, filename); /* real error */ + else { /* open function not found */ + lua_pushfstring(L, "\n\tno module " LUA_QS " in file " LUA_QS, + name, filename); + return 1; + } + } + lua_pushstring(L, filename); /* will be 2nd argument to module */ + return 2; +} + + +static int searcher_preload (lua_State *L) { + const char *name = luaL_checkstring(L, 1); + lua_getfield(L, LUA_REGISTRYINDEX, "_PRELOAD"); + lua_getfield(L, -1, name); + if (lua_isnil(L, -1)) /* not found? */ + lua_pushfstring(L, "\n\tno field package.preload['%s']", name); + return 1; +} + + +static void findloader (lua_State *L, const char *name) { + int i; + luaL_Buffer msg; /* to build error message */ + luaL_buffinit(L, &msg); + lua_getfield(L, lua_upvalueindex(1), "searchers"); /* will be at index 3 */ + if (!lua_istable(L, 3)) + luaL_error(L, LUA_QL("package.searchers") " must be a table"); + /* iterate over available searchers to find a loader */ + for (i = 1; ; i++) { + lua_rawgeti(L, 3, i); /* get a searcher */ + if (lua_isnil(L, -1)) { /* no more searchers? */ + lua_pop(L, 1); /* remove nil */ + luaL_pushresult(&msg); /* create error message */ + luaL_error(L, "module " LUA_QS " not found:%s", + name, lua_tostring(L, -1)); + } + lua_pushstring(L, name); + lua_call(L, 1, 2); /* call it */ + if (lua_isfunction(L, -2)) /* did it find a loader? */ + return; /* module loader found */ + else if (lua_isstring(L, -2)) { /* searcher returned error message? */ + lua_pop(L, 1); /* remove extra return */ + luaL_addvalue(&msg); /* concatenate error message */ + } + else + lua_pop(L, 2); /* remove both returns */ + } +} + + +static int ll_require (lua_State *L) { + const char *name = luaL_checkstring(L, 1); + lua_settop(L, 1); /* _LOADED table will be at index 2 */ + lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED"); + lua_getfield(L, 2, name); /* _LOADED[name] */ + if (lua_toboolean(L, -1)) /* is it there? */ + return 1; /* package is already loaded */ + /* else must load package */ + lua_pop(L, 1); /* remove 'getfield' result */ + findloader(L, name); + lua_pushstring(L, name); /* pass name as argument to module loader */ + lua_insert(L, -2); /* name is 1st argument (before search data) */ + lua_call(L, 2, 1); /* run loader to load module */ + if (!lua_isnil(L, -1)) /* non-nil return? */ + lua_setfield(L, 2, name); /* _LOADED[name] = returned value */ + lua_getfield(L, 2, name); + if (lua_isnil(L, -1)) { /* module did not set a value? */ + lua_pushboolean(L, 1); /* use true as result */ + lua_pushvalue(L, -1); /* extra copy to be returned */ + lua_setfield(L, 2, name); /* _LOADED[name] = true */ + } + return 1; +} + +/* }====================================================== */ + + + +/* +** {====================================================== +** 'module' function +** ======================================================= +*/ +#if defined(LUA_COMPAT_MODULE) + +/* +** changes the environment variable of calling function +*/ +static void set_env (lua_State *L) { + lua_Debug ar; + if (lua_getstack(L, 1, &ar) == 0 || + lua_getinfo(L, "f", &ar) == 0 || /* get calling function */ + lua_iscfunction(L, -1)) + luaL_error(L, LUA_QL("module") " not called from a Lua function"); + lua_pushvalue(L, -2); /* copy new environment table to top */ + lua_setupvalue(L, -2, 1); + lua_pop(L, 1); /* remove function */ +} + + +static void dooptions (lua_State *L, int n) { + int i; + for (i = 2; i <= n; i++) { + if (lua_isfunction(L, i)) { /* avoid 'calling' extra info. */ + lua_pushvalue(L, i); /* get option (a function) */ + lua_pushvalue(L, -2); /* module */ + lua_call(L, 1, 0); + } + } +} + + +static void modinit (lua_State *L, const char *modname) { + const char *dot; + lua_pushvalue(L, -1); + lua_setfield(L, -2, "_M"); /* module._M = module */ + lua_pushstring(L, modname); + lua_setfield(L, -2, "_NAME"); + dot = strrchr(modname, '.'); /* look for last dot in module name */ + if (dot == NULL) dot = modname; + else dot++; + /* set _PACKAGE as package name (full module name minus last part) */ + lua_pushlstring(L, modname, dot - modname); + lua_setfield(L, -2, "_PACKAGE"); +} + + +static int ll_module (lua_State *L) { + const char *modname = luaL_checkstring(L, 1); + int lastarg = lua_gettop(L); /* last parameter */ + luaL_pushmodule(L, modname, 1); /* get/create module table */ + /* check whether table already has a _NAME field */ + lua_getfield(L, -1, "_NAME"); + if (!lua_isnil(L, -1)) /* is table an initialized module? */ + lua_pop(L, 1); + else { /* no; initialize it */ + lua_pop(L, 1); + modinit(L, modname); + } + lua_pushvalue(L, -1); + set_env(L); + dooptions(L, lastarg); + return 1; +} + + +static int ll_seeall (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + if (!lua_getmetatable(L, 1)) { + lua_createtable(L, 0, 1); /* create new metatable */ + lua_pushvalue(L, -1); + lua_setmetatable(L, 1); + } + lua_pushglobaltable(L); + lua_setfield(L, -2, "__index"); /* mt.__index = _G */ + return 0; +} + +#endif +/* }====================================================== */ + + + +/* auxiliary mark (for internal use) */ +#define AUXMARK "\1" + + +/* +** return registry.LUA_NOENV as a boolean +*/ +static int noenv (lua_State *L) { + int b; + lua_getfield(L, LUA_REGISTRYINDEX, "LUA_NOENV"); + b = lua_toboolean(L, -1); + lua_pop(L, 1); /* remove value */ + return b; +} + + +static void setpath (lua_State *L, const char *fieldname, const char *envname1, + const char *envname2, const char *def) { + const char *path = getenv(envname1); + if (path == NULL) /* no environment variable? */ + path = getenv(envname2); /* try alternative name */ + if (path == NULL || noenv(L)) /* no environment variable? */ + lua_pushstring(L, def); /* use default */ + else { + /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */ + path = luaL_gsub(L, path, LUA_PATH_SEP LUA_PATH_SEP, + LUA_PATH_SEP AUXMARK LUA_PATH_SEP); + luaL_gsub(L, path, AUXMARK, def); + lua_remove(L, -2); + } + setprogdir(L); + lua_setfield(L, -2, fieldname); +} + + +static const luaL_Reg pk_funcs[] = { + {"loadlib", ll_loadlib}, + {"searchpath", ll_searchpath}, +#if defined(LUA_COMPAT_MODULE) + {"seeall", ll_seeall}, +#endif + {NULL, NULL} +}; + + +static const luaL_Reg ll_funcs[] = { +#if defined(LUA_COMPAT_MODULE) + {"module", ll_module}, +#endif + {"require", ll_require}, + {NULL, NULL} +}; + + +static void createsearcherstable (lua_State *L) { + static const lua_CFunction searchers[] = + {searcher_preload, searcher_Lua, searcher_C, searcher_Croot, NULL}; + int i; + /* create 'searchers' table */ + lua_createtable(L, sizeof(searchers)/sizeof(searchers[0]) - 1, 0); + /* fill it with pre-defined searchers */ + for (i=0; searchers[i] != NULL; i++) { + lua_pushvalue(L, -2); /* set 'package' as upvalue for all searchers */ + lua_pushcclosure(L, searchers[i], 1); + lua_rawseti(L, -2, i+1); + } +} + + +LUAMOD_API int luaopen_package (lua_State *L) { + /* create table CLIBS to keep track of loaded C libraries */ + luaL_getsubtable(L, LUA_REGISTRYINDEX, CLIBS); + lua_createtable(L, 0, 1); /* metatable for CLIBS */ + lua_pushcfunction(L, gctm); + lua_setfield(L, -2, "__gc"); /* set finalizer for CLIBS table */ + lua_setmetatable(L, -2); + /* create `package' table */ + luaL_newlib(L, pk_funcs); + createsearcherstable(L); +#if defined(LUA_COMPAT_LOADERS) + lua_pushvalue(L, -1); /* make a copy of 'searchers' table */ + lua_setfield(L, -3, "loaders"); /* put it in field `loaders' */ +#endif + lua_setfield(L, -2, "searchers"); /* put it in field 'searchers' */ + /* set field 'path' */ + setpath(L, "path", LUA_PATHVERSION, LUA_PATH, LUA_PATH_DEFAULT); + /* set field 'cpath' */ + setpath(L, "cpath", LUA_CPATHVERSION, LUA_CPATH, LUA_CPATH_DEFAULT); + /* store config information */ + lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATH_SEP "\n" LUA_PATH_MARK "\n" + LUA_EXEC_DIR "\n" LUA_IGMARK "\n"); + lua_setfield(L, -2, "config"); + /* set field `loaded' */ + luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED"); + lua_setfield(L, -2, "loaded"); + /* set field `preload' */ + luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD"); + lua_setfield(L, -2, "preload"); + lua_pushglobaltable(L); + lua_pushvalue(L, -2); /* set 'package' as upvalue for next lib */ + luaL_setfuncs(L, ll_funcs, 1); /* open lib into global table */ + lua_pop(L, 1); /* pop global table */ + return 1; /* return 'package' table */ +} + diff --git a/extern/lua/src/loadlib.o b/extern/lua/src/loadlib.o new file mode 100644 index 0000000000000000000000000000000000000000..8e49a4aa49065a5688a42ee7ff4863674e34eef9 GIT binary patch literal 16944 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 G^nU?u6&A|? literal 0 HcmV?d00001 diff --git a/extern/lua/src/lobject.c b/extern/lua/src/lobject.c new file mode 100644 index 0000000..882d994 --- /dev/null +++ b/extern/lua/src/lobject.c @@ -0,0 +1,287 @@ +/* +** $Id: lobject.c,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $ +** Some generic functions over Lua objects +** See Copyright Notice in lua.h +*/ + +#include +#include +#include +#include + +#define lobject_c +#define LUA_CORE + +#include "lua.h" + +#include "lctype.h" +#include "ldebug.h" +#include "ldo.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "lvm.h" + + + +LUAI_DDEF const TValue luaO_nilobject_ = {NILCONSTANT}; + + +/* +** converts an integer to a "floating point byte", represented as +** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if +** eeeee != 0 and (xxx) otherwise. +*/ +int luaO_int2fb (unsigned int x) { + int e = 0; /* exponent */ + if (x < 8) return x; + while (x >= 0x10) { + x = (x+1) >> 1; + e++; + } + return ((e+1) << 3) | (cast_int(x) - 8); +} + + +/* converts back */ +int luaO_fb2int (int x) { + int e = (x >> 3) & 0x1f; + if (e == 0) return x; + else return ((x & 7) + 8) << (e - 1); +} + + +int luaO_ceillog2 (unsigned int x) { + static const lu_byte log_2[256] = { + 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8 + }; + int l = 0; + x--; + while (x >= 256) { l += 8; x >>= 8; } + return l + log_2[x]; +} + + +lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2) { + switch (op) { + case LUA_OPADD: return luai_numadd(NULL, v1, v2); + case LUA_OPSUB: return luai_numsub(NULL, v1, v2); + case LUA_OPMUL: return luai_nummul(NULL, v1, v2); + case LUA_OPDIV: return luai_numdiv(NULL, v1, v2); + case LUA_OPMOD: return luai_nummod(NULL, v1, v2); + case LUA_OPPOW: return luai_numpow(NULL, v1, v2); + case LUA_OPUNM: return luai_numunm(NULL, v1); + default: lua_assert(0); return 0; + } +} + + +int luaO_hexavalue (int c) { + if (lisdigit(c)) return c - '0'; + else return ltolower(c) - 'a' + 10; +} + + +#if !defined(lua_strx2number) + +#include + + +static int isneg (const char **s) { + if (**s == '-') { (*s)++; return 1; } + else if (**s == '+') (*s)++; + return 0; +} + + +static lua_Number readhexa (const char **s, lua_Number r, int *count) { + for (; lisxdigit(cast_uchar(**s)); (*s)++) { /* read integer part */ + r = (r * cast_num(16.0)) + cast_num(luaO_hexavalue(cast_uchar(**s))); + (*count)++; + } + return r; +} + + +/* +** convert an hexadecimal numeric string to a number, following +** C99 specification for 'strtod' +*/ +static lua_Number lua_strx2number (const char *s, char **endptr) { + lua_Number r = 0.0; + int e = 0, i = 0; + int neg = 0; /* 1 if number is negative */ + *endptr = cast(char *, s); /* nothing is valid yet */ + while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */ + neg = isneg(&s); /* check signal */ + if (!(*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X'))) /* check '0x' */ + return 0.0; /* invalid format (no '0x') */ + s += 2; /* skip '0x' */ + r = readhexa(&s, r, &i); /* read integer part */ + if (*s == '.') { + s++; /* skip dot */ + r = readhexa(&s, r, &e); /* read fractional part */ + } + if (i == 0 && e == 0) + return 0.0; /* invalid format (no digit) */ + e *= -4; /* each fractional digit divides value by 2^-4 */ + *endptr = cast(char *, s); /* valid up to here */ + if (*s == 'p' || *s == 'P') { /* exponent part? */ + int exp1 = 0; + int neg1; + s++; /* skip 'p' */ + neg1 = isneg(&s); /* signal */ + if (!lisdigit(cast_uchar(*s))) + goto ret; /* must have at least one digit */ + while (lisdigit(cast_uchar(*s))) /* read exponent */ + exp1 = exp1 * 10 + *(s++) - '0'; + if (neg1) exp1 = -exp1; + e += exp1; + } + *endptr = cast(char *, s); /* valid up to here */ + ret: + if (neg) r = -r; + return l_mathop(ldexp)(r, e); +} + +#endif + + +int luaO_str2d (const char *s, size_t len, lua_Number *result) { + char *endptr; + if (strpbrk(s, "nN")) /* reject 'inf' and 'nan' */ + return 0; + else if (strpbrk(s, "xX")) /* hexa? */ + *result = lua_strx2number(s, &endptr); + else + *result = lua_str2number(s, &endptr); + if (endptr == s) return 0; /* nothing recognized */ + while (lisspace(cast_uchar(*endptr))) endptr++; + return (endptr == s + len); /* OK if no trailing characters */ +} + + + +static void pushstr (lua_State *L, const char *str, size_t l) { + setsvalue2s(L, L->top++, luaS_newlstr(L, str, l)); +} + + +/* this function handles only `%d', `%c', %f, %p, and `%s' formats */ +const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) { + int n = 0; + for (;;) { + const char *e = strchr(fmt, '%'); + if (e == NULL) break; + luaD_checkstack(L, 2); /* fmt + item */ + pushstr(L, fmt, e - fmt); + switch (*(e+1)) { + case 's': { + const char *s = va_arg(argp, char *); + if (s == NULL) s = "(null)"; + pushstr(L, s, strlen(s)); + break; + } + case 'c': { + char buff; + buff = cast(char, va_arg(argp, int)); + pushstr(L, &buff, 1); + break; + } + case 'd': { + setnvalue(L->top++, cast_num(va_arg(argp, int))); + break; + } + case 'f': { + setnvalue(L->top++, cast_num(va_arg(argp, l_uacNumber))); + break; + } + case 'p': { + char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */ + int l = sprintf(buff, "%p", va_arg(argp, void *)); + pushstr(L, buff, l); + break; + } + case '%': { + pushstr(L, "%", 1); + break; + } + default: { + luaG_runerror(L, + "invalid option " LUA_QL("%%%c") " to " LUA_QL("lua_pushfstring"), + *(e + 1)); + } + } + n += 2; + fmt = e+2; + } + luaD_checkstack(L, 1); + pushstr(L, fmt, strlen(fmt)); + if (n > 0) luaV_concat(L, n + 1); + return svalue(L->top - 1); +} + + +const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) { + const char *msg; + va_list argp; + va_start(argp, fmt); + msg = luaO_pushvfstring(L, fmt, argp); + va_end(argp); + return msg; +} + + +/* number of chars of a literal string without the ending \0 */ +#define LL(x) (sizeof(x)/sizeof(char) - 1) + +#define RETS "..." +#define PRE "[string \"" +#define POS "\"]" + +#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) + +void luaO_chunkid (char *out, const char *source, size_t bufflen) { + size_t l = strlen(source); + if (*source == '=') { /* 'literal' source */ + if (l <= bufflen) /* small enough? */ + memcpy(out, source + 1, l * sizeof(char)); + else { /* truncate it */ + addstr(out, source + 1, bufflen - 1); + *out = '\0'; + } + } + else if (*source == '@') { /* file name */ + if (l <= bufflen) /* small enough? */ + memcpy(out, source + 1, l * sizeof(char)); + else { /* add '...' before rest of name */ + addstr(out, RETS, LL(RETS)); + bufflen -= LL(RETS); + memcpy(out, source + 1 + l - bufflen, bufflen * sizeof(char)); + } + } + else { /* string; format as [string "source"] */ + const char *nl = strchr(source, '\n'); /* find first new line (if any) */ + addstr(out, PRE, LL(PRE)); /* add prefix */ + bufflen -= LL(PRE RETS POS) + 1; /* save space for prefix+suffix+'\0' */ + if (l < bufflen && nl == NULL) { /* small one-line source? */ + addstr(out, source, l); /* keep it */ + } + else { + if (nl != NULL) l = nl - source; /* stop at first newline */ + if (l > bufflen) l = bufflen; + addstr(out, source, l); + addstr(out, RETS, LL(RETS)); + } + memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); + } +} + diff --git a/extern/lua/src/lobject.h b/extern/lua/src/lobject.h new file mode 100644 index 0000000..3a630b9 --- /dev/null +++ b/extern/lua/src/lobject.h @@ -0,0 +1,607 @@ +/* +** $Id: lobject.h,v 2.71.1.1 2013/04/12 18:48:47 roberto Exp $ +** Type definitions for Lua objects +** See Copyright Notice in lua.h +*/ + + +#ifndef lobject_h +#define lobject_h + + +#include + + +#include "llimits.h" +#include "lua.h" + + +/* +** Extra tags for non-values +*/ +#define LUA_TPROTO LUA_NUMTAGS +#define LUA_TUPVAL (LUA_NUMTAGS+1) +#define LUA_TDEADKEY (LUA_NUMTAGS+2) + +/* +** number of all possible tags (including LUA_TNONE but excluding DEADKEY) +*/ +#define LUA_TOTALTAGS (LUA_TUPVAL+2) + + +/* +** tags for Tagged Values have the following use of bits: +** bits 0-3: actual tag (a LUA_T* value) +** bits 4-5: variant bits +** bit 6: whether value is collectable +*/ + +#define VARBITS (3 << 4) + + +/* +** LUA_TFUNCTION variants: +** 0 - Lua function +** 1 - light C function +** 2 - regular C function (closure) +*/ + +/* Variant tags for functions */ +#define LUA_TLCL (LUA_TFUNCTION | (0 << 4)) /* Lua closure */ +#define LUA_TLCF (LUA_TFUNCTION | (1 << 4)) /* light C function */ +#define LUA_TCCL (LUA_TFUNCTION | (2 << 4)) /* C closure */ + + +/* Variant tags for strings */ +#define LUA_TSHRSTR (LUA_TSTRING | (0 << 4)) /* short strings */ +#define LUA_TLNGSTR (LUA_TSTRING | (1 << 4)) /* long strings */ + + +/* Bit mark for collectable types */ +#define BIT_ISCOLLECTABLE (1 << 6) + +/* mark a tag as collectable */ +#define ctb(t) ((t) | BIT_ISCOLLECTABLE) + + +/* +** Union of all collectable objects +*/ +typedef union GCObject GCObject; + + +/* +** Common Header for all collectable objects (in macro form, to be +** included in other objects) +*/ +#define CommonHeader GCObject *next; lu_byte tt; lu_byte marked + + +/* +** Common header in struct form +*/ +typedef struct GCheader { + CommonHeader; +} GCheader; + + + +/* +** Union of all Lua values +*/ +typedef union Value Value; + + +#define numfield lua_Number n; /* numbers */ + + + +/* +** Tagged Values. This is the basic representation of values in Lua, +** an actual value plus a tag with its type. +*/ + +#define TValuefields Value value_; int tt_ + +typedef struct lua_TValue TValue; + + +/* macro defining a nil value */ +#define NILCONSTANT {NULL}, LUA_TNIL + + +#define val_(o) ((o)->value_) +#define num_(o) (val_(o).n) + + +/* raw type tag of a TValue */ +#define rttype(o) ((o)->tt_) + +/* tag with no variants (bits 0-3) */ +#define novariant(x) ((x) & 0x0F) + +/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */ +#define ttype(o) (rttype(o) & 0x3F) + +/* type tag of a TValue with no variants (bits 0-3) */ +#define ttypenv(o) (novariant(rttype(o))) + + +/* Macros to test type */ +#define checktag(o,t) (rttype(o) == (t)) +#define checktype(o,t) (ttypenv(o) == (t)) +#define ttisnumber(o) checktag((o), LUA_TNUMBER) +#define ttisnil(o) checktag((o), LUA_TNIL) +#define ttisboolean(o) checktag((o), LUA_TBOOLEAN) +#define ttislightuserdata(o) checktag((o), LUA_TLIGHTUSERDATA) +#define ttisstring(o) checktype((o), LUA_TSTRING) +#define ttisshrstring(o) checktag((o), ctb(LUA_TSHRSTR)) +#define ttislngstring(o) checktag((o), ctb(LUA_TLNGSTR)) +#define ttistable(o) checktag((o), ctb(LUA_TTABLE)) +#define ttisfunction(o) checktype(o, LUA_TFUNCTION) +#define ttisclosure(o) ((rttype(o) & 0x1F) == LUA_TFUNCTION) +#define ttisCclosure(o) checktag((o), ctb(LUA_TCCL)) +#define ttisLclosure(o) checktag((o), ctb(LUA_TLCL)) +#define ttislcf(o) checktag((o), LUA_TLCF) +#define ttisuserdata(o) checktag((o), ctb(LUA_TUSERDATA)) +#define ttisthread(o) checktag((o), ctb(LUA_TTHREAD)) +#define ttisdeadkey(o) checktag((o), LUA_TDEADKEY) + +#define ttisequal(o1,o2) (rttype(o1) == rttype(o2)) + +/* Macros to access values */ +#define nvalue(o) check_exp(ttisnumber(o), num_(o)) +#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) +#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) +#define rawtsvalue(o) check_exp(ttisstring(o), &val_(o).gc->ts) +#define tsvalue(o) (&rawtsvalue(o)->tsv) +#define rawuvalue(o) check_exp(ttisuserdata(o), &val_(o).gc->u) +#define uvalue(o) (&rawuvalue(o)->uv) +#define clvalue(o) check_exp(ttisclosure(o), &val_(o).gc->cl) +#define clLvalue(o) check_exp(ttisLclosure(o), &val_(o).gc->cl.l) +#define clCvalue(o) check_exp(ttisCclosure(o), &val_(o).gc->cl.c) +#define fvalue(o) check_exp(ttislcf(o), val_(o).f) +#define hvalue(o) check_exp(ttistable(o), &val_(o).gc->h) +#define bvalue(o) check_exp(ttisboolean(o), val_(o).b) +#define thvalue(o) check_exp(ttisthread(o), &val_(o).gc->th) +/* a dead value may get the 'gc' field, but cannot access its contents */ +#define deadvalue(o) check_exp(ttisdeadkey(o), cast(void *, val_(o).gc)) + +#define l_isfalse(o) (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0)) + + +#define iscollectable(o) (rttype(o) & BIT_ISCOLLECTABLE) + + +/* Macros for internal tests */ +#define righttt(obj) (ttype(obj) == gcvalue(obj)->gch.tt) + +#define checkliveness(g,obj) \ + lua_longassert(!iscollectable(obj) || \ + (righttt(obj) && !isdead(g,gcvalue(obj)))) + + +/* Macros to set values */ +#define settt_(o,t) ((o)->tt_=(t)) + +#define setnvalue(obj,x) \ + { TValue *io=(obj); num_(io)=(x); settt_(io, LUA_TNUMBER); } + +#define setnilvalue(obj) settt_(obj, LUA_TNIL) + +#define setfvalue(obj,x) \ + { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_TLCF); } + +#define setpvalue(obj,x) \ + { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_TLIGHTUSERDATA); } + +#define setbvalue(obj,x) \ + { TValue *io=(obj); val_(io).b=(x); settt_(io, LUA_TBOOLEAN); } + +#define setgcovalue(L,obj,x) \ + { TValue *io=(obj); GCObject *i_g=(x); \ + val_(io).gc=i_g; settt_(io, ctb(gch(i_g)->tt)); } + +#define setsvalue(L,obj,x) \ + { TValue *io=(obj); \ + TString *x_ = (x); \ + val_(io).gc=cast(GCObject *, x_); settt_(io, ctb(x_->tsv.tt)); \ + checkliveness(G(L),io); } + +#define setuvalue(L,obj,x) \ + { TValue *io=(obj); \ + val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TUSERDATA)); \ + checkliveness(G(L),io); } + +#define setthvalue(L,obj,x) \ + { TValue *io=(obj); \ + val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTHREAD)); \ + checkliveness(G(L),io); } + +#define setclLvalue(L,obj,x) \ + { TValue *io=(obj); \ + val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TLCL)); \ + checkliveness(G(L),io); } + +#define setclCvalue(L,obj,x) \ + { TValue *io=(obj); \ + val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TCCL)); \ + checkliveness(G(L),io); } + +#define sethvalue(L,obj,x) \ + { TValue *io=(obj); \ + val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTABLE)); \ + checkliveness(G(L),io); } + +#define setdeadvalue(obj) settt_(obj, LUA_TDEADKEY) + + + +#define setobj(L,obj1,obj2) \ + { const TValue *io2=(obj2); TValue *io1=(obj1); \ + io1->value_ = io2->value_; io1->tt_ = io2->tt_; \ + checkliveness(G(L),io1); } + + +/* +** different types of assignments, according to destination +*/ + +/* from stack to (same) stack */ +#define setobjs2s setobj +/* to stack (not from same stack) */ +#define setobj2s setobj +#define setsvalue2s setsvalue +#define sethvalue2s sethvalue +#define setptvalue2s setptvalue +/* from table to same table */ +#define setobjt2t setobj +/* to table */ +#define setobj2t setobj +/* to new object */ +#define setobj2n setobj +#define setsvalue2n setsvalue + + +/* check whether a number is valid (useful only for NaN trick) */ +#define luai_checknum(L,o,c) { /* empty */ } + + +/* +** {====================================================== +** NaN Trick +** ======================================================= +*/ +#if defined(LUA_NANTRICK) + +/* +** numbers are represented in the 'd_' field. All other values have the +** value (NNMARK | tag) in 'tt__'. A number with such pattern would be +** a "signaled NaN", which is never generated by regular operations by +** the CPU (nor by 'strtod') +*/ + +/* allows for external implementation for part of the trick */ +#if !defined(NNMARK) /* { */ + + +#if !defined(LUA_IEEEENDIAN) +#error option 'LUA_NANTRICK' needs 'LUA_IEEEENDIAN' +#endif + + +#define NNMARK 0x7FF7A500 +#define NNMASK 0x7FFFFF00 + +#undef TValuefields +#undef NILCONSTANT + +#if (LUA_IEEEENDIAN == 0) /* { */ + +/* little endian */ +#define TValuefields \ + union { struct { Value v__; int tt__; } i; double d__; } u +#define NILCONSTANT {{{NULL}, tag2tt(LUA_TNIL)}} +/* field-access macros */ +#define v_(o) ((o)->u.i.v__) +#define d_(o) ((o)->u.d__) +#define tt_(o) ((o)->u.i.tt__) + +#else /* }{ */ + +/* big endian */ +#define TValuefields \ + union { struct { int tt__; Value v__; } i; double d__; } u +#define NILCONSTANT {{tag2tt(LUA_TNIL), {NULL}}} +/* field-access macros */ +#define v_(o) ((o)->u.i.v__) +#define d_(o) ((o)->u.d__) +#define tt_(o) ((o)->u.i.tt__) + +#endif /* } */ + +#endif /* } */ + + +/* correspondence with standard representation */ +#undef val_ +#define val_(o) v_(o) +#undef num_ +#define num_(o) d_(o) + + +#undef numfield +#define numfield /* no such field; numbers are the entire struct */ + +/* basic check to distinguish numbers from non-numbers */ +#undef ttisnumber +#define ttisnumber(o) ((tt_(o) & NNMASK) != NNMARK) + +#define tag2tt(t) (NNMARK | (t)) + +#undef rttype +#define rttype(o) (ttisnumber(o) ? LUA_TNUMBER : tt_(o) & 0xff) + +#undef settt_ +#define settt_(o,t) (tt_(o) = tag2tt(t)) + +#undef setnvalue +#define setnvalue(obj,x) \ + { TValue *io_=(obj); num_(io_)=(x); lua_assert(ttisnumber(io_)); } + +#undef setobj +#define setobj(L,obj1,obj2) \ + { const TValue *o2_=(obj2); TValue *o1_=(obj1); \ + o1_->u = o2_->u; \ + checkliveness(G(L),o1_); } + + +/* +** these redefinitions are not mandatory, but these forms are more efficient +*/ + +#undef checktag +#undef checktype +#define checktag(o,t) (tt_(o) == tag2tt(t)) +#define checktype(o,t) (ctb(tt_(o) | VARBITS) == ctb(tag2tt(t) | VARBITS)) + +#undef ttisequal +#define ttisequal(o1,o2) \ + (ttisnumber(o1) ? ttisnumber(o2) : (tt_(o1) == tt_(o2))) + + +#undef luai_checknum +#define luai_checknum(L,o,c) { if (!ttisnumber(o)) c; } + +#endif +/* }====================================================== */ + + + +/* +** {====================================================== +** types and prototypes +** ======================================================= +*/ + + +union Value { + GCObject *gc; /* collectable objects */ + void *p; /* light userdata */ + int b; /* booleans */ + lua_CFunction f; /* light C functions */ + numfield /* numbers */ +}; + + +struct lua_TValue { + TValuefields; +}; + + +typedef TValue *StkId; /* index to stack elements */ + + + + +/* +** Header for string value; string bytes follow the end of this structure +*/ +typedef union TString { + L_Umaxalign dummy; /* ensures maximum alignment for strings */ + struct { + CommonHeader; + lu_byte extra; /* reserved words for short strings; "has hash" for longs */ + unsigned int hash; + size_t len; /* number of characters in string */ + } tsv; +} TString; + + +/* get the actual string (array of bytes) from a TString */ +#define getstr(ts) cast(const char *, (ts) + 1) + +/* get the actual string (array of bytes) from a Lua value */ +#define svalue(o) getstr(rawtsvalue(o)) + + +/* +** Header for userdata; memory area follows the end of this structure +*/ +typedef union Udata { + L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */ + struct { + CommonHeader; + struct Table *metatable; + struct Table *env; + size_t len; /* number of bytes */ + } uv; +} Udata; + + + +/* +** Description of an upvalue for function prototypes +*/ +typedef struct Upvaldesc { + TString *name; /* upvalue name (for debug information) */ + lu_byte instack; /* whether it is in stack */ + lu_byte idx; /* index of upvalue (in stack or in outer function's list) */ +} Upvaldesc; + + +/* +** Description of a local variable for function prototypes +** (used for debug information) +*/ +typedef struct LocVar { + TString *varname; + int startpc; /* first point where variable is active */ + int endpc; /* first point where variable is dead */ +} LocVar; + + +/* +** Function Prototypes +*/ +typedef struct Proto { + CommonHeader; + TValue *k; /* constants used by the function */ + Instruction *code; + struct Proto **p; /* functions defined inside the function */ + int *lineinfo; /* map from opcodes to source lines (debug information) */ + LocVar *locvars; /* information about local variables (debug information) */ + Upvaldesc *upvalues; /* upvalue information */ + union Closure *cache; /* last created closure with this prototype */ + TString *source; /* used for debug information */ + int sizeupvalues; /* size of 'upvalues' */ + int sizek; /* size of `k' */ + int sizecode; + int sizelineinfo; + int sizep; /* size of `p' */ + int sizelocvars; + int linedefined; + int lastlinedefined; + GCObject *gclist; + lu_byte numparams; /* number of fixed parameters */ + lu_byte is_vararg; + lu_byte maxstacksize; /* maximum stack used by this function */ +} Proto; + + + +/* +** Lua Upvalues +*/ +typedef struct UpVal { + CommonHeader; + TValue *v; /* points to stack or to its own value */ + union { + TValue value; /* the value (when closed) */ + struct { /* double linked list (when open) */ + struct UpVal *prev; + struct UpVal *next; + } l; + } u; +} UpVal; + + +/* +** Closures +*/ + +#define ClosureHeader \ + CommonHeader; lu_byte nupvalues; GCObject *gclist + +typedef struct CClosure { + ClosureHeader; + lua_CFunction f; + TValue upvalue[1]; /* list of upvalues */ +} CClosure; + + +typedef struct LClosure { + ClosureHeader; + struct Proto *p; + UpVal *upvals[1]; /* list of upvalues */ +} LClosure; + + +typedef union Closure { + CClosure c; + LClosure l; +} Closure; + + +#define isLfunction(o) ttisLclosure(o) + +#define getproto(o) (clLvalue(o)->p) + + +/* +** Tables +*/ + +typedef union TKey { + struct { + TValuefields; + struct Node *next; /* for chaining */ + } nk; + TValue tvk; +} TKey; + + +typedef struct Node { + TValue i_val; + TKey i_key; +} Node; + + +typedef struct Table { + CommonHeader; + lu_byte flags; /* 1<

lsizenode)) + + +/* +** (address of) a fixed nil value +*/ +#define luaO_nilobject (&luaO_nilobject_) + + +LUAI_DDEC const TValue luaO_nilobject_; + + +LUAI_FUNC int luaO_int2fb (unsigned int x); +LUAI_FUNC int luaO_fb2int (int x); +LUAI_FUNC int luaO_ceillog2 (unsigned int x); +LUAI_FUNC lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2); +LUAI_FUNC int luaO_str2d (const char *s, size_t len, lua_Number *result); +LUAI_FUNC int luaO_hexavalue (int c); +LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt, + va_list argp); +LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...); +LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len); + + +#endif + diff --git a/extern/lua/src/lobject.o b/extern/lua/src/lobject.o new file mode 100644 index 0000000000000000000000000000000000000000..71228abb249fe42802525ee61b4b4fb77baacfed GIT binary patch literal 6512 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 literal 0 HcmV?d00001 diff --git a/extern/lua/src/lopcodes.c b/extern/lua/src/lopcodes.c new file mode 100644 index 0000000..4190dc7 --- /dev/null +++ b/extern/lua/src/lopcodes.c @@ -0,0 +1,107 @@ +/* +** $Id: lopcodes.c,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $ +** Opcodes for Lua virtual machine +** See Copyright Notice in lua.h +*/ + + +#define lopcodes_c +#define LUA_CORE + + +#include "lopcodes.h" + + +/* ORDER OP */ + +LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = { + "MOVE", + "LOADK", + "LOADKX", + "LOADBOOL", + "LOADNIL", + "GETUPVAL", + "GETTABUP", + "GETTABLE", + "SETTABUP", + "SETUPVAL", + "SETTABLE", + "NEWTABLE", + "SELF", + "ADD", + "SUB", + "MUL", + "DIV", + "MOD", + "POW", + "UNM", + "NOT", + "LEN", + "CONCAT", + "JMP", + "EQ", + "LT", + "LE", + "TEST", + "TESTSET", + "CALL", + "TAILCALL", + "RETURN", + "FORLOOP", + "FORPREP", + "TFORCALL", + "TFORLOOP", + "SETLIST", + "CLOSURE", + "VARARG", + "EXTRAARG", + NULL +}; + + +#define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m)) + +LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = { +/* T A B C mode opcode */ + opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_MOVE */ + ,opmode(0, 1, OpArgK, OpArgN, iABx) /* OP_LOADK */ + ,opmode(0, 1, OpArgN, OpArgN, iABx) /* OP_LOADKX */ + ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_LOADBOOL */ + ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_LOADNIL */ + ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_GETUPVAL */ + ,opmode(0, 1, OpArgU, OpArgK, iABC) /* OP_GETTABUP */ + ,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_GETTABLE */ + ,opmode(0, 0, OpArgK, OpArgK, iABC) /* OP_SETTABUP */ + ,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_SETUPVAL */ + ,opmode(0, 0, OpArgK, OpArgK, iABC) /* OP_SETTABLE */ + ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_NEWTABLE */ + ,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_SELF */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_ADD */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_SUB */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MUL */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_DIV */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MOD */ + ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_POW */ + ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_UNM */ + ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_NOT */ + ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_LEN */ + ,opmode(0, 1, OpArgR, OpArgR, iABC) /* OP_CONCAT */ + ,opmode(0, 0, OpArgR, OpArgN, iAsBx) /* OP_JMP */ + ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_EQ */ + ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LT */ + ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LE */ + ,opmode(1, 0, OpArgN, OpArgU, iABC) /* OP_TEST */ + ,opmode(1, 1, OpArgR, OpArgU, iABC) /* OP_TESTSET */ + ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_CALL */ + ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_TAILCALL */ + ,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_RETURN */ + ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORLOOP */ + ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORPREP */ + ,opmode(0, 0, OpArgN, OpArgU, iABC) /* OP_TFORCALL */ + ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_TFORLOOP */ + ,opmode(0, 0, OpArgU, OpArgU, iABC) /* OP_SETLIST */ + ,opmode(0, 1, OpArgU, OpArgN, iABx) /* OP_CLOSURE */ + ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_VARARG */ + ,opmode(0, 0, OpArgU, OpArgU, iAx) /* OP_EXTRAARG */ +}; + diff --git a/extern/lua/src/lopcodes.h b/extern/lua/src/lopcodes.h new file mode 100644 index 0000000..51f5791 --- /dev/null +++ b/extern/lua/src/lopcodes.h @@ -0,0 +1,288 @@ +/* +** $Id: lopcodes.h,v 1.142.1.1 2013/04/12 18:48:47 roberto Exp $ +** Opcodes for Lua virtual machine +** See Copyright Notice in lua.h +*/ + +#ifndef lopcodes_h +#define lopcodes_h + +#include "llimits.h" + + +/*=========================================================================== + We assume that instructions are unsigned numbers. + All instructions have an opcode in the first 6 bits. + Instructions can have the following fields: + `A' : 8 bits + `B' : 9 bits + `C' : 9 bits + 'Ax' : 26 bits ('A', 'B', and 'C' together) + `Bx' : 18 bits (`B' and `C' together) + `sBx' : signed Bx + + A signed argument is represented in excess K; that is, the number + value is the unsigned value minus K. K is exactly the maximum value + for that argument (so that -max is represented by 0, and +max is + represented by 2*max), which is half the maximum for the corresponding + unsigned argument. +===========================================================================*/ + + +enum OpMode {iABC, iABx, iAsBx, iAx}; /* basic instruction format */ + + +/* +** size and position of opcode arguments. +*/ +#define SIZE_C 9 +#define SIZE_B 9 +#define SIZE_Bx (SIZE_C + SIZE_B) +#define SIZE_A 8 +#define SIZE_Ax (SIZE_C + SIZE_B + SIZE_A) + +#define SIZE_OP 6 + +#define POS_OP 0 +#define POS_A (POS_OP + SIZE_OP) +#define POS_C (POS_A + SIZE_A) +#define POS_B (POS_C + SIZE_C) +#define POS_Bx POS_C +#define POS_Ax POS_A + + +/* +** limits for opcode arguments. +** we use (signed) int to manipulate most arguments, +** so they must fit in LUAI_BITSINT-1 bits (-1 for sign) +*/ +#if SIZE_Bx < LUAI_BITSINT-1 +#define MAXARG_Bx ((1<>1) /* `sBx' is signed */ +#else +#define MAXARG_Bx MAX_INT +#define MAXARG_sBx MAX_INT +#endif + +#if SIZE_Ax < LUAI_BITSINT-1 +#define MAXARG_Ax ((1<>POS_OP) & MASK1(SIZE_OP,0))) +#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ + ((cast(Instruction, o)<>pos) & MASK1(size,0))) +#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ + ((cast(Instruction, v)<= R(A) + 1 */ +OP_EQ,/* A B C if ((RK(B) == RK(C)) ~= A) then pc++ */ +OP_LT,/* A B C if ((RK(B) < RK(C)) ~= A) then pc++ */ +OP_LE,/* A B C if ((RK(B) <= RK(C)) ~= A) then pc++ */ + +OP_TEST,/* A C if not (R(A) <=> C) then pc++ */ +OP_TESTSET,/* A B C if (R(B) <=> C) then R(A) := R(B) else pc++ */ + +OP_CALL,/* A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */ +OP_TAILCALL,/* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */ +OP_RETURN,/* A B return R(A), ... ,R(A+B-2) (see note) */ + +OP_FORLOOP,/* A sBx R(A)+=R(A+2); + if R(A) > 4) & 3)) +#define getCMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3)) +#define testAMode(m) (luaP_opmodes[m] & (1 << 6)) +#define testTMode(m) (luaP_opmodes[m] & (1 << 7)) + + +LUAI_DDEC const char *const luaP_opnames[NUM_OPCODES+1]; /* opcode names */ + + +/* number of list items to accumulate before a SETLIST instruction */ +#define LFIELDS_PER_FLUSH 50 + + +#endif diff --git a/extern/lua/src/lopcodes.o b/extern/lua/src/lopcodes.o new file mode 100644 index 0000000000000000000000000000000000000000..a80045752bdc62eb5a3be05f86b6268d817c3f2e GIT binary patch literal 2880 zcmeH{O=uHQ5XYxY)mD3GMX(}BRnQ7{X{3UcQnF39X>^m_CYv;ZU^ZzmV!mu5Ruo!L zu;4{Jh=QO84<0<|O{9lJA)>+F;Cpi4Ytk z;dn36F9dbd1V@jUUJw^U#$zyL#ZAky(c5vu21f)kQMHItGa|YPnpPqiHz1|Q^>`SJ zv=i4cfN(H)bZ{t?&z^D1gQMD*<{$Qt9*_}$R=ZfLyIJAu^U@boRL?KeL7Q{yE@;_W z4Yc`u(beWFl1Ptbe$5YBu2L%H%ObyAspqwDEIC}OyScM}>7(ux{owuE$odN~tt7vz zyF~-Cmh0-J2E6zB7q8zhQo66e>2Bd>A;cRpvcp4X#pHQ)y5Q^2R;FT~ z_r;WIdSBa>;QZRn5ILTl_2yf5n`Dl!vHIU@d_aqB!M!5x?`-xzL~T2W2S`t=4JlTt zxyoF=rsbe`-nCCvswI?4l--gL&2x@rt#=;JA)4YFqy(G1;`klW($Y2Zx022i3{{ocryT||l literal 0 HcmV?d00001 diff --git a/extern/lua/src/loslib.c b/extern/lua/src/loslib.c new file mode 100644 index 0000000..052ba17 --- /dev/null +++ b/extern/lua/src/loslib.c @@ -0,0 +1,323 @@ +/* +** $Id: loslib.c,v 1.40.1.1 2013/04/12 18:48:47 roberto Exp $ +** Standard Operating System library +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include +#include +#include + +#define loslib_c +#define LUA_LIB + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +/* +** list of valid conversion specifiers for the 'strftime' function +*/ +#if !defined(LUA_STRFTIMEOPTIONS) + +#if !defined(LUA_USE_POSIX) +#define LUA_STRFTIMEOPTIONS { "aAbBcdHIjmMpSUwWxXyYz%", "" } +#else +#define LUA_STRFTIMEOPTIONS \ + { "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%", "" \ + "", "E", "cCxXyY", \ + "O", "deHImMSuUVwWy" } +#endif + +#endif + + + +/* +** By default, Lua uses tmpnam except when POSIX is available, where it +** uses mkstemp. +*/ +#if defined(LUA_USE_MKSTEMP) +#include +#define LUA_TMPNAMBUFSIZE 32 +#define lua_tmpnam(b,e) { \ + strcpy(b, "/tmp/lua_XXXXXX"); \ + e = mkstemp(b); \ + if (e != -1) close(e); \ + e = (e == -1); } + +#elif !defined(lua_tmpnam) + +#define LUA_TMPNAMBUFSIZE L_tmpnam +#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); } + +#endif + + +/* +** By default, Lua uses gmtime/localtime, except when POSIX is available, +** where it uses gmtime_r/localtime_r +*/ +#if defined(LUA_USE_GMTIME_R) + +#define l_gmtime(t,r) gmtime_r(t,r) +#define l_localtime(t,r) localtime_r(t,r) + +#elif !defined(l_gmtime) + +#define l_gmtime(t,r) ((void)r, gmtime(t)) +#define l_localtime(t,r) ((void)r, localtime(t)) + +#endif + + + +static int os_execute (lua_State *L) { + const char *cmd = luaL_optstring(L, 1, NULL); + int stat = system(cmd); + if (cmd != NULL) + return luaL_execresult(L, stat); + else { + lua_pushboolean(L, stat); /* true if there is a shell */ + return 1; + } +} + + +static int os_remove (lua_State *L) { + const char *filename = luaL_checkstring(L, 1); + return luaL_fileresult(L, remove(filename) == 0, filename); +} + + +static int os_rename (lua_State *L) { + const char *fromname = luaL_checkstring(L, 1); + const char *toname = luaL_checkstring(L, 2); + return luaL_fileresult(L, rename(fromname, toname) == 0, NULL); +} + + +static int os_tmpname (lua_State *L) { + char buff[LUA_TMPNAMBUFSIZE]; + int err; + lua_tmpnam(buff, err); + if (err) + return luaL_error(L, "unable to generate a unique filename"); + lua_pushstring(L, buff); + return 1; +} + + +static int os_getenv (lua_State *L) { + lua_pushstring(L, getenv(luaL_checkstring(L, 1))); /* if NULL push nil */ + return 1; +} + + +static int os_clock (lua_State *L) { + lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC); + return 1; +} + + +/* +** {====================================================== +** Time/Date operations +** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S, +** wday=%w+1, yday=%j, isdst=? } +** ======================================================= +*/ + +static void setfield (lua_State *L, const char *key, int value) { + lua_pushinteger(L, value); + lua_setfield(L, -2, key); +} + +static void setboolfield (lua_State *L, const char *key, int value) { + if (value < 0) /* undefined? */ + return; /* does not set field */ + lua_pushboolean(L, value); + lua_setfield(L, -2, key); +} + +static int getboolfield (lua_State *L, const char *key) { + int res; + lua_getfield(L, -1, key); + res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1); + lua_pop(L, 1); + return res; +} + + +static int getfield (lua_State *L, const char *key, int d) { + int res, isnum; + lua_getfield(L, -1, key); + res = (int)lua_tointegerx(L, -1, &isnum); + if (!isnum) { + if (d < 0) + return luaL_error(L, "field " LUA_QS " missing in date table", key); + res = d; + } + lua_pop(L, 1); + return res; +} + + +static const char *checkoption (lua_State *L, const char *conv, char *buff) { + static const char *const options[] = LUA_STRFTIMEOPTIONS; + unsigned int i; + for (i = 0; i < sizeof(options)/sizeof(options[0]); i += 2) { + if (*conv != '\0' && strchr(options[i], *conv) != NULL) { + buff[1] = *conv; + if (*options[i + 1] == '\0') { /* one-char conversion specifier? */ + buff[2] = '\0'; /* end buffer */ + return conv + 1; + } + else if (*(conv + 1) != '\0' && + strchr(options[i + 1], *(conv + 1)) != NULL) { + buff[2] = *(conv + 1); /* valid two-char conversion specifier */ + buff[3] = '\0'; /* end buffer */ + return conv + 2; + } + } + } + luaL_argerror(L, 1, + lua_pushfstring(L, "invalid conversion specifier '%%%s'", conv)); + return conv; /* to avoid warnings */ +} + + +static int os_date (lua_State *L) { + const char *s = luaL_optstring(L, 1, "%c"); + time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL)); + struct tm tmr, *stm; + if (*s == '!') { /* UTC? */ + stm = l_gmtime(&t, &tmr); + s++; /* skip `!' */ + } + else + stm = l_localtime(&t, &tmr); + if (stm == NULL) /* invalid date? */ + lua_pushnil(L); + else if (strcmp(s, "*t") == 0) { + lua_createtable(L, 0, 9); /* 9 = number of fields */ + setfield(L, "sec", stm->tm_sec); + setfield(L, "min", stm->tm_min); + setfield(L, "hour", stm->tm_hour); + setfield(L, "day", stm->tm_mday); + setfield(L, "month", stm->tm_mon+1); + setfield(L, "year", stm->tm_year+1900); + setfield(L, "wday", stm->tm_wday+1); + setfield(L, "yday", stm->tm_yday+1); + setboolfield(L, "isdst", stm->tm_isdst); + } + else { + char cc[4]; + luaL_Buffer b; + cc[0] = '%'; + luaL_buffinit(L, &b); + while (*s) { + if (*s != '%') /* no conversion specifier? */ + luaL_addchar(&b, *s++); + else { + size_t reslen; + char buff[200]; /* should be big enough for any conversion result */ + s = checkoption(L, s + 1, cc); + reslen = strftime(buff, sizeof(buff), cc, stm); + luaL_addlstring(&b, buff, reslen); + } + } + luaL_pushresult(&b); + } + return 1; +} + + +static int os_time (lua_State *L) { + time_t t; + if (lua_isnoneornil(L, 1)) /* called without args? */ + t = time(NULL); /* get current time */ + else { + struct tm ts; + luaL_checktype(L, 1, LUA_TTABLE); + lua_settop(L, 1); /* make sure table is at the top */ + ts.tm_sec = getfield(L, "sec", 0); + ts.tm_min = getfield(L, "min", 0); + ts.tm_hour = getfield(L, "hour", 12); + ts.tm_mday = getfield(L, "day", -1); + ts.tm_mon = getfield(L, "month", -1) - 1; + ts.tm_year = getfield(L, "year", -1) - 1900; + ts.tm_isdst = getboolfield(L, "isdst"); + t = mktime(&ts); + } + if (t == (time_t)(-1)) + lua_pushnil(L); + else + lua_pushnumber(L, (lua_Number)t); + return 1; +} + + +static int os_difftime (lua_State *L) { + lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)), + (time_t)(luaL_optnumber(L, 2, 0)))); + return 1; +} + +/* }====================================================== */ + + +static int os_setlocale (lua_State *L) { + static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, + LC_NUMERIC, LC_TIME}; + static const char *const catnames[] = {"all", "collate", "ctype", "monetary", + "numeric", "time", NULL}; + const char *l = luaL_optstring(L, 1, NULL); + int op = luaL_checkoption(L, 2, "all", catnames); + lua_pushstring(L, setlocale(cat[op], l)); + return 1; +} + + +static int os_exit (lua_State *L) { + int status; + if (lua_isboolean(L, 1)) + status = (lua_toboolean(L, 1) ? EXIT_SUCCESS : EXIT_FAILURE); + else + status = luaL_optint(L, 1, EXIT_SUCCESS); + if (lua_toboolean(L, 2)) + lua_close(L); + if (L) exit(status); /* 'if' to avoid warnings for unreachable 'return' */ + return 0; +} + + +static const luaL_Reg syslib[] = { + {"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}, + {NULL, NULL} +}; + +/* }====================================================== */ + + + +LUAMOD_API int luaopen_os (lua_State *L) { + luaL_newlib(L, syslib); + return 1; +} + diff --git a/extern/lua/src/loslib.o b/extern/lua/src/loslib.o new file mode 100644 index 0000000000000000000000000000000000000000..a1dbd69c1c68458946a4e0f1d58b4b7f6385b807 GIT binary patch literal 11384 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 literal 0 HcmV?d00001 diff --git a/extern/lua/src/lparser.c b/extern/lua/src/lparser.c new file mode 100644 index 0000000..9e1a9ca --- /dev/null +++ b/extern/lua/src/lparser.c @@ -0,0 +1,1638 @@ +/* +** $Id: lparser.c,v 2.130.1.1 2013/04/12 18:48:47 roberto Exp $ +** Lua Parser +** See Copyright Notice in lua.h +*/ + + +#include + +#define lparser_c +#define LUA_CORE + +#include "lua.h" + +#include "lcode.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "llex.h" +#include "lmem.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lparser.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" + + + +/* maximum number of local variables per function (must be smaller + than 250, due to the bytecode format) */ +#define MAXVARS 200 + + +#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) + + + +/* +** nodes for block list (list of active blocks) +*/ +typedef struct BlockCnt { + struct BlockCnt *previous; /* chain */ + short firstlabel; /* index of first label in this block */ + short firstgoto; /* index of first pending goto in this block */ + lu_byte nactvar; /* # active locals outside the block */ + lu_byte upval; /* true if some variable in the block is an upvalue */ + lu_byte isloop; /* true if `block' is a loop */ +} BlockCnt; + + + +/* +** prototypes for recursive non-terminal functions +*/ +static void statement (LexState *ls); +static void expr (LexState *ls, expdesc *v); + + +static void anchor_token (LexState *ls) { + /* last token from outer function must be EOS */ + lua_assert(ls->fs != NULL || ls->t.token == TK_EOS); + if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) { + TString *ts = ls->t.seminfo.ts; + luaX_newstring(ls, getstr(ts), ts->tsv.len); + } +} + + +/* semantic error */ +static l_noret semerror (LexState *ls, const char *msg) { + ls->t.token = 0; /* remove 'near to' from final message */ + luaX_syntaxerror(ls, msg); +} + + +static l_noret error_expected (LexState *ls, int token) { + luaX_syntaxerror(ls, + luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token))); +} + + +static l_noret errorlimit (FuncState *fs, int limit, const char *what) { + lua_State *L = fs->ls->L; + const char *msg; + int line = fs->f->linedefined; + const char *where = (line == 0) + ? "main function" + : luaO_pushfstring(L, "function at line %d", line); + msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s", + what, limit, where); + luaX_syntaxerror(fs->ls, msg); +} + + +static void checklimit (FuncState *fs, int v, int l, const char *what) { + if (v > l) errorlimit(fs, l, what); +} + + +static int testnext (LexState *ls, int c) { + if (ls->t.token == c) { + luaX_next(ls); + return 1; + } + else return 0; +} + + +static void check (LexState *ls, int c) { + if (ls->t.token != c) + error_expected(ls, c); +} + + +static void checknext (LexState *ls, int c) { + check(ls, c); + luaX_next(ls); +} + + +#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } + + + +static void check_match (LexState *ls, int what, int who, int where) { + if (!testnext(ls, what)) { + if (where == ls->linenumber) + error_expected(ls, what); + else { + luaX_syntaxerror(ls, luaO_pushfstring(ls->L, + "%s expected (to close %s at line %d)", + luaX_token2str(ls, what), luaX_token2str(ls, who), where)); + } + } +} + + +static TString *str_checkname (LexState *ls) { + TString *ts; + check(ls, TK_NAME); + ts = ls->t.seminfo.ts; + luaX_next(ls); + return ts; +} + + +static void init_exp (expdesc *e, expkind k, int i) { + e->f = e->t = NO_JUMP; + e->k = k; + e->u.info = i; +} + + +static void codestring (LexState *ls, expdesc *e, TString *s) { + init_exp(e, VK, luaK_stringK(ls->fs, s)); +} + + +static void checkname (LexState *ls, expdesc *e) { + codestring(ls, e, str_checkname(ls)); +} + + +static int registerlocalvar (LexState *ls, TString *varname) { + FuncState *fs = ls->fs; + Proto *f = fs->f; + int oldsize = f->sizelocvars; + luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars, + LocVar, SHRT_MAX, "local variables"); + while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL; + f->locvars[fs->nlocvars].varname = varname; + luaC_objbarrier(ls->L, f, varname); + return fs->nlocvars++; +} + + +static void new_localvar (LexState *ls, TString *name) { + FuncState *fs = ls->fs; + Dyndata *dyd = ls->dyd; + int reg = registerlocalvar(ls, name); + checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal, + MAXVARS, "local variables"); + luaM_growvector(ls->L, dyd->actvar.arr, dyd->actvar.n + 1, + dyd->actvar.size, Vardesc, MAX_INT, "local variables"); + dyd->actvar.arr[dyd->actvar.n++].idx = cast(short, reg); +} + + +static void new_localvarliteral_ (LexState *ls, const char *name, size_t sz) { + new_localvar(ls, luaX_newstring(ls, name, sz)); +} + +#define new_localvarliteral(ls,v) \ + new_localvarliteral_(ls, "" v, (sizeof(v)/sizeof(char))-1) + + +static LocVar *getlocvar (FuncState *fs, int i) { + int idx = fs->ls->dyd->actvar.arr[fs->firstlocal + i].idx; + lua_assert(idx < fs->nlocvars); + return &fs->f->locvars[idx]; +} + + +static void adjustlocalvars (LexState *ls, int nvars) { + FuncState *fs = ls->fs; + fs->nactvar = cast_byte(fs->nactvar + nvars); + for (; nvars; nvars--) { + getlocvar(fs, fs->nactvar - nvars)->startpc = fs->pc; + } +} + + +static void removevars (FuncState *fs, int tolevel) { + fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel); + while (fs->nactvar > tolevel) + getlocvar(fs, --fs->nactvar)->endpc = fs->pc; +} + + +static int searchupvalue (FuncState *fs, TString *name) { + int i; + Upvaldesc *up = fs->f->upvalues; + for (i = 0; i < fs->nups; i++) { + if (luaS_eqstr(up[i].name, name)) return i; + } + return -1; /* not found */ +} + + +static int newupvalue (FuncState *fs, TString *name, expdesc *v) { + Proto *f = fs->f; + int oldsize = f->sizeupvalues; + checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues"); + luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues, + Upvaldesc, MAXUPVAL, "upvalues"); + while (oldsize < f->sizeupvalues) f->upvalues[oldsize++].name = NULL; + f->upvalues[fs->nups].instack = (v->k == VLOCAL); + f->upvalues[fs->nups].idx = cast_byte(v->u.info); + f->upvalues[fs->nups].name = name; + luaC_objbarrier(fs->ls->L, f, name); + return fs->nups++; +} + + +static int searchvar (FuncState *fs, TString *n) { + int i; + for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) { + if (luaS_eqstr(n, getlocvar(fs, i)->varname)) + return i; + } + return -1; /* not found */ +} + + +/* + Mark block where variable at given level was defined + (to emit close instructions later). +*/ +static void markupval (FuncState *fs, int level) { + BlockCnt *bl = fs->bl; + while (bl->nactvar > level) bl = bl->previous; + bl->upval = 1; +} + + +/* + Find variable with given name 'n'. If it is an upvalue, add this + upvalue into all intermediate functions. +*/ +static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { + if (fs == NULL) /* no more levels? */ + return VVOID; /* default is global */ + else { + int v = searchvar(fs, n); /* look up locals at current level */ + if (v >= 0) { /* found? */ + init_exp(var, VLOCAL, v); /* variable is local */ + if (!base) + markupval(fs, v); /* local will be used as an upval */ + return VLOCAL; + } + else { /* not found as local at current level; try upvalues */ + int idx = searchupvalue(fs, n); /* try existing upvalues */ + if (idx < 0) { /* not found? */ + if (singlevaraux(fs->prev, n, var, 0) == VVOID) /* try upper levels */ + return VVOID; /* not found; is a global */ + /* else was LOCAL or UPVAL */ + idx = newupvalue(fs, n, var); /* will be a new upvalue */ + } + init_exp(var, VUPVAL, idx); + return VUPVAL; + } + } +} + + +static void singlevar (LexState *ls, expdesc *var) { + TString *varname = str_checkname(ls); + FuncState *fs = ls->fs; + if (singlevaraux(fs, varname, var, 1) == VVOID) { /* global name? */ + expdesc key; + singlevaraux(fs, ls->envn, var, 1); /* get environment variable */ + lua_assert(var->k == VLOCAL || var->k == VUPVAL); + codestring(ls, &key, varname); /* key is variable name */ + luaK_indexed(fs, var, &key); /* env[varname] */ + } +} + + +static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) { + FuncState *fs = ls->fs; + int extra = nvars - nexps; + if (hasmultret(e->k)) { + extra++; /* includes call itself */ + if (extra < 0) extra = 0; + luaK_setreturns(fs, e, extra); /* last exp. provides the difference */ + if (extra > 1) luaK_reserveregs(fs, extra-1); + } + else { + if (e->k != VVOID) luaK_exp2nextreg(fs, e); /* close last expression */ + if (extra > 0) { + int reg = fs->freereg; + luaK_reserveregs(fs, extra); + luaK_nil(fs, reg, extra); + } + } +} + + +static void enterlevel (LexState *ls) { + lua_State *L = ls->L; + ++L->nCcalls; + checklimit(ls->fs, L->nCcalls, LUAI_MAXCCALLS, "C levels"); +} + + +#define leavelevel(ls) ((ls)->L->nCcalls--) + + +static void closegoto (LexState *ls, int g, Labeldesc *label) { + int i; + FuncState *fs = ls->fs; + Labellist *gl = &ls->dyd->gt; + Labeldesc *gt = &gl->arr[g]; + lua_assert(luaS_eqstr(gt->name, label->name)); + if (gt->nactvar < label->nactvar) { + TString *vname = getlocvar(fs, gt->nactvar)->varname; + const char *msg = luaO_pushfstring(ls->L, + " at line %d jumps into the scope of local " LUA_QS, + getstr(gt->name), gt->line, getstr(vname)); + semerror(ls, msg); + } + luaK_patchlist(fs, gt->pc, label->pc); + /* remove goto from pending list */ + for (i = g; i < gl->n - 1; i++) + gl->arr[i] = gl->arr[i + 1]; + gl->n--; +} + + +/* +** try to close a goto with existing labels; this solves backward jumps +*/ +static int findlabel (LexState *ls, int g) { + int i; + BlockCnt *bl = ls->fs->bl; + Dyndata *dyd = ls->dyd; + Labeldesc *gt = &dyd->gt.arr[g]; + /* check labels in current block for a match */ + for (i = bl->firstlabel; i < dyd->label.n; i++) { + Labeldesc *lb = &dyd->label.arr[i]; + if (luaS_eqstr(lb->name, gt->name)) { /* correct label? */ + if (gt->nactvar > lb->nactvar && + (bl->upval || dyd->label.n > bl->firstlabel)) + luaK_patchclose(ls->fs, gt->pc, lb->nactvar); + closegoto(ls, g, lb); /* close it */ + return 1; + } + } + return 0; /* label not found; cannot close goto */ +} + + +static int newlabelentry (LexState *ls, Labellist *l, TString *name, + int line, int pc) { + int n = l->n; + luaM_growvector(ls->L, l->arr, n, l->size, + Labeldesc, SHRT_MAX, "labels/gotos"); + l->arr[n].name = name; + l->arr[n].line = line; + l->arr[n].nactvar = ls->fs->nactvar; + l->arr[n].pc = pc; + l->n++; + return n; +} + + +/* +** check whether new label 'lb' matches any pending gotos in current +** block; solves forward jumps +*/ +static void findgotos (LexState *ls, Labeldesc *lb) { + Labellist *gl = &ls->dyd->gt; + int i = ls->fs->bl->firstgoto; + while (i < gl->n) { + if (luaS_eqstr(gl->arr[i].name, lb->name)) + closegoto(ls, i, lb); + else + i++; + } +} + + +/* +** "export" pending gotos to outer level, to check them against +** outer labels; if the block being exited has upvalues, and +** the goto exits the scope of any variable (which can be the +** upvalue), close those variables being exited. +*/ +static void movegotosout (FuncState *fs, BlockCnt *bl) { + int i = bl->firstgoto; + Labellist *gl = &fs->ls->dyd->gt; + /* correct pending gotos to current block and try to close it + with visible labels */ + while (i < gl->n) { + Labeldesc *gt = &gl->arr[i]; + if (gt->nactvar > bl->nactvar) { + if (bl->upval) + luaK_patchclose(fs, gt->pc, bl->nactvar); + gt->nactvar = bl->nactvar; + } + if (!findlabel(fs->ls, i)) + i++; /* move to next one */ + } +} + + +static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) { + bl->isloop = isloop; + bl->nactvar = fs->nactvar; + bl->firstlabel = fs->ls->dyd->label.n; + bl->firstgoto = fs->ls->dyd->gt.n; + bl->upval = 0; + bl->previous = fs->bl; + fs->bl = bl; + lua_assert(fs->freereg == fs->nactvar); +} + + +/* +** create a label named "break" to resolve break statements +*/ +static void breaklabel (LexState *ls) { + TString *n = luaS_new(ls->L, "break"); + int l = newlabelentry(ls, &ls->dyd->label, n, 0, ls->fs->pc); + findgotos(ls, &ls->dyd->label.arr[l]); +} + +/* +** generates an error for an undefined 'goto'; choose appropriate +** message when label name is a reserved word (which can only be 'break') +*/ +static l_noret undefgoto (LexState *ls, Labeldesc *gt) { + const char *msg = isreserved(gt->name) + ? "<%s> at line %d not inside a loop" + : "no visible label " LUA_QS " for at line %d"; + msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line); + semerror(ls, msg); +} + + +static void leaveblock (FuncState *fs) { + BlockCnt *bl = fs->bl; + LexState *ls = fs->ls; + if (bl->previous && bl->upval) { + /* create a 'jump to here' to close upvalues */ + int j = luaK_jump(fs); + luaK_patchclose(fs, j, bl->nactvar); + luaK_patchtohere(fs, j); + } + if (bl->isloop) + breaklabel(ls); /* close pending breaks */ + fs->bl = bl->previous; + removevars(fs, bl->nactvar); + lua_assert(bl->nactvar == fs->nactvar); + fs->freereg = fs->nactvar; /* free registers */ + ls->dyd->label.n = bl->firstlabel; /* remove local labels */ + if (bl->previous) /* inner block? */ + movegotosout(fs, bl); /* update pending gotos to outer block */ + else if (bl->firstgoto < ls->dyd->gt.n) /* pending gotos in outer block? */ + undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */ +} + + +/* +** adds a new prototype into list of prototypes +*/ +static Proto *addprototype (LexState *ls) { + Proto *clp; + lua_State *L = ls->L; + FuncState *fs = ls->fs; + Proto *f = fs->f; /* prototype of current function */ + if (fs->np >= f->sizep) { + int oldsize = f->sizep; + luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions"); + while (oldsize < f->sizep) f->p[oldsize++] = NULL; + } + f->p[fs->np++] = clp = luaF_newproto(L); + luaC_objbarrier(L, f, clp); + return clp; +} + + +/* +** codes instruction to create new closure in parent function. +** The OP_CLOSURE instruction must use the last available register, +** so that, if it invokes the GC, the GC knows which registers +** are in use at that time. +*/ +static void codeclosure (LexState *ls, expdesc *v) { + FuncState *fs = ls->fs->prev; + init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1)); + luaK_exp2nextreg(fs, v); /* fix it at the last register */ +} + + +static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) { + lua_State *L = ls->L; + Proto *f; + fs->prev = ls->fs; /* linked list of funcstates */ + fs->ls = ls; + ls->fs = fs; + fs->pc = 0; + fs->lasttarget = 0; + fs->jpc = NO_JUMP; + fs->freereg = 0; + fs->nk = 0; + fs->np = 0; + fs->nups = 0; + fs->nlocvars = 0; + fs->nactvar = 0; + fs->firstlocal = ls->dyd->actvar.n; + fs->bl = NULL; + f = fs->f; + f->source = ls->source; + f->maxstacksize = 2; /* registers 0/1 are always valid */ + fs->h = luaH_new(L); + /* anchor table of constants (to avoid being collected) */ + sethvalue2s(L, L->top, fs->h); + incr_top(L); + enterblock(fs, bl, 0); +} + + +static void close_func (LexState *ls) { + lua_State *L = ls->L; + FuncState *fs = ls->fs; + Proto *f = fs->f; + luaK_ret(fs, 0, 0); /* final return */ + leaveblock(fs); + luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction); + f->sizecode = fs->pc; + luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int); + f->sizelineinfo = fs->pc; + luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue); + f->sizek = fs->nk; + luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *); + f->sizep = fs->np; + luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar); + f->sizelocvars = fs->nlocvars; + luaM_reallocvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc); + f->sizeupvalues = fs->nups; + lua_assert(fs->bl == NULL); + ls->fs = fs->prev; + /* last token read was anchored in defunct function; must re-anchor it */ + anchor_token(ls); + L->top--; /* pop table of constants */ + luaC_checkGC(L); +} + + + +/*============================================================*/ +/* GRAMMAR RULES */ +/*============================================================*/ + + +/* +** check whether current token is in the follow set of a block. +** 'until' closes syntactical blocks, but do not close scope, +** so it handled in separate. +*/ +static int block_follow (LexState *ls, int withuntil) { + switch (ls->t.token) { + case TK_ELSE: case TK_ELSEIF: + case TK_END: case TK_EOS: + return 1; + case TK_UNTIL: return withuntil; + default: return 0; + } +} + + +static void statlist (LexState *ls) { + /* statlist -> { stat [`;'] } */ + while (!block_follow(ls, 1)) { + if (ls->t.token == TK_RETURN) { + statement(ls); + return; /* 'return' must be last statement */ + } + statement(ls); + } +} + + +static void fieldsel (LexState *ls, expdesc *v) { + /* fieldsel -> ['.' | ':'] NAME */ + FuncState *fs = ls->fs; + expdesc key; + luaK_exp2anyregup(fs, v); + luaX_next(ls); /* skip the dot or colon */ + checkname(ls, &key); + luaK_indexed(fs, v, &key); +} + + +static void yindex (LexState *ls, expdesc *v) { + /* index -> '[' expr ']' */ + luaX_next(ls); /* skip the '[' */ + expr(ls, v); + luaK_exp2val(ls->fs, v); + checknext(ls, ']'); +} + + +/* +** {====================================================================== +** Rules for Constructors +** ======================================================================= +*/ + + +struct ConsControl { + expdesc v; /* last list item read */ + expdesc *t; /* table descriptor */ + int nh; /* total number of `record' elements */ + int na; /* total number of array elements */ + int tostore; /* number of array elements pending to be stored */ +}; + + +static void recfield (LexState *ls, struct ConsControl *cc) { + /* recfield -> (NAME | `['exp1`]') = exp1 */ + FuncState *fs = ls->fs; + int reg = ls->fs->freereg; + expdesc key, val; + int rkkey; + if (ls->t.token == TK_NAME) { + checklimit(fs, cc->nh, MAX_INT, "items in a constructor"); + checkname(ls, &key); + } + else /* ls->t.token == '[' */ + yindex(ls, &key); + cc->nh++; + checknext(ls, '='); + rkkey = luaK_exp2RK(fs, &key); + expr(ls, &val); + luaK_codeABC(fs, OP_SETTABLE, cc->t->u.info, rkkey, luaK_exp2RK(fs, &val)); + fs->freereg = reg; /* free registers */ +} + + +static void closelistfield (FuncState *fs, struct ConsControl *cc) { + if (cc->v.k == VVOID) return; /* there is no list item */ + luaK_exp2nextreg(fs, &cc->v); + cc->v.k = VVOID; + if (cc->tostore == LFIELDS_PER_FLUSH) { + luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); /* flush */ + cc->tostore = 0; /* no more items pending */ + } +} + + +static void lastlistfield (FuncState *fs, struct ConsControl *cc) { + if (cc->tostore == 0) return; + if (hasmultret(cc->v.k)) { + luaK_setmultret(fs, &cc->v); + luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET); + cc->na--; /* do not count last expression (unknown number of elements) */ + } + else { + if (cc->v.k != VVOID) + luaK_exp2nextreg(fs, &cc->v); + luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); + } +} + + +static void listfield (LexState *ls, struct ConsControl *cc) { + /* listfield -> exp */ + expr(ls, &cc->v); + checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor"); + cc->na++; + cc->tostore++; +} + + +static void field (LexState *ls, struct ConsControl *cc) { + /* field -> listfield | recfield */ + switch(ls->t.token) { + case TK_NAME: { /* may be 'listfield' or 'recfield' */ + if (luaX_lookahead(ls) != '=') /* expression? */ + listfield(ls, cc); + else + recfield(ls, cc); + break; + } + case '[': { + recfield(ls, cc); + break; + } + default: { + listfield(ls, cc); + break; + } + } +} + + +static void constructor (LexState *ls, expdesc *t) { + /* constructor -> '{' [ field { sep field } [sep] ] '}' + sep -> ',' | ';' */ + FuncState *fs = ls->fs; + int line = ls->linenumber; + int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0); + struct ConsControl cc; + cc.na = cc.nh = cc.tostore = 0; + cc.t = t; + init_exp(t, VRELOCABLE, pc); + init_exp(&cc.v, VVOID, 0); /* no value (yet) */ + luaK_exp2nextreg(ls->fs, t); /* fix it at stack top */ + checknext(ls, '{'); + do { + lua_assert(cc.v.k == VVOID || cc.tostore > 0); + if (ls->t.token == '}') break; + closelistfield(fs, &cc); + field(ls, &cc); + } while (testnext(ls, ',') || testnext(ls, ';')); + check_match(ls, '}', '{', line); + lastlistfield(fs, &cc); + SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */ + SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh)); /* set initial table size */ +} + +/* }====================================================================== */ + + + +static void parlist (LexState *ls) { + /* parlist -> [ param { `,' param } ] */ + FuncState *fs = ls->fs; + Proto *f = fs->f; + int nparams = 0; + f->is_vararg = 0; + if (ls->t.token != ')') { /* is `parlist' not empty? */ + do { + switch (ls->t.token) { + case TK_NAME: { /* param -> NAME */ + new_localvar(ls, str_checkname(ls)); + nparams++; + break; + } + case TK_DOTS: { /* param -> `...' */ + luaX_next(ls); + f->is_vararg = 1; + break; + } + default: luaX_syntaxerror(ls, " or " LUA_QL("...") " expected"); + } + } while (!f->is_vararg && testnext(ls, ',')); + } + adjustlocalvars(ls, nparams); + f->numparams = cast_byte(fs->nactvar); + luaK_reserveregs(fs, fs->nactvar); /* reserve register for parameters */ +} + + +static void body (LexState *ls, expdesc *e, int ismethod, int line) { + /* body -> `(' parlist `)' block END */ + FuncState new_fs; + BlockCnt bl; + new_fs.f = addprototype(ls); + new_fs.f->linedefined = line; + open_func(ls, &new_fs, &bl); + checknext(ls, '('); + if (ismethod) { + new_localvarliteral(ls, "self"); /* create 'self' parameter */ + adjustlocalvars(ls, 1); + } + parlist(ls); + checknext(ls, ')'); + statlist(ls); + new_fs.f->lastlinedefined = ls->linenumber; + check_match(ls, TK_END, TK_FUNCTION, line); + codeclosure(ls, e); + close_func(ls); +} + + +static int explist (LexState *ls, expdesc *v) { + /* explist -> expr { `,' expr } */ + int n = 1; /* at least one expression */ + expr(ls, v); + while (testnext(ls, ',')) { + luaK_exp2nextreg(ls->fs, v); + expr(ls, v); + n++; + } + return n; +} + + +static void funcargs (LexState *ls, expdesc *f, int line) { + FuncState *fs = ls->fs; + expdesc args; + int base, nparams; + switch (ls->t.token) { + case '(': { /* funcargs -> `(' [ explist ] `)' */ + luaX_next(ls); + if (ls->t.token == ')') /* arg list is empty? */ + args.k = VVOID; + else { + explist(ls, &args); + luaK_setmultret(fs, &args); + } + check_match(ls, ')', '(', line); + break; + } + case '{': { /* funcargs -> constructor */ + constructor(ls, &args); + break; + } + case TK_STRING: { /* funcargs -> STRING */ + codestring(ls, &args, ls->t.seminfo.ts); + luaX_next(ls); /* must use `seminfo' before `next' */ + break; + } + default: { + luaX_syntaxerror(ls, "function arguments expected"); + } + } + lua_assert(f->k == VNONRELOC); + base = f->u.info; /* base register for call */ + if (hasmultret(args.k)) + nparams = LUA_MULTRET; /* open call */ + else { + if (args.k != VVOID) + luaK_exp2nextreg(fs, &args); /* close last argument */ + nparams = fs->freereg - (base+1); + } + init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2)); + luaK_fixline(fs, line); + fs->freereg = base+1; /* call remove function and arguments and leaves + (unless changed) one result */ +} + + + + +/* +** {====================================================================== +** Expression parsing +** ======================================================================= +*/ + + +static void primaryexp (LexState *ls, expdesc *v) { + /* primaryexp -> NAME | '(' expr ')' */ + switch (ls->t.token) { + case '(': { + int line = ls->linenumber; + luaX_next(ls); + expr(ls, v); + check_match(ls, ')', '(', line); + luaK_dischargevars(ls->fs, v); + return; + } + case TK_NAME: { + singlevar(ls, v); + return; + } + default: { + luaX_syntaxerror(ls, "unexpected symbol"); + } + } +} + + +static void suffixedexp (LexState *ls, expdesc *v) { + /* suffixedexp -> + primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */ + FuncState *fs = ls->fs; + int line = ls->linenumber; + primaryexp(ls, v); + for (;;) { + switch (ls->t.token) { + case '.': { /* fieldsel */ + fieldsel(ls, v); + break; + } + case '[': { /* `[' exp1 `]' */ + expdesc key; + luaK_exp2anyregup(fs, v); + yindex(ls, &key); + luaK_indexed(fs, v, &key); + break; + } + case ':': { /* `:' NAME funcargs */ + expdesc key; + luaX_next(ls); + checkname(ls, &key); + luaK_self(fs, v, &key); + funcargs(ls, v, line); + break; + } + case '(': case TK_STRING: case '{': { /* funcargs */ + luaK_exp2nextreg(fs, v); + funcargs(ls, v, line); + break; + } + default: return; + } + } +} + + +static void simpleexp (LexState *ls, expdesc *v) { + /* simpleexp -> NUMBER | STRING | NIL | TRUE | FALSE | ... | + constructor | FUNCTION body | suffixedexp */ + switch (ls->t.token) { + case TK_NUMBER: { + init_exp(v, VKNUM, 0); + v->u.nval = ls->t.seminfo.r; + break; + } + case TK_STRING: { + codestring(ls, v, ls->t.seminfo.ts); + break; + } + case TK_NIL: { + init_exp(v, VNIL, 0); + break; + } + case TK_TRUE: { + init_exp(v, VTRUE, 0); + break; + } + case TK_FALSE: { + init_exp(v, VFALSE, 0); + break; + } + case TK_DOTS: { /* vararg */ + FuncState *fs = ls->fs; + check_condition(ls, fs->f->is_vararg, + "cannot use " LUA_QL("...") " outside a vararg function"); + init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0)); + break; + } + case '{': { /* constructor */ + constructor(ls, v); + return; + } + case TK_FUNCTION: { + luaX_next(ls); + body(ls, v, 0, ls->linenumber); + return; + } + default: { + suffixedexp(ls, v); + return; + } + } + luaX_next(ls); +} + + +static UnOpr getunopr (int op) { + switch (op) { + case TK_NOT: return OPR_NOT; + case '-': return OPR_MINUS; + case '#': return OPR_LEN; + default: return OPR_NOUNOPR; + } +} + + +static BinOpr getbinopr (int op) { + switch (op) { + case '+': return OPR_ADD; + case '-': return OPR_SUB; + case '*': return OPR_MUL; + case '/': return OPR_DIV; + case '%': return OPR_MOD; + case '^': return OPR_POW; + case TK_CONCAT: return OPR_CONCAT; + case TK_NE: return OPR_NE; + case TK_EQ: return OPR_EQ; + case '<': return OPR_LT; + case TK_LE: return OPR_LE; + case '>': return OPR_GT; + case TK_GE: return OPR_GE; + case TK_AND: return OPR_AND; + case TK_OR: return OPR_OR; + default: return OPR_NOBINOPR; + } +} + + +static const struct { + lu_byte left; /* left priority for each binary operator */ + lu_byte right; /* right priority */ +} priority[] = { /* ORDER OPR */ + {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7}, /* `+' `-' `*' `/' `%' */ + {10, 9}, {5, 4}, /* ^, .. (right associative) */ + {3, 3}, {3, 3}, {3, 3}, /* ==, <, <= */ + {3, 3}, {3, 3}, {3, 3}, /* ~=, >, >= */ + {2, 2}, {1, 1} /* and, or */ +}; + +#define UNARY_PRIORITY 8 /* priority for unary operators */ + + +/* +** subexpr -> (simpleexp | unop subexpr) { binop subexpr } +** where `binop' is any binary operator with a priority higher than `limit' +*/ +static BinOpr subexpr (LexState *ls, expdesc *v, int limit) { + BinOpr op; + UnOpr uop; + enterlevel(ls); + uop = getunopr(ls->t.token); + if (uop != OPR_NOUNOPR) { + int line = ls->linenumber; + luaX_next(ls); + subexpr(ls, v, UNARY_PRIORITY); + luaK_prefix(ls->fs, uop, v, line); + } + else simpleexp(ls, v); + /* expand while operators have priorities higher than `limit' */ + op = getbinopr(ls->t.token); + while (op != OPR_NOBINOPR && priority[op].left > limit) { + expdesc v2; + BinOpr nextop; + int line = ls->linenumber; + luaX_next(ls); + luaK_infix(ls->fs, op, v); + /* read sub-expression with higher priority */ + nextop = subexpr(ls, &v2, priority[op].right); + luaK_posfix(ls->fs, op, v, &v2, line); + op = nextop; + } + leavelevel(ls); + return op; /* return first untreated operator */ +} + + +static void expr (LexState *ls, expdesc *v) { + subexpr(ls, v, 0); +} + +/* }==================================================================== */ + + + +/* +** {====================================================================== +** Rules for Statements +** ======================================================================= +*/ + + +static void block (LexState *ls) { + /* block -> statlist */ + FuncState *fs = ls->fs; + BlockCnt bl; + enterblock(fs, &bl, 0); + statlist(ls); + leaveblock(fs); +} + + +/* +** structure to chain all variables in the left-hand side of an +** assignment +*/ +struct LHS_assign { + struct LHS_assign *prev; + expdesc v; /* variable (global, local, upvalue, or indexed) */ +}; + + +/* +** check whether, in an assignment to an upvalue/local variable, the +** upvalue/local variable is begin used in a previous assignment to a +** table. If so, save original upvalue/local value in a safe place and +** use this safe copy in the previous assignment. +*/ +static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) { + FuncState *fs = ls->fs; + int extra = fs->freereg; /* eventual position to save local variable */ + int conflict = 0; + for (; lh; lh = lh->prev) { /* check all previous assignments */ + if (lh->v.k == VINDEXED) { /* assigning to a table? */ + /* table is the upvalue/local being assigned now? */ + if (lh->v.u.ind.vt == v->k && lh->v.u.ind.t == v->u.info) { + conflict = 1; + lh->v.u.ind.vt = VLOCAL; + lh->v.u.ind.t = extra; /* previous assignment will use safe copy */ + } + /* index is the local being assigned? (index cannot be upvalue) */ + if (v->k == VLOCAL && lh->v.u.ind.idx == v->u.info) { + conflict = 1; + lh->v.u.ind.idx = extra; /* previous assignment will use safe copy */ + } + } + } + if (conflict) { + /* copy upvalue/local value to a temporary (in position 'extra') */ + OpCode op = (v->k == VLOCAL) ? OP_MOVE : OP_GETUPVAL; + luaK_codeABC(fs, op, extra, v->u.info, 0); + luaK_reserveregs(fs, 1); + } +} + + +static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) { + expdesc e; + check_condition(ls, vkisvar(lh->v.k), "syntax error"); + if (testnext(ls, ',')) { /* assignment -> ',' suffixedexp assignment */ + struct LHS_assign nv; + nv.prev = lh; + suffixedexp(ls, &nv.v); + if (nv.v.k != VINDEXED) + check_conflict(ls, lh, &nv.v); + checklimit(ls->fs, nvars + ls->L->nCcalls, LUAI_MAXCCALLS, + "C levels"); + assignment(ls, &nv, nvars+1); + } + else { /* assignment -> `=' explist */ + int nexps; + checknext(ls, '='); + nexps = explist(ls, &e); + if (nexps != nvars) { + adjust_assign(ls, nvars, nexps, &e); + if (nexps > nvars) + ls->fs->freereg -= nexps - nvars; /* remove extra values */ + } + else { + luaK_setoneret(ls->fs, &e); /* close last expression */ + luaK_storevar(ls->fs, &lh->v, &e); + return; /* avoid default */ + } + } + init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */ + luaK_storevar(ls->fs, &lh->v, &e); +} + + +static int cond (LexState *ls) { + /* cond -> exp */ + expdesc v; + expr(ls, &v); /* read condition */ + if (v.k == VNIL) v.k = VFALSE; /* `falses' are all equal here */ + luaK_goiftrue(ls->fs, &v); + return v.f; +} + + +static void gotostat (LexState *ls, int pc) { + int line = ls->linenumber; + TString *label; + int g; + if (testnext(ls, TK_GOTO)) + label = str_checkname(ls); + else { + luaX_next(ls); /* skip break */ + label = luaS_new(ls->L, "break"); + } + g = newlabelentry(ls, &ls->dyd->gt, label, line, pc); + findlabel(ls, g); /* close it if label already defined */ +} + + +/* check for repeated labels on the same block */ +static void checkrepeated (FuncState *fs, Labellist *ll, TString *label) { + int i; + for (i = fs->bl->firstlabel; i < ll->n; i++) { + if (luaS_eqstr(label, ll->arr[i].name)) { + const char *msg = luaO_pushfstring(fs->ls->L, + "label " LUA_QS " already defined on line %d", + getstr(label), ll->arr[i].line); + semerror(fs->ls, msg); + } + } +} + + +/* skip no-op statements */ +static void skipnoopstat (LexState *ls) { + while (ls->t.token == ';' || ls->t.token == TK_DBCOLON) + statement(ls); +} + + +static void labelstat (LexState *ls, TString *label, int line) { + /* label -> '::' NAME '::' */ + FuncState *fs = ls->fs; + Labellist *ll = &ls->dyd->label; + int l; /* index of new label being created */ + checkrepeated(fs, ll, label); /* check for repeated labels */ + checknext(ls, TK_DBCOLON); /* skip double colon */ + /* create new entry for this label */ + l = newlabelentry(ls, ll, label, line, fs->pc); + skipnoopstat(ls); /* skip other no-op statements */ + if (block_follow(ls, 0)) { /* label is last no-op statement in the block? */ + /* assume that locals are already out of scope */ + ll->arr[l].nactvar = fs->bl->nactvar; + } + findgotos(ls, &ll->arr[l]); +} + + +static void whilestat (LexState *ls, int line) { + /* whilestat -> WHILE cond DO block END */ + FuncState *fs = ls->fs; + int whileinit; + int condexit; + BlockCnt bl; + luaX_next(ls); /* skip WHILE */ + whileinit = luaK_getlabel(fs); + condexit = cond(ls); + enterblock(fs, &bl, 1); + checknext(ls, TK_DO); + block(ls); + luaK_jumpto(fs, whileinit); + check_match(ls, TK_END, TK_WHILE, line); + leaveblock(fs); + luaK_patchtohere(fs, condexit); /* false conditions finish the loop */ +} + + +static void repeatstat (LexState *ls, int line) { + /* repeatstat -> REPEAT block UNTIL cond */ + int condexit; + FuncState *fs = ls->fs; + int repeat_init = luaK_getlabel(fs); + BlockCnt bl1, bl2; + enterblock(fs, &bl1, 1); /* loop block */ + enterblock(fs, &bl2, 0); /* scope block */ + luaX_next(ls); /* skip REPEAT */ + statlist(ls); + check_match(ls, TK_UNTIL, TK_REPEAT, line); + condexit = cond(ls); /* read condition (inside scope block) */ + if (bl2.upval) /* upvalues? */ + luaK_patchclose(fs, condexit, bl2.nactvar); + leaveblock(fs); /* finish scope */ + luaK_patchlist(fs, condexit, repeat_init); /* close the loop */ + leaveblock(fs); /* finish loop */ +} + + +static int exp1 (LexState *ls) { + expdesc e; + int reg; + expr(ls, &e); + luaK_exp2nextreg(ls->fs, &e); + lua_assert(e.k == VNONRELOC); + reg = e.u.info; + return reg; +} + + +static void forbody (LexState *ls, int base, int line, int nvars, int isnum) { + /* forbody -> DO block */ + BlockCnt bl; + FuncState *fs = ls->fs; + int prep, endfor; + adjustlocalvars(ls, 3); /* control variables */ + checknext(ls, TK_DO); + prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs); + enterblock(fs, &bl, 0); /* scope for declared variables */ + adjustlocalvars(ls, nvars); + luaK_reserveregs(fs, nvars); + block(ls); + leaveblock(fs); /* end of scope for declared variables */ + luaK_patchtohere(fs, prep); + if (isnum) /* numeric for? */ + endfor = luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP); + else { /* generic for */ + luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars); + luaK_fixline(fs, line); + endfor = luaK_codeAsBx(fs, OP_TFORLOOP, base + 2, NO_JUMP); + } + luaK_patchlist(fs, endfor, prep + 1); + luaK_fixline(fs, line); +} + + +static void fornum (LexState *ls, TString *varname, int line) { + /* fornum -> NAME = exp1,exp1[,exp1] forbody */ + FuncState *fs = ls->fs; + int base = fs->freereg; + new_localvarliteral(ls, "(for index)"); + new_localvarliteral(ls, "(for limit)"); + new_localvarliteral(ls, "(for step)"); + new_localvar(ls, varname); + checknext(ls, '='); + exp1(ls); /* initial value */ + checknext(ls, ','); + exp1(ls); /* limit */ + if (testnext(ls, ',')) + exp1(ls); /* optional step */ + else { /* default step = 1 */ + luaK_codek(fs, fs->freereg, luaK_numberK(fs, 1)); + luaK_reserveregs(fs, 1); + } + forbody(ls, base, line, 1, 1); +} + + +static void forlist (LexState *ls, TString *indexname) { + /* forlist -> NAME {,NAME} IN explist forbody */ + FuncState *fs = ls->fs; + expdesc e; + int nvars = 4; /* gen, state, control, plus at least one declared var */ + int line; + int base = fs->freereg; + /* create control variables */ + new_localvarliteral(ls, "(for generator)"); + new_localvarliteral(ls, "(for state)"); + new_localvarliteral(ls, "(for control)"); + /* create declared variables */ + new_localvar(ls, indexname); + while (testnext(ls, ',')) { + new_localvar(ls, str_checkname(ls)); + nvars++; + } + checknext(ls, TK_IN); + line = ls->linenumber; + adjust_assign(ls, 3, explist(ls, &e), &e); + luaK_checkstack(fs, 3); /* extra space to call generator */ + forbody(ls, base, line, nvars - 3, 0); +} + + +static void forstat (LexState *ls, int line) { + /* forstat -> FOR (fornum | forlist) END */ + FuncState *fs = ls->fs; + TString *varname; + BlockCnt bl; + enterblock(fs, &bl, 1); /* scope for loop and control variables */ + luaX_next(ls); /* skip `for' */ + varname = str_checkname(ls); /* first variable name */ + switch (ls->t.token) { + case '=': fornum(ls, varname, line); break; + case ',': case TK_IN: forlist(ls, varname); break; + default: luaX_syntaxerror(ls, LUA_QL("=") " or " LUA_QL("in") " expected"); + } + check_match(ls, TK_END, TK_FOR, line); + leaveblock(fs); /* loop scope (`break' jumps to this point) */ +} + + +static void test_then_block (LexState *ls, int *escapelist) { + /* test_then_block -> [IF | ELSEIF] cond THEN block */ + BlockCnt bl; + FuncState *fs = ls->fs; + expdesc v; + int jf; /* instruction to skip 'then' code (if condition is false) */ + luaX_next(ls); /* skip IF or ELSEIF */ + expr(ls, &v); /* read condition */ + checknext(ls, TK_THEN); + if (ls->t.token == TK_GOTO || ls->t.token == TK_BREAK) { + luaK_goiffalse(ls->fs, &v); /* will jump to label if condition is true */ + enterblock(fs, &bl, 0); /* must enter block before 'goto' */ + gotostat(ls, v.t); /* handle goto/break */ + skipnoopstat(ls); /* skip other no-op statements */ + if (block_follow(ls, 0)) { /* 'goto' is the entire block? */ + leaveblock(fs); + return; /* and that is it */ + } + else /* must skip over 'then' part if condition is false */ + jf = luaK_jump(fs); + } + else { /* regular case (not goto/break) */ + luaK_goiftrue(ls->fs, &v); /* skip over block if condition is false */ + enterblock(fs, &bl, 0); + jf = v.f; + } + statlist(ls); /* `then' part */ + leaveblock(fs); + if (ls->t.token == TK_ELSE || + ls->t.token == TK_ELSEIF) /* followed by 'else'/'elseif'? */ + luaK_concat(fs, escapelist, luaK_jump(fs)); /* must jump over it */ + luaK_patchtohere(fs, jf); +} + + +static void ifstat (LexState *ls, int line) { + /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */ + FuncState *fs = ls->fs; + int escapelist = NO_JUMP; /* exit list for finished parts */ + test_then_block(ls, &escapelist); /* IF cond THEN block */ + while (ls->t.token == TK_ELSEIF) + test_then_block(ls, &escapelist); /* ELSEIF cond THEN block */ + if (testnext(ls, TK_ELSE)) + block(ls); /* `else' part */ + check_match(ls, TK_END, TK_IF, line); + luaK_patchtohere(fs, escapelist); /* patch escape list to 'if' end */ +} + + +static void localfunc (LexState *ls) { + expdesc b; + FuncState *fs = ls->fs; + new_localvar(ls, str_checkname(ls)); /* new local variable */ + adjustlocalvars(ls, 1); /* enter its scope */ + body(ls, &b, 0, ls->linenumber); /* function created in next register */ + /* debug information will only see the variable after this point! */ + getlocvar(fs, b.u.info)->startpc = fs->pc; +} + + +static void localstat (LexState *ls) { + /* stat -> LOCAL NAME {`,' NAME} [`=' explist] */ + int nvars = 0; + int nexps; + expdesc e; + do { + new_localvar(ls, str_checkname(ls)); + nvars++; + } while (testnext(ls, ',')); + if (testnext(ls, '=')) + nexps = explist(ls, &e); + else { + e.k = VVOID; + nexps = 0; + } + adjust_assign(ls, nvars, nexps, &e); + adjustlocalvars(ls, nvars); +} + + +static int funcname (LexState *ls, expdesc *v) { + /* funcname -> NAME {fieldsel} [`:' NAME] */ + int ismethod = 0; + singlevar(ls, v); + while (ls->t.token == '.') + fieldsel(ls, v); + if (ls->t.token == ':') { + ismethod = 1; + fieldsel(ls, v); + } + return ismethod; +} + + +static void funcstat (LexState *ls, int line) { + /* funcstat -> FUNCTION funcname body */ + int ismethod; + expdesc v, b; + luaX_next(ls); /* skip FUNCTION */ + ismethod = funcname(ls, &v); + body(ls, &b, ismethod, line); + luaK_storevar(ls->fs, &v, &b); + luaK_fixline(ls->fs, line); /* definition `happens' in the first line */ +} + + +static void exprstat (LexState *ls) { + /* stat -> func | assignment */ + FuncState *fs = ls->fs; + struct LHS_assign v; + suffixedexp(ls, &v.v); + if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */ + v.prev = NULL; + assignment(ls, &v, 1); + } + else { /* stat -> func */ + check_condition(ls, v.v.k == VCALL, "syntax error"); + SETARG_C(getcode(fs, &v.v), 1); /* call statement uses no results */ + } +} + + +static void retstat (LexState *ls) { + /* stat -> RETURN [explist] [';'] */ + FuncState *fs = ls->fs; + expdesc e; + int first, nret; /* registers with returned values */ + if (block_follow(ls, 1) || ls->t.token == ';') + first = nret = 0; /* return no values */ + else { + nret = explist(ls, &e); /* optional return values */ + if (hasmultret(e.k)) { + luaK_setmultret(fs, &e); + if (e.k == VCALL && nret == 1) { /* tail call? */ + SET_OPCODE(getcode(fs,&e), OP_TAILCALL); + lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar); + } + first = fs->nactvar; + nret = LUA_MULTRET; /* return all values */ + } + else { + if (nret == 1) /* only one single value? */ + first = luaK_exp2anyreg(fs, &e); + else { + luaK_exp2nextreg(fs, &e); /* values must go to the `stack' */ + first = fs->nactvar; /* return all `active' values */ + lua_assert(nret == fs->freereg - first); + } + } + } + luaK_ret(fs, first, nret); + testnext(ls, ';'); /* skip optional semicolon */ +} + + +static void statement (LexState *ls) { + int line = ls->linenumber; /* may be needed for error messages */ + enterlevel(ls); + switch (ls->t.token) { + case ';': { /* stat -> ';' (empty statement) */ + luaX_next(ls); /* skip ';' */ + break; + } + case TK_IF: { /* stat -> ifstat */ + ifstat(ls, line); + break; + } + case TK_WHILE: { /* stat -> whilestat */ + whilestat(ls, line); + break; + } + case TK_DO: { /* stat -> DO block END */ + luaX_next(ls); /* skip DO */ + block(ls); + check_match(ls, TK_END, TK_DO, line); + break; + } + case TK_FOR: { /* stat -> forstat */ + forstat(ls, line); + break; + } + case TK_REPEAT: { /* stat -> repeatstat */ + repeatstat(ls, line); + break; + } + case TK_FUNCTION: { /* stat -> funcstat */ + funcstat(ls, line); + break; + } + case TK_LOCAL: { /* stat -> localstat */ + luaX_next(ls); /* skip LOCAL */ + if (testnext(ls, TK_FUNCTION)) /* local function? */ + localfunc(ls); + else + localstat(ls); + break; + } + case TK_DBCOLON: { /* stat -> label */ + luaX_next(ls); /* skip double colon */ + labelstat(ls, str_checkname(ls), line); + break; + } + case TK_RETURN: { /* stat -> retstat */ + luaX_next(ls); /* skip RETURN */ + retstat(ls); + break; + } + case TK_BREAK: /* stat -> breakstat */ + case TK_GOTO: { /* stat -> 'goto' NAME */ + gotostat(ls, luaK_jump(ls->fs)); + break; + } + default: { /* stat -> func | assignment */ + exprstat(ls); + break; + } + } + lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg && + ls->fs->freereg >= ls->fs->nactvar); + ls->fs->freereg = ls->fs->nactvar; /* free registers */ + leavelevel(ls); +} + +/* }====================================================================== */ + + +/* +** compiles the main function, which is a regular vararg function with an +** upvalue named LUA_ENV +*/ +static void mainfunc (LexState *ls, FuncState *fs) { + BlockCnt bl; + expdesc v; + open_func(ls, fs, &bl); + fs->f->is_vararg = 1; /* main function is always vararg */ + init_exp(&v, VLOCAL, 0); /* create and... */ + newupvalue(fs, ls->envn, &v); /* ...set environment upvalue */ + luaX_next(ls); /* read first token */ + statlist(ls); /* parse main body */ + check(ls, TK_EOS); + close_func(ls); +} + + +Closure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, + Dyndata *dyd, const char *name, int firstchar) { + LexState lexstate; + FuncState funcstate; + Closure *cl = luaF_newLclosure(L, 1); /* create main closure */ + /* anchor closure (to avoid being collected) */ + setclLvalue(L, L->top, cl); + incr_top(L); + funcstate.f = cl->l.p = luaF_newproto(L); + funcstate.f->source = luaS_new(L, name); /* create and anchor TString */ + lexstate.buff = buff; + lexstate.dyd = dyd; + dyd->actvar.n = dyd->gt.n = dyd->label.n = 0; + luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar); + mainfunc(&lexstate, &funcstate); + lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs); + /* all scopes should be correctly finished */ + lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0); + return cl; /* it's on the stack too */ +} + diff --git a/extern/lua/src/lparser.h b/extern/lua/src/lparser.h new file mode 100644 index 0000000..0346e3c --- /dev/null +++ b/extern/lua/src/lparser.h @@ -0,0 +1,119 @@ +/* +** $Id: lparser.h,v 1.70.1.1 2013/04/12 18:48:47 roberto Exp $ +** Lua Parser +** See Copyright Notice in lua.h +*/ + +#ifndef lparser_h +#define lparser_h + +#include "llimits.h" +#include "lobject.h" +#include "lzio.h" + + +/* +** Expression descriptor +*/ + +typedef enum { + VVOID, /* no value */ + VNIL, + VTRUE, + VFALSE, + VK, /* info = index of constant in `k' */ + VKNUM, /* nval = numerical value */ + VNONRELOC, /* info = result register */ + VLOCAL, /* info = local register */ + VUPVAL, /* info = index of upvalue in 'upvalues' */ + VINDEXED, /* t = table register/upvalue; idx = index R/K */ + VJMP, /* info = instruction pc */ + VRELOCABLE, /* info = instruction pc */ + VCALL, /* info = instruction pc */ + VVARARG /* info = instruction pc */ +} expkind; + + +#define vkisvar(k) (VLOCAL <= (k) && (k) <= VINDEXED) +#define vkisinreg(k) ((k) == VNONRELOC || (k) == VLOCAL) + +typedef struct expdesc { + expkind k; + union { + struct { /* for indexed variables (VINDEXED) */ + short idx; /* index (R/K) */ + lu_byte t; /* table (register or upvalue) */ + lu_byte vt; /* whether 't' is register (VLOCAL) or upvalue (VUPVAL) */ + } ind; + int info; /* for generic use */ + lua_Number nval; /* for VKNUM */ + } u; + int t; /* patch list of `exit when true' */ + int f; /* patch list of `exit when false' */ +} expdesc; + + +/* description of active local variable */ +typedef struct Vardesc { + short idx; /* variable index in stack */ +} Vardesc; + + +/* description of pending goto statements and label statements */ +typedef struct Labeldesc { + TString *name; /* label identifier */ + int pc; /* position in code */ + int line; /* line where it appeared */ + lu_byte nactvar; /* local level where it appears in current block */ +} Labeldesc; + + +/* list of labels or gotos */ +typedef struct Labellist { + Labeldesc *arr; /* array */ + int n; /* number of entries in use */ + int size; /* array size */ +} Labellist; + + +/* dynamic structures used by the parser */ +typedef struct Dyndata { + struct { /* list of active local variables */ + Vardesc *arr; + int n; + int size; + } actvar; + Labellist gt; /* list of pending gotos */ + Labellist label; /* list of active labels */ +} Dyndata; + + +/* control of blocks */ +struct BlockCnt; /* defined in lparser.c */ + + +/* state needed to generate code for a given function */ +typedef struct FuncState { + Proto *f; /* current function header */ + Table *h; /* table to find (and reuse) elements in `k' */ + struct FuncState *prev; /* enclosing function */ + struct LexState *ls; /* lexical state */ + struct BlockCnt *bl; /* chain of current blocks */ + int pc; /* next position to code (equivalent to `ncode') */ + int lasttarget; /* 'label' of last 'jump label' */ + int jpc; /* list of pending jumps to `pc' */ + int nk; /* number of elements in `k' */ + int np; /* number of elements in `p' */ + int firstlocal; /* index of first local var (in Dyndata array) */ + short nlocvars; /* number of elements in 'f->locvars' */ + lu_byte nactvar; /* number of active local variables */ + lu_byte nups; /* number of upvalues */ + lu_byte freereg; /* first free register */ +} FuncState; + + +LUAI_FUNC Closure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, + Dyndata *dyd, const char *name, int firstchar); + + +#endif diff --git a/extern/lua/src/lparser.o b/extern/lua/src/lparser.o new file mode 100644 index 0000000000000000000000000000000000000000..67f2a70b36587375604b811f0e1ebb4cf8685801 GIT binary patch literal 26776 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%0DYPd4pEt_s@2f1R^Win>t;yN-IjsW|qyG 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 +#include + +#define lstate_c +#define LUA_CORE + +#include "lua.h" + +#include "lapi.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "llex.h" +#include "lmem.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" + + +#if !defined(LUAI_GCPAUSE) +#define LUAI_GCPAUSE 200 /* 200% */ +#endif + +#if !defined(LUAI_GCMAJOR) +#define LUAI_GCMAJOR 200 /* 200% */ +#endif + +#if !defined(LUAI_GCMUL) +#define LUAI_GCMUL 200 /* GC runs 'twice the speed' of memory allocation */ +#endif + + +#define MEMERRMSG "not enough memory" + + +/* +** a macro to help the creation of a unique random seed when a state is +** created; the seed is used to randomize hashes. +*/ +#if !defined(luai_makeseed) +#include +#define luai_makeseed() cast(unsigned int, time(NULL)) +#endif + + + +/* +** thread state + extra space +*/ +typedef struct LX { +#if defined(LUAI_EXTRASPACE) + char buff[LUAI_EXTRASPACE]; +#endif + lua_State l; +} LX; + + +/* +** Main thread combines a thread state and the global state +*/ +typedef struct LG { + LX l; + global_State g; +} LG; + + + +#define fromstate(L) (cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l))) + + +/* +** Compute an initial seed as random as possible. In ANSI, rely on +** Address Space Layout Randomization (if present) to increase +** randomness.. +*/ +#define addbuff(b,p,e) \ + { size_t t = cast(size_t, e); \ + memcpy(buff + p, &t, sizeof(t)); p += sizeof(t); } + +static unsigned int makeseed (lua_State *L) { + char buff[4 * sizeof(size_t)]; + unsigned int h = luai_makeseed(); + int p = 0; + addbuff(buff, p, L); /* heap variable */ + addbuff(buff, p, &h); /* local variable */ + addbuff(buff, p, luaO_nilobject); /* global variable */ + addbuff(buff, p, &lua_newstate); /* public function */ + lua_assert(p == sizeof(buff)); + return luaS_hash(buff, p, h); +} + + +/* +** set GCdebt to a new value keeping the value (totalbytes + GCdebt) +** invariant +*/ +void luaE_setdebt (global_State *g, l_mem debt) { + g->totalbytes -= (debt - g->GCdebt); + g->GCdebt = debt; +} + + +CallInfo *luaE_extendCI (lua_State *L) { + CallInfo *ci = luaM_new(L, CallInfo); + lua_assert(L->ci->next == NULL); + L->ci->next = ci; + ci->previous = L->ci; + ci->next = NULL; + return ci; +} + + +void luaE_freeCI (lua_State *L) { + CallInfo *ci = L->ci; + CallInfo *next = ci->next; + ci->next = NULL; + while ((ci = next) != NULL) { + next = ci->next; + luaM_free(L, ci); + } +} + + +static void stack_init (lua_State *L1, lua_State *L) { + int i; CallInfo *ci; + /* initialize stack array */ + L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, TValue); + L1->stacksize = BASIC_STACK_SIZE; + for (i = 0; i < BASIC_STACK_SIZE; i++) + setnilvalue(L1->stack + i); /* erase new stack */ + L1->top = L1->stack; + L1->stack_last = L1->stack + L1->stacksize - EXTRA_STACK; + /* initialize first ci */ + ci = &L1->base_ci; + ci->next = ci->previous = NULL; + ci->callstatus = 0; + ci->func = L1->top; + setnilvalue(L1->top++); /* 'function' entry for this 'ci' */ + ci->top = L1->top + LUA_MINSTACK; + L1->ci = ci; +} + + +static void freestack (lua_State *L) { + if (L->stack == NULL) + return; /* stack not completely built yet */ + L->ci = &L->base_ci; /* free the entire 'ci' list */ + luaE_freeCI(L); + luaM_freearray(L, L->stack, L->stacksize); /* free stack array */ +} + + +/* +** Create registry table and its predefined values +*/ +static void init_registry (lua_State *L, global_State *g) { + TValue mt; + /* create registry */ + Table *registry = luaH_new(L); + sethvalue(L, &g->l_registry, registry); + luaH_resize(L, registry, LUA_RIDX_LAST, 0); + /* registry[LUA_RIDX_MAINTHREAD] = L */ + setthvalue(L, &mt, L); + luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &mt); + /* registry[LUA_RIDX_GLOBALS] = table of globals */ + sethvalue(L, &mt, luaH_new(L)); + luaH_setint(L, registry, LUA_RIDX_GLOBALS, &mt); +} + + +/* +** open parts of the state that may cause memory-allocation errors +*/ +static void f_luaopen (lua_State *L, void *ud) { + global_State *g = G(L); + UNUSED(ud); + stack_init(L, L); /* init stack */ + init_registry(L, g); + luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */ + luaT_init(L); + luaX_init(L); + /* pre-create memory-error message */ + g->memerrmsg = luaS_newliteral(L, MEMERRMSG); + luaS_fix(g->memerrmsg); /* it should never be collected */ + g->gcrunning = 1; /* allow gc */ + g->version = lua_version(NULL); + luai_userstateopen(L); +} + + +/* +** preinitialize a state with consistent values without allocating +** any memory (to avoid errors) +*/ +static void preinit_state (lua_State *L, global_State *g) { + G(L) = g; + L->stack = NULL; + L->ci = NULL; + L->stacksize = 0; + L->errorJmp = NULL; + L->nCcalls = 0; + L->hook = NULL; + L->hookmask = 0; + L->basehookcount = 0; + L->allowhook = 1; + resethookcount(L); + L->openupval = NULL; + L->nny = 1; + L->status = LUA_OK; + L->errfunc = 0; +} + + +static void close_state (lua_State *L) { + global_State *g = G(L); + luaF_close(L, L->stack); /* close all upvalues for this thread */ + luaC_freeallobjects(L); /* collect all objects */ + if (g->version) /* closing a fully built state? */ + luai_userstateclose(L); + luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size); + luaZ_freebuffer(L, &g->buff); + freestack(L); + lua_assert(gettotalbytes(g) == sizeof(LG)); + (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); /* free main block */ +} + + +LUA_API lua_State *lua_newthread (lua_State *L) { + lua_State *L1; + lua_lock(L); + luaC_checkGC(L); + L1 = &luaC_newobj(L, LUA_TTHREAD, sizeof(LX), NULL, offsetof(LX, l))->th; + setthvalue(L, L->top, L1); + api_incr_top(L); + preinit_state(L1, G(L)); + L1->hookmask = L->hookmask; + L1->basehookcount = L->basehookcount; + L1->hook = L->hook; + resethookcount(L1); + luai_userstatethread(L, L1); + stack_init(L1, L); /* init stack */ + lua_unlock(L); + return L1; +} + + +void luaE_freethread (lua_State *L, lua_State *L1) { + LX *l = fromstate(L1); + luaF_close(L1, L1->stack); /* close all upvalues for this thread */ + lua_assert(L1->openupval == NULL); + luai_userstatefree(L, L1); + freestack(L1); + luaM_free(L, l); +} + + +LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) { + int i; + lua_State *L; + global_State *g; + LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG))); + if (l == NULL) return NULL; + L = &l->l.l; + g = &l->g; + L->next = NULL; + L->tt = LUA_TTHREAD; + g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT); + L->marked = luaC_white(g); + g->gckind = KGC_NORMAL; + preinit_state(L, g); + g->frealloc = f; + g->ud = ud; + g->mainthread = L; + g->seed = makeseed(L); + g->uvhead.u.l.prev = &g->uvhead; + g->uvhead.u.l.next = &g->uvhead; + g->gcrunning = 0; /* no GC while building state */ + g->GCestimate = 0; + g->strt.size = 0; + g->strt.nuse = 0; + g->strt.hash = NULL; + setnilvalue(&g->l_registry); + luaZ_initbuffer(L, &g->buff); + g->panic = NULL; + g->version = NULL; + g->gcstate = GCSpause; + g->allgc = NULL; + g->finobj = NULL; + g->tobefnz = NULL; + g->sweepgc = g->sweepfin = NULL; + g->gray = g->grayagain = NULL; + g->weak = g->ephemeron = g->allweak = NULL; + g->totalbytes = sizeof(LG); + g->GCdebt = 0; + g->gcpause = LUAI_GCPAUSE; + g->gcmajorinc = LUAI_GCMAJOR; + g->gcstepmul = LUAI_GCMUL; + for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL; + if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) { + /* memory allocation error: free partial state */ + close_state(L); + L = NULL; + } + return L; +} + + +LUA_API void lua_close (lua_State *L) { + L = G(L)->mainthread; /* only the main thread can be closed */ + lua_lock(L); + close_state(L); +} + + diff --git a/extern/lua/src/lstate.h b/extern/lua/src/lstate.h new file mode 100644 index 0000000..daffd9a --- /dev/null +++ b/extern/lua/src/lstate.h @@ -0,0 +1,228 @@ +/* +** $Id: lstate.h,v 2.82.1.1 2013/04/12 18:48:47 roberto Exp $ +** Global State +** See Copyright Notice in lua.h +*/ + +#ifndef lstate_h +#define lstate_h + +#include "lua.h" + +#include "lobject.h" +#include "ltm.h" +#include "lzio.h" + + +/* + +** Some notes about garbage-collected objects: All objects in Lua must +** be kept somehow accessible until being freed. +** +** Lua keeps most objects linked in list g->allgc. The link uses field +** 'next' of the CommonHeader. +** +** Strings are kept in several lists headed by the array g->strt.hash. +** +** Open upvalues are not subject to independent garbage collection. They +** are collected together with their respective threads. Lua keeps a +** double-linked list with all open upvalues (g->uvhead) so that it can +** mark objects referred by them. (They are always gray, so they must +** be remarked in the atomic step. Usually their contents would be marked +** when traversing the respective threads, but the thread may already be +** dead, while the upvalue is still accessible through closures.) +** +** Objects with finalizers are kept in the list g->finobj. +** +** The list g->tobefnz links all objects being finalized. + +*/ + + +struct lua_longjmp; /* defined in ldo.c */ + + + +/* extra stack space to handle TM calls and some other extras */ +#define EXTRA_STACK 5 + + +#define BASIC_STACK_SIZE (2*LUA_MINSTACK) + + +/* kinds of Garbage Collection */ +#define KGC_NORMAL 0 +#define KGC_EMERGENCY 1 /* gc was forced by an allocation failure */ +#define KGC_GEN 2 /* generational collection */ + + +typedef struct stringtable { + GCObject **hash; + lu_int32 nuse; /* number of elements */ + int size; +} stringtable; + + +/* +** information about a call +*/ +typedef struct CallInfo { + StkId func; /* function index in the stack */ + StkId top; /* top for this function */ + struct CallInfo *previous, *next; /* dynamic call link */ + short nresults; /* expected number of results from this function */ + lu_byte callstatus; + ptrdiff_t extra; + union { + struct { /* only for Lua functions */ + StkId base; /* base for this function */ + const Instruction *savedpc; + } l; + struct { /* only for C functions */ + int ctx; /* context info. in case of yields */ + lua_CFunction k; /* continuation in case of yields */ + ptrdiff_t old_errfunc; + lu_byte old_allowhook; + lu_byte status; + } c; + } u; +} CallInfo; + + +/* +** Bits in CallInfo status +*/ +#define CIST_LUA (1<<0) /* call is running a Lua function */ +#define CIST_HOOKED (1<<1) /* call is running a debug hook */ +#define CIST_REENTRY (1<<2) /* call is running on same invocation of + luaV_execute of previous call */ +#define CIST_YIELDED (1<<3) /* call reentered after suspension */ +#define CIST_YPCALL (1<<4) /* call is a yieldable protected call */ +#define CIST_STAT (1<<5) /* call has an error status (pcall) */ +#define CIST_TAIL (1<<6) /* call was tail called */ +#define CIST_HOOKYIELD (1<<7) /* last hook called yielded */ + + +#define isLua(ci) ((ci)->callstatus & CIST_LUA) + + +/* +** `global state', shared by all threads of this state +*/ +typedef struct global_State { + lua_Alloc frealloc; /* function to reallocate memory */ + void *ud; /* auxiliary data to `frealloc' */ + lu_mem totalbytes; /* number of bytes currently allocated - GCdebt */ + l_mem GCdebt; /* bytes allocated not yet compensated by the collector */ + lu_mem GCmemtrav; /* memory traversed by the GC */ + lu_mem GCestimate; /* an estimate of the non-garbage memory in use */ + stringtable strt; /* hash table for strings */ + TValue l_registry; + unsigned int seed; /* randomized seed for hashes */ + lu_byte currentwhite; + lu_byte gcstate; /* state of garbage collector */ + lu_byte gckind; /* kind of GC running */ + lu_byte gcrunning; /* true if GC is running */ + int sweepstrgc; /* position of sweep in `strt' */ + GCObject *allgc; /* list of all collectable objects */ + GCObject *finobj; /* list of collectable objects with finalizers */ + GCObject **sweepgc; /* current position of sweep in list 'allgc' */ + GCObject **sweepfin; /* current position of sweep in list 'finobj' */ + GCObject *gray; /* list of gray objects */ + GCObject *grayagain; /* list of objects to be traversed atomically */ + GCObject *weak; /* list of tables with weak values */ + GCObject *ephemeron; /* list of ephemeron tables (weak keys) */ + GCObject *allweak; /* list of all-weak tables */ + GCObject *tobefnz; /* list of userdata to be GC */ + UpVal uvhead; /* head of double-linked list of all open upvalues */ + Mbuffer buff; /* temporary buffer for string concatenation */ + int gcpause; /* size of pause between successive GCs */ + int gcmajorinc; /* pause between major collections (only in gen. mode) */ + int gcstepmul; /* GC `granularity' */ + lua_CFunction panic; /* to be called in unprotected errors */ + struct lua_State *mainthread; + const lua_Number *version; /* pointer to version number */ + TString *memerrmsg; /* memory-error message */ + TString *tmname[TM_N]; /* array with tag-method names */ + struct Table *mt[LUA_NUMTAGS]; /* metatables for basic types */ +} global_State; + + +/* +** `per thread' state +*/ +struct lua_State { + CommonHeader; + lu_byte status; + StkId top; /* first free slot in the stack */ + global_State *l_G; + CallInfo *ci; /* call info for current function */ + const Instruction *oldpc; /* last pc traced */ + StkId stack_last; /* last free slot in the stack */ + StkId stack; /* stack base */ + int stacksize; + unsigned short nny; /* number of non-yieldable calls in stack */ + unsigned short nCcalls; /* number of nested C calls */ + lu_byte hookmask; + lu_byte allowhook; + int basehookcount; + int hookcount; + lua_Hook hook; + GCObject *openupval; /* list of open upvalues in this stack */ + GCObject *gclist; + struct lua_longjmp *errorJmp; /* current error recover point */ + ptrdiff_t errfunc; /* current error handling function (stack index) */ + CallInfo base_ci; /* CallInfo for first level (C calling Lua) */ +}; + + +#define G(L) (L->l_G) + + +/* +** Union of all collectable objects +*/ +union GCObject { + GCheader gch; /* common header */ + union TString ts; + union Udata u; + union Closure cl; + struct Table h; + struct Proto p; + struct UpVal uv; + struct lua_State th; /* thread */ +}; + + +#define gch(o) (&(o)->gch) + +/* macros to convert a GCObject into a specific value */ +#define rawgco2ts(o) \ + check_exp(novariant((o)->gch.tt) == LUA_TSTRING, &((o)->ts)) +#define gco2ts(o) (&rawgco2ts(o)->tsv) +#define rawgco2u(o) check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u)) +#define gco2u(o) (&rawgco2u(o)->uv) +#define gco2lcl(o) check_exp((o)->gch.tt == LUA_TLCL, &((o)->cl.l)) +#define gco2ccl(o) check_exp((o)->gch.tt == LUA_TCCL, &((o)->cl.c)) +#define gco2cl(o) \ + check_exp(novariant((o)->gch.tt) == LUA_TFUNCTION, &((o)->cl)) +#define gco2t(o) check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h)) +#define gco2p(o) check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p)) +#define gco2uv(o) check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv)) +#define gco2th(o) check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th)) + +/* macro to convert any Lua object into a GCObject */ +#define obj2gco(v) (cast(GCObject *, (v))) + + +/* actual number of total bytes allocated */ +#define gettotalbytes(g) ((g)->totalbytes + (g)->GCdebt) + +LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt); +LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1); +LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L); +LUAI_FUNC void luaE_freeCI (lua_State *L); + + +#endif + diff --git a/extern/lua/src/lstate.o b/extern/lua/src/lstate.o new file mode 100644 index 0000000000000000000000000000000000000000..ce268f9b12e31d2045ffb14933a8ea246bfc9495 GIT binary patch literal 5504 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 literal 0 HcmV?d00001 diff --git a/extern/lua/src/lstring.c b/extern/lua/src/lstring.c new file mode 100644 index 0000000..af96c89 --- /dev/null +++ b/extern/lua/src/lstring.c @@ -0,0 +1,185 @@ +/* +** $Id: lstring.c,v 2.26.1.1 2013/04/12 18:48:47 roberto Exp $ +** String table (keeps all strings handled by Lua) +** See Copyright Notice in lua.h +*/ + + +#include + +#define lstring_c +#define LUA_CORE + +#include "lua.h" + +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" + + +/* +** Lua will use at most ~(2^LUAI_HASHLIMIT) bytes from a string to +** compute its hash +*/ +#if !defined(LUAI_HASHLIMIT) +#define LUAI_HASHLIMIT 5 +#endif + + +/* +** equality for long strings +*/ +int luaS_eqlngstr (TString *a, TString *b) { + size_t len = a->tsv.len; + lua_assert(a->tsv.tt == LUA_TLNGSTR && b->tsv.tt == LUA_TLNGSTR); + return (a == b) || /* same instance or... */ + ((len == b->tsv.len) && /* equal length and ... */ + (memcmp(getstr(a), getstr(b), len) == 0)); /* equal contents */ +} + + +/* +** equality for strings +*/ +int luaS_eqstr (TString *a, TString *b) { + return (a->tsv.tt == b->tsv.tt) && + (a->tsv.tt == LUA_TSHRSTR ? eqshrstr(a, b) : luaS_eqlngstr(a, b)); +} + + +unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) { + unsigned int h = seed ^ cast(unsigned int, l); + size_t l1; + size_t step = (l >> LUAI_HASHLIMIT) + 1; + for (l1 = l; l1 >= step; l1 -= step) + h = h ^ ((h<<5) + (h>>2) + cast_byte(str[l1 - 1])); + return h; +} + + +/* +** resizes the string table +*/ +void luaS_resize (lua_State *L, int newsize) { + int i; + stringtable *tb = &G(L)->strt; + /* cannot resize while GC is traversing strings */ + luaC_runtilstate(L, ~bitmask(GCSsweepstring)); + if (newsize > tb->size) { + luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *); + for (i = tb->size; i < newsize; i++) tb->hash[i] = NULL; + } + /* rehash */ + for (i=0; isize; i++) { + GCObject *p = tb->hash[i]; + tb->hash[i] = NULL; + while (p) { /* for each node in the list */ + GCObject *next = gch(p)->next; /* save next */ + unsigned int h = lmod(gco2ts(p)->hash, newsize); /* new position */ + gch(p)->next = tb->hash[h]; /* chain it */ + tb->hash[h] = p; + resetoldbit(p); /* see MOVE OLD rule */ + p = next; + } + } + if (newsize < tb->size) { + /* shrinking slice must be empty */ + lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL); + luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *); + } + tb->size = newsize; +} + + +/* +** creates a new string object +*/ +static TString *createstrobj (lua_State *L, const char *str, size_t l, + int tag, unsigned int h, GCObject **list) { + TString *ts; + size_t totalsize; /* total size of TString object */ + totalsize = sizeof(TString) + ((l + 1) * sizeof(char)); + ts = &luaC_newobj(L, tag, totalsize, list, 0)->ts; + ts->tsv.len = l; + ts->tsv.hash = h; + ts->tsv.extra = 0; + memcpy(ts+1, str, l*sizeof(char)); + ((char *)(ts+1))[l] = '\0'; /* ending 0 */ + return ts; +} + + +/* +** creates a new short string, inserting it into string table +*/ +static TString *newshrstr (lua_State *L, const char *str, size_t l, + unsigned int h) { + GCObject **list; /* (pointer to) list where it will be inserted */ + stringtable *tb = &G(L)->strt; + TString *s; + if (tb->nuse >= cast(lu_int32, tb->size) && tb->size <= MAX_INT/2) + luaS_resize(L, tb->size*2); /* too crowded */ + list = &tb->hash[lmod(h, tb->size)]; + s = createstrobj(L, str, l, LUA_TSHRSTR, h, list); + tb->nuse++; + return s; +} + + +/* +** checks whether short string exists and reuses it or creates a new one +*/ +static TString *internshrstr (lua_State *L, const char *str, size_t l) { + GCObject *o; + global_State *g = G(L); + unsigned int h = luaS_hash(str, l, g->seed); + for (o = g->strt.hash[lmod(h, g->strt.size)]; + o != NULL; + o = gch(o)->next) { + TString *ts = rawgco2ts(o); + if (h == ts->tsv.hash && + l == ts->tsv.len && + (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) { + if (isdead(G(L), o)) /* string is dead (but was not collected yet)? */ + changewhite(o); /* resurrect it */ + return ts; + } + } + return newshrstr(L, str, l, h); /* not found; create a new string */ +} + + +/* +** new string (with explicit length) +*/ +TString *luaS_newlstr (lua_State *L, const char *str, size_t l) { + if (l <= LUAI_MAXSHORTLEN) /* short string? */ + return internshrstr(L, str, l); + else { + if (l + 1 > (MAX_SIZET - sizeof(TString))/sizeof(char)) + luaM_toobig(L); + return createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed, NULL); + } +} + + +/* +** new zero-terminated string +*/ +TString *luaS_new (lua_State *L, const char *str) { + return luaS_newlstr(L, str, strlen(str)); +} + + +Udata *luaS_newudata (lua_State *L, size_t s, Table *e) { + Udata *u; + if (s > MAX_SIZET - sizeof(Udata)) + luaM_toobig(L); + u = &luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s, NULL, 0)->u; + u->uv.len = s; + u->uv.metatable = NULL; + u->uv.env = e; + return u; +} + diff --git a/extern/lua/src/lstring.h b/extern/lua/src/lstring.h new file mode 100644 index 0000000..260e7f1 --- /dev/null +++ b/extern/lua/src/lstring.h @@ -0,0 +1,46 @@ +/* +** $Id: lstring.h,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $ +** String table (keep all strings handled by Lua) +** See Copyright Notice in lua.h +*/ + +#ifndef lstring_h +#define lstring_h + +#include "lgc.h" +#include "lobject.h" +#include "lstate.h" + + +#define sizestring(s) (sizeof(union TString)+((s)->len+1)*sizeof(char)) + +#define sizeudata(u) (sizeof(union Udata)+(u)->len) + +#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ + (sizeof(s)/sizeof(char))-1)) + +#define luaS_fix(s) l_setbit((s)->tsv.marked, FIXEDBIT) + + +/* +** test whether a string is a reserved word +*/ +#define isreserved(s) ((s)->tsv.tt == LUA_TSHRSTR && (s)->tsv.extra > 0) + + +/* +** equality for short strings, which are always internalized +*/ +#define eqshrstr(a,b) check_exp((a)->tsv.tt == LUA_TSHRSTR, (a) == (b)) + + +LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed); +LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b); +LUAI_FUNC int luaS_eqstr (TString *a, TString *b); +LUAI_FUNC void luaS_resize (lua_State *L, int newsize); +LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e); +LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l); +LUAI_FUNC TString *luaS_new (lua_State *L, const char *str); + + +#endif diff --git a/extern/lua/src/lstring.o b/extern/lua/src/lstring.o new file mode 100644 index 0000000000000000000000000000000000000000..da54aa2753cd2eaf8775329aad7ce451ec8599ea GIT binary patch literal 3736 zcmbVOYfPI}7(Tt=3S(b8Zz;h@&Cqlz4NWkkbJ2dZz-dw@85d_JLaAjSrEG24#ps6V zn4WyA@?(qs@V7DkFeWC%Kh6RZbcwMh&XAaxI5mPZQZJKbUh4av@0{*iEs60Y{oZq) z^S;k}JLka3_Hc*UWFm5y$Rp&&N}`1LZ!ygI)K9jN8bW;=RC~;k-bJ;3hc`!k7t_{7 zdjp}FA8jncK6%TRY2n> z)7P!(dL)x1=Sn2@h9Dv6as!w_c^U~rtibZ2`PC|KA(Y9P!oH>CJ;=l6*~0wgs`)ju z=`;IW@2+Ba=aT87Hy`p9j(qd$;)sk#?d@Y%d#E<(JpV_rSPZd0x#OS~*rWPZpO0n! zD%#JigCnY?nnTe%jebJszqZi%%a$Ha?@-+pl7LrZt)k zD<-tLvIXm;1)Axy)q#67vtWY)PF?X9y}!55qFcr4C|?pblZ}DBxev`Jbxbc$ri!(e1rNeZM3dDa%7W*&6#n_F08SR~6~b z0yG+QmX2I**E;ruwEku_>o4B3N?)Vd+6AiB(U~vpGv^_|k=b@%M{ClpzHsgDV)4_dv@tzcgvJ3TYZ(U6^*>1c&Ym8S^thaZkQrtYWN zl#?5-QxixZ$f+h2d z<Ad&#Q1%yP8tWJOQ`~Ezl$#W^+U}@;dETE9T-^To=ImQu-oMh#)iit30I59=kYdq zTXyO*LhzX2Fg?4En2tG2^|f1Uvv8OYzl-k>(t+|x#nG?WINl;~AIc{b$6mnEcUa)N zgnSU>keIvh-Dy)CXUwYNJZ%Xmu8h^9m}(TKsyNydo4QrkofZ1aLjM(Wo8o-g(yq9& z);7g`rYfj3pT0#^S~FWZm2PuijnWE;s<_(}7ifY9AnV*}{&(=z;d;beaPh4&q=m0|ERWmwn4998@V45#~Rb>KBoGb{^EZ8}Vx zLf$8Ei&#r>xXiD_1)W^-z98rSwfBN;rTqV^f4{JA25B79{%#`(a~Z#sAp>SqedRyq z|CF%jf0GOZv%;QAM`BObU#dOADemE0I!)~G$){Ok4-g6ZFCzL70|vjMAvU-=zIHW&O*zZ(}Y z_*)M00r(+4iy#d7mOlh@#Pb{ld*MojwWC5q_icg?ZGy)ENB)A~#emyI{gKCR zz*jcGe>C7&U&-$kX9C5o27Ippzs-PuZ@}>>l00_NmvWv54Y-kK+<+VF@U8(j#+f(Z zcNqL`7gxC4Z<7Hx@_cLH!8cOI?}9lF@~ literal 0 HcmV?d00001 diff --git a/extern/lua/src/lstrlib.c b/extern/lua/src/lstrlib.c new file mode 100644 index 0000000..9261fd2 --- /dev/null +++ b/extern/lua/src/lstrlib.c @@ -0,0 +1,1019 @@ +/* +** $Id: lstrlib.c,v 1.178.1.1 2013/04/12 18:48:47 roberto Exp $ +** Standard library for string operations and pattern-matching +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include +#include +#include + +#define lstrlib_c +#define LUA_LIB + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +/* +** maximum number of captures that a pattern can do during +** pattern-matching. This limit is arbitrary. +*/ +#if !defined(LUA_MAXCAPTURES) +#define LUA_MAXCAPTURES 32 +#endif + + +/* macro to `unsign' a character */ +#define uchar(c) ((unsigned char)(c)) + + + +static int str_len (lua_State *L) { + size_t l; + luaL_checklstring(L, 1, &l); + lua_pushinteger(L, (lua_Integer)l); + return 1; +} + + +/* translate a relative string position: negative means back from end */ +static size_t posrelat (ptrdiff_t pos, size_t len) { + if (pos >= 0) return (size_t)pos; + else if (0u - (size_t)pos > len) return 0; + else return len - ((size_t)-pos) + 1; +} + + +static int str_sub (lua_State *L) { + size_t l; + const char *s = luaL_checklstring(L, 1, &l); + size_t start = posrelat(luaL_checkinteger(L, 2), l); + size_t end = posrelat(luaL_optinteger(L, 3, -1), l); + if (start < 1) start = 1; + if (end > l) end = l; + if (start <= end) + lua_pushlstring(L, s + start - 1, end - start + 1); + else lua_pushliteral(L, ""); + return 1; +} + + +static int str_reverse (lua_State *L) { + size_t l, i; + luaL_Buffer b; + const char *s = luaL_checklstring(L, 1, &l); + char *p = luaL_buffinitsize(L, &b, l); + for (i = 0; i < l; i++) + p[i] = s[l - i - 1]; + luaL_pushresultsize(&b, l); + return 1; +} + + +static int str_lower (lua_State *L) { + size_t l; + size_t i; + luaL_Buffer b; + const char *s = luaL_checklstring(L, 1, &l); + char *p = luaL_buffinitsize(L, &b, l); + for (i=0; i> 1) + +static int str_rep (lua_State *L) { + size_t l, lsep; + const char *s = luaL_checklstring(L, 1, &l); + int n = luaL_checkint(L, 2); + const char *sep = luaL_optlstring(L, 3, "", &lsep); + if (n <= 0) lua_pushliteral(L, ""); + else if (l + lsep < l || l + lsep >= MAXSIZE / n) /* may overflow? */ + return luaL_error(L, "resulting string too large"); + else { + size_t totallen = n * l + (n - 1) * lsep; + luaL_Buffer b; + char *p = luaL_buffinitsize(L, &b, totallen); + while (n-- > 1) { /* first n-1 copies (followed by separator) */ + memcpy(p, s, l * sizeof(char)); p += l; + if (lsep > 0) { /* avoid empty 'memcpy' (may be expensive) */ + memcpy(p, sep, lsep * sizeof(char)); p += lsep; + } + } + memcpy(p, s, l * sizeof(char)); /* last copy (not followed by separator) */ + luaL_pushresultsize(&b, totallen); + } + return 1; +} + + +static int str_byte (lua_State *L) { + size_t l; + const char *s = luaL_checklstring(L, 1, &l); + size_t posi = posrelat(luaL_optinteger(L, 2, 1), l); + size_t pose = posrelat(luaL_optinteger(L, 3, posi), l); + int n, i; + if (posi < 1) posi = 1; + if (pose > l) pose = l; + if (posi > pose) return 0; /* empty interval; return no values */ + n = (int)(pose - posi + 1); + if (posi + n <= pose) /* (size_t -> int) overflow? */ + return luaL_error(L, "string slice too long"); + luaL_checkstack(L, n, "string slice too long"); + for (i=0; i= ms->level || ms->capture[l].len == CAP_UNFINISHED) + return luaL_error(ms->L, "invalid capture index %%%d", l + 1); + return l; +} + + +static int capture_to_close (MatchState *ms) { + int level = ms->level; + for (level--; level>=0; level--) + if (ms->capture[level].len == CAP_UNFINISHED) return level; + return luaL_error(ms->L, "invalid pattern capture"); +} + + +static const char *classend (MatchState *ms, const char *p) { + switch (*p++) { + case L_ESC: { + if (p == ms->p_end) + luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")"); + return p+1; + } + case '[': { + if (*p == '^') p++; + do { /* look for a `]' */ + if (p == ms->p_end) + luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")"); + if (*(p++) == L_ESC && p < ms->p_end) + p++; /* skip escapes (e.g. `%]') */ + } while (*p != ']'); + return p+1; + } + default: { + return p; + } + } +} + + +static int match_class (int c, int cl) { + int res; + switch (tolower(cl)) { + case 'a' : res = isalpha(c); break; + case 'c' : res = iscntrl(c); break; + case 'd' : res = isdigit(c); break; + case 'g' : res = isgraph(c); break; + case 'l' : res = islower(c); break; + case 'p' : res = ispunct(c); break; + case 's' : res = isspace(c); break; + case 'u' : res = isupper(c); break; + case 'w' : res = isalnum(c); break; + case 'x' : res = isxdigit(c); break; + case 'z' : res = (c == 0); break; /* deprecated option */ + default: return (cl == c); + } + return (islower(cl) ? res : !res); +} + + +static int matchbracketclass (int c, const char *p, const char *ec) { + int sig = 1; + if (*(p+1) == '^') { + sig = 0; + p++; /* skip the `^' */ + } + while (++p < ec) { + if (*p == L_ESC) { + p++; + if (match_class(c, uchar(*p))) + return sig; + } + else if ((*(p+1) == '-') && (p+2 < ec)) { + p+=2; + if (uchar(*(p-2)) <= c && c <= uchar(*p)) + return sig; + } + else if (uchar(*p) == c) return sig; + } + return !sig; +} + + +static int singlematch (MatchState *ms, const char *s, const char *p, + const char *ep) { + if (s >= ms->src_end) + return 0; + else { + int c = uchar(*s); + switch (*p) { + case '.': return 1; /* matches any char */ + case L_ESC: return match_class(c, uchar(*(p+1))); + case '[': return matchbracketclass(c, p, ep-1); + default: return (uchar(*p) == c); + } + } +} + + +static const char *matchbalance (MatchState *ms, const char *s, + const char *p) { + if (p >= ms->p_end - 1) + luaL_error(ms->L, "malformed pattern " + "(missing arguments to " LUA_QL("%%b") ")"); + if (*s != *p) return NULL; + else { + int b = *p; + int e = *(p+1); + int cont = 1; + while (++s < ms->src_end) { + if (*s == e) { + if (--cont == 0) return s+1; + } + else if (*s == b) cont++; + } + } + return NULL; /* string ends out of balance */ +} + + +static const char *max_expand (MatchState *ms, const char *s, + const char *p, const char *ep) { + ptrdiff_t i = 0; /* counts maximum expand for item */ + while (singlematch(ms, s + i, p, ep)) + i++; + /* keeps trying to match with the maximum repetitions */ + while (i>=0) { + const char *res = match(ms, (s+i), ep+1); + if (res) return res; + i--; /* else didn't match; reduce 1 repetition to try again */ + } + return NULL; +} + + +static const char *min_expand (MatchState *ms, const char *s, + const char *p, const char *ep) { + for (;;) { + const char *res = match(ms, s, ep+1); + if (res != NULL) + return res; + else if (singlematch(ms, s, p, ep)) + s++; /* try with one more repetition */ + else return NULL; + } +} + + +static const char *start_capture (MatchState *ms, const char *s, + const char *p, int what) { + const char *res; + int level = ms->level; + if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures"); + ms->capture[level].init = s; + ms->capture[level].len = what; + ms->level = level+1; + if ((res=match(ms, s, p)) == NULL) /* match failed? */ + ms->level--; /* undo capture */ + return res; +} + + +static const char *end_capture (MatchState *ms, const char *s, + const char *p) { + int l = capture_to_close(ms); + const char *res; + ms->capture[l].len = s - ms->capture[l].init; /* close capture */ + if ((res = match(ms, s, p)) == NULL) /* match failed? */ + ms->capture[l].len = CAP_UNFINISHED; /* undo capture */ + return res; +} + + +static const char *match_capture (MatchState *ms, const char *s, int l) { + size_t len; + l = check_capture(ms, l); + len = ms->capture[l].len; + if ((size_t)(ms->src_end-s) >= len && + memcmp(ms->capture[l].init, s, len) == 0) + return s+len; + else return NULL; +} + + +static const char *match (MatchState *ms, const char *s, const char *p) { + if (ms->matchdepth-- == 0) + luaL_error(ms->L, "pattern too complex"); + init: /* using goto's to optimize tail recursion */ + if (p != ms->p_end) { /* end of pattern? */ + switch (*p) { + case '(': { /* start capture */ + if (*(p + 1) == ')') /* position capture? */ + s = start_capture(ms, s, p + 2, CAP_POSITION); + else + s = start_capture(ms, s, p + 1, CAP_UNFINISHED); + break; + } + case ')': { /* end capture */ + s = end_capture(ms, s, p + 1); + break; + } + case '$': { + if ((p + 1) != ms->p_end) /* is the `$' the last char in pattern? */ + goto dflt; /* no; go to default */ + s = (s == ms->src_end) ? s : NULL; /* check end of string */ + break; + } + case L_ESC: { /* escaped sequences not in the format class[*+?-]? */ + switch (*(p + 1)) { + case 'b': { /* balanced string? */ + s = matchbalance(ms, s, p + 2); + if (s != NULL) { + p += 4; goto init; /* return match(ms, s, p + 4); */ + } /* else fail (s == NULL) */ + break; + } + case 'f': { /* frontier? */ + const char *ep; char previous; + p += 2; + if (*p != '[') + luaL_error(ms->L, "missing " LUA_QL("[") " after " + LUA_QL("%%f") " in pattern"); + ep = classend(ms, p); /* points to what is next */ + previous = (s == ms->src_init) ? '\0' : *(s - 1); + if (!matchbracketclass(uchar(previous), p, ep - 1) && + matchbracketclass(uchar(*s), p, ep - 1)) { + p = ep; goto init; /* return match(ms, s, ep); */ + } + s = NULL; /* match failed */ + break; + } + case '0': case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + case '8': case '9': { /* capture results (%0-%9)? */ + s = match_capture(ms, s, uchar(*(p + 1))); + if (s != NULL) { + p += 2; goto init; /* return match(ms, s, p + 2) */ + } + break; + } + default: goto dflt; + } + break; + } + default: dflt: { /* pattern class plus optional suffix */ + const char *ep = classend(ms, p); /* points to optional suffix */ + /* does not match at least once? */ + if (!singlematch(ms, s, p, ep)) { + if (*ep == '*' || *ep == '?' || *ep == '-') { /* accept empty? */ + p = ep + 1; goto init; /* return match(ms, s, ep + 1); */ + } + else /* '+' or no suffix */ + s = NULL; /* fail */ + } + else { /* matched once */ + switch (*ep) { /* handle optional suffix */ + case '?': { /* optional */ + const char *res; + if ((res = match(ms, s + 1, ep + 1)) != NULL) + s = res; + else { + p = ep + 1; goto init; /* else return match(ms, s, ep + 1); */ + } + break; + } + case '+': /* 1 or more repetitions */ + s++; /* 1 match already done */ + /* go through */ + case '*': /* 0 or more repetitions */ + s = max_expand(ms, s, p, ep); + break; + case '-': /* 0 or more repetitions (minimum) */ + s = min_expand(ms, s, p, ep); + break; + default: /* no suffix */ + s++; p = ep; goto init; /* return match(ms, s + 1, ep); */ + } + } + break; + } + } + } + ms->matchdepth++; + return s; +} + + + +static const char *lmemfind (const char *s1, size_t l1, + const char *s2, size_t l2) { + if (l2 == 0) return s1; /* empty strings are everywhere */ + else if (l2 > l1) return NULL; /* avoids a negative `l1' */ + else { + const char *init; /* to search for a `*s2' inside `s1' */ + l2--; /* 1st char will be checked by `memchr' */ + l1 = l1-l2; /* `s2' cannot be found after that */ + while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) { + init++; /* 1st char is already checked */ + if (memcmp(init, s2+1, l2) == 0) + return init-1; + else { /* correct `l1' and `s1' to try again */ + l1 -= init-s1; + s1 = init; + } + } + return NULL; /* not found */ + } +} + + +static void push_onecapture (MatchState *ms, int i, const char *s, + const char *e) { + if (i >= ms->level) { + if (i == 0) /* ms->level == 0, too */ + lua_pushlstring(ms->L, s, e - s); /* add whole match */ + else + luaL_error(ms->L, "invalid capture index"); + } + else { + ptrdiff_t l = ms->capture[i].len; + if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture"); + if (l == CAP_POSITION) + lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1); + else + lua_pushlstring(ms->L, ms->capture[i].init, l); + } +} + + +static int push_captures (MatchState *ms, const char *s, const char *e) { + int i; + int nlevels = (ms->level == 0 && s) ? 1 : ms->level; + luaL_checkstack(ms->L, nlevels, "too many captures"); + for (i = 0; i < nlevels; i++) + push_onecapture(ms, i, s, e); + return nlevels; /* number of strings pushed */ +} + + +/* check whether pattern has no special characters */ +static int nospecials (const char *p, size_t l) { + size_t upto = 0; + do { + if (strpbrk(p + upto, SPECIALS)) + return 0; /* pattern has a special character */ + upto += strlen(p + upto) + 1; /* may have more after \0 */ + } while (upto <= l); + return 1; /* no special chars found */ +} + + +static int str_find_aux (lua_State *L, int find) { + size_t ls, lp; + const char *s = luaL_checklstring(L, 1, &ls); + const char *p = luaL_checklstring(L, 2, &lp); + size_t init = posrelat(luaL_optinteger(L, 3, 1), ls); + if (init < 1) init = 1; + else if (init > ls + 1) { /* start after string's end? */ + lua_pushnil(L); /* cannot find anything */ + return 1; + } + /* explicit request or no special characters? */ + if (find && (lua_toboolean(L, 4) || nospecials(p, lp))) { + /* do a plain search */ + const char *s2 = lmemfind(s + init - 1, ls - init + 1, p, lp); + if (s2) { + lua_pushinteger(L, s2 - s + 1); + lua_pushinteger(L, s2 - s + lp); + return 2; + } + } + else { + MatchState ms; + const char *s1 = s + init - 1; + int anchor = (*p == '^'); + if (anchor) { + p++; lp--; /* skip anchor character */ + } + ms.L = L; + ms.matchdepth = MAXCCALLS; + ms.src_init = s; + ms.src_end = s + ls; + ms.p_end = p + lp; + do { + const char *res; + ms.level = 0; + lua_assert(ms.matchdepth == MAXCCALLS); + if ((res=match(&ms, s1, p)) != NULL) { + if (find) { + lua_pushinteger(L, s1 - s + 1); /* start */ + lua_pushinteger(L, res - s); /* end */ + return push_captures(&ms, NULL, 0) + 2; + } + else + return push_captures(&ms, s1, res); + } + } while (s1++ < ms.src_end && !anchor); + } + lua_pushnil(L); /* not found */ + return 1; +} + + +static int str_find (lua_State *L) { + return str_find_aux(L, 1); +} + + +static int str_match (lua_State *L) { + return str_find_aux(L, 0); +} + + +static int gmatch_aux (lua_State *L) { + MatchState ms; + size_t ls, lp; + const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls); + const char *p = lua_tolstring(L, lua_upvalueindex(2), &lp); + const char *src; + ms.L = L; + ms.matchdepth = MAXCCALLS; + ms.src_init = s; + ms.src_end = s+ls; + ms.p_end = p + lp; + for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3)); + src <= ms.src_end; + src++) { + const char *e; + ms.level = 0; + lua_assert(ms.matchdepth == MAXCCALLS); + if ((e = match(&ms, src, p)) != NULL) { + lua_Integer newstart = e-s; + if (e == src) newstart++; /* empty match? go at least one position */ + lua_pushinteger(L, newstart); + lua_replace(L, lua_upvalueindex(3)); + return push_captures(&ms, src, e); + } + } + return 0; /* not found */ +} + + +static int gmatch (lua_State *L) { + luaL_checkstring(L, 1); + luaL_checkstring(L, 2); + lua_settop(L, 2); + lua_pushinteger(L, 0); + lua_pushcclosure(L, gmatch_aux, 3); + return 1; +} + + +static void add_s (MatchState *ms, luaL_Buffer *b, const char *s, + const char *e) { + size_t l, i; + const char *news = lua_tolstring(ms->L, 3, &l); + for (i = 0; i < l; i++) { + if (news[i] != L_ESC) + luaL_addchar(b, news[i]); + else { + i++; /* skip ESC */ + if (!isdigit(uchar(news[i]))) { + if (news[i] != L_ESC) + luaL_error(ms->L, "invalid use of " LUA_QL("%c") + " in replacement string", L_ESC); + luaL_addchar(b, news[i]); + } + else if (news[i] == '0') + luaL_addlstring(b, s, e - s); + else { + push_onecapture(ms, news[i] - '1', s, e); + luaL_addvalue(b); /* add capture to accumulated result */ + } + } + } +} + + +static void add_value (MatchState *ms, luaL_Buffer *b, const char *s, + const char *e, int tr) { + lua_State *L = ms->L; + switch (tr) { + case LUA_TFUNCTION: { + int n; + lua_pushvalue(L, 3); + n = push_captures(ms, s, e); + lua_call(L, n, 1); + break; + } + case LUA_TTABLE: { + push_onecapture(ms, 0, s, e); + lua_gettable(L, 3); + break; + } + default: { /* LUA_TNUMBER or LUA_TSTRING */ + add_s(ms, b, s, e); + return; + } + } + if (!lua_toboolean(L, -1)) { /* nil or false? */ + lua_pop(L, 1); + lua_pushlstring(L, s, e - s); /* keep original text */ + } + else if (!lua_isstring(L, -1)) + luaL_error(L, "invalid replacement value (a %s)", luaL_typename(L, -1)); + luaL_addvalue(b); /* add result to accumulator */ +} + + +static int str_gsub (lua_State *L) { + size_t srcl, lp; + const char *src = luaL_checklstring(L, 1, &srcl); + const char *p = luaL_checklstring(L, 2, &lp); + int tr = lua_type(L, 3); + size_t max_s = luaL_optinteger(L, 4, srcl+1); + int anchor = (*p == '^'); + size_t n = 0; + MatchState ms; + luaL_Buffer b; + luaL_argcheck(L, tr == LUA_TNUMBER || tr == LUA_TSTRING || + tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3, + "string/function/table expected"); + luaL_buffinit(L, &b); + if (anchor) { + p++; lp--; /* skip anchor character */ + } + ms.L = L; + ms.matchdepth = MAXCCALLS; + ms.src_init = src; + ms.src_end = src+srcl; + ms.p_end = p + lp; + while (n < max_s) { + const char *e; + ms.level = 0; + lua_assert(ms.matchdepth == MAXCCALLS); + e = match(&ms, src, p); + if (e) { + n++; + add_value(&ms, &b, src, e, tr); + } + if (e && e>src) /* non empty match? */ + src = e; /* skip it */ + else if (src < ms.src_end) + luaL_addchar(&b, *src++); + else break; + if (anchor) break; + } + luaL_addlstring(&b, src, ms.src_end-src); + luaL_pushresult(&b); + lua_pushinteger(L, n); /* number of substitutions */ + return 2; +} + +/* }====================================================== */ + + + +/* +** {====================================================== +** STRING FORMAT +** ======================================================= +*/ + +/* +** LUA_INTFRMLEN is the length modifier for integer conversions in +** 'string.format'; LUA_INTFRM_T is the integer type corresponding to +** the previous length +*/ +#if !defined(LUA_INTFRMLEN) /* { */ +#if defined(LUA_USE_LONGLONG) + +#define LUA_INTFRMLEN "ll" +#define LUA_INTFRM_T long long + +#else + +#define LUA_INTFRMLEN "l" +#define LUA_INTFRM_T long + +#endif +#endif /* } */ + + +/* +** LUA_FLTFRMLEN is the length modifier for float conversions in +** 'string.format'; LUA_FLTFRM_T is the float type corresponding to +** the previous length +*/ +#if !defined(LUA_FLTFRMLEN) + +#define LUA_FLTFRMLEN "" +#define LUA_FLTFRM_T double + +#endif + + +/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */ +#define MAX_ITEM 512 +/* valid flags in a format specification */ +#define FLAGS "-+ #0" +/* +** maximum size of each format specification (such as '%-099.99d') +** (+10 accounts for %99.99x plus margin of error) +*/ +#define MAX_FORMAT (sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10) + + +static void addquoted (lua_State *L, luaL_Buffer *b, int arg) { + size_t l; + const char *s = luaL_checklstring(L, arg, &l); + luaL_addchar(b, '"'); + while (l--) { + if (*s == '"' || *s == '\\' || *s == '\n') { + luaL_addchar(b, '\\'); + luaL_addchar(b, *s); + } + else if (*s == '\0' || iscntrl(uchar(*s))) { + char buff[10]; + if (!isdigit(uchar(*(s+1)))) + sprintf(buff, "\\%d", (int)uchar(*s)); + else + sprintf(buff, "\\%03d", (int)uchar(*s)); + luaL_addstring(b, buff); + } + else + luaL_addchar(b, *s); + s++; + } + luaL_addchar(b, '"'); +} + +static const char *scanformat (lua_State *L, const char *strfrmt, char *form) { + const char *p = strfrmt; + while (*p != '\0' && strchr(FLAGS, *p) != NULL) p++; /* skip flags */ + if ((size_t)(p - strfrmt) >= sizeof(FLAGS)/sizeof(char)) + luaL_error(L, "invalid format (repeated flags)"); + if (isdigit(uchar(*p))) p++; /* skip width */ + if (isdigit(uchar(*p))) p++; /* (2 digits at most) */ + if (*p == '.') { + p++; + if (isdigit(uchar(*p))) p++; /* skip precision */ + if (isdigit(uchar(*p))) p++; /* (2 digits at most) */ + } + if (isdigit(uchar(*p))) + luaL_error(L, "invalid format (width or precision too long)"); + *(form++) = '%'; + memcpy(form, strfrmt, (p - strfrmt + 1) * sizeof(char)); + form += p - strfrmt + 1; + *form = '\0'; + return p; +} + + +/* +** add length modifier into formats +*/ +static void addlenmod (char *form, const char *lenmod) { + size_t l = strlen(form); + size_t lm = strlen(lenmod); + char spec = form[l - 1]; + strcpy(form + l - 1, lenmod); + form[l + lm - 1] = spec; + form[l + lm] = '\0'; +} + + +static int str_format (lua_State *L) { + int top = lua_gettop(L); + int arg = 1; + size_t sfl; + const char *strfrmt = luaL_checklstring(L, arg, &sfl); + const char *strfrmt_end = strfrmt+sfl; + luaL_Buffer b; + luaL_buffinit(L, &b); + while (strfrmt < strfrmt_end) { + if (*strfrmt != L_ESC) + luaL_addchar(&b, *strfrmt++); + else if (*++strfrmt == L_ESC) + luaL_addchar(&b, *strfrmt++); /* %% */ + else { /* format item */ + char form[MAX_FORMAT]; /* to store the format (`%...') */ + char *buff = luaL_prepbuffsize(&b, MAX_ITEM); /* to put formatted item */ + int nb = 0; /* number of bytes in added item */ + if (++arg > top) + luaL_argerror(L, arg, "no value"); + strfrmt = scanformat(L, strfrmt, form); + switch (*strfrmt++) { + case 'c': { + nb = sprintf(buff, form, luaL_checkint(L, arg)); + break; + } + case 'd': case 'i': { + lua_Number n = luaL_checknumber(L, arg); + LUA_INTFRM_T ni = (LUA_INTFRM_T)n; + lua_Number diff = n - (lua_Number)ni; + luaL_argcheck(L, -1 < diff && diff < 1, arg, + "not a number in proper range"); + addlenmod(form, LUA_INTFRMLEN); + nb = sprintf(buff, form, ni); + break; + } + case 'o': case 'u': case 'x': case 'X': { + lua_Number n = luaL_checknumber(L, arg); + unsigned LUA_INTFRM_T ni = (unsigned LUA_INTFRM_T)n; + lua_Number diff = n - (lua_Number)ni; + luaL_argcheck(L, -1 < diff && diff < 1, arg, + "not a non-negative number in proper range"); + addlenmod(form, LUA_INTFRMLEN); + nb = sprintf(buff, form, ni); + break; + } + case 'e': case 'E': case 'f': +#if defined(LUA_USE_AFORMAT) + case 'a': case 'A': +#endif + case 'g': case 'G': { + addlenmod(form, LUA_FLTFRMLEN); + nb = sprintf(buff, form, (LUA_FLTFRM_T)luaL_checknumber(L, arg)); + break; + } + case 'q': { + addquoted(L, &b, arg); + break; + } + case 's': { + size_t l; + const char *s = luaL_tolstring(L, arg, &l); + if (!strchr(form, '.') && l >= 100) { + /* no precision and string is too long to be formatted; + keep original string */ + luaL_addvalue(&b); + break; + } + else { + nb = sprintf(buff, form, s); + lua_pop(L, 1); /* remove result from 'luaL_tolstring' */ + break; + } + } + default: { /* also treat cases `pnLlh' */ + return luaL_error(L, "invalid option " LUA_QL("%%%c") " to " + LUA_QL("format"), *(strfrmt - 1)); + } + } + luaL_addsize(&b, nb); + } + } + luaL_pushresult(&b); + return 1; +} + +/* }====================================================== */ + + +static const luaL_Reg strlib[] = { + {"byte", str_byte}, + {"char", str_char}, + {"dump", str_dump}, + {"find", str_find}, + {"format", str_format}, + {"gmatch", gmatch}, + {"gsub", str_gsub}, + {"len", str_len}, + {"lower", str_lower}, + {"match", str_match}, + {"rep", str_rep}, + {"reverse", str_reverse}, + {"sub", str_sub}, + {"upper", str_upper}, + {NULL, NULL} +}; + + +static void createmetatable (lua_State *L) { + lua_createtable(L, 0, 1); /* table to be metatable for strings */ + lua_pushliteral(L, ""); /* dummy string */ + lua_pushvalue(L, -2); /* copy table */ + lua_setmetatable(L, -2); /* set table as metatable for strings */ + lua_pop(L, 1); /* pop dummy string */ + lua_pushvalue(L, -2); /* get string library */ + lua_setfield(L, -2, "__index"); /* metatable.__index = string */ + lua_pop(L, 1); /* pop metatable */ +} + + +/* +** Open string library +*/ +LUAMOD_API int luaopen_string (lua_State *L) { + luaL_newlib(L, strlib); + createmetatable(L); + return 1; +} + diff --git a/extern/lua/src/lstrlib.o b/extern/lua/src/lstrlib.o new file mode 100644 index 0000000000000000000000000000000000000000..d6c40423d8a9c13421f67c0905ec0752467d2782 GIT binary patch literal 25192 zcmeHue{@vUz3-Vx&?t6Js;H>7j&^cM6k?)WO(g0JBydJ18VV>CB!tO?L_(4#Gk`71 z;ADW)Fp9V8<-Ypf!gb$!SFinH``T2k55rH<+TLiZvb4pBwq^`Mv=t~Sd7tn8G5O|@ z)75p~A8)O}t<1VWp=`Zj56O6jL@vH-w|UurUVcEz zwd_|d&q3?>t7h*xzRl+pj*)!GRdSPgSvU332;C97J#3GJ7KRoGLoA%H?O-1gD(~=u zDq@d>?LD#!nMj}@Z0~!HTJOk{m7=C5eaw8|eE?PuNUWae0n7dm%X7T*;_}zR_TF&x zi1o~fEbFb~pIVhKc3!@NxPW_kAGgoqyFyDscZHUQ>UUS$e+s3JctBDcJr*&4^s#0B z=!h7Ui04zw{!ljSnFLuoX&h2Rp#38R$8X|QR!=ol^1N!L`{KVNwd`FH`-r5lcUpN+ z7%eUEk*yQEWF3v1r3l5SWxs(QVBE@I)2a(XS$8AqnnWqp_SNq7nUy+R$bE|(#C}Ig zN$n|=F0p&-|8sw|qDSUu9!b(LM&Gdqp?1NBlk4HIYkX4Ko&qcSdQbjCslkTSiHpol zccN}2u$KlBc1gc&KCEX-q1pTPvFf`$Ui(0zfGYaT-aad}r$D&A^gqS3(ENG+olQkX zzWMV5L%#$cj;98^1pk!Am*b!>po;G~=z%8*Po0hvqinMn!qera21tB1OrxmB&mqrG z1jR1xA=g9o1upfe0a7=cJ>||Hb~upT4+1T}ysz^2FkE)8z=8%%)R6tf!uetQxBpv2 zE(}oeKF`v`d085?z18;7 z!9wuFe0Y%0{WGvyf0o&MdtRvW_4{5&7##XH8VA)THS7^{ z70skQt<*kGu{FKgfo!v356P0sj0Q2*U(zmY ze;Qh_5KGQ{(Fg)_t4n6xrKF9Osq;iU?;%80o4wZys(sa$8bP4g2j1V% z^Qyy}b%!b9_=R;L#jXxaQeE3^;-|2klB0N2rZM#HlO3A#-UL1=Ay(eL&^1?qQpAh_7!NR z+ImOZqK$6exkuQaR;*=0Nnu25!yf93?lKkx?N>xM>NY}Dwq8uUB-Df~syDEBg)mNn zVRdC=V3K9$2h1&RfFfk>SmOz2+C5?WNU-}@;@qLD5ii2cJv`1?E_Frw86X9RCW?)gJw5cE6KP@_J``!QNX{YIdj5 z{8;r&PeI&N>&Q{H1lHQet)6v($yjy5B}eyF2ZBZ6%pI}^Gxt?j%_PMysLkBx$;^DA z>UwjN7ZU-FszR{v)oS76Lh{=?Mv<^?L%&oy+j15BtXLV%J%-smjAyg= z^_X)9Cx6U&@B*km4k2{%{%>JxLx z&L*>T0vU6)?-R4|OLPZh|C&PQAWP#?{orGtjbKKeW>9Neb{A|qR^BMjoo0$UCp56q zADNrK1Y7(qs-&H&WILq4v3}*$v3Kb-Z(DY{aFw9&qo54q@17hP8LycL1k%g4Wk1Kr zQ{1C@n(hCb9+K2?$1KY3h8@H@MUE-rS64hY7TOV(Fju+%>(FRiudXD+Y5&78V!BwK zf?6{qQaMR{NLPw0D-S=?_uL)}M7 z!ed^g5&Y09-_1E@zHgPfVF zXl1~fK=}w_@B#G*znXDbyhsww^a@n!6UN-&V>a{{Lnsiiz2DFaOme4 zJ@@*d&E&;*$#%K?huA88L=Ag(YV&jH&tP`d8f>qij$lX`muM>Omp(=tx;H`##muBc z=u?cq=kt5oi>Xa~cKV~lOfkYDeH5Nr{&vp4Db4vfVt*L1KR}){_yydka%f$4u|25L zncdQkYEP8@X#K9CLoB~Bd(SX?Z>}nhUsts_egy{FSNWn${4q+1*R(EX|M^e3d26LU z^kk=entK+LeK*SwpF0C~)+r+PrhdO#azr0;TPWJ|soj))NElQ* zqHGfa3_XQ6>>+~1sOu(J!#7X(||CMT_*bYR^gcA%QbD|0^0>FYdxj z9}&A`(2XI&4s`9^wdwbTE)lbOK&&iQkqB1XJzgbgqyoQpu=-!BD*sAPbEginvK7!L4VTPLYNB0Hh zW|mAJsr8(y_54}+-?em_L%t0$1~x~D!_~CSrMa0qbr|(O5RdT>2i;bf%&PoNCt~!1 zJWsX;7LwzFo~WuXMKbX`97+sl&p>T?UrqV3?B{Yx!F(w1BMToh(-)A16V!gp{%AD6 z|1((|8!+L7J!c|yN%z?on%!q(sg7h;`XiZdQ|Os&Reor8=Ob@0duxoUBC|V;Au%6F zp|@4Ya^9wEiJ4B~+B2&-l3C?R4SMc5FS{J6Qqxx4r%sHR-3usjite{kJM*la@8)CC zm{>59c-M*!M(hE^2W#ga^2JffJC^77)>SoSmR(aZcq{Z5dELT%!${>J-j6XW;&fFY zah8>-!NJ(B_>EXmu*JdI&fx2RLBpQ8g*aFWSH5E2Ukja)ik?w*Gg7gtE6s;@6}+0r zubP&)Fq~=gWG6vRq%v9vUE2@d$QAUlbbIvs;6qX z*}V?@%m;l?GgH@}Jb9M6>1vRfJN9Qn{{aKW&zdo-*xa&|tl0Bye`a3)7%z(UW3s}q zhw>vm@$(SO=NDoQ!?n##*Mg0;En(^$I7a z9Cb|$`oM89ir6vjHM<{x2q>{GfTW~$Bw`;E%Pi@7)=|>cOkV`HLSv9s;hc^r1`i*R zm0l=;9A>lbFMKAw7NZj>dAFtBzK_v{B9|%_Li(e6}pw*cwv4!;P5)?mX6p4e7k=P{&y0@VM4ws*OL?qV~ zL2`UIkrUOFf0X?Nu3Db`Y4&cFhu6Y;hQ89YRoWANIQSYypUgiKT!nTN48$s4fHuO? z&*3IABU;$`63qMqJm5Uy#Tqedv;R#nMvNLemBOi0BWC(3@XV(02LU1*Cw8M|cMi+L z!mS*m@^LqxH5sA0tZZ9&)@sjN5>D|87)ax)z3UJcI7EV)sgC zH0hVj?&GN1fq+YF1v{GAATYc4(G0-52rLZXg=LU7ciptP6MRbstja+w(w!}Er;%{U z9%5M-Uu^EkqvH(9ujN6|HKYEWS&3uv1vnKKY;yw5?kxFi$q|I6_{BI;mqwG^Pl=c6?@Fo zVsJ(NEcRuV{T9LunlB>pgB>S?U&en){ZGGUcK--yZOJJyny^G*W`& z#(lE?v{@{F4d<74{u%2^pEo-K7lS_|kWe;4Y87W^Lb%KyB9xS6hjV_1tU;`Ew`3+= zE0z+=ev^4J#ie24$k@T4O319u#Ls~9eA@ML_PB@|v<{FSFf#fz*pD-Lwhs=8_g+Y5vY2N%{}59k`-X(ne97gDc+n&#%@bG1 zNrS;y7bsTtS%C8);*WFyo+3c~dI?#9W##4{^z0el8q z<^s$|m;%mFw;x(s_L9INlGSWs=6BFgEHl$TA^Ti{iIB4g^qdr?45Ozp&_O4M-E>}; zI&p@Xwn3+~Qm4lln>sA5IJh62{t1QCzVequ(6IMW!~}C=2RsB(O+L`5e?}liBnL_c zw9=QnB|DpWezc!futYj&5 zpdNLUglR}V(AXeDkPjR7kh44k0X$5M=I5u`!zWE4aKQqWP;*et8~FYQYP**mfaS!z zqJV9oLJSBp2GNxEFW4KD93Tg_Quf@kw+Mq^ z(XBP;oE)h}WCr+|sRu!NTV`riD0#0@l=vyt(4&wI@`Z3YoD$dJY&QKcNRuav;up~2 zaL02+cof~y`_|Lccu%OI59{Ta2o^WWjmO9muS*sUzi>JcB!tn(5}EOIeQ)lmxYiLv`hF!z__L3equCK_pdT z->ST29QogYl3TTaaq3TDoP^8yHIeo=5%gr7r9cw2Qu#=0vGoz_LiUtMExJifgWlKd zc=OrekIX~!F&(Qy)fL+=W(1{Gol|GKOpmkDBe`S*iu z1VKYA;AO~Ah;TBAt`IE4nXjB-%~%pBTYY}^UeHSaq^VU2uyYknRX>(i^akuK(sJ~}-}Q?>N6PoB3(1@M4Dl9P>U{iyfp^B{EdlK9sU(9t7C2crbJsb-qPM?D6P9% zTcSh*-P_w%7#$7qc&xKc0MYhU9jy?iRnT=xl^i}sHGfeNbYB{{@~WFlix(G7GwSQ5 z%FFMG$BbxmL#IL77|_4bXln0V)etvU;7_#KSkaYOZnVbQjMnxwu}(vRov{v>dUdR` zD`rrAq63B^kNkW2y9NGkf&c$3preh94gO*TfLKEufv%~wVMSL-F6!v|H7$+tW`BDp zVrVSd(uL5Li)JNc9TjTZ+orX}Ry4#B1l{7Uw568c-a%o~KLznDI)#Gh6e)3vGWn{8 zRsx`yj*G>yw#F|1nii;oR#Sv@17Ykmx>YS*U9@6MxeG*pr5=k(VpXgy-X+8r6)h*8 zxyFm9_#2uKtVvkY6f6u{5vibz?^o-1e|20e2C=mru_&x*%2z}&43 z(HMzU3!Cb%whJea3te%8zX$^}rVNWO8w_LkW(g0>GUm*hb%VdSI<~x}q0K+Nw6e5( zTKV)6c?Y6Ns=eo1UpG8!3q6;db7sL-Y+#Cke?`?%vSNgMg&Vyg-{e%@ZNC1Xx6wCw zwy!YcD?k;|T111ghWpg^+gG;n zjF7J)b>8q++0cyi z8lXy)zoif7kUl7n(N*-JTK3oPop-ixG7$7PJkf}txC41_(}xapsE%ohv#q%j*+>rC*dA_nGXu2E2y3bco zkN)Lt^mdFQqOBjhdMXL}Q$u!v^i19yvP*T&F6-s6=6rL`#6plSQEg{aTNLug4uy%$ zxERj`zNdrU;Mu}uYbM^VCKZjtV~Vzrd;qpkJ~lh&V{?3Baufr}`PiI^i=YfgYRC@D z@H?#dEm!=Mzo0M5UogpX^RCXjcidr`J8}NF_^gS-7wYmM2<1EUfy-a_g^@0h&k+5n z+)+D?&Z{}TfttK&UdTOtX3ZtJG(Q>@zb`AhtGOk7NW_X;e8~ykLl`zbxk3}?i0F}X zDiIH!R=j9yuHwNXA_$ju-LnddjZumfNM4)uU1zMdp)?*_8#hWD8{!Q{>GG~FLja|T zw$_%FvDSNx($03Oqt@l6<#?nv5*u4rk$a4G#qogc3awg3DOUVg>6}{^PV0&{L{};f zvF7@w&W2Sn()RzV_|cloM|m zXhioal;&9UeNEmz?dVuAMLdAzHUIhzUQP(jtoxMIcXnN z?Va{-R_*tzxS-o>z4h}$xEas>C+a0dhhj|jr!Nw9du^9519J?qXjmo^FXSoWY4nd% ze|mQ6PSkbNWt;6vAj!EBKd1b&fQ=`AxJtGkbW}R!ORCfV5?#LW@yO{lByW5!dE;tA z^km`FOP*e2SQV`eUdCVKr@+ovcoJ7CBA=GG;P0IMhH*LS1RtfU$f<#mTM)iX8C?yN zL2-m|oo8veGZbE^>?m?zU{vzNjFk8K?;P9^pQlxqpHvm!Q1~+Ck0PH1woKtkg^PR^ z*b0UF{kTC9Yb368*hKvM6}`xDfqh%y9m*6UUj;@b&mb=uThe$WK7EQ_5Dtwvv z{8r_gz_u&gPsg7qPsxk%G_FD)g^PR;80D#i*O`)Vw!9bz6uw>I6hElEiyzVZX`-Qs z+z!_)euS6N1V9lv8m^zw}l!~eFI)&?e zXR^YVDO}_{puZfr2d(>*{|pN*@=snaTVfz?^Ne%G0_rJGM3k{r#o#}hb&b}QDqPQh zT{B(b%4`}I*F1w})7WwY=*OdtxZq1&@J<(eqYJ*x1%JW?|6eXRovx3k|I04;TQ2w! z7yNS<{2Yw;cycdv!HZq+YhCb=3vRjKx4Ym?F8Ep(e7y@!pC^si-$z~We{;cmUGP0F z_-|eC_gwJ9F8Jpzcpl>Tc>Vga3qIKe54hk{UGRT&!DqSPwJ!LbF8B%;JmG@h?}9(% zg8x_G=TiKxtBeHpuQooRxl7Rh8h|h!EjZ3qk!ab zt05ZWWVN)VtFr+c!j42&bA5YTOuvN^&+4JepmWvMnBXlNTwB`F&>1hCE?9~;Poyus zNusNGDJ5St(IdT-%BeIK7Ubd$6$oJ-qck$B9J@~Zt)#!#Tw}B*8Y1=4=2&zknGlLd zWO<^AUe?9CTD}#-+puW-o{m_3yj>U;hKoun>V|x!DCkCcwY0@!D_}Q);81!D?^tJN zJKmJVRz*ARA&Pop!zjeF<}fN-4406tvE`$h&?t=RU*8pr$J;w{%%joP_Ab1L6u^pH zU8J7gd+`N zHH8X|jq)YysP*I#!00m>pW4<7R}eTI^eY>aA@OdK>f`Op+uK`X4Q;}@QZZr8ww6}% zg^uN&D-1k zx79O_(N20jl4}{E0i#3zF3}JVt5BJ%7PT$0)<)w(m8KwUi+v70s1k+F2dEH!6@D7O zi9i&>iALjh6Np0iH2gHK!)b4$`JZyZFQyKm(1p`aVK}$v423)UHH*<- z172Eg7sIb)c#`4QGMw@WDsk9gMnH@M*c;)4I!1%Jr}f7b=~sQo4B&-J<71rNF44KDZw7ra^RJ4x%m;DUcu1vPCS8Urd{Q#i?`m#&)6jST00n__$>f!>cFl?a#-DB}=2H0`%jiiTUH-)AxjwVh5exN~+pUq|LDXqGtY$d3 z&p$Cd#ONPqIG-=CFr1J3CK?bF(q|@qTJGZv{|AOY#qcQ%?^QTmsOx&&-O1>=-G1qy zUyL?X-edHDUltxzl9V|{Uv>tDn1sY z=W_30_$<(BJFjFo=fBaxf4SnHVf38;2Mp(Y^3~!>`d2f#7c-pGf2wdjj(T2y&gi*) z&Q#}-n*Ir;=XnYzxtu=D=*e!)ivAG?exJf0cj5E4gZ?2!?@{NSB)0}XZRZ&-crU|e zGy2^O=W*cI4CitF4TX~(NVYzIKFH|jF#aDhoUaS{g&;!Fe)X^N(GV~6aqqNeg`y|? zO8j(xYZ+e3@J@zX41e4q7geJCPe#x4%zhU<@@3i1sZSHbx!g@I_$vz6cG#)(d6Uue z@%@b9Jf8`ub89D`s}%0E=iO=%()4*ADfpWTchdhm!^0re_J7^M=S`*mTa3Pp(XTjP z5|CUX@hiD)3U|s~c)=(=&7+6pqtT#nCw;;}Kcwi_xzHcJaD4tJ6z=3dQN0Jy`VTAq z=PKMuKcC@Of>ztD*#*C!;oN^-W%w+sWl_yEIseEuH8`MA8q@Og~SL56cX4>J7gjQ%5qYdh2X94aRnJ&zj~eO1p$Z*c**Dm3qyyLdH@o0l9k^fd+2+7CpY0AjsOX=#l7?>V1iy;lzKwqAzAR(d+N!${0@cixhnY!v#J4K?yRP z=$9yZi{V7NRnhBpkI0B#e;2sOL9f5}TgGsrZ&v)987^2Wyo2FH->UGn3@7>|epHeS zC;GUe-^_5L_ZJd1`oVCbU#sZ1F3tH~x1AuKlXdf$RA~-`i2qa`ktumIK%R{ICPp z->>TVrTOUZSLypL&c9#f@!C%`z5aeR?x5H6bh`uB<2&rYb=+8xKUS{(es#M8*Wa%W kJ88j(vWCyP2BY$s8^nSn8 + +#define ltable_c +#define LUA_CORE + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "lvm.h" + + +/* +** max size of array part is 2^MAXBITS +*/ +#if LUAI_BITSINT >= 32 +#define MAXBITS 30 +#else +#define MAXBITS (LUAI_BITSINT-2) +#endif + +#define MAXASIZE (1 << MAXBITS) + + +#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) + +#define hashstr(t,str) hashpow2(t, (str)->tsv.hash) +#define hashboolean(t,p) hashpow2(t, p) + + +/* +** for some types, it is better to avoid modulus by power of 2, as +** they tend to have many 2 factors. +*/ +#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) + + +#define hashpointer(t,p) hashmod(t, IntPoint(p)) + + +#define dummynode (&dummynode_) + +#define isdummy(n) ((n) == dummynode) + +static const Node dummynode_ = { + {NILCONSTANT}, /* value */ + {{NILCONSTANT, NULL}} /* key */ +}; + + +/* +** hash for lua_Numbers +*/ +static Node *hashnum (const Table *t, lua_Number n) { + int i; + luai_hashnum(i, n); + if (i < 0) { + if (cast(unsigned int, i) == 0u - i) /* use unsigned to avoid overflows */ + i = 0; /* handle INT_MIN */ + i = -i; /* must be a positive value */ + } + return hashmod(t, i); +} + + + +/* +** returns the `main' position of an element in a table (that is, the index +** of its hash value) +*/ +static Node *mainposition (const Table *t, const TValue *key) { + switch (ttype(key)) { + case LUA_TNUMBER: + return hashnum(t, nvalue(key)); + case LUA_TLNGSTR: { + TString *s = rawtsvalue(key); + if (s->tsv.extra == 0) { /* no hash? */ + s->tsv.hash = luaS_hash(getstr(s), s->tsv.len, s->tsv.hash); + s->tsv.extra = 1; /* now it has its hash */ + } + return hashstr(t, rawtsvalue(key)); + } + case LUA_TSHRSTR: + return hashstr(t, rawtsvalue(key)); + case LUA_TBOOLEAN: + return hashboolean(t, bvalue(key)); + case LUA_TLIGHTUSERDATA: + return hashpointer(t, pvalue(key)); + case LUA_TLCF: + return hashpointer(t, fvalue(key)); + default: + return hashpointer(t, gcvalue(key)); + } +} + + +/* +** returns the index for `key' if `key' is an appropriate key to live in +** the array part of the table, -1 otherwise. +*/ +static int arrayindex (const TValue *key) { + if (ttisnumber(key)) { + lua_Number n = nvalue(key); + int k; + lua_number2int(k, n); + if (luai_numeq(cast_num(k), n)) + return k; + } + return -1; /* `key' did not match some condition */ +} + + +/* +** returns the index of a `key' for table traversals. First goes all +** elements in the array part, then elements in the hash part. The +** beginning of a traversal is signaled by -1. +*/ +static int findindex (lua_State *L, Table *t, StkId key) { + int i; + if (ttisnil(key)) return -1; /* first iteration */ + i = arrayindex(key); + if (0 < i && i <= t->sizearray) /* is `key' inside array part? */ + return i-1; /* yes; that's the index (corrected to C) */ + else { + Node *n = mainposition(t, key); + for (;;) { /* check whether `key' is somewhere in the chain */ + /* key may be dead already, but it is ok to use it in `next' */ + if (luaV_rawequalobj(gkey(n), key) || + (ttisdeadkey(gkey(n)) && iscollectable(key) && + deadvalue(gkey(n)) == gcvalue(key))) { + i = cast_int(n - gnode(t, 0)); /* key index in hash table */ + /* hash elements are numbered after array ones */ + return i + t->sizearray; + } + else n = gnext(n); + if (n == NULL) + luaG_runerror(L, "invalid key to " LUA_QL("next")); /* key not found */ + } + } +} + + +int luaH_next (lua_State *L, Table *t, StkId key) { + int i = findindex(L, t, key); /* find original element */ + for (i++; i < t->sizearray; i++) { /* try first array part */ + if (!ttisnil(&t->array[i])) { /* a non-nil value? */ + setnvalue(key, cast_num(i+1)); + setobj2s(L, key+1, &t->array[i]); + return 1; + } + } + for (i -= t->sizearray; i < sizenode(t); i++) { /* then hash part */ + if (!ttisnil(gval(gnode(t, i)))) { /* a non-nil value? */ + setobj2s(L, key, gkey(gnode(t, i))); + setobj2s(L, key+1, gval(gnode(t, i))); + return 1; + } + } + return 0; /* no more elements */ +} + + +/* +** {============================================================= +** Rehash +** ============================================================== +*/ + + +static int computesizes (int nums[], int *narray) { + int i; + int twotoi; /* 2^i */ + int a = 0; /* number of elements smaller than 2^i */ + int na = 0; /* number of elements to go to array part */ + int n = 0; /* optimal size for array part */ + for (i = 0, twotoi = 1; twotoi/2 < *narray; i++, twotoi *= 2) { + if (nums[i] > 0) { + a += nums[i]; + if (a > twotoi/2) { /* more than half elements present? */ + n = twotoi; /* optimal size (till now) */ + na = a; /* all elements smaller than n will go to array part */ + } + } + if (a == *narray) break; /* all elements already counted */ + } + *narray = n; + lua_assert(*narray/2 <= na && na <= *narray); + return na; +} + + +static int countint (const TValue *key, int *nums) { + int k = arrayindex(key); + if (0 < k && k <= MAXASIZE) { /* is `key' an appropriate array index? */ + nums[luaO_ceillog2(k)]++; /* count as such */ + return 1; + } + else + return 0; +} + + +static int numusearray (const Table *t, int *nums) { + int lg; + int ttlg; /* 2^lg */ + int ause = 0; /* summation of `nums' */ + int i = 1; /* count to traverse all array keys */ + for (lg=0, ttlg=1; lg<=MAXBITS; lg++, ttlg*=2) { /* for each slice */ + int lc = 0; /* counter */ + int lim = ttlg; + if (lim > t->sizearray) { + lim = t->sizearray; /* adjust upper limit */ + if (i > lim) + break; /* no more elements to count */ + } + /* count elements in range (2^(lg-1), 2^lg] */ + for (; i <= lim; i++) { + if (!ttisnil(&t->array[i-1])) + lc++; + } + nums[lg] += lc; + ause += lc; + } + return ause; +} + + +static int numusehash (const Table *t, int *nums, int *pnasize) { + int totaluse = 0; /* total number of elements */ + int ause = 0; /* summation of `nums' */ + int i = sizenode(t); + while (i--) { + Node *n = &t->node[i]; + if (!ttisnil(gval(n))) { + ause += countint(gkey(n), nums); + totaluse++; + } + } + *pnasize += ause; + return totaluse; +} + + +static void setarrayvector (lua_State *L, Table *t, int size) { + int i; + luaM_reallocvector(L, t->array, t->sizearray, size, TValue); + for (i=t->sizearray; iarray[i]); + t->sizearray = size; +} + + +static void setnodevector (lua_State *L, Table *t, int size) { + int lsize; + if (size == 0) { /* no elements to hash part? */ + t->node = cast(Node *, dummynode); /* use common `dummynode' */ + lsize = 0; + } + else { + int i; + lsize = luaO_ceillog2(size); + if (lsize > MAXBITS) + luaG_runerror(L, "table overflow"); + size = twoto(lsize); + t->node = luaM_newvector(L, size, Node); + for (i=0; ilsizenode = cast_byte(lsize); + t->lastfree = gnode(t, size); /* all positions are free */ +} + + +void luaH_resize (lua_State *L, Table *t, int nasize, int nhsize) { + int i; + int oldasize = t->sizearray; + int oldhsize = t->lsizenode; + Node *nold = t->node; /* save old hash ... */ + if (nasize > oldasize) /* array part must grow? */ + setarrayvector(L, t, nasize); + /* create new hash part with appropriate size */ + setnodevector(L, t, nhsize); + if (nasize < oldasize) { /* array part must shrink? */ + t->sizearray = nasize; + /* re-insert elements from vanishing slice */ + for (i=nasize; iarray[i])) + luaH_setint(L, t, i + 1, &t->array[i]); + } + /* shrink array */ + luaM_reallocvector(L, t->array, oldasize, nasize, TValue); + } + /* re-insert elements from hash part */ + for (i = twoto(oldhsize) - 1; i >= 0; i--) { + Node *old = nold+i; + if (!ttisnil(gval(old))) { + /* doesn't need barrier/invalidate cache, as entry was + already present in the table */ + setobjt2t(L, luaH_set(L, t, gkey(old)), gval(old)); + } + } + if (!isdummy(nold)) + luaM_freearray(L, nold, cast(size_t, twoto(oldhsize))); /* free old array */ +} + + +void luaH_resizearray (lua_State *L, Table *t, int nasize) { + int nsize = isdummy(t->node) ? 0 : sizenode(t); + luaH_resize(L, t, nasize, nsize); +} + + +static void rehash (lua_State *L, Table *t, const TValue *ek) { + int nasize, na; + int nums[MAXBITS+1]; /* nums[i] = number of keys with 2^(i-1) < k <= 2^i */ + int i; + int totaluse; + for (i=0; i<=MAXBITS; i++) nums[i] = 0; /* reset counts */ + nasize = numusearray(t, nums); /* count keys in array part */ + totaluse = nasize; /* all those keys are integer keys */ + totaluse += numusehash(t, nums, &nasize); /* count keys in hash part */ + /* count extra key */ + nasize += countint(ek, nums); + totaluse++; + /* compute new size for array part */ + na = computesizes(nums, &nasize); + /* resize the table to new computed sizes */ + luaH_resize(L, t, nasize, totaluse - na); +} + + + +/* +** }============================================================= +*/ + + +Table *luaH_new (lua_State *L) { + Table *t = &luaC_newobj(L, LUA_TTABLE, sizeof(Table), NULL, 0)->h; + t->metatable = NULL; + t->flags = cast_byte(~0); + t->array = NULL; + t->sizearray = 0; + setnodevector(L, t, 0); + return t; +} + + +void luaH_free (lua_State *L, Table *t) { + if (!isdummy(t->node)) + luaM_freearray(L, t->node, cast(size_t, sizenode(t))); + luaM_freearray(L, t->array, t->sizearray); + luaM_free(L, t); +} + + +static Node *getfreepos (Table *t) { + while (t->lastfree > t->node) { + t->lastfree--; + if (ttisnil(gkey(t->lastfree))) + return t->lastfree; + } + return NULL; /* could not find a free place */ +} + + + +/* +** inserts a new key into a hash table; first, check whether key's main +** position is free. If not, check whether colliding node is in its main +** position or not: if it is not, move colliding node to an empty place and +** put new key in its main position; otherwise (colliding node is in its main +** position), new key goes to an empty position. +*/ +TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) { + Node *mp; + if (ttisnil(key)) luaG_runerror(L, "table index is nil"); + else if (ttisnumber(key) && luai_numisnan(L, nvalue(key))) + luaG_runerror(L, "table index is NaN"); + mp = mainposition(t, key); + if (!ttisnil(gval(mp)) || isdummy(mp)) { /* main position is taken? */ + Node *othern; + Node *n = getfreepos(t); /* get a free place */ + if (n == NULL) { /* cannot find a free place? */ + rehash(L, t, key); /* grow table */ + /* whatever called 'newkey' take care of TM cache and GC barrier */ + return luaH_set(L, t, key); /* insert key into grown table */ + } + lua_assert(!isdummy(n)); + othern = mainposition(t, gkey(mp)); + if (othern != mp) { /* is colliding node out of its main position? */ + /* yes; move colliding node into free position */ + while (gnext(othern) != mp) othern = gnext(othern); /* find previous */ + gnext(othern) = n; /* redo the chain with `n' in place of `mp' */ + *n = *mp; /* copy colliding node into free pos. (mp->next also goes) */ + gnext(mp) = NULL; /* now `mp' is free */ + setnilvalue(gval(mp)); + } + else { /* colliding node is in its own main position */ + /* new node will go into free position */ + gnext(n) = gnext(mp); /* chain new position */ + gnext(mp) = n; + mp = n; + } + } + setobj2t(L, gkey(mp), key); + luaC_barrierback(L, obj2gco(t), key); + lua_assert(ttisnil(gval(mp))); + return gval(mp); +} + + +/* +** search function for integers +*/ +const TValue *luaH_getint (Table *t, int key) { + /* (1 <= key && key <= t->sizearray) */ + if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray)) + return &t->array[key-1]; + else { + lua_Number nk = cast_num(key); + Node *n = hashnum(t, nk); + do { /* check whether `key' is somewhere in the chain */ + if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk)) + return gval(n); /* that's it */ + else n = gnext(n); + } while (n); + return luaO_nilobject; + } +} + + +/* +** search function for short strings +*/ +const TValue *luaH_getstr (Table *t, TString *key) { + Node *n = hashstr(t, key); + lua_assert(key->tsv.tt == LUA_TSHRSTR); + do { /* check whether `key' is somewhere in the chain */ + if (ttisshrstring(gkey(n)) && eqshrstr(rawtsvalue(gkey(n)), key)) + return gval(n); /* that's it */ + else n = gnext(n); + } while (n); + return luaO_nilobject; +} + + +/* +** main search function +*/ +const TValue *luaH_get (Table *t, const TValue *key) { + switch (ttype(key)) { + case LUA_TSHRSTR: return luaH_getstr(t, rawtsvalue(key)); + case LUA_TNIL: return luaO_nilobject; + case LUA_TNUMBER: { + int k; + lua_Number n = nvalue(key); + lua_number2int(k, n); + if (luai_numeq(cast_num(k), n)) /* index is int? */ + return luaH_getint(t, k); /* use specialized version */ + /* else go through */ + } + default: { + Node *n = mainposition(t, key); + do { /* check whether `key' is somewhere in the chain */ + if (luaV_rawequalobj(gkey(n), key)) + return gval(n); /* that's it */ + else n = gnext(n); + } while (n); + return luaO_nilobject; + } + } +} + + +/* +** beware: when using this function you probably need to check a GC +** barrier and invalidate the TM cache. +*/ +TValue *luaH_set (lua_State *L, Table *t, const TValue *key) { + const TValue *p = luaH_get(t, key); + if (p != luaO_nilobject) + return cast(TValue *, p); + else return luaH_newkey(L, t, key); +} + + +void luaH_setint (lua_State *L, Table *t, int key, TValue *value) { + const TValue *p = luaH_getint(t, key); + TValue *cell; + if (p != luaO_nilobject) + cell = cast(TValue *, p); + else { + TValue k; + setnvalue(&k, cast_num(key)); + cell = luaH_newkey(L, t, &k); + } + setobj2t(L, cell, value); +} + + +static int unbound_search (Table *t, unsigned int j) { + unsigned int i = j; /* i is zero or a present index */ + j++; + /* find `i' and `j' such that i is present and j is not */ + while (!ttisnil(luaH_getint(t, j))) { + i = j; + j *= 2; + if (j > cast(unsigned int, MAX_INT)) { /* overflow? */ + /* table was built with bad purposes: resort to linear search */ + i = 1; + while (!ttisnil(luaH_getint(t, i))) i++; + return i - 1; + } + } + /* now do a binary search between them */ + while (j - i > 1) { + unsigned int m = (i+j)/2; + if (ttisnil(luaH_getint(t, m))) j = m; + else i = m; + } + return i; +} + + +/* +** Try to find a boundary in table `t'. A `boundary' is an integer index +** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil). +*/ +int luaH_getn (Table *t) { + unsigned int j = t->sizearray; + if (j > 0 && ttisnil(&t->array[j - 1])) { + /* there is a boundary in the array part: (binary) search for it */ + unsigned int i = 0; + while (j - i > 1) { + unsigned int m = (i+j)/2; + if (ttisnil(&t->array[m - 1])) j = m; + else i = m; + } + return i; + } + /* else must find a boundary in hash part */ + else if (isdummy(t->node)) /* hash part is empty? */ + return j; /* that is easy... */ + else return unbound_search(t, j); +} + + + +#if defined(LUA_DEBUG) + +Node *luaH_mainposition (const Table *t, const TValue *key) { + return mainposition(t, key); +} + +int luaH_isdummy (Node *n) { return isdummy(n); } + +#endif diff --git a/extern/lua/src/ltable.h b/extern/lua/src/ltable.h new file mode 100644 index 0000000..d69449b --- /dev/null +++ b/extern/lua/src/ltable.h @@ -0,0 +1,45 @@ +/* +** $Id: ltable.h,v 2.16.1.2 2013/08/30 15:49:41 roberto Exp $ +** Lua tables (hash) +** See Copyright Notice in lua.h +*/ + +#ifndef ltable_h +#define ltable_h + +#include "lobject.h" + + +#define gnode(t,i) (&(t)->node[i]) +#define gkey(n) (&(n)->i_key.tvk) +#define gval(n) (&(n)->i_val) +#define gnext(n) ((n)->i_key.nk.next) + +#define invalidateTMcache(t) ((t)->flags = 0) + +/* returns the key, given the value of a table entry */ +#define keyfromval(v) \ + (gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val)))) + + +LUAI_FUNC const TValue *luaH_getint (Table *t, int key); +LUAI_FUNC void luaH_setint (lua_State *L, Table *t, int key, TValue *value); +LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key); +LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key); +LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key); +LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key); +LUAI_FUNC Table *luaH_new (lua_State *L); +LUAI_FUNC void luaH_resize (lua_State *L, Table *t, int nasize, int nhsize); +LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize); +LUAI_FUNC void luaH_free (lua_State *L, Table *t); +LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key); +LUAI_FUNC int luaH_getn (Table *t); + + +#if defined(LUA_DEBUG) +LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key); +LUAI_FUNC int luaH_isdummy (Node *n); +#endif + + +#endif diff --git a/extern/lua/src/ltable.o b/extern/lua/src/ltable.o new file mode 100644 index 0000000000000000000000000000000000000000..d901e09880933556e13779b17a33f951bd6ccbf7 GIT binary patch literal 9744 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 X)s5>NxK*#d?!c|OwBW$4dh)*jZ%r;l literal 0 HcmV?d00001 diff --git a/extern/lua/src/ltablib.c b/extern/lua/src/ltablib.c new file mode 100644 index 0000000..6001224 --- /dev/null +++ b/extern/lua/src/ltablib.c @@ -0,0 +1,283 @@ +/* +** $Id: ltablib.c,v 1.65.1.1 2013/04/12 18:48:47 roberto Exp $ +** Library for Table Manipulation +** See Copyright Notice in lua.h +*/ + + +#include + +#define ltablib_c +#define LUA_LIB + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +#define aux_getn(L,n) (luaL_checktype(L, n, LUA_TTABLE), luaL_len(L, n)) + + + +#if defined(LUA_COMPAT_MAXN) +static int maxn (lua_State *L) { + lua_Number max = 0; + luaL_checktype(L, 1, LUA_TTABLE); + lua_pushnil(L); /* first key */ + while (lua_next(L, 1)) { + lua_pop(L, 1); /* remove value */ + if (lua_type(L, -1) == LUA_TNUMBER) { + lua_Number v = lua_tonumber(L, -1); + if (v > max) max = v; + } + } + lua_pushnumber(L, max); + return 1; +} +#endif + + +static int tinsert (lua_State *L) { + int e = aux_getn(L, 1) + 1; /* first empty element */ + int pos; /* where to insert new element */ + switch (lua_gettop(L)) { + case 2: { /* called with only 2 arguments */ + pos = e; /* insert new element at the end */ + break; + } + case 3: { + int i; + pos = luaL_checkint(L, 2); /* 2nd argument is the position */ + luaL_argcheck(L, 1 <= pos && pos <= e, 2, "position out of bounds"); + for (i = e; i > pos; i--) { /* move up elements */ + lua_rawgeti(L, 1, i-1); + lua_rawseti(L, 1, i); /* t[i] = t[i-1] */ + } + break; + } + default: { + return luaL_error(L, "wrong number of arguments to " LUA_QL("insert")); + } + } + lua_rawseti(L, 1, pos); /* t[pos] = v */ + return 0; +} + + +static int tremove (lua_State *L) { + int size = aux_getn(L, 1); + int pos = luaL_optint(L, 2, size); + if (pos != size) /* validate 'pos' if given */ + luaL_argcheck(L, 1 <= pos && pos <= size + 1, 1, "position out of bounds"); + lua_rawgeti(L, 1, pos); /* result = t[pos] */ + for ( ; pos < size; pos++) { + lua_rawgeti(L, 1, pos+1); + lua_rawseti(L, 1, pos); /* t[pos] = t[pos+1] */ + } + lua_pushnil(L); + lua_rawseti(L, 1, pos); /* t[pos] = nil */ + return 1; +} + + +static void addfield (lua_State *L, luaL_Buffer *b, int i) { + lua_rawgeti(L, 1, i); + if (!lua_isstring(L, -1)) + luaL_error(L, "invalid value (%s) at index %d in table for " + LUA_QL("concat"), luaL_typename(L, -1), i); + luaL_addvalue(b); +} + + +static int tconcat (lua_State *L) { + luaL_Buffer b; + size_t lsep; + int i, last; + const char *sep = luaL_optlstring(L, 2, "", &lsep); + luaL_checktype(L, 1, LUA_TTABLE); + i = luaL_optint(L, 3, 1); + last = luaL_opt(L, luaL_checkint, 4, luaL_len(L, 1)); + luaL_buffinit(L, &b); + for (; i < last; i++) { + addfield(L, &b, i); + luaL_addlstring(&b, sep, lsep); + } + if (i == last) /* add last value (if interval was not empty) */ + addfield(L, &b, i); + luaL_pushresult(&b); + return 1; +} + + +/* +** {====================================================== +** Pack/unpack +** ======================================================= +*/ + +static int pack (lua_State *L) { + int n = lua_gettop(L); /* number of elements to pack */ + lua_createtable(L, n, 1); /* create result table */ + lua_pushinteger(L, n); + lua_setfield(L, -2, "n"); /* t.n = number of elements */ + if (n > 0) { /* at least one element? */ + int i; + lua_pushvalue(L, 1); + lua_rawseti(L, -2, 1); /* insert first element */ + lua_replace(L, 1); /* move table into index 1 */ + for (i = n; i >= 2; i--) /* assign other elements */ + lua_rawseti(L, 1, i); + } + return 1; /* return table */ +} + + +static int unpack (lua_State *L) { + int i, e, n; + luaL_checktype(L, 1, LUA_TTABLE); + i = luaL_optint(L, 2, 1); + e = luaL_opt(L, luaL_checkint, 3, luaL_len(L, 1)); + if (i > e) return 0; /* empty range */ + n = e - i + 1; /* number of elements */ + if (n <= 0 || !lua_checkstack(L, n)) /* n <= 0 means arith. overflow */ + return luaL_error(L, "too many results to unpack"); + lua_rawgeti(L, 1, i); /* push arg[i] (avoiding overflow problems) */ + while (i++ < e) /* push arg[i + 1...e] */ + lua_rawgeti(L, 1, i); + return n; +} + +/* }====================================================== */ + + + +/* +** {====================================================== +** Quicksort +** (based on `Algorithms in MODULA-3', Robert Sedgewick; +** Addison-Wesley, 1993.) +** ======================================================= +*/ + + +static void set2 (lua_State *L, int i, int j) { + lua_rawseti(L, 1, i); + lua_rawseti(L, 1, j); +} + +static int sort_comp (lua_State *L, int a, int b) { + if (!lua_isnil(L, 2)) { /* function? */ + int res; + lua_pushvalue(L, 2); + lua_pushvalue(L, a-1); /* -1 to compensate function */ + lua_pushvalue(L, b-2); /* -2 to compensate function and `a' */ + lua_call(L, 2, 1); + res = lua_toboolean(L, -1); + lua_pop(L, 1); + return res; + } + else /* a < b? */ + return lua_compare(L, a, b, LUA_OPLT); +} + +static void auxsort (lua_State *L, int l, int u) { + while (l < u) { /* for tail recursion */ + int i, j; + /* sort elements a[l], a[(l+u)/2] and a[u] */ + lua_rawgeti(L, 1, l); + lua_rawgeti(L, 1, u); + if (sort_comp(L, -1, -2)) /* a[u] < a[l]? */ + set2(L, l, u); /* swap a[l] - a[u] */ + else + lua_pop(L, 2); + if (u-l == 1) break; /* only 2 elements */ + i = (l+u)/2; + lua_rawgeti(L, 1, i); + lua_rawgeti(L, 1, l); + if (sort_comp(L, -2, -1)) /* a[i]= P */ + while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) { + if (i>=u) luaL_error(L, "invalid order function for sorting"); + lua_pop(L, 1); /* remove a[i] */ + } + /* repeat --j until a[j] <= P */ + while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) { + if (j<=l) luaL_error(L, "invalid order function for sorting"); + lua_pop(L, 1); /* remove a[j] */ + } + if (jTd;pFDumf;1^Xl-t^E{Jhz5N|bEuL}*~ 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 Gz5Q?F{!o$t literal 0 HcmV?d00001 diff --git a/extern/lua/src/ltm.c b/extern/lua/src/ltm.c new file mode 100644 index 0000000..69b4ed7 --- /dev/null +++ b/extern/lua/src/ltm.c @@ -0,0 +1,77 @@ +/* +** $Id: ltm.c,v 2.14.1.1 2013/04/12 18:48:47 roberto Exp $ +** Tag methods +** See Copyright Notice in lua.h +*/ + + +#include + +#define ltm_c +#define LUA_CORE + +#include "lua.h" + +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" + + +static const char udatatypename[] = "userdata"; + +LUAI_DDEF const char *const luaT_typenames_[LUA_TOTALTAGS] = { + "no value", + "nil", "boolean", udatatypename, "number", + "string", "table", "function", udatatypename, "thread", + "proto", "upval" /* these last two cases are used for tests only */ +}; + + +void luaT_init (lua_State *L) { + static const char *const luaT_eventname[] = { /* ORDER TM */ + "__index", "__newindex", + "__gc", "__mode", "__len", "__eq", + "__add", "__sub", "__mul", "__div", "__mod", + "__pow", "__unm", "__lt", "__le", + "__concat", "__call" + }; + int i; + for (i=0; itmname[i] = luaS_new(L, luaT_eventname[i]); + luaS_fix(G(L)->tmname[i]); /* never collect these names */ + } +} + + +/* +** function to be used with macro "fasttm": optimized for absence of +** tag methods +*/ +const TValue *luaT_gettm (Table *events, TMS event, TString *ename) { + const TValue *tm = luaH_getstr(events, ename); + lua_assert(event <= TM_EQ); + if (ttisnil(tm)) { /* no tag method? */ + events->flags |= cast_byte(1u<metatable; + break; + case LUA_TUSERDATA: + mt = uvalue(o)->metatable; + break; + default: + mt = G(L)->mt[ttypenv(o)]; + } + return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject); +} + diff --git a/extern/lua/src/ltm.h b/extern/lua/src/ltm.h new file mode 100644 index 0000000..7f89c84 --- /dev/null +++ b/extern/lua/src/ltm.h @@ -0,0 +1,57 @@ +/* +** $Id: ltm.h,v 2.11.1.1 2013/04/12 18:48:47 roberto Exp $ +** Tag methods +** See Copyright Notice in lua.h +*/ + +#ifndef ltm_h +#define ltm_h + + +#include "lobject.h" + + +/* +* WARNING: if you change the order of this enumeration, +* grep "ORDER TM" +*/ +typedef enum { + TM_INDEX, + TM_NEWINDEX, + TM_GC, + TM_MODE, + TM_LEN, + TM_EQ, /* last tag method with `fast' access */ + TM_ADD, + TM_SUB, + TM_MUL, + TM_DIV, + TM_MOD, + TM_POW, + TM_UNM, + TM_LT, + TM_LE, + TM_CONCAT, + TM_CALL, + TM_N /* number of elements in the enum */ +} TMS; + + + +#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ + ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) + +#define fasttm(l,et,e) gfasttm(G(l), et, e) + +#define ttypename(x) luaT_typenames_[(x) + 1] +#define objtypename(x) ttypename(ttypenv(x)) + +LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS]; + + +LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename); +LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, + TMS event); +LUAI_FUNC void luaT_init (lua_State *L); + +#endif diff --git a/extern/lua/src/ltm.o b/extern/lua/src/ltm.o new file mode 100644 index 0000000000000000000000000000000000000000..4aa39ff17bf62d7ca369f7aac1da136a936fe1d7 GIT binary patch literal 3648 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£`(LEi+)SthT>jz(hGZZ(=O~3S)lYWpJ;iuAX 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

^%(Us;28GqCJgPg`r<%XhU6ta}ZNYqnK>vXEH! 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�vDf@8aGwSQ_GWt4*`;5?UgD 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 +#include +#include +#include + +#define lua_c + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +#if !defined(LUA_PROMPT) +#define LUA_PROMPT "> " +#define LUA_PROMPT2 ">> " +#endif + +#if !defined(LUA_PROGNAME) +#define LUA_PROGNAME "lua" +#endif + +#if !defined(LUA_MAXINPUT) +#define LUA_MAXINPUT 512 +#endif + +#if !defined(LUA_INIT) +#define LUA_INIT "LUA_INIT" +#endif + +#define LUA_INITVERSION \ + LUA_INIT "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR + + +/* +** lua_stdin_is_tty detects whether the standard input is a 'tty' (that +** is, whether we're running lua interactively). +*/ +#if defined(LUA_USE_ISATTY) +#include +#define lua_stdin_is_tty() isatty(0) +#elif defined(LUA_WIN) +#include +#include +#define lua_stdin_is_tty() _isatty(_fileno(stdin)) +#else +#define lua_stdin_is_tty() 1 /* assume stdin is a tty */ +#endif + + +/* +** lua_readline defines how to show a prompt and then read a line from +** the standard input. +** lua_saveline defines how to "save" a read line in a "history". +** lua_freeline defines how to free a line read by lua_readline. +*/ +#if defined(LUA_USE_READLINE) + +#include +#include +#include +#define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL) +#define lua_saveline(L,idx) \ + if (lua_rawlen(L,idx) > 0) /* non-empty line? */ \ + add_history(lua_tostring(L, idx)); /* add it to history */ +#define lua_freeline(L,b) ((void)L, free(b)) + +#elif !defined(lua_readline) + +#define lua_readline(L,b,p) \ + ((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \ + fgets(b, LUA_MAXINPUT, stdin) != NULL) /* get line */ +#define lua_saveline(L,idx) { (void)L; (void)idx; } +#define lua_freeline(L,b) { (void)L; (void)b; } + +#endif + + + + +static lua_State *globalL = NULL; + +static const char *progname = LUA_PROGNAME; + + + +static void lstop (lua_State *L, lua_Debug *ar) { + (void)ar; /* unused arg. */ + lua_sethook(L, NULL, 0, 0); + luaL_error(L, "interrupted!"); +} + + +static void laction (int i) { + signal(i, SIG_DFL); /* if another SIGINT happens before lstop, + terminate process (default action) */ + lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1); +} + + +static void print_usage (const char *badoption) { + luai_writestringerror("%s: ", progname); + if (badoption[1] == 'e' || badoption[1] == 'l') + luai_writestringerror("'%s' needs argument\n", badoption); + else + luai_writestringerror("unrecognized option '%s'\n", badoption); + luai_writestringerror( + "usage: %s [options] [script [args]]\n" + "Available options are:\n" + " -e stat execute string " LUA_QL("stat") "\n" + " -i enter interactive mode after executing " LUA_QL("script") "\n" + " -l name require library " LUA_QL("name") "\n" + " -v show version information\n" + " -E ignore environment variables\n" + " -- stop handling options\n" + " - stop handling options and execute stdin\n" + , + progname); +} + + +static void l_message (const char *pname, const char *msg) { + if (pname) luai_writestringerror("%s: ", pname); + luai_writestringerror("%s\n", msg); +} + + +static int report (lua_State *L, int status) { + if (status != LUA_OK && !lua_isnil(L, -1)) { + const char *msg = lua_tostring(L, -1); + if (msg == NULL) msg = "(error object is not a string)"; + l_message(progname, msg); + lua_pop(L, 1); + /* force a complete garbage collection in case of errors */ + lua_gc(L, LUA_GCCOLLECT, 0); + } + return status; +} + + +/* the next function is called unprotected, so it must avoid errors */ +static void finalreport (lua_State *L, int status) { + if (status != LUA_OK) { + const char *msg = (lua_type(L, -1) == LUA_TSTRING) ? lua_tostring(L, -1) + : NULL; + if (msg == NULL) msg = "(error object is not a string)"; + l_message(progname, msg); + lua_pop(L, 1); + } +} + + +static int traceback (lua_State *L) { + const char *msg = lua_tostring(L, 1); + if (msg) + luaL_traceback(L, L, msg, 1); + else if (!lua_isnoneornil(L, 1)) { /* is there an error object? */ + if (!luaL_callmeta(L, 1, "__tostring")) /* try its 'tostring' metamethod */ + lua_pushliteral(L, "(no error message)"); + } + return 1; +} + + +static int docall (lua_State *L, int narg, int nres) { + int status; + int base = lua_gettop(L) - narg; /* function index */ + lua_pushcfunction(L, traceback); /* push traceback function */ + lua_insert(L, base); /* put it under chunk and args */ + globalL = L; /* to be available to 'laction' */ + signal(SIGINT, laction); + status = lua_pcall(L, narg, nres, base); + signal(SIGINT, SIG_DFL); + lua_remove(L, base); /* remove traceback function */ + return status; +} + + +static void print_version (void) { + luai_writestring(LUA_COPYRIGHT, strlen(LUA_COPYRIGHT)); + luai_writeline(); +} + + +static int getargs (lua_State *L, char **argv, int n) { + int narg; + int i; + int argc = 0; + while (argv[argc]) argc++; /* count total number of arguments */ + narg = argc - (n + 1); /* number of arguments to the script */ + luaL_checkstack(L, narg + 3, "too many arguments to script"); + for (i=n+1; i < argc; i++) + lua_pushstring(L, argv[i]); + lua_createtable(L, narg, n + 1); + for (i=0; i < argc; i++) { + lua_pushstring(L, argv[i]); + lua_rawseti(L, -2, i - n); + } + return narg; +} + + +static int dofile (lua_State *L, const char *name) { + int status = luaL_loadfile(L, name); + if (status == LUA_OK) status = docall(L, 0, 0); + return report(L, status); +} + + +static int dostring (lua_State *L, const char *s, const char *name) { + int status = luaL_loadbuffer(L, s, strlen(s), name); + if (status == LUA_OK) status = docall(L, 0, 0); + return report(L, status); +} + + +static int dolibrary (lua_State *L, const char *name) { + int status; + lua_getglobal(L, "require"); + lua_pushstring(L, name); + status = docall(L, 1, 1); /* call 'require(name)' */ + if (status == LUA_OK) + lua_setglobal(L, name); /* global[name] = require return */ + return report(L, status); +} + + +static const char *get_prompt (lua_State *L, int firstline) { + const char *p; + lua_getglobal(L, firstline ? "_PROMPT" : "_PROMPT2"); + p = lua_tostring(L, -1); + if (p == NULL) p = (firstline ? LUA_PROMPT : LUA_PROMPT2); + return p; +} + +/* mark in error messages for incomplete statements */ +#define EOFMARK "" +#define marklen (sizeof(EOFMARK)/sizeof(char) - 1) + +static int incomplete (lua_State *L, int status) { + if (status == LUA_ERRSYNTAX) { + size_t lmsg; + const char *msg = lua_tolstring(L, -1, &lmsg); + if (lmsg >= marklen && strcmp(msg + lmsg - marklen, EOFMARK) == 0) { + lua_pop(L, 1); + return 1; + } + } + return 0; /* else... */ +} + + +static int pushline (lua_State *L, int firstline) { + char buffer[LUA_MAXINPUT]; + char *b = buffer; + size_t l; + const char *prmt = get_prompt(L, firstline); + int readstatus = lua_readline(L, b, prmt); + lua_pop(L, 1); /* remove result from 'get_prompt' */ + if (readstatus == 0) + return 0; /* no input */ + l = strlen(b); + if (l > 0 && b[l-1] == '\n') /* line ends with newline? */ + b[l-1] = '\0'; /* remove it */ + if (firstline && b[0] == '=') /* first line starts with `=' ? */ + lua_pushfstring(L, "return %s", b+1); /* change it to `return' */ + else + lua_pushstring(L, b); + lua_freeline(L, b); + return 1; +} + + +static int loadline (lua_State *L) { + int status; + lua_settop(L, 0); + if (!pushline(L, 1)) + return -1; /* no input */ + for (;;) { /* repeat until gets a complete line */ + size_t l; + const char *line = lua_tolstring(L, 1, &l); + status = luaL_loadbuffer(L, line, l, "=stdin"); + if (!incomplete(L, status)) break; /* cannot try to add lines? */ + if (!pushline(L, 0)) /* no more input? */ + return -1; + lua_pushliteral(L, "\n"); /* add a new line... */ + lua_insert(L, -2); /* ...between the two lines */ + lua_concat(L, 3); /* join them */ + } + lua_saveline(L, 1); + lua_remove(L, 1); /* remove line */ + return status; +} + + +static void dotty (lua_State *L) { + int status; + const char *oldprogname = progname; + progname = NULL; + while ((status = loadline(L)) != -1) { + if (status == LUA_OK) status = docall(L, 0, LUA_MULTRET); + report(L, status); + if (status == LUA_OK && lua_gettop(L) > 0) { /* any result to print? */ + luaL_checkstack(L, LUA_MINSTACK, "too many results to print"); + lua_getglobal(L, "print"); + lua_insert(L, 1); + if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != LUA_OK) + l_message(progname, lua_pushfstring(L, + "error calling " LUA_QL("print") " (%s)", + lua_tostring(L, -1))); + } + } + lua_settop(L, 0); /* clear stack */ + luai_writeline(); + progname = oldprogname; +} + + +static int handle_script (lua_State *L, char **argv, int n) { + int status; + const char *fname; + int narg = getargs(L, argv, n); /* collect arguments */ + lua_setglobal(L, "arg"); + fname = argv[n]; + if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0) + fname = NULL; /* stdin */ + status = luaL_loadfile(L, fname); + lua_insert(L, -(narg+1)); + if (status == LUA_OK) + status = docall(L, narg, LUA_MULTRET); + else + lua_pop(L, narg); + return report(L, status); +} + + +/* check that argument has no extra characters at the end */ +#define noextrachars(x) {if ((x)[2] != '\0') return -1;} + + +/* indices of various argument indicators in array args */ +#define has_i 0 /* -i */ +#define has_v 1 /* -v */ +#define has_e 2 /* -e */ +#define has_E 3 /* -E */ + +#define num_has 4 /* number of 'has_*' */ + + +static int collectargs (char **argv, int *args) { + int i; + for (i = 1; argv[i] != NULL; i++) { + if (argv[i][0] != '-') /* not an option? */ + return i; + switch (argv[i][1]) { /* option */ + case '-': + noextrachars(argv[i]); + return (argv[i+1] != NULL ? i+1 : 0); + case '\0': + return i; + case 'E': + args[has_E] = 1; + break; + case 'i': + noextrachars(argv[i]); + args[has_i] = 1; /* go through */ + case 'v': + noextrachars(argv[i]); + args[has_v] = 1; + break; + case 'e': + args[has_e] = 1; /* go through */ + case 'l': /* both options need an argument */ + if (argv[i][2] == '\0') { /* no concatenated argument? */ + i++; /* try next 'argv' */ + if (argv[i] == NULL || argv[i][0] == '-') + return -(i - 1); /* no next argument or it is another option */ + } + break; + default: /* invalid option; return its index... */ + return -i; /* ...as a negative value */ + } + } + return 0; +} + + +static int runargs (lua_State *L, char **argv, int n) { + int i; + for (i = 1; i < n; i++) { + lua_assert(argv[i][0] == '-'); + switch (argv[i][1]) { /* option */ + case 'e': { + const char *chunk = argv[i] + 2; + if (*chunk == '\0') chunk = argv[++i]; + lua_assert(chunk != NULL); + if (dostring(L, chunk, "=(command line)") != LUA_OK) + return 0; + break; + } + case 'l': { + const char *filename = argv[i] + 2; + if (*filename == '\0') filename = argv[++i]; + lua_assert(filename != NULL); + if (dolibrary(L, filename) != LUA_OK) + return 0; /* stop if file fails */ + break; + } + default: break; + } + } + return 1; +} + + +static int handle_luainit (lua_State *L) { + const char *name = "=" LUA_INITVERSION; + const char *init = getenv(name + 1); + if (init == NULL) { + name = "=" LUA_INIT; + init = getenv(name + 1); /* try alternative name */ + } + if (init == NULL) return LUA_OK; + else if (init[0] == '@') + return dofile(L, init+1); + else + return dostring(L, init, name); +} + + +static int pmain (lua_State *L) { + int argc = (int)lua_tointeger(L, 1); + char **argv = (char **)lua_touserdata(L, 2); + int script; + int args[num_has]; + args[has_i] = args[has_v] = args[has_e] = args[has_E] = 0; + if (argv[0] && argv[0][0]) progname = argv[0]; + script = collectargs(argv, args); + if (script < 0) { /* invalid arg? */ + print_usage(argv[-script]); + return 0; + } + if (args[has_v]) print_version(); + if (args[has_E]) { /* option '-E'? */ + lua_pushboolean(L, 1); /* signal for libraries to ignore env. vars. */ + lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV"); + } + /* open standard libraries */ + luaL_checkversion(L); + lua_gc(L, LUA_GCSTOP, 0); /* stop collector during initialization */ + luaL_openlibs(L); /* open libraries */ + lua_gc(L, LUA_GCRESTART, 0); + if (!args[has_E] && handle_luainit(L) != LUA_OK) + return 0; /* error running LUA_INIT */ + /* execute arguments -e and -l */ + if (!runargs(L, argv, (script > 0) ? script : argc)) return 0; + /* execute main script (if there is one) */ + if (script && handle_script(L, argv, script) != LUA_OK) return 0; + if (args[has_i]) /* -i option? */ + dotty(L); + else if (script == 0 && !args[has_e] && !args[has_v]) { /* no arguments? */ + if (lua_stdin_is_tty()) { + print_version(); + dotty(L); + } + else dofile(L, NULL); /* executes stdin as a file */ + } + lua_pushboolean(L, 1); /* signal no errors */ + return 1; +} + + +int main (int argc, char **argv) { + int status, result; + lua_State *L = luaL_newstate(); /* create state */ + if (L == NULL) { + l_message(argv[0], "cannot create state: not enough memory"); + return EXIT_FAILURE; + } + /* call 'pmain' in protected mode */ + lua_pushcfunction(L, &pmain); + lua_pushinteger(L, argc); /* 1st argument */ + lua_pushlightuserdata(L, argv); /* 2nd argument */ + status = lua_pcall(L, 2, 1, 0); + result = lua_toboolean(L, -1); /* get result */ + finalreport(L, status); + lua_close(L); + return (result && status == LUA_OK) ? EXIT_SUCCESS : EXIT_FAILURE; +} + diff --git a/extern/lua/src/lua.h b/extern/lua/src/lua.h new file mode 100644 index 0000000..149a2c3 --- /dev/null +++ b/extern/lua/src/lua.h @@ -0,0 +1,444 @@ +/* +** $Id: lua.h,v 1.285.1.2 2013/11/11 12:09:16 roberto Exp $ +** Lua - A Scripting Language +** Lua.org, PUC-Rio, Brazil (http://www.lua.org) +** See Copyright Notice at the end of this file +*/ + + +#ifndef lua_h +#define lua_h + +#include +#include + + +#include "luaconf.h" + + +#define LUA_VERSION_MAJOR "5" +#define LUA_VERSION_MINOR "2" +#define LUA_VERSION_NUM 502 +#define LUA_VERSION_RELEASE "3" + +#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR +#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE +#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2013 Lua.org, PUC-Rio" +#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" + + +/* mark for precompiled code ('Lua') */ +#define LUA_SIGNATURE "\033Lua" + +/* option for multiple returns in 'lua_pcall' and 'lua_call' */ +#define LUA_MULTRET (-1) + + +/* +** pseudo-indices +*/ +#define LUA_REGISTRYINDEX LUAI_FIRSTPSEUDOIDX +#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) + + +/* thread status */ +#define LUA_OK 0 +#define LUA_YIELD 1 +#define LUA_ERRRUN 2 +#define LUA_ERRSYNTAX 3 +#define LUA_ERRMEM 4 +#define LUA_ERRGCMM 5 +#define LUA_ERRERR 6 + + +typedef struct lua_State lua_State; + +typedef int (*lua_CFunction) (lua_State *L); + + +/* +** functions that read/write blocks when loading/dumping Lua chunks +*/ +typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz); + +typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud); + + +/* +** prototype for memory-allocation functions +*/ +typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); + + +/* +** basic types +*/ +#define LUA_TNONE (-1) + +#define LUA_TNIL 0 +#define LUA_TBOOLEAN 1 +#define LUA_TLIGHTUSERDATA 2 +#define LUA_TNUMBER 3 +#define LUA_TSTRING 4 +#define LUA_TTABLE 5 +#define LUA_TFUNCTION 6 +#define LUA_TUSERDATA 7 +#define LUA_TTHREAD 8 + +#define LUA_NUMTAGS 9 + + + +/* minimum Lua stack available to a C function */ +#define LUA_MINSTACK 20 + + +/* predefined values in the registry */ +#define LUA_RIDX_MAINTHREAD 1 +#define LUA_RIDX_GLOBALS 2 +#define LUA_RIDX_LAST LUA_RIDX_GLOBALS + + +/* type of numbers in Lua */ +typedef LUA_NUMBER lua_Number; + + +/* type for integer functions */ +typedef LUA_INTEGER lua_Integer; + +/* unsigned integer type */ +typedef LUA_UNSIGNED lua_Unsigned; + + + +/* +** generic extra include file +*/ +#if defined(LUA_USER_H) +#include LUA_USER_H +#endif + + +/* +** RCS ident string +*/ +extern const char lua_ident[]; + + +/* +** state manipulation +*/ +LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud); +LUA_API void (lua_close) (lua_State *L); +LUA_API lua_State *(lua_newthread) (lua_State *L); + +LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf); + + +LUA_API const lua_Number *(lua_version) (lua_State *L); + + +/* +** basic stack manipulation +*/ +LUA_API int (lua_absindex) (lua_State *L, int idx); +LUA_API int (lua_gettop) (lua_State *L); +LUA_API void (lua_settop) (lua_State *L, int idx); +LUA_API void (lua_pushvalue) (lua_State *L, int idx); +LUA_API void (lua_remove) (lua_State *L, int idx); +LUA_API void (lua_insert) (lua_State *L, int idx); +LUA_API void (lua_replace) (lua_State *L, int idx); +LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx); +LUA_API int (lua_checkstack) (lua_State *L, int sz); + +LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n); + + +/* +** access functions (stack -> C) +*/ + +LUA_API int (lua_isnumber) (lua_State *L, int idx); +LUA_API int (lua_isstring) (lua_State *L, int idx); +LUA_API int (lua_iscfunction) (lua_State *L, int idx); +LUA_API int (lua_isuserdata) (lua_State *L, int idx); +LUA_API int (lua_type) (lua_State *L, int idx); +LUA_API const char *(lua_typename) (lua_State *L, int tp); + +LUA_API lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum); +LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum); +LUA_API lua_Unsigned (lua_tounsignedx) (lua_State *L, int idx, int *isnum); +LUA_API int (lua_toboolean) (lua_State *L, int idx); +LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len); +LUA_API size_t (lua_rawlen) (lua_State *L, int idx); +LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx); +LUA_API void *(lua_touserdata) (lua_State *L, int idx); +LUA_API lua_State *(lua_tothread) (lua_State *L, int idx); +LUA_API const void *(lua_topointer) (lua_State *L, int idx); + + +/* +** Comparison and arithmetic functions +*/ + +#define LUA_OPADD 0 /* ORDER TM */ +#define LUA_OPSUB 1 +#define LUA_OPMUL 2 +#define LUA_OPDIV 3 +#define LUA_OPMOD 4 +#define LUA_OPPOW 5 +#define LUA_OPUNM 6 + +LUA_API void (lua_arith) (lua_State *L, int op); + +#define LUA_OPEQ 0 +#define LUA_OPLT 1 +#define LUA_OPLE 2 + +LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2); +LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op); + + +/* +** push functions (C -> stack) +*/ +LUA_API void (lua_pushnil) (lua_State *L); +LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n); +LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n); +LUA_API void (lua_pushunsigned) (lua_State *L, lua_Unsigned n); +LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t l); +LUA_API const char *(lua_pushstring) (lua_State *L, const char *s); +LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt, + va_list argp); +LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...); +LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n); +LUA_API void (lua_pushboolean) (lua_State *L, int b); +LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p); +LUA_API int (lua_pushthread) (lua_State *L); + + +/* +** get functions (Lua -> stack) +*/ +LUA_API void (lua_getglobal) (lua_State *L, const char *var); +LUA_API void (lua_gettable) (lua_State *L, int idx); +LUA_API void (lua_getfield) (lua_State *L, int idx, const char *k); +LUA_API void (lua_rawget) (lua_State *L, int idx); +LUA_API void (lua_rawgeti) (lua_State *L, int idx, int n); +LUA_API void (lua_rawgetp) (lua_State *L, int idx, const void *p); +LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec); +LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz); +LUA_API int (lua_getmetatable) (lua_State *L, int objindex); +LUA_API void (lua_getuservalue) (lua_State *L, int idx); + + +/* +** set functions (stack -> Lua) +*/ +LUA_API void (lua_setglobal) (lua_State *L, const char *var); +LUA_API void (lua_settable) (lua_State *L, int idx); +LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k); +LUA_API void (lua_rawset) (lua_State *L, int idx); +LUA_API void (lua_rawseti) (lua_State *L, int idx, int n); +LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p); +LUA_API int (lua_setmetatable) (lua_State *L, int objindex); +LUA_API void (lua_setuservalue) (lua_State *L, int idx); + + +/* +** 'load' and 'call' functions (load and run Lua code) +*/ +LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, int ctx, + lua_CFunction k); +#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) + +LUA_API int (lua_getctx) (lua_State *L, int *ctx); + +LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc, + int ctx, lua_CFunction k); +#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) + +LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, + const char *chunkname, + const char *mode); + +LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data); + + +/* +** coroutine functions +*/ +LUA_API int (lua_yieldk) (lua_State *L, int nresults, int ctx, + lua_CFunction k); +#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) +LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg); +LUA_API int (lua_status) (lua_State *L); + +/* +** garbage-collection function and options +*/ + +#define LUA_GCSTOP 0 +#define LUA_GCRESTART 1 +#define LUA_GCCOLLECT 2 +#define LUA_GCCOUNT 3 +#define LUA_GCCOUNTB 4 +#define LUA_GCSTEP 5 +#define LUA_GCSETPAUSE 6 +#define LUA_GCSETSTEPMUL 7 +#define LUA_GCSETMAJORINC 8 +#define LUA_GCISRUNNING 9 +#define LUA_GCGEN 10 +#define LUA_GCINC 11 + +LUA_API int (lua_gc) (lua_State *L, int what, int data); + + +/* +** miscellaneous functions +*/ + +LUA_API int (lua_error) (lua_State *L); + +LUA_API int (lua_next) (lua_State *L, int idx); + +LUA_API void (lua_concat) (lua_State *L, int n); +LUA_API void (lua_len) (lua_State *L, int idx); + +LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud); +LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud); + + + +/* +** =============================================================== +** some useful macros +** =============================================================== +*/ + +#define lua_tonumber(L,i) lua_tonumberx(L,i,NULL) +#define lua_tointeger(L,i) lua_tointegerx(L,i,NULL) +#define lua_tounsigned(L,i) lua_tounsignedx(L,i,NULL) + +#define lua_pop(L,n) lua_settop(L, -(n)-1) + +#define lua_newtable(L) lua_createtable(L, 0, 0) + +#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n))) + +#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) + +#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION) +#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) +#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA) +#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL) +#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN) +#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD) +#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE) +#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0) + +#define lua_pushliteral(L, s) \ + lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1) + +#define lua_pushglobaltable(L) \ + lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS) + +#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) + + + +/* +** {====================================================================== +** Debug API +** ======================================================================= +*/ + + +/* +** Event codes +*/ +#define LUA_HOOKCALL 0 +#define LUA_HOOKRET 1 +#define LUA_HOOKLINE 2 +#define LUA_HOOKCOUNT 3 +#define LUA_HOOKTAILCALL 4 + + +/* +** Event masks +*/ +#define LUA_MASKCALL (1 << LUA_HOOKCALL) +#define LUA_MASKRET (1 << LUA_HOOKRET) +#define LUA_MASKLINE (1 << LUA_HOOKLINE) +#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) + +typedef struct lua_Debug lua_Debug; /* activation record */ + + +/* Functions to be called by the debugger in specific events */ +typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar); + + +LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar); +LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar); +LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n); +LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n); +LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n); +LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n); + +LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n); +LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1, + int fidx2, int n2); + +LUA_API int (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count); +LUA_API lua_Hook (lua_gethook) (lua_State *L); +LUA_API int (lua_gethookmask) (lua_State *L); +LUA_API int (lua_gethookcount) (lua_State *L); + + +struct lua_Debug { + int event; + const char *name; /* (n) */ + const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */ + const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */ + const char *source; /* (S) */ + int currentline; /* (l) */ + int linedefined; /* (S) */ + int lastlinedefined; /* (S) */ + unsigned char nups; /* (u) number of upvalues */ + unsigned char nparams;/* (u) number of parameters */ + char isvararg; /* (u) */ + char istailcall; /* (t) */ + char short_src[LUA_IDSIZE]; /* (S) */ + /* private part */ + struct CallInfo *i_ci; /* active function */ +}; + +/* }====================================================================== */ + + +/****************************************************************************** +* Copyright (C) 1994-2013 Lua.org, PUC-Rio. +* +* Permission is hereby granted, free of charge, to any person obtaining +* a copy of this software and associated documentation files (the +* "Software"), to deal in the Software without restriction, including +* without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to +* permit persons to whom the Software is furnished to do so, subject to +* the following conditions: +* +* The above copyright notice and this permission notice shall be +* included in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +******************************************************************************/ + + +#endif diff --git a/extern/lua/src/lua.hpp b/extern/lua/src/lua.hpp new file mode 100644 index 0000000..ec417f5 --- /dev/null +++ b/extern/lua/src/lua.hpp @@ -0,0 +1,9 @@ +// lua.hpp +// Lua header files for C++ +// <> not supplied automatically because Lua also compiles as C++ + +extern "C" { +#include "lua.h" +#include "lualib.h" +#include "lauxlib.h" +} diff --git a/extern/lua/src/lua.o b/extern/lua/src/lua.o new file mode 100644 index 0000000000000000000000000000000000000000..4b652d7c49acc2a82fa70d90d21cead2f0ac8d20 GIT binary patch literal 13816 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 arxgCU2iJdBI^@B1zSSxFxaqwW^#2dMmGf2r literal 0 HcmV?d00001 diff --git a/extern/lua/src/luac b/extern/lua/src/luac new file mode 100755 index 0000000000000000000000000000000000000000..768031cb025aab5bb0b095116e2eb1d5a663aea0 GIT binary patch literal 153265 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 mO!r*hz?U*I!3ZADYq;dgFHbSp?4b@Eo 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 literal 0 HcmV?d00001 diff --git a/extern/lua/src/luac.c b/extern/lua/src/luac.c new file mode 100644 index 0000000..7409706 --- /dev/null +++ b/extern/lua/src/luac.c @@ -0,0 +1,432 @@ +/* +** $Id: luac.c,v 1.69 2011/11/29 17:46:33 lhf Exp $ +** Lua compiler (saves bytecodes to files; also list bytecodes) +** See Copyright Notice in lua.h +*/ + +#include +#include +#include +#include + +#define luac_c +#define LUA_CORE + +#include "lua.h" +#include "lauxlib.h" + +#include "lobject.h" +#include "lstate.h" +#include "lundump.h" + +static void PrintFunction(const Proto* f, int full); +#define luaU_print PrintFunction + +#define PROGNAME "luac" /* default program name */ +#define OUTPUT PROGNAME ".out" /* default output file */ + +static int listing=0; /* list bytecodes? */ +static int dumping=1; /* dump bytecodes? */ +static int stripping=0; /* strip debug information? */ +static char Output[]={ OUTPUT }; /* default output file name */ +static const char* output=Output; /* actual output file name */ +static const char* progname=PROGNAME; /* actual program name */ + +static void fatal(const char* message) +{ + fprintf(stderr,"%s: %s\n",progname,message); + exit(EXIT_FAILURE); +} + +static void cannot(const char* what) +{ + fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno)); + exit(EXIT_FAILURE); +} + +static void usage(const char* message) +{ + if (*message=='-') + fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message); + else + fprintf(stderr,"%s: %s\n",progname,message); + fprintf(stderr, + "usage: %s [options] [filenames]\n" + "Available options are:\n" + " -l list (use -l -l for full listing)\n" + " -o name output to file " LUA_QL("name") " (default is \"%s\")\n" + " -p parse only\n" + " -s strip debug information\n" + " -v show version information\n" + " -- stop handling options\n" + " - stop handling options and process stdin\n" + ,progname,Output); + exit(EXIT_FAILURE); +} + +#define IS(s) (strcmp(argv[i],s)==0) + +static int doargs(int argc, char* argv[]) +{ + int i; + int version=0; + if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0]; + for (i=1; itop+(i)) + +static const Proto* combine(lua_State* L, int n) +{ + if (n==1) + return toproto(L,-1); + else + { + Proto* f; + int i=n; + if (lua_load(L,reader,&i,"=(" PROGNAME ")",NULL)!=LUA_OK) fatal(lua_tostring(L,-1)); + f=toproto(L,-1); + for (i=0; ip[i]=toproto(L,i-n-1); + if (f->p[i]->sizeupvalues>0) f->p[i]->upvalues[0].instack=0; + } + f->sizelineinfo=0; + return f; + } +} + +static int writer(lua_State* L, const void* p, size_t size, void* u) +{ + UNUSED(L); + return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0); +} + +static int pmain(lua_State* L) +{ + int argc=(int)lua_tointeger(L,1); + char** argv=(char**)lua_touserdata(L,2); + const Proto* f; + int i; + if (!lua_checkstack(L,argc)) fatal("too many input files"); + for (i=0; i1); + if (dumping) + { + FILE* D= (output==NULL) ? stdout : fopen(output,"wb"); + if (D==NULL) cannot("open"); + lua_lock(L); + luaU_dump(L,f,writer,D,stripping); + lua_unlock(L); + if (ferror(D)) cannot("write"); + if (fclose(D)) cannot("close"); + } + return 0; +} + +int main(int argc, char* argv[]) +{ + lua_State* L; + int i=doargs(argc,argv); + argc-=i; argv+=i; + if (argc<=0) usage("no input files given"); + L=luaL_newstate(); + if (L==NULL) fatal("cannot create state: not enough memory"); + lua_pushcfunction(L,&pmain); + lua_pushinteger(L,argc); + lua_pushlightuserdata(L,argv); + if (lua_pcall(L,2,0,0)!=LUA_OK) fatal(lua_tostring(L,-1)); + lua_close(L); + return EXIT_SUCCESS; +} + +/* +** $Id: print.c,v 1.69 2013/07/04 01:03:46 lhf Exp $ +** print bytecodes +** See Copyright Notice in lua.h +*/ + +#include +#include + +#define luac_c +#define LUA_CORE + +#include "ldebug.h" +#include "lobject.h" +#include "lopcodes.h" + +#define VOID(p) ((const void*)(p)) + +static void PrintString(const TString* ts) +{ + const char* s=getstr(ts); + size_t i,n=ts->tsv.len; + printf("%c",'"'); + for (i=0; ik[i]; + switch (ttypenv(o)) + { + case LUA_TNIL: + printf("nil"); + break; + case LUA_TBOOLEAN: + printf(bvalue(o) ? "true" : "false"); + break; + case LUA_TNUMBER: + printf(LUA_NUMBER_FMT,nvalue(o)); + break; + case LUA_TSTRING: + PrintString(rawtsvalue(o)); + break; + default: /* cannot happen */ + printf("? type=%d",ttype(o)); + break; + } +} + +#define UPVALNAME(x) ((f->upvalues[x].name) ? getstr(f->upvalues[x].name) : "-") +#define MYK(x) (-1-(x)) + +static void PrintCode(const Proto* f) +{ + const Instruction* code=f->code; + int pc,n=f->sizecode; + for (pc=0; pc0) printf("[%d]\t",line); else printf("[-]\t"); + printf("%-9s\t",luaP_opnames[o]); + switch (getOpMode(o)) + { + case iABC: + printf("%d",a); + if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (MYK(INDEXK(b))) : b); + if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (MYK(INDEXK(c))) : c); + break; + case iABx: + printf("%d",a); + if (getBMode(o)==OpArgK) printf(" %d",MYK(bx)); + if (getBMode(o)==OpArgU) printf(" %d",bx); + break; + case iAsBx: + printf("%d %d",a,sbx); + break; + case iAx: + printf("%d",MYK(ax)); + break; + } + switch (o) + { + case OP_LOADK: + printf("\t; "); PrintConstant(f,bx); + break; + case OP_GETUPVAL: + case OP_SETUPVAL: + printf("\t; %s",UPVALNAME(b)); + break; + case OP_GETTABUP: + printf("\t; %s",UPVALNAME(b)); + if (ISK(c)) { printf(" "); PrintConstant(f,INDEXK(c)); } + break; + case OP_SETTABUP: + printf("\t; %s",UPVALNAME(a)); + if (ISK(b)) { printf(" "); PrintConstant(f,INDEXK(b)); } + if (ISK(c)) { printf(" "); PrintConstant(f,INDEXK(c)); } + break; + case OP_GETTABLE: + case OP_SELF: + if (ISK(c)) { printf("\t; "); PrintConstant(f,INDEXK(c)); } + break; + case OP_SETTABLE: + case OP_ADD: + case OP_SUB: + case OP_MUL: + case OP_DIV: + case OP_POW: + case OP_EQ: + case OP_LT: + case OP_LE: + if (ISK(b) || ISK(c)) + { + printf("\t; "); + if (ISK(b)) PrintConstant(f,INDEXK(b)); else printf("-"); + printf(" "); + if (ISK(c)) PrintConstant(f,INDEXK(c)); else printf("-"); + } + break; + case OP_JMP: + case OP_FORLOOP: + case OP_FORPREP: + case OP_TFORLOOP: + printf("\t; to %d",sbx+pc+2); + break; + case OP_CLOSURE: + printf("\t; %p",VOID(f->p[bx])); + break; + case OP_SETLIST: + if (c==0) printf("\t; %d",(int)code[++pc]); else printf("\t; %d",c); + break; + case OP_EXTRAARG: + printf("\t; "); PrintConstant(f,ax); + break; + default: + break; + } + printf("\n"); + } +} + +#define SS(x) ((x==1)?"":"s") +#define S(x) (int)(x),SS(x) + +static void PrintHeader(const Proto* f) +{ + const char* s=f->source ? getstr(f->source) : "=?"; + if (*s=='@' || *s=='=') + s++; + else if (*s==LUA_SIGNATURE[0]) + s="(bstring)"; + else + s="(string)"; + printf("\n%s <%s:%d,%d> (%d instruction%s at %p)\n", + (f->linedefined==0)?"main":"function",s, + f->linedefined,f->lastlinedefined, + S(f->sizecode),VOID(f)); + printf("%d%s param%s, %d slot%s, %d upvalue%s, ", + (int)(f->numparams),f->is_vararg?"+":"",SS(f->numparams), + S(f->maxstacksize),S(f->sizeupvalues)); + printf("%d local%s, %d constant%s, %d function%s\n", + S(f->sizelocvars),S(f->sizek),S(f->sizep)); +} + +static void PrintDebug(const Proto* f) +{ + int i,n; + n=f->sizek; + printf("constants (%d) for %p:\n",n,VOID(f)); + for (i=0; isizelocvars; + printf("locals (%d) for %p:\n",n,VOID(f)); + for (i=0; ilocvars[i].varname),f->locvars[i].startpc+1,f->locvars[i].endpc+1); + } + n=f->sizeupvalues; + printf("upvalues (%d) for %p:\n",n,VOID(f)); + for (i=0; iupvalues[i].instack,f->upvalues[i].idx); + } +} + +static void PrintFunction(const Proto* f, int full) +{ + int i,n=f->sizep; + PrintHeader(f); + PrintCode(f); + if (full) PrintDebug(f); + for (i=0; ip[i],full); +} diff --git a/extern/lua/src/luac.o b/extern/lua/src/luac.o new file mode 100644 index 0000000000000000000000000000000000000000..7750c772a92505ab27e899d6115cb439b028e4a8 GIT binary patch literal 18904 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 literal 0 HcmV?d00001 diff --git a/extern/lua/src/luaconf.h b/extern/lua/src/luaconf.h new file mode 100644 index 0000000..18be9a9 --- /dev/null +++ b/extern/lua/src/luaconf.h @@ -0,0 +1,551 @@ +/* +** $Id: luaconf.h,v 1.176.1.1 2013/04/12 18:48:47 roberto Exp $ +** Configuration file for Lua +** See Copyright Notice in lua.h +*/ + + +#ifndef lconfig_h +#define lconfig_h + +#include +#include + + +/* +** ================================================================== +** Search for "@@" to find all configurable definitions. +** =================================================================== +*/ + + +/* +@@ LUA_ANSI controls the use of non-ansi features. +** CHANGE it (define it) if you want Lua to avoid the use of any +** non-ansi feature or library. +*/ +#if !defined(LUA_ANSI) && defined(__STRICT_ANSI__) +#define LUA_ANSI +#endif + + +#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE) +#define LUA_WIN /* enable goodies for regular Windows platforms */ +#endif + +#if defined(LUA_WIN) +#define LUA_DL_DLL +#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */ +#endif + + + +#if defined(LUA_USE_LINUX) +#define LUA_USE_POSIX +#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ +#define LUA_USE_READLINE /* needs some extra libraries */ +#define LUA_USE_STRTODHEX /* assume 'strtod' handles hex formats */ +#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */ +#define LUA_USE_LONGLONG /* assume support for long long */ +#endif + +#if defined(LUA_USE_MACOSX) +#define LUA_USE_POSIX +#define LUA_USE_DLOPEN /* does not need -ldl */ +#define LUA_USE_READLINE /* needs an extra library: -lreadline */ +#define LUA_USE_STRTODHEX /* assume 'strtod' handles hex formats */ +#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */ +#define LUA_USE_LONGLONG /* assume support for long long */ +#endif + + + +/* +@@ LUA_USE_POSIX includes all functionality listed as X/Open System +@* Interfaces Extension (XSI). +** CHANGE it (define it) if your system is XSI compatible. +*/ +#if defined(LUA_USE_POSIX) +#define LUA_USE_MKSTEMP +#define LUA_USE_ISATTY +#define LUA_USE_POPEN +#define LUA_USE_ULONGJMP +#define LUA_USE_GMTIME_R +#endif + + + +/* +@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for +@* Lua libraries. +@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for +@* C libraries. +** CHANGE them if your machine has a non-conventional directory +** hierarchy or if you want to install your libraries in +** non-conventional directories. +*/ +#if defined(_WIN32) /* { */ +/* +** In Windows, any exclamation mark ('!') in the path is replaced by the +** path of the directory of the executable file of the current process. +*/ +#define LUA_LDIR "!\\lua\\" +#define LUA_CDIR "!\\" +#define LUA_PATH_DEFAULT \ + LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" ".\\?.lua" +#define LUA_CPATH_DEFAULT \ + LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll" + +#else /* }{ */ + +#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR "/" +#define LUA_ROOT "/usr/local/" +#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR +#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR +#define LUA_PATH_DEFAULT \ + LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" "./?.lua" +#define LUA_CPATH_DEFAULT \ + LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so" +#endif /* } */ + + +/* +@@ LUA_DIRSEP is the directory separator (for submodules). +** CHANGE it if your machine does not use "/" as the directory separator +** and is not Windows. (On Windows Lua automatically uses "\".) +*/ +#if defined(_WIN32) +#define LUA_DIRSEP "\\" +#else +#define LUA_DIRSEP "/" +#endif + + +/* +@@ LUA_ENV is the name of the variable that holds the current +@@ environment, used to access global names. +** CHANGE it if you do not like this name. +*/ +#define LUA_ENV "_ENV" + + +/* +@@ LUA_API is a mark for all core API functions. +@@ LUALIB_API is a mark for all auxiliary library functions. +@@ LUAMOD_API is a mark for all standard library opening functions. +** CHANGE them if you need to define those functions in some special way. +** For instance, if you want to create one Windows DLL with the core and +** the libraries, you may want to use the following definition (define +** LUA_BUILD_AS_DLL to get it). +*/ +#if defined(LUA_BUILD_AS_DLL) /* { */ + +#if defined(LUA_CORE) || defined(LUA_LIB) /* { */ +#define LUA_API __declspec(dllexport) +#else /* }{ */ +#define LUA_API __declspec(dllimport) +#endif /* } */ + +#else /* }{ */ + +#define LUA_API extern + +#endif /* } */ + + +/* more often than not the libs go together with the core */ +#define LUALIB_API LUA_API +#define LUAMOD_API LUALIB_API + + +/* +@@ LUAI_FUNC is a mark for all extern functions that are not to be +@* exported to outside modules. +@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables +@* that are not to be exported to outside modules (LUAI_DDEF for +@* definitions and LUAI_DDEC for declarations). +** CHANGE them if you need to mark them in some special way. Elf/gcc +** (versions 3.2 and later) mark them as "hidden" to optimize access +** when Lua is compiled as a shared library. Not all elf targets support +** this attribute. Unfortunately, gcc does not offer a way to check +** whether the target offers that support, and those without support +** give a warning about it. To avoid these warnings, change to the +** default definition. +*/ +#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ + defined(__ELF__) /* { */ +#define LUAI_FUNC __attribute__((visibility("hidden"))) extern +#define LUAI_DDEC LUAI_FUNC +#define LUAI_DDEF /* empty */ + +#else /* }{ */ +#define LUAI_FUNC extern +#define LUAI_DDEC extern +#define LUAI_DDEF /* empty */ +#endif /* } */ + + + +/* +@@ LUA_QL describes how error messages quote program elements. +** CHANGE it if you want a different appearance. +*/ +#define LUA_QL(x) "'" x "'" +#define LUA_QS LUA_QL("%s") + + +/* +@@ LUA_IDSIZE gives the maximum size for the description of the source +@* of a function in debug information. +** CHANGE it if you want a different size. +*/ +#define LUA_IDSIZE 60 + + +/* +@@ luai_writestring/luai_writeline define how 'print' prints its results. +** They are only used in libraries and the stand-alone program. (The #if +** avoids including 'stdio.h' everywhere.) +*/ +#if defined(LUA_LIB) || defined(lua_c) +#include +#define luai_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) +#define luai_writeline() (luai_writestring("\n", 1), fflush(stdout)) +#endif + +/* +@@ luai_writestringerror defines how to print error messages. +** (A format string with one argument is enough for Lua...) +*/ +#define luai_writestringerror(s,p) \ + (fprintf(stderr, (s), (p)), fflush(stderr)) + + +/* +@@ LUAI_MAXSHORTLEN is the maximum length for short strings, that is, +** strings that are internalized. (Cannot be smaller than reserved words +** or tags for metamethods, as these strings must be internalized; +** #("function") = 8, #("__newindex") = 10.) +*/ +#define LUAI_MAXSHORTLEN 40 + + + +/* +** {================================================================== +** Compatibility with previous versions +** =================================================================== +*/ + +/* +@@ LUA_COMPAT_ALL controls all compatibility options. +** You can define it to get all options, or change specific options +** to fit your specific needs. +*/ +#if defined(LUA_COMPAT_ALL) /* { */ + +/* +@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'. +** You can replace it with 'table.unpack'. +*/ +#define LUA_COMPAT_UNPACK + +/* +@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'. +** You can replace it with 'package.searchers'. +*/ +#define LUA_COMPAT_LOADERS + +/* +@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall. +** You can call your C function directly (with light C functions). +*/ +#define lua_cpcall(L,f,u) \ + (lua_pushcfunction(L, (f)), \ + lua_pushlightuserdata(L,(u)), \ + lua_pcall(L,1,0,0)) + + +/* +@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library. +** You can rewrite 'log10(x)' as 'log(x, 10)'. +*/ +#define LUA_COMPAT_LOG10 + +/* +@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base +** library. You can rewrite 'loadstring(s)' as 'load(s)'. +*/ +#define LUA_COMPAT_LOADSTRING + +/* +@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library. +*/ +#define LUA_COMPAT_MAXN + +/* +@@ The following macros supply trivial compatibility for some +** changes in the API. The macros themselves document how to +** change your code to avoid using them. +*/ +#define lua_strlen(L,i) lua_rawlen(L, (i)) + +#define lua_objlen(L,i) lua_rawlen(L, (i)) + +#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) +#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT) + +/* +@@ LUA_COMPAT_MODULE controls compatibility with previous +** module functions 'module' (Lua) and 'luaL_register' (C). +*/ +#define LUA_COMPAT_MODULE + +#endif /* } */ + +/* }================================================================== */ + + + +/* +@@ LUAI_BITSINT defines the number of bits in an int. +** CHANGE here if Lua cannot automatically detect the number of bits of +** your machine. Probably you do not need to change this. +*/ +/* avoid overflows in comparison */ +#if INT_MAX-20 < 32760 /* { */ +#define LUAI_BITSINT 16 +#elif INT_MAX > 2147483640L /* }{ */ +/* int has at least 32 bits */ +#define LUAI_BITSINT 32 +#else /* }{ */ +#error "you must define LUA_BITSINT with number of bits in an integer" +#endif /* } */ + + +/* +@@ LUA_INT32 is an signed integer with exactly 32 bits. +@@ LUAI_UMEM is an unsigned integer big enough to count the total +@* memory used by Lua. +@@ LUAI_MEM is a signed integer big enough to count the total memory +@* used by Lua. +** CHANGE here if for some weird reason the default definitions are not +** good enough for your machine. Probably you do not need to change +** this. +*/ +#if LUAI_BITSINT >= 32 /* { */ +#define LUA_INT32 int +#define LUAI_UMEM size_t +#define LUAI_MEM ptrdiff_t +#else /* }{ */ +/* 16-bit ints */ +#define LUA_INT32 long +#define LUAI_UMEM unsigned long +#define LUAI_MEM long +#endif /* } */ + + +/* +@@ LUAI_MAXSTACK limits the size of the Lua stack. +** CHANGE it if you need a different limit. This limit is arbitrary; +** its only purpose is to stop Lua to consume unlimited stack +** space (and to reserve some numbers for pseudo-indices). +*/ +#if LUAI_BITSINT >= 32 +#define LUAI_MAXSTACK 1000000 +#else +#define LUAI_MAXSTACK 15000 +#endif + +/* reserve some space for error handling */ +#define LUAI_FIRSTPSEUDOIDX (-LUAI_MAXSTACK - 1000) + + + + +/* +@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. +** CHANGE it if it uses too much C-stack space. +*/ +#define LUAL_BUFFERSIZE BUFSIZ + + + + +/* +** {================================================================== +@@ LUA_NUMBER is the type of numbers in Lua. +** CHANGE the following definitions only if you want to build Lua +** with a number type different from double. You may also need to +** change lua_number2int & lua_number2integer. +** =================================================================== +*/ + +#define LUA_NUMBER_DOUBLE +#define LUA_NUMBER double + +/* +@@ LUAI_UACNUMBER is the result of an 'usual argument conversion' +@* over a number. +*/ +#define LUAI_UACNUMBER double + + +/* +@@ LUA_NUMBER_SCAN is the format for reading numbers. +@@ LUA_NUMBER_FMT is the format for writing numbers. +@@ lua_number2str converts a number to a string. +@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion. +*/ +#define LUA_NUMBER_SCAN "%lf" +#define LUA_NUMBER_FMT "%.14g" +#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n)) +#define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */ + + +/* +@@ l_mathop allows the addition of an 'l' or 'f' to all math operations +*/ +#define l_mathop(x) (x) + + +/* +@@ lua_str2number converts a decimal numeric string to a number. +@@ lua_strx2number converts an hexadecimal numeric string to a number. +** In C99, 'strtod' does both conversions. C89, however, has no function +** to convert floating hexadecimal strings to numbers. For these +** systems, you can leave 'lua_strx2number' undefined and Lua will +** provide its own implementation. +*/ +#define lua_str2number(s,p) strtod((s), (p)) + +#if defined(LUA_USE_STRTODHEX) +#define lua_strx2number(s,p) strtod((s), (p)) +#endif + + +/* +@@ The luai_num* macros define the primitive operations over numbers. +*/ + +/* the following operations need the math library */ +#if defined(lobject_c) || defined(lvm_c) +#include +#define luai_nummod(L,a,b) ((a) - l_mathop(floor)((a)/(b))*(b)) +#define luai_numpow(L,a,b) (l_mathop(pow)(a,b)) +#endif + +/* these are quite standard operations */ +#if defined(LUA_CORE) +#define luai_numadd(L,a,b) ((a)+(b)) +#define luai_numsub(L,a,b) ((a)-(b)) +#define luai_nummul(L,a,b) ((a)*(b)) +#define luai_numdiv(L,a,b) ((a)/(b)) +#define luai_numunm(L,a) (-(a)) +#define luai_numeq(a,b) ((a)==(b)) +#define luai_numlt(L,a,b) ((a)<(b)) +#define luai_numle(L,a,b) ((a)<=(b)) +#define luai_numisnan(L,a) (!luai_numeq((a), (a))) +#endif + + + +/* +@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger. +** CHANGE that if ptrdiff_t is not adequate on your machine. (On most +** machines, ptrdiff_t gives a good choice between int or long.) +*/ +#define LUA_INTEGER ptrdiff_t + +/* +@@ LUA_UNSIGNED is the integral type used by lua_pushunsigned/lua_tounsigned. +** It must have at least 32 bits. +*/ +#define LUA_UNSIGNED unsigned LUA_INT32 + + + +/* +** Some tricks with doubles +*/ + +#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) /* { */ +/* +** The next definitions activate some tricks to speed up the +** conversion from doubles to integer types, mainly to LUA_UNSIGNED. +** +@@ LUA_MSASMTRICK uses Microsoft assembler to avoid clashes with a +** DirectX idiosyncrasy. +** +@@ LUA_IEEE754TRICK uses a trick that should work on any machine +** using IEEE754 with a 32-bit integer type. +** +@@ LUA_IEEELL extends the trick to LUA_INTEGER; should only be +** defined when LUA_INTEGER is a 32-bit integer. +** +@@ LUA_IEEEENDIAN is the endianness of doubles in your machine +** (0 for little endian, 1 for big endian); if not defined, Lua will +** check it dynamically for LUA_IEEE754TRICK (but not for LUA_NANTRICK). +** +@@ LUA_NANTRICK controls the use of a trick to pack all types into +** a single double value, using NaN values to represent non-number +** values. The trick only works on 32-bit machines (ints and pointers +** are 32-bit values) with numbers represented as IEEE 754-2008 doubles +** with conventional endianess (12345678 or 87654321), in CPUs that do +** not produce signaling NaN values (all NaNs are quiet). +*/ + +/* Microsoft compiler on a Pentium (32 bit) ? */ +#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86) /* { */ + +#define LUA_MSASMTRICK +#define LUA_IEEEENDIAN 0 +#define LUA_NANTRICK + + +/* pentium 32 bits? */ +#elif defined(__i386__) || defined(__i386) || defined(__X86__) /* }{ */ + +#define LUA_IEEE754TRICK +#define LUA_IEEELL +#define LUA_IEEEENDIAN 0 +#define LUA_NANTRICK + +/* pentium 64 bits? */ +#elif defined(__x86_64) /* }{ */ + +#define LUA_IEEE754TRICK +#define LUA_IEEEENDIAN 0 + +#elif defined(__POWERPC__) || defined(__ppc__) /* }{ */ + +#define LUA_IEEE754TRICK +#define LUA_IEEEENDIAN 1 + +#else /* }{ */ + +/* assume IEEE754 and a 32-bit integer type */ +#define LUA_IEEE754TRICK + +#endif /* } */ + +#endif /* } */ + +/* }================================================================== */ + + + + +/* =================================================================== */ + +/* +** Local configuration. You can use this space to add your redefinitions +** without modifying the main part of the file. +*/ + + + +#endif + diff --git a/extern/lua/src/lualib.h b/extern/lua/src/lualib.h new file mode 100644 index 0000000..da82005 --- /dev/null +++ b/extern/lua/src/lualib.h @@ -0,0 +1,55 @@ +/* +** $Id: lualib.h,v 1.43.1.1 2013/04/12 18:48:47 roberto Exp $ +** Lua standard libraries +** See Copyright Notice in lua.h +*/ + + +#ifndef lualib_h +#define lualib_h + +#include "lua.h" + + + +LUAMOD_API int (luaopen_base) (lua_State *L); + +#define LUA_COLIBNAME "coroutine" +LUAMOD_API int (luaopen_coroutine) (lua_State *L); + +#define LUA_TABLIBNAME "table" +LUAMOD_API int (luaopen_table) (lua_State *L); + +#define LUA_IOLIBNAME "io" +LUAMOD_API int (luaopen_io) (lua_State *L); + +#define LUA_OSLIBNAME "os" +LUAMOD_API int (luaopen_os) (lua_State *L); + +#define LUA_STRLIBNAME "string" +LUAMOD_API int (luaopen_string) (lua_State *L); + +#define LUA_BITLIBNAME "bit32" +LUAMOD_API int (luaopen_bit32) (lua_State *L); + +#define LUA_MATHLIBNAME "math" +LUAMOD_API int (luaopen_math) (lua_State *L); + +#define LUA_DBLIBNAME "debug" +LUAMOD_API int (luaopen_debug) (lua_State *L); + +#define LUA_LOADLIBNAME "package" +LUAMOD_API int (luaopen_package) (lua_State *L); + + +/* open all previous libraries */ +LUALIB_API void (luaL_openlibs) (lua_State *L); + + + +#if !defined(lua_assert) +#define lua_assert(x) ((void)0) +#endif + + +#endif diff --git a/extern/lua/src/lundump.c b/extern/lua/src/lundump.c new file mode 100644 index 0000000..4163cb5 --- /dev/null +++ b/extern/lua/src/lundump.c @@ -0,0 +1,258 @@ +/* +** $Id: lundump.c,v 2.22.1.1 2013/04/12 18:48:47 roberto Exp $ +** load precompiled Lua chunks +** See Copyright Notice in lua.h +*/ + +#include + +#define lundump_c +#define LUA_CORE + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstring.h" +#include "lundump.h" +#include "lzio.h" + +typedef struct { + lua_State* L; + ZIO* Z; + Mbuffer* b; + const char* name; +} LoadState; + +static l_noret error(LoadState* S, const char* why) +{ + luaO_pushfstring(S->L,"%s: %s precompiled chunk",S->name,why); + luaD_throw(S->L,LUA_ERRSYNTAX); +} + +#define LoadMem(S,b,n,size) LoadBlock(S,b,(n)*(size)) +#define LoadByte(S) (lu_byte)LoadChar(S) +#define LoadVar(S,x) LoadMem(S,&x,1,sizeof(x)) +#define LoadVector(S,b,n,size) LoadMem(S,b,n,size) + +#if !defined(luai_verifycode) +#define luai_verifycode(L,b,f) /* empty */ +#endif + +static void LoadBlock(LoadState* S, void* b, size_t size) +{ + if (luaZ_read(S->Z,b,size)!=0) error(S,"truncated"); +} + +static int LoadChar(LoadState* S) +{ + char x; + LoadVar(S,x); + return x; +} + +static int LoadInt(LoadState* S) +{ + int x; + LoadVar(S,x); + if (x<0) error(S,"corrupted"); + return x; +} + +static lua_Number LoadNumber(LoadState* S) +{ + lua_Number x; + LoadVar(S,x); + return x; +} + +static TString* LoadString(LoadState* S) +{ + size_t size; + LoadVar(S,size); + if (size==0) + return NULL; + else + { + char* s=luaZ_openspace(S->L,S->b,size); + LoadBlock(S,s,size*sizeof(char)); + return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */ + } +} + +static void LoadCode(LoadState* S, Proto* f) +{ + int n=LoadInt(S); + f->code=luaM_newvector(S->L,n,Instruction); + f->sizecode=n; + LoadVector(S,f->code,n,sizeof(Instruction)); +} + +static void LoadFunction(LoadState* S, Proto* f); + +static void LoadConstants(LoadState* S, Proto* f) +{ + int i,n; + n=LoadInt(S); + f->k=luaM_newvector(S->L,n,TValue); + f->sizek=n; + for (i=0; ik[i]); + for (i=0; ik[i]; + int t=LoadChar(S); + switch (t) + { + case LUA_TNIL: + setnilvalue(o); + break; + case LUA_TBOOLEAN: + setbvalue(o,LoadChar(S)); + break; + case LUA_TNUMBER: + setnvalue(o,LoadNumber(S)); + break; + case LUA_TSTRING: + setsvalue2n(S->L,o,LoadString(S)); + break; + default: lua_assert(0); + } + } + n=LoadInt(S); + f->p=luaM_newvector(S->L,n,Proto*); + f->sizep=n; + for (i=0; ip[i]=NULL; + for (i=0; ip[i]=luaF_newproto(S->L); + LoadFunction(S,f->p[i]); + } +} + +static void LoadUpvalues(LoadState* S, Proto* f) +{ + int i,n; + n=LoadInt(S); + f->upvalues=luaM_newvector(S->L,n,Upvaldesc); + f->sizeupvalues=n; + for (i=0; iupvalues[i].name=NULL; + for (i=0; iupvalues[i].instack=LoadByte(S); + f->upvalues[i].idx=LoadByte(S); + } +} + +static void LoadDebug(LoadState* S, Proto* f) +{ + int i,n; + f->source=LoadString(S); + n=LoadInt(S); + f->lineinfo=luaM_newvector(S->L,n,int); + f->sizelineinfo=n; + LoadVector(S,f->lineinfo,n,sizeof(int)); + n=LoadInt(S); + f->locvars=luaM_newvector(S->L,n,LocVar); + f->sizelocvars=n; + for (i=0; ilocvars[i].varname=NULL; + for (i=0; ilocvars[i].varname=LoadString(S); + f->locvars[i].startpc=LoadInt(S); + f->locvars[i].endpc=LoadInt(S); + } + n=LoadInt(S); + for (i=0; iupvalues[i].name=LoadString(S); +} + +static void LoadFunction(LoadState* S, Proto* f) +{ + f->linedefined=LoadInt(S); + f->lastlinedefined=LoadInt(S); + f->numparams=LoadByte(S); + f->is_vararg=LoadByte(S); + f->maxstacksize=LoadByte(S); + LoadCode(S,f); + LoadConstants(S,f); + LoadUpvalues(S,f); + LoadDebug(S,f); +} + +/* the code below must be consistent with the code in luaU_header */ +#define N0 LUAC_HEADERSIZE +#define N1 (sizeof(LUA_SIGNATURE)-sizeof(char)) +#define N2 N1+2 +#define N3 N2+6 + +static void LoadHeader(LoadState* S) +{ + lu_byte h[LUAC_HEADERSIZE]; + lu_byte s[LUAC_HEADERSIZE]; + luaU_header(h); + memcpy(s,h,sizeof(char)); /* first char already read */ + LoadBlock(S,s+sizeof(char),LUAC_HEADERSIZE-sizeof(char)); + if (memcmp(h,s,N0)==0) return; + if (memcmp(h,s,N1)!=0) error(S,"not a"); + if (memcmp(h,s,N2)!=0) error(S,"version mismatch in"); + if (memcmp(h,s,N3)!=0) error(S,"incompatible"); else error(S,"corrupted"); +} + +/* +** load precompiled chunk +*/ +Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name) +{ + LoadState S; + Closure* cl; + if (*name=='@' || *name=='=') + S.name=name+1; + else if (*name==LUA_SIGNATURE[0]) + S.name="binary string"; + else + S.name=name; + S.L=L; + S.Z=Z; + S.b=buff; + LoadHeader(&S); + cl=luaF_newLclosure(L,1); + setclLvalue(L,L->top,cl); incr_top(L); + cl->l.p=luaF_newproto(L); + LoadFunction(&S,cl->l.p); + if (cl->l.p->sizeupvalues != 1) + { + Proto* p=cl->l.p; + cl=luaF_newLclosure(L,cl->l.p->sizeupvalues); + cl->l.p=p; + setclLvalue(L,L->top-1,cl); + } + luai_verifycode(L,buff,cl->l.p); + return cl; +} + +#define MYINT(s) (s[0]-'0') +#define VERSION MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR) +#define FORMAT 0 /* this is the official format */ + +/* +* make header for precompiled chunks +* if you change the code below be sure to update LoadHeader and FORMAT above +* and LUAC_HEADERSIZE in lundump.h +*/ +void luaU_header (lu_byte* h) +{ + int x=1; + memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-sizeof(char)); + h+=sizeof(LUA_SIGNATURE)-sizeof(char); + *h++=cast_byte(VERSION); + *h++=cast_byte(FORMAT); + *h++=cast_byte(*(char*)&x); /* endianness */ + *h++=cast_byte(sizeof(int)); + *h++=cast_byte(sizeof(size_t)); + *h++=cast_byte(sizeof(Instruction)); + *h++=cast_byte(sizeof(lua_Number)); + *h++=cast_byte(((lua_Number)0.5)==0); /* is lua_Number integral? */ + memcpy(h,LUAC_TAIL,sizeof(LUAC_TAIL)-sizeof(char)); +} diff --git a/extern/lua/src/lundump.h b/extern/lua/src/lundump.h new file mode 100644 index 0000000..5255db2 --- /dev/null +++ b/extern/lua/src/lundump.h @@ -0,0 +1,28 @@ +/* +** $Id: lundump.h,v 1.39.1.1 2013/04/12 18:48:47 roberto Exp $ +** load precompiled Lua chunks +** See Copyright Notice in lua.h +*/ + +#ifndef lundump_h +#define lundump_h + +#include "lobject.h" +#include "lzio.h" + +/* load one chunk; from lundump.c */ +LUAI_FUNC Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name); + +/* make header; from lundump.c */ +LUAI_FUNC void luaU_header (lu_byte* h); + +/* dump one chunk; from ldump.c */ +LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip); + +/* data to catch conversion errors */ +#define LUAC_TAIL "\x19\x93\r\n\x1a\n" + +/* size in bytes of header of binary files */ +#define LUAC_HEADERSIZE (sizeof(LUA_SIGNATURE)-sizeof(char)+2+6+sizeof(LUAC_TAIL)-sizeof(char)) + +#endif diff --git a/extern/lua/src/lundump.o b/extern/lua/src/lundump.o new file mode 100644 index 0000000000000000000000000000000000000000..ca7d49749072d20a67f306c9981d5875266f2ea9 GIT binary patch literal 5216 zcmbtXZ){sv6~B(%#7#0kZ-e2rsCj^kGFZJB0wik~eyJV56lV)fGYV~&IL^yr)&FEa zukEy^m0nWy$;ni0pFkT_;sZnF1JY1cMWQ5a{#4rsSR@c15NT1%6?i5`rT=-+O=O?>+atbDxh!VjWcu2jS!(FObz0M+y1E#?^UPU~QKa@+~ zlJ$>*Q?h>d9I_1jkxSdpIr(BJAT*33%H)r_O_{N&V%6RYa;e~(M5e4S8mCuQR)$vP zdwV9`l=D#5Zu#U1)$caWf{0w&?RSIAu?6+3pzj5D%q`%uJ_n{`eb$(uqG5na+hzT> zJkh;kifJ>xz56c=o$Q%(mCbw6e7*5K&?$xe^ExcTD5 zvrFhL61>u-UyV77BABL0>eQ>LhQ7G7)GT&tGj8Js1l`qotN1(I_Pem)=k%quAzAVa zA+hKbhx?15iS9t zdb?VefVZ*uK1TXBaA1T`WaApldDJSDZN=)^2jY#Z)zx6yFn(&$Zw7tKL9E?%6YP3$ zBxT<tB~#x>C%^C&U6b%QPm^hqpS5^rye22E3_Hxm-b2frB^Np4acxJ%y$@z z0}XEh@w=%s&*bd_2sa~ry zhPRT*sb9lUzbuzjh>iLN4lxcsz~mmoxvWh)Xz15N(Bg(p+C^hjG(^r}vhm2Ml0GY! zc6epIaX#ekKnAW#-)@q%DX;v@w5-EYdmxN_r>ud_X-|##jAgJ1Jq2W;0?s zSxCp##ITsmkYomp#nt3MN+Be=W5@GiV^|qT#xr7bpfwQO7HodToMFbur|2&sj@Ne) z$04s{bA65bB;*wF&obT@ag;n>4H};hrp*lBTE=(PdfZZ-AJ*NB_X^`3uaZ1I%^CAF zRdsoMU_|n`Mc^G`a$je1T2;&=zFbTBQXL^7z~5mqajdm=kN3^0c8_nu+3pd?U6QBq z_=d2jNvn=}Le4)qYduW>NgfeIK(yWCmg}(VUt%`C!A6Yz9-Gf#?SSw&#(3Nb%9<>$OagF7X(a<1aFR+O`eN_4f*Ma805vqG4EGJ?<7qg+|CdBCfZN2E z(n=w=P;0CxA@ruSK$~HX=?_^joEl8MZv zZxbWU|E2#l(`Uz2Hq*lN8@VIKv6~$Re7*BO`=qJx9@E3~$G;X_pPxV8DfY8Nm45a= zSBIImw1cK|q|3yv+pu!4Xnr@k@I)V0aFQ^ZKJb8?etaydOp++OJ{U z1`oNX6PiXq!Z~}SuvJKWedeTbrSA-72+_jMw%*~Gx&O5 z^LBiiaM#GkU* z|A^syU)V2@?pWkM18W{n1G_lU4(5{MtrhT|3V6B#evIKfo?h^QblQgV{7+l#YyvqR z&)+P#HJ_VUtHSuL@*Nf&zmd3|?=qanvmJOy2W+@x!bD^v+Q)}e3!8A9_wU^{yq~S# Yu;Ei|eaeROE8>a`=Y4D0hV#DlAI<2ckpKVy literal 0 HcmV?d00001 diff --git a/extern/lua/src/lvm.c b/extern/lua/src/lvm.c new file mode 100644 index 0000000..141b9fd --- /dev/null +++ b/extern/lua/src/lvm.c @@ -0,0 +1,867 @@ +/* +** $Id: lvm.c,v 2.155.1.1 2013/04/12 18:48:47 roberto Exp $ +** Lua virtual machine +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include + +#define lvm_c +#define LUA_CORE + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lvm.h" + + + +/* limit for table tag-method chains (to avoid loops) */ +#define MAXTAGLOOP 100 + + +const TValue *luaV_tonumber (const TValue *obj, TValue *n) { + lua_Number num; + if (ttisnumber(obj)) return obj; + if (ttisstring(obj) && luaO_str2d(svalue(obj), tsvalue(obj)->len, &num)) { + setnvalue(n, num); + return n; + } + else + return NULL; +} + + +int luaV_tostring (lua_State *L, StkId obj) { + if (!ttisnumber(obj)) + return 0; + else { + char s[LUAI_MAXNUMBER2STR]; + lua_Number n = nvalue(obj); + int l = lua_number2str(s, n); + setsvalue2s(L, obj, luaS_newlstr(L, s, l)); + return 1; + } +} + + +static void traceexec (lua_State *L) { + CallInfo *ci = L->ci; + lu_byte mask = L->hookmask; + int counthook = ((mask & LUA_MASKCOUNT) && L->hookcount == 0); + if (counthook) + resethookcount(L); /* reset count */ + if (ci->callstatus & CIST_HOOKYIELD) { /* called hook last time? */ + ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */ + return; /* do not call hook again (VM yielded, so it did not move) */ + } + if (counthook) + luaD_hook(L, LUA_HOOKCOUNT, -1); /* call count hook */ + if (mask & LUA_MASKLINE) { + Proto *p = ci_func(ci)->p; + int npc = pcRel(ci->u.l.savedpc, p); + int newline = getfuncline(p, npc); + if (npc == 0 || /* call linehook when enter a new function, */ + ci->u.l.savedpc <= L->oldpc || /* when jump back (loop), or when */ + newline != getfuncline(p, pcRel(L->oldpc, p))) /* enter a new line */ + luaD_hook(L, LUA_HOOKLINE, newline); /* call line hook */ + } + L->oldpc = ci->u.l.savedpc; + if (L->status == LUA_YIELD) { /* did hook yield? */ + if (counthook) + L->hookcount = 1; /* undo decrement to zero */ + ci->u.l.savedpc--; /* undo increment (resume will increment it again) */ + ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */ + ci->func = L->top - 1; /* protect stack below results */ + luaD_throw(L, LUA_YIELD); + } +} + + +static void callTM (lua_State *L, const TValue *f, const TValue *p1, + const TValue *p2, TValue *p3, int hasres) { + ptrdiff_t result = savestack(L, p3); + setobj2s(L, L->top++, f); /* push function */ + setobj2s(L, L->top++, p1); /* 1st argument */ + setobj2s(L, L->top++, p2); /* 2nd argument */ + if (!hasres) /* no result? 'p3' is third argument */ + setobj2s(L, L->top++, p3); /* 3rd argument */ + /* metamethod may yield only when called from Lua code */ + luaD_call(L, L->top - (4 - hasres), hasres, isLua(L->ci)); + if (hasres) { /* if has result, move it to its place */ + p3 = restorestack(L, result); + setobjs2s(L, p3, --L->top); + } +} + + +void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) { + int loop; + for (loop = 0; loop < MAXTAGLOOP; loop++) { + const TValue *tm; + if (ttistable(t)) { /* `t' is a table? */ + Table *h = hvalue(t); + const TValue *res = luaH_get(h, key); /* do a primitive get */ + if (!ttisnil(res) || /* result is not nil? */ + (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */ + setobj2s(L, val, res); + return; + } + /* else will try the tag method */ + } + else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))) + luaG_typeerror(L, t, "index"); + if (ttisfunction(tm)) { + callTM(L, tm, t, key, val, 1); + return; + } + t = tm; /* else repeat with 'tm' */ + } + luaG_runerror(L, "loop in gettable"); +} + + +void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) { + int loop; + for (loop = 0; loop < MAXTAGLOOP; loop++) { + const TValue *tm; + if (ttistable(t)) { /* `t' is a table? */ + Table *h = hvalue(t); + TValue *oldval = cast(TValue *, luaH_get(h, key)); + /* if previous value is not nil, there must be a previous entry + in the table; moreover, a metamethod has no relevance */ + if (!ttisnil(oldval) || + /* previous value is nil; must check the metamethod */ + ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL && + /* no metamethod; is there a previous entry in the table? */ + (oldval != luaO_nilobject || + /* no previous entry; must create one. (The next test is + always true; we only need the assignment.) */ + (oldval = luaH_newkey(L, h, key), 1)))) { + /* no metamethod and (now) there is an entry with given key */ + setobj2t(L, oldval, val); /* assign new value to that entry */ + invalidateTMcache(h); + luaC_barrierback(L, obj2gco(h), val); + return; + } + /* else will try the metamethod */ + } + else /* not a table; check metamethod */ + if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))) + luaG_typeerror(L, t, "index"); + /* there is a metamethod */ + if (ttisfunction(tm)) { + callTM(L, tm, t, key, val, 0); + return; + } + t = tm; /* else repeat with 'tm' */ + } + luaG_runerror(L, "loop in settable"); +} + + +static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2, + StkId res, TMS event) { + const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */ + if (ttisnil(tm)) + tm = luaT_gettmbyobj(L, p2, event); /* try second operand */ + if (ttisnil(tm)) return 0; + callTM(L, tm, p1, p2, res, 1); + return 1; +} + + +static const TValue *get_equalTM (lua_State *L, Table *mt1, Table *mt2, + TMS event) { + const TValue *tm1 = fasttm(L, mt1, event); + const TValue *tm2; + if (tm1 == NULL) return NULL; /* no metamethod */ + if (mt1 == mt2) return tm1; /* same metatables => same metamethods */ + tm2 = fasttm(L, mt2, event); + if (tm2 == NULL) return NULL; /* no metamethod */ + if (luaV_rawequalobj(tm1, tm2)) /* same metamethods? */ + return tm1; + return NULL; +} + + +static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2, + TMS event) { + if (!call_binTM(L, p1, p2, L->top, event)) + return -1; /* no metamethod */ + else + return !l_isfalse(L->top); +} + + +static int l_strcmp (const TString *ls, const TString *rs) { + const char *l = getstr(ls); + size_t ll = ls->tsv.len; + const char *r = getstr(rs); + size_t lr = rs->tsv.len; + for (;;) { + int temp = strcoll(l, r); + if (temp != 0) return temp; + else { /* strings are equal up to a `\0' */ + size_t len = strlen(l); /* index of first `\0' in both strings */ + if (len == lr) /* r is finished? */ + return (len == ll) ? 0 : 1; + else if (len == ll) /* l is finished? */ + return -1; /* l is smaller than r (because r is not finished) */ + /* both strings longer than `len'; go on comparing (after the `\0') */ + len++; + l += len; ll -= len; r += len; lr -= len; + } + } +} + + +int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) { + int res; + if (ttisnumber(l) && ttisnumber(r)) + return luai_numlt(L, nvalue(l), nvalue(r)); + else if (ttisstring(l) && ttisstring(r)) + return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0; + else if ((res = call_orderTM(L, l, r, TM_LT)) < 0) + luaG_ordererror(L, l, r); + return res; +} + + +int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) { + int res; + if (ttisnumber(l) && ttisnumber(r)) + return luai_numle(L, nvalue(l), nvalue(r)); + else if (ttisstring(l) && ttisstring(r)) + return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0; + else if ((res = call_orderTM(L, l, r, TM_LE)) >= 0) /* first try `le' */ + return res; + else if ((res = call_orderTM(L, r, l, TM_LT)) < 0) /* else try `lt' */ + luaG_ordererror(L, l, r); + return !res; +} + + +/* +** equality of Lua values. L == NULL means raw equality (no metamethods) +*/ +int luaV_equalobj_ (lua_State *L, const TValue *t1, const TValue *t2) { + const TValue *tm; + lua_assert(ttisequal(t1, t2)); + switch (ttype(t1)) { + case LUA_TNIL: return 1; + case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2)); + case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */ + case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); + case LUA_TLCF: return fvalue(t1) == fvalue(t2); + case LUA_TSHRSTR: return eqshrstr(rawtsvalue(t1), rawtsvalue(t2)); + case LUA_TLNGSTR: return luaS_eqlngstr(rawtsvalue(t1), rawtsvalue(t2)); + case LUA_TUSERDATA: { + if (uvalue(t1) == uvalue(t2)) return 1; + else if (L == NULL) return 0; + tm = get_equalTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable, TM_EQ); + break; /* will try TM */ + } + case LUA_TTABLE: { + if (hvalue(t1) == hvalue(t2)) return 1; + else if (L == NULL) return 0; + tm = get_equalTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ); + break; /* will try TM */ + } + default: + lua_assert(iscollectable(t1)); + return gcvalue(t1) == gcvalue(t2); + } + if (tm == NULL) return 0; /* no TM? */ + callTM(L, tm, t1, t2, L->top, 1); /* call TM */ + return !l_isfalse(L->top); +} + + +void luaV_concat (lua_State *L, int total) { + lua_assert(total >= 2); + do { + StkId top = L->top; + int n = 2; /* number of elements handled in this pass (at least 2) */ + if (!(ttisstring(top-2) || ttisnumber(top-2)) || !tostring(L, top-1)) { + if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT)) + luaG_concaterror(L, top-2, top-1); + } + else if (tsvalue(top-1)->len == 0) /* second operand is empty? */ + (void)tostring(L, top - 2); /* result is first operand */ + else if (ttisstring(top-2) && tsvalue(top-2)->len == 0) { + setobjs2s(L, top - 2, top - 1); /* result is second op. */ + } + else { + /* at least two non-empty string values; get as many as possible */ + size_t tl = tsvalue(top-1)->len; + char *buffer; + int i; + /* collect total length */ + for (i = 1; i < total && tostring(L, top-i-1); i++) { + size_t l = tsvalue(top-i-1)->len; + if (l >= (MAX_SIZET/sizeof(char)) - tl) + luaG_runerror(L, "string length overflow"); + tl += l; + } + buffer = luaZ_openspace(L, &G(L)->buff, tl); + tl = 0; + n = i; + do { /* concat all strings */ + size_t l = tsvalue(top-i)->len; + memcpy(buffer+tl, svalue(top-i), l * sizeof(char)); + tl += l; + } while (--i > 0); + setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl)); + } + total -= n-1; /* got 'n' strings to create 1 new */ + L->top -= n-1; /* popped 'n' strings and pushed one */ + } while (total > 1); /* repeat until only 1 result left */ +} + + +void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) { + const TValue *tm; + switch (ttypenv(rb)) { + case LUA_TTABLE: { + Table *h = hvalue(rb); + tm = fasttm(L, h->metatable, TM_LEN); + if (tm) break; /* metamethod? break switch to call it */ + setnvalue(ra, cast_num(luaH_getn(h))); /* else primitive len */ + return; + } + case LUA_TSTRING: { + setnvalue(ra, cast_num(tsvalue(rb)->len)); + return; + } + default: { /* try metamethod */ + tm = luaT_gettmbyobj(L, rb, TM_LEN); + if (ttisnil(tm)) /* no metamethod? */ + luaG_typeerror(L, rb, "get length of"); + break; + } + } + callTM(L, tm, rb, rb, ra, 1); +} + + +void luaV_arith (lua_State *L, StkId ra, const TValue *rb, + const TValue *rc, TMS op) { + TValue tempb, tempc; + const TValue *b, *c; + if ((b = luaV_tonumber(rb, &tempb)) != NULL && + (c = luaV_tonumber(rc, &tempc)) != NULL) { + lua_Number res = luaO_arith(op - TM_ADD + LUA_OPADD, nvalue(b), nvalue(c)); + setnvalue(ra, res); + } + else if (!call_binTM(L, rb, rc, ra, op)) + luaG_aritherror(L, rb, rc); +} + + +/* +** check whether cached closure in prototype 'p' may be reused, that is, +** whether there is a cached closure with the same upvalues needed by +** new closure to be created. +*/ +static Closure *getcached (Proto *p, UpVal **encup, StkId base) { + Closure *c = p->cache; + if (c != NULL) { /* is there a cached closure? */ + int nup = p->sizeupvalues; + Upvaldesc *uv = p->upvalues; + int i; + for (i = 0; i < nup; i++) { /* check whether it has right upvalues */ + TValue *v = uv[i].instack ? base + uv[i].idx : encup[uv[i].idx]->v; + if (c->l.upvals[i]->v != v) + return NULL; /* wrong upvalue; cannot reuse closure */ + } + } + return c; /* return cached closure (or NULL if no cached closure) */ +} + + +/* +** create a new Lua closure, push it in the stack, and initialize +** its upvalues. Note that the call to 'luaC_barrierproto' must come +** before the assignment to 'p->cache', as the function needs the +** original value of that field. +*/ +static void pushclosure (lua_State *L, Proto *p, UpVal **encup, StkId base, + StkId ra) { + int nup = p->sizeupvalues; + Upvaldesc *uv = p->upvalues; + int i; + Closure *ncl = luaF_newLclosure(L, nup); + ncl->l.p = p; + setclLvalue(L, ra, ncl); /* anchor new closure in stack */ + for (i = 0; i < nup; i++) { /* fill in its upvalues */ + if (uv[i].instack) /* upvalue refers to local variable? */ + ncl->l.upvals[i] = luaF_findupval(L, base + uv[i].idx); + else /* get upvalue from enclosing function */ + ncl->l.upvals[i] = encup[uv[i].idx]; + } + luaC_barrierproto(L, p, ncl); + p->cache = ncl; /* save it on cache for reuse */ +} + + +/* +** finish execution of an opcode interrupted by an yield +*/ +void luaV_finishOp (lua_State *L) { + CallInfo *ci = L->ci; + StkId base = ci->u.l.base; + Instruction inst = *(ci->u.l.savedpc - 1); /* interrupted instruction */ + OpCode op = GET_OPCODE(inst); + switch (op) { /* finish its execution */ + case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: + case OP_MOD: case OP_POW: case OP_UNM: case OP_LEN: + case OP_GETTABUP: case OP_GETTABLE: case OP_SELF: { + setobjs2s(L, base + GETARG_A(inst), --L->top); + break; + } + case OP_LE: case OP_LT: case OP_EQ: { + int res = !l_isfalse(L->top - 1); + L->top--; + /* metamethod should not be called when operand is K */ + lua_assert(!ISK(GETARG_B(inst))); + if (op == OP_LE && /* "<=" using "<" instead? */ + ttisnil(luaT_gettmbyobj(L, base + GETARG_B(inst), TM_LE))) + res = !res; /* invert result */ + lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_JMP); + if (res != GETARG_A(inst)) /* condition failed? */ + ci->u.l.savedpc++; /* skip jump instruction */ + break; + } + case OP_CONCAT: { + StkId top = L->top - 1; /* top when 'call_binTM' was called */ + int b = GETARG_B(inst); /* first element to concatenate */ + int total = cast_int(top - 1 - (base + b)); /* yet to concatenate */ + setobj2s(L, top - 2, top); /* put TM result in proper position */ + if (total > 1) { /* are there elements to concat? */ + L->top = top - 1; /* top is one after last element (at top-2) */ + luaV_concat(L, total); /* concat them (may yield again) */ + } + /* move final result to final position */ + setobj2s(L, ci->u.l.base + GETARG_A(inst), L->top - 1); + L->top = ci->top; /* restore top */ + break; + } + case OP_TFORCALL: { + lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_TFORLOOP); + L->top = ci->top; /* correct top */ + break; + } + case OP_CALL: { + if (GETARG_C(inst) - 1 >= 0) /* nresults >= 0? */ + L->top = ci->top; /* adjust results */ + break; + } + case OP_TAILCALL: case OP_SETTABUP: case OP_SETTABLE: + break; + default: lua_assert(0); + } +} + + + +/* +** some macros for common tasks in `luaV_execute' +*/ + +#if !defined luai_runtimecheck +#define luai_runtimecheck(L, c) /* void */ +#endif + + +#define RA(i) (base+GETARG_A(i)) +/* to be used after possible stack reallocation */ +#define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i)) +#define RC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i)) +#define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \ + ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i)) +#define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \ + ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i)) +#define KBx(i) \ + (k + (GETARG_Bx(i) != 0 ? GETARG_Bx(i) - 1 : GETARG_Ax(*ci->u.l.savedpc++))) + + +/* execute a jump instruction */ +#define dojump(ci,i,e) \ + { int a = GETARG_A(i); \ + if (a > 0) luaF_close(L, ci->u.l.base + a - 1); \ + ci->u.l.savedpc += GETARG_sBx(i) + e; } + +/* for test instructions, execute the jump instruction that follows it */ +#define donextjump(ci) { i = *ci->u.l.savedpc; dojump(ci, i, 1); } + + +#define Protect(x) { {x;}; base = ci->u.l.base; } + +#define checkGC(L,c) \ + Protect( luaC_condGC(L,{L->top = (c); /* limit of live values */ \ + luaC_step(L); \ + L->top = ci->top;}) /* restore top */ \ + luai_threadyield(L); ) + + +#define arith_op(op,tm) { \ + TValue *rb = RKB(i); \ + TValue *rc = RKC(i); \ + if (ttisnumber(rb) && ttisnumber(rc)) { \ + lua_Number nb = nvalue(rb), nc = nvalue(rc); \ + setnvalue(ra, op(L, nb, nc)); \ + } \ + else { Protect(luaV_arith(L, ra, rb, rc, tm)); } } + + +#define vmdispatch(o) switch(o) +#define vmcase(l,b) case l: {b} break; +#define vmcasenb(l,b) case l: {b} /* nb = no break */ + +void luaV_execute (lua_State *L) { + CallInfo *ci = L->ci; + LClosure *cl; + TValue *k; + StkId base; + newframe: /* reentry point when frame changes (call/return) */ + lua_assert(ci == L->ci); + cl = clLvalue(ci->func); + k = cl->p->k; + base = ci->u.l.base; + /* main loop of interpreter */ + for (;;) { + Instruction i = *(ci->u.l.savedpc++); + StkId ra; + if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) && + (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) { + Protect(traceexec(L)); + } + /* WARNING: several calls may realloc the stack and invalidate `ra' */ + ra = RA(i); + lua_assert(base == ci->u.l.base); + lua_assert(base <= L->top && L->top < L->stack + L->stacksize); + vmdispatch (GET_OPCODE(i)) { + vmcase(OP_MOVE, + setobjs2s(L, ra, RB(i)); + ) + vmcase(OP_LOADK, + TValue *rb = k + GETARG_Bx(i); + setobj2s(L, ra, rb); + ) + vmcase(OP_LOADKX, + TValue *rb; + lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG); + rb = k + GETARG_Ax(*ci->u.l.savedpc++); + setobj2s(L, ra, rb); + ) + vmcase(OP_LOADBOOL, + setbvalue(ra, GETARG_B(i)); + if (GETARG_C(i)) ci->u.l.savedpc++; /* skip next instruction (if C) */ + ) + vmcase(OP_LOADNIL, + int b = GETARG_B(i); + do { + setnilvalue(ra++); + } while (b--); + ) + vmcase(OP_GETUPVAL, + int b = GETARG_B(i); + setobj2s(L, ra, cl->upvals[b]->v); + ) + vmcase(OP_GETTABUP, + int b = GETARG_B(i); + Protect(luaV_gettable(L, cl->upvals[b]->v, RKC(i), ra)); + ) + vmcase(OP_GETTABLE, + Protect(luaV_gettable(L, RB(i), RKC(i), ra)); + ) + vmcase(OP_SETTABUP, + int a = GETARG_A(i); + Protect(luaV_settable(L, cl->upvals[a]->v, RKB(i), RKC(i))); + ) + vmcase(OP_SETUPVAL, + UpVal *uv = cl->upvals[GETARG_B(i)]; + setobj(L, uv->v, ra); + luaC_barrier(L, uv, ra); + ) + vmcase(OP_SETTABLE, + Protect(luaV_settable(L, ra, RKB(i), RKC(i))); + ) + vmcase(OP_NEWTABLE, + int b = GETARG_B(i); + int c = GETARG_C(i); + Table *t = luaH_new(L); + sethvalue(L, ra, t); + if (b != 0 || c != 0) + luaH_resize(L, t, luaO_fb2int(b), luaO_fb2int(c)); + checkGC(L, ra + 1); + ) + vmcase(OP_SELF, + StkId rb = RB(i); + setobjs2s(L, ra+1, rb); + Protect(luaV_gettable(L, rb, RKC(i), ra)); + ) + vmcase(OP_ADD, + arith_op(luai_numadd, TM_ADD); + ) + vmcase(OP_SUB, + arith_op(luai_numsub, TM_SUB); + ) + vmcase(OP_MUL, + arith_op(luai_nummul, TM_MUL); + ) + vmcase(OP_DIV, + arith_op(luai_numdiv, TM_DIV); + ) + vmcase(OP_MOD, + arith_op(luai_nummod, TM_MOD); + ) + vmcase(OP_POW, + arith_op(luai_numpow, TM_POW); + ) + vmcase(OP_UNM, + TValue *rb = RB(i); + if (ttisnumber(rb)) { + lua_Number nb = nvalue(rb); + setnvalue(ra, luai_numunm(L, nb)); + } + else { + Protect(luaV_arith(L, ra, rb, rb, TM_UNM)); + } + ) + vmcase(OP_NOT, + TValue *rb = RB(i); + int res = l_isfalse(rb); /* next assignment may change this value */ + setbvalue(ra, res); + ) + vmcase(OP_LEN, + Protect(luaV_objlen(L, ra, RB(i))); + ) + vmcase(OP_CONCAT, + int b = GETARG_B(i); + int c = GETARG_C(i); + StkId rb; + L->top = base + c + 1; /* mark the end of concat operands */ + Protect(luaV_concat(L, c - b + 1)); + ra = RA(i); /* 'luav_concat' may invoke TMs and move the stack */ + rb = b + base; + setobjs2s(L, ra, rb); + checkGC(L, (ra >= rb ? ra + 1 : rb)); + L->top = ci->top; /* restore top */ + ) + vmcase(OP_JMP, + dojump(ci, i, 0); + ) + vmcase(OP_EQ, + TValue *rb = RKB(i); + TValue *rc = RKC(i); + Protect( + if (cast_int(equalobj(L, rb, rc)) != GETARG_A(i)) + ci->u.l.savedpc++; + else + donextjump(ci); + ) + ) + vmcase(OP_LT, + Protect( + if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i)) + ci->u.l.savedpc++; + else + donextjump(ci); + ) + ) + vmcase(OP_LE, + Protect( + if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) + ci->u.l.savedpc++; + else + donextjump(ci); + ) + ) + vmcase(OP_TEST, + if (GETARG_C(i) ? l_isfalse(ra) : !l_isfalse(ra)) + ci->u.l.savedpc++; + else + donextjump(ci); + ) + vmcase(OP_TESTSET, + TValue *rb = RB(i); + if (GETARG_C(i) ? l_isfalse(rb) : !l_isfalse(rb)) + ci->u.l.savedpc++; + else { + setobjs2s(L, ra, rb); + donextjump(ci); + } + ) + vmcase(OP_CALL, + int b = GETARG_B(i); + int nresults = GETARG_C(i) - 1; + if (b != 0) L->top = ra+b; /* else previous instruction set top */ + if (luaD_precall(L, ra, nresults)) { /* C function? */ + if (nresults >= 0) L->top = ci->top; /* adjust results */ + base = ci->u.l.base; + } + else { /* Lua function */ + ci = L->ci; + ci->callstatus |= CIST_REENTRY; + goto newframe; /* restart luaV_execute over new Lua function */ + } + ) + vmcase(OP_TAILCALL, + int b = GETARG_B(i); + if (b != 0) L->top = ra+b; /* else previous instruction set top */ + lua_assert(GETARG_C(i) - 1 == LUA_MULTRET); + if (luaD_precall(L, ra, LUA_MULTRET)) /* C function? */ + base = ci->u.l.base; + else { + /* tail call: put called frame (n) in place of caller one (o) */ + CallInfo *nci = L->ci; /* called frame */ + CallInfo *oci = nci->previous; /* caller frame */ + StkId nfunc = nci->func; /* called function */ + StkId ofunc = oci->func; /* caller function */ + /* last stack slot filled by 'precall' */ + StkId lim = nci->u.l.base + getproto(nfunc)->numparams; + int aux; + /* close all upvalues from previous call */ + if (cl->p->sizep > 0) luaF_close(L, oci->u.l.base); + /* move new frame into old one */ + for (aux = 0; nfunc + aux < lim; aux++) + setobjs2s(L, ofunc + aux, nfunc + aux); + oci->u.l.base = ofunc + (nci->u.l.base - nfunc); /* correct base */ + oci->top = L->top = ofunc + (L->top - nfunc); /* correct top */ + oci->u.l.savedpc = nci->u.l.savedpc; + oci->callstatus |= CIST_TAIL; /* function was tail called */ + ci = L->ci = oci; /* remove new frame */ + lua_assert(L->top == oci->u.l.base + getproto(ofunc)->maxstacksize); + goto newframe; /* restart luaV_execute over new Lua function */ + } + ) + vmcasenb(OP_RETURN, + int b = GETARG_B(i); + if (b != 0) L->top = ra+b-1; + if (cl->p->sizep > 0) luaF_close(L, base); + b = luaD_poscall(L, ra); + if (!(ci->callstatus & CIST_REENTRY)) /* 'ci' still the called one */ + return; /* external invocation: return */ + else { /* invocation via reentry: continue execution */ + ci = L->ci; + if (b) L->top = ci->top; + lua_assert(isLua(ci)); + lua_assert(GET_OPCODE(*((ci)->u.l.savedpc - 1)) == OP_CALL); + goto newframe; /* restart luaV_execute over new Lua function */ + } + ) + vmcase(OP_FORLOOP, + lua_Number step = nvalue(ra+2); + lua_Number idx = luai_numadd(L, nvalue(ra), step); /* increment index */ + lua_Number limit = nvalue(ra+1); + if (luai_numlt(L, 0, step) ? luai_numle(L, idx, limit) + : luai_numle(L, limit, idx)) { + ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ + setnvalue(ra, idx); /* update internal index... */ + setnvalue(ra+3, idx); /* ...and external index */ + } + ) + vmcase(OP_FORPREP, + const TValue *init = ra; + const TValue *plimit = ra+1; + const TValue *pstep = ra+2; + if (!tonumber(init, ra)) + luaG_runerror(L, LUA_QL("for") " initial value must be a number"); + else if (!tonumber(plimit, ra+1)) + luaG_runerror(L, LUA_QL("for") " limit must be a number"); + else if (!tonumber(pstep, ra+2)) + luaG_runerror(L, LUA_QL("for") " step must be a number"); + setnvalue(ra, luai_numsub(L, nvalue(ra), nvalue(pstep))); + ci->u.l.savedpc += GETARG_sBx(i); + ) + vmcasenb(OP_TFORCALL, + StkId cb = ra + 3; /* call base */ + setobjs2s(L, cb+2, ra+2); + setobjs2s(L, cb+1, ra+1); + setobjs2s(L, cb, ra); + L->top = cb + 3; /* func. + 2 args (state and index) */ + Protect(luaD_call(L, cb, GETARG_C(i), 1)); + L->top = ci->top; + i = *(ci->u.l.savedpc++); /* go to next instruction */ + ra = RA(i); + lua_assert(GET_OPCODE(i) == OP_TFORLOOP); + goto l_tforloop; + ) + vmcase(OP_TFORLOOP, + l_tforloop: + if (!ttisnil(ra + 1)) { /* continue loop? */ + setobjs2s(L, ra, ra + 1); /* save control variable */ + ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ + } + ) + vmcase(OP_SETLIST, + int n = GETARG_B(i); + int c = GETARG_C(i); + int last; + Table *h; + if (n == 0) n = cast_int(L->top - ra) - 1; + if (c == 0) { + lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG); + c = GETARG_Ax(*ci->u.l.savedpc++); + } + luai_runtimecheck(L, ttistable(ra)); + h = hvalue(ra); + last = ((c-1)*LFIELDS_PER_FLUSH) + n; + if (last > h->sizearray) /* needs more space? */ + luaH_resizearray(L, h, last); /* pre-allocate it at once */ + for (; n > 0; n--) { + TValue *val = ra+n; + luaH_setint(L, h, last--, val); + luaC_barrierback(L, obj2gco(h), val); + } + L->top = ci->top; /* correct top (in case of previous open call) */ + ) + vmcase(OP_CLOSURE, + Proto *p = cl->p->p[GETARG_Bx(i)]; + Closure *ncl = getcached(p, cl->upvals, base); /* cached closure */ + if (ncl == NULL) /* no match? */ + pushclosure(L, p, cl->upvals, base, ra); /* create a new one */ + else + setclLvalue(L, ra, ncl); /* push cashed closure */ + checkGC(L, ra + 1); + ) + vmcase(OP_VARARG, + int b = GETARG_B(i) - 1; + int j; + int n = cast_int(base - ci->func) - cl->p->numparams - 1; + if (b < 0) { /* B == 0? */ + b = n; /* get all var. arguments */ + Protect(luaD_checkstack(L, n)); + ra = RA(i); /* previous call may change the stack */ + L->top = ra + n; + } + for (j = 0; j < b; j++) { + if (j < n) { + setobjs2s(L, ra + j, base - n + j); + } + else { + setnilvalue(ra + j); + } + } + ) + vmcase(OP_EXTRAARG, + lua_assert(0); + ) + } + } +} + diff --git a/extern/lua/src/lvm.h b/extern/lua/src/lvm.h new file mode 100644 index 0000000..5380270 --- /dev/null +++ b/extern/lua/src/lvm.h @@ -0,0 +1,44 @@ +/* +** $Id: lvm.h,v 2.18.1.1 2013/04/12 18:48:47 roberto Exp $ +** Lua virtual machine +** See Copyright Notice in lua.h +*/ + +#ifndef lvm_h +#define lvm_h + + +#include "ldo.h" +#include "lobject.h" +#include "ltm.h" + + +#define tostring(L,o) (ttisstring(o) || (luaV_tostring(L, o))) + +#define tonumber(o,n) (ttisnumber(o) || (((o) = luaV_tonumber(o,n)) != NULL)) + +#define equalobj(L,o1,o2) (ttisequal(o1, o2) && luaV_equalobj_(L, o1, o2)) + +#define luaV_rawequalobj(o1,o2) equalobj(NULL,o1,o2) + + +/* not to called directly */ +LUAI_FUNC int luaV_equalobj_ (lua_State *L, const TValue *t1, const TValue *t2); + + +LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r); +LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r); +LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n); +LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj); +LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key, + StkId val); +LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key, + StkId val); +LUAI_FUNC void luaV_finishOp (lua_State *L); +LUAI_FUNC void luaV_execute (lua_State *L); +LUAI_FUNC void luaV_concat (lua_State *L, int total); +LUAI_FUNC void luaV_arith (lua_State *L, StkId ra, const TValue *rb, + const TValue *rc, TMS op); +LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb); + +#endif diff --git a/extern/lua/src/lvm.o b/extern/lua/src/lvm.o new file mode 100644 index 0000000000000000000000000000000000000000..c45d69fcbf04a194406aba1e22e502bc7beca222 GIT binary patch literal 20840 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 + +#define lzio_c +#define LUA_CORE + +#include "lua.h" + +#include "llimits.h" +#include "lmem.h" +#include "lstate.h" +#include "lzio.h" + + +int luaZ_fill (ZIO *z) { + size_t size; + lua_State *L = z->L; + const char *buff; + lua_unlock(L); + buff = z->reader(L, z->data, &size); + lua_lock(L); + if (buff == NULL || size == 0) + return EOZ; + z->n = size - 1; /* discount char being returned */ + z->p = buff; + return cast_uchar(*(z->p++)); +} + + +void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) { + z->L = L; + z->reader = reader; + z->data = data; + z->n = 0; + z->p = NULL; +} + + +/* --------------------------------------------------------------- read --- */ +size_t luaZ_read (ZIO *z, void *b, size_t n) { + while (n) { + size_t m; + if (z->n == 0) { /* no bytes in buffer? */ + if (luaZ_fill(z) == EOZ) /* try to read more */ + return n; /* no more input; return number of missing bytes */ + else { + z->n++; /* luaZ_fill consumed first byte; put it back */ + z->p--; + } + } + m = (n <= z->n) ? n : z->n; /* min. between n and z->n */ + memcpy(b, z->p, m); + z->n -= m; + z->p += m; + b = (char *)b + m; + n -= m; + } + return 0; +} + +/* ------------------------------------------------------------------------ */ +char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) { + if (n > buff->buffsize) { + if (n < LUA_MINBUFFER) n = LUA_MINBUFFER; + luaZ_resizebuffer(L, buff, n); + } + return buff->buffer; +} + + diff --git a/extern/lua/src/lzio.h b/extern/lua/src/lzio.h new file mode 100644 index 0000000..441f747 --- /dev/null +++ b/extern/lua/src/lzio.h @@ -0,0 +1,65 @@ +/* +** $Id: lzio.h,v 1.26.1.1 2013/04/12 18:48:47 roberto Exp $ +** Buffered streams +** See Copyright Notice in lua.h +*/ + + +#ifndef lzio_h +#define lzio_h + +#include "lua.h" + +#include "lmem.h" + + +#define EOZ (-1) /* end of stream */ + +typedef struct Zio ZIO; + +#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) + + +typedef struct Mbuffer { + char *buffer; + size_t n; + size_t buffsize; +} Mbuffer; + +#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0) + +#define luaZ_buffer(buff) ((buff)->buffer) +#define luaZ_sizebuffer(buff) ((buff)->buffsize) +#define luaZ_bufflen(buff) ((buff)->n) + +#define luaZ_resetbuffer(buff) ((buff)->n = 0) + + +#define luaZ_resizebuffer(L, buff, size) \ + (luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \ + (buff)->buffsize = size) + +#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) + + +LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n); +LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, + void *data); +LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n); /* read next n bytes */ + + + +/* --------- Private Part ------------------ */ + +struct Zio { + size_t n; /* bytes still unread */ + const char *p; /* current position in buffer */ + lua_Reader reader; /* reader function */ + void* data; /* additional data */ + lua_State *L; /* Lua state (for reader) */ +}; + + +LUAI_FUNC int luaZ_fill (ZIO *z); + +#endif diff --git a/extern/lua/src/lzio.o b/extern/lua/src/lzio.o new file mode 100644 index 0000000000000000000000000000000000000000..37000479d4a5423c2fa1154e54fb13942af089cb GIT binary patch literal 2280 zcmbuA-D@0G6u|H7r0tlkv(xIsO2rKL!3NBbl?ui$cC*{=*%C`IN&QIUI@wOllGzWl zv!>~T6~+{YaUp+!_@Ll};F}1(6jBI^fucUB4}QF9(;^B&p~`yB%)OiGWChU!cka2r zbIv{I-aB{Z;)$t~2}xo?B=$7h8wtvoChzIFK+Ul`*)W>{?-sb%HSpKc;9u0CJNtmr zo6%t7vU5N9IDm~WoqNE&CV_Vsbf>YKQBof>aIa|dTbrNsP;`yescKB-W@l^V&h{9Jyv?0r2qgGqy_8(2Wu`vd&cZZ7Z32XtFK z@Y>4mhyD88D@ykA{6hY0egO-jWhhhLj~py*VqxA_fb~#$KCWZpyY>^{-WqxBLFg7F zaBu##_9*xr2Hv+}UET@Q7c`n^eqrlV9gE%les4eggWM8$vr?h(xSlCmi#4;MA2%k9 z>{#~rXsFRL@1_Tebm3Vho!6vehYu;6c%VA6d&z)OqDNlU+(b#$JHx7$SCz>mo-yJa z*-(TppgtQA#@?ZRQq{VNNj3epTvYW-LwPmh9w@5giM3%hQ&9E1nnsUFRVgNmY6e~U zfU(Cg{9T#@r9uy^;Zgz}T=|r$zdEd@5nwI(v3FL(epzU%mTel2 zb>3mdInyzjvDj|202rNyU0bp2b!JqX^}5wSmqydEjMC}3v9@DYSC|n*Tg#QDRkLn| zx&Fsf$5^^Q!J8YIC&%?>>~hhbN97m}hOp(L5cP}_f|ohR;|lU{%+j1c#Chbp29}Rv zdAa+(yZ$g5XwLr{pT*cg>;Jd;b3A?=`>2Tc`=Stau`JP-BP{B=BOIb|fbUD3C1QS8 zdHgpqF7{vG7f=~=es2vpKSCm2oZk^-@x7L9o{c8JFp)jkr^*O zW|jM^zuh43yS?E)9Zl@5Hu#2O*imZ8r}-4(yGcFq7U#jY6Lq?u@jFj0W7x=F<0*pg zBeEy4X#)=Q)IV@$U#K;WDziK0ic{X)ZGtGo>D>|hDZUQkYJ{&ucq+nm)Je#n Wnvfz_1Q+}Ke2j~IelNzwe*O(otsvb1 literal 0 HcmV?d00001 diff --git a/extern/luabridge/LuaBridge.h b/extern/luabridge/LuaBridge.h new file mode 100644 index 0000000..1928e9a --- /dev/null +++ b/extern/luabridge/LuaBridge.h @@ -0,0 +1,142 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + Copyright 2007, Nathan Reed + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +#ifndef LUABRIDGE_LUABRIDGE_HEADER +#define LUABRIDGE_LUABRIDGE_HEADER + +// All #include dependencies are listed here +// instead of in the individual header files. +// +#include +#include +#include +#include +#include + +#define LUABRIDGE_MAJOR_VERSION 2 +#define LUABRIDGE_MINOR_VERSION 0 +#define LUABRIDGE_VERSION 200 + +namespace luabridge +{ + +// Forward declaration +// +template +struct Stack; + +#include "detail/LuaHelpers.h" + +#include "detail/TypeTraits.h" +#include "detail/TypeList.h" +#include "detail/FuncTraits.h" +#include "detail/Constructor.h" +#include "detail/Stack.h" +#include "detail/ClassInfo.h" + +class LuaRef; + +#include "detail/LuaException.h" +#include "detail/LuaRef.h" +#include "detail/Iterator.h" + +//------------------------------------------------------------------------------ +/** + security options. +*/ +class Security +{ +public: + static bool hideMetatables () + { + return getSettings().hideMetatables; + } + + static void setHideMetatables (bool shouldHide) + { + getSettings().hideMetatables = shouldHide; + } + +private: + struct Settings + { + Settings () : hideMetatables (true) + { + } + + bool hideMetatables; + }; + + static Settings& getSettings () + { + static Settings settings; + return settings; + } +}; + +#include "detail/Userdata.h" +#include "detail/CFunctions.h" +#include "detail/Namespace.h" + +//------------------------------------------------------------------------------ +/** + Push an object onto the Lua stack. +*/ +template +inline void push (lua_State* L, T t) +{ + Stack ::push (L, t); +} + +//------------------------------------------------------------------------------ +/** + Set a global value in the lua_State. + + @note This works on any type specialized by `Stack`, including `LuaRef` and + its table proxies. +*/ +template +inline void setGlobal (lua_State* L, T t, char const* name) +{ + push (L, t); + lua_setglobal (L, name); +} + +//------------------------------------------------------------------------------ +/** + Change whether or not metatables are hidden (on by default). +*/ +inline void setHideMetatables (bool shouldHide) +{ + Security::setHideMetatables (shouldHide); +} + +} + +#endif diff --git a/extern/luabridge/RefCountedObject.h b/extern/luabridge/RefCountedObject.h new file mode 100644 index 0000000..807b460 --- /dev/null +++ b/extern/luabridge/RefCountedObject.h @@ -0,0 +1,363 @@ +//============================================================================== +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + Copyright 2004-11 by Raw Material Software Ltd. + + This is a derivative work used by permission from part of + JUCE, available at http://www.rawaterialsoftware.com + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + + This file incorporates work covered by the following copyright and + permission notice: + + This file is part of the JUCE library - "Jules' Utility Class Extensions" + Copyright 2004-11 by Raw Material Software Ltd. +*/ +//============================================================================== + +#ifndef LUABRIDGE_REFCOUNTEDOBJECT_HEADER +#define LUABRIDGE_REFCOUNTEDOBJECT_HEADER + +//#define LUABRIDGE_COMPILER_SUPPORTS_MOVE_SEMANTICS 1 + +#include + +//============================================================================== +/** + Adds reference-counting to an object. + + To add reference-counting to a class, derive it from this class, and + use the RefCountedObjectPtr class to point to it. + + e.g. @code + class MyClass : public RefCountedObjectType + { + void foo(); + + // This is a neat way of declaring a typedef for a pointer class, + // rather than typing out the full templated name each time.. + typedef RefCountedObjectPtr Ptr; + }; + + MyClass::Ptr p = new MyClass(); + MyClass::Ptr p2 = p; + p = 0; + p2->foo(); + @endcode + + Once a new RefCountedObjectType has been assigned to a pointer, be + careful not to delete the object manually. +*/ +template +class RefCountedObjectType +{ +public: + //============================================================================== + /** Increments the object's reference count. + + This is done automatically by the smart pointer, but is public just + in case it's needed for nefarious purposes. + */ + inline void incReferenceCount() const + { + ++refCount; + } + + /** Decreases the object's reference count. + + If the count gets to zero, the object will be deleted. + */ + inline void decReferenceCount() const + { + assert (getReferenceCount() > 0); + + if (--refCount == 0) + delete this; + } + + /** Returns the object's current reference count. */ + inline int getReferenceCount() const + { + return static_cast (refCount); + } + +protected: + //============================================================================== + /** Creates the reference-counted object (with an initial ref count of zero). */ + RefCountedObjectType() : refCount () + { + } + + /** Destructor. */ + virtual ~RefCountedObjectType() + { + // it's dangerous to delete an object that's still referenced by something else! + assert (getReferenceCount() == 0); + } + +private: + //============================================================================== + CounterType mutable refCount; +}; + +//============================================================================== + +/** Non thread-safe reference counted object. + + This creates a RefCountedObjectType that uses a non-atomic integer + as the counter. +*/ +typedef RefCountedObjectType RefCountedObject; + +//============================================================================== +/** + A smart-pointer class which points to a reference-counted object. + + The template parameter specifies the class of the object you want to point + to - the easiest way to make a class reference-countable is to simply make + it inherit from RefCountedObjectType, but if you need to, you could roll + your own reference-countable class by implementing a pair of methods called + incReferenceCount() and decReferenceCount(). + + When using this class, you'll probably want to create a typedef to + abbreviate the full templated name - e.g. + + @code + + typedef RefCountedObjectPtr MyClassPtr; + + @endcode +*/ +template +class RefCountedObjectPtr +{ +public: + /** The class being referenced by this pointer. */ + typedef ReferenceCountedObjectClass ReferencedType; + + //============================================================================== + /** Creates a pointer to a null object. */ + inline RefCountedObjectPtr() : referencedObject (0) + { + } + + /** Creates a pointer to an object. + + This will increment the object's reference-count if it is non-null. + */ + inline RefCountedObjectPtr (ReferenceCountedObjectClass* const refCountedObject) + : referencedObject (refCountedObject) + { + if (refCountedObject != 0) + refCountedObject->incReferenceCount(); + } + + /** Copies another pointer. + This will increment the object's reference-count (if it is non-null). + */ + inline RefCountedObjectPtr (const RefCountedObjectPtr& other) + : referencedObject (other.referencedObject) + { + if (referencedObject != 0) + referencedObject->incReferenceCount(); + } + +#if LUABRIDGE_COMPILER_SUPPORTS_MOVE_SEMANTICS + /** Takes-over the object from another pointer. */ + inline RefCountedObjectPtr (RefCountedObjectPtr&& other) + : referencedObject (other.referencedObject) + { + other.referencedObject = 0; + } +#endif + + /** Copies another pointer. + This will increment the object's reference-count (if it is non-null). + */ + template + inline RefCountedObjectPtr (const RefCountedObjectPtr& other) + : referencedObject (static_cast (other.getObject())) + { + if (referencedObject != 0) + referencedObject->incReferenceCount(); + } + + /** Changes this pointer to point at a different object. + + The reference count of the old object is decremented, and it might be + deleted if it hits zero. The new object's count is incremented. + */ + RefCountedObjectPtr& operator= (const RefCountedObjectPtr& other) + { + return operator= (other.referencedObject); + } + + /** Changes this pointer to point at a different object. + + The reference count of the old object is decremented, and it might be + deleted if it hits zero. The new object's count is incremented. + */ + template + RefCountedObjectPtr& operator= (const RefCountedObjectPtr& other) + { + return operator= (static_cast (other.getObject())); + } + +#if LUABRIDGE_COMPILER_SUPPORTS_MOVE_SEMANTICS + /** Takes-over the object from another pointer. */ + RefCountedObjectPtr& operator= (RefCountedObjectPtr&& other) + { + std::swap (referencedObject, other.referencedObject); + return *this; + } +#endif + + /** Changes this pointer to point at a different object. + + The reference count of the old object is decremented, and it might be + deleted if it hits zero. The new object's count is incremented. + */ + RefCountedObjectPtr& operator= (ReferenceCountedObjectClass* const newObject) + { + if (referencedObject != newObject) + { + if (newObject != 0) + newObject->incReferenceCount(); + + ReferenceCountedObjectClass* const oldObject = referencedObject; + referencedObject = newObject; + + if (oldObject != 0) + oldObject->decReferenceCount(); + } + + return *this; + } + + /** Destructor. + + This will decrement the object's reference-count, and may delete it if it + gets to zero. + */ + inline ~RefCountedObjectPtr() + { + if (referencedObject != 0) + referencedObject->decReferenceCount(); + } + + /** Returns the object that this pointer references. + The pointer returned may be zero, of course. + */ + inline operator ReferenceCountedObjectClass*() const + { + return referencedObject; + } + + // the -> operator is called on the referenced object + inline ReferenceCountedObjectClass* operator->() const + { + return referencedObject; + } + + /** Returns the object that this pointer references. + The pointer returned may be zero, of course. + */ + inline ReferenceCountedObjectClass* getObject() const + { + return referencedObject; + } + +private: + //============================================================================== + ReferenceCountedObjectClass* referencedObject; +}; + +/** Compares two ReferenceCountedObjectPointers. */ +template +bool operator== (const RefCountedObjectPtr& object1, ReferenceCountedObjectClass* const object2) +{ + return object1.getObject() == object2; +} + +/** Compares two ReferenceCountedObjectPointers. */ +template +bool operator== (const RefCountedObjectPtr& object1, const RefCountedObjectPtr& object2) +{ + return object1.getObject() == object2.getObject(); +} + +/** Compares two ReferenceCountedObjectPointers. */ +template +bool operator== (ReferenceCountedObjectClass* object1, RefCountedObjectPtr& object2) +{ + return object1 == object2.getObject(); +} + +/** Compares two ReferenceCountedObjectPointers. */ +template +bool operator!= (const RefCountedObjectPtr& object1, const ReferenceCountedObjectClass* object2) +{ + return object1.getObject() != object2; +} + +/** Compares two ReferenceCountedObjectPointers. */ +template +bool operator!= (const RefCountedObjectPtr& object1, RefCountedObjectPtr& object2) +{ + return object1.getObject() != object2.getObject(); +} + +/** Compares two ReferenceCountedObjectPointers. */ +template +bool operator!= (ReferenceCountedObjectClass* object1, RefCountedObjectPtr& object2) +{ + return object1 != object2.getObject(); +} + +//============================================================================== + +namespace luabridge +{ + +// forward declaration +template +struct ContainerTraits; + +template +struct ContainerTraits > +{ + typedef T Type; + + static T* get (RefCountedObjectPtr const& c) + { + return c.getObject (); + } +}; + +} + +//============================================================================== + +#endif + diff --git a/extern/luabridge/RefCountedPtr.h b/extern/luabridge/RefCountedPtr.h new file mode 100644 index 0000000..7c27ca4 --- /dev/null +++ b/extern/luabridge/RefCountedPtr.h @@ -0,0 +1,251 @@ +//============================================================================== +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + Copyright 2007, Nathan Reed + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +#ifndef LUABRIDGE_REFCOUNTEDPTR_HEADER +#define LUABRIDGE_REFCOUNTEDPTR_HEADER + +#ifdef _MSC_VER +# include +#else +# include +# include +#endif + +//============================================================================== +/** + Support for our RefCountedPtr. +*/ +struct RefCountedPtrBase +{ + // Declaration of container for the refcounts +#ifdef _MSC_VER + typedef stdext::hash_map RefCountsType; +#else + struct ptr_hash + { + size_t operator () (const void * const v) const + { + static __gnu_cxx::hash H; + return H(uintptr_t(v)); + } + }; + typedef __gnu_cxx::hash_map RefCountsType; +#endif + +protected: + inline RefCountsType& getRefCounts () + { + static RefCountsType refcounts; + return refcounts ; + } +}; + +//============================================================================== +/** + A reference counted smart pointer. + + The api is compatible with boost::RefCountedPtr and std::RefCountedPtr, in the + sense that it implements a strict subset of the functionality. + + This implementation uses a hash table to look up the reference count + associated with a particular pointer. + + @tparam T The class type. + + @todo Decompose RefCountedPtr using a policy. At a minimum, the underlying + reference count should be policy based (to support atomic operations) + and the delete behavior should be policy based (to support custom + disposal methods). + + @todo Provide an intrusive version of RefCountedPtr. +*/ +template +class RefCountedPtr : private RefCountedPtrBase +{ +public: + template + struct rebind + { + typedef RefCountedPtr other; + }; + + /** Construct as nullptr or from existing pointer to T. + + @param p The optional, existing pointer to assign from. + */ + RefCountedPtr (T* p = 0) : m_p (p) + { + ++getRefCounts () [m_p]; + } + + /** Construct from another RefCountedPtr. + + @param rhs The RefCountedPtr to assign from. + */ + RefCountedPtr (RefCountedPtr const& rhs) : m_p (rhs.get()) + { + ++getRefCounts () [m_p]; + } + + /** Construct from a RefCountedPtr of a different type. + + @invariant A pointer to U must be convertible to a pointer to T. + + @param rhs The RefCountedPtr to assign from. + @tparam U The other object type. + */ + template + RefCountedPtr (RefCountedPtr const& rhs) : m_p (static_cast (rhs.get())) + { + ++getRefCounts () [m_p]; + } + + /** Release the object. + + If there are no more references then the object is deleted. + */ + ~RefCountedPtr () + { + reset(); + } + + /** Assign from another RefCountedPtr. + + @param rhs The RefCountedPtr to assign from. + @return A reference to the RefCountedPtr. + */ + RefCountedPtr & operator= (RefCountedPtr const& rhs) + { + if (m_p != rhs.m_p) + { + reset (); + m_p = rhs.m_p; + ++getRefCounts () [m_p]; + } + return *this; + } + + /** Assign from another RefCountedPtr of a different type. + + @note A pointer to U must be convertible to a pointer to T. + + @tparam U The other object type. + @param rhs The other RefCountedPtr to assign from. + @return A reference to the RefCountedPtr. + */ + template + RefCountedPtr & operator= (RefCountedPtr const& rhs) + { + reset (); + m_p = static_cast (rhs.get()); + ++getRefCounts () [m_p]; + return *this; + } + + /** Retrieve the raw pointer. + + @return A pointer to the object. + */ + T* get () const + { + return m_p; + } + + /** Retrieve the raw pointer. + + @return A pointer to the object. + */ + T* operator* () const + { + return m_p; + } + + /** Retrieve the raw pointer. + + @return A pointer to the object. + */ + T* operator-> () const + { + return m_p; + } + + /** Determine the number of references. + + @note This is not thread-safe. + + @return The number of active references. + */ + long use_count () const + { + return getRefCounts () [m_p]; + } + + /** Release the pointer. + + The reference count is decremented. If the reference count reaches + zero, the object is deleted. + */ + void reset () + { + if (m_p != 0) + { + if (--getRefCounts () [m_p] <= 0) + delete m_p; + + m_p = 0; + } + } + +private: + T* m_p; +}; + +//============================================================================== + +namespace luabridge +{ + +// forward declaration +template +struct ContainerTraits; + +template +struct ContainerTraits > +{ + typedef T Type; + + static T* get (RefCountedPtr const& c) + { + return c.get (); + } +}; + +} + +#endif diff --git a/extern/luabridge/detail/CFunctions.h b/extern/luabridge/detail/CFunctions.h new file mode 100644 index 0000000..0497b6b --- /dev/null +++ b/extern/luabridge/detail/CFunctions.h @@ -0,0 +1,442 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +// We use a structure so we can define everything in the header. +// +struct CFunc +{ + //---------------------------------------------------------------------------- + /** + __index metamethod for a namespace or class static members. + + This handles: + Retrieving functions and class static methods, stored in the metatable. + Reading global and class static data, stored in the __propget table. + Reading global and class properties, stored in the __propget table. + */ + static int indexMetaMethod (lua_State* L) + { + int result = 0; + lua_getmetatable (L, 1); // push metatable of arg1 + for (;;) + { + lua_pushvalue (L, 2); // push key arg2 + lua_rawget (L, -2); // lookup key in metatable + if (lua_isnil (L, -1)) // not found + { + lua_pop (L, 1); // discard nil + rawgetfield (L, -1, "__propget"); // lookup __propget in metatable + lua_pushvalue (L, 2); // push key arg2 + lua_rawget (L, -2); // lookup key in __propget + lua_remove (L, -2); // discard __propget + if (lua_iscfunction (L, -1)) + { + lua_remove (L, -2); // discard metatable + lua_pushvalue (L, 1); // push arg1 + lua_call (L, 1, 1); // call cfunction + result = 1; + break; + } + else + { + assert (lua_isnil (L, -1)); + lua_pop (L, 1); // discard nil and fall through + } + } + else + { + assert (lua_istable (L, -1) || lua_iscfunction (L, -1)); + lua_remove (L, -2); + result = 1; + break; + } + + rawgetfield (L, -1, "__parent"); + if (lua_istable (L, -1)) + { + // Remove metatable and repeat the search in __parent. + lua_remove (L, -2); + } + else + { + // Discard metatable and return nil. + assert (lua_isnil (L, -1)); + lua_remove (L, -2); + result = 1; + break; + } + } + + return result; + } + + //---------------------------------------------------------------------------- + /** + __newindex metamethod for a namespace or class static members. + + The __propset table stores proxy functions for assignment to: + Global and class static data. + Global and class properties. + */ + static int newindexMetaMethod (lua_State* L) + { + int result = 0; + lua_getmetatable (L, 1); // push metatable of arg1 + for (;;) + { + rawgetfield (L, -1, "__propset"); // lookup __propset in metatable + assert (lua_istable (L, -1)); + lua_pushvalue (L, 2); // push key arg2 + lua_rawget (L, -2); // lookup key in __propset + lua_remove (L, -2); // discard __propset + if (lua_iscfunction (L, -1)) // ensure value is a cfunction + { + lua_remove (L, -2); // discard metatable + lua_pushvalue (L, 3); // push new value arg3 + lua_call (L, 1, 0); // call cfunction + result = 0; + break; + } + else + { + assert (lua_isnil (L, -1)); + lua_pop (L, 1); + } + + rawgetfield (L, -1, "__parent"); + if (lua_istable (L, -1)) + { + // Remove metatable and repeat the search in __parent. + lua_remove (L, -2); + } + else + { + assert (lua_isnil (L, -1)); + lua_pop (L, 2); + result = luaL_error (L,"no writable variable '%s'", lua_tostring (L, 2)); + } + } + + return result; + } + + //---------------------------------------------------------------------------- + /** + lua_CFunction to report an error writing to a read-only value. + + The name of the variable is in the first upvalue. + */ + static int readOnlyError (lua_State* L) + { + std::string s; + + s = s + "'" + lua_tostring (L, lua_upvalueindex (1)) + "' is read-only"; + + return luaL_error (L, s.c_str ()); + } + + //---------------------------------------------------------------------------- + /** + lua_CFunction to get a variable. + + This is used for global variables or class static data members. + + The pointer to the data is in the first upvalue. + */ + template + static int getVariable (lua_State* L) + { + assert (lua_islightuserdata (L, lua_upvalueindex (1))); + T const* ptr = static_cast (lua_touserdata (L, lua_upvalueindex (1))); + assert (ptr != 0); + Stack ::push (L, *ptr); + return 1; + } + + //---------------------------------------------------------------------------- + /** + lua_CFunction to set a variable. + + This is used for global variables or class static data members. + + The pointer to the data is in the first upvalue. + */ + template + static int setVariable (lua_State* L) + { + assert (lua_islightuserdata (L, lua_upvalueindex (1))); + T* ptr = static_cast (lua_touserdata (L, lua_upvalueindex (1))); + assert (ptr != 0); + *ptr = Stack ::get (L, 1); + return 0; + } + + //---------------------------------------------------------------------------- + /** + lua_CFunction to call a function with a return value. + + This is used for global functions, global properties, class static methods, + and class static properties. + + The function pointer is in the first upvalue. + */ + template ::ReturnType> + struct Call + { + typedef typename FuncTraits ::Params Params; + static int f (lua_State* L) + { + assert (isfulluserdata (L, lua_upvalueindex (1))); + FnPtr const& fnptr = *static_cast (lua_touserdata (L, lua_upvalueindex (1))); + assert (fnptr != 0); + ArgList args (L); + Stack ::ReturnType>::push (L, FuncTraits ::call (fnptr, args)); + return 1; + } + }; + + //---------------------------------------------------------------------------- + /** + lua_CFunction to call a function with no return value. + + This is used for global functions, global properties, class static methods, + and class static properties. + + The function pointer is in the first upvalue. + */ + template + struct Call + { + typedef typename FuncTraits ::Params Params; + static int f (lua_State* L) + { + assert (isfulluserdata (L, lua_upvalueindex (1))); + FnPtr const& fnptr = *static_cast (lua_touserdata (L, lua_upvalueindex (1))); + assert (fnptr != 0); + ArgList args (L); + FuncTraits ::call (fnptr, args); + return 0; + } + }; + + //---------------------------------------------------------------------------- + /** + lua_CFunction to call a class member function with a return value. + + The member function pointer is in the first upvalue. + The class userdata object is at the top of the Lua stack. + */ + template ::ReturnType> + struct CallMember + { + typedef typename FuncTraits ::ClassType T; + typedef typename FuncTraits ::Params Params; + + static int f (lua_State* L) + { + assert (isfulluserdata (L, lua_upvalueindex (1))); + T* const t = Userdata::get (L, 1, false); + MemFnPtr const& fnptr = *static_cast (lua_touserdata (L, lua_upvalueindex (1))); + assert (fnptr != 0); + ArgList args (L); + Stack ::push (L, FuncTraits ::call (t, fnptr, args)); + return 1; + } + }; + + template ::ReturnType> + struct CallConstMember + { + typedef typename FuncTraits ::ClassType T; + typedef typename FuncTraits ::Params Params; + + static int f (lua_State* L) + { + assert (isfulluserdata (L, lua_upvalueindex (1))); + T const* const t = Userdata::get (L, 1, true); + MemFnPtr const& fnptr = *static_cast (lua_touserdata (L, lua_upvalueindex (1))); + assert (fnptr != 0); + ArgList args(L); + Stack ::push (L, FuncTraits ::call (t, fnptr, args)); + return 1; + } + }; + + //---------------------------------------------------------------------------- + /** + lua_CFunction to call a class member function with no return value. + + The member function pointer is in the first upvalue. + The class userdata object is at the top of the Lua stack. + */ + template + struct CallMember + { + typedef typename FuncTraits ::ClassType T; + typedef typename FuncTraits ::Params Params; + + static int f (lua_State* L) + { + assert (isfulluserdata (L, lua_upvalueindex (1))); + T* const t = Userdata::get (L, 1, false); + MemFnPtr const& fnptr = *static_cast (lua_touserdata (L, lua_upvalueindex (1))); + assert (fnptr != 0); + ArgList args (L); + FuncTraits ::call (t, fnptr, args); + return 0; + } + }; + + template + struct CallConstMember + { + typedef typename FuncTraits ::ClassType T; + typedef typename FuncTraits ::Params Params; + + static int f (lua_State* L) + { + assert (isfulluserdata (L, lua_upvalueindex (1))); + T const* const t = Userdata::get (L, 1, true); + MemFnPtr const& fnptr = *static_cast (lua_touserdata (L, lua_upvalueindex (1))); + assert (fnptr != 0); + ArgList args (L); + FuncTraits ::call (t, fnptr, args); + return 0; + } + }; + + //-------------------------------------------------------------------------- + /** + lua_CFunction to call a class member lua_CFunction. + + The member function pointer is in the first upvalue. + The class userdata object is at the top of the Lua stack. + */ + template + struct CallMemberCFunction + { + static int f (lua_State* L) + { + assert (isfulluserdata (L, lua_upvalueindex (1))); + typedef int (T::*MFP)(lua_State* L); + T* const t = Userdata::get (L, 1, false); + MFP const& fnptr = *static_cast (lua_touserdata (L, lua_upvalueindex (1))); + assert (fnptr != 0); + return (t->*fnptr) (L); + } + }; + + template + struct CallConstMemberCFunction + { + static int f (lua_State* L) + { + assert (isfulluserdata (L, lua_upvalueindex (1))); + typedef int (T::*MFP)(lua_State* L); + T const* const t = Userdata::get (L, 1, true); + MFP const& fnptr = *static_cast (lua_touserdata (L, lua_upvalueindex (1))); + assert (fnptr != 0); + return (t->*fnptr) (L); + } + }; + + //-------------------------------------------------------------------------- + + // SFINAE Helpers + + template + struct CallMemberFunctionHelper + { + static void add (lua_State* L, char const* name, MemFnPtr mf) + { + new (lua_newuserdata (L, sizeof (MemFnPtr))) MemFnPtr (mf); + lua_pushcclosure (L, &CallConstMember ::f, 1); + lua_pushvalue (L, -1); + rawsetfield (L, -5, name); // const table + rawsetfield (L, -3, name); // class table + } + }; + + template + struct CallMemberFunctionHelper + { + static void add (lua_State* L, char const* name, MemFnPtr mf) + { + new (lua_newuserdata (L, sizeof (MemFnPtr))) MemFnPtr (mf); + lua_pushcclosure (L, &CallMember ::f, 1); + rawsetfield (L, -3, name); // class table + } + }; + + //-------------------------------------------------------------------------- + /** + __gc metamethod for a class. + */ + template + static int gcMetaMethod (lua_State* L) + { + Userdata* const ud = Userdata::getExact (L, 1); + ud->~Userdata (); + return 0; + } + + //-------------------------------------------------------------------------- + /** + lua_CFunction to get a class data member. + + The pointer-to-member is in the first upvalue. + The class userdata object is at the top of the Lua stack. + */ + template + static int getProperty (lua_State* L) + { + C const* const c = Userdata::get (L, 1, true); + T C::** mp = static_cast (lua_touserdata (L, lua_upvalueindex (1))); + Stack ::push (L, c->**mp); + return 1; + } + + //-------------------------------------------------------------------------- + /** + lua_CFunction to set a class data member. + + The pointer-to-member is in the first upvalue. + The class userdata object is at the top of the Lua stack. + */ + template + static int setProperty (lua_State* L) + { + C* const c = Userdata::get (L, 1, false); + T C::** mp = static_cast (lua_touserdata (L, lua_upvalueindex (1))); + c->**mp = Stack ::get (L, 2); + return 0; + } +}; diff --git a/extern/luabridge/detail/ClassInfo.h b/extern/luabridge/detail/ClassInfo.h new file mode 100644 index 0000000..8d58069 --- /dev/null +++ b/extern/luabridge/detail/ClassInfo.h @@ -0,0 +1,73 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +/** Unique Lua registry keys for a class. + + Each registered class inserts three keys into the registry, whose + values are the corresponding static, class, and const metatables. This + allows a quick and reliable lookup for a metatable from a template type. +*/ +template +class ClassInfo +{ +public: + /** Get the key for the static table. + + The static table holds the static data members, static properties, and + static member functions for a class. + */ + static void const* getStaticKey () + { + static char value; + return &value; + } + + /** Get the key for the class table. + + The class table holds the data members, properties, and member functions + of a class. Read-only data and properties, and const member functions are + also placed here (to save a lookup in the const table). + */ + static void const* getClassKey () + { + static char value; + return &value; + } + + /** Get the key for the const table. + + The const table holds read-only data members and properties, and const + member functions of a class. + */ + static void const* getConstKey () + { + static char value; + return &value; + } +}; + diff --git a/extern/luabridge/detail/Constructor.h b/extern/luabridge/detail/Constructor.h new file mode 100644 index 0000000..7b2dad0 --- /dev/null +++ b/extern/luabridge/detail/Constructor.h @@ -0,0 +1,204 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + Copyright 2007, Nathan Reed + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +#ifndef LUABRIDGE_CONSTRUCTOR_HEADER +#define LUABRIDGE_CONSTRUCTOR_HEADER + +/* +* Constructor generators. These templates allow you to call operator new and +* pass the contents of a type/value list to the Constructor. Like the +* function pointer containers, these are only defined up to 8 parameters. +*/ + +/** Constructor generators. + + These templates call operator new with the contents of a type/value + list passed to the Constructor with up to 8 parameters. Two versions + of call() are provided. One performs a regular new, the other performs + a placement new. +*/ +template +struct Constructor {}; + +template +struct Constructor +{ + static T* call (TypeListValues const&) + { + return new T; + } + static T* call (void* mem, TypeListValues const&) + { + return new (mem) T; + } +}; + +template +struct Constructor > +{ + static T* call (const TypeListValues > &tvl) + { + return new T(tvl.hd); + } + static T* call (void* mem, const TypeListValues > &tvl) + { + return new (mem) T(tvl.hd); + } +}; + +template +struct Constructor > > +{ + static T* call (const TypeListValues > > &tvl) + { + return new T(tvl.hd, tvl.tl.hd); + } + static T* call (void* mem, const TypeListValues > > &tvl) + { + return new (mem) T(tvl.hd, tvl.tl.hd); + } +}; + +template +struct Constructor > > > +{ + static T* call (const TypeListValues > > > &tvl) + { + return new T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd); + } + static T* call (void* mem, const TypeListValues > > > &tvl) + { + return new (mem) T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd); + } +}; + +template +struct Constructor > > > > +{ + static T* call (const TypeListValues > > > > &tvl) + { + return new T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd); + } + static T* call (void* mem, const TypeListValues > > > > &tvl) + { + return new (mem) T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd); + } +}; + +template +struct Constructor > > > > > +{ + static T* call (const TypeListValues > > > > > &tvl) + { + return new T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.hd); + } + static T* call (void* mem, const TypeListValues > > > > > &tvl) + { + return new (mem) T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.hd); + } +}; + +template +struct Constructor > > > > > > +{ + static T* call (const TypeListValues > > > > > > &tvl) + { + return new T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd); + } + static T* call (void* mem, const TypeListValues > > > > > > &tvl) + { + return new (mem) T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct Constructor > > > > > > > +{ + static T* call (const TypeListValues > > > > > > > &tvl) + { + return new T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.tl.tl.hd); + } + static T* call (void* mem, const TypeListValues > > > > > > > &tvl) + { + return new (mem) T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct Constructor > > > > > > > > +{ + static T* call (const TypeListValues > > > > > > > > &tvl) + { + return new T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd); + } + static T* call (void* mem, const TypeListValues > > > > > > > > &tvl) + { + return new (mem) T(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +#endif diff --git a/extern/luabridge/detail/FuncTraits.h b/extern/luabridge/detail/FuncTraits.h new file mode 100644 index 0000000..7eccb61 --- /dev/null +++ b/extern/luabridge/detail/FuncTraits.h @@ -0,0 +1,852 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +/** + Since the throw specification is part of a function signature, the FuncTraits + family of templates needs to be specialized for both types. The + LUABRIDGE_THROWSPEC macro controls whether we use the 'throw ()' form, or + 'noexcept' (if C++11 is available) to distinguish the functions. +*/ +#if defined (__APPLE_CPP__) || defined(__APPLE_CC__) || defined(__clang__) || defined(__GNUC__) || \ + (defined (_MSC_VER) && (_MSC_VER >= 1700)) +// Do not define LUABRIDGE_THROWSPEC since the Xcode and gcc compilers do not +// distinguish the throw specification in the function signature. +#else +// Visual Studio 10 and earlier pay too much mind to useless throw() spec. +// +# define LUABRIDGE_THROWSPEC throw() +#endif + +//============================================================================== +/** + Traits for function pointers. + + There are three types of functions: global, non-const member, and const + member. These templates determine the type of function, which class type it + belongs to if it is a class member, the const-ness if it is a member + function, and the type information for the return value and argument list. + + Expansions are provided for functions with up to 8 parameters. This can be + manually extended, or expanded to an arbitrary amount using C++11 features. +*/ +template +struct FuncTraits +{ +}; + +/* Ordinary function pointers. */ + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef None Params; + static R call (D fp, TypeListValues ) + { + return fp (); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > > > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > > > > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > > > > > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > > > > > > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > > > > > > > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +/* Non-const member function pointers. */ + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef None Params; + static R call (T* obj, D fp, TypeListValues ) + { + return (obj->*fp)(); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > > > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > > > > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +/* Const member function pointers. */ + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef None Params; + static R call (T const* obj, D fp, TypeListValues ) + { + return (obj->*fp)(); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > Params; + static R call (T const* obj, R (T::*fp) (P1, P2) const, + TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > > > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > > > > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +#if defined (LUABRIDGE_THROWSPEC) + +/* Ordinary function pointers. */ + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef None Params; + static R call (D fp, TypeListValues const&) + { + return fp (); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > > > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > > > > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > > > > > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > > > > > > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = false; + typedef D DeclType; + typedef R ReturnType; + typedef TypeList > > > > > > > Params; + static R call (D fp, TypeListValues tvl) + { + return fp (tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +/* Non-const member function pointers with THROWSPEC. */ + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef None Params; + static R call (T* obj, D fp, TypeListValues const&) + { + return (obj->*fp)(); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > > > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = false; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > > > > Params; + static R call (T* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +/* Const member function pointers with THROWSPEC. */ + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef None Params; + static R call (T const* obj, D fp, TypeListValues ) + { + return (obj->*fp)(); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, + tvl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > > > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +template +struct FuncTraits +{ + static bool const isMemberFunction = true; + static bool const isConstMemberFunction = true; + typedef D DeclType; + typedef T ClassType; + typedef R ReturnType; + typedef TypeList > > > > > > > Params; + static R call (T const* obj, D fp, TypeListValues tvl) + { + return (obj->*fp)(tvl.hd, tvl.tl.hd, tvl.tl.tl.hd, tvl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.hd, tvl.tl.tl.tl.tl.tl.tl.tl.hd); + } +}; + +#endif diff --git a/extern/luabridge/detail/Iterator.h b/extern/luabridge/detail/Iterator.h new file mode 100644 index 0000000..d883fb3 --- /dev/null +++ b/extern/luabridge/detail/Iterator.h @@ -0,0 +1,114 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +/** Allows table iteration. +*/ +class Iterator +{ +private: + lua_State* m_L; + LuaRef m_table; + LuaRef m_key; + LuaRef m_value; + + void next () + { + m_table.push(m_L); + m_key.push (m_L); + if (lua_next (m_L, -2)) + { + m_value.pop (m_L); + m_key.pop (m_L); + } + else + { + m_key = Nil(); + m_value = Nil(); + } + lua_pop(m_L, 1); + } + +public: + explicit Iterator (LuaRef table) + : m_L (table.state ()) + , m_table (table) + , m_key (table.state ()) // m_key is nil + , m_value (table.state ()) // m_value is nil + { + next (); // get the first (key, value) pair from table + } + + lua_State* state () const + { + return m_L; + } + + LuaRef operator* () const + { + return m_value; + } + + LuaRef operator-> () const + { + return m_value; + } + + Iterator& operator++ () + { + if (isNil()) + { + // if the iterator reaches the end, do nothing + return *this; + } + else + { + next(); + return *this; + } + } + + inline bool isNil () const + { + return m_key.isNil (); + } + + inline LuaRef key () const + { + return m_key; + } + + inline LuaRef value () const + { + return m_value; + } + +private: + // Don't use postfix increment, it is less efficient + Iterator operator++ (int); +}; + diff --git a/extern/luabridge/detail/LuaException.h b/extern/luabridge/detail/LuaException.h new file mode 100644 index 0000000..a094496 --- /dev/null +++ b/extern/luabridge/detail/LuaException.h @@ -0,0 +1,113 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + Copyright 2008, Nigel Atkinson + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +class LuaException : public std::exception +{ +private: + lua_State* m_L; + std::string m_what; + +public: + //---------------------------------------------------------------------------- + /** + Construct a LuaException after a lua_pcall(). + */ + LuaException (lua_State* L, int /*code*/) + : m_L (L) + { + whatFromStack (); + } + + //---------------------------------------------------------------------------- + + LuaException (lua_State *L, + char const*, + char const*, + long) + : m_L (L) + { + whatFromStack (); + } + + //---------------------------------------------------------------------------- + + ~LuaException() throw () + { + } + + //---------------------------------------------------------------------------- + + char const* what() const throw () + { + return m_what.c_str(); + } + + //============================================================================ + /** + Throw an exception. + + This centralizes all the exceptions thrown, so that we can set + breakpoints before the stack is unwound, or otherwise customize the + behavior. + */ + template + static void Throw (Exception e) + { + throw e; + } + + //---------------------------------------------------------------------------- + /** + Wrapper for lua_pcall that throws. + */ + static void pcall (lua_State* L, int nargs = 0, int nresults = 0, int msgh = 0) + { + int code = lua_pcall (L, nargs, nresults, msgh); + + if (code != LUABRIDGE_LUA_OK) + Throw (LuaException (L, code)); + } + + //---------------------------------------------------------------------------- + +protected: + void whatFromStack () + { + if (lua_gettop (m_L) > 0) + { + char const* s = lua_tostring (m_L, -1); + m_what = s ? s : ""; + } + else + { + // stack is empty + m_what = "missing error"; + } + } +}; diff --git a/extern/luabridge/detail/LuaHelpers.h b/extern/luabridge/detail/LuaHelpers.h new file mode 100644 index 0000000..7bc84eb --- /dev/null +++ b/extern/luabridge/detail/LuaHelpers.h @@ -0,0 +1,143 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + Copyright 2007, Nathan Reed + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +// These are for Lua versions prior to 5.2.0. +// +#if LUA_VERSION_NUM < 502 +inline int lua_absindex (lua_State* L, int idx) +{ + if (idx > LUA_REGISTRYINDEX && idx < 0) + return lua_gettop (L) + idx + 1; + else + return idx; +} + +inline void lua_rawgetp (lua_State* L, int idx, void const* p) +{ + idx = lua_absindex (L, idx); + lua_pushlightuserdata (L, const_cast (p)); + lua_rawget (L,idx); +} + +inline void lua_rawsetp (lua_State* L, int idx, void const* p) +{ + idx = lua_absindex (L, idx); + lua_pushlightuserdata (L, const_cast (p)); + // put key behind value + lua_insert (L, -2); + lua_rawset (L, idx); +} + +#define LUA_OPEQ 1 +#define LUA_OPLT 2 +#define LUA_OPLE 3 + +inline int lua_compare (lua_State* L, int idx1, int idx2, int op) +{ + switch (op) + { + case LUA_OPEQ: + return lua_equal (L, idx1, idx2); + break; + + case LUA_OPLT: + return lua_lessthan (L, idx1, idx2); + break; + + case LUA_OPLE: + return lua_equal (L, idx1, idx2) || lua_lessthan (L, idx1, idx2); + break; + + default: + return 0; + }; +} + +inline int get_length (lua_State* L, int idx) +{ + return int (lua_objlen (L, idx)); +} + +#else +inline int get_length (lua_State* L, int idx) +{ + lua_len (L, idx); + int len = int (luaL_checknumber (L, -1)); + lua_pop (L, 1); + return len; +} + +#endif + +#ifndef LUA_OK +# define LUABRIDGE_LUA_OK 0 +#else +# define LUABRIDGE_LUA_OK LUA_OK +#endif + +/** Get a table value, bypassing metamethods. +*/ +inline void rawgetfield (lua_State* L, int index, char const* key) +{ + assert (lua_istable (L, index)); + index = lua_absindex (L, index); + lua_pushstring (L, key); + lua_rawget (L, index); +} + +/** Set a table value, bypassing metamethods. +*/ +inline void rawsetfield (lua_State* L, int index, char const* key) +{ + assert (lua_istable (L, index)); + index = lua_absindex (L, index); + lua_pushstring (L, key); + lua_insert (L, -2); + lua_rawset (L, index); +} + +/** Returns true if the value is a full userdata (not light). +*/ +inline bool isfulluserdata (lua_State* L, int index) +{ + return lua_isuserdata (L, index) && !lua_islightuserdata (L, index); +} + +/** Test lua_State objects for global equality. + + This can determine if two different lua_State objects really point + to the same global state, such as when using coroutines. + + @note This is used for assertions. +*/ +inline bool equalstates (lua_State* L1, lua_State* L2) +{ + return lua_topointer (L1, LUA_REGISTRYINDEX) == + lua_topointer (L2, LUA_REGISTRYINDEX); +} diff --git a/extern/luabridge/detail/LuaRef.h b/extern/luabridge/detail/LuaRef.h new file mode 100644 index 0000000..e726bca --- /dev/null +++ b/extern/luabridge/detail/LuaRef.h @@ -0,0 +1,1215 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + Copyright 2008, Nigel Atkinson + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +//------------------------------------------------------------------------------ +/** + Type tag for representing LUA_TNIL. + + Construct one of these using `Nil()` to represent a Lua nil. This is faster + than creating a reference in the registry to nil. Example: + + LuaRef t (LuaRef::createTable (L)); + ... + t ["k"] = Nil(); // assign nil +*/ +struct Nil +{ +}; + +//------------------------------------------------------------------------------ +/** + Lightweight reference to a Lua object. + + The reference is maintained for the lifetime of the C++ object. +*/ +class LuaRef +{ +private: + class Proxy; + friend struct Stack ; + + //---------------------------------------------------------------------------- + /** + Pop the Lua stack. + + Pops the specified number of stack items on destruction. We use this + when returning objects, to avoid an explicit temporary variable, since + the destructor executes after the return statement. For example: + + template + U cast (lua_State* L) + { + StackPop p (L, 1); + ... + return U (); // dtor called after this line + } + + @note The `StackPop` object must always be a named local variable. + */ + class StackPop + { + public: + /** Create a StackPop object. + + @param count The number of stack entries to pop on destruction. + */ + StackPop (lua_State* L, int count) + : m_L (L) + , m_count (count) + { + } + + ~StackPop () + { + lua_pop (m_L, m_count); + } + + private: + lua_State* m_L; + int m_count; + }; + + //---------------------------------------------------------------------------- + /** + A proxy for representing table values. + */ + class Proxy + { + private: + lua_State* m_L; + int m_tableRef; + int m_keyRef; + + public: + //-------------------------------------------------------------------------- + /** + Construct a Proxy from a table value. + + The table is in the registry, and the key is at the top of the stack. + The key is popped off the stack. + */ + Proxy (lua_State* L, int tableRef) + : m_L (L) + , m_tableRef (tableRef) + , m_keyRef (luaL_ref (L, LUA_REGISTRYINDEX)) + { + } + + //-------------------------------------------------------------------------- + /** + Create a Proxy via copy constructor. + + It is best to avoid code paths that invoke this, because it creates + an extra temporary Lua reference. Typically this is done by passing + the Proxy parameter as a `const` reference. + */ + Proxy (Proxy const& other) + : m_L (other.m_L) + , m_tableRef (other.m_tableRef) + { + // If this assert goes off it means code is taking this path, + // which is better avoided. + // + assert (0); + + lua_rawgeti (m_L, LUA_REGISTRYINDEX, other.m_keyRef); + m_keyRef = luaL_ref (m_L, LUA_REGISTRYINDEX); + } + + //-------------------------------------------------------------------------- + /** + Destroy the proxy. + + This does not destroy the table value. + */ + ~Proxy () + { + luaL_unref (m_L, LUA_REGISTRYINDEX, m_keyRef); + } + + //-------------------------------------------------------------------------- + /** + Return a reference to the table value. + */ + int createRef () const + { + push (m_L); + return luaL_ref (m_L, LUA_REGISTRYINDEX); + } + + //-------------------------------------------------------------------------- + /** + Assign a new value to this table key. + + This may invoke metamethods. + */ + template + Proxy& operator= (T v) + { + StackPop p (m_L, 1); + lua_rawgeti (m_L, LUA_REGISTRYINDEX, m_tableRef); + lua_rawgeti (m_L, LUA_REGISTRYINDEX, m_keyRef); + Stack ::push (m_L, v); + lua_rawset (m_L, -3); + return *this; + } + + //-------------------------------------------------------------------------- + /** + Assign a new value to this table key. + + The assignment is raw, no metamethods are invoked. + */ + template + Proxy& rawset (T v) + { + StackPop p (m_L, 1); + lua_rawgeti (m_L, LUA_REGISTRYINDEX, m_tableRef); + lua_rawgeti (m_L, LUA_REGISTRYINDEX, m_keyRef); + Stack ::push (m_L, v); + lua_settable (m_L, -3); + return *this; + } + + //========================================================================== + // + // This group of member functions mirrors the member functions in LuaRef. + + /** Retrieve the lua_State associated with the table value. + */ + lua_State* state () const + { + return m_L; + } + + //-------------------------------------------------------------------------- + /** + Push the value onto the Lua stack. + */ + void push (lua_State* L) const + { + assert (equalstates (L, m_L)); + lua_rawgeti (L, LUA_REGISTRYINDEX, m_tableRef); + lua_rawgeti (L, LUA_REGISTRYINDEX, m_keyRef); + lua_gettable (L, -2); + lua_remove (L, -2); // remove the table + } + + //-------------------------------------------------------------------------- + /** + Determine the object type. + + The return values are the same as for `lua_type`. + */ + int type () const + { + int result; + push (m_L); + result = lua_type (m_L, -1); + lua_pop (m_L, 1); + return result; + } + + inline bool isNil () const { return type () == LUA_TNIL; } + inline bool isNumber () const { return type () == LUA_TNUMBER; } + inline bool isString () const { return type () == LUA_TSTRING; } + inline bool isTable () const { return type () == LUA_TTABLE; } + inline bool isFunction () const { return type () == LUA_TFUNCTION; } + inline bool isUserdata () const { return type () == LUA_TUSERDATA; } + inline bool isThread () const { return type () == LUA_TTHREAD; } + inline bool isLightUserdata () const { return type () == LUA_TLIGHTUSERDATA; } + + //-------------------------------------------------------------------------- + /** + Perform an explicit conversion. + */ + template + T cast () const + { + StackPop p (m_L, 1); + push (m_L); + + // lua_gettop is used because Userdata::getClass() doesn't handle + // negative stack indexes. + // + return Stack ::get (m_L, lua_gettop (m_L)); + } + + //-------------------------------------------------------------------------- + /** + Universal implicit conversion operator. + + NOTE: Visual Studio 2010 and 2012 have a bug where this function + is not used. See: + + http://social.msdn.microsoft.com/Forums/en-US/vcgeneral/thread/e30b2664-a92d-445c-9db2-e8e0fbde2014 + https://connect.microsoft.com/VisualStudio/feedback/details/771509/correct-code-doesnt-compile + + // This code snippet fails to compile in vs2010,vs2012 + struct S { + template inline operator T () const { return T (); } + }; + int main () { + S () || false; + return 0; + } + */ + template + inline operator T () const + { + return cast (); + } + + //-------------------------------------------------------------------------- + /** + Universal comparison operators. + */ + /** @{ */ + template + bool operator== (T rhs) const + { + StackPop p (m_L, 2); + push (m_L); + Stack ::push (m_L, rhs); + return lua_compare (m_L, -2, -1, LUA_OPEQ) == 1; + } + + template + bool operator< (T rhs) const + { + StackPop p (m_L, 2); + push (m_L); + Stack ::push (m_L, rhs); + return lua_compare (m_L, -2, -1, LUA_OPLT) == 1; + } + + template + bool operator<= (T rhs) const + { + StackPop p (m_L, 2); + push (m_L); + Stack ::push (m_L, rhs); + return lua_compare (m_L, -2, -1, LUA_OPLE) == 1; + } + + template + bool operator> (T rhs) const + { + StackPop p (m_L, 2); + push (m_L); + Stack ::push (m_L, rhs); + return lua_compare (m_L, -1, -2, LUA_OPLT) == 1; + } + + template + bool operator>= (T rhs) const + { + StackPop p (m_L, 2); + push (m_L); + Stack ::push (m_L, rhs); + return lua_compare (m_L, -1, -2, LUA_OPLE) == 1; + } + + template + bool rawequal (T rhs) const + { + StackPop p (m_L, 2); + push (m_L); + Stack ::push (m_L, rhs); + return lua_rawequal (m_L, -1, -2) == 1; + } + /** @} */ + + //-------------------------------------------------------------------------- + /** + Access a table value using a key. + + This invokes metamethods. + */ + template + Proxy operator[] (T key) const + { + return LuaRef (*this) [key]; + } + + //-------------------------------------------------------------------------- + /** + Access a table value using a key. + + The operation is raw, metamethods are not invoked. The result is + passed by value and may not be modified. + */ + template + LuaRef rawget (T key) const + { + StackPop (m_L, 1); + push (m_L); + Stack ::push (m_L, key); + lua_rawget (m_L, -2); + return LuaRef (m_L, FromStack ()); + } + + //-------------------------------------------------------------------------- + /** + Append a value to the table. + + If the table is a sequence this will add another element to it. + */ + template + void append (T v) const + { + push (m_L); + Stack ::push (m_L, v); + luaL_ref (m_L, -2); + lua_pop (m_L, 1); + } + + //-------------------------------------------------------------------------- + /** + Call the length operator. + + This is identical to applying the Lua # operator. + */ + int length () const + { + StackPop p (m_L, 1); + push (m_L); + return get_length (m_L, -1); + } + + //-------------------------------------------------------------------------- + /** + Call Lua code. + + These overloads allow Lua code to be called with up to 8 parameters. + The return value is provided as a LuaRef (which may be LUA_REFNIL). + If an error occurs, a LuaException is thrown. + */ + /** @{ */ + LuaRef const operator() () const + { + push (m_L); + LuaException::pcall (m_L, 0, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1) const + { + push (m_L); + Stack ::push (m_L, p1); + LuaException::pcall (m_L, 1, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + LuaException::pcall (m_L, 2, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2, P3 p3) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + Stack ::push (m_L, p3); + LuaException::pcall (m_L, 3, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + Stack ::push (m_L, p3); + Stack ::push (m_L, p4); + LuaException::pcall (m_L, 4, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + Stack ::push (m_L, p3); + Stack ::push (m_L, p4); + Stack ::push (m_L, p5); + LuaException::pcall (m_L, 5, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + Stack ::push (m_L, p3); + Stack ::push (m_L, p4); + Stack ::push (m_L, p5); + Stack ::push (m_L, p6); + LuaException::pcall (m_L, 6, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + Stack ::push (m_L, p3); + Stack ::push (m_L, p4); + Stack ::push (m_L, p5); + Stack ::push (m_L, p6); + Stack ::push (m_L, p7); + LuaException::pcall (m_L, 7, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + Stack ::push (m_L, p3); + Stack ::push (m_L, p4); + Stack ::push (m_L, p5); + Stack ::push (m_L, p6); + Stack ::push (m_L, p7); + Stack ::push (m_L, p8); + LuaException::pcall (m_L, 8, 1); + return LuaRef (m_L, FromStack ()); + } + /** @} */ + + //========================================================================== + }; + +private: + friend struct Stack ; + + //---------------------------------------------------------------------------- + /** + Type tag for stack construction. + */ + struct FromStack { }; + + //---------------------------------------------------------------------------- + /** + Create a reference to an object at the top of the Lua stack and pop it. + + This constructor is private and not invoked directly. + Instead, use the `fromStack` function. + + @note The object is popped. + */ + LuaRef (lua_State* L, FromStack) + : m_L (L) + { + m_ref = luaL_ref (m_L, LUA_REGISTRYINDEX); + } + + //---------------------------------------------------------------------------- + /** + Create a reference to an object on the Lua stack. + + This constructor is private and not invoked directly. + Instead, use the `fromStack` function. + + @note The object is not popped. + */ + LuaRef (lua_State* L, int index, FromStack) + : m_L (L) + { + lua_pushvalue (m_L, index); + m_ref = luaL_ref (m_L, LUA_REGISTRYINDEX); + } + + //---------------------------------------------------------------------------- + + // This type of construction is disallowed, since we don't have a `lua_State`. + // + template + LuaRef (T) + { + } + + //---------------------------------------------------------------------------- + /** + Create a reference to this ref. + + This is used internally. + */ + int createRef () const + { + if (m_ref != LUA_REFNIL) + { + push (m_L); + return luaL_ref (m_L, LUA_REGISTRYINDEX); + } + else + { + return LUA_REFNIL; + } + } + +public: + //---------------------------------------------------------------------------- + /** + Create a nil reference. + + The LuaRef may be assigned later. + */ + LuaRef (lua_State* L) + : m_L (L) + , m_ref (LUA_REFNIL) + { + } + + //---------------------------------------------------------------------------- + /** + Create a reference to a value. + */ + template + LuaRef (lua_State* L, T v) + : m_L (L) + { + Stack ::push (m_L, v); + m_ref = luaL_ref (m_L, LUA_REGISTRYINDEX); + } + + //---------------------------------------------------------------------------- + /** + Create a reference to a table value. + */ + LuaRef (Proxy const& v) + : m_L (v.state ()) + , m_ref (v.createRef ()) + { + } + + //---------------------------------------------------------------------------- + /** + Create a new reference to an existing reference. + */ + LuaRef (LuaRef const& other) + : m_L (other.m_L) + , m_ref (other.createRef ()) + { + } + + //---------------------------------------------------------------------------- + /** + Destroy a reference. + + The corresponding Lua registry reference will be released. + + @note If the state refers to a thread, it is the responsibility of the + caller to ensure that the thread still exists when the LuaRef + is destroyed. + */ + ~LuaRef () + { + luaL_unref (m_L, LUA_REGISTRYINDEX, m_ref); + } + + //---------------------------------------------------------------------------- + /** + Return a LuaRef from a stack item. + + The stack item is not popped. + */ + static LuaRef fromStack (lua_State* L, int index) + { + lua_pushvalue (L, index); + return LuaRef (L, FromStack ()); + } + + //---------------------------------------------------------------------------- + /** + Create a new empty table and return a reference to it. + + It is also possible to use the free function `newTable`. + + @see ::getGlobal + */ + static LuaRef newTable (lua_State* L) + { + lua_newtable (L); + return LuaRef (L, FromStack ()); + } + + //---------------------------------------------------------------------------- + /** + Return a reference to a named global. + + It is also possible to use the free function `getGlobal`. + + @see ::getGlobal + */ + static LuaRef getGlobal (lua_State *L, char const* name) + { + lua_getglobal (L, name); + return LuaRef (L, FromStack ()); + } + + //---------------------------------------------------------------------------- + /** + Assign a different value to this LuaRef. + */ + template + LuaRef& operator= (T rhs) + { + luaL_unref (m_L, LUA_REGISTRYINDEX, m_ref); + Stack ::push (m_L, rhs); + m_ref = luaL_ref (m_L, LUA_REGISTRYINDEX); + return *this; + } + + //---------------------------------------------------------------------------- + /** + Assign another LuaRef to this LuaRef. + */ + LuaRef& operator= (LuaRef const& rhs) + { + luaL_unref (m_L, LUA_REGISTRYINDEX, m_ref); + rhs.push (m_L); + m_L = rhs.state (); + m_ref = luaL_ref (m_L, LUA_REGISTRYINDEX); + return *this; + } + + //---------------------------------------------------------------------------- + /** + converts to a string using luas tostring function + */ + std::string tostring() const + { + lua_getglobal (m_L, "tostring"); + push (m_L); + lua_call (m_L, 1, 1); + const char* str = lua_tostring(m_L, 1); + lua_pop(m_L, 1); + return std::string(str); + } + + //---------------------------------------------------------------------------- + /** + Print a text description of the value to a stream. + + This is used for diagnostics. + */ + void print (std::ostream& os) const + { + switch (type ()) + { + case LUA_TNIL: + os << "nil"; + break; + + case LUA_TNUMBER: + os << cast (); + break; + + case LUA_TBOOLEAN: + os << (cast () ? "true" : "false"); + break; + + case LUA_TSTRING: + os << '"' << cast () << '"'; + break; + + case LUA_TTABLE: + os << "table: " << tostring(); + break; + + case LUA_TFUNCTION: + os << "function: " << tostring(); + break; + + case LUA_TUSERDATA: + os << "userdata: " << tostring(); + break; + + case LUA_TTHREAD: + os << "thread: " << tostring(); + break; + + case LUA_TLIGHTUSERDATA: + os << "lightuserdata: " << tostring(); + break; + + default: + os << "unknown"; + break; + } + } + + //============================================================================ + // + // This group of member functions is mirrored in Proxy + // + + /** Retrieve the lua_State associated with the reference. + */ + lua_State* state () const + { + return m_L; + } + + //---------------------------------------------------------------------------- + /** + Place the object onto the Lua stack. + */ + void push (lua_State* L) const + { + assert (equalstates (L, m_L)); + lua_rawgeti (L, LUA_REGISTRYINDEX, m_ref); + } + + //---------------------------------------------------------------------------- + /** + Pop the top of Lua stack and assign the ref to m_ref + */ + void pop (lua_State* L) + { + assert (equalstates (L, m_L)); + luaL_unref (m_L, LUA_REGISTRYINDEX, m_ref); + m_ref = luaL_ref (m_L, LUA_REGISTRYINDEX); + } + + //---------------------------------------------------------------------------- + /** + Determine the object type. + + The return values are the same as for `lua_type`. + */ + /** @{ */ + int type () const + { + int result; + if (m_ref != LUA_REFNIL) + { + push (m_L); + result = lua_type (m_L, -1); + lua_pop (m_L, 1); + } + else + { + result = LUA_TNIL; + } + + return result; + } + + // should never happen + //inline bool isNone () const { return m_ref == LUA_NOREF; } + + inline bool isNil () const { return type () == LUA_TNIL; } + inline bool isNumber () const { return type () == LUA_TNUMBER; } + inline bool isString () const { return type () == LUA_TSTRING; } + inline bool isTable () const { return type () == LUA_TTABLE; } + inline bool isFunction () const { return type () == LUA_TFUNCTION; } + inline bool isUserdata () const { return type () == LUA_TUSERDATA; } + inline bool isThread () const { return type () == LUA_TTHREAD; } + inline bool isLightUserdata () const { return type () == LUA_TLIGHTUSERDATA; } + /** @} */ + + //---------------------------------------------------------------------------- + /** + Perform an explicit conversion. + */ + template + T cast () const + { + StackPop p (m_L, 1); + push (m_L); + + // lua_gettop is used because Userdata::getClass() doesn't handle + // negative stack indexes. + // + return Stack ::get (m_L, lua_gettop (m_L)); + } + + //---------------------------------------------------------------------------- + /** + Universal implicit conversion operator. + + NOTE: Visual Studio 2010 and 2012 have a bug where this function + is not used. See: + + http://social.msdn.microsoft.com/Forums/en-US/vcgeneral/thread/e30b2664-a92d-445c-9db2-e8e0fbde2014 + https://connect.microsoft.com/VisualStudio/feedback/details/771509/correct-code-doesnt-compile + + // This code snippet fails to compile in vs2010,vs2012 + struct S { + template inline operator T () const { return T (); } + }; + int main () { + S () || false; + return 0; + } + */ + template + inline operator T () const + { + return cast (); + } + + //---------------------------------------------------------------------------- + /** + Universal comparison operators. + */ + /** @{ */ + template + bool operator== (T rhs) const + { + StackPop p (m_L, 2); + push (m_L); + Stack ::push (m_L, rhs); + return lua_compare (m_L, -2, -1, LUA_OPEQ) == 1; + } + + template + bool operator< (T rhs) const + { + StackPop p (m_L, 2); + push (m_L); + Stack ::push (m_L, rhs); + return lua_compare (m_L, -2, -1, LUA_OPLT) == 1; + } + + template + bool operator<= (T rhs) const + { + StackPop p (m_L, 2); + push (m_L); + Stack ::push (m_L, rhs); + return lua_compare (m_L, -2, -1, LUA_OPLE) == 1; + } + + template + bool operator> (T rhs) const + { + StackPop p (m_L, 2); + push (m_L); + Stack ::push (m_L, rhs); + return lua_compare (m_L, -1, -2, LUA_OPLT) == 1; + } + + template + bool operator>= (T rhs) const + { + StackPop p (m_L, 2); + push (m_L); + Stack ::push (m_L, rhs); + return lua_compare (m_L, -1, -2, LUA_OPLE) == 1; + } + + template + bool rawequal (T rhs) const + { + StackPop p (m_L, 2); + push (m_L); + Stack ::push (m_L, rhs); + return lua_rawequal (m_L, -1, -2) == 1; + } + /** @} */ + + //---------------------------------------------------------------------------- + /** + Append a value to the table. + + If the table is a sequence this will add another element to it. + */ + template + void append (T v) const + { + push (m_L); + Stack ::push (m_L, v); + luaL_ref (m_L, -2); + lua_pop (m_L, 1); + } + + //---------------------------------------------------------------------------- + /** + Call the length operator. + + This is identical to applying the Lua # operator. + */ + int length () const + { + StackPop p (m_L, 1); + push (m_L); + return get_length (m_L, -1); + } + + //---------------------------------------------------------------------------- + /** + Access a table value using a key. + + This invokes metamethods. + */ + template + Proxy operator[] (T key) const + { + Stack ::push (m_L, key); + return Proxy (m_L, m_ref); + } + + //---------------------------------------------------------------------------- + /** + Call Lua code. + + These overloads allow Lua code to be called with up to 8 parameters. + The return value is provided as a LuaRef (which may be LUA_REFNIL). + If an error occurs, a LuaException is thrown. + */ + /** @{ */ + LuaRef const operator() () const + { + push (m_L); + LuaException::pcall (m_L, 0, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1) const + { + push (m_L); + Stack ::push (m_L, p1); + LuaException::pcall (m_L, 1, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + LuaException::pcall (m_L, 2, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2, P3 p3) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + Stack ::push (m_L, p3); + LuaException::pcall (m_L, 3, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + Stack ::push (m_L, p3); + Stack ::push (m_L, p4); + LuaException::pcall (m_L, 4, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + Stack ::push (m_L, p3); + Stack ::push (m_L, p4); + Stack ::push (m_L, p5); + LuaException::pcall (m_L, 5, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + Stack ::push (m_L, p3); + Stack ::push (m_L, p4); + Stack ::push (m_L, p5); + Stack ::push (m_L, p6); + LuaException::pcall (m_L, 6, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + Stack ::push (m_L, p3); + Stack ::push (m_L, p4); + Stack ::push (m_L, p5); + Stack ::push (m_L, p6); + Stack ::push (m_L, p7); + LuaException::pcall (m_L, 7, 1); + return LuaRef (m_L, FromStack ()); + } + + template + LuaRef const operator() (P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) const + { + push (m_L); + Stack ::push (m_L, p1); + Stack ::push (m_L, p2); + Stack ::push (m_L, p3); + Stack ::push (m_L, p4); + Stack ::push (m_L, p5); + Stack ::push (m_L, p6); + Stack ::push (m_L, p7); + Stack ::push (m_L, p8); + LuaException::pcall (m_L, 8, 1); + return LuaRef (m_L, FromStack ()); + } + /** @} */ + + //============================================================================ + +private: + lua_State* m_L; + int m_ref; +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for Nil +*/ +template <> +struct Stack +{ +public: + static inline void push (lua_State* L, Nil) + { + lua_pushnil (L); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for LuaRef. +*/ +template <> +struct Stack +{ +public: + // The value is const& to prevent a copy construction. + // + static inline void push (lua_State* L, LuaRef const& v) + { + v.push (L); + } + + static inline LuaRef get (lua_State* L, int index) + { + return LuaRef (L, index, LuaRef::FromStack ()); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for Proxy. +*/ +template <> +struct Stack +{ +public: + // The value is const& to prevent a copy construction. + // + static inline void push (lua_State* L, LuaRef::Proxy const& v) + { + v.push (L); + } +}; + +//------------------------------------------------------------------------------ +/** + Create a reference to a new, empty table. + + This is a syntactic abbreviation for LuaRef::newTable(). +*/ +inline LuaRef newTable (lua_State* L) +{ + return LuaRef::newTable (L); +} + +//------------------------------------------------------------------------------ +/** + Create a reference to a value in the global table. + + This is a syntactic abbreviation for LuaRef::getGlobal(). +*/ +inline LuaRef getGlobal (lua_State *L, char const* name) +{ + return LuaRef::getGlobal (L, name); +} + +//------------------------------------------------------------------------------ +/** + Write a LuaRef to a stream. + + This allows LuaRef and table proxies to work with streams. +*/ +inline std::ostream& operator<< (std::ostream& os, LuaRef const& ref) +{ + ref.print (os); + return os; +} + +//------------------------------------------------------------------------------ + +// more C++-like cast syntax +// +template +inline T LuaRef_cast(LuaRef const& lr) +{ + return lr.cast(); +} diff --git a/extern/luabridge/detail/Namespace.h b/extern/luabridge/detail/Namespace.h new file mode 100644 index 0000000..ff22e6b --- /dev/null +++ b/extern/luabridge/detail/Namespace.h @@ -0,0 +1,1136 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + Copyright 2007, Nathan Reed + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +/** Provides C++ to Lua registration capabilities. + + This class is not instantiated directly, call `getGlobalNamespace` to start + the registration process. +*/ +class Namespace +{ +private: + Namespace& operator= (Namespace const& other); + + lua_State* const L; + int mutable m_stackSize; + +private: + //============================================================================ + /** + Error reporting. + + VF: This function looks handy, why aren't we using it? + */ +#if 0 + static int luaError (lua_State* L, std::string message) + { + assert (lua_isstring (L, lua_upvalueindex (1))); + std::string s; + + // Get information on the caller's caller to format the message, + // so the error appears to originate from the Lua source. + lua_Debug ar; + int result = lua_getstack (L, 2, &ar); + if (result != 0) + { + lua_getinfo (L, "Sl", &ar); + s = ar.short_src; + if (ar.currentline != -1) + { + // poor mans int to string to avoid . + lua_pushnumber (L, ar.currentline); + s = s + ":" + lua_tostring (L, -1) + ": "; + lua_pop (L, 1); + } + } + + s = s + message; + + return luaL_error (L, s.c_str ()); + } +#endif + + //---------------------------------------------------------------------------- + /** + Pop the Lua stack. + */ + void pop (int n) const + { + if (m_stackSize >= n && lua_gettop (L) >= n) + { + lua_pop (L, n); + m_stackSize -= n; + } + else + { + throw std::logic_error ("invalid stack"); + } + } + +private: + /** + Factored base to reduce template instantiations. + */ + class ClassBase + { + private: + ClassBase& operator= (ClassBase const& other); + + protected: + friend class Namespace; + + lua_State* const L; + int mutable m_stackSize; + + protected: + //-------------------------------------------------------------------------- + /** + __index metamethod for a class. + + This implements member functions, data members, and property members. + Functions are stored in the metatable and const metatable. Data members + and property members are in the __propget table. + + If the key is not found, the search proceeds up the hierarchy of base + classes. + */ + static int indexMetaMethod (lua_State* L) + { + int result = 0; + + assert (lua_isuserdata (L, 1)); // warn on security bypass + lua_getmetatable (L, 1); // get metatable for object + for (;;) + { + lua_pushvalue (L, 2); // push key arg2 + lua_rawget (L, -2); // lookup key in metatable + if (lua_iscfunction (L, -1)) // ensure its a cfunction + { + lua_remove (L, -2); // remove metatable + result = 1; + break; + } + else if (lua_isnil (L, -1)) + { + lua_pop (L, 1); + } + else + { + lua_pop (L, 2); + throw std::logic_error ("not a cfunction"); + } + + rawgetfield (L, -1, "__propget"); // get __propget table + if (lua_istable (L, -1)) // ensure it is a table + { + lua_pushvalue (L, 2); // push key arg2 + lua_rawget (L, -2); // lookup key in __propget + lua_remove (L, -2); // remove __propget + if (lua_iscfunction (L, -1)) // ensure its a cfunction + { + lua_remove (L, -2); // remove metatable + lua_pushvalue (L, 1); // push class arg1 + lua_call (L, 1, 1); + result = 1; + break; + } + else if (lua_isnil (L, -1)) + { + lua_pop (L, 1); + } + else + { + lua_pop (L, 2); + + // We only put cfunctions into __propget. + throw std::logic_error ("not a cfunction"); + } + } + else + { + lua_pop (L, 2); + + // __propget is missing, or not a table. + throw std::logic_error ("missing __propget table"); + } + + // Repeat the lookup in the __parent metafield, + // or return nil if the field doesn't exist. + rawgetfield (L, -1, "__parent"); + if (lua_istable (L, -1)) + { + // Remove metatable and repeat the search in __parent. + lua_remove (L, -2); + } + else if (lua_isnil (L, -1)) + { + result = 1; + break; + } + else + { + lua_pop (L, 2); + + throw std::logic_error ("__parent is not a table"); + } + } + + return result; + } + + //-------------------------------------------------------------------------- + /** + __newindex metamethod for classes. + + This supports writable variables and properties on class objects. The + corresponding object is passed in the first parameter to the set function. + */ + static int newindexMetaMethod (lua_State* L) + { + int result = 0; + + lua_getmetatable (L, 1); + + for (;;) + { + // Check __propset + rawgetfield (L, -1, "__propset"); + if (!lua_isnil (L, -1)) + { + lua_pushvalue (L, 2); + lua_rawget (L, -2); + if (!lua_isnil (L, -1)) + { + // found it, call the setFunction. + assert (lua_isfunction (L, -1)); + lua_pushvalue (L, 1); + lua_pushvalue (L, 3); + lua_call (L, 2, 0); + result = 0; + break; + } + lua_pop (L, 1); + } + lua_pop (L, 1); + + // Repeat the lookup in the __parent metafield. + rawgetfield (L, -1, "__parent"); + if (lua_isnil (L, -1)) + { + // Either the property or __parent must exist. + result = luaL_error (L, + "no member named '%s'", lua_tostring (L, 2)); + } + lua_remove (L, -2); + } + + return result; + } + + //-------------------------------------------------------------------------- + /** + Create the const table. + */ + void createConstTable (char const* name) + { + lua_newtable (L); + lua_pushvalue (L, -1); + lua_setmetatable (L, -2); + lua_pushboolean (L, 1); + lua_rawsetp (L, -2, getIdentityKey ()); + lua_pushstring (L, (std::string ("const ") + name).c_str ()); + rawsetfield (L, -2, "__type"); + lua_pushcfunction (L, &indexMetaMethod); + rawsetfield (L, -2, "__index"); + lua_pushcfunction (L, &newindexMetaMethod); + rawsetfield (L, -2, "__newindex"); + lua_newtable (L); + rawsetfield (L, -2, "__propget"); + + if (Security::hideMetatables ()) + { + lua_pushnil (L); + rawsetfield (L, -2, "__metatable"); + } + } + + //-------------------------------------------------------------------------- + /** + Create the class table. + + The Lua stack should have the const table on top. + */ + void createClassTable (char const* name) + { + lua_newtable (L); + lua_pushvalue (L, -1); + lua_setmetatable (L, -2); + lua_pushboolean (L, 1); + lua_rawsetp (L, -2, getIdentityKey ()); + lua_pushstring (L, name); + rawsetfield (L, -2, "__type"); + lua_pushcfunction (L, &indexMetaMethod); + rawsetfield (L, -2, "__index"); + lua_pushcfunction (L, &newindexMetaMethod); + rawsetfield (L, -2, "__newindex"); + lua_newtable (L); + rawsetfield (L, -2, "__propget"); + lua_newtable (L); + rawsetfield (L, -2, "__propset"); + + lua_pushvalue (L, -2); + rawsetfield (L, -2, "__const"); // point to const table + + lua_pushvalue (L, -1); + rawsetfield (L, -3, "__class"); // point const table to class table + + if (Security::hideMetatables ()) + { + lua_pushnil (L); + rawsetfield (L, -2, "__metatable"); + } + } + + //-------------------------------------------------------------------------- + /** + Create the static table. + + The Lua stack should have: + -1 class table + -2 const table + -3 enclosing namespace + */ + void createStaticTable (char const* name) + { + lua_newtable (L); + lua_newtable (L); + lua_pushvalue (L, -1); + lua_setmetatable (L, -3); + lua_insert (L, -2); + rawsetfield (L, -5, name); + +#if 0 + lua_pushlightuserdata (L, this); + lua_pushcclosure (L, &tostringMetaMethod, 1); + rawsetfield (L, -2, "__tostring"); +#endif + lua_pushcfunction (L, &CFunc::indexMetaMethod); + rawsetfield (L, -2, "__index"); + lua_pushcfunction (L, &CFunc::newindexMetaMethod); + rawsetfield (L, -2, "__newindex"); + lua_newtable (L); + rawsetfield (L, -2, "__propget"); + lua_newtable (L); + rawsetfield (L, -2, "__propset"); + + lua_pushvalue (L, -2); + rawsetfield (L, -2, "__class"); // point to class table + + if (Security::hideMetatables ()) + { + lua_pushnil (L); + rawsetfield (L, -2, "__metatable"); + } + } + + //========================================================================== + /** + lua_CFunction to construct a class object wrapped in a container. + */ + template + static int ctorContainerProxy (lua_State* L) + { + typedef typename ContainerTraits ::Type T; + ArgList args (L); + T* const p = Constructor ::call (args); + UserdataSharedHelper ::push (L, p); + return 1; + } + + //-------------------------------------------------------------------------- + /** + lua_CFunction to construct a class object in-place in the userdata. + */ + template + static int ctorPlacementProxy (lua_State* L) + { + ArgList args (L); + Constructor ::call (UserdataValue ::place (L), args); + return 1; + } + + //-------------------------------------------------------------------------- + /** + Pop the Lua stack. + */ + void pop (int n) const + { + if (m_stackSize >= n && lua_gettop (L) >= n) + { + lua_pop (L, n); + m_stackSize -= n; + } + else + { + throw std::logic_error ("invalid stack"); + } + } + + public: + //-------------------------------------------------------------------------- + explicit ClassBase (lua_State* L_) + : L (L_) + , m_stackSize (0) + { + } + + //-------------------------------------------------------------------------- + /** + Copy Constructor. + */ + ClassBase (ClassBase const& other) + : L (other.L) + , m_stackSize (0) + { + m_stackSize = other.m_stackSize; + other.m_stackSize = 0; + } + + ~ClassBase () + { + pop (m_stackSize); + } + }; + + //============================================================================ + // + // Class + // + //============================================================================ + /** + Provides a class registration in a lua_State. + + After contstruction the Lua stack holds these objects: + -1 static table + -2 class table + -3 const table + -4 (enclosing namespace) + */ + template + class Class : public ClassBase + { + public: + //========================================================================== + /** + Register a new class or add to an existing class registration. + */ + Class (char const* name, Namespace const* parent) : ClassBase (parent->L) + { + m_stackSize = parent->m_stackSize + 3; + parent->m_stackSize = 0; + + assert (lua_istable (L, -1)); + rawgetfield (L, -1, name); + + if (lua_isnil (L, -1)) + { + lua_pop (L, 1); + + createConstTable (name); + lua_pushcfunction (L, &CFunc::gcMetaMethod ); + rawsetfield (L, -2, "__gc"); + + createClassTable (name); + lua_pushcfunction (L, &CFunc::gcMetaMethod ); + rawsetfield (L, -2, "__gc"); + + createStaticTable (name); + + // Map T back to its tables. + lua_pushvalue (L, -1); + lua_rawsetp (L, LUA_REGISTRYINDEX, ClassInfo ::getStaticKey ()); + lua_pushvalue (L, -2); + lua_rawsetp (L, LUA_REGISTRYINDEX, ClassInfo ::getClassKey ()); + lua_pushvalue (L, -3); + lua_rawsetp (L, LUA_REGISTRYINDEX, ClassInfo ::getConstKey ()); + } + else + { + rawgetfield (L, -1, "__class"); + rawgetfield (L, -1, "__const"); + + // Reverse the top 3 stack elements + lua_insert (L, -3); + lua_insert (L, -2); + } + } + + //========================================================================== + /** + Derive a new class. + */ + Class (char const* name, Namespace const* parent, void const* const staticKey) + : ClassBase (parent->L) + { + m_stackSize = parent->m_stackSize + 3; + parent->m_stackSize = 0; + + assert (lua_istable (L, -1)); + + createConstTable (name); + lua_pushcfunction (L, &CFunc::gcMetaMethod ); + rawsetfield (L, -2, "__gc"); + + createClassTable (name); + lua_pushcfunction (L, &CFunc::gcMetaMethod ); + rawsetfield (L, -2, "__gc"); + + createStaticTable (name); + + lua_rawgetp (L, LUA_REGISTRYINDEX, staticKey); + assert (lua_istable (L, -1)); + rawgetfield (L, -1, "__class"); + assert (lua_istable (L, -1)); + rawgetfield (L, -1, "__const"); + assert (lua_istable (L, -1)); + + rawsetfield (L, -6, "__parent"); + rawsetfield (L, -4, "__parent"); + rawsetfield (L, -2, "__parent"); + + lua_pushvalue (L, -1); + lua_rawsetp (L, LUA_REGISTRYINDEX, ClassInfo ::getStaticKey ()); + lua_pushvalue (L, -2); + lua_rawsetp (L, LUA_REGISTRYINDEX, ClassInfo ::getClassKey ()); + lua_pushvalue (L, -3); + lua_rawsetp (L, LUA_REGISTRYINDEX, ClassInfo ::getConstKey ()); + } + + //-------------------------------------------------------------------------- + /** + Continue registration in the enclosing namespace. + */ + Namespace endClass () + { + return Namespace (this); + } + + //-------------------------------------------------------------------------- + /** + Add or replace a static data member. + */ + template + Class & addStaticData (char const* name, U* pu, bool isWritable = true) + { + assert (lua_istable (L, -1)); + + rawgetfield (L, -1, "__propget"); + assert (lua_istable (L, -1)); + lua_pushlightuserdata (L, pu); + lua_pushcclosure (L, &CFunc::getVariable , 1); + rawsetfield (L, -2, name); + lua_pop (L, 1); + + rawgetfield (L, -1, "__propset"); + assert (lua_istable (L, -1)); + if (isWritable) + { + lua_pushlightuserdata (L, pu); + lua_pushcclosure (L, &CFunc::setVariable , 1); + } + else + { + lua_pushstring (L, name); + lua_pushcclosure (L, &CFunc::readOnlyError, 1); + } + rawsetfield (L, -2, name); + lua_pop (L, 1); + + return *this; + } + + //-------------------------------------------------------------------------- + /** + Add or replace a static property member. + + If the set function is null, the property is read-only. + */ + template + Class & addStaticProperty (char const* name, U (*get)(), void (*set)(U) = 0) + { + typedef U (*get_t)(); + typedef void (*set_t)(U); + + assert (lua_istable (L, -1)); + + rawgetfield (L, -1, "__propget"); + assert (lua_istable (L, -1)); + new (lua_newuserdata (L, sizeof (get))) get_t (get); + lua_pushcclosure (L, &CFunc::Call ::f, 1); + rawsetfield (L, -2, name); + lua_pop (L, 1); + + rawgetfield (L, -1, "__propset"); + assert (lua_istable (L, -1)); + if (set != 0) + { + new (lua_newuserdata (L, sizeof (set))) set_t (set); + lua_pushcclosure (L, &CFunc::Call ::f, 1); + } + else + { + lua_pushstring (L, name); + lua_pushcclosure (L, &CFunc::readOnlyError, 1); + } + rawsetfield (L, -2, name); + lua_pop (L, 1); + + return *this; + } + + //-------------------------------------------------------------------------- + /** + Add or replace a static member function. + */ + template + Class & addStaticFunction (char const* name, FP const fp) + { + new (lua_newuserdata (L, sizeof (fp))) FP (fp); + lua_pushcclosure (L, &CFunc::Call ::f, 1); + rawsetfield (L, -2, name); + + return *this; + } + + //-------------------------------------------------------------------------- + /** + Add or replace a lua_CFunction. + */ + Class & addStaticCFunction (char const* name, int (*const fp)(lua_State*)) + { + lua_pushcfunction (L, fp); + rawsetfield (L, -2, name); + return *this; + } + + //-------------------------------------------------------------------------- + /** + Add or replace a data member. + */ + template + Class & addData (char const* name, const U T::* mp, bool isWritable = true) + { + typedef const U T::*mp_t; + + // Add to __propget in class and const tables. + { + rawgetfield (L, -2, "__propget"); + rawgetfield (L, -4, "__propget"); + new (lua_newuserdata (L, sizeof (mp_t))) mp_t (mp); + lua_pushcclosure (L, &CFunc::getProperty , 1); + lua_pushvalue (L, -1); + rawsetfield (L, -4, name); + rawsetfield (L, -2, name); + lua_pop (L, 2); + } + + if (isWritable) + { + // Add to __propset in class table. + rawgetfield (L, -2, "__propset"); + assert (lua_istable (L, -1)); + new (lua_newuserdata (L, sizeof (mp_t))) mp_t (mp); + lua_pushcclosure (L, &CFunc::setProperty , 1); + rawsetfield (L, -2, name); + lua_pop (L, 1); + } + + return *this; + } + + //-------------------------------------------------------------------------- + /** + Add or replace a property member. + */ + template + Class & addProperty (char const* name, TG (T::* get) () const, void (T::* set) (TS)) + { + // Add to __propget in class and const tables. + { + rawgetfield (L, -2, "__propget"); + rawgetfield (L, -4, "__propget"); + typedef TG (T::*get_t) () const; + new (lua_newuserdata (L, sizeof (get_t))) get_t (get); + lua_pushcclosure (L, &CFunc::CallConstMember ::f, 1); + lua_pushvalue (L, -1); + rawsetfield (L, -4, name); + rawsetfield (L, -2, name); + lua_pop (L, 2); + } + + { + // Add to __propset in class table. + rawgetfield (L, -2, "__propset"); + assert (lua_istable (L, -1)); + typedef void (T::* set_t) (TS); + new (lua_newuserdata (L, sizeof (set_t))) set_t (set); + lua_pushcclosure (L, &CFunc::CallMember ::f, 1); + rawsetfield (L, -2, name); + lua_pop (L, 1); + } + + return *this; + } + + // read-only + template + Class & addProperty (char const* name, TG (T::* get) () const) + { + // Add to __propget in class and const tables. + rawgetfield (L, -2, "__propget"); + rawgetfield (L, -4, "__propget"); + typedef TG (T::*get_t) () const; + new (lua_newuserdata (L, sizeof (get_t))) get_t (get); + lua_pushcclosure (L, &CFunc::CallConstMember ::f, 1); + lua_pushvalue (L, -1); + rawsetfield (L, -4, name); + rawsetfield (L, -2, name); + lua_pop (L, 2); + + return *this; + } + + //-------------------------------------------------------------------------- + /** + Add or replace a property member, by proxy. + + When a class is closed for modification and does not provide (or cannot + provide) the function signatures necessary to implement get or set for + a property, this will allow non-member functions act as proxies. + + Both the get and the set functions require a T const* and T* in the first + argument respectively. + */ + template + Class & addProperty (char const* name, TG (*get) (T const*), void (*set) (T*, TS)) + { + // Add to __propget in class and const tables. + { + rawgetfield (L, -2, "__propget"); + rawgetfield (L, -4, "__propget"); + typedef TG (*get_t) (T const*); + new (lua_newuserdata (L, sizeof (get_t))) get_t (get); + lua_pushcclosure (L, &CFunc::Call ::f, 1); + lua_pushvalue (L, -1); + rawsetfield (L, -4, name); + rawsetfield (L, -2, name); + lua_pop (L, 2); + } + + if (set != 0) + { + // Add to __propset in class table. + rawgetfield (L, -2, "__propset"); + assert (lua_istable (L, -1)); + typedef void (*set_t) (T*, TS); + new (lua_newuserdata (L, sizeof (set_t))) set_t (set); + lua_pushcclosure (L, &CFunc::Call ::f, 1); + rawsetfield (L, -2, name); + lua_pop (L, 1); + } + + return *this; + } + + // read-only + template + Class & addProperty (char const* name, TG (*get) (T const*)) + { + // Add to __propget in class and const tables. + rawgetfield (L, -2, "__propget"); + rawgetfield (L, -4, "__propget"); + typedef TG (*get_t) (T const*); + new (lua_newuserdata (L, sizeof (get_t))) get_t (get); + lua_pushcclosure (L, &CFunc::Call ::f, 1); + lua_pushvalue (L, -1); + rawsetfield (L, -4, name); + rawsetfield (L, -2, name); + lua_pop (L, 2); + + return *this; + } + + //-------------------------------------------------------------------------- + /** + Add or replace a member function. + */ + template + Class & addFunction (char const* name, MemFn mf) + { + CFunc::CallMemberFunctionHelper ::isConstMemberFunction>::add (L, name, mf); + return *this; + } + + //-------------------------------------------------------------------------- + /** + Add or replace a member lua_CFunction. + */ + Class & addCFunction (char const* name, int (T::*mfp)(lua_State*)) + { + typedef int (T::*MFP)(lua_State*); + assert (lua_istable (L, -1)); + new (lua_newuserdata (L, sizeof (mfp))) MFP (mfp); + lua_pushcclosure (L, &CFunc::CallMemberCFunction ::f, 1); + rawsetfield (L, -3, name); // class table + + return *this; + } + + //-------------------------------------------------------------------------- + /** + Add or replace a const member lua_CFunction. + */ + Class & addCFunction (char const* name, int (T::*mfp)(lua_State*) const) + { + typedef int (T::*MFP)(lua_State*) const; + assert (lua_istable (L, -1)); + new (lua_newuserdata (L, sizeof (mfp))) MFP (mfp); + lua_pushcclosure (L, &CFunc::CallConstMemberCFunction ::f, 1); + lua_pushvalue (L, -1); + rawsetfield (L, -5, name); // const table + rawsetfield (L, -3, name); // class table + + return *this; + } + + //-------------------------------------------------------------------------- + /** + Add or replace a primary Constructor. + + The primary Constructor is invoked when calling the class type table + like a function. + + The template parameter should be a function pointer type that matches + the desired Constructor (since you can't take the address of a Constructor + and pass it as an argument). + */ + template + Class & addConstructor () + { + lua_pushcclosure (L, + &ctorContainerProxy ::Params, C>, 0); + rawsetfield(L, -2, "__call"); + + return *this; + } + + template + Class & addConstructor () + { + lua_pushcclosure (L, + &ctorPlacementProxy ::Params, T>, 0); + rawsetfield(L, -2, "__call"); + + return *this; + } + }; + +private: + //---------------------------------------------------------------------------- + /** + Open the global namespace for registrations. + */ + explicit Namespace (lua_State* L_) + : L (L_) + , m_stackSize (0) + { + lua_getglobal (L, "_G"); + ++m_stackSize; + } + + //---------------------------------------------------------------------------- + /** + Open a namespace for registrations. + + The namespace is created if it doesn't already exist. + The parent namespace is at the top of the Lua stack. + */ + Namespace (char const* name, Namespace const* parent) + : L (parent->L) + , m_stackSize (0) + { + m_stackSize = parent->m_stackSize + 1; + parent->m_stackSize = 0; + + assert (lua_istable (L, -1)); + rawgetfield (L, -1, name); + if (lua_isnil (L, -1)) + { + lua_pop (L, 1); + + lua_newtable (L); + lua_pushvalue (L, -1); + lua_setmetatable (L, -2); + lua_pushcfunction (L, &CFunc::indexMetaMethod); + rawsetfield (L, -2, "__index"); + lua_pushcfunction (L, &CFunc::newindexMetaMethod); + rawsetfield (L, -2, "__newindex"); + lua_newtable (L); + rawsetfield (L, -2, "__propget"); + lua_newtable (L); + rawsetfield (L, -2, "__propset"); + lua_pushvalue (L, -1); + rawsetfield (L, -3, name); +#if 0 + lua_pushcfunction (L, &tostringMetaMethod); + rawsetfield (L, -2, "__tostring"); +#endif + } + } + + //---------------------------------------------------------------------------- + /** + Creates a continued registration from a child namespace. + */ + explicit Namespace (Namespace const* child) + : L (child->L) + , m_stackSize (0) + { + m_stackSize = child->m_stackSize - 1; + child->m_stackSize = 1; + child->pop (1); + + // It is not necessary or valid to call + // endNamespace() for the global namespace! + // + assert (m_stackSize != 0); + } + + //---------------------------------------------------------------------------- + /** + Creates a continued registration from a child class. + */ + explicit Namespace (ClassBase const* child) + : L (child->L) + , m_stackSize (0) + { + m_stackSize = child->m_stackSize - 3; + child->m_stackSize = 3; + child->pop (3); + } + +public: + //---------------------------------------------------------------------------- + /** + Copy Constructor. + + Ownership of the stack is transferred to the new object. This happens + when the compiler emits temporaries to hold these objects while chaining + registrations across namespaces. + */ + Namespace (Namespace const& other) : L (other.L) + { + m_stackSize = other.m_stackSize; + other.m_stackSize = 0; + } + + //---------------------------------------------------------------------------- + /** + Closes this namespace registration. + */ + ~Namespace () + { + pop (m_stackSize); + } + + //---------------------------------------------------------------------------- + /** + Open the global namespace. + */ + static Namespace getGlobalNamespace (lua_State* L) + { + return Namespace (L); + } + + //---------------------------------------------------------------------------- + /** + Open a new or existing namespace for registrations. + */ + Namespace beginNamespace (char const* name) + { + return Namespace (name, this); + } + + //---------------------------------------------------------------------------- + /** + Continue namespace registration in the parent. + + Do not use this on the global namespace. + */ + Namespace endNamespace () + { + return Namespace (this); + } + + //---------------------------------------------------------------------------- + /** + Add or replace a variable. + */ + template + Namespace& addVariable (char const* name, T* pt, bool isWritable = true) + { + assert (lua_istable (L, -1)); + + rawgetfield (L, -1, "__propget"); + assert (lua_istable (L, -1)); + lua_pushlightuserdata (L, pt); + lua_pushcclosure (L, &CFunc::getVariable , 1); + rawsetfield (L, -2, name); + lua_pop (L, 1); + + rawgetfield (L, -1, "__propset"); + assert (lua_istable (L, -1)); + if (isWritable) + { + lua_pushlightuserdata (L, pt); + lua_pushcclosure (L, &CFunc::setVariable , 1); + } + else + { + lua_pushstring (L, name); + lua_pushcclosure (L, &CFunc::readOnlyError, 1); + } + rawsetfield (L, -2, name); + lua_pop (L, 1); + + return *this; + } + + //---------------------------------------------------------------------------- + /** + Add or replace a property. + + If the set function is omitted or null, the property is read-only. + */ + template + Namespace& addProperty (char const* name, TG (*get) (), void (*set)(TS) = 0) + { + assert (lua_istable (L, -1)); + + rawgetfield (L, -1, "__propget"); + assert (lua_istable (L, -1)); + typedef TG (*get_t) (); + new (lua_newuserdata (L, sizeof (get_t))) get_t (get); + lua_pushcclosure (L, &CFunc::Call ::f, 1); + rawsetfield (L, -2, name); + lua_pop (L, 1); + + rawgetfield (L, -1, "__propset"); + assert (lua_istable (L, -1)); + if (set != 0) + { + typedef void (*set_t) (TS); + new (lua_newuserdata (L, sizeof (set_t))) set_t (set); + lua_pushcclosure (L, &CFunc::Call ::f, 1); + } + else + { + lua_pushstring (L, name); + lua_pushcclosure (L, &CFunc::readOnlyError, 1); + } + rawsetfield (L, -2, name); + lua_pop (L, 1); + + return *this; + } + + //---------------------------------------------------------------------------- + /** + Add or replace a free function. + */ + template + Namespace& addFunction (char const* name, FP const fp) + { + assert (lua_istable (L, -1)); + + new (lua_newuserdata (L, sizeof (fp))) FP (fp); + lua_pushcclosure (L, &CFunc::Call ::f, 1); + rawsetfield (L, -2, name); + + return *this; + } + + //---------------------------------------------------------------------------- + /** + Add or replace a lua_CFunction. + */ + Namespace& addCFunction (char const* name, int (*const fp)(lua_State*)) + { + lua_pushcfunction (L, fp); + rawsetfield (L, -2, name); + + return *this; + } + + //---------------------------------------------------------------------------- + /** + Open a new or existing class for registrations. + */ + template + Class beginClass (char const* name) + { + return Class (name, this); + } + + //---------------------------------------------------------------------------- + /** + Derive a new class for registrations. + + To continue registrations for the class later, use beginClass(). + Do not call deriveClass() again. + */ + template + Class deriveClass (char const* name) + { + return Class (name, this, ClassInfo ::getStaticKey ()); + } +}; + +//------------------------------------------------------------------------------ +/** + Retrieve the global namespace. + + It is recommended to put your namespace inside the global namespace, and + then add your classes and functions to it, rather than adding many classes + and functions directly to the global namespace. +*/ +inline Namespace getGlobalNamespace (lua_State* L) +{ + return Namespace::getGlobalNamespace (L); +} diff --git a/extern/luabridge/detail/Stack.h b/extern/luabridge/detail/Stack.h new file mode 100644 index 0000000..1a0aae7 --- /dev/null +++ b/extern/luabridge/detail/Stack.h @@ -0,0 +1,469 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + Copyright 2007, Nathan Reed + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +//------------------------------------------------------------------------------ +/** + Receive the lua_State* as an argument. +*/ +template <> +struct Stack +{ + static lua_State* get (lua_State* L, int) + { + return L; + } +}; + +//------------------------------------------------------------------------------ +/** + Push a lua_CFunction. +*/ +template <> +struct Stack +{ + static void push (lua_State* L, lua_CFunction f) + { + lua_pushcfunction (L, f); + } + + static lua_CFunction get (lua_State* L, int index) + { + return lua_tocfunction (L, index); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `int`. +*/ +template <> +struct Stack +{ + static inline void push (lua_State* L, int value) + { + lua_pushinteger (L, static_cast (value)); + } + + static inline int get (lua_State* L, int index) + { + return static_cast (luaL_checkinteger (L, index)); + } +}; + +template <> +struct Stack +{ + static inline void push (lua_State* L, int value) + { + lua_pushnumber (L, static_cast (value)); + } + + static inline int get (lua_State* L, int index) + { + return static_cast (luaL_checknumber (L, index)); + } +}; +//------------------------------------------------------------------------------ +/** + Stack specialization for `unsigned int`. +*/ +template <> +struct Stack +{ + static inline void push (lua_State* L, unsigned int value) + { + lua_pushinteger (L, static_cast (value)); + } + + static inline unsigned int get (lua_State* L, int index) + { + return static_cast (luaL_checkinteger (L, index)); + } +}; + +template <> +struct Stack +{ + static inline void push (lua_State* L, unsigned int value) + { + lua_pushnumber (L, static_cast (value)); + } + + static inline unsigned int get (lua_State* L, int index) + { + return static_cast (luaL_checknumber (L, index)); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `unsigned char`. +*/ +template <> +struct Stack +{ + static inline void push (lua_State* L, unsigned char value) + { + lua_pushinteger (L, static_cast (value)); + } + + static inline unsigned char get (lua_State* L, int index) + { + return static_cast (luaL_checkinteger (L, index)); + } +}; + +template <> +struct Stack +{ + static inline void push (lua_State* L, unsigned char value) + { + lua_pushnumber (L, static_cast (value)); + } + + static inline unsigned char get (lua_State* L, int index) + { + return static_cast (luaL_checknumber (L, index)); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `short`. +*/ +template <> +struct Stack +{ + static inline void push (lua_State* L, short value) + { + lua_pushinteger (L, static_cast (value)); + } + + static inline short get (lua_State* L, int index) + { + return static_cast (luaL_checkinteger (L, index)); + } +}; + +template <> +struct Stack +{ + static inline void push (lua_State* L, short value) + { + lua_pushnumber (L, static_cast (value)); + } + + static inline short get (lua_State* L, int index) + { + return static_cast (luaL_checknumber (L, index)); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `unsigned short`. +*/ +template <> +struct Stack +{ + static inline void push (lua_State* L, unsigned short value) + { + lua_pushinteger (L, static_cast (value)); + } + + static inline unsigned short get (lua_State* L, int index) + { + return static_cast (luaL_checkinteger (L, index)); + } +}; + +template <> +struct Stack +{ + static inline void push (lua_State* L, unsigned short value) + { + lua_pushnumber (L, static_cast (value)); + } + + static inline unsigned short get (lua_State* L, int index) + { + return static_cast (luaL_checknumber (L, index)); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `long`. +*/ +template <> +struct Stack +{ + static inline void push (lua_State* L, long value) + { + lua_pushinteger (L, static_cast (value)); + } + + static inline long get (lua_State* L, int index) + { + return static_cast (luaL_checkinteger (L, index)); + } +}; + +template <> +struct Stack +{ + static inline void push (lua_State* L, long value) + { + lua_pushnumber (L, static_cast (value)); + } + + static inline long get (lua_State* L, int index) + { + return static_cast (luaL_checknumber (L, index)); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `unsigned long`. +*/ +template <> +struct Stack +{ + static inline void push (lua_State* L, unsigned long value) + { + lua_pushinteger (L, static_cast (value)); + } + + static inline unsigned long get (lua_State* L, int index) + { + return static_cast (luaL_checkinteger (L, index)); + } +}; + +template <> +struct Stack +{ + static inline void push (lua_State* L, unsigned long value) + { + lua_pushnumber (L, static_cast (value)); + } + + static inline unsigned long get (lua_State* L, int index) + { + return static_cast (luaL_checknumber (L, index)); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `float`. +*/ +template <> +struct Stack +{ + static inline void push (lua_State* L, float value) + { + lua_pushnumber (L, static_cast (value)); + } + + static inline float get (lua_State* L, int index) + { + return static_cast (luaL_checknumber (L, index)); + } +}; + +template <> +struct Stack +{ + static inline void push (lua_State* L, float value) + { + lua_pushnumber (L, static_cast (value)); + } + + static inline float get (lua_State* L, int index) + { + return static_cast (luaL_checknumber (L, index)); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `double`. +*/ +template <> struct Stack +{ + static inline void push (lua_State* L, double value) + { + lua_pushnumber (L, static_cast (value)); + } + + static inline double get (lua_State* L, int index) + { + return static_cast (luaL_checknumber (L, index)); + } +}; + +template <> struct Stack +{ + static inline void push (lua_State* L, double value) + { + lua_pushnumber (L, static_cast (value)); + } + + static inline double get (lua_State* L, int index) + { + return static_cast (luaL_checknumber (L, index)); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `bool`. +*/ +template <> +struct Stack { + static inline void push (lua_State* L, bool value) + { + lua_pushboolean (L, value ? 1 : 0); + } + + static inline bool get (lua_State* L, int index) + { + return lua_toboolean (L, index) ? true : false; + } +}; + +template <> +struct Stack { + static inline void push (lua_State* L, bool value) + { + lua_pushboolean (L, value ? 1 : 0); + } + + static inline bool get (lua_State* L, int index) + { + return lua_toboolean (L, index) ? true : false; + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `char`. +*/ +template <> +struct Stack +{ + static inline void push (lua_State* L, char value) + { + char str [2] = { value, 0 }; + lua_pushstring (L, str); + } + + static inline char get (lua_State* L, int index) + { + return luaL_checkstring (L, index) [0]; + } +}; + +template <> +struct Stack +{ + static inline void push (lua_State* L, char value) + { + char str [2] = { value, 0 }; + lua_pushstring (L, str); + } + + static inline char get (lua_State* L, int index) + { + return luaL_checkstring (L, index) [0]; + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `float`. +*/ +template <> +struct Stack +{ + static inline void push (lua_State* L, char const* str) + { + if (str != 0) + lua_pushstring (L, str); + else + lua_pushnil (L); + } + + static inline char const* get (lua_State* L, int index) + { + return lua_isnil (L, index) ? 0 : luaL_checkstring (L, index); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `std::string`. +*/ +template <> +struct Stack +{ + static inline void push (lua_State* L, std::string const& str) + { + lua_pushlstring (L, str.c_str (), str.size()); + } + + static inline std::string get (lua_State* L, int index) + { + size_t len; + const char *str = luaL_checklstring(L, index, &len); + return std::string (str, len); + } +}; + +//------------------------------------------------------------------------------ +/** + Stack specialization for `std::string const&`. +*/ +template <> +struct Stack +{ + static inline void push (lua_State* L, std::string const& str) + { + lua_pushstring (L, str.c_str()); + } + + static inline std::string get (lua_State* L, int index) + { + size_t len; + const char *str = luaL_checklstring(L, index, &len); + return std::string (str, len); + } +}; diff --git a/extern/luabridge/detail/TypeList.h b/extern/luabridge/detail/TypeList.h new file mode 100644 index 0000000..21f850e --- /dev/null +++ b/extern/luabridge/detail/TypeList.h @@ -0,0 +1,174 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + Copyright 2007, Nathan Reed + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + + This file incorporates work covered by the following copyright and + permission notice: + + The Loki Library + Copyright (c) 2001 by Andrei Alexandrescu + This code accompanies the book: + Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design + Patterns Applied". Copyright (c) 2001. Addison-Wesley. + Permission to use, copy, modify, distribute and sell this software for any + purpose is hereby granted without fee, provided that the above copyright + notice appear in all copies and that both that copyright notice and this + permission notice appear in supporting documentation. + The author or Addison-Welsey Longman make no representations about the + suitability of this software for any purpose. It is provided "as is" + without express or implied warranty. +*/ +//============================================================================== + +/** + None type means void parameters or return value. +*/ +typedef void None; + +template +struct TypeList +{ +}; + +/** + A TypeList with actual values. +*/ +template +struct TypeListValues +{ + static std::string const tostring (bool) + { + return ""; + } +}; + +/** + TypeListValues recursive template definition. +*/ +template +struct TypeListValues > +{ + Head hd; + TypeListValues tl; + + TypeListValues (Head hd_, TypeListValues const& tl_) + : hd (hd_), tl (tl_) + { + } + + static std::string const tostring (bool comma = false) + { + std::string s; + + if (comma) + s = ", "; + + s = s + typeid (Head).name (); + + return s + TypeListValues ::tostring (true); + } +}; + +// Specializations of type/value list for head types that are references and +// const-references. We need to handle these specially since we can't count +// on the referenced object hanging around for the lifetime of the list. + +template +struct TypeListValues > +{ + Head hd; + TypeListValues tl; + + TypeListValues (Head& hd_, TypeListValues const& tl_) + : hd (hd_), tl (tl_) + { + } + + static std::string const tostring (bool comma = false) + { + std::string s; + + if (comma) + s = ", "; + + s = s + typeid (Head).name () + "&"; + + return s + TypeListValues ::tostring (true); + } +}; + +template +struct TypeListValues > +{ + Head hd; + TypeListValues tl; + + TypeListValues (Head const& hd_, const TypeListValues & tl_) + : hd (hd_), tl (tl_) + { + } + + static std::string const tostring (bool comma = false) + { + std::string s; + + if (comma) + s = ", "; + + s = s + typeid (Head).name () + " const&"; + + return s + TypeListValues ::tostring (true); + } +}; + +//============================================================================== +/** + Subclass of a TypeListValues constructable from the Lua stack. +*/ + +template +struct ArgList +{ +}; + +template +struct ArgList : public TypeListValues +{ + ArgList (lua_State*) + { + } +}; + +template +struct ArgList , Start> + : public TypeListValues > +{ + ArgList (lua_State* L) + : TypeListValues > (Stack ::get (L, Start), + ArgList (L)) + { + } +}; diff --git a/extern/luabridge/detail/TypeTraits.h b/extern/luabridge/detail/TypeTraits.h new file mode 100644 index 0000000..5dd0771 --- /dev/null +++ b/extern/luabridge/detail/TypeTraits.h @@ -0,0 +1,125 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +#ifndef LUABRIDGE_TYPEINFO_HEADER +#define LUABRIDGE_TYPEINFO_HEADER + +//------------------------------------------------------------------------------ +/** + Container traits. + + Unspecialized ContainerTraits has the isNotContainer typedef for SFINAE. + All user defined containers must supply an appropriate specialization for + ContinerTraits (without the typedef isNotContainer). The containers that + come with LuaBridge also come with the appropriate ContainerTraits + specialization. See the corresponding declaration for details. + + A specialization of ContainerTraits for some generic type ContainerType + looks like this: + + template + struct ContainerTraits > + { + typedef typename T Type; + + static T* get (ContainerType const& c) + { + return c.get (); // Implementation-dependent on ContainerType + } + }; +*/ +template +struct ContainerTraits +{ + typedef bool isNotContainer; +}; + +//------------------------------------------------------------------------------ +/** + Type traits. + + Specializations return information about a type. +*/ +struct TypeTraits +{ + /** Determine if type T is a container. + + To be considered a container, there must be a specialization of + ContainerTraits with the required fields. + */ + template + class isContainer + { + private: + typedef char yes[1]; // sizeof (yes) == 1 + typedef char no [2]; // sizeof (no) == 2 + + template + static no& test (typename C::isNotContainer*); + + template + static yes& test (...); + + public: + static const bool value = sizeof (test >(0)) == sizeof (yes); + }; + + /** Determine if T is const qualified. + */ + /** @{ */ + template + struct isConst + { + static bool const value = false; + }; + + template + struct isConst + { + static bool const value = true; + }; + /** @} */ + + /** Remove the const qualifier from T. + */ + /** @{ */ + template + struct removeConst + { + typedef T Type; + }; + + template + struct removeConst + { + typedef T Type; + }; + /**@}*/ +}; + +#endif diff --git a/extern/luabridge/detail/Userdata.h b/extern/luabridge/detail/Userdata.h new file mode 100644 index 0000000..19451bd --- /dev/null +++ b/extern/luabridge/detail/Userdata.h @@ -0,0 +1,817 @@ +//------------------------------------------------------------------------------ +/* + https://github.com/vinniefalco/LuaBridge + + Copyright 2012, Vinnie Falco + + License: The MIT License (http://www.opensource.org/licenses/mit-license.php) + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ +//============================================================================== + +//============================================================================== +/** + Return the identity pointer for our lightuserdata tokens. + + LuaBridge metatables are tagged with a security "token." The token is a + lightuserdata created from the identity pointer, used as a key in the + metatable. The value is a boolean = true, although any value could have been + used. + + Because of Lua's dynamic typing and our improvised system of imposing C++ + class structure, there is the possibility that executing scripts may + knowingly or unknowingly cause invalid data to get passed to the C functions + created by LuaBridge. In particular, our security model addresses the + following: + + Notes: + 1. Scripts cannot create a userdata (ignoring the debug lib). + 2. Scripts cannot create a lightuserdata (ignoring the debug lib). + 3. Scripts cannot set the metatable on a userdata. + 4. Our identity key is a unique pointer in the process. + 5. Our metatables have a lightuserdata identity key / value pair. + 6. Our metatables have "__metatable" set to a boolean = false. + 7. Our lightuserdata is unique. +*/ +inline void* getIdentityKey () +{ + static char value; + return &value; +} + +/** + Interface to a class pointer retrievable from a userdata. +*/ +class Userdata +{ +protected: + void* m_p; // subclasses must set this + + //-------------------------------------------------------------------------- + /** + Get an untyped pointer to the contained class. + */ + inline void* const getPointer () + { + return m_p; + } + +private: + //-------------------------------------------------------------------------- + /** + Validate and retrieve a Userdata on the stack. + + The Userdata must exactly match the corresponding class table or + const table, or else a Lua error is raised. This is used for the + __gc metamethod. + */ + static Userdata* getExactClass (lua_State* L, + int narg, + void const* classKey) + { + Userdata* ud = 0; + int const index = lua_absindex (L, narg); + + bool mismatch = false; + char const* got = 0; + + lua_rawgetp (L, LUA_REGISTRYINDEX, classKey); + assert (lua_istable (L, -1)); + + // Make sure we have a userdata. + if (!lua_isuserdata (L, index)) + mismatch = true; + + // Make sure it's metatable is ours. + if (!mismatch) + { + lua_getmetatable (L, index); + lua_rawgetp (L, -1, getIdentityKey ()); + if (lua_isboolean (L, -1)) + { + lua_pop (L, 1); + } + else + { + lua_pop (L, 2); + mismatch = true; + } + } + + if (!mismatch) + { + if (lua_rawequal (L, -1, -2)) + { + // Matches class table. + lua_pop (L, 2); + ud = static_cast (lua_touserdata (L, index)); + } + else + { + rawgetfield (L, -2, "__const"); + if (lua_rawequal (L, -1, -2)) + { + // Matches const table + lua_pop (L, 3); + ud = static_cast (lua_touserdata (L, index)); + } + else + { + // Mismatch, but its one of ours so get a type name. + rawgetfield (L, -2, "__type"); + lua_insert (L, -4); + lua_pop (L, 2); + got = lua_tostring (L, -2); + mismatch = true; + } + } + } + + if (mismatch) + { + rawgetfield (L, -1, "__type"); + assert (lua_type (L, -1) == LUA_TSTRING); + char const* const expected = lua_tostring (L, -1); + + if (got == 0) + got = lua_typename (L, lua_type (L, index)); + + char const* const msg = lua_pushfstring ( + L, "%s expected, got %s", expected, got); + + if (narg > 0) + luaL_argerror (L, narg, msg); + else + lua_error (L); + } + + return ud; + } + + //-------------------------------------------------------------------------- + /** + Validate and retrieve a Userdata on the stack. + + The Userdata must be derived from or the same as the given base class, + identified by the key. If canBeConst is false, generates an error if + the resulting Userdata represents to a const object. We do the type check + first so that the error message is informative. + */ + static Userdata* getClass (lua_State* L, + int index, + void const* baseClassKey, + bool canBeConst) + { + assert (index > 0); + Userdata* ud = 0; + + bool mismatch = false; + char const* got = 0; + + lua_rawgetp (L, LUA_REGISTRYINDEX, baseClassKey); + assert (lua_istable (L, -1)); + + // Make sure we have a userdata. + if (lua_isuserdata (L, index)) + { + // Make sure it's metatable is ours. + lua_getmetatable (L, index); + lua_rawgetp (L, -1, getIdentityKey ()); + if (lua_isboolean (L, -1)) + { + lua_pop (L, 1); + + // If __const is present, object is NOT const. + rawgetfield (L, -1, "__const"); + assert (lua_istable (L, -1) || lua_isnil (L, -1)); + bool const isConst = lua_isnil (L, -1); + lua_pop (L, 1); + + // Replace the class table with the const table if needed. + if (isConst) + { + rawgetfield (L, -2, "__const"); + assert (lua_istable (L, -1)); + lua_replace (L, -3); + } + + for (;;) + { + if (lua_rawequal (L, -1, -2)) + { + lua_pop (L, 2); + + // Match, now check const-ness. + if (isConst && !canBeConst) + { + luaL_argerror (L, index, "cannot be const"); + } + else + { + ud = static_cast (lua_touserdata (L, index)); + break; + } + } + else + { + // Replace current metatable with it's base class. + rawgetfield (L, -1, "__parent"); +/* +ud +class metatable +ud metatable +ud __parent (nil) +*/ + + if (lua_isnil (L, -1)) + { + lua_remove (L, -1); + // Mismatch, but its one of ours so get a type name. + rawgetfield (L, -1, "__type"); + lua_insert (L, -3); + lua_pop (L, 1); + got = lua_tostring (L, -2); + mismatch = true; + break; + } + else + { + lua_remove (L, -2); + } + } + } + } + else + { + lua_pop (L, 2); + mismatch = true; + } + } + else + { + mismatch = true; + } + + if (mismatch) + { + assert (lua_type (L, -1) == LUA_TTABLE); + rawgetfield (L, -1, "__type"); + assert (lua_type (L, -1) == LUA_TSTRING); + char const* const expected = lua_tostring (L, -1); + + if (got == 0) + got = lua_typename (L, lua_type (L, index)); + + char const* const msg = lua_pushfstring ( + L, "%s expected, got %s", expected, got); + + luaL_argerror (L, index, msg); + } + + return ud; + } + +public: + virtual ~Userdata () { } + + //-------------------------------------------------------------------------- + /** + Returns the Userdata* if the class on the Lua stack matches. + + If the class does not match, a Lua error is raised. + */ + template + static inline Userdata* getExact (lua_State* L, int index) + { + return getExactClass (L, index, ClassInfo ::getClassKey ()); + } + + //-------------------------------------------------------------------------- + /** + Get a pointer to the class from the Lua stack. + + If the object is not the class or a subclass, or it violates the + const-ness, a Lua error is raised. + */ + template + static inline T* get (lua_State* L, int index, bool canBeConst) + { + if (lua_isnil (L, index)) + return 0; + else + return static_cast (getClass (L, index, + ClassInfo ::getClassKey (), canBeConst)->getPointer ()); + } +}; + +//---------------------------------------------------------------------------- +/** + Wraps a class object stored in a Lua userdata. + + The lifetime of the object is managed by Lua. The object is constructed + inside the userdata using placement new. +*/ +template +class UserdataValue : public Userdata +{ +private: + UserdataValue (UserdataValue const&); + UserdataValue operator= (UserdataValue const&); + + char m_storage [sizeof (T)]; + + inline T* getObject () + { + // If this fails to compile it means you forgot to provide + // a Container specialization for your container! + // + return reinterpret_cast (&m_storage [0]); + } + +private: + /** + Used for placement construction. + */ + UserdataValue () + { + m_p = getObject (); + } + + ~UserdataValue () + { + getObject ()->~T (); + } + +public: + /** + Push a T via placement new. + + The caller is responsible for calling placement new using the + returned uninitialized storage. + */ + static void* place (lua_State* const L) + { + UserdataValue * const ud = new ( + lua_newuserdata (L, sizeof (UserdataValue ))) UserdataValue (); + lua_rawgetp (L, LUA_REGISTRYINDEX, ClassInfo ::getClassKey ()); + // If this goes off it means you forgot to register the class! + assert (lua_istable (L, -1)); + lua_setmetatable (L, -2); + return ud->getPointer (); + } + + /** + Push T via copy construction from U. + */ + template + static inline void push (lua_State* const L, U const& u) + { + new (place (L)) U (u); + } +}; + +//---------------------------------------------------------------------------- +/** + Wraps a pointer to a class object inside a Lua userdata. + + The lifetime of the object is managed by C++. +*/ +class UserdataPtr : public Userdata +{ +private: + UserdataPtr (UserdataPtr const&); + UserdataPtr operator= (UserdataPtr const&); + +private: + /** Push non-const pointer to object using metatable key. + */ + static void push (lua_State* L, void* const p, void const* const key) + { + if (p) + { + new (lua_newuserdata (L, sizeof (UserdataPtr))) UserdataPtr (p); + lua_rawgetp (L, LUA_REGISTRYINDEX, key); + // If this goes off it means you forgot to register the class! + assert (lua_istable (L, -1)); + lua_setmetatable (L, -2); + } + else + { + lua_pushnil (L); + } + } + + /** Push const pointer to object using metatable key. + */ + static void push (lua_State* L, void const* const p, void const* const key) + { + if (p) + { + new (lua_newuserdata (L, sizeof (UserdataPtr))) + UserdataPtr (const_cast (p)); + lua_rawgetp (L, LUA_REGISTRYINDEX, key); + // If this goes off it means you forgot to register the class! + assert (lua_istable (L, -1)); + lua_setmetatable (L, -2); + } + else + { + lua_pushnil (L); + } + } + + explicit UserdataPtr (void* const p) + { + m_p = p; + + // Can't construct with a null pointer! + // + assert (m_p != 0); + } + +public: + /** Push non-const pointer to object. + */ + template + static inline void push (lua_State* const L, T* const p) + { + if (p) + push (L, p, ClassInfo ::getClassKey ()); + else + lua_pushnil (L); + } + + /** Push const pointer to object. + */ + template + static inline void push (lua_State* const L, T const* const p) + { + if (p) + push (L, p, ClassInfo ::getConstKey ()); + else + lua_pushnil (L); + } +}; + +//============================================================================ +/** + Wraps a container thet references a class object. + + The template argument C is the container type, ContainerTraits must be + specialized on C or else a compile error will result. +*/ +template +class UserdataShared : public Userdata +{ +private: + UserdataShared (UserdataShared const&); + UserdataShared & operator= (UserdataShared const&); + + typedef typename TypeTraits::removeConst < + typename ContainerTraits ::Type>::Type T; + + C m_c; + +private: + ~UserdataShared () + { + } + +public: + /** + Construct from a container to the class or a derived class. + */ + template + explicit UserdataShared (U const& u) : m_c (u) + { + m_p = const_cast (reinterpret_cast ( + (ContainerTraits ::get (m_c)))); + } + + /** + Construct from a pointer to the class or a derived class. + */ + template + explicit UserdataShared (U* u) : m_c (u) + { + m_p = const_cast (reinterpret_cast ( + (ContainerTraits ::get (m_c)))); + } +}; + +//---------------------------------------------------------------------------- +// +// SFINAE helpers. +// + +// non-const objects +template +struct UserdataSharedHelper +{ + typedef typename TypeTraits::removeConst < + typename ContainerTraits ::Type>::Type T; + + static void push (lua_State* L, C const& c) + { + if (ContainerTraits ::get (c) != 0) + { + new (lua_newuserdata (L, sizeof (UserdataShared ))) UserdataShared (c); + lua_rawgetp (L, LUA_REGISTRYINDEX, ClassInfo ::getClassKey ()); + // If this goes off it means the class T is unregistered! + assert (lua_istable (L, -1)); + lua_setmetatable (L, -2); + } + else + { + lua_pushnil (L); + } + } + + static void push (lua_State* L, T* const t) + { + if (t) + { + new (lua_newuserdata (L, sizeof (UserdataShared ))) UserdataShared (t); + lua_rawgetp (L, LUA_REGISTRYINDEX, ClassInfo ::getClassKey ()); + // If this goes off it means the class T is unregistered! + assert (lua_istable (L, -1)); + lua_setmetatable (L, -2); + } + else + { + lua_pushnil (L); + } + } +}; + +// const objects +template +struct UserdataSharedHelper +{ + typedef typename TypeTraits::removeConst < + typename ContainerTraits ::Type>::Type T; + + static void push (lua_State* L, C const& c) + { + if (ContainerTraits ::get (c) != 0) + { + new (lua_newuserdata (L, sizeof (UserdataShared ))) UserdataShared (c); + lua_rawgetp (L, LUA_REGISTRYINDEX, ClassInfo ::getConstKey ()); + // If this goes off it means the class T is unregistered! + assert (lua_istable (L, -1)); + lua_setmetatable (L, -2); + } + else + { + lua_pushnil (L); + } + } + + static void push (lua_State* L, T* const t) + { + if (t) + { + new (lua_newuserdata (L, sizeof (UserdataShared ))) UserdataShared (t); + lua_rawgetp (L, LUA_REGISTRYINDEX, ClassInfo ::getConstKey ()); + // If this goes off it means the class T is unregistered! + assert (lua_istable (L, -1)); + lua_setmetatable (L, -2); + } + else + { + lua_pushnil (L); + } + } +}; + +/** + Pass by container. + + The container controls the object lifetime. Typically this will be a + lifetime shared by C++ and Lua using a reference count. Because of type + erasure, containers like std::shared_ptr will not work. Containers must + either be of the intrusive variety, or in the style of the RefCountedPtr + type provided by LuaBridge (that uses a global hash table). +*/ +template +struct StackHelper +{ + static inline void push (lua_State* L, C const& c) + { + UserdataSharedHelper ::Type>::value>::push (L, c); + } + + typedef typename TypeTraits::removeConst < + typename ContainerTraits ::Type>::Type T; + + static inline C get (lua_State* L, int index) + { + return Userdata::get (L, index, true); + } +}; + +/** + Pass by value. + + Lifetime is managed by Lua. A C++ function which accesses a pointer or + reference to an object outside the activation record in which it was + retrieved may result in undefined behavior if Lua garbage collected it. +*/ +template +struct StackHelper +{ + static inline void push (lua_State* L, T const& t) + { + UserdataValue ::push (L, t); + } + + static inline T const& get (lua_State* L, int index) + { + return *Userdata::get (L, index, true); + } +}; + +//============================================================================== + +/** + Lua stack conversions for class objects passed by value. +*/ +template +struct Stack +{ +public: + static inline void push (lua_State* L, T const& t) + { + StackHelper ::value>::push (L, t); + } + + static inline T get (lua_State* L, int index) + { + return StackHelper ::value>::get (L, index); + } +}; + +//------------------------------------------------------------------------------ +/** + Lua stack conversions for pointers and references to class objects. + + Lifetime is managed by C++. Lua code which remembers a reference to the + value may result in undefined behavior if C++ destroys the object. The + handling of the const and volatile qualifiers happens in UserdataPtr. +*/ + +// pointer +template +struct Stack +{ + static inline void push (lua_State* L, T* const p) + { + UserdataPtr::push (L, p); + } + + static inline T* const get (lua_State* L, int index) + { + return Userdata::get (L, index, false); + } +}; + +// Strips the const off the right side of * +template +struct Stack +{ + static inline void push (lua_State* L, T* const p) + { + UserdataPtr::push (L, p); + } + + static inline T* const get (lua_State* L, int index) + { + return Userdata::get (L, index, false); + } +}; + +// pointer to const +template +struct Stack +{ + static inline void push (lua_State* L, T const* const p) + { + UserdataPtr::push (L, p); + } + + static inline T const* const get (lua_State* L, int index) + { + return Userdata::get (L, index, true); + } +}; + +// Strips the const off the right side of * +template +struct Stack +{ + static inline void push (lua_State* L, T const* const p) + { + UserdataPtr::push (L, p); + } + + static inline T const* const get (lua_State* L, int index) + { + return Userdata::get (L, index, true); + } +}; + +// reference +template +struct Stack +{ + static inline void push (lua_State* L, T& t) + { + UserdataPtr::push (L, &t); + } + + static T& get (lua_State* L, int index) + { + T* const t = Userdata::get (L, index, false); + if (!t) + luaL_error (L, "nil passed to reference"); + return *t; + } +}; + +template +struct RefStackHelper +{ + typedef C return_type; + + static inline void push (lua_State* L, C const& t) + { + UserdataSharedHelper ::Type>::value>::push (L, t); + } + + typedef typename TypeTraits::removeConst < + typename ContainerTraits ::Type>::Type T; + + static return_type get (lua_State* L, int index) + { + return Userdata::get (L, index, true); + } +}; + +template +struct RefStackHelper +{ + typedef T const& return_type; + + static inline void push (lua_State* L, T const& t) + { + UserdataPtr::push (L, &t); + } + + static return_type get (lua_State* L, int index) + { + T const* const t = Userdata::get (L, index, true); + + if (!t) + luaL_error (L, "nil passed to reference"); + return *t; + } + +}; + +// reference to const +template +struct Stack +{ + typedef RefStackHelper ::value> helper_t; + + static inline void push (lua_State* L, T const& t) + { + helper_t::push (L, t); + } + + static typename helper_t::return_type get (lua_State* L, int index) + { + return helper_t::get (L, index); + } +}; diff --git a/extern/luabridge/detail/dump.h b/extern/luabridge/detail/dump.h new file mode 100644 index 0000000..c066803 --- /dev/null +++ b/extern/luabridge/detail/dump.h @@ -0,0 +1,28 @@ +#include +#include + +std::string dumpLuaState(lua_State *L) { + std::stringstream ostr; + int i; + int top = lua_gettop(L); + ostr << "top=" << top << ":\n"; + for (i = 1; i <= top; ++i) { + int t = lua_type(L, i); + switch(t) { + case LUA_TSTRING: + ostr << " " << i << ": '" << lua_tostring(L, i) << "'\n"; + break; + case LUA_TBOOLEAN: + ostr << " " << i << ": " << + (lua_toboolean(L, i) ? "true" : "false") << "\n"; + break; + case LUA_TNUMBER: + ostr << " " << i << ": " << lua_tonumber(L, i) << "\n"; + break; + default: + ostr << " " << i << ": TYPE=" << lua_typename(L, t) << "\n"; + break; + } + } + return ostr.str(); +} diff --git a/level.cc b/level.cc index d78de87..1354d9e 100644 --- a/level.cc +++ b/level.cc @@ -1,5 +1,11 @@ #include "level.hh" #include +extern "C" { +#include "extern/lua/src/lua.h" +#include "extern/lua/src/lualib.h" +#include "extern/lua/src/lauxlib.h" +} +#include "extern/luabridge/LuaBridge.h" using namespace tinyxml2; //dowadiddydiddydumdiddydo @@ -41,6 +47,26 @@ void Level::errorCheck(XMLError error){ } void Level::load() { + //Intialize lua state + lua_State *L = nullptr; + // Check if there's an existing state and close it + if(L != nullptr){ + lua_close(L); + L = nullptr; + } + // Create a new lua state + L = luaL_newstate(); + luaL_openlibs(L); + //Expose the class Level and its functions + luabridge::getGlobalNamespace(L) + .beginClass("Level") + .addFunction("getObjects", &Level::getObjects) + .endClass(); + //Push the level as a global variable + luabridge::push(L, this); + lua_setglobal(L, "Level"); + + this->physics = Physics(); this->physics.init(); @@ -334,7 +360,7 @@ void Level::load() { } errorCheck(xmlTrigger->FirstChildElement("functionPointer")->QueryIntText(&functionPointer_int)); if (object != 0) { - Trigger trigger = Trigger(position, distance, isBigger, object, functionPointer_int, this); + Trigger trigger = Trigger(position, distance, isBigger, object, functionPointer_int, L, this); triggers.push_back(trigger); } else { diff --git a/trigger.cc b/trigger.cc index 5cda732..8450b40 100644 --- a/trigger.cc +++ b/trigger.cc @@ -1,7 +1,7 @@ #include "trigger.hh" #include "level.hh" -Trigger::Trigger(glm::vec3 position, float distance, bool isBigger, Object* object, int functionPointer_int, Level* level) { +Trigger::Trigger(glm::vec3 position, float distance, bool isBigger, Object* object, int functionPointer_int, lua_State* L, Level* level) { this->position=position; this->distance=distance; this->isBigger=isBigger; @@ -27,6 +27,11 @@ Trigger::Trigger(glm::vec3 position, float distance, bool isBigger, Object* obje printf("Trigger function could not be found.\n"); } this->level = level; + this->L = L; + if(L == nullptr){ + printf("L is NULL in trigger!\n"); + } + triggered = false; } Trigger::Trigger(){ @@ -36,21 +41,27 @@ Trigger::~Trigger(){ } void Trigger::triggerUpdate(){ - if (isBigger && (glm::distance(object->getPosition(), position) > distance)) { - (this->*functionPointer)(level); - } - else if (!isBigger && (glm::distance(object->getPosition(), position) < distance)) { - (this->*functionPointer)(level); + if (!triggered){ + if (isBigger && (glm::distance(object->getPosition(), position) > distance)) { + (this->*functionPointer)(level); + luaL_dofile(L, "../Levels/scripts/Level1/deleteRandomObject.lua"); + luabridge::getGlobal(L, "trigger")(); + triggered = true; + } + else if (!isBigger && (glm::distance(object->getPosition(), position) < distance)) { + (this->*functionPointer)(level); + luaL_dofile(L, "../Levels/scripts/Level1/deleteRandomObject.lua"); + luabridge::getGlobal(L, "trigger")(); + triggered = true; + } } } void Trigger::trigger_function_0(Level* level) { - static bool triggered = false; if (!triggered) { int rand = std::rand() % level->getObjects()->size(); level->getObjects()->erase(level->getObjects()->begin() + rand); } - triggered = true; } void Trigger::trigger_function_1(Level* level) { diff --git a/trigger.hh b/trigger.hh index bdc7f8f..1dad2ec 100644 --- a/trigger.hh +++ b/trigger.hh @@ -3,12 +3,18 @@ #include #include "object.hh" +extern "C" { +#include "extern/lua/src/lua.h" +#include "extern/lua/src/lualib.h" +#include "extern/lua/src/lauxlib.h" +} +#include "extern/luabridge/LuaBridge.h" class Level; class Trigger { public: - Trigger(glm::vec3 position, float distance, bool isBigger, Object* object, int functionPointer_int, Level* level); + Trigger(glm::vec3 position, float distance, bool isBigger, Object* object, int functionPointer_int, lua_State* L, Level* level); Trigger(); ~Trigger(); void triggerUpdate(); @@ -19,6 +25,8 @@ class Trigger { Object* object; void (Trigger::*functionPointer)(Level*); Level* level; + bool triggered; + lua_State* L; void trigger_function_0(Level* level); void trigger_function_1(Level* level); void trigger_function_2(Level* level);