[ { "path": ".gitignore", "content": "build\nllvm-lua/*.bc\nllvm-lua/*_bc.h\nsrc/.libs\nsrc/*.o\nsrc/*.lo\nsrc/*.la\nsrc/*.a\nsrc/lua\nsrc/luac\nsrc/lua_test\n.*.swp\n" }, { "path": ".hgignore", "content": "# Backup files\n.*~$\n# Rejected patches\n.*\\.orig$\n.*\\.rej$\n# Build directory\n^build$\n" }, { "path": "AUTHORS", "content": "bobby@neoawareness.com:Robert G. Jakabosky \n" }, { "path": "CMakeLists.txt", "content": "#\n# llvm-lua\n#\ncmake_minimum_required(VERSION 2.4 FATAL_ERROR)\n\nif(COMMAND cmake_policy)\n cmake_policy(SET CMP0003 NEW)\nendif(COMMAND cmake_policy)\n\nproject(llvm_lua C CXX)\n\nset(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)\n\ninclude(CustomMacros)\ninclude(CMakeDependentOption)\ninclude(FindLLVM)\n\nenable_testing()\n\nset(LLVM_LUA_NAME \"llvm-lua\")\nset(LLVM_LUA_COPYRIGHT \"Copyright (C) 2008-2009 Robert G. Jakabosky, http://code.google.com/p/llvm-lua/\")\n\n#\n# Lua version\n#\nset(LUA_VERSION_MAJOR 5)\nset(LUA_VERSION_MINOR 1)\nset(LUA_VERSION_PATCH 4)\nset(LUA_VERSION\n\t\t\t\t\"${LUA_VERSION_MAJOR}.${LUA_VERSION_MINOR}.${LUA_VERSION_PATCH}\")\nset(LUA_SOVERSION\n\t\t\t\t\"${LUA_VERSION_MAJOR}.${LUA_VERSION_MINOR}\")\n\n#\n# llvm-lua version\n#\nset(LLVM_LUA_VERSION_MAJOR 1)\nset(LLVM_LUA_VERSION_MINOR 3)\nset(LLVM_LUA_VERSION_PATCH 1)\nset(LLVM_LUA_VERSION\n\t\"${LLVM_LUA_VERSION_MAJOR}.${LLVM_LUA_VERSION_MINOR}.${LLVM_LUA_VERSION_PATCH}\")\nset(LLVM_LUA_SOVERSION\n\t\"${LLVM_LUA_VERSION_MAJOR}.${LLVM_LUA_VERSION_MINOR}\")\n\n#\n# Lua package info.\n#\nset(CPACK_PACKAGE_VERSION_MAJOR ${LLVM_LUA_VERSION_MAJOR})\nset(CPACK_PACKAGE_VERSION_MINOR ${LLVM_LUA_VERSION_MINOR})\nset(CPACK_PACKAGE_VERSION_PATCH ${LLVM_LUA_VERSION_PATCH})\nset(CPACK_RESOURCE_FILE_LICENSE \"${CMAKE_SOURCE_DIR}/COPYRIGHT\")\nset(CPACK_RESOURCE_FILE_README \"${CMAKE_SOURCE_DIR}/README\")\nset(CPACK_PACKAGE_VENDOR \"\")\nset(CPACK_SOURCE_GENERATOR \"TGZ\")\nset(CPACK_SOURCE_IGNORE_FILES\n\"/\\\\\\\\.;/\\\\\\\\.git.*/;~$;build/;CMakeFiles/;CMakeCache;Testing/;cmake_install;CPack;Dart;Makefile$\")\nset(CPACK_SOURCE_PACKAGE_FILE_NAME\n\t\"${LLVM_LUA_NAME}-${LLVM_LUA_VERSION_MAJOR}.${LLVM_LUA_VERSION_MINOR}.${LLVM_LUA_VERSION_PATCH}\")\n# MUST be after CPACK_* variables.\ninclude(CPack)\n\nset(COMMON_CFLAGS)\nset(COMMON_LDFLAGS)\nset(LIBS)\n#\n# Detect system type\n#\nif(CMAKE_SYSTEM_NAME STREQUAL \"Linux\")\n\tset(DEFAULT_POSIX TRUE)\n\tset(DEFAULT_DLOPEN ON)\n\tset(DEFAULT_READLINE ON)\n\tset(COMMON_LDFLAGS \"${COMMON_LDFLAGS} -Wl,-E\")\n\tset(USE_RPATH TRUE)\n\t# This is a HACK. We need to put the flags from `llvm-config --lflags` at\n\t# the end of the linker command. If you know a better way to fix this let\n\t# me know.\n\tset(CMAKE_CXX_LINK_EXECUTABLE\n\t\t\" -o \")\n\tSET(CMAKE_C_LINK_EXECUTABLE\n\t\t\" -o \")\nelseif(APPLE)\n\tset(DEFAULT_POSIX TRUE)\n\tset(DEFAULT_DLOPEN ON)\n\t# use this on Mac OS X 10.3-\n\toption(LUA_USE_MACOSX \"Mac OS X 10.3-\" OFF)\n\tset(OSX_ARCHITECTURES \"x86_64\" CACHE STRING \"Build architectures for OSX\")\n\tCMAKE_DEPENDENT_OPTION(WANT_FRAMEWORK\n\t\t\"Set to ON to build framework instead of dylib.\" ON\n\t\t\"WANT_SHARED_LIBRARY\" ON\n\t)\n\tCMAKE_DEPENDENT_OPTION(LUA_FRAMEWORK_SYMLINKS\n\t\t\"Set to ON to create symlinks to llvm-lua & llvm-luac to CMAKE_PREFIX_PATH/bin.\" ON\n\t\t\"WANT_FRAMEWORK;WANT_SHARED_LIBRARY\" ON\n\t)\n\tset(CMAKE_FRAMEWORK_INSTALL_DIR \"/Library/Frameworks\" CACHE STRING \"Directory to install frameworks to.\")\n\tset(CMAKE_FRAMEWORK_INSTALL_NAME_DIR \"@executable_path/../Frameworks\" CACHE STRING \"install_name path for framework.\")\n\tset(CMAKE_DYLIB_INSTALL_NAME_DIR \"${CMAKE_INSTALL_PREFIX}/lib\" CACHE STRING \"install_name path for dylib.\")\n\tset(LUA_FRAMEWORK_NAME \"llvm-lua.framework\")\n\tset(LUA_FRAMEWORK_VERSION_NUMBER \"${LLVM_LUA_VERSION_MAJOR}.${LLVM_LUA_VERSION_MINOR}\")\n\tset(LUA_FRAMEWORK_VERSIONED_EXECUTABLE_DIR \"Versions/${LUA_FRAMEWORK_VERSION_NUMBER}/MacOS\")\n\tset(LUA_FRAMEWORK_VERSIONED_LIB_DIR \"Versions/${LUA_FRAMEWORK_VERSION_NUMBER}/lib\")\n\tset(LUA_FRAMEWORK_CURRENT_EXECUTABLE_DIR \"Versions/Current/MacOS\")\n\n\t# For Apple install_name, is it better to detect if Xcode vs Makefile?\n\t# Xcode default=1, Makefile=0? Or detect if Framework vs. dylib,\n\t# Framework=1, dylib=0?\n\toption(CMAKE_BUILD_WITH_INSTALL_RPATH \"Set to YES to set the rpath or install_name on build instead of install.\" ON)\n\n\tset(LUA_SOVERSION\n\t\t\t\t\"${LUA_VERSION_MAJOR}.${LUA_VERSION_MINOR}.0\")\nelseif(CYGWIN)\n\tset(DEFAULT_POSIX TRUE)\n\tset(USE_RPATH TRUE)\nelseif(UNIX)\n\tset(DEFAULT_POSIX TRUE)\n\tset(USE_RPATH TRUE)\nelseif(WIN32)\n\tset(LUA_WIN TRUE)\n\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DLUA_BUILD_AS_DLL\")\nelse(APPLE)\n\tset(DEFAULT_ANSI TRUE)\nendif(CMAKE_SYSTEM_NAME STREQUAL \"Linux\")\n\n#\n# setup config options with default values.\n#\noption(WANT_SHARED_LIBRARY \"Set to ON to build dynamic library.\" ON)\nif(WIN32)\n\tset(WANT_STATIC_LIBRARY OFF)\nelse(WIN32)\n\toption(WANT_STATIC_LIBRARY \"Set to ON to build static library.\" ON)\nendif(WIN32)\n\noption(WANT_NOJIT_LIBRARIES \"Set to ON to build nojit libraries.\" ON)\n\nif(USE_RPATH)\n\tset(CMAKE_INSTALL_RPATH \"${CMAKE_INSTALL_PREFIX}/lib\" CACHE STRING \"rpaths separated by semicolons.\")\n\toption(CMAKE_BUILD_WITH_INSTALL_RPATH \"Set to YES to set the rpath or install_name on build instead of install.\" OFF)\nendif(USE_RPATH)\n\nif(DEFAULT_DLOPEN)\n\toption(LUA_USE_DLOPEN \"Enable dlopen support.\" ON)\nelse(DEFAULT_DLOPEN)\n\toption(LUA_USE_DLOPEN \"Enable dlopen support.\" OFF)\nendif(DEFAULT_DLOPEN)\n\nif(DEFAULT_POSIX)\n\toption(LUA_USE_CURSES \"Enable Curses support.\" ON)\n\toption(LUA_USE_MKSTEMP \"Use mkstemp.\" ON)\n\toption(LUA_USE_ISATTY \"Enable isatty support.\" ON)\n\toption(LUA_USE_POPEN \"Enable lua_popen support.\" ON)\n\toption(LUA_USE_ULONGJMP \"Try using _longjmp/_setjmp (more efficient)\" ON)\nelse(DEFAULT_POSIX)\n\toption(LUA_USE_CURSES \"Enable Curses support.\" OFF)\n\toption(LUA_USE_MKSTEMP \"Use mkstemp.\" OFF)\n\toption(LUA_USE_ISATTY \"Enable isatty support.\" OFF)\n\toption(LUA_USE_POPEN \"Enable lua_popen support.\" OFF)\n\toption(LUA_USE_ULONGJMP \"Try using _longjmp/_setjmp (more efficient)\" OFF)\nendif(DEFAULT_POSIX)\n\nif(DEFAULT_READLINE)\n\toption(LUA_USE_READLINE \"Enable readline support.\" ON)\nelse(DEFAULT_READLINE)\n\toption(LUA_USE_READLINE \"Enable readline support.\" OFF)\nendif(DEFAULT_READLINE)\n\nif(DEFAULT_ANSI)\n\toption(LUA_ANSI \"Disable non-ansi features.\" ON)\nelse(DEFAULT_ANSI)\n\toption(LUA_ANSI \"Disable non-ansi features.\" OFF)\nendif(DEFAULT_ANSI)\n\noption(LUA_USE_APICHECK \"Enable API checks.\" OFF)\n\n#\n# llvm-lua options.\n#\noption(LUA_CPP_SUPPORT \"Enable c++ support\" OFF)\nset(LLVM_PATH \"/usr\" CACHE STRING \"Path to LLVM/Clang.\")\nset(LLVM_CC \"${LLVM_PATH}/bin/clang\" CACHE STRING \"Command to compile C-code to LLVM bitcode (clang or llvm-gcc)\")\nset(LLVM_LD \"${LLVM_PATH}/bin/llvm-link\" CACHE STRING \"Command to link LLVM bitcode files into one bitcode file.\")\n\n#\n# Cross-compile options.\n#\noption(CROSS_COMPILE \"Build llvm-luac as a cross-compiler\" OFF)\nset(CROSS_ARCH \"arm\" CACHE STRING \"Cross-compiler target.\")\nset(CROSS_TRIPLE \"arm-linux-gnueabi\" CACHE STRING \"Cross-compiler target triple.\")\nset(CROSS_CPU \"arm926ej-s\" CACHE STRING \"Cross-compiler target cpu name.\")\nset(CROSS_ISYSTEM\n\t\"/usr/lib/gcc/arm-linux-gnueabi/4.6.3/include:/usr/lib/gcc/arm-linux-gnueabi/4.6.3/include-fixed:/usr/arm-linux-gnueabi/usr/include/\"\n\tCACHE STRING \"Path to target system includes.\")\n\n#\n# LuaCoco options\n#\noption(COCO_USE_SETJMP \"Coco: Force use of setjmp (instead of gccasm)\" OFF)\noption(COCO_USE_UCONTEXT \"Coco: Force use of ucontext (instead of gccasm or setjmp)\" OFF)\noption(COCO_USE_VALGRIND \"Enable valgrind debugging support\" OFF)\noption(COCO_DISABLE \"Disable coco\" OFF)\nset(COCO_DEFAULT_CSTACKSIZE \"\" CACHE STRING \"Coco default cstacksize\")\n\n#\n# libs & cflags\n#\nset(COMMON_LDFLAGS \"${COMMON_LDFLAGS} -lm \")\n\n# For \"Mac OS X 10.3-\"\nif(LUA_USE_MACOSX)\n\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DLUA_USE_MACOSX\")\n\tset(LUA_USE_DLOPEN FALSE)\nendif(LUA_USE_MACOSX)\n\n# enable options\nif(LUA_USE_DLOPEN)\n\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DLUA_USE_DLOPEN\")\n\tif(NOT APPLE)\n\t\tset(COMMON_LDFLAGS \"${COMMON_LDFLAGS} -ldl \")\n\tendif(NOT APPLE)\nendif(LUA_USE_DLOPEN)\nif(LUA_USE_MKSTEMP)\n\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DLUA_USE_MKSTEMP\")\nendif(LUA_USE_MKSTEMP)\nif(LUA_USE_ISATTY)\n\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DLUA_USE_ISATTY\")\nendif(LUA_USE_ISATTY)\nif(LUA_USE_POPEN)\n\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DLUA_USE_POPEN\")\nendif(LUA_USE_POPEN)\nif(LUA_USE_ULONGJMP)\n\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DLUA_USE_ULONGJMP\")\nendif(LUA_USE_ULONGJMP)\nif(LUA_USE_APICHECK)\n\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DLUA_USE_APICHECK\")\nendif(LUA_USE_APICHECK)\nif(LUA_ANSI)\n\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DLUA_ANSI\")\nendif(LUA_ANSI)\n\n# readline support\nif(LUA_USE_READLINE AND NOT CROSS_COMPILE)\n\tFIND_PATH(READLINE_INCLUDE_DIR readline/readline.h)\n\tFIND_LIBRARY(READLINE_LIBRARY NAMES readline)\n\tif(READLINE_LIBRARY)\n\t\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DLUA_USE_READLINE\")\n\t\tset(COMMON_LDFLAGS \"${COMMON_LDFLAGS} -lreadline -lhistory\")\n\t\tinclude_directories(${READLINE_INCLUDE_DIR})\n\tendif(READLINE_LIBRARY)\nendif()\n\n# curses\nif(LUA_USE_CURSES AND NOT CROSS_COMPILE)\n\tinclude(FindCurses)\n\tif(CURSES_LIBRARY)\n\t\tinclude_directories(${CURSES_INCLUDE_DIR})\n\t\tset(LIBS ${LIBS} ${CURSES_LIBRARY})\n\tendif(CURSES_LIBRARY)\nendif()\n\n# LuaCoco flags\nif(COCO_DISABLE)\n\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DCOCO_DISABLE\")\nelse(COCO_DISABLE)\n\tif(COCO_USE_SETJMP)\n\t\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DCOCO_USE_SETJMP\")\n\telseif(COCO_USE_UCONTEXT)\n\t\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DCOCO_USE_UCONTEXT\")\n\tendif(COCO_USE_SETJMP)\n\n\t# check cstacksize variable.\n\tif(COCO_DEFAULT_CSTACKSIZE)\n\t\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DCOCO_DEFAULT_CSTACKSIZE=${COCO_DEFAULT_CSTACKSIZE}\")\n\tendif(COCO_DEFAULT_CSTACKSIZE)\nendif(COCO_DISABLE)\n\n#\n# Support for embedding llvm-lua into c++ programs with exception support.\n#\nif(LUA_CPP_SUPPORT)\n\tmessage(STATUS \"Lua C++ support enabled, forcing usage of g++ & llvm-g++\")\n\tset(COMMON_CFLAGS \"${COMMON_CFLAGS} -DLUA_CPP_SUPPORT\")\n\tinclude(CMakeForceCompiler)\n\tCMAKE_FORCE_C_COMPILER(${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ID})\n\tset(LLVM_CC \"llvm-g++\")\nendif(LUA_CPP_SUPPORT)\n\n#\n# standard flags to use for each build type.\n#\nif(CMAKE_COMPILER_IS_GNUCC)\n\tset(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS} -pipe -Wall -Wshadow -W -std=gnu89 \")\n\tset(CMAKE_C_FLAGS_RELEASE \"${CMAKE_C_FLAGS_RELEASE} -O2\")\n\tset(CMAKE_C_FLAGS_DEBUG \"${CMAKE_C_FLAGS_DEBUG} -O0 -g\")\n\tset(CMAKE_C_FLAGS_PROFILE \"${CMAKE_C_FLAGS_PROFILE} -O1 -g\")\n\tset(CMAKE_C_FLAGS_RELWITHDEBINFO \"${CMAKE_C_FLAGS_WITHDEBINFO} -O2 -g\")\nendif(CMAKE_COMPILER_IS_GNUCC)\nif(CMAKE_COMPILER_IS_GNUCXX)\n\tset(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -pipe -Wall -Wshadow -W -pedantic\")\n\tset(CMAKE_CXX_FLAGS_RELEASE \"${CMAKE_CXX_FLAGS_RELEASE} -O2\")\n\tset(CMAKE_CXX_FLAGS_DEBUG \"${CMAKE_CXX_FLAGS_DEBUG} -O0 -g\")\n\tset(CMAKE_CXX_FLAGS_PROFILE \"${CMAKE_CXX_FLAGS_PROFILE} -O2 -g\")\n\tset(CMAKE_CXX_FLAGS_RELWITHDEBINFO \"${CMAKE_CXX_FLAGS_WITHDEBINFO} -O2 -g\")\nendif(CMAKE_COMPILER_IS_GNUCXX)\n\n#\n# For uninstall (needs cmake_uninstall.cmake.in in the top-level directory)\n#\nconfigure_file(\n \"${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in\"\n \"${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake\"\n IMMEDIATE @ONLY)\nadd_custom_target(uninstall\n \"${CMAKE_COMMAND}\" -P \"${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake\")\n\n#\n# sub-folders\n#\nadd_subdirectory(llvm-lua build)\n\n" }, { "path": "COPYRIGHT", "content": "Lua License\n-----------\n\nLua is licensed under the terms of the MIT license reproduced below.\nThis means that Lua is free software and can be used for both academic\nand commercial purposes at absolutely no cost.\n\nFor details and rationale, see http://www.lua.org/license.html .\n\n===============================================================================\n\nCopyright (C) 1994-2008 Lua.org, PUC-Rio.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n===============================================================================\n\n(end of COPYRIGHT)\n" }, { "path": "ChangeLog", "content": "2009-11-05 Robert G. Jakabosky \n\n\t* llvm-lua/CMakeLists.txt, llvm-lua/run_tests.sh, src/ldo.c,\n\t src/lgc.c, src/lgc.h, src/lobject.h, src/lvm.c, src/lzio.h:\n\t Emergency GC fixes.\n\n2009-10-18 Robert G. Jakabosky \n\n\t* CMakeLists.txt:\n\t Fixed bug\n\t* AUTHORS, ChangeLog, gen_changelog.sh, llvm-lua/CMakeLists.txt,\n\t llvm-lua/lua-compiler, llvm-lua/lua-compiler.in,\n\t llvm-lua/lua-cross-compiler.in, llvm-lua/lua_compiler.c,\n\t llvm-lua/run_tests.sh:\n\t Added ChangeLog, Improved lua-compiler & lua-cross-compiler.\n\t \n\t Added -mcpu option to *-compiler scripts.\n\t Changed -arch to -target option.\n\t Embed the install prefix into lua-compiler so it can find\n\t liblua_main.a\n\t Added gen_changelog.sh script to generate ChangeLog from svn\n\t history.\n\n2009-10-17 Robert G. Jakabosky \n\n\t* CMakeLists.txt, README.llvm-lua, src/loadlib.c:\n\t Last commit missed these files.\n\t* llvm-lua/CMakeLists.txt, llvm-lua/Makefile,\n\t llvm-lua/llvm-lua.cpp, llvm-lua/llvm-luac.cpp,\n\t llvm-lua/lua-compiler, llvm-lua/lua_compiler.c:\n\t Added support for preloading libraries during static compilling.\n\t \n\t Updated README.llvm-lua file.\n\t Improved lua-compilers argument parsing.\n\t \n\t Now it is possible to static compile multiple Lua scripts and\n\t there required sub-scripts into one standalone executable.\n\n2009-10-15 Robert G. Jakabosky \n\n\t* llvm-lua/compile_all.sh:\n\t Wrong compiler in compile_all.sh.\n\t* cmake/CustomMacros.cmake, llvm-lua/CMakeLists.txt,\n\t llvm-lua/compile_all.sh, llvm-lua/lua-compiler,\n\t llvm-lua/lua-cross-compiler.in, llvm-lua/lua_core.h,\n\t llvm-lua/lua_vm_ops.c, src/ldo.c:\n\t Fixed bugs. Improved cross-compiler support.\n\t* src/lcoco.c, src/lcoco.h:\n\t Update LuaCoco patch to 1.1.6\n\n2009-10-14 Robert G. Jakabosky \n\n\t* CMakeLists.txt, llvm-lua/CMakeLists.txt,\n\t llvm-lua/lua-cross-compiler.in:\n\t Adding cross-compiler support to CMake build scripts.\n\n2009-10-07 Robert G. Jakabosky \n\n\t* .svnignore, CMakeLists.txt, cmake_uninstall.cmake.in,\n\t llvm-lua/CMakeLists.txt, llvm-lua/load_jit_proto.c,\n\t llvm-lua/lua_core.c, llvm-lua/lua_vm_ops_static.c, src/loadlib.c,\n\t src/lobject.h, src/lstate.h, src/ltable.c, src/luaconf.h:\n\t Added MacOSX framework support.\n\n2009-09-27 Robert G. Jakabosky \n\n\t* llvm-lua/CMakeLists.txt:\n\t Remove duplicate source files\n\t* CMakeLists.txt, llvm-lua/CMakeLists.txt:\n\t Added lua-compiler to CMake build.\n\t* CMakeLists.txt, cmake, cmake/CustomMacros.cmake,\n\t cmake/FindLLVM.cmake, llvm-lua/CMakeLists.txt, llvm-lua/Makefile:\n\t Add CMake build scripts.\n\n2009-09-23 Robert G. Jakabosky \n\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/Makefile,\n\t llvm-lua/hook_parser.c, llvm-lua/llvm-lua.cpp,\n\t llvm-lua/llvm_lmathlib.c, llvm-lua/lua_vm_ops.c,\n\t llvm-lua/lua_vm_ops_static.c, llvm-lua/tests/coroutine.lua,\n\t llvm-lua/tests/test_lineerror.lua, llvm-lua/tests/test_tail.lua,\n\t llvm-lua/tests/test_tail_nil_multret.lua, src/lauxlib.c,\n\t src/ldo.c, src/lvm.c:\n\t Fixed memory leak, tailcalls, memlimit.\n\t Release LLVM Function objects when Lua Proto's are garbage\n\t collected.\n\t Fixed a few of tailcall bugs.\n\t Fixed a bug with the memlimit code.\n\t Improved command line option parsing.\n\t Added hack for iPhone support.\n\n2009-09-22 Robert G. Jakabosky \n\n\t* llvm-lua/tests/test_varg_tail2.lua:\n\t Add testcase: tailcall from varg function.\n\t* llvm-lua/lua_vm_ops_static.c, src/ldo.c:\n\t Fixed tailcall inside varg function bug.\n\n2009-09-18 Robert G. Jakabosky \n\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/LLVMCompiler.h,\n\t llvm-lua/Makefile, llvm-lua/llvm-lua.cpp, llvm-lua/llvm-luac.cpp,\n\t llvm-lua/llvm_compiler.cpp:\n\t Fixed memory leaks and a memory access error.\n\n2009-09-17 Robert G. Jakabosky \n\n\t* llvm-lua/Makefile, llvm-lua/compile_all.sh,\n\t llvm-lua/load_jit_proto.c, llvm-lua/lua-compiler:\n\t Improved cross-compiling support.\n\t* llvm-lua/LLVMDumper.cpp, llvm-lua/LLVMDumper.h,\n\t llvm-lua/load_jit_proto.c, llvm-lua/load_jit_proto.h:\n\t Made jit_proto & constant_type structures more portable.\n\t Added correct amount of padding for target architecture.\n\n2009-09-16 Robert G. Jakabosky \n\n\t* llvm-lua/llvm-luac.cpp:\n\t Adding support for all native backends to llvm-luac.\n\t* README.llvm-lua, etc/embed_jit.c, etc/embed_jit.cpp:\n\t Added example 'embed_jit.c' & 'embed_jit.cpp' files.\n\t* llvm-lua/llvm_compiler.cpp:\n\t Fixed bug with native target initialization.\n\t* llvm-lua/lua-compiler:\n\t Add better support for -arch flag\n\t* llvm-lua/lua-compiler:\n\t Removed debug messages.\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/lua-compiler:\n\t Added support for compiling static lua-modules.\n\t* llvm-lua/lua-compiler:\n\t Removed unneeded \"-rdynamic -Wl,-E\" from 'lua-compiler' script.\n\n2009-09-15 Robert G. Jakabosky \n\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/LLVMCompiler.h,\n\t llvm-lua/LLVMDumper.cpp, llvm-lua/LLVMDumper.h,\n\t llvm-lua/Makefile, llvm-lua/llvm_compiler.cpp,\n\t llvm-lua/load_embedded_bc.cpp, llvm-lua/load_embedded_bc.h,\n\t llvm-lua/load_liblua_main.cpp, llvm-lua/load_liblua_main.h,\n\t llvm-lua/load_vm_ops.cpp, llvm-lua/load_vm_ops.h, src/lcode.c,\n\t src/ldblib.c, src/lvm.c:\n\t Ported code to LLVM 2.6 API.\n\t Applied patches for Lua 5.1.4:\n\t 3. Wrong code generation for some particular boolean expressions\n\t 4. luaV_settable may invalidate a reference to a table and try to\n\t reuse it.\n\t 5. debug.getfenv does not check whether it has an argument.\n\n2009-06-16 Robert G. Jakabosky \n\n\t* llvm-lua/Makefile:\n\t Fixing MinGW support.\n\n2009-06-07 Robert G. Jakabosky \n\n\t* Makefile, llvm-lua/Makefile:\n\t Add support for compiling shared library liblua-llvm.so\n\n2009-06-04 Robert G. Jakabosky \n\n\t* llvm-lua/lua-compiler:\n\t Fixed bug with lua-compiler.\n\t Added '-c++' option for static compiling Lua code with C++\n\t exception support.\n\t* README.llvm-lua, llvm-lua/LLVMCompiler.cpp,\n\t llvm-lua/LLVMCompiler.h, llvm-lua/LLVMDumper.cpp,\n\t llvm-lua/LLVMDumper.h, llvm-lua/Makefile, llvm-lua/TODO,\n\t llvm-lua/hook_parser.c, llvm-lua/llvm-lua.cpp,\n\t llvm-lua/llvm-lua.h, llvm-lua/llvm-luac.cpp,\n\t llvm-lua/llvm-luac.h, llvm-lua/llvm_compiler.cpp,\n\t llvm-lua/llvm_compiler.h, llvm-lua/llvm_compiler_private.h,\n\t llvm-lua/llvm_dumper.cpp, llvm-lua/llvm_dumper.h,\n\t llvm-lua/llvm_lmathlib.c, llvm-lua/load_embedded_bc.cpp,\n\t llvm-lua/load_embedded_bc.h, llvm-lua/load_jit_proto.c,\n\t llvm-lua/load_jit_proto.h, llvm-lua/load_liblua_main.cpp,\n\t llvm-lua/load_liblua_main.h, llvm-lua/load_vm_ops.cpp,\n\t llvm-lua/load_vm_ops.h, llvm-lua/lua-compiler,\n\t llvm-lua/lua_compiler.c, llvm-lua/lua_core.c,\n\t llvm-lua/lua_core.h, llvm-lua/lua_interpreter.c,\n\t llvm-lua/lua_main.c, llvm-lua/lua_normal.c,\n\t llvm-lua/lua_vm_ops.c, llvm-lua/lua_vm_ops.h,\n\t llvm-lua/lua_vm_ops_static.c, llvm-lua/no_jit.c, src/lcoco.h,\n\t src/ldebug.c, src/ldebug.h, src/lstate.c, src/lstate.h,\n\t src/luaconf.h, src/lvm.c, src/print.c:\n\t Add C++ exception support. llvm-lua is now thread-safe.\n\t \n\t Moved LLVMCompiler instance from global variable to\n\t 'global_State'\n\t to help make llvm-lua thread-safe.\n\n2009-05-31 Robert G. Jakabosky \n\n\t* README.llvm-lua, llvm-lua/lua-compiler:\n\t Fixed bug with lua-compiler script and the 'cbe' mode.\n\t Fixed example compile/link commands in README.llvm-lua.\n\t* README.llvm-lua, llvm-lua/Makefile, llvm-lua/compile_all.sh,\n\t llvm-lua/llvm_compiler.cpp, llvm-lua/llvm_compiler.h,\n\t llvm-lua/lua-compiler:\n\t Bump version to 1.0.\n\t Add for information to README.llvm-lua\n\t Fixed some bugs with embedding llvm-lua.\n\t Added -help option to lua-compiler script.\n\n2009-05-30 Robert G. Jakabosky \n\n\t* llvm-lua/tests, llvm-lua/tests/NOTES, llvm-lua/tests/add.lua,\n\t llvm-lua/tests/arg_test.lua, llvm-lua/tests/big_table.lua,\n\t llvm-lua/tests/dump.lua, llvm-lua/tests/for.lua,\n\t llvm-lua/tests/hash2.lua, llvm-lua/tests/loadk.lua,\n\t llvm-lua/tests/local_nil.lua, llvm-lua/tests/loops.lua,\n\t llvm-lua/tests/lua_tail.lua, llvm-lua/tests/nestedloop.lua,\n\t llvm-lua/tests/nestedloop2.lua, llvm-lua/tests/nums.lua,\n\t llvm-lua/tests/scimark_loop.lua, llvm-lua/tests/scimark_rand.lua,\n\t llvm-lua/tests/stress_for.lua, llvm-lua/tests/test.lua,\n\t llvm-lua/tests/test2.lua, llvm-lua/tests/test3.lua,\n\t llvm-lua/tests/test4.lua, llvm-lua/tests/test_math.lua,\n\t llvm-lua/tests/test_tail.lua:\n\t Added lua scripts used for regression testing.\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/TODO,\n\t llvm-lua/llvm_lmathlib.c, llvm-lua/lua_core.c, src/lauxlib.c,\n\t src/lauxlib.h, src/ldo.c:\n\t Improved speed of math.* functions by lowering the call overhead.\n\n2009-05-28 Robert G. Jakabosky \n\n\t* llvm-lua/LLVMCompiler.cpp:\n\t Fixed some bugs with numeric forloop optimizations.\n\n2009-05-24 Robert G. Jakabosky \n\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/LLVMCompiler.h,\n\t llvm-lua/TODO, llvm-lua/lua-compiler, llvm-lua/lua_vm_ops.c,\n\t llvm-lua/lua_vm_ops.h, llvm-lua/lua_vm_ops_static.c, src/ldo.c:\n\t Improved performance of numeric for loops.\n\n2009-05-21 Robert G. Jakabosky \n\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/LLVMCompiler.h,\n\t llvm-lua/llvm_dumper.cpp, llvm-lua/llvm_dumper.h,\n\t llvm-lua/lua_compiler.c, llvm-lua/lua_vm_ops.c,\n\t llvm-lua/lua_vm_ops.h, llvm-lua/lua_vm_ops_static.c,\n\t llvm-lua/no_jit.c:\n\t Added some optimizations.\n\t Fixed a few bugs.\n\n2009-05-20 Robert G. Jakabosky \n\n\t* Makefile, llvm-lua/LLVMDumper.cpp, llvm-lua/Makefile,\n\t llvm-lua/compile_all.sh, llvm-lua/lua-compiler,\n\t llvm-lua/lua_compiler.c:\n\t Fixed support for using c-backend to compile Lua scripts to\n\t standalone binaries.\n\t* Makefile, llvm-lua/Makefile, llvm-lua/compile.sh,\n\t llvm-lua/compile_all.sh, llvm-lua/llvm_compiler.h,\n\t llvm-lua/lua-compiler:\n\t Bump version number to 0.9\n\t Cleaned up Makefile.\n\t Renamed llvm-luac wrapper script from compile.sh to lua-compiler.\n\t* Makefile, README.llvm-lua, llvm-lua/LLVMDumper.cpp,\n\t llvm-lua/Makefile, llvm-lua/bin2c.c, llvm-lua/compile.sh,\n\t llvm-lua/llvm_compiler.cpp, llvm-lua/llvm_compiler.h,\n\t llvm-lua/llvm_dumper.cpp, llvm-lua/llvm_dumper.h,\n\t llvm-lua/load_embedded_bc.cpp, llvm-lua/load_embedded_bc.h,\n\t llvm-lua/load_liblua_main.cpp, llvm-lua/load_liblua_main.h,\n\t llvm-lua/load_vm_ops.cpp, llvm-lua/lua_vm_ops_module.cpp,\n\t llvm-lua/lua_vm_ops_module.h:\n\t Embedded lua_vm_ops.bc & liblua_main.bc instead of\n\t loading/linking them at run-time.\n\n2009-05-19 Robert G. Jakabosky \n\n\t* Makefile, llvm-lua/LLVMCompiler.cpp, llvm-lua/LLVMCompiler.h,\n\t llvm-lua/LLVMDumper.cpp, llvm-lua/LLVMDumper.h,\n\t llvm-lua/Makefile, llvm-lua/TODO, llvm-lua/compile.sh,\n\t llvm-lua/hook_parser.c, llvm-lua/load_jit_proto.c,\n\t llvm-lua/load_jit_proto.h, llvm-lua/lua_main.c,\n\t llvm-lua/lua_vm_ops.c, llvm-lua/lua_vm_ops.h,\n\t llvm-lua/lua_vm_ops_static.c, llvm-lua/no_jit.c, src/ldo.c,\n\t src/luaconf.h:\n\t Fixed bugs with debug hooks.\n\t Added line/upvalues/locals info to jit_proto, to support\n\t debugging info of JITed code.\n\t Allow debuging info be stripped when compling Lua scripts.\n\n2009-05-17 Robert G. Jakabosky \n\n\t* Makefile, etc/lua.pc, llvm-lua/LLVMCompiler.cpp,\n\t llvm-lua/compile.sh, llvm-lua/load_vm_ops.cpp, src/ldebug.c:\n\t Fixed compile bug.\n\t Fixed lua debug libraries handling of JIT functions that have Lua\n\t bytecode stripped.\n\n2009-03-12 Robert G. Jakabosky \n\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/LLVMCompiler.h,\n\t llvm-lua/LLVMDumper.cpp, llvm-lua/LLVMDumper.h,\n\t llvm-lua/Makefile, llvm-lua/TODO, llvm-lua/compile.sh,\n\t llvm-lua/compile_all.sh, llvm-lua/compile_bc.sh,\n\t llvm-lua/compile_c.sh, llvm-lua/hook_parser.c,\n\t llvm-lua/llvm-lua.cpp, llvm-lua/llvm-luac.cpp,\n\t llvm-lua/llvm_compiler.cpp, llvm-lua/llvm_compiler.h,\n\t llvm-lua/load_jit_proto.c, llvm-lua/load_jit_proto.h,\n\t llvm-lua/lua_compiler.c, llvm-lua/lua_core.c,\n\t llvm-lua/lua_main.c, llvm-lua/lua_vm_ops.h,\n\t llvm-lua/lua_vm_ops_static.c:\n\t Added support for stripping Lua opcodes from compiled Lua code\n\t (can be used for obfucation).\n\t Added support for compiling Lua code as native code modules\n\t instead of just standalone binaries.\n\t Added support for compiling llvm-lua as an embeddable library\n\t with JIT support.\n\t Improved compile.sh wrapper script.\n\n2009-03-06 Robert G. Jakabosky \n\n\t* llvm-lua/Makefile, llvm-lua/lua_vm_ops.c, src/lvm.c:\n\t Fixed bug with Lua stack re-allocation.\n\n2009-01-22 Robert G. Jakabosky \n\n\t* llvm-lua/Makefile, llvm-lua/compile_c.sh, llvm-lua/llvm-lua.cpp,\n\t llvm-lua/llvm-luac.cpp:\n\t fixed bug with llvm asserts.\n\t Added bash script for compiling lua scripts to C code.\n\n2008-10-09 Robert G. Jakabosky \n\n\t* llvm-lua/Makefile, llvm-lua/compile.sh, llvm-lua/compile_all.sh,\n\t llvm-lua/compile_bc.sh:\n\t compile llvm bitcode to assembly instead of 'C' code.\n\n2008-10-08 Robert G. Jakabosky \n\n\t* llvm-lua/Makefile, llvm-lua/compile.sh:\n\t remove '-foptimize-sibling-calls'\n\t disabled '-march=athlon64'\n\t* llvm-lua/llvm_compiler.h:\n\t bump version to 0.5\n\t* src/ldo.h:\n\t Added 'PCRTAILRECUR' for tail-recursive calls from JIT functions.\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/compile.sh,\n\t llvm-lua/hook_parser.c, llvm-lua/llvm-lua.cpp,\n\t llvm-lua/llvm-luac.cpp, llvm-lua/llvm_compiler.cpp,\n\t llvm-lua/lua_vm_ops.c, llvm-lua/lua_vm_ops_static.c:\n\t Fixed memory offset bug & memory leaks.\n\t Fixed '-time-passes' to display info about passes run by JIT.\n\t Changed default Optimization level to '3'.\n\n2008-10-07 Robert G. Jakabosky \n\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/LLVMCompiler.h,\n\t llvm-lua/LLVMDumper.cpp, llvm-lua/LLVMDumper.h, llvm-lua/TODO,\n\t llvm-lua/compile.sh, llvm-lua/hook_parser.c,\n\t llvm-lua/llvm-lua.cpp, llvm-lua/llvm-luac.cpp,\n\t llvm-lua/llvm_compiler.cpp, llvm-lua/llvm_compiler.h,\n\t llvm-lua/lua_compiler.c, llvm-lua/lua_main.c,\n\t llvm-lua/lua_vm_ops.c, llvm-lua/lua_vm_ops.h,\n\t llvm-lua/lua_vm_ops_static.c:\n\t Added specialized functions for OP_EQ.\n\t Added support to Lower for loop's internal idx variable from the\n\t Lua stack to the c-stack.\n\t Added support to remove \"LOADK\" opcodes used for constant for\n\t loop parameters and turn then into llvm constants.\n\t Added command-line options for controlling the optimization\n\t level.\n\t Fixed bug with passing command-line options to the Lua core\n\t interpreter & compiler.\n\n2008-10-05 Robert G. Jakabosky \n\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/LLVMDumper.cpp,\n\t llvm-lua/lua_vm_ops_static.c:\n\t Fixed a few bugs.\n\t Improved tail-calls from JIT function to non-JIT Lua function.\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/TODO, llvm-lua/llvm-lua.cpp,\n\t llvm-lua/llvm-luac.cpp, llvm-lua/llvm_compiler.h:\n\t Added LLVM command options to llvm-luac.\n\t Don't compiled inlined opcode functions, since they will not be\n\t called.\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/LLVMCompiler.h,\n\t llvm-lua/LLVMDumper.cpp, llvm-lua/Makefile, llvm-lua/compile.sh,\n\t llvm-lua/hook_parser.c, llvm-lua/lua_vm_ops.c,\n\t llvm-lua/lua_vm_ops.h, llvm-lua/lua_vm_ops_static.c, src/ldo.c,\n\t src/ldo.h:\n\t Fixed tail-call support, now lua scripts can make tail-calls\n\t without the c-stack/lua callstack growing.\n\t Added some optimizations of the Lua bytecode and generated\n\t machine code.\n\t Lowered the opcode limit from 800 down to 200 for the max\n\t function size that is JITed.\n\t Added support for specialized versions of each opcode function to\n\t support more optimizations.\n\n2008-10-03 Robert G. Jakabosky \n\n\t* llvm-lua/lua_vm_ops.h, llvm-lua/lua_vm_ops_static.c:\n\t remove unused argument.\n\t* llvm-lua/LLVMDumper.cpp, llvm-lua/LLVMDumper.h,\n\t llvm-lua/load_jit_proto.h, llvm-lua/lua_main.c:\n\t Fixed 32bit support for static compiling Lua scripts.\n\t* Makefile, README.llvm-lua, llvm-lua/Makefile:\n\t Improve Makefile support for other platforms.\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/LLVMCompiler.h,\n\t llvm-lua/Makefile, llvm-lua/compile.sh, llvm-lua/compile_bc.sh,\n\t llvm-lua/hook_parser.c, llvm-lua/llvm_compiler.cpp,\n\t llvm-lua/llvm_compiler.h, llvm-lua/lua_core.c,\n\t llvm-lua/lua_vm_ops.c, llvm-lua/lua_vm_ops.h,\n\t llvm-lua/lua_vm_ops_static.c:\n\t Improved true tailcall support when calling a JIT/C function from\n\t a JIT function.\n\t Removed 'func_state' structure from JIT functions to allow\n\t tailcalls into vm_OP_* functions.\n\t* src/ldo.c, src/ldo.h, src/luaconf.h:\n\t Export 'tryfuncTM' function as 'luaD_tryfuncTM' from ldo.c\n\t disable HARDSTACKTESTS tests.\n\n2008-09-29 Robert G. Jakabosky \n\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/LLVMCompiler.h,\n\t llvm-lua/Makefile, llvm-lua/compile.sh, llvm-lua/lua_compiler.h,\n\t llvm-lua/lua_core.c, llvm-lua/lua_core.h, llvm-lua/lua_vm_ops.c,\n\t llvm-lua/lua_vm_ops.h, llvm-lua/lua_vm_ops_module.cpp,\n\t llvm-lua/lua_vm_ops_static.c:\n\t Moved some large vm_OP_* functions from loadable bitcode file\n\t into llvm-lua.\n\t Added LLVM timers to compiler.\n\t Added support for LLVM command line options.\n\t Some code clean up.\n\n2008-09-28 Robert G. Jakabosky \n\n\t* llvm-lua/lua_vm_ops_module.cpp:\n\t fixed compile bug.\n\n2008-09-27 Robert G. Jakabosky \n\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/llvm-lua.cpp:\n\t Add command line parsing support for LLVM options.\n\t* llvm-lua/load_vm_ops.cpp:\n\t search current directory & LLVM_LIB_SEARCH_PATH for lua_vm_ops.bc\n\t file.\n\t* llvm-lua/LLVMCompiler.cpp, llvm-lua/LLVMCompiler.h,\n\t llvm-lua/LLVMDumper.cpp, llvm-lua/LLVMDumper.h,\n\t llvm-lua/Makefile, llvm-lua/compile.sh, llvm-lua/hook_parser.c,\n\t llvm-lua/llvm-compiler.cpp, llvm-lua/llvm-compiler.h,\n\t llvm-lua/llvm-lua.cpp, llvm-lua/llvm-luac.cpp,\n\t llvm-lua/llvm_compiler.cpp, llvm-lua/llvm_compiler.h,\n\t llvm-lua/load_jit_proto.c, llvm-lua/load_vm_ops.cpp,\n\t llvm-lua/load_vm_ops.h, llvm-lua/lua_compiler.c,\n\t llvm-lua/lua_core.c, llvm-lua/lua_main.c, llvm-lua/lua_vm_ops.c,\n\t llvm-lua/lua_vm_ops_module.cpp, llvm-lua/lua_vm_ops_module.h:\n\t Added a new way to load the lua_vm_ops.bc by compiling it into\n\t C++ LLVM API calls and embedding it into the llvm-lua & llvm-luac\n\t programs.\n\t Re-factored Lua bytecode to LLVM IR compiler code into two\n\t classes LLVMCompiler & LLVMDumper.\n\t Fixed some other bugs.\n\n2008-09-23 Robert G. Jakabosky \n\n\t* src/lcoco.c:\n\t Mac OS X 64bit fix from Mike Pall\n\n2008-09-19 Robert G. Jakabosky \n\n\t* Makefile, doc/manual.html, doc/readme.html, etc/lua.pc,\n\t src/lapi.c, src/loadlib.c, src/lobject.h, src/lstrlib.c,\n\t src/lua.h:\n\t Update to Official Lua-5.1.4\n\n2008-08-30 Robert G. Jakabosky \n\n\t* src/lcoco.c:\n\t Changed from using %rbp & %rbx to %r12 & %r13 for wrap function.\n\t* llvm-lua/lua_vm_ops.c, src/lvm.c, src/lvm.h:\n\t Fixed support for line/count debug hooks.\n\t* src/lcoco.c:\n\t Added wrap function to set register %rdi (to lua_State *) on\n\t first resume of a coroutine, instead of very resume/yield.\n\n2008-08-28 Robert G. Jakabosky \n\n\t* llvm-lua/Makefile, llvm-lua/llvm-compiler.cpp:\n\t Patch from \"Kay Ropke\" fixes bug with compiling on OS X with the\n\t latest LLVM revision(55456).\n\n2008-08-27 Robert G. Jakabosky \n\n\t* llvm-lua/llvm-compiler.cpp, llvm-lua/load_jit_proto.h:\n\t fixed bug with boolean constants when static compiling Lua\n\t scripts.\n\n2008-08-26 Robert G. Jakabosky \n\n\t* llvm-lua/compile_all.sh:\n\t add message\n\n2008-08-25 Robert G. Jakabosky \n\n\t* llvm-lua/Makefile, llvm-lua/compile.sh, llvm-lua/compile_all.sh,\n\t llvm-lua/hook_parser.c, llvm-lua/llvm-compiler.cpp,\n\t llvm-lua/lua_vm_ops.c:\n\t Fixed bugs with calling non-JITed Lua functions.\n\t Manually inline opcode functions instead of using the inliner\n\t pass.\n\t Code cleanup.\n\n2008-08-23 Robert G. Jakabosky \n\n\t* src/lcoco.c:\n\t fixed bug with assembly coco_switcher for x86_64.\n\t* src/Makefile, src/lcoco.c:\n\t Added added assembly ctx_switcher for x86_64-linux to LuaCoco.\n\t* .svnignore, COPYRIGHT, HISTORY, INSTALL, Makefile, README,\n\t README.llvm-lua, doc, doc/amazon.gif, doc/contents.html,\n\t doc/cover.png, doc/logo.gif, doc/lua.1, doc/lua.css,\n\t doc/lua.html, doc/luac.1, doc/luac.html, doc/manual.css,\n\t doc/manual.html, doc/readme.html, etc, etc/Makefile, etc/README,\n\t etc/all.c, etc/lua.hpp, etc/lua.ico, etc/lua.pc, etc/luavs.bat,\n\t etc/min.c, etc/noparser.c, etc/strict.lua, llvm-lua,\n\t llvm-lua/COPYRIGHT.llvm-lua, llvm-lua/Makefile,\n\t llvm-lua/compile.sh, llvm-lua/hook_parser.c,\n\t llvm-lua/llvm-compiler.cpp, llvm-lua/llvm-compiler.h,\n\t llvm-lua/llvm-lua.cpp, llvm-lua/llvm-lua.h,\n\t llvm-lua/llvm-luac.cpp, llvm-lua/llvm-luac.h,\n\t llvm-lua/load_jit_proto.c, llvm-lua/load_jit_proto.h,\n\t llvm-lua/lua_compiler.c, llvm-lua/lua_compiler.h,\n\t llvm-lua/lua_core.c, llvm-lua/lua_core.h,\n\t llvm-lua/lua_interpreter.c, llvm-lua/lua_interpreter.h,\n\t llvm-lua/lua_main.c, llvm-lua/lua_normal.c,\n\t llvm-lua/lua_vm_ops.c, llvm-lua/lua_vm_ops.h, src, src/Makefile,\n\t src/lapi.c, src/lapi.h, src/lauxlib.c, src/lauxlib.h,\n\t src/lbaselib.c, src/lcoco.c, src/lcoco.h, src/lcode.c,\n\t src/lcode.h, src/ldblib.c, src/ldebug.c, src/ldebug.h, src/ldo.c,\n\t src/ldo.h, src/ldump.c, src/lfunc.c, src/lfunc.h, src/lgc.c,\n\t src/lgc.h, src/linit.c, src/liolib.c, src/llex.c, src/llex.h,\n\t src/llimits.h, src/lmathlib.c, src/lmem.c, src/lmem.h,\n\t src/loadlib.c, src/lobject.c, src/lobject.h, src/lopcodes.c,\n\t src/lopcodes.h, src/loslib.c, src/lparser.c, src/lparser.h,\n\t src/lstate.c, src/lstate.h, src/lstring.c, src/lstring.h,\n\t src/lstrlib.c, src/ltable.c, src/ltable.h, src/ltablib.c,\n\t src/ltm.c, src/ltm.h, src/lua.c, src/lua.h, src/luac.c,\n\t src/luaconf.h, src/lualib.h, src/lundump.c, src/lundump.h,\n\t src/lvm.c, src/lvm.h, src/lzio.c, src/lzio.h, src/print.c, test,\n\t test/README, test/bisect.lua, test/cf.lua, test/echo.lua,\n\t test/env.lua, test/factorial.lua, test/fib.lua, test/fibfor.lua,\n\t test/globals.lua, test/hello.lua, test/life.lua, test/luac.lua,\n\t test/printf.lua, test/readonly.lua, test/sieve.lua,\n\t test/sort.lua, test/table.lua, test/trace-calls.lua,\n\t test/trace-globals.lua, test/xd.lua:\n\t Initial 0.1 release\n\n2008-08-23 \n\n\t* .:\n\t Initial directory structure.\n\n" }, { "path": "HISTORY", "content": "HISTORY for Lua 5.1\n\n* Changes from version 5.0 to 5.1\n -------------------------------\n Language:\n + new module system.\n + new semantics for control variables of fors.\n + new semantics for setn/getn.\n + new syntax/semantics for varargs.\n + new long strings and comments.\n + new `mod' operator (`%')\n + new length operator #t\n + metatables for all types\n API:\n + new functions: lua_createtable, lua_get(set)field, lua_push(to)integer.\n + user supplies memory allocator (lua_open becomes lua_newstate).\n + luaopen_* functions must be called through Lua.\n Implementation:\n + new configuration scheme via luaconf.h.\n + incremental garbage collection.\n + better handling of end-of-line in the lexer.\n + fully reentrant parser (new Lua function `load')\n + better support for 64-bit machines.\n + native loadlib support for Mac OS X.\n + standard distribution in only one library (lualib.a merged into lua.a)\n\n* Changes from version 4.0 to 5.0\n -------------------------------\n Language:\n + lexical scoping.\n + Lua coroutines.\n + standard libraries now packaged in tables.\n + tags replaced by metatables and tag methods replaced by metamethods,\n stored in metatables.\n + proper tail calls.\n + each function can have its own global table, which can be shared.\n + new __newindex metamethod, called when we insert a new key into a table.\n + new block comments: --[[ ... ]].\n + new generic for.\n + new weak tables.\n + new boolean type.\n + new syntax \"local function\".\n + (f()) returns the first value returned by f.\n + {f()} fills a table with all values returned by f.\n + \\n ignored in [[\\n .\n + fixed and-or priorities.\n + more general syntax for function definition (e.g. function a.x.y:f()...end).\n + more general syntax for function calls (e.g. (print or write)(9)).\n + new functions (time/date, tmpfile, unpack, require, load*, etc.).\n API:\n + chunks are loaded by using lua_load; new luaL_loadfile and luaL_loadbuffer.\n + introduced lightweight userdata, a simple \"void*\" without a metatable.\n + new error handling protocol: the core no longer prints error messages;\n all errors are reported to the caller on the stack.\n + new lua_atpanic for host cleanup.\n + new, signal-safe, hook scheme.\n Implementation:\n + new license: MIT.\n + new, faster, register-based virtual machine.\n + support for external multithreading and coroutines.\n + new and consistent error message format.\n + the core no longer needs \"stdio.h\" for anything (except for a single\n use of sprintf to convert numbers to strings).\n + lua.c now runs the environment variable LUA_INIT, if present. It can\n be \"@filename\", to run a file, or the chunk itself.\n + support for user extensions in lua.c.\n sample implementation given for command line editing.\n + new dynamic loading library, active by default on several platforms.\n + safe garbage-collector metamethods.\n + precompiled bytecodes checked for integrity (secure binary dostring).\n + strings are fully aligned.\n + position capture in string.find.\n + read('*l') can read lines with embedded zeros.\n\n* Changes from version 3.2 to 4.0\n -------------------------------\n Language:\n + new \"break\" and \"for\" statements (both numerical and for tables).\n + uniform treatment of globals: globals are now stored in a Lua table.\n + improved error messages.\n + no more '$debug': full speed *and* full debug information.\n + new read form: read(N) for next N bytes.\n + general read patterns now deprecated.\n (still available with -DCOMPAT_READPATTERNS.)\n + all return values are passed as arguments for the last function\n (old semantics still available with -DLUA_COMPAT_ARGRET)\n + garbage collection tag methods for tables now deprecated.\n + there is now only one tag method for order.\n API:\n + New API: fully re-entrant, simpler, and more efficient.\n + New debug API.\n Implementation:\n + faster than ever: cleaner virtual machine and new hashing algorithm.\n + non-recursive garbage-collector algorithm.\n + reduced memory usage for programs with many strings.\n + improved treatment for memory allocation errors.\n + improved support for 16-bit machines (we hope).\n + code now compiles unmodified as both ANSI C and C++.\n + numbers in bases other than 10 are converted using strtoul.\n + new -f option in Lua to support #! scripts.\n + luac can now combine text and binaries.\n\n* Changes from version 3.1 to 3.2\n -------------------------------\n + redirected all output in Lua's core to _ERRORMESSAGE and _ALERT.\n + increased limit on the number of constants and globals per function\n (from 2^16 to 2^24).\n + debugging info (lua_debug and hooks) moved into lua_state and new API\n functions provided to get and set this info.\n + new debug lib gives full debugging access within Lua.\n + new table functions \"foreachi\", \"sort\", \"tinsert\", \"tremove\", \"getn\".\n + new io functions \"flush\", \"seek\".\n\n* Changes from version 3.0 to 3.1\n -------------------------------\n + NEW FEATURE: anonymous functions with closures (via \"upvalues\").\n + new syntax:\n - local variables in chunks.\n - better scope control with DO block END.\n - constructors can now be also written: { record-part; list-part }.\n - more general syntax for function calls and lvalues, e.g.:\n f(x).y=1\n o:f(x,y):g(z)\n f\"string\" is sugar for f(\"string\")\n + strings may now contain arbitrary binary data (e.g., embedded zeros).\n + major code re-organization and clean-up; reduced module interdependecies.\n + no arbitrary limits on the total number of constants and globals.\n + support for multiple global contexts.\n + better syntax error messages.\n + new traversal functions \"foreach\" and \"foreachvar\".\n + the default for numbers is now double.\n changing it to use floats or longs is easy.\n + complete debug information stored in pre-compiled chunks.\n + sample interpreter now prompts user when run interactively, and also\n handles control-C interruptions gracefully.\n\n* Changes from version 2.5 to 3.0\n -------------------------------\n + NEW CONCEPT: \"tag methods\".\n Tag methods replace fallbacks as the meta-mechanism for extending the\n semantics of Lua. Whereas fallbacks had a global nature, tag methods\n work on objects having the same tag (e.g., groups of tables).\n Existing code that uses fallbacks should work without change.\n + new, general syntax for constructors {[exp] = exp, ... }.\n + support for handling variable number of arguments in functions (varargs).\n + support for conditional compilation ($if ... $else ... $end).\n + cleaner semantics in API simplifies host code.\n + better support for writing libraries (auxlib.h).\n + better type checking and error messages in the standard library.\n + luac can now also undump.\n\n* Changes from version 2.4 to 2.5\n -------------------------------\n + io and string libraries are now based on pattern matching;\n the old libraries are still available for compatibility\n + dofile and dostring can now return values (via return statement)\n + better support for 16- and 64-bit machines\n + expanded documentation, with more examples\n\n* Changes from version 2.2 to 2.4\n -------------------------------\n + external compiler creates portable binary files that can be loaded faster\n + interface for debugging and profiling\n + new \"getglobal\" fallback\n + new functions for handling references to Lua objects\n + new functions in standard lib\n + only one copy of each string is stored\n + expanded documentation, with more examples\n\n* Changes from version 2.1 to 2.2\n -------------------------------\n + functions now may be declared with any \"lvalue\" as a name\n + garbage collection of functions\n + support for pipes\n\n* Changes from version 1.1 to 2.1\n -------------------------------\n + object-oriented support\n + fallbacks\n + simplified syntax for tables\n + many internal improvements\n\n(end of HISTORY)\n" }, { "path": "INSTALL", "content": "INSTALL for Lua 5.1\n\n* Building Lua\n ------------\n Lua is built in the src directory, but the build process can be\n controlled from the top-level Makefile.\n\n Building Lua on Unix systems should be very easy. First do \"make\" and\n see if your platform is listed. If so, just do \"make xxx\", where xxx\n is your platform name. The platforms currently supported are:\n aix ansi bsd freebsd generic linux macosx mingw posix solaris\n\n If your platform is not listed, try the closest one or posix, generic,\n ansi, in this order.\n\n See below for customization instructions and for instructions on how\n to build with other Windows compilers.\n\n If you want to check that Lua has been built correctly, do \"make test\"\n after building Lua. Also, have a look at the example programs in test.\n\n* Installing Lua\n --------------\n Once you have built Lua, you may want to install it in an official\n place in your system. In this case, do \"make install\". The official\n place and the way to install files are defined in Makefile. You must\n have the right permissions to install files.\n\n If you want to build and install Lua in one step, do \"make xxx install\",\n where xxx is your platform name.\n\n If you want to install Lua locally, then do \"make local\". This will\n create directories bin, include, lib, man, and install Lua there as\n follows:\n\n bin:\tlua luac\n include:\tlua.h luaconf.h lualib.h lauxlib.h lua.hpp\n lib:\tliblua.a\n man/man1:\tlua.1 luac.1\n\n These are the only directories you need for development.\n\n There are man pages for lua and luac, in both nroff and html, and a\n reference manual in html in doc, some sample code in test, and some\n useful stuff in etc. You don't need these directories for development.\n\n If you want to install Lua locally, but in some other directory, do\n \"make install INSTALL_TOP=xxx\", where xxx is your chosen directory.\n\n See below for instructions for Windows and other systems.\n\n* Customization\n -------------\n Three things can be customized by editing a file:\n - Where and how to install Lua -- edit Makefile.\n - How to build Lua -- edit src/Makefile.\n - Lua features -- edit src/luaconf.h.\n\n You don't actually need to edit the Makefiles because you may set the\n relevant variables when invoking make.\n\n On the other hand, if you need to select some Lua features, you'll need\n to edit src/luaconf.h. The edited file will be the one installed, and\n it will be used by any Lua clients that you build, to ensure consistency.\n\n We strongly recommend that you enable dynamic loading. This is done\n automatically for all platforms listed above that have this feature\n (and also Windows). See src/luaconf.h and also src/Makefile.\n\n* Building Lua on Windows and other systems\n -----------------------------------------\n If you're not using the usual Unix tools, then the instructions for\n building Lua depend on the compiler you use. You'll need to create\n projects (or whatever your compiler uses) for building the library,\n the interpreter, and the compiler, as follows:\n\n library:\tlapi.c lcode.c ldebug.c ldo.c ldump.c lfunc.c lgc.c llex.c\n\t\tlmem.c lobject.c lopcodes.c lparser.c lstate.c lstring.c\n\t\tltable.c ltm.c lundump.c lvm.c lzio.c\n\t\tlauxlib.c lbaselib.c ldblib.c liolib.c lmathlib.c loslib.c\n\t\tltablib.c lstrlib.c loadlib.c linit.c\n\n interpreter:\tlibrary, lua.c\n\n compiler:\tlibrary, luac.c print.c\n\n If you use Visual Studio .NET, you can use etc/luavs.bat in its\n \"Command Prompt\".\n\n If all you want is to build the Lua interpreter, you may put all .c files\n in a single project, except for luac.c and print.c. Or just use etc/all.c.\n\n To use Lua as a library in your own programs, you'll need to know how to\n create and use libraries with your compiler.\n\n As mentioned above, you may edit luaconf.h to select some features before\n building Lua.\n\n(end of INSTALL)\n" }, { "path": "README", "content": "README for Lua 5.1\n\nSee INSTALL for installation instructions.\nSee HISTORY for a summary of changes since the last released version.\n\n* What is Lua?\n ------------\n Lua is a powerful, light-weight programming language designed for extending\n applications. Lua is also frequently used as a general-purpose, stand-alone\n language. Lua is free software.\n\n For complete information, visit Lua's web site at http://www.lua.org/ .\n For an executive summary, see http://www.lua.org/about.html .\n\n Lua has been used in many different projects around the world.\n For a short list, see http://www.lua.org/uses.html .\n\n* Availability\n ------------\n Lua is freely available for both academic and commercial purposes.\n See COPYRIGHT and http://www.lua.org/license.html for details.\n Lua can be downloaded at http://www.lua.org/download.html .\n\n* Installation\n ------------\n Lua is implemented in pure ANSI C, and compiles unmodified in all known\n platforms that have an ANSI C compiler. In most Unix-like platforms, simply\n do \"make\" with a suitable target. See INSTALL for detailed instructions.\n\n* Origin\n ------\n Lua is developed at Lua.org, a laboratory of the Department of Computer\n Science of PUC-Rio (the Pontifical Catholic University of Rio de Janeiro\n in Brazil).\n For more information about the authors, see http://www.lua.org/authors.html .\n\n(end of README)\n" }, { "path": "README.llvm-lua", "content": "README for llvm-lua\n\n=== Requires ===\n * LLVM 2.8\n * Clang or llvm-gcc 4.2.x from llvm.org\n\n=== Compile ===\n * mkdir build\n * cd build\n for Release build:\n * cmake .. -DLLVM_PATH= -DCMAKE_BUILD_TYPE=Release\n for Debug build:\n * cmake .. -DLLVM_PATH= -DCMAKE_BUILD_TYPE=Debug\n * make\n\n=== Install ===\n * make install\n\n=== Patches to lua/src ===\n * Emergency Garbage Collector: http://lua-users.org/wiki/EmergencyGarbageCollector\n * LuaCoco-1.1.6: http://luajit.org/coco.html + (x86_64 support added)\n * a few hooks where added to support JIT compiled functions.\n\n=== Programs ===\n * llvm-lua: This command can be used to run Lua script. It uses the LLVM backend to JIT Lua scripts to machine code for faster execution.\n * llvm-luac: This command compiles Lua scripts into LLVM bitcode.\n * lua-compiler: This is a bash script that wraps llvm-luac to compile Lua scripts into standalone executables or loadable modules.\n\n=== Libraries ===\n -- Lua core without LLVM JIT support, but compatible with compiled modules. Can be used as drop-in replacements of the normal Lua libraries.\n * liblua_static.a & liblua.so\n\n -- Static library with LLVM JIT support requires static linking with LLVM libraries.\n * libllvm-lua_static.a & libllvm-lua.so\n\n -- Used for compling Lua scripts to standalone executables.\n * liblua_main.a\n\n=== Using llvm-lua ===\nThe JIT/interpreter command 'llvm-lua' can be used just like the normal 'lua'. There are a lot of extra command line options that expose some options from LLVM, they are not required for normal use. The JIT will compile Lua code with optimization level 3 by default.\n\n=== Static compiling Lua scripts ===\n'llvm-luac' alone can only compile Lua scripts to Lua bytecode or LLVM bitcode. A wrapper script called 'lua-compiler' is provided that wraps 'llvm-luac', the LLVM tools (llc & opt), and gcc.\n\nCompile standalone Lua script:\nlua-compiler script.lua\noutputs: ./script\n\nCompile Lua script as a module:\nlua-compiler -lua-module script.lua\noutputs: ./script.so\n\n=== Embedding 'llvm-lua' with JIT support ===\nThe Lua C API is unchanged and no extra API functions are exposed by llvm-lua. The only change is how host app. is linked with the 'liblua-llvm.a' library instead of the normal 'liblua.a' library.\n\nUse the following command to link your C app with llvm-lua:\ngcc -o embed.o -c etc/embed_jit.c\ng++ -o embed embed.o -lllvm-lua `llvm-config --ldflags --libs core jit native linker` -rdynamic -Wl,-E -lm -ldl\n\nUse the following command to link your C++ app with llvm-lua:\ng++ -o embed.o -c etc/embed_jit.cpp\ng++ -o embed embed.o -lllvm-lua `llvm-config --ldflags --libs core jit native linker` -rdynamic -Wl,-E -lm -ldl\n\n" }, { "path": "TODO", "content": "-- TODO list\n\nmisc:\n* Port lua-compiler bash script to a Lua script.\n* handle coroutine c-stack alignment issues on x86_64 when compiling in DEBUG mode.\n* Add option to compile liblua_main.a without lua parser, lundump/ldump code.\n* Update to latest EGC patch.\n\nmodule naming issues:\n* change how the compiler names modules.\n* give the compiler a search path + module name \"A.B.C\" and have it compile A/B/C.lua into A/B/C.so\n* remove output file extension when nameing the module, instead of just the last three letters.\n\nlua-compiler script:\n* fix linking bug reported by DigitalKiwi:\n #CFLAGS=\" -ggdb -O3 -fomit-frame-pointer -pipe -Wall \"\n CFLAGS=\" -O3 -fomit-frame-pointer -pipe -Wl,-E \"\n http://www.tecgraf.puc-rio.br/~lhf/ftp/lua/install.html\n\n" }, { "path": "cmake/CustomMacros.cmake", "content": "\nmacro(add_llvm_bc_library _target)\n\tset(_llvm_cflags)\n\tget_property(_idirs DIRECTORY PROPERTY INCLUDE_DIRECTORIES)\n\tforeach(_idir ${_idirs})\n\t\tset(_llvm_cflags ${_llvm_cflags} -I${_idir})\n\tendforeach(_idir)\n\n\tif(${ARGC} GREATER 2)\n\t\tset(_bc_files)\n\t\tforeach(_file ${ARGN})\n\t\t\tset(_bc_file \"${CMAKE_CURRENT_BINARY_DIR}/${_file}.bc\")\n\t\t\tset(_bc_files ${_bc_files} ${_bc_file})\n\t\t\tadd_custom_command(OUTPUT ${_bc_file}\n\t\t\t\tCOMMAND ${LLVM_CC} ARGS ${BC_CFLAGS} ${_llvm_cflags} -o ${_bc_file} ${_file}\n\t\t\t\tWORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}\n\t\t\t\tDEPENDS ${_file}\n\t\t\t)\n\t\tendforeach(_file)\n\t\tadd_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_target}.bc\n\t\t\tCOMMAND ${LLVM_LD} ARGS -o ${CMAKE_CURRENT_BINARY_DIR}/${_target}.bc ${_bc_files}\n\t\t\tWORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}\n\t\t\tDEPENDS ${_bc_files}\n\t\t)\n\telse(${ARGC} GREATER 2)\n\t\tadd_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_target}.bc\n\t\t\tCOMMAND ${LLVM_CC} ARGS ${BC_CFLAGS} ${_llvm_cflags} -o ${CMAKE_CURRENT_BINARY_DIR}/${_target}.bc ${ARGV1}\n\t\t\tWORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}\n\t\t\tDEPENDS ${ARGV1}\n\t\t)\n\tendif(${ARGC} GREATER 2)\nendmacro(add_llvm_bc_library)\n\nmacro(add_target_properties _target _name)\n\tset(_properties)\n\tforeach(_prop ${ARGN})\n\t\tset(_properties \"${_properties} ${_prop}\")\n\tendforeach(_prop)\n\tget_target_property(_old_properties ${_target} ${_name})\n\tif(NOT _old_properties)\n\t\t# in case it's NOTFOUND\n\t\tset(_old_properties)\n\tendif(NOT _old_properties)\n\tset_target_properties(${_target} PROPERTIES ${_name} \"${_old_properties} ${_properties}\")\nendmacro(add_target_properties)\n\n" }, { "path": "cmake/FindLLVM.cmake", "content": "# - Find libev\n# Find the native LLVM includes and library\n#\n# LLVM_INCLUDE_DIR - where to find ev.h, etc.\n# LLVM_LIBRARIES - List of libraries when using libev.\n# LLVM_FOUND - True if libev found.\n\nfind_program(LLVM_CONFIG_EXECUTABLE NAMES \"${LLVM_PATH}/bin/llvm-config\" DOC \"llvm-config executable\")\n\nexecute_process(\n\tCOMMAND ${LLVM_CONFIG_EXECUTABLE} --cppflags\n\tOUTPUT_VARIABLE LLVM_CFLAGS\n\tOUTPUT_STRIP_TRAILING_WHITESPACE\n)\n\nexecute_process(\n\tCOMMAND ${LLVM_CONFIG_EXECUTABLE} --ldflags\n\tOUTPUT_VARIABLE LLVM_LFLAGS\n\tOUTPUT_STRIP_TRAILING_WHITESPACE\n)\nexecute_process(\n\tCOMMAND ${LLVM_CONFIG_EXECUTABLE} --libs core jit native linker bitreader bitwriter ipo\n\tOUTPUT_VARIABLE LLVM_JIT_LIBS\n\tOUTPUT_STRIP_TRAILING_WHITESPACE\n)\nexecute_process(\n\tCOMMAND ${LLVM_CONFIG_EXECUTABLE} --libs all\n\tOUTPUT_VARIABLE LLVM_ALL_LIBS\n\tOUTPUT_STRIP_TRAILING_WHITESPACE\n)\n\n" }, { "path": "cmake_uninstall.cmake.in", "content": "IF(NOT EXISTS \"@CMAKE_BINARY_DIR@/install_manifest.txt\")\n MESSAGE(FATAL_ERROR \"Cannot find install manifest: \\\"@CMAKE_BINARY_DIR@/install_manifest.txt\\\"\")\nENDIF(NOT EXISTS \"@CMAKE_BINARY_DIR@/install_manifest.txt\")\n\nFILE(READ \"@CMAKE_BINARY_DIR@/install_manifest.txt\" files)\nSTRING(REGEX REPLACE \"\\n\" \";\" files \"${files}\")\nFOREACH(file ${files})\n MESSAGE(STATUS \"Uninstalling \\\"$ENV{DESTDIR}${file}\\\"\")\n EXEC_PROGRAM(\n \"@CMAKE_COMMAND@\" ARGS \"-E remove \\\"$ENV{DESTDIR}${file}\\\"\"\n OUTPUT_VARIABLE rm_out\n RETURN_VALUE rm_retval\n )\n IF(NOT \"${rm_retval}\" STREQUAL 0)\n MESSAGE(FATAL_ERROR \"Problem when removing \\\"$ENV{DESTDIR}${file}\\\"\")\n ENDIF(NOT \"${rm_retval}\" STREQUAL 0)\nENDFOREACH(file)\n\n" }, { "path": "doc/contents.html", "content": "\n\n\nLua 5.1 Reference Manual - contents\n\n\n\n\n\n\n\n
\n

\n\"\"\nLua 5.1 Reference Manual\n

\n\nThis is an online version of\n
\n\n\"\"\n\nLua 5.1 Reference Manual\n
by R. Ierusalimschy, L. H. de Figueiredo, W. Celes\n
Lua.org, August 2006\n
ISBN 85-903798-3-3\n
\n\"[Buy\n
\n
\n

\n\nBuy a copy of this book and \nhelp to support\nthe Lua project.\n

\n\nThe reference manual is the official definition of the Lua language.\nFor a complete introduction to Lua programming, see the book\nProgramming in Lua.\n

\n\nstart\n·\ncontents\n·\nindex\n·\nportugus\n·\nespaol\n

\n\nCopyright © 2006-2008 Lua.org, PUC-Rio.\nFreely available under the terms of the\nLua license.\n\n

\n\n

Contents

\n\n\n

Index

\n\n\n\n\n\n\n\n
\n

Lua functions

\n_G
\n_VERSION
\nassert
\ncollectgarbage
\ndofile
\nerror
\ngetfenv
\ngetmetatable
\nipairs
\nload
\nloadfile
\nloadstring
\nmodule
\nnext
\npairs
\npcall
\nprint
\nrawequal
\nrawget
\nrawset
\nrequire
\nselect
\nsetfenv
\nsetmetatable
\ntonumber
\ntostring
\ntype
\nunpack
\nxpcall
\n

\n\ncoroutine.create
\ncoroutine.resume
\ncoroutine.running
\ncoroutine.status
\ncoroutine.wrap
\ncoroutine.yield
\n

\n\ndebug.debug
\ndebug.getfenv
\ndebug.gethook
\ndebug.getinfo
\ndebug.getlocal
\ndebug.getmetatable
\ndebug.getregistry
\ndebug.getupvalue
\ndebug.setfenv
\ndebug.sethook
\ndebug.setlocal
\ndebug.setmetatable
\ndebug.setupvalue
\ndebug.traceback
\n\n

\n

 

\nfile:close
\nfile:flush
\nfile:lines
\nfile:read
\nfile:seek
\nfile:setvbuf
\nfile:write
\n

\n\nio.close
\nio.flush
\nio.input
\nio.lines
\nio.open
\nio.output
\nio.popen
\nio.read
\nio.stderr
\nio.stdin
\nio.stdout
\nio.tmpfile
\nio.type
\nio.write
\n

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

\n\nos.clock
\nos.date
\nos.difftime
\nos.execute
\nos.exit
\nos.getenv
\nos.remove
\nos.rename
\nos.setlocale
\nos.time
\nos.tmpname
\n

\n\npackage.cpath
\npackage.loaded
\npackage.loaders
\npackage.loadlib
\npackage.path
\npackage.preload
\npackage.seeall
\n

\n\nstring.byte
\nstring.char
\nstring.dump
\nstring.find
\nstring.format
\nstring.gmatch
\nstring.gsub
\nstring.len
\nstring.lower
\nstring.match
\nstring.rep
\nstring.reverse
\nstring.sub
\nstring.upper
\n

\n\ntable.concat
\ntable.insert
\ntable.maxn
\ntable.remove
\ntable.sort
\n\n

\n

C API

\nlua_Alloc
\nlua_CFunction
\nlua_Debug
\nlua_Hook
\nlua_Integer
\nlua_Number
\nlua_Reader
\nlua_State
\nlua_Writer
\n

\n\nlua_atpanic
\nlua_call
\nlua_checkstack
\nlua_close
\nlua_concat
\nlua_cpcall
\nlua_createtable
\nlua_dump
\nlua_equal
\nlua_error
\nlua_gc
\nlua_getallocf
\nlua_getfenv
\nlua_getfield
\nlua_getglobal
\nlua_gethook
\nlua_gethookcount
\nlua_gethookmask
\nlua_getinfo
\nlua_getlocal
\nlua_getmetatable
\nlua_getstack
\nlua_gettable
\nlua_gettop
\nlua_getupvalue
\nlua_insert
\nlua_isboolean
\nlua_iscfunction
\nlua_isfunction
\nlua_islightuserdata
\nlua_isnil
\nlua_isnone
\nlua_isnoneornil
\nlua_isnumber
\nlua_isstring
\nlua_istable
\nlua_isthread
\nlua_isuserdata
\nlua_lessthan
\nlua_load
\nlua_newstate
\nlua_newtable
\nlua_newthread
\nlua_newuserdata
\nlua_next
\nlua_objlen
\nlua_pcall
\nlua_pop
\nlua_pushboolean
\nlua_pushcclosure
\nlua_pushcfunction
\nlua_pushfstring
\nlua_pushinteger
\nlua_pushlightuserdata
\nlua_pushliteral
\nlua_pushlstring
\nlua_pushnil
\nlua_pushnumber
\nlua_pushstring
\nlua_pushthread
\nlua_pushvalue
\nlua_pushvfstring
\nlua_rawequal
\nlua_rawget
\nlua_rawgeti
\nlua_rawset
\nlua_rawseti
\nlua_register
\nlua_remove
\nlua_replace
\nlua_resume
\nlua_setallocf
\nlua_setfenv
\nlua_setfield
\nlua_setglobal
\nlua_sethook
\nlua_setlocal
\nlua_setmetatable
\nlua_settable
\nlua_settop
\nlua_setupvalue
\nlua_status
\nlua_toboolean
\nlua_tocfunction
\nlua_tointeger
\nlua_tolstring
\nlua_tonumber
\nlua_topointer
\nlua_tostring
\nlua_tothread
\nlua_touserdata
\nlua_type
\nlua_typename
\nlua_upvalueindex
\nlua_xmove
\nlua_yield
\n\n

\n

auxiliary library

\nluaL_Buffer
\nluaL_Reg
\n

\n\nluaL_addchar
\nluaL_addlstring
\nluaL_addsize
\nluaL_addstring
\nluaL_addvalue
\nluaL_argcheck
\nluaL_argerror
\nluaL_buffinit
\nluaL_callmeta
\nluaL_checkany
\nluaL_checkint
\nluaL_checkinteger
\nluaL_checklong
\nluaL_checklstring
\nluaL_checknumber
\nluaL_checkoption
\nluaL_checkstack
\nluaL_checkstring
\nluaL_checktype
\nluaL_checkudata
\nluaL_dofile
\nluaL_dostring
\nluaL_error
\nluaL_getmetafield
\nluaL_getmetatable
\nluaL_gsub
\nluaL_loadbuffer
\nluaL_loadfile
\nluaL_loadstring
\nluaL_newmetatable
\nluaL_newstate
\nluaL_openlibs
\nluaL_optint
\nluaL_optinteger
\nluaL_optlong
\nluaL_optlstring
\nluaL_optnumber
\nluaL_optstring
\nluaL_prepbuffer
\nluaL_pushresult
\nluaL_ref
\nluaL_register
\nluaL_typename
\nluaL_typerror
\nluaL_unref
\nluaL_where
\n\n

\n

\n\n

\n\nLast update:\nSat Jan 19 13:24:29 BRST 2008\n\n\n\n\n\n" }, { "path": "doc/lua.1", "content": ".\\\" $Id: lua.man,v 1.11 2006/01/06 16:03:34 lhf Exp $\n.TH LUA 1 \"$Date: 2006/01/06 16:03:34 $\"\n.SH NAME\nlua \\- Lua interpreter\n.SH SYNOPSIS\n.B lua\n[\n.I options\n]\n[\n.I script\n[\n.I args\n]\n]\n.SH DESCRIPTION\n.B lua\nis the stand-alone Lua interpreter.\nIt loads and executes Lua programs,\neither in textual source form or\nin precompiled binary form.\n(Precompiled binaries are output by\n.BR luac ,\nthe Lua compiler.)\n.B lua\ncan be used as a batch interpreter and also interactively.\n.LP\nThe given\n.I options\n(see below)\nare executed and then\nthe Lua program in file\n.I script\nis loaded and executed.\nThe given\n.I args\nare available to\n.I script\nas strings in a global table named\n.BR arg .\nIf these arguments contain spaces or other characters special to the shell,\nthen they should be quoted\n(but note that the quotes will be removed by the shell).\nThe arguments in\n.B arg\nstart at 0,\nwhich contains the string\n.RI ' script '.\nThe index of the last argument is stored in\n.BR arg.n .\nThe arguments given in the command line before\n.IR script ,\nincluding the name of the interpreter,\nare available in negative indices in\n.BR arg .\n.LP\nAt the very start,\nbefore even handling the command line,\n.B lua\nexecutes the contents of the environment variable\n.BR LUA_INIT ,\nif it is defined.\nIf the value of\n.B LUA_INIT\nis of the form\n.RI '@ filename ',\nthen\n.I filename\nis executed.\nOtherwise, the string is assumed to be a Lua statement and is executed.\n.LP\nOptions start with\n.B '\\-'\nand are described below.\nYou can use\n.B \"'\\--'\"\nto signal the end of options.\n.LP\nIf no arguments are given,\nthen\n.B \"\\-v \\-i\"\nis assumed when the standard input is a terminal;\notherwise,\n.B \"\\-\"\nis assumed.\n.LP\nIn interactive mode,\n.B lua\nprompts the user,\nreads lines from the standard input,\nand executes them as they are read.\nIf a line does not contain a complete statement,\nthen a secondary prompt is displayed and\nlines are read until a complete statement is formed or\na syntax error is found.\nSo, one way to interrupt the reading of an incomplete statement is\nto force a syntax error:\nadding a\n.B ';' \nin the middle of a statement is a sure way of forcing a syntax error\n(except inside multiline strings and comments; these must be closed explicitly).\nIf a line starts with\n.BR '=' ,\nthen\n.B lua\ndisplays the values of all the expressions in the remainder of the\nline. The expressions must be separated by commas.\nThe primary prompt is the value of the global variable\n.BR _PROMPT ,\nif this value is a string;\notherwise, the default prompt is used.\nSimilarly, the secondary prompt is the value of the global variable\n.BR _PROMPT2 .\nSo,\nto change the prompts,\nset the corresponding variable to a string of your choice.\nYou can do that after calling the interpreter\nor on the command line\n(but in this case you have to be careful with quotes\nif the prompt string contains a space; otherwise you may confuse the shell.)\nThe default prompts are \"> \" and \">> \".\n.SH OPTIONS\n.TP\n.B \\-\nload and execute the standard input as a file,\nthat is,\nnot interactively,\neven when the standard input is a terminal.\n.TP\n.BI \\-e \" stat\"\nexecute statement\n.IR stat .\nYou need to quote\n.I stat \nif it contains spaces, quotes,\nor other characters special to the shell.\n.TP\n.B \\-i\nenter interactive mode after\n.I script\nis executed.\n.TP\n.BI \\-l \" name\"\ncall\n.BI require(' name ')\nbefore executing\n.IR script .\nTypically used to load libraries.\n.TP\n.B \\-v\nshow version information.\n.SH \"SEE ALSO\"\n.BR luac (1)\n.br\nhttp://www.lua.org/\n.SH DIAGNOSTICS\nError messages should be self explanatory.\n.SH AUTHORS\nR. Ierusalimschy,\nL. H. de Figueiredo,\nand\nW. Celes\n.\\\" EOF\n" }, { "path": "doc/lua.css", "content": "body {\n\tcolor: #000000 ;\n\tbackground-color: #FFFFFF ;\n\tfont-family: sans-serif ;\n\ttext-align: justify ;\n\tmargin-right: 20px ;\n\tmargin-left: 20px ;\n}\n\nh1, h2, h3, h4 {\n\tfont-weight: normal ;\n\tfont-style: italic ;\n}\n\na:link {\n\tcolor: #000080 ;\n\tbackground-color: inherit ;\n\ttext-decoration: none ;\n}\n\na:visited {\n\tbackground-color: inherit ;\n\ttext-decoration: none ;\n}\n\na:link:hover, a:visited:hover {\n\tcolor: #000080 ;\n\tbackground-color: #E0E0FF ;\n}\n\na:link:active, a:visited:active {\n\tcolor: #FF0000 ;\n}\n\nhr {\n\tborder: 0 ;\n\theight: 1px ;\n\tcolor: #a0a0a0 ;\n\tbackground-color: #a0a0a0 ;\n}\n\n" }, { "path": "doc/lua.html", "content": "\n\n\nLUA man page\n\n\n\n\n\n

NAME

\nlua - Lua interpreter\n

SYNOPSIS

\nlua\n[\noptions\n]\n[\nscript\n[\nargs\n]\n]\n

DESCRIPTION

\nlua\nis the stand-alone Lua interpreter.\nIt loads and executes Lua programs,\neither in textual source form or\nin precompiled binary form.\n(Precompiled binaries are output by\nluac,\nthe Lua compiler.)\nlua\ncan be used as a batch interpreter and also interactively.\n

\nThe given\noptions\n(see below)\nare executed and then\nthe Lua program in file\nscript\nis loaded and executed.\nThe given\nargs\nare available to\nscript\nas strings in a global table named\narg.\nIf these arguments contain spaces or other characters special to the shell,\nthen they should be quoted\n(but note that the quotes will be removed by the shell).\nThe arguments in\narg\nstart at 0,\nwhich contains the string\n'script'.\nThe index of the last argument is stored in\narg.n.\nThe arguments given in the command line before\nscript,\nincluding the name of the interpreter,\nare available in negative indices in\narg.\n

\nAt the very start,\nbefore even handling the command line,\nlua\nexecutes the contents of the environment variable\nLUA_INIT,\nif it is defined.\nIf the value of\nLUA_INIT\nis of the form\n'@filename',\nthen\nfilename\nis executed.\nOtherwise, the string is assumed to be a Lua statement and is executed.\n

\nOptions start with\n'-'\nand are described below.\nYou can use\n'--'\nto signal the end of options.\n

\nIf no arguments are given,\nthen\n\"-v -i\"\nis assumed when the standard input is a terminal;\notherwise,\n\"-\"\nis assumed.\n

\nIn interactive mode,\nlua\nprompts the user,\nreads lines from the standard input,\nand executes them as they are read.\nIf a line does not contain a complete statement,\nthen a secondary prompt is displayed and\nlines are read until a complete statement is formed or\na syntax error is found.\nSo, one way to interrupt the reading of an incomplete statement is\nto force a syntax error:\nadding a\n';'\nin the middle of a statement is a sure way of forcing a syntax error\n(except inside multiline strings and comments; these must be closed explicitly).\nIf a line starts with\n'=',\nthen\nlua\ndisplays the values of all the expressions in the remainder of the\nline. The expressions must be separated by commas.\nThe primary prompt is the value of the global variable\n_PROMPT,\nif this value is a string;\notherwise, the default prompt is used.\nSimilarly, the secondary prompt is the value of the global variable\n_PROMPT2.\nSo,\nto change the prompts,\nset the corresponding variable to a string of your choice.\nYou can do that after calling the interpreter\nor on the command line\n(but in this case you have to be careful with quotes\nif the prompt string contains a space; otherwise you may confuse the shell.)\nThe default prompts are \"> \" and \">> \".\n

OPTIONS

\n

\n-\nload and execute the standard input as a file,\nthat is,\nnot interactively,\neven when the standard input is a terminal.\n

\n-e stat\nexecute statement\nstat.\nYou need to quote\nstat \nif it contains spaces, quotes,\nor other characters special to the shell.\n

\n-i\nenter interactive mode after\nscript\nis executed.\n

\n-l name\ncall\nrequire('name')\nbefore executing\nscript.\nTypically used to load libraries.\n

\n-v\nshow version information.\n

SEE ALSO

\nluac(1)\n
\nhttp://www.lua.org/\n

DIAGNOSTICS

\nError messages should be self explanatory.\n

AUTHORS

\nR. Ierusalimschy,\nL. H. de Figueiredo,\nand\nW. Celes\n\n\n\n" }, { "path": "doc/luac.1", "content": ".\\\" $Id: luac.man,v 1.28 2006/01/06 16:03:34 lhf Exp $\n.TH LUAC 1 \"$Date: 2006/01/06 16:03:34 $\"\n.SH NAME\nluac \\- Lua compiler\n.SH SYNOPSIS\n.B luac\n[\n.I options\n] [\n.I filenames\n]\n.SH DESCRIPTION\n.B luac\nis the Lua compiler.\nIt translates programs written in the Lua programming language\ninto binary files that can be later loaded and executed.\n.LP\nThe main advantages of precompiling chunks are:\nfaster loading,\nprotecting source code from accidental user changes,\nand\noff-line syntax checking.\n.LP\nPre-compiling does not imply faster execution\nbecause in Lua chunks are always compiled into bytecodes before being executed.\n.B luac\nsimply allows those bytecodes to be saved in a file for later execution.\n.LP\nPre-compiled chunks are not necessarily smaller than the corresponding source.\nThe main goal in pre-compiling is faster loading.\n.LP\nThe binary files created by\n.B luac\nare portable only among architectures with the same word size and byte order.\n.LP\n.B luac\nproduces a single output file containing the bytecodes\nfor all source files given.\nBy default,\nthe output file is named\n.BR luac.out ,\nbut you can change this with the\n.B \\-o\noption.\n.LP\nIn the command line,\nyou can mix\ntext files containing Lua source and\nbinary files containing precompiled chunks.\nThis is useful to combine several precompiled chunks,\neven from different (but compatible) platforms,\ninto a single precompiled chunk.\n.LP\nYou can use\n.B \"'\\-'\"\nto indicate the standard input as a source file\nand\n.B \"'\\--'\"\nto signal the end of options\n(that is,\nall remaining arguments will be treated as files even if they start with\n.BR \"'\\-'\" ).\n.LP\nThe internal format of the binary files produced by\n.B luac\nis likely to change when a new version of Lua is released.\nSo,\nsave the source files of all Lua programs that you precompile.\n.LP\n.SH OPTIONS\nOptions must be separate.\n.TP\n.B \\-l\nproduce a listing of the compiled bytecode for Lua's virtual machine.\nListing bytecodes is useful to learn about Lua's virtual machine.\nIf no files are given, then\n.B luac\nloads\n.B luac.out\nand lists its contents.\n.TP\n.BI \\-o \" file\"\noutput to\n.IR file ,\ninstead of the default\n.BR luac.out .\n(You can use\n.B \"'\\-'\"\nfor standard output,\nbut not on platforms that open standard output in text mode.)\nThe output file may be a source file because\nall files are loaded before the output file is written.\nBe careful not to overwrite precious files.\n.TP\n.B \\-p\nload files but do not generate any output file.\nUsed mainly for syntax checking and for testing precompiled chunks:\ncorrupted files will probably generate errors when loaded.\nLua always performs a thorough integrity test on precompiled chunks.\nBytecode that passes this test is completely safe,\nin the sense that it will not break the interpreter.\nHowever,\nthere is no guarantee that such code does anything sensible.\n(None can be given, because the halting problem is unsolvable.)\nIf no files are given, then\n.B luac\nloads\n.B luac.out\nand tests its contents.\nNo messages are displayed if the file passes the integrity test.\n.TP\n.B \\-s\nstrip debug information before writing the output file.\nThis saves some space in very large chunks,\nbut if errors occur when running a stripped chunk,\nthen the error messages may not contain the full information they usually do.\nFor instance,\nline numbers and names of local variables are lost.\n.TP\n.B \\-v\nshow version information.\n.SH FILES\n.TP 15\n.B luac.out\ndefault output file\n.SH \"SEE ALSO\"\n.BR lua (1)\n.br\nhttp://www.lua.org/\n.SH DIAGNOSTICS\nError messages should be self explanatory.\n.SH AUTHORS\nL. H. de Figueiredo,\nR. Ierusalimschy and\nW. Celes\n.\\\" EOF\n" }, { "path": "doc/luac.html", "content": "\n\n\nLUAC man page\n\n\n\n\n\n

NAME

\nluac - Lua compiler\n

SYNOPSIS

\nluac\n[\noptions\n] [\nfilenames\n]\n

DESCRIPTION

\nluac\nis the Lua compiler.\nIt translates programs written in the Lua programming language\ninto binary files that can be later loaded and executed.\n

\nThe main advantages of precompiling chunks are:\nfaster loading,\nprotecting source code from accidental user changes,\nand\noff-line syntax checking.\n

\nPrecompiling does not imply faster execution\nbecause in Lua chunks are always compiled into bytecodes before being executed.\nluac\nsimply allows those bytecodes to be saved in a file for later execution.\n

\nPrecompiled chunks are not necessarily smaller than the corresponding source.\nThe main goal in precompiling is faster loading.\n

\nThe binary files created by\nluac\nare portable only among architectures with the same word size and byte order.\n

\nluac\nproduces a single output file containing the bytecodes\nfor all source files given.\nBy default,\nthe output file is named\nluac.out,\nbut you can change this with the\n-o\noption.\n

\nIn the command line,\nyou can mix\ntext files containing Lua source and\nbinary files containing precompiled chunks.\nThis is useful because several precompiled chunks,\neven from different (but compatible) platforms,\ncan be combined into a single precompiled chunk.\n

\nYou can use\n'-'\nto indicate the standard input as a source file\nand\n'--'\nto signal the end of options\n(that is,\nall remaining arguments will be treated as files even if they start with\n'-').\n

\nThe internal format of the binary files produced by\nluac\nis likely to change when a new version of Lua is released.\nSo,\nsave the source files of all Lua programs that you precompile.\n

\n

OPTIONS

\nOptions must be separate.\n

\n-l\nproduce a listing of the compiled bytecode for Lua's virtual machine.\nListing bytecodes is useful to learn about Lua's virtual machine.\nIf no files are given, then\nluac\nloads\nluac.out\nand lists its contents.\n

\n-o file\noutput to\nfile,\ninstead of the default\nluac.out.\n(You can use\n'-'\nfor standard output,\nbut not on platforms that open standard output in text mode.)\nThe output file may be a source file because\nall files are loaded before the output file is written.\nBe careful not to overwrite precious files.\n

\n-p\nload files but do not generate any output file.\nUsed mainly for syntax checking and for testing precompiled chunks:\ncorrupted files will probably generate errors when loaded.\nLua always performs a thorough integrity test on precompiled chunks.\nBytecode that passes this test is completely safe,\nin the sense that it will not break the interpreter.\nHowever,\nthere is no guarantee that such code does anything sensible.\n(None can be given, because the halting problem is unsolvable.)\nIf no files are given, then\nluac\nloads\nluac.out\nand tests its contents.\nNo messages are displayed if the file passes the integrity test.\n

\n-s\nstrip debug information before writing the output file.\nThis saves some space in very large chunks,\nbut if errors occur when running a stripped chunk,\nthen the error messages may not contain the full information they usually do.\nFor instance,\nline numbers and names of local variables are lost.\n

\n-v\nshow version information.\n

FILES

\n

\nluac.out\ndefault output file\n

SEE ALSO

\nlua(1)\n
\nhttp://www.lua.org/\n

DIAGNOSTICS

\nError messages should be self explanatory.\n

AUTHORS

\nL. H. de Figueiredo,\nR. Ierusalimschy and\nW. Celes\n\n\n\n" }, { "path": "doc/manual.css", "content": "h3 code {\n\tfont-family: inherit ;\n}\n\npre {\n\tfont-size: 105% ;\n}\n\nspan.apii {\n\tfloat: right ;\n\tfont-family: inherit ;\n}\n\n" }, { "path": "doc/manual.html", "content": "\n\n\n\nLua 5.1 Reference Manual\n\n\n\n\n\n\n\n
\n

\n\"\"\nLua 5.1 Reference Manual\n

\n\nby Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes\n

\n\nCopyright © 2006-2008 Lua.org, PUC-Rio.\nFreely available under the terms of the\nLua license.\n\n

\n

\n\ncontents\n·\nindex\n\n\n

\n\n\n\n\n\n\n

1 - Introduction

\n\n

\nLua is an extension programming language designed to support\ngeneral procedural programming with data description\nfacilities.\nIt also offers good support for object-oriented programming,\nfunctional programming, and data-driven programming.\nLua is intended to be used as a powerful, light-weight\nscripting language for any program that needs one.\nLua is implemented as a library, written in clean C\n(that is, in the common subset of ANSI C and C++).\n\n\n

\nBeing an extension language, Lua has no notion of a \"main\" program:\nit only works embedded in a host client,\ncalled the embedding program or simply the host.\nThis host program can invoke functions to execute a piece of Lua code,\ncan write and read Lua variables,\nand can register C functions to be called by Lua code.\nThrough the use of C functions, Lua can be augmented to cope with\na wide range of different domains,\nthus creating customized programming languages sharing a syntactical framework.\nThe Lua distribution includes a sample host program called lua,\nwhich uses the Lua library to offer a complete, stand-alone Lua interpreter.\n\n\n

\nLua is free software,\nand is provided as usual with no guarantees,\nas stated in its license.\nThe implementation described in this manual is available\nat Lua's official web site, www.lua.org.\n\n\n

\nLike any other reference manual,\nthis document is dry in places.\nFor a discussion of the decisions behind the design of Lua,\nsee the technical papers available at Lua's web site.\nFor a detailed introduction to programming in Lua,\nsee Roberto's book, Programming in Lua (Second Edition).\n\n\n\n

2 - The Language

\n\n

\nThis section describes the lexis, the syntax, and the semantics of Lua.\nIn other words,\nthis section describes\nwhich tokens are valid,\nhow they can be combined,\nand what their combinations mean.\n\n\n

\nThe language constructs will be explained using the usual extended BNF notation,\nin which\n{a} means 0 or more a's, and\n[a] means an optional a.\nNon-terminals are shown like non-terminal,\nkeywords are shown like kword,\nand other terminal symbols are shown like `=´.\nThe complete syntax of Lua can be found in §8\nat the end of this manual.\n\n\n\n

2.1 - Lexical Conventions

\n\n

\nNames\n(also called identifiers)\nin Lua can be any string of letters,\ndigits, and underscores,\nnot beginning with a digit.\nThis coincides with the definition of names in most languages.\n(The definition of letter depends on the current locale:\nany character considered alphabetic by the current locale\ncan be used in an identifier.)\nIdentifiers are used to name variables and table fields.\n\n\n

\nThe following keywords are reserved\nand cannot be used as names:\n\n\n

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

\nLua is a case-sensitive language:\nand is a reserved word, but And and AND\nare two different, valid names.\nAs a convention, names starting with an underscore followed by\nuppercase letters (such as _VERSION)\nare reserved for internal global variables used by Lua.\n\n\n

\nThe following strings denote other tokens:\n\n

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

\nLiteral strings\ncan be delimited by matching single or double quotes,\nand can contain the following C-like escape sequences:\n'\\a' (bell),\n'\\b' (backspace),\n'\\f' (form feed),\n'\\n' (newline),\n'\\r' (carriage return),\n'\\t' (horizontal tab),\n'\\v' (vertical tab),\n'\\\\' (backslash),\n'\\\"' (quotation mark [double quote]),\nand '\\'' (apostrophe [single quote]).\nMoreover, a backslash followed by a real newline\nresults in a newline in the string.\nA character in a string can also be specified by its numerical value\nusing the escape sequence \\ddd,\nwhere ddd is a sequence of up to three decimal digits.\n(Note that if a numerical escape is to be followed by a digit,\nit must be expressed using exactly three digits.)\nStrings in Lua can contain any 8-bit value, including embedded zeros,\nwhich can be specified as '\\0'.\n\n\n

\nLiteral strings can also be defined using a long format\nenclosed by long brackets.\nWe define an opening long bracket of level n as an opening\nsquare bracket followed by n equal signs followed by another\nopening square bracket.\nSo, an opening long bracket of level 0 is written as [[,\nan opening long bracket of level 1 is written as [=[,\nand so on.\nA closing long bracket is defined similarly;\nfor instance, a closing long bracket of level 4 is written as ]====].\nA long string starts with an opening long bracket of any level and\nends at the first closing long bracket of the same level.\nLiterals in this bracketed form can run for several lines,\ndo not interpret any escape sequences,\nand ignore long brackets of any other level.\nThey can contain anything except a closing bracket of the proper level.\n\n\n

\nFor convenience,\nwhen the opening long bracket is immediately followed by a newline,\nthe newline is not included in the string.\nAs an example, in a system using ASCII\n(in which 'a' is coded as 97,\nnewline is coded as 10, and '1' is coded as 49),\nthe five literal strings below denote the same string:\n\n

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

\nA numerical constant can be written with an optional decimal part\nand an optional decimal exponent.\nLua also accepts integer hexadecimal constants,\nby prefixing them with 0x.\nExamples of valid numerical constants are\n\n

\n     3   3.0   3.1416   314.16e-2   0.31416E1   0xff   0x56\n
\n\n

\nA comment starts with a double hyphen (--)\nanywhere outside a string.\nIf the text immediately after -- is not an opening long bracket,\nthe comment is a short comment,\nwhich runs until the end of the line.\nOtherwise, it is a long comment,\nwhich runs until the corresponding closing long bracket.\nLong comments are frequently used to disable code temporarily.\n\n\n\n\n\n

2.2 - Values and Types

\n\n

\nLua is a dynamically typed language.\nThis means that\nvariables do not have types; only values do.\nThere are no type definitions in the language.\nAll values carry their own type.\n\n\n

\nAll values in Lua are first-class values.\nThis means that all values can be stored in variables,\npassed as arguments to other functions, and returned as results.\n\n\n

\nThere are eight basic types in Lua:\nnil, boolean, number,\nstring, function, userdata,\nthread, and table.\nNil is the type of the value nil,\nwhose main property is to be different from any other value;\nit usually represents the absence of a useful value.\nBoolean is the type of the values false and true.\nBoth nil and false make a condition false;\nany other value makes it true.\nNumber represents real (double-precision floating-point) numbers.\n(It is easy to build Lua interpreters that use other\ninternal representations for numbers,\nsuch as single-precision float or long integers;\nsee file luaconf.h.)\nString represents arrays of characters.\n\nLua is 8-bit clean:\nstrings can contain any 8-bit character,\nincluding embedded zeros ('\\0') (see §2.1).\n\n\n

\nLua can call (and manipulate) functions written in Lua and\nfunctions written in C\n(see §2.5.8).\n\n\n

\nThe type userdata is provided to allow arbitrary C data to\nbe stored in Lua variables.\nThis type corresponds to a block of raw memory\nand has no pre-defined operations in Lua,\nexcept assignment and identity test.\nHowever, by using metatables,\nthe programmer can define operations for userdata values\n(see §2.8).\nUserdata values cannot be created or modified in Lua,\nonly through the C API.\nThis guarantees the integrity of data owned by the host program.\n\n\n

\nThe type thread represents independent threads of execution\nand it is used to implement coroutines (see §2.11).\nDo not confuse Lua threads with operating-system threads.\nLua supports coroutines on all systems,\neven those that do not support threads.\n\n\n

\nThe type table implements associative arrays,\nthat is, arrays that can be indexed not only with numbers,\nbut with any value (except nil).\nTables can be heterogeneous;\nthat is, they can contain values of all types (except nil).\nTables are the sole data structuring mechanism in Lua;\nthey can be used to represent ordinary arrays,\nsymbol tables, sets, records, graphs, trees, etc.\nTo represent records, Lua uses the field name as an index.\nThe language supports this representation by\nproviding a.name as syntactic sugar for a[\"name\"].\nThere are several convenient ways to create tables in Lua\n(see §2.5.7).\n\n\n

\nLike indices,\nthe value of a table field can be of any type (except nil).\nIn particular,\nbecause functions are first-class values,\ntable fields can contain functions.\nThus tables can also carry methods (see §2.5.9).\n\n\n

\nTables, functions, threads, and (full) userdata values are objects:\nvariables do not actually contain these values,\nonly references to them.\nAssignment, parameter passing, and function returns\nalways manipulate references to such values;\nthese operations do not imply any kind of copy.\n\n\n

\nThe library function type returns a string describing the type\nof a given value.\n\n\n\n

2.2.1 - Coercion

\n\n

\nLua provides automatic conversion between\nstring and number values at run time.\nAny arithmetic operation applied to a string tries to convert\nthis string to a number, following the usual conversion rules.\nConversely, whenever a number is used where a string is expected,\nthe number is converted to a string, in a reasonable format.\nFor complete control over how numbers are converted to strings,\nuse the format function from the string library\n(see string.format).\n\n\n\n\n\n\n\n

2.3 - Variables

\n\n

\nVariables are places that store values.\n\nThere are three kinds of variables in Lua:\nglobal variables, local variables, and table fields.\n\n\n

\nA single name can denote a global variable or a local variable\n(or a function's formal parameter,\nwhich is a particular kind of local variable):\n\n

\n\tvar ::= Name\n

\nName denotes identifiers, as defined in §2.1.\n\n\n

\nAny variable is assumed to be global unless explicitly declared\nas a local (see §2.4.7).\nLocal variables are lexically scoped:\nlocal variables can be freely accessed by functions\ndefined inside their scope (see §2.6).\n\n\n

\nBefore the first assignment to a variable, its value is nil.\n\n\n

\nSquare brackets are used to index a table:\n\n

\n\tvar ::= prefixexp `[´ exp `]´\n

\nThe meaning of accesses to global variables \nand table fields can be changed via metatables.\nAn access to an indexed variable t[i] is equivalent to\na call gettable_event(t,i).\n(See §2.8 for a complete description of the\ngettable_event function.\nThis function is not defined or callable in Lua.\nWe use it here only for explanatory purposes.)\n\n\n

\nThe syntax var.Name is just syntactic sugar for\nvar[\"Name\"]:\n\n

\n\tvar ::= prefixexp `.´ Name\n
\n\n

\nAll global variables live as fields in ordinary Lua tables,\ncalled environment tables or simply\nenvironments (see §2.9).\nEach function has its own reference to an environment,\nso that all global variables in this function\nwill refer to this environment table.\nWhen a function is created,\nit inherits the environment from the function that created it.\nTo get the environment table of a Lua function,\nyou call getfenv.\nTo replace it,\nyou call setfenv.\n(You can only manipulate the environment of C functions\nthrough the debug library; (see §5.9).)\n\n\n

\nAn access to a global variable x\nis equivalent to _env.x,\nwhich in turn is equivalent to\n\n

\n     gettable_event(_env, \"x\")\n

\nwhere _env is the environment of the running function.\n(See §2.8 for a complete description of the\ngettable_event function.\nThis function is not defined or callable in Lua.\nSimilarly, the _env variable is not defined in Lua.\nWe use them here only for explanatory purposes.)\n\n\n\n\n\n

2.4 - Statements

\n\n

\nLua supports an almost conventional set of statements,\nsimilar to those in Pascal or C.\nThis set includes\nassignments, control structures, function calls,\nand variable declarations.\n\n\n\n

2.4.1 - Chunks

\n\n

\nThe unit of execution of Lua is called a chunk.\nA chunk is simply a sequence of statements,\nwhich are executed sequentially.\nEach statement can be optionally followed by a semicolon:\n\n

\n\tchunk ::= {stat [`;´]}\n

\nThere are no empty statements and thus ';;' is not legal.\n\n\n

\nLua handles a chunk as the body of an anonymous function \nwith a variable number of arguments\n(see §2.5.9).\nAs such, chunks can define local variables,\nreceive arguments, and return values.\n\n\n

\nA chunk can be stored in a file or in a string inside the host program.\nTo execute a chunk,\nLua first pre-compiles the chunk into instructions for a virtual machine,\nand then it executes the compiled code\nwith an interpreter for the virtual machine.\n\n\n

\nChunks can also be pre-compiled into binary form;\nsee program luac for details.\nPrograms in source and compiled forms are interchangeable;\nLua automatically detects the file type and acts accordingly.\n\n\n\n\n\n\n

2.4.2 - Blocks

\nA block is a list of statements;\nsyntactically, a block is the same as a chunk:\n\n

\n\tblock ::= chunk\n
\n\n

\nA block can be explicitly delimited to produce a single statement:\n\n

\n\tstat ::= do block end\n

\nExplicit blocks are useful\nto control the scope of variable declarations.\nExplicit blocks are also sometimes used to\nadd a return or break statement in the middle\nof another block (see §2.4.4).\n\n\n\n\n\n

2.4.3 - Assignment

\n\n

\nLua allows multiple assignments.\nTherefore, the syntax for assignment\ndefines a list of variables on the left side\nand a list of expressions on the right side.\nThe elements in both lists are separated by commas:\n\n

\n\tstat ::= varlist `=´ explist\n\tvarlist ::= var {`,´ var}\n\texplist ::= exp {`,´ exp}\n

\nExpressions are discussed in §2.5.\n\n\n

\nBefore the assignment,\nthe list of values is adjusted to the length of\nthe list of variables.\nIf there are more values than needed,\nthe excess values are thrown away.\nIf there are fewer values than needed,\nthe list is extended with as many nil's as needed.\nIf the list of expressions ends with a function call,\nthen all values returned by that call enter the list of values,\nbefore the adjustment\n(except when the call is enclosed in parentheses; see §2.5).\n\n\n

\nThe assignment statement first evaluates all its expressions\nand only then are the assignments performed.\nThus the code\n\n

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

\nsets a[3] to 20, without affecting a[4]\nbecause the i in a[i] is evaluated (to 3)\nbefore it is assigned 4.\nSimilarly, the line\n\n

\n     x, y = y, x\n

\nexchanges the values of x and y,\nand\n\n

\n     x, y, z = y, z, x\n

\ncyclically permutes the values of x, y, and z.\n\n\n

\nThe meaning of assignments to global variables\nand table fields can be changed via metatables.\nAn assignment to an indexed variable t[i] = val is equivalent to\nsettable_event(t,i,val).\n(See §2.8 for a complete description of the\nsettable_event function.\nThis function is not defined or callable in Lua.\nWe use it here only for explanatory purposes.)\n\n\n

\nAn assignment to a global variable x = val\nis equivalent to the assignment\n_env.x = val,\nwhich in turn is equivalent to\n\n

\n     settable_event(_env, \"x\", val)\n

\nwhere _env is the environment of the running function.\n(The _env variable is not defined in Lua.\nWe use it here only for explanatory purposes.)\n\n\n\n\n\n

2.4.4 - Control Structures

\nThe control structures\nif, while, and repeat have the usual meaning and\nfamiliar syntax:\n\n\n\n\n

\n\tstat ::= while exp do block end\n\tstat ::= repeat block until exp\n\tstat ::= if exp then block {elseif exp then block} [else block] end\n

\nLua also has a for statement, in two flavors (see §2.4.5).\n\n\n

\nThe condition expression of a\ncontrol structure can return any value.\nBoth false and nil are considered false.\nAll values different from nil and false are considered true\n(in particular, the number 0 and the empty string are also true).\n\n\n

\nIn the repeat–until loop,\nthe inner block does not end at the until keyword,\nbut only after the condition.\nSo, the condition can refer to local variables\ndeclared inside the loop block.\n\n\n

\nThe return statement is used to return values\nfrom a function or a chunk (which is just a function).\n\nFunctions and chunks can return more than one value,\nand so the syntax for the return statement is\n\n

\n\tstat ::= return [explist]\n
\n\n

\nThe break statement is used to terminate the execution of a\nwhile, repeat, or for loop,\nskipping to the next statement after the loop:\n\n\n

\n\tstat ::= break\n

\nA break ends the innermost enclosing loop.\n\n\n

\nThe return and break\nstatements can only be written as the last statement of a block.\nIf it is really necessary to return or break in the\nmiddle of a block,\nthen an explicit inner block can be used,\nas in the idioms\ndo return end and do break end,\nbecause now return and break are the last statements in\ntheir (inner) blocks.\n\n\n\n\n\n

2.4.5 - For Statement

\n\n

\n\nThe for statement has two forms:\none numeric and one generic.\n\n\n

\nThe numeric for loop repeats a block of code while a\ncontrol variable runs through an arithmetic progression.\nIt has the following syntax:\n\n

\n\tstat ::= for Name `=´ exp `,´ exp [`,´ exp] do block end\n

\nThe block is repeated for name starting at the value of\nthe first exp, until it passes the second exp by steps of the\nthird exp.\nMore precisely, a for statement like\n\n

\n     for v = e1, e2, e3 do block end\n

\nis equivalent to the code:\n\n

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

\nNote the following:\n\n

    \n\n
  • \nAll three control expressions are evaluated only once,\nbefore the loop starts.\nThey must all result in numbers.\n
    • \n\n
  • \nvar, limit, and step are invisible variables.\nThe names shown here are for explanatory purposes only.\n
    • \n\n
  • \nIf the third expression (the step) is absent,\nthen a step of 1 is used.\n
    • \n\n
  • \nYou can use break to exit a for loop.\n
    • \n\n
  • \nThe loop variable v is local to the loop;\nyou cannot use its value after the for ends or is broken.\nIf you need this value,\nassign it to another variable before breaking or exiting the loop.\n
    • \n\n
\n\n

\nThe generic for statement works over functions,\ncalled iterators.\nOn each iteration, the iterator function is called to produce a new value,\nstopping when this new value is nil.\nThe generic for loop has the following syntax:\n\n

\n\tstat ::= for namelist in explist do block end\n\tnamelist ::= Name {`,´ Name}\n

\nA for statement like\n\n

\n     for var_1, ···, var_n in explist do block end\n

\nis equivalent to the code:\n\n

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

\nNote the following:\n\n

    \n\n
  • \nexplist is evaluated only once.\nIts results are an iterator function,\na state,\nand an initial value for the first iterator variable.\n
    • \n\n
  • \nf, s, and var are invisible variables.\nThe names are here for explanatory purposes only.\n
    • \n\n
  • \nYou can use break to exit a for loop.\n
    • \n\n
  • \nThe loop variables var_i are local to the loop;\nyou cannot use their values after the for ends.\nIf you need these values,\nthen assign them to other variables before breaking or exiting the loop.\n
    • \n\n
\n\n\n\n\n

2.4.6 - Function Calls as Statements

\nTo allow possible side-effects,\nfunction calls can be executed as statements:\n\n

\n\tstat ::= functioncall\n

\nIn this case, all returned values are thrown away.\nFunction calls are explained in §2.5.8.\n\n\n\n\n\n

2.4.7 - Local Declarations

\nLocal variables can be declared anywhere inside a block.\nThe declaration can include an initial assignment:\n\n

\n\tstat ::= local namelist [`=´ explist]\n

\nIf present, an initial assignment has the same semantics\nof a multiple assignment (see §2.4.3).\nOtherwise, all variables are initialized with nil.\n\n\n

\nA chunk is also a block (see §2.4.1),\nand so local variables can be declared in a chunk outside any explicit block.\nThe scope of such local variables extends until the end of the chunk.\n\n\n

\nThe visibility rules for local variables are explained in §2.6.\n\n\n\n\n\n\n\n

2.5 - Expressions

\n\n

\nThe basic expressions in Lua are the following:\n\n

\n\texp ::= prefixexp\n\texp ::= nil | false | true\n\texp ::= Number\n\texp ::= String\n\texp ::= function\n\texp ::= tableconstructor\n\texp ::= `...´\n\texp ::= exp binop exp\n\texp ::= unop exp\n\tprefixexp ::= var | functioncall | `(´ exp `)´\n
\n\n

\nNumbers and literal strings are explained in §2.1;\nvariables are explained in §2.3;\nfunction definitions are explained in §2.5.9;\nfunction calls are explained in §2.5.8;\ntable constructors are explained in §2.5.7.\nVararg expressions,\ndenoted by three dots ('...'), can only be used when\ndirectly inside a vararg function;\nthey are explained in §2.5.9.\n\n\n

\nBinary operators comprise arithmetic operators (see §2.5.1),\nrelational operators (see §2.5.2), logical operators (see §2.5.3),\nand the concatenation operator (see §2.5.4).\nUnary operators comprise the unary minus (see §2.5.1),\nthe unary not (see §2.5.3),\nand the unary length operator (see §2.5.5).\n\n\n

\nBoth function calls and vararg expressions can result in multiple values.\nIf an expression is used as a statement\n(only possible for function calls (see §2.4.6)),\nthen its return list is adjusted to zero elements,\nthus discarding all returned values.\nIf an expression is used as the last (or the only) element\nof a list of expressions,\nthen no adjustment is made\n(unless the call is enclosed in parentheses).\nIn all other contexts,\nLua adjusts the result list to one element,\ndiscarding all values except the first one.\n\n\n

\nHere are some examples:\n\n

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

\nAny expression enclosed in parentheses always results in only one value.\nThus,\n(f(x,y,z)) is always a single value,\neven if f returns several values.\n(The value of (f(x,y,z)) is the first value returned by f\nor nil if f does not return any values.)\n\n\n\n

2.5.1 - Arithmetic Operators

\nLua supports the usual arithmetic operators:\nthe binary + (addition),\n- (subtraction), * (multiplication),\n/ (division), % (modulo), and ^ (exponentiation);\nand unary - (negation).\nIf the operands are numbers, or strings that can be converted to\nnumbers (see §2.2.1),\nthen all operations have the usual meaning.\nExponentiation works for any exponent.\nFor instance, x^(-0.5) computes the inverse of the square root of x.\nModulo is defined as\n\n

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

\nThat is, it is the remainder of a division that rounds\nthe quotient towards minus infinity.\n\n\n\n\n\n

2.5.2 - Relational Operators

\nThe relational operators in Lua are\n\n

\n     ==    ~=    <     >     <=    >=\n

\nThese operators always result in false or true.\n\n\n

\nEquality (==) first compares the type of its operands.\nIf the types are different, then the result is false.\nOtherwise, the values of the operands are compared.\nNumbers and strings are compared in the usual way.\nObjects (tables, userdata, threads, and functions)\nare compared by reference:\ntwo objects are considered equal only if they are the same object.\nEvery time you create a new object\n(a table, userdata, thread, or function),\nthis new object is different from any previously existing object.\n\n\n

\nYou can change the way that Lua compares tables and userdata \nby using the \"eq\" metamethod (see §2.8).\n\n\n

\nThe conversion rules of §2.2.1\ndo not apply to equality comparisons.\nThus, \"0\"==0 evaluates to false,\nand t[0] and t[\"0\"] denote different\nentries in a table.\n\n\n

\nThe operator ~= is exactly the negation of equality (==).\n\n\n

\nThe order operators work as follows.\nIf both arguments are numbers, then they are compared as such.\nOtherwise, if both arguments are strings,\nthen their values are compared according to the current locale.\nOtherwise, Lua tries to call the \"lt\" or the \"le\"\nmetamethod (see §2.8).\nA comparison a > b is translated to b < a\nand a >= b is translated to b <= a.\n\n\n\n\n\n

2.5.3 - Logical Operators

\nThe logical operators in Lua are\nand, or, and not.\nLike the control structures (see §2.4.4),\nall logical operators consider both false and nil as false\nand anything else as true.\n\n\n

\nThe negation operator not always returns false or true.\nThe conjunction operator and returns its first argument\nif this value is false or nil;\notherwise, and returns its second argument.\nThe disjunction operator or returns its first argument\nif this value is different from nil and false;\notherwise, or returns its second argument.\nBoth and and or use short-cut evaluation;\nthat is,\nthe second operand is evaluated only if necessary.\nHere are some examples:\n\n

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

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

2.5.4 - Concatenation

\nThe string concatenation operator in Lua is\ndenoted by two dots ('..').\nIf both operands are strings or numbers, then they are converted to\nstrings according to the rules mentioned in §2.2.1.\nOtherwise, the \"concat\" metamethod is called (see §2.8).\n\n\n\n\n\n

2.5.5 - The Length Operator

\n\n

\nThe length operator is denoted by the unary operator #.\nThe length of a string is its number of bytes\n(that is, the usual meaning of string length when each\ncharacter is one byte).\n\n\n

\nThe length of a table t is defined to be any\ninteger index n\nsuch that t[n] is not nil and t[n+1] is nil;\nmoreover, if t[1] is nil, n can be zero.\nFor a regular array, with non-nil values from 1 to a given n,\nits length is exactly that n,\nthe index of its last value.\nIf the array has \"holes\"\n(that is, nil values between other non-nil values),\nthen #t can be any of the indices that\ndirectly precedes a nil value\n(that is, it may consider any such nil value as the end of\nthe array). \n\n\n\n\n\n

2.5.6 - Precedence

\nOperator precedence in Lua follows the table below,\nfrom lower to higher priority:\n\n

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

\nAs usual,\nyou can use parentheses to change the precedences of an expression.\nThe concatenation ('..') and exponentiation ('^')\noperators are right associative.\nAll other binary operators are left associative.\n\n\n\n\n\n

2.5.7 - Table Constructors

\nTable constructors are expressions that create tables.\nEvery time a constructor is evaluated, a new table is created.\nA constructor can be used to create an empty table\nor to create a table and initialize some of its fields.\nThe general syntax for constructors is\n\n

\n\ttableconstructor ::= `{´ [fieldlist] `}´\n\tfieldlist ::= field {fieldsep field} [fieldsep]\n\tfield ::= `[´ exp `]´ `=´ exp | Name `=´ exp | exp\n\tfieldsep ::= `,´ | `;´\n
\n\n

\nEach field of the form [exp1] = exp2 adds to the new table an entry\nwith key exp1 and value exp2.\nA field of the form name = exp is equivalent to\n[\"name\"] = exp.\nFinally, fields of the form exp are equivalent to\n[i] = exp, where i are consecutive numerical integers,\nstarting with 1.\nFields in the other formats do not affect this counting.\nFor example,\n\n

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

\nis equivalent to\n\n

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

\nIf the last field in the list has the form exp\nand the expression is a function call or a vararg expression,\nthen all values returned by this expression enter the list consecutively\n(see §2.5.8).\nTo avoid this,\nenclose the function call or the vararg expression\nin parentheses (see §2.5).\n\n\n

\nThe field list can have an optional trailing separator,\nas a convenience for machine-generated code.\n\n\n\n\n\n

2.5.8 - Function Calls

\nA function call in Lua has the following syntax:\n\n

\n\tfunctioncall ::= prefixexp args\n

\nIn a function call,\nfirst prefixexp and args are evaluated.\nIf the value of prefixexp has type function,\nthen this function is called\nwith the given arguments.\nOtherwise, the prefixexp \"call\" metamethod is called,\nhaving as first parameter the value of prefixexp,\nfollowed by the original call arguments\n(see §2.8).\n\n\n

\nThe form\n\n

\n\tfunctioncall ::= prefixexp `:´ Name args\n

\ncan be used to call \"methods\".\nA call v:name(args)\nis syntactic sugar for v.name(v,args),\nexcept that v is evaluated only once.\n\n\n

\nArguments have the following syntax:\n\n

\n\targs ::= `(´ [explist] `)´\n\targs ::= tableconstructor\n\targs ::= String\n

\nAll argument expressions are evaluated before the call.\nA call of the form f{fields} is\nsyntactic sugar for f({fields});\nthat is, the argument list is a single new table.\nA call of the form f'string'\n(or f\"string\" or f[[string]])\nis syntactic sugar for f('string');\nthat is, the argument list is a single literal string.\n\n\n

\nAs an exception to the free-format syntax of Lua,\nyou cannot put a line break before the '(' in a function call.\nThis restriction avoids some ambiguities in the language.\nIf you write\n\n

\n     a = f\n     (g).x(a)\n

\nLua would see that as a single statement, a = f(g).x(a).\nSo, if you want two statements, you must add a semi-colon between them.\nIf you actually want to call f,\nyou must remove the line break before (g).\n\n\n

\nA call of the form return functioncall is called\na tail call.\nLua implements proper tail calls\n(or proper tail recursion):\nin a tail call,\nthe called function reuses the stack entry of the calling function.\nTherefore, there is no limit on the number of nested tail calls that\na program can execute.\nHowever, a tail call erases any debug information about the\ncalling function.\nNote that a tail call only happens with a particular syntax,\nwhere the return has one single function call as argument;\nthis syntax makes the calling function return exactly\nthe returns of the called function.\nSo, none of the following examples are tail calls:\n\n

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

2.5.9 - Function Definitions

\n\n

\nThe syntax for function definition is\n\n

\n\tfunction ::= function funcbody\n\tfuncbody ::= `(´ [parlist] `)´ block end\n
\n\n

\nThe following syntactic sugar simplifies function definitions:\n\n

\n\tstat ::= function funcname funcbody\n\tstat ::= local function Name funcbody\n\tfuncname ::= Name {`.´ Name} [`:´ Name]\n

\nThe statement\n\n

\n     function f () body end\n

\ntranslates to\n\n

\n     f = function () body end\n

\nThe statement\n\n

\n     function t.a.b.c.f () body end\n

\ntranslates to\n\n

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

\nThe statement\n\n

\n     local function f () body end\n

\ntranslates to\n\n

\n     local f; f = function () body end\n

\nnot to\n\n

\n     local f = function () body end\n

\n(This only makes a difference when the body of the function\ncontains references to f.)\n\n\n

\nA function definition is an executable expression,\nwhose value has type function.\nWhen Lua pre-compiles a chunk,\nall its function bodies are pre-compiled too.\nThen, whenever Lua executes the function definition,\nthe function is instantiated (or closed).\nThis function instance (or closure)\nis the final value of the expression.\nDifferent instances of the same function\ncan refer to different external local variables\nand can have different environment tables.\n\n\n

\nParameters act as local variables that are\ninitialized with the argument values:\n\n

\n\tparlist ::= namelist [`,´ `...´] | `...´\n

\nWhen a function is called,\nthe list of arguments is adjusted to\nthe length of the list of parameters,\nunless the function is a variadic or vararg function,\nwhich is\nindicated by three dots ('...') at the end of its parameter list.\nA vararg function does not adjust its argument list;\ninstead, it collects all extra arguments and supplies them\nto the function through a vararg expression,\nwhich is also written as three dots.\nThe value of this expression is a list of all actual extra arguments,\nsimilar to a function with multiple results.\nIf a vararg expression is used inside another expression\nor in the middle of a list of expressions,\nthen its return list is adjusted to one element.\nIf the expression is used as the last element of a list of expressions,\nthen no adjustment is made\n(unless that last expression is enclosed in parentheses).\n\n\n

\nAs an example, consider the following definitions:\n\n

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

\nThen, we have the following mapping from arguments to parameters and\nto the vararg expression:\n\n

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

\nResults are returned using the return statement (see §2.4.4).\nIf control reaches the end of a function\nwithout encountering a return statement,\nthen the function returns with no results.\n\n\n

\nThe colon syntax\nis used for defining methods,\nthat is, functions that have an implicit extra parameter self.\nThus, the statement\n\n

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

\nis syntactic sugar for\n\n

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

2.6 - Visibility Rules

\n\n

\n\nLua is a lexically scoped language.\nThe scope of variables begins at the first statement after\ntheir declaration and lasts until the end of the innermost block that\nincludes the declaration.\nConsider the following example:\n\n

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

\nNotice that, in a declaration like local x = x,\nthe new x being declared is not in scope yet,\nand so the second x refers to the outside variable.\n\n\n

\nBecause of the lexical scoping rules,\nlocal variables can be freely accessed by functions\ndefined inside their scope.\nA local variable used by an inner function is called\nan upvalue, or external local variable,\ninside the inner function.\n\n\n

\nNotice that each execution of a local statement\ndefines new local variables.\nConsider the following example:\n\n

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

\nThe loop creates ten closures\n(that is, ten instances of the anonymous function).\nEach of these closures uses a different y variable,\nwhile all of them share the same x.\n\n\n\n\n\n

2.7 - Error Handling

\n\n

\nBecause Lua is an embedded extension language,\nall Lua actions start from C code in the host program\ncalling a function from the Lua library (see lua_pcall).\nWhenever an error occurs during Lua compilation or execution,\ncontrol returns to C,\nwhich can take appropriate measures\n(such as printing an error message).\n\n\n

\nLua code can explicitly generate an error by calling the\nerror function.\nIf you need to catch errors in Lua,\nyou can use the pcall function.\n\n\n\n\n\n

2.8 - Metatables

\n\n

\nEvery value in Lua can have a metatable.\nThis metatable is an ordinary Lua table\nthat defines the behavior of the original value\nunder certain special operations.\nYou can change several aspects of the behavior\nof operations over a value by setting specific fields in its metatable.\nFor instance, when a non-numeric value is the operand of an addition,\nLua checks for a function in the field \"__add\" in its metatable.\nIf it finds one,\nLua calls this function to perform the addition.\n\n\n

\nWe call the keys in a metatable events\nand the values metamethods.\nIn the previous example, the event is \"add\" \nand the metamethod is the function that performs the addition.\n\n\n

\nYou can query the metatable of any value\nthrough the getmetatable function.\n\n\n

\nYou can replace the metatable of tables\nthrough the setmetatable\nfunction.\nYou cannot change the metatable of other types from Lua\n(except by using the debug library);\nyou must use the C API for that.\n\n\n

\nTables and full userdata have individual metatables\n(although multiple tables and userdata can share their metatables).\nValues of all other types share one single metatable per type;\nthat is, there is one single metatable for all numbers,\none for all strings, etc.\n\n\n

\nA metatable controls how an object behaves in arithmetic operations,\norder comparisons, concatenation, length operation, and indexing.\nA metatable also can define a function to be called when a userdata\nis garbage collected.\nFor each of these operations Lua associates a specific key\ncalled an event.\nWhen Lua performs one of these operations over a value,\nit checks whether this value has a metatable with the corresponding event.\nIf so, the value associated with that key (the metamethod)\ncontrols how Lua will perform the operation.\n\n\n

\nMetatables control the operations listed next.\nEach operation is identified by its corresponding name.\nThe key for each operation is a string with its name prefixed by\ntwo underscores, '__';\nfor instance, the key for operation \"add\" is the\nstring \"__add\".\nThe semantics of these operations is better explained by a Lua function\ndescribing how the interpreter executes the operation.\n\n\n

\nThe code shown here in Lua is only illustrative;\nthe real behavior is hard coded in the interpreter\nand it is much more efficient than this simulation.\nAll functions used in these descriptions\n(rawget, tonumber, etc.)\nare described in §5.1.\nIn particular, to retrieve the metamethod of a given object,\nwe use the expression\n\n

\n     metatable(obj)[event]\n

\nThis should be read as\n\n

\n     rawget(getmetatable(obj) or {}, event)\n

\n\nThat is, the access to a metamethod does not invoke other metamethods,\nand the access to objects with no metatables does not fail\n(it simply results in nil).\n\n\n\n

    \n\n
  • \"add\":\nthe + operation.\n\n\n\n

    \nThe function getbinhandler below defines how Lua chooses a handler\nfor a binary operation.\nFirst, Lua tries the first operand.\nIf its type does not define a handler for the operation,\nthen Lua tries the second operand.\n\n

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

    \nBy using this function,\nthe behavior of the op1 + op2 is\n\n

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

    \n

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

    \n

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

    \n

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

    \nSee §2.5.5 for a description of the length of a table.\n

    • \n\n
  • \"eq\":\nthe == operation.\n\nThe function getcomphandler defines how Lua chooses a metamethod\nfor comparison operators.\nA metamethod only is selected when both objects\nbeing compared have the same type\nand the same metamethod for the selected operation.\n\n
    \n     function getcomphandler (op1, op2, event)\n       if type(op1) ~= type(op2) then return nil end\n       local mm1 = metatable(op1)[event]\n       local mm2 = metatable(op2)[event]\n       if mm1 == mm2 then return mm1 else return nil end\n     end\n

    \nThe \"eq\" event is defined as follows:\n\n

    \n     function eq_event (op1, op2)\n       if type(op1) ~= type(op2) then  -- different types?\n         return false   -- different objects\n       end\n       if op1 == op2 then   -- primitive equal?\n         return true   -- objects are equal\n       end\n       -- try metamethod\n       local h = getcomphandler(op1, op2, \"__eq\")\n       if h then\n         return (h(op1, op2))\n       else\n         return false\n       end\n     end\n

    \na ~= b is equivalent to not (a == b).\n

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

    \na > b is equivalent to b < a.\n

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

    \na >= b is equivalent to b <= a.\nNote that, in the absence of a \"le\" metamethod,\nLua tries the \"lt\", assuming that a <= b is\nequivalent to not (b < a).\n

    • \n\n
  • \"index\":\nThe indexing access table[key].\n\n\n
    \n     function gettable_event (table, key)\n       local h\n       if type(table) == \"table\" then\n         local v = rawget(table, key)\n         if v ~= nil then return v end\n         h = metatable(table).__index\n         if h == nil then return nil end\n       else\n         h = metatable(table).__index\n         if h == nil then\n           error(···)\n         end\n       end\n       if type(h) == \"function\" then\n         return (h(table, key))     -- call the handler\n       else return h[key]           -- or repeat operation on it\n       end\n     end\n

    \n

    • \n\n
  • \"newindex\":\nThe indexing assignment table[key] = value.\n\n\n
    \n     function settable_event (table, key, value)\n       local h\n       if type(table) == \"table\" then\n         local v = rawget(table, key)\n         if v ~= nil then rawset(table, key, value); return end\n         h = metatable(table).__newindex\n         if h == nil then rawset(table, key, value); return end\n       else\n         h = metatable(table).__newindex\n         if h == nil then\n           error(···)\n         end\n       end\n       if type(h) == \"function\" then\n         h(table, key,value)           -- call the handler\n       else h[key] = value             -- or repeat operation on it\n       end\n     end\n

    \n

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

    \n

    • \n\n
\n\n\n\n\n

2.9 - Environments

\n\n

\nBesides metatables,\nobjects of types thread, function, and userdata\nhave another table associated with them,\ncalled their environment.\nLike metatables, environments are regular tables and\nmultiple objects can share the same environment.\n\n\n

\nThreads are created sharing the environment of the creating thread.\nUserdata and C functions are created sharing the environment\nof the creating C function.\nNon-nested Lua functions\n(created by loadfile, loadstring or load)\nare created sharing the environment of the creating thread.\nNested Lua functions are created sharing the environment of\nthe creating Lua function.\n\n\n

\nEnvironments associated with userdata have no meaning for Lua.\nIt is only a convenience feature for programmers to associate a table to\na userdata.\n\n\n

\nEnvironments associated with threads are called\nglobal environments.\nThey are used as the default environment for threads and\nnon-nested Lua functions created by the thread\nand can be directly accessed by C code (see §3.3).\n\n\n

\nThe environment associated with a C function can be directly\naccessed by C code (see §3.3).\nIt is used as the default environment for other C functions\nand userdata created by the function.\n\n\n

\nEnvironments associated with Lua functions are used to resolve\nall accesses to global variables within the function (see §2.3).\nThey are used as the default environment for nested Lua functions\ncreated by the function.\n\n\n

\nYou can change the environment of a Lua function or the\nrunning thread by calling setfenv.\nYou can get the environment of a Lua function or the running thread\nby calling getfenv.\nTo manipulate the environment of other objects\n(userdata, C functions, other threads) you must\nuse the C API.\n\n\n\n\n\n

2.10 - Garbage Collection

\n\n

\nLua performs automatic memory management.\nThis means that\nyou have to worry neither about allocating memory for new objects\nnor about freeing it when the objects are no longer needed.\nLua manages memory automatically by running\na garbage collector from time to time\nto collect all dead objects\n(that is, objects that are no longer accessible from Lua).\nAll memory used by Lua is subject to automatic management:\ntables, userdata, functions, threads, strings, etc.\n\n\n

\nLua implements an incremental mark-and-sweep collector.\nIt uses two numbers to control its garbage-collection cycles:\nthe garbage-collector pause and\nthe garbage-collector step multiplier.\nBoth use percentage points as units\n(so that a value of 100 means an internal value of 1).\n\n\n

\nThe garbage-collector pause\ncontrols how long the collector waits before starting a new cycle.\nLarger values make the collector less aggressive.\nValues smaller than 100 mean the collector will not wait to\nstart a new cycle.\nA value of 200 means that the collector waits for the total memory in use\nto double before starting a new cycle.\n\n\n

\nThe step multiplier\ncontrols the relative speed of the collector relative to\nmemory allocation.\nLarger values make the collector more aggressive but also increase\nthe size of each incremental step.\nValues smaller than 100 make the collector too slow and\ncan result in the collector never finishing a cycle.\nThe default, 200, means that the collector runs at \"twice\"\nthe speed of memory allocation.\n\n\n

\nYou can change these numbers by calling lua_gc in C\nor collectgarbage in Lua.\nWith these functions you can also control \nthe collector directly (e.g., stop and restart it).\n\n\n\n

2.10.1 - Garbage-Collection Metamethods

\n\n

\nUsing the C API,\nyou can set garbage-collector metamethods for userdata (see §2.8).\nThese metamethods are also called finalizers.\nFinalizers allow you to coordinate Lua's garbage collection\nwith external resource management\n(such as closing files, network or database connections,\nor freeing your own memory).\n\n\n

\nGarbage userdata with a field __gc in their metatables are not\ncollected immediately by the garbage collector.\nInstead, Lua puts them in a list.\nAfter the collection,\nLua does the equivalent of the following function\nfor each userdata in that list:\n\n

\n     function gc_event (udata)\n       local h = metatable(udata).__gc\n       if h then\n         h(udata)\n       end\n     end\n
\n\n

\nAt the end of each garbage-collection cycle,\nthe finalizers for userdata are called in reverse\norder of their creation,\namong those collected in that cycle.\nThat is, the first finalizer to be called is the one associated\nwith the userdata created last in the program.\nThe userdata itself is freed only in the next garbage-collection cycle.\n\n\n\n\n\n

2.10.2 - Weak Tables

\n\n

\nA weak table is a table whose elements are\nweak references.\nA weak reference is ignored by the garbage collector.\nIn other words,\nif the only references to an object are weak references,\nthen the garbage collector will collect this object.\n\n\n

\nA weak table can have weak keys, weak values, or both.\nA table with weak keys allows the collection of its keys,\nbut prevents the collection of its values.\nA table with both weak keys and weak values allows the collection of\nboth keys and values.\nIn any case, if either the key or the value is collected,\nthe whole pair is removed from the table.\nThe weakness of a table is controlled by the\n__mode field of its metatable.\nIf the __mode field is a string containing the character 'k',\nthe keys in the table are weak.\nIf __mode contains 'v',\nthe values in the table are weak.\n\n\n

\nAfter you use a table as a metatable,\nyou should not change the value of its __mode field.\nOtherwise, the weak behavior of the tables controlled by this\nmetatable is undefined.\n\n\n\n\n\n\n\n

2.11 - Coroutines

\n\n

\nLua supports coroutines,\nalso called collaborative multithreading.\nA coroutine in Lua represents an independent thread of execution.\nUnlike threads in multithread systems, however,\na coroutine only suspends its execution by explicitly calling\na yield function.\n\n\n

\nYou create a coroutine with a call to coroutine.create.\nIts sole argument is a function\nthat is the main function of the coroutine.\nThe create function only creates a new coroutine and\nreturns a handle to it (an object of type thread);\nit does not start the coroutine execution.\n\n\n

\nWhen you first call coroutine.resume,\npassing as its first argument\na thread returned by coroutine.create,\nthe coroutine starts its execution,\nat the first line of its main function.\nExtra arguments passed to coroutine.resume are passed on\nto the coroutine main function.\nAfter the coroutine starts running,\nit runs until it terminates or yields.\n\n\n

\nA coroutine can terminate its execution in two ways:\nnormally, when its main function returns\n(explicitly or implicitly, after the last instruction);\nand abnormally, if there is an unprotected error.\nIn the first case, coroutine.resume returns true,\nplus any values returned by the coroutine main function.\nIn case of errors, coroutine.resume returns false\nplus an error message.\n\n\n

\nA coroutine yields by calling coroutine.yield.\nWhen a coroutine yields,\nthe corresponding coroutine.resume returns immediately,\neven if the yield happens inside nested function calls\n(that is, not in the main function,\nbut in a function directly or indirectly called by the main function).\nIn the case of a yield, coroutine.resume also returns true,\nplus any values passed to coroutine.yield.\nThe next time you resume the same coroutine,\nit continues its execution from the point where it yielded,\nwith the call to coroutine.yield returning any extra\narguments passed to coroutine.resume.\n\n\n

\nLike coroutine.create,\nthe coroutine.wrap function also creates a coroutine,\nbut instead of returning the coroutine itself,\nit returns a function that, when called, resumes the coroutine.\nAny arguments passed to this function\ngo as extra arguments to coroutine.resume.\ncoroutine.wrap returns all the values returned by coroutine.resume,\nexcept the first one (the boolean error code).\nUnlike coroutine.resume,\ncoroutine.wrap does not catch errors;\nany error is propagated to the caller.\n\n\n

\nAs an example,\nconsider the following code:\n\n

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

\nWhen you run it, it produces the following output:\n\n

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

3 - The Application Program Interface

\n\n

\n\nThis section describes the C API for Lua, that is,\nthe set of C functions available to the host program to communicate\nwith Lua.\nAll API functions and related types and constants\nare declared in the header file lua.h.\n\n\n

\nEven when we use the term \"function\",\nany facility in the API may be provided as a macro instead.\nAll such macros use each of their arguments exactly once\n(except for the first argument, which is always a Lua state),\nand so do not generate any hidden side-effects.\n\n\n

\nAs in most C libraries,\nthe Lua API functions do not check their arguments for validity or consistency.\nHowever, you can change this behavior by compiling Lua\nwith a proper definition for the macro luai_apicheck,\nin file luaconf.h.\n\n\n\n

3.1 - The Stack

\n\n

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

\nWhenever Lua calls C, the called function gets a new stack,\nwhich is independent of previous stacks and of stacks of\nC functions that are still active.\nThis stack initially contains any arguments to the C function\nand it is where the C function pushes its results\nto be returned to the caller (see lua_CFunction).\n\n\n

\nFor convenience,\nmost query operations in the API do not follow a strict stack discipline.\nInstead, they can refer to any element in the stack\nby using an index:\nA positive index represents an absolute stack position\n(starting at 1);\na negative index represents an offset relative to the top of the stack.\nMore specifically, if the stack has n elements,\nthen index 1 represents the first element\n(that is, the element that was pushed onto the stack first)\nand\nindex n represents the last element;\nindex -1 also represents the last element\n(that is, the element at the top)\nand index -n represents the first element.\nWe say that an index is valid\nif it lies between 1 and the stack top\n(that is, if 1 ≤ abs(index) ≤ top).\n \n\n\n\n\n\n

3.2 - Stack Size

\n\n

\nWhen you interact with Lua API,\nyou are responsible for ensuring consistency.\nIn particular,\nyou are responsible for controlling stack overflow.\nYou can use the function lua_checkstack\nto grow the stack size.\n\n\n

\nWhenever Lua calls C,\nit ensures that at least LUA_MINSTACK stack positions are available.\nLUA_MINSTACK is defined as 20,\nso that usually you do not have to worry about stack space\nunless your code has loops pushing elements onto the stack.\n\n\n

\nMost query functions accept as indices any value inside the\navailable stack space, that is, indices up to the maximum stack size\nyou have set through lua_checkstack.\nSuch indices are called acceptable indices.\nMore formally, we define an acceptable index\nas follows:\n\n

\n     (index < 0 && abs(index) <= top) ||\n     (index > 0 && index <= stackspace)\n

\nNote that 0 is never an acceptable index.\n\n\n\n\n\n

3.3 - Pseudo-Indices

\n\n

\nUnless otherwise noted,\nany function that accepts valid indices can also be called with\npseudo-indices,\nwhich represent some Lua values that are accessible to C code\nbut which are not in the stack.\nPseudo-indices are used to access the thread environment,\nthe function environment,\nthe registry,\nand the upvalues of a C function (see §3.4).\n\n\n

\nThe thread environment (where global variables live) is\nalways at pseudo-index LUA_GLOBALSINDEX.\nThe environment of the running C function is always\nat pseudo-index LUA_ENVIRONINDEX.\n\n\n

\nTo access and change the value of global variables,\nyou can use regular table operations over an environment table.\nFor instance, to access the value of a global variable, do\n\n

\n     lua_getfield(L, LUA_GLOBALSINDEX, varname);\n
\n\n\n\n\n

3.4 - C Closures

\n\n

\nWhen a C function is created,\nit is possible to associate some values with it,\nthus creating a C closure;\nthese values are called upvalues and are\naccessible to the function whenever it is called\n(see lua_pushcclosure).\n\n\n

\nWhenever a C function is called,\nits upvalues are located at specific pseudo-indices.\nThese pseudo-indices are produced by the macro\nlua_upvalueindex.\nThe first value associated with a function is at position\nlua_upvalueindex(1), and so on.\nAny access to lua_upvalueindex(n),\nwhere n is greater than the number of upvalues of the\ncurrent function (but not greater than 256),\nproduces an acceptable (but invalid) index.\n\n\n\n\n\n

3.5 - Registry

\n\n

\nLua provides a registry,\na pre-defined table that can be used by any C code to\nstore whatever Lua value it needs to store.\nThis table is always located at pseudo-index\nLUA_REGISTRYINDEX.\nAny C library can store data into this table,\nbut it should take care to choose keys different from those used\nby other libraries, to avoid collisions.\nTypically, you should use as key a string containing your library name\nor a light userdata with the address of a C object in your code.\n\n\n

\nThe integer keys in the registry are used by the reference mechanism,\nimplemented by the auxiliary library,\nand therefore should not be used for other purposes.\n\n\n\n\n\n

3.6 - Error Handling in C

\n\n

\nInternally, Lua uses the C longjmp facility to handle errors.\n(You can also choose to use exceptions if you use C++;\nsee file luaconf.h.)\nWhen Lua faces any error\n(such as memory allocation errors, type errors, syntax errors,\nand runtime errors)\nit raises an error;\nthat is, it does a long jump.\nA protected environment uses setjmp\nto set a recover point;\nany error jumps to the most recent active recover point.\n\n\n

\nMost functions in the API can throw an error,\nfor instance due to a memory allocation error.\nThe documentation for each function indicates whether\nit can throw errors.\n\n\n

\nInside a C function you can throw an error by calling lua_error.\n\n\n\n\n\n

3.7 - Functions and Types

\n\n

\nHere we list all functions and types from the C API in\nalphabetical order.\nEach function has an indicator like this:\n[-o, +p, x]\n\n\n

\nThe first field, o,\nis how many elements the function pops from the stack.\nThe second field, p,\nis how many elements the function pushes onto the stack.\n(Any function always pushes its results after popping its arguments.)\nA field in the form x|y means the function can push (or pop)\nx or y elements,\ndepending on the situation;\nan interrogation mark '?' means that\nwe cannot know how many elements the function pops/pushes\nby looking only at its arguments\n(e.g., they may depend on what is on the stack).\nThe third field, x,\ntells whether the function may throw errors:\n'-' means the function never throws any error;\n'm' means the function may throw an error\nonly due to not enough memory;\n'e' means the function may throw other kinds of errors;\n'v' means the function may throw an error on purpose.\n\n\n\n

lua_Alloc

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

\nThe type of the memory-allocation function used by Lua states.\nThe allocator function must provide a\nfunctionality similar to realloc,\nbut not exactly the same.\nIts arguments are\nud, an opaque pointer passed to lua_newstate;\nptr, a pointer to the block being allocated/reallocated/freed;\nosize, the original size of the block;\nnsize, the new size of the block.\nptr is NULL if and only if osize is zero.\nWhen nsize is zero, the allocator must return NULL;\nif osize is not zero,\nit should free the block pointed to by ptr.\nWhen nsize is not zero, the allocator returns NULL\nif and only if it cannot fill the request.\nWhen nsize is not zero and osize is zero,\nthe allocator should behave like malloc.\nWhen nsize and osize are not zero,\nthe allocator behaves like realloc.\nLua assumes that the allocator never fails when\nosize >= nsize.\n\n\n

\nHere is a simple implementation for the allocator function.\nIt is used in the auxiliary library by luaL_newstate.\n\n

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

\nThis code assumes\nthat free(NULL) has no effect and that\nrealloc(NULL, size) is equivalent to malloc(size).\nANSI C ensures both behaviors.\n\n\n\n\n\n

lua_atpanic

\n[-0, +0, -]\n

lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);
\n\n

\nSets a new panic function and returns the old one.\n\n\n

\nIf an error happens outside any protected environment,\nLua calls a panic function\nand then calls exit(EXIT_FAILURE),\nthus exiting the host application.\nYour panic function can avoid this exit by\nnever returning (e.g., doing a long jump).\n\n\n

\nThe panic function can access the error message at the top of the stack.\n\n\n\n\n\n

lua_call

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

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

\nCalls a function.\n\n\n

\nTo call a function you must use the following protocol:\nfirst, the function to be called is pushed onto the stack;\nthen, the arguments to the function are pushed\nin direct order;\nthat is, the first argument is pushed first.\nFinally you call lua_call;\nnargs is the number of arguments that you pushed onto the stack.\nAll arguments and the function value are popped from the stack\nwhen the function is called.\nThe function results are pushed onto the stack when the function returns.\nThe number of results is adjusted to nresults,\nunless nresults is LUA_MULTRET.\nIn this case, all results from the function are pushed.\nLua takes care that the returned values fit into the stack space.\nThe function results are pushed onto the stack in direct order\n(the first result is pushed first),\nso that after the call the last result is on the top of the stack.\n\n\n

\nAny error inside the called function is propagated upwards\n(with a longjmp).\n\n\n

\nThe following example shows how the host program can do the\nequivalent to this Lua code:\n\n

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

\nHere it is in C:\n\n

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

\nNote that the code above is \"balanced\":\nat its end, the stack is back to its original configuration.\nThis is considered good programming practice.\n\n\n\n\n\n

lua_CFunction

\n
typedef int (*lua_CFunction) (lua_State *L);
\n\n

\nType for C functions.\n\n\n

\nIn order to communicate properly with Lua,\na C function must use the following protocol,\nwhich defines the way parameters and results are passed:\na C function receives its arguments from Lua in its stack\nin direct order (the first argument is pushed first).\nSo, when the function starts,\nlua_gettop(L) returns the number of arguments received by the function.\nThe first argument (if any) is at index 1\nand its last argument is at index lua_gettop(L).\nTo return values to Lua, a C function just pushes them onto the stack,\nin direct order (the first result is pushed first),\nand returns the number of results.\nAny other value in the stack below the results will be properly\ndiscarded by Lua.\nLike a Lua function, a C function called by Lua can also return\nmany results.\n\n\n

\nAs an example, the following function receives a variable number\nof numerical arguments and returns their average and sum:\n\n

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

lua_checkstack

\n[-0, +0, m]\n

int lua_checkstack (lua_State *L, int extra);
\n\n

\nEnsures that there are at least extra free stack slots in the stack.\nIt returns false if it cannot grow the stack to that size.\nThis function never shrinks the stack;\nif the stack is already larger than the new size,\nit is left unchanged.\n\n\n\n\n\n

lua_close

\n[-0, +0, -]\n

void lua_close (lua_State *L);
\n\n

\nDestroys all objects in the given Lua state\n(calling the corresponding garbage-collection metamethods, if any)\nand frees all dynamic memory used by this state.\nOn several platforms, you may not need to call this function,\nbecause all resources are naturally released when the host program ends.\nOn the other hand, long-running programs,\nsuch as a daemon or a web server,\nmight need to release states as soon as they are not needed,\nto avoid growing too large.\n\n\n\n\n\n

lua_concat

\n[-n, +1, e]\n

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

\nConcatenates the n values at the top of the stack,\npops them, and leaves the result at the top.\nIf n is 1, the result is the single value on the stack\n(that is, the function does nothing);\nif n is 0, the result is the empty string.\nConcatenation is performed following the usual semantics of Lua\n(see §2.5.4).\n\n\n\n\n\n

lua_cpcall

\n[-0, +(0|1), -]\n

int lua_cpcall (lua_State *L, lua_CFunction func, void *ud);
\n\n

\nCalls the C function func in protected mode.\nfunc starts with only one element in its stack,\na light userdata containing ud.\nIn case of errors,\nlua_cpcall returns the same error codes as lua_pcall,\nplus the error object on the top of the stack;\notherwise, it returns zero, and does not change the stack.\nAll values returned by func are discarded.\n\n\n\n\n\n

lua_createtable

\n[-0, +1, m]\n

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

\nCreates a new empty table and pushes it onto the stack.\nThe new table has space pre-allocated\nfor narr array elements and nrec non-array elements.\nThis pre-allocation is useful when you know exactly how many elements\nthe table will have.\nOtherwise you can use the function lua_newtable.\n\n\n\n\n\n

lua_dump

\n[-0, +0, m]\n

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

\nDumps a function as a binary chunk.\nReceives a Lua function on the top of the stack\nand produces a binary chunk that,\nif loaded again,\nresults in a function equivalent to the one dumped.\nAs it produces parts of the chunk,\nlua_dump calls function writer (see lua_Writer)\nwith the given data\nto write them.\n\n\n

\nThe value returned is the error code returned by the last\ncall to the writer;\n0 means no errors.\n\n\n

\nThis function does not pop the Lua function from the stack.\n\n\n\n\n\n

lua_equal

\n[-0, +0, e]\n

int lua_equal (lua_State *L, int index1, int index2);
\n\n

\nReturns 1 if the two values in acceptable indices index1 and\nindex2 are equal,\nfollowing the semantics of the Lua == operator\n(that is, may call metamethods).\nOtherwise returns 0.\nAlso returns 0 if any of the indices is non valid.\n\n\n\n\n\n

lua_error

\n[-1, +0, v]\n

int lua_error (lua_State *L);
\n\n

\nGenerates a Lua error.\nThe error message (which can actually be a Lua value of any type)\nmust be on the stack top.\nThis function does a long jump,\nand therefore never returns.\n(see luaL_error).\n\n\n\n\n\n

lua_gc

\n[-0, +0, e]\n

int lua_gc (lua_State *L, int what, int data);
\n\n

\nControls the garbage collector.\n\n\n

\nThis function performs several tasks,\naccording to the value of the parameter what:\n\n

    \n\n
  • LUA_GCSTOP:\nstops the garbage collector.\n
    • \n\n
  • LUA_GCRESTART:\nrestarts the garbage collector.\n
    • \n\n
  • LUA_GCCOLLECT:\nperforms a full garbage-collection cycle.\n
    • \n\n
  • LUA_GCCOUNT:\nreturns the current amount of memory (in Kbytes) in use by Lua.\n
    • \n\n
  • LUA_GCCOUNTB:\nreturns the remainder of dividing the current amount of bytes of\nmemory in use by Lua by 1024.\n
    • \n\n
  • LUA_GCSTEP:\nperforms an incremental step of garbage collection.\nThe step \"size\" is controlled by data\n(larger values mean more steps) in a non-specified way.\nIf you want to control the step size\nyou must experimentally tune the value of data.\nThe function returns 1 if the step finished a\ngarbage-collection cycle.\n
    • \n\n
  • LUA_GCSETPAUSE:\nsets data as the new value\nfor the pause of the collector (see §2.10).\nThe function returns the previous value of the pause.\n
    • \n\n
  • LUA_GCSETSTEPMUL:\nsets data as the new value for the step multiplier of\nthe collector (see §2.10).\nThe function returns the previous value of the step multiplier.\n
    • \n\n
\n\n\n\n\n

lua_getallocf

\n[-0, +0, -]\n

lua_Alloc lua_getallocf (lua_State *L, void **ud);
\n\n

\nReturns the memory-allocation function of a given state.\nIf ud is not NULL, Lua stores in *ud the\nopaque pointer passed to lua_newstate.\n\n\n\n\n\n

lua_getfenv

\n[-0, +1, -]\n

void lua_getfenv (lua_State *L, int index);
\n\n

\nPushes onto the stack the environment table of\nthe value at the given index.\n\n\n\n\n\n

lua_getfield

\n[-0, +1, e]\n

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

\nPushes onto the stack the value t[k],\nwhere t is the value at the given valid index.\nAs in Lua, this function may trigger a metamethod\nfor the \"index\" event (see §2.8).\n\n\n\n\n\n

lua_getglobal

\n[-0, +1, e]\n

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

\nPushes onto the stack the value of the global name.\nIt is defined as a macro:\n\n

\n     #define lua_getglobal(L,s)  lua_getfield(L, LUA_GLOBALSINDEX, s)\n
\n\n\n\n\n

lua_getmetatable

\n[-0, +(0|1), -]\n

int lua_getmetatable (lua_State *L, int index);
\n\n

\nPushes onto the stack the metatable of the value at the given\nacceptable index.\nIf the index is not valid,\nor if the value does not have a metatable,\nthe function returns 0 and pushes nothing on the stack.\n\n\n\n\n\n

lua_gettable

\n[-1, +1, e]\n

void lua_gettable (lua_State *L, int index);
\n\n

\nPushes onto the stack the value t[k],\nwhere t is the value at the given valid index\nand k is the value at the top of the stack.\n\n\n

\nThis function pops the key from the stack\n(putting the resulting value in its place).\nAs in Lua, this function may trigger a metamethod\nfor the \"index\" event (see §2.8).\n\n\n\n\n\n

lua_gettop

\n[-0, +0, -]\n

int lua_gettop (lua_State *L);
\n\n

\nReturns the index of the top element in the stack.\nBecause indices start at 1,\nthis result is equal to the number of elements in the stack\n(and so 0 means an empty stack).\n\n\n\n\n\n

lua_insert

\n[-1, +1, -]\n

void lua_insert (lua_State *L, int index);
\n\n

\nMoves the top element into the given valid index,\nshifting up the elements above this index to open space.\nCannot be called with a pseudo-index,\nbecause a pseudo-index is not an actual stack position.\n\n\n\n\n\n

lua_Integer

\n
typedef ptrdiff_t lua_Integer;
\n\n

\nThe type used by the Lua API to represent integral values.\n\n\n

\nBy default it is a ptrdiff_t,\nwhich is usually the largest signed integral type the machine handles\n\"comfortably\".\n\n\n\n\n\n

lua_isboolean

\n[-0, +0, -]\n

int lua_isboolean (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index has type boolean,\nand 0 otherwise.\n\n\n\n\n\n

lua_iscfunction

\n[-0, +0, -]\n

int lua_iscfunction (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a C function,\nand 0 otherwise.\n\n\n\n\n\n

lua_isfunction

\n[-0, +0, -]\n

int lua_isfunction (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a function\n(either C or Lua), and 0 otherwise.\n\n\n\n\n\n

lua_islightuserdata

\n[-0, +0, -]\n

int lua_islightuserdata (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a light userdata,\nand 0 otherwise.\n\n\n\n\n\n

lua_isnil

\n[-0, +0, -]\n

int lua_isnil (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is nil,\nand 0 otherwise.\n\n\n\n\n\n

lua_isnone

\n[-0, +0, -]\n

int lua_isnone (lua_State *L, int index);
\n\n

\nReturns 1 if the given acceptable index is not valid\n(that is, it refers to an element outside the current stack),\nand 0 otherwise.\n\n\n\n\n\n

lua_isnoneornil

\n[-0, +0, -]\n

int lua_isnoneornil (lua_State *L, int index);
\n\n

\nReturns 1 if the given acceptable index is not valid\n(that is, it refers to an element outside the current stack)\nor if the value at this index is nil,\nand 0 otherwise.\n\n\n\n\n\n

lua_isnumber

\n[-0, +0, -]\n

int lua_isnumber (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a number\nor a string convertible to a number,\nand 0 otherwise.\n\n\n\n\n\n

lua_isstring

\n[-0, +0, -]\n

int lua_isstring (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a string\nor a number (which is always convertible to a string),\nand 0 otherwise.\n\n\n\n\n\n

lua_istable

\n[-0, +0, -]\n

int lua_istable (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a table,\nand 0 otherwise.\n\n\n\n\n\n

lua_isthread

\n[-0, +0, -]\n

int lua_isthread (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a thread,\nand 0 otherwise.\n\n\n\n\n\n

lua_isuserdata

\n[-0, +0, -]\n

int lua_isuserdata (lua_State *L, int index);
\n\n

\nReturns 1 if the value at the given acceptable index is a userdata\n(either full or light), and 0 otherwise.\n\n\n\n\n\n

lua_lessthan

\n[-0, +0, e]\n

int lua_lessthan (lua_State *L, int index1, int index2);
\n\n

\nReturns 1 if the value at acceptable index index1 is smaller\nthan the value at acceptable index index2,\nfollowing the semantics of the Lua < operator\n(that is, may call metamethods).\nOtherwise returns 0.\nAlso returns 0 if any of the indices is non valid.\n\n\n\n\n\n

lua_load

\n[-0, +1, -]\n

int lua_load (lua_State *L,\n              lua_Reader reader,\n              void *data,\n              const char *chunkname);
\n\n

\nLoads a Lua chunk.\nIf there are no errors,\nlua_load pushes the compiled chunk as a Lua\nfunction on top of the stack.\nOtherwise, it pushes an error message.\nThe return values of lua_load are:\n\n

    \n\n
  • 0: no errors;
    • \n\n
  • LUA_ERRSYNTAX:\nsyntax error during pre-compilation;
    • \n\n
  • LUA_ERRMEM:\nmemory allocation error.
    • \n\n
\n\n

\nThis function only loads a chunk;\nit does not run it.\n\n\n

\nlua_load automatically detects whether the chunk is text or binary,\nand loads it accordingly (see program luac).\n\n\n

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

\nThe chunkname argument gives a name to the chunk,\nwhich is used for error messages and in debug information (see §3.8).\n\n\n\n\n\n

lua_newstate

\n[-0, +0, -]\n

lua_State *lua_newstate (lua_Alloc f, void *ud);
\n\n

\nCreates a new, independent state.\nReturns NULL if cannot create the state\n(due to lack of memory).\nThe argument f is the allocator function;\nLua does all memory allocation for this state through this function.\nThe second argument, ud, is an opaque pointer that Lua\nsimply passes to the allocator in every call.\n\n\n\n\n\n

lua_newtable

\n[-0, +1, m]\n

void lua_newtable (lua_State *L);
\n\n

\nCreates a new empty table and pushes it onto the stack.\nIt is equivalent to lua_createtable(L, 0, 0).\n\n\n\n\n\n

lua_newthread

\n[-0, +1, m]\n

lua_State *lua_newthread (lua_State *L);
\n\n

\nCreates a new thread, pushes it on the stack,\nand returns a pointer to a lua_State that represents this new thread.\nThe new state returned by this function shares with the original state\nall global objects (such as tables),\nbut has an independent execution stack.\n\n\n

\nThere is no explicit function to close or to destroy a thread.\nThreads are subject to garbage collection,\nlike any Lua object.\n\n\n\n\n\n

lua_newuserdata

\n[-0, +1, m]\n

void *lua_newuserdata (lua_State *L, size_t size);
\n\n

\nThis function allocates a new block of memory with the given size,\npushes onto the stack a new full userdata with the block address,\nand returns this address.\n\n\n

\nUserdata represent C values in Lua.\nA full userdata represents a block of memory.\nIt is an object (like a table):\nyou must create it, it can have its own metatable,\nand you can detect when it is being collected.\nA full userdata is only equal to itself (under raw equality).\n\n\n

\nWhen Lua collects a full userdata with a gc metamethod,\nLua calls the metamethod and marks the userdata as finalized.\nWhen this userdata is collected again then\nLua frees its corresponding memory.\n\n\n\n\n\n

lua_next

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

int lua_next (lua_State *L, int index);
\n\n

\nPops a key from the stack,\nand pushes a key-value pair from the table at the given index\n(the \"next\" pair after the given key).\nIf there are no more elements in the table,\nthen lua_next returns 0 (and pushes nothing).\n\n\n

\nA typical traversal looks like this:\n\n

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

\nWhile traversing a table,\ndo not call lua_tolstring directly on a key,\nunless you know that the key is actually a string.\nRecall that lua_tolstring changes\nthe value at the given index;\nthis confuses the next call to lua_next.\n\n\n\n\n\n

lua_Number

\n
typedef double lua_Number;
\n\n

\nThe type of numbers in Lua.\nBy default, it is double, but that can be changed in luaconf.h.\n\n\n

\nThrough the configuration file you can change\nLua to operate with another type for numbers (e.g., float or long).\n\n\n\n\n\n

lua_objlen

\n[-0, +0, -]\n

size_t lua_objlen (lua_State *L, int index);
\n\n

\nReturns the \"length\" of the value at the given acceptable index:\nfor strings, this is the string length;\nfor tables, this is the result of the length operator ('#');\nfor userdata, this is the size of the block of memory allocated\nfor the userdata;\nfor other values, it is 0.\n\n\n\n\n\n

lua_pcall

\n[-(nargs + 1), +(nresults|1), -]\n

int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);
\n\n

\nCalls a function in protected mode.\n\n\n

\nBoth nargs and nresults have the same meaning as\nin lua_call.\nIf there are no errors during the call,\nlua_pcall behaves exactly like lua_call.\nHowever, if there is any error,\nlua_pcall catches it,\npushes a single value on the stack (the error message),\nand returns an error code.\nLike lua_call,\nlua_pcall always removes the function\nand its arguments from the stack.\n\n\n

\nIf errfunc is 0,\nthen the error message returned on the stack\nis exactly the original error message.\nOtherwise, errfunc is the stack index of an\nerror handler function.\n(In the current implementation, this index cannot be a pseudo-index.)\nIn case of runtime errors,\nthis function will be called with the error message\nand its return value will be the message returned on the stack by lua_pcall.\n\n\n

\nTypically, the error handler function is used to add more debug\ninformation to the error message, such as a stack traceback.\nSuch information cannot be gathered after the return of lua_pcall,\nsince by then the stack has unwound.\n\n\n

\nThe lua_pcall function returns 0 in case of success\nor one of the following error codes\n(defined in lua.h):\n\n

    \n\n
  • LUA_ERRRUN:\na runtime error.\n
    • \n\n
  • LUA_ERRMEM:\nmemory allocation error.\nFor such errors, Lua does not call the error handler function.\n
    • \n\n
  • LUA_ERRERR:\nerror while running the error handler function.\n
    • \n\n
\n\n\n\n\n

lua_pop

\n[-n, +0, -]\n

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

\nPops n elements from the stack.\n\n\n\n\n\n

lua_pushboolean

\n[-0, +1, -]\n

void lua_pushboolean (lua_State *L, int b);
\n\n

\nPushes a boolean value with value b onto the stack.\n\n\n\n\n\n

lua_pushcclosure

\n[-n, +1, m]\n

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

\nPushes a new C closure onto the stack.\n\n\n

\nWhen a C function is created,\nit is possible to associate some values with it,\nthus creating a C closure (see §3.4);\nthese values are then accessible to the function whenever it is called.\nTo associate values with a C function,\nfirst these values should be pushed onto the stack\n(when there are multiple values, the first value is pushed first).\nThen lua_pushcclosure\nis called to create and push the C function onto the stack,\nwith the argument n telling how many values should be\nassociated with the function.\nlua_pushcclosure also pops these values from the stack.\n\n\n

\nThe maximum value for n is 255.\n\n\n\n\n\n

lua_pushcfunction

\n[-0, +1, m]\n

void lua_pushcfunction (lua_State *L, lua_CFunction f);
\n\n

\nPushes a C function onto the stack.\nThis function receives a pointer to a C function\nand pushes onto the stack a Lua value of type function that,\nwhen called, invokes the corresponding C function.\n\n\n

\nAny function to be registered in Lua must\nfollow the correct protocol to receive its parameters\nand return its results (see lua_CFunction).\n\n\n

\nlua_pushcfunction is defined as a macro:\n\n

\n     #define lua_pushcfunction(L,f)  lua_pushcclosure(L,f,0)\n
\n\n\n\n\n

lua_pushfstring

\n[-0, +1, m]\n

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

\nPushes onto the stack a formatted string\nand returns a pointer to this string.\nIt is similar to the C function sprintf,\nbut has some important differences:\n\n

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

lua_pushinteger

\n[-0, +1, -]\n

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

\nPushes a number with value n onto the stack.\n\n\n\n\n\n

lua_pushlightuserdata

\n[-0, +1, -]\n

void lua_pushlightuserdata (lua_State *L, void *p);
\n\n

\nPushes a light userdata onto the stack.\n\n\n

\nUserdata represent C values in Lua.\nA light userdata represents a pointer.\nIt is a value (like a number):\nyou do not create it, it has no individual metatable,\nand it is not collected (as it was never created).\nA light userdata is equal to \"any\"\nlight userdata with the same C address.\n\n\n\n\n\n

lua_pushliteral

\n[-0, +1, m]\n

void lua_pushliteral (lua_State *L, const char *s);
\n\n

\nThis macro is equivalent to lua_pushlstring,\nbut can be used only when s is a literal string.\nIn these cases, it automatically provides the string length.\n\n\n\n\n\n

lua_pushlstring

\n[-0, +1, m]\n

void lua_pushlstring (lua_State *L, const char *s, size_t len);
\n\n

\nPushes the string pointed to by s with size len\nonto the stack.\nLua makes (or reuses) an internal copy of the given string,\nso the memory at s can be freed or reused immediately after\nthe function returns.\nThe string can contain embedded zeros.\n\n\n\n\n\n

lua_pushnil

\n[-0, +1, -]\n

void lua_pushnil (lua_State *L);
\n\n

\nPushes a nil value onto the stack.\n\n\n\n\n\n

lua_pushnumber

\n[-0, +1, -]\n

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

\nPushes a number with value n onto the stack.\n\n\n\n\n\n

lua_pushstring

\n[-0, +1, m]\n

void lua_pushstring (lua_State *L, const char *s);
\n\n

\nPushes the zero-terminated string pointed to by s\nonto the stack.\nLua makes (or reuses) an internal copy of the given string,\nso the memory at s can be freed or reused immediately after\nthe function returns.\nThe string cannot contain embedded zeros;\nit is assumed to end at the first zero.\n\n\n\n\n\n

lua_pushthread

\n[-0, +1, -]\n

int lua_pushthread (lua_State *L);
\n\n

\nPushes the thread represented by L onto the stack.\nReturns 1 if this thread is the main thread of its state.\n\n\n\n\n\n

lua_pushvalue

\n[-0, +1, -]\n

void lua_pushvalue (lua_State *L, int index);
\n\n

\nPushes a copy of the element at the given valid index\nonto the stack.\n\n\n\n\n\n

lua_pushvfstring

\n[-0, +1, m]\n

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

\nEquivalent to lua_pushfstring, except that it receives a va_list\ninstead of a variable number of arguments.\n\n\n\n\n\n

lua_rawequal

\n[-0, +0, -]\n

int lua_rawequal (lua_State *L, int index1, int index2);
\n\n

\nReturns 1 if the two values in acceptable indices index1 and\nindex2 are primitively equal\n(that is, without calling metamethods).\nOtherwise returns 0.\nAlso returns 0 if any of the indices are non valid.\n\n\n\n\n\n

lua_rawget

\n[-1, +1, -]\n

void lua_rawget (lua_State *L, int index);
\n\n

\nSimilar to lua_gettable, but does a raw access\n(i.e., without metamethods).\n\n\n\n\n\n

lua_rawgeti

\n[-0, +1, -]\n

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

\nPushes onto the stack the value t[n],\nwhere t is the value at the given valid index.\nThe access is raw;\nthat is, it does not invoke metamethods.\n\n\n\n\n\n

lua_rawset

\n[-2, +0, m]\n

void lua_rawset (lua_State *L, int index);
\n\n

\nSimilar to lua_settable, but does a raw assignment\n(i.e., without metamethods).\n\n\n\n\n\n

lua_rawseti

\n[-1, +0, m]\n

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

\nDoes the equivalent of t[n] = v,\nwhere t is the value at the given valid index\nand v is the value at the top of the stack.\n\n\n

\nThis function pops the value from the stack.\nThe assignment is raw;\nthat is, it does not invoke metamethods.\n\n\n\n\n\n

lua_Reader

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

\nThe reader function used by lua_load.\nEvery time it needs another piece of the chunk,\nlua_load calls the reader,\npassing along its data parameter.\nThe reader must return a pointer to a block of memory\nwith a new piece of the chunk\nand set size to the block size.\nThe block must exist until the reader function is called again.\nTo signal the end of the chunk,\nthe reader must return NULL or set size to zero.\nThe reader function may return pieces of any size greater than zero.\n\n\n\n\n\n

lua_register

\n[-0, +0, e]\n

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

\nSets the C function f as the new value of global name.\nIt is defined as a macro:\n\n

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

lua_remove

\n[-1, +0, -]\n

void lua_remove (lua_State *L, int index);
\n\n

\nRemoves the element at the given valid index,\nshifting down the elements above this index to fill the gap.\nCannot be called with a pseudo-index,\nbecause a pseudo-index is not an actual stack position.\n\n\n\n\n\n

lua_replace

\n[-1, +0, -]\n

void lua_replace (lua_State *L, int index);
\n\n

\nMoves the top element into the given position (and pops it),\nwithout shifting any element\n(therefore replacing the value at the given position).\n\n\n\n\n\n

lua_resume

\n[-?, +?, -]\n

int lua_resume (lua_State *L, int narg);
\n\n

\nStarts and resumes a coroutine in a given thread.\n\n\n

\nTo start a coroutine, you first create a new thread\n(see lua_newthread);\nthen you push onto its stack the main function plus any arguments;\nthen you call lua_resume,\nwith narg being the number of arguments.\nThis call returns when the coroutine suspends or finishes its execution.\nWhen it returns, the stack contains all values passed to lua_yield,\nor all values returned by the body function.\nlua_resume returns\nLUA_YIELD if the coroutine yields,\n0 if the coroutine finishes its execution\nwithout errors,\nor an error code in case of errors (see lua_pcall).\nIn case of errors,\nthe stack is not unwound,\nso you can use the debug API over it.\nThe error message is on the top of the stack.\nTo restart a coroutine, you put on its stack only the values to\nbe passed as results from yield,\nand then call lua_resume.\n\n\n\n\n\n

lua_setallocf

\n[-0, +0, -]\n

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

\nChanges the allocator function of a given state to f\nwith user data ud.\n\n\n\n\n\n

lua_setfenv

\n[-1, +0, -]\n

int lua_setfenv (lua_State *L, int index);
\n\n

\nPops a table from the stack and sets it as\nthe new environment for the value at the given index.\nIf the value at the given index is\nneither a function nor a thread nor a userdata,\nlua_setfenv returns 0.\nOtherwise it returns 1.\n\n\n\n\n\n

lua_setfield

\n[-1, +0, e]\n

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

\nDoes the equivalent to t[k] = v,\nwhere t is the value at the given valid index\nand v is the value at the top of the stack.\n\n\n

\nThis function pops the value from the stack.\nAs in Lua, this function may trigger a metamethod\nfor the \"newindex\" event (see §2.8).\n\n\n\n\n\n

lua_setglobal

\n[-1, +0, e]\n

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

\nPops a value from the stack and\nsets it as the new value of global name.\nIt is defined as a macro:\n\n

\n     #define lua_setglobal(L,s)   lua_setfield(L, LUA_GLOBALSINDEX, s)\n
\n\n\n\n\n

lua_setmetatable

\n[-1, +0, -]\n

int lua_setmetatable (lua_State *L, int index);
\n\n

\nPops a table from the stack and\nsets it as the new metatable for the value at the given\nacceptable index.\n\n\n\n\n\n

lua_settable

\n[-2, +0, e]\n

void lua_settable (lua_State *L, int index);
\n\n

\nDoes the equivalent to t[k] = v,\nwhere t is the value at the given valid index,\nv is the value at the top of the stack,\nand k is the value just below the top.\n\n\n

\nThis function pops both the key and the value from the stack.\nAs in Lua, this function may trigger a metamethod\nfor the \"newindex\" event (see §2.8).\n\n\n\n\n\n

lua_settop

\n[-?, +?, -]\n

void lua_settop (lua_State *L, int index);
\n\n

\nAccepts any acceptable index, or 0,\nand sets the stack top to this index.\nIf the new top is larger than the old one,\nthen the new elements are filled with nil.\nIf index is 0, then all stack elements are removed.\n\n\n\n\n\n

lua_State

\n
typedef struct lua_State lua_State;
\n\n

\nOpaque structure that keeps the whole state of a Lua interpreter.\nThe Lua library is fully reentrant:\nit has no global variables.\nAll information about a state is kept in this structure.\n\n\n

\nA pointer to this state must be passed as the first argument to\nevery function in the library, except to lua_newstate,\nwhich creates a Lua state from scratch.\n\n\n\n\n\n

lua_status

\n[-0, +0, -]\n

int lua_status (lua_State *L);
\n\n

\nReturns the status of the thread L.\n\n\n

\nThe status can be 0 for a normal thread,\nan error code if the thread finished its execution with an error,\nor LUA_YIELD if the thread is suspended.\n\n\n\n\n\n

lua_toboolean

\n[-0, +0, -]\n

int lua_toboolean (lua_State *L, int index);
\n\n

\nConverts the Lua value at the given acceptable index to a C boolean\nvalue (0 or 1).\nLike all tests in Lua,\nlua_toboolean returns 1 for any Lua value\ndifferent from false and nil;\notherwise it returns 0.\nIt also returns 0 when called with a non-valid index.\n(If you want to accept only actual boolean values,\nuse lua_isboolean to test the value's type.)\n\n\n\n\n\n

lua_tocfunction

\n[-0, +0, -]\n

lua_CFunction lua_tocfunction (lua_State *L, int index);
\n\n

\nConverts a value at the given acceptable index to a C function.\nThat value must be a C function;\notherwise, returns NULL.\n\n\n\n\n\n

lua_tointeger

\n[-0, +0, -]\n

lua_Integer lua_tointeger (lua_State *L, int index);
\n\n

\nConverts the Lua value at the given acceptable index\nto the signed integral type lua_Integer.\nThe Lua value must be a number or a string convertible to a number\n(see §2.2.1);\notherwise, lua_tointeger returns 0.\n\n\n

\nIf the number is not an integer,\nit is truncated in some non-specified way.\n\n\n\n\n\n

lua_tolstring

\n[-0, +0, m]\n

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

\nConverts the Lua value at the given acceptable index to a C string.\nIf len is not NULL,\nit also sets *len with the string length.\nThe Lua value must be a string or a number;\notherwise, the function returns NULL.\nIf the value is a number,\nthen lua_tolstring also\nchanges the actual value in the stack to a string.\n(This change confuses lua_next\nwhen lua_tolstring is applied to keys during a table traversal.)\n\n\n

\nlua_tolstring returns a fully aligned pointer\nto a string inside the Lua state.\nThis string always has a zero ('\\0')\nafter its last character (as in C),\nbut can contain other zeros in its body.\nBecause Lua has garbage collection,\nthere is no guarantee that the pointer returned by lua_tolstring\nwill be valid after the corresponding value is removed from the stack.\n\n\n\n\n\n

lua_tonumber

\n[-0, +0, -]\n

lua_Number lua_tonumber (lua_State *L, int index);
\n\n

\nConverts the Lua value at the given acceptable index\nto the C type lua_Number (see lua_Number).\nThe Lua value must be a number or a string convertible to a number\n(see §2.2.1);\notherwise, lua_tonumber returns 0.\n\n\n\n\n\n

lua_topointer

\n[-0, +0, -]\n

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

\nConverts the value at the given acceptable index to a generic\nC pointer (void*).\nThe value can be a userdata, a table, a thread, or a function;\notherwise, lua_topointer returns NULL.\nDifferent objects will give different pointers.\nThere is no way to convert the pointer back to its original value.\n\n\n

\nTypically this function is used only for debug information.\n\n\n\n\n\n

lua_tostring

\n[-0, +0, m]\n

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

\nEquivalent to lua_tolstring with len equal to NULL.\n\n\n\n\n\n

lua_tothread

\n[-0, +0, -]\n

lua_State *lua_tothread (lua_State *L, int index);
\n\n

\nConverts the value at the given acceptable index to a Lua thread\n(represented as lua_State*).\nThis value must be a thread;\notherwise, the function returns NULL.\n\n\n\n\n\n

lua_touserdata

\n[-0, +0, -]\n

void *lua_touserdata (lua_State *L, int index);
\n\n

\nIf the value at the given acceptable index is a full userdata,\nreturns its block address.\nIf the value is a light userdata,\nreturns its pointer.\nOtherwise, returns NULL.\n\n\n\n\n\n

lua_type

\n[-0, +0, -]\n

int lua_type (lua_State *L, int index);
\n\n

\nReturns the type of the value in the given acceptable index,\nor LUA_TNONE for a non-valid index\n(that is, an index to an \"empty\" stack position).\nThe types returned by lua_type are coded by the following constants\ndefined in lua.h:\nLUA_TNIL,\nLUA_TNUMBER,\nLUA_TBOOLEAN,\nLUA_TSTRING,\nLUA_TTABLE,\nLUA_TFUNCTION,\nLUA_TUSERDATA,\nLUA_TTHREAD,\nand\nLUA_TLIGHTUSERDATA.\n\n\n\n\n\n

lua_typename

\n[-0, +0, -]\n

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

\nReturns the name of the type encoded by the value tp,\nwhich must be one the values returned by lua_type.\n\n\n\n\n\n

lua_Writer

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

\nThe type of the writer function used by lua_dump.\nEvery time it produces another piece of chunk,\nlua_dump calls the writer,\npassing along the buffer to be written (p),\nits size (sz),\nand the data parameter supplied to lua_dump.\n\n\n

\nThe writer returns an error code:\n0 means no errors;\nany other value means an error and stops lua_dump from\ncalling the writer again.\n\n\n\n\n\n

lua_xmove

\n[-?, +?, -]\n

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

\nExchange values between different threads of the same global state.\n\n\n

\nThis function pops n values from the stack from,\nand pushes them onto the stack to.\n\n\n\n\n\n

lua_yield

\n[-?, +?, -]\n

int lua_yield  (lua_State *L, int nresults);
\n\n

\nYields a coroutine.\n\n\n

\nThis function should only be called as the\nreturn expression of a C function, as follows:\n\n

\n     return lua_yield (L, nresults);\n

\nWhen a C function calls lua_yield in that way,\nthe running coroutine suspends its execution,\nand the call to lua_resume that started this coroutine returns.\nThe parameter nresults is the number of values from the stack\nthat are passed as results to lua_resume.\n\n\n\n\n\n\n\n

3.8 - The Debug Interface

\n\n

\nLua has no built-in debugging facilities.\nInstead, it offers a special interface\nby means of functions and hooks.\nThis interface allows the construction of different\nkinds of debuggers, profilers, and other tools\nthat need \"inside information\" from the interpreter.\n\n\n\n

lua_Debug

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

\nA structure used to carry different pieces of\ninformation about an active function.\nlua_getstack fills only the private part\nof this structure, for later use.\nTo fill the other fields of lua_Debug with useful information,\ncall lua_getinfo.\n\n\n

\nThe fields of lua_Debug have the following meaning:\n\n

    \n\n
  • source:\nIf the function was defined in a string,\nthen source is that string.\nIf the function was defined in a file,\nthen source starts with a '@' followed by the file name.\n
    • \n\n
  • short_src:\na \"printable\" version of source, to be used in error messages.\n
    • \n\n
  • linedefined:\nthe line number where the definition of the function starts.\n
    • \n\n
  • lastlinedefined:\nthe line number where the definition of the function ends.\n
    • \n\n
  • what:\nthe string \"Lua\" if the function is a Lua function,\n\"C\" if it is a C function,\n\"main\" if it is the main part of a chunk,\nand \"tail\" if it was a function that did a tail call.\nIn the latter case,\nLua has no other information about the function.\n
    • \n\n
  • currentline:\nthe current line where the given function is executing.\nWhen no line information is available,\ncurrentline is set to -1.\n
    • \n\n
  • name:\na reasonable name for the given function.\nBecause functions in Lua are first-class values,\nthey do not have a fixed name:\nsome functions can be the value of multiple global variables,\nwhile others can be stored only in a table field.\nThe lua_getinfo function checks how the function was\ncalled to find a suitable name.\nIf it cannot find a name,\nthen name is set to NULL.\n
    • \n\n
  • namewhat:\nexplains the name field.\nThe value of namewhat can be\n\"global\", \"local\", \"method\",\n\"field\", \"upvalue\", or \"\" (the empty string),\naccording to how the function was called.\n(Lua uses the empty string when no other option seems to apply.)\n
    • \n\n
  • nups:\nthe number of upvalues of the function.\n
    • \n\n
\n\n\n\n\n

lua_gethook

\n[-0, +0, -]\n

lua_Hook lua_gethook (lua_State *L);
\n\n

\nReturns the current hook function.\n\n\n\n\n\n

lua_gethookcount

\n[-0, +0, -]\n

int lua_gethookcount (lua_State *L);
\n\n

\nReturns the current hook count.\n\n\n\n\n\n

lua_gethookmask

\n[-0, +0, -]\n

int lua_gethookmask (lua_State *L);
\n\n

\nReturns the current hook mask.\n\n\n\n\n\n

lua_getinfo

\n[-(0|1), +(0|1|2), m]\n

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

\nReturns information about a specific function or function invocation.\n\n\n

\nTo get information about a function invocation,\nthe parameter ar must be a valid activation record that was\nfilled by a previous call to lua_getstack or\ngiven as argument to a hook (see lua_Hook).\n\n\n

\nTo get information about a function you push it onto the stack\nand start the what string with the character '>'.\n(In that case,\nlua_getinfo pops the function in the top of the stack.)\nFor instance, to know in which line a function f was defined,\nyou can write the following code:\n\n

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

\nEach character in the string what\nselects some fields of the structure ar to be filled or\na value to be pushed on the stack:\n\n

    \n\n
  • 'n': fills in the field name and namewhat;\n
    • \n\n
  • 'S':\nfills in the fields source, short_src,\nlinedefined, lastlinedefined, and what;\n
    • \n\n
  • 'l': fills in the field currentline;\n
    • \n\n
  • 'u': fills in the field nups;\n
    • \n\n
  • 'f':\npushes onto the stack the function that is\nrunning at the given level;\n
    • \n\n
  • 'L':\npushes onto the stack a table whose indices are the\nnumbers of the lines that are valid on the function.\n(A valid line is a line with some associated code,\nthat is, a line where you can put a break point.\nNon-valid lines include empty lines and comments.)\n
    • \n\n
\n\n

\nThis function returns 0 on error\n(for instance, an invalid option in what).\n\n\n\n\n\n

lua_getlocal

\n[-0, +(0|1), -]\n

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

\nGets information about a local variable of a given activation record.\nThe parameter ar must be a valid activation record that was\nfilled by a previous call to lua_getstack or\ngiven as argument to a hook (see lua_Hook).\nThe index n selects which local variable to inspect\n(1 is the first parameter or active local variable, and so on,\nuntil the last active local variable).\nlua_getlocal pushes the variable's value onto the stack\nand returns its name.\n\n\n

\nVariable names starting with '(' (open parentheses)\nrepresent internal variables\n(loop control variables, temporaries, and C function locals).\n\n\n

\nReturns NULL (and pushes nothing)\nwhen the index is greater than\nthe number of active local variables.\n\n\n\n\n\n

lua_getstack

\n[-0, +0, -]\n

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

\nGet information about the interpreter runtime stack.\n\n\n

\nThis function fills parts of a lua_Debug structure with\nan identification of the activation record\nof the function executing at a given level.\nLevel 0 is the current running function,\nwhereas level n+1 is the function that has called level n.\nWhen there are no errors, lua_getstack returns 1;\nwhen called with a level greater than the stack depth,\nit returns 0.\n\n\n\n\n\n

lua_getupvalue

\n[-0, +(0|1), -]\n

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

\nGets information about a closure's upvalue.\n(For Lua functions,\nupvalues are the external local variables that the function uses,\nand that are consequently included in its closure.)\nlua_getupvalue gets the index n of an upvalue,\npushes the upvalue's value onto the stack,\nand returns its name.\nfuncindex points to the closure in the stack.\n(Upvalues have no particular order,\nas they are active through the whole function.\nSo, they are numbered in an arbitrary order.)\n\n\n

\nReturns NULL (and pushes nothing)\nwhen the index is greater than the number of upvalues.\nFor C functions, this function uses the empty string \"\"\nas a name for all upvalues.\n\n\n\n\n\n

lua_Hook

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

\nType for debugging hook functions.\n\n\n

\nWhenever a hook is called, its ar argument has its field\nevent set to the specific event that triggered the hook.\nLua identifies these events with the following constants:\nLUA_HOOKCALL, LUA_HOOKRET,\nLUA_HOOKTAILRET, LUA_HOOKLINE,\nand LUA_HOOKCOUNT.\nMoreover, for line events, the field currentline is also set.\nTo get the value of any other field in ar,\nthe hook must call lua_getinfo.\nFor return events, event can be LUA_HOOKRET,\nthe normal value, or LUA_HOOKTAILRET.\nIn the latter case, Lua is simulating a return from\na function that did a tail call;\nin this case, it is useless to call lua_getinfo.\n\n\n

\nWhile Lua is running a hook, it disables other calls to hooks.\nTherefore, if a hook calls back Lua to execute a function or a chunk,\nthis execution occurs without any calls to hooks.\n\n\n\n\n\n

lua_sethook

\n[-0, +0, -]\n

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

\nSets the debugging hook function.\n\n\n

\nArgument f is the hook function.\nmask specifies on which events the hook will be called:\nit is formed by a bitwise or of the constants\nLUA_MASKCALL,\nLUA_MASKRET,\nLUA_MASKLINE,\nand LUA_MASKCOUNT.\nThe count argument is only meaningful when the mask\nincludes LUA_MASKCOUNT.\nFor each event, the hook is called as explained below:\n\n

    \n\n
  • The call hook: is called when the interpreter calls a function.\nThe hook is called just after Lua enters the new function,\nbefore the function gets its arguments.\n
    • \n\n
  • The return hook: is called when the interpreter returns from a function.\nThe hook is called just before Lua leaves the function.\nYou have no access to the values to be returned by the function.\n
    • \n\n
  • The line hook: is called when the interpreter is about to\nstart the execution of a new line of code,\nor when it jumps back in the code (even to the same line).\n(This event only happens while Lua is executing a Lua function.)\n
    • \n\n
  • The count hook: is called after the interpreter executes every\ncount instructions.\n(This event only happens while Lua is executing a Lua function.)\n
    • \n\n
\n\n

\nA hook is disabled by setting mask to zero.\n\n\n\n\n\n

lua_setlocal

\n[-(0|1), +0, -]\n

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

\nSets the value of a local variable of a given activation record.\nParameters ar and n are as in lua_getlocal\n(see lua_getlocal).\nlua_setlocal assigns the value at the top of the stack\nto the variable and returns its name.\nIt also pops the value from the stack.\n\n\n

\nReturns NULL (and pops nothing)\nwhen the index is greater than\nthe number of active local variables.\n\n\n\n\n\n

lua_setupvalue

\n[-(0|1), +0, -]\n

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

\nSets the value of a closure's upvalue.\nIt assigns the value at the top of the stack\nto the upvalue and returns its name.\nIt also pops the value from the stack.\nParameters funcindex and n are as in the lua_getupvalue\n(see lua_getupvalue).\n\n\n

\nReturns NULL (and pops nothing)\nwhen the index is greater than the number of upvalues.\n\n\n\n\n\n\n\n

4 - The Auxiliary Library

\n\n

\n\nThe auxiliary library provides several convenient functions\nto interface C with Lua.\nWhile the basic API provides the primitive functions for all \ninteractions between C and Lua,\nthe auxiliary library provides higher-level functions for some\ncommon tasks.\n\n\n

\nAll functions from the auxiliary library\nare defined in header file lauxlib.h and\nhave a prefix luaL_.\n\n\n

\nAll functions in the auxiliary library are built on\ntop of the basic API,\nand so they provide nothing that cannot be done with this API.\n\n\n

\nSeveral functions in the auxiliary library are used to\ncheck C function arguments.\nTheir names are always luaL_check* or luaL_opt*.\nAll of these functions throw an error if the check is not satisfied.\nBecause the error message is formatted for arguments\n(e.g., \"bad argument #1\"),\nyou should not use these functions for other stack values.\n\n\n\n

4.1 - Functions and Types

\n\n

\nHere we list all functions and types from the auxiliary library\nin alphabetical order.\n\n\n\n

luaL_addchar

\n[-0, +0, m]\n

void luaL_addchar (luaL_Buffer *B, char c);
\n\n

\nAdds the character c to the buffer B\n(see luaL_Buffer).\n\n\n\n\n\n

luaL_addlstring

\n[-0, +0, m]\n

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

\nAdds the string pointed to by s with length l to\nthe buffer B\n(see luaL_Buffer).\nThe string may contain embedded zeros.\n\n\n\n\n\n

luaL_addsize

\n[-0, +0, m]\n

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

\nAdds to the buffer B (see luaL_Buffer)\na string of length n previously copied to the\nbuffer area (see luaL_prepbuffer).\n\n\n\n\n\n

luaL_addstring

\n[-0, +0, m]\n

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

\nAdds the zero-terminated string pointed to by s\nto the buffer B\n(see luaL_Buffer).\nThe string may not contain embedded zeros.\n\n\n\n\n\n

luaL_addvalue

\n[-1, +0, m]\n

void luaL_addvalue (luaL_Buffer *B);
\n\n

\nAdds the value at the top of the stack\nto the buffer B\n(see luaL_Buffer).\nPops the value.\n\n\n

\nThis is the only function on string buffers that can (and must)\nbe called with an extra element on the stack,\nwhich is the value to be added to the buffer.\n\n\n\n\n\n

luaL_argcheck

\n[-0, +0, v]\n

void luaL_argcheck (lua_State *L,\n                    int cond,\n                    int narg,\n                    const char *extramsg);
\n\n

\nChecks whether cond is true.\nIf not, raises an error with the following message,\nwhere func is retrieved from the call stack:\n\n

\n     bad argument #<narg> to <func> (<extramsg>)\n
\n\n\n\n\n

luaL_argerror

\n[-0, +0, v]\n

int luaL_argerror (lua_State *L, int narg, const char *extramsg);
\n\n

\nRaises an error with the following message,\nwhere func is retrieved from the call stack:\n\n

\n     bad argument #<narg> to <func> (<extramsg>)\n
\n\n

\nThis function never returns,\nbut it is an idiom to use it in C functions\nas return luaL_argerror(args).\n\n\n\n\n\n

luaL_Buffer

\n
typedef struct luaL_Buffer luaL_Buffer;
\n\n

\nType for a string buffer.\n\n\n

\nA string buffer allows C code to build Lua strings piecemeal.\nIts pattern of use is as follows:\n\n

    \n\n
  • First you declare a variable b of type luaL_Buffer.
    • \n\n
  • Then you initialize it with a call luaL_buffinit(L, &b).
    • \n\n
  • \nThen you add string pieces to the buffer calling any of\nthe luaL_add* functions.\n
    • \n\n
  • \nYou finish by calling luaL_pushresult(&b).\nThis call leaves the final string on the top of the stack.\n
    • \n\n
\n\n

\nDuring its normal operation,\na string buffer uses a variable number of stack slots.\nSo, while using a buffer, you cannot assume that you know where\nthe top of the stack is.\nYou can use the stack between successive calls to buffer operations\nas long as that use is balanced;\nthat is,\nwhen you call a buffer operation,\nthe stack is at the same level\nit was immediately after the previous buffer operation.\n(The only exception to this rule is luaL_addvalue.)\nAfter calling luaL_pushresult the stack is back to its\nlevel when the buffer was initialized,\nplus the final string on its top.\n\n\n\n\n\n

luaL_buffinit

\n[-0, +0, -]\n

void luaL_buffinit (lua_State *L, luaL_Buffer *B);
\n\n

\nInitializes a buffer B.\nThis function does not allocate any space;\nthe buffer must be declared as a variable\n(see luaL_Buffer).\n\n\n\n\n\n

luaL_callmeta

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

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

\nCalls a metamethod.\n\n\n

\nIf the object at index obj has a metatable and this\nmetatable has a field e,\nthis function calls this field and passes the object as its only argument.\nIn this case this function returns 1 and pushes onto the\nstack the value returned by the call.\nIf there is no metatable or no metamethod,\nthis function returns 0 (without pushing any value on the stack).\n\n\n\n\n\n

luaL_checkany

\n[-0, +0, v]\n

void luaL_checkany (lua_State *L, int narg);
\n\n

\nChecks whether the function has an argument\nof any type (including nil) at position narg.\n\n\n\n\n\n

luaL_checkint

\n[-0, +0, v]\n

int luaL_checkint (lua_State *L, int narg);
\n\n

\nChecks whether the function argument narg is a number\nand returns this number cast to an int.\n\n\n\n\n\n

luaL_checkinteger

\n[-0, +0, v]\n

lua_Integer luaL_checkinteger (lua_State *L, int narg);
\n\n

\nChecks whether the function argument narg is a number\nand returns this number cast to a lua_Integer.\n\n\n\n\n\n

luaL_checklong

\n[-0, +0, v]\n

long luaL_checklong (lua_State *L, int narg);
\n\n

\nChecks whether the function argument narg is a number\nand returns this number cast to a long.\n\n\n\n\n\n

luaL_checklstring

\n[-0, +0, v]\n

const char *luaL_checklstring (lua_State *L, int narg, size_t *l);
\n\n

\nChecks whether the function argument narg is a string\nand returns this string;\nif l is not NULL fills *l\nwith the string's length.\n\n\n

\nThis function uses lua_tolstring to get its result,\nso all conversions and caveats of that function apply here.\n\n\n\n\n\n

luaL_checknumber

\n[-0, +0, v]\n

lua_Number luaL_checknumber (lua_State *L, int narg);
\n\n

\nChecks whether the function argument narg is a number\nand returns this number.\n\n\n\n\n\n

luaL_checkoption

\n[-0, +0, v]\n

int luaL_checkoption (lua_State *L,\n                      int narg,\n                      const char *def,\n                      const char *const lst[]);
\n\n

\nChecks whether the function argument narg is a string and\nsearches for this string in the array lst\n(which must be NULL-terminated).\nReturns the index in the array where the string was found.\nRaises an error if the argument is not a string or\nif the string cannot be found.\n\n\n

\nIf def is not NULL,\nthe function uses def as a default value when\nthere is no argument narg or if this argument is nil.\n\n\n

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

luaL_checkstack

\n[-0, +0, v]\n

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

\nGrows the stack size to top + sz elements,\nraising an error if the stack cannot grow to that size.\nmsg is an additional text to go into the error message.\n\n\n\n\n\n

luaL_checkstring

\n[-0, +0, v]\n

const char *luaL_checkstring (lua_State *L, int narg);
\n\n

\nChecks whether the function argument narg is a string\nand returns this string.\n\n\n

\nThis function uses lua_tolstring to get its result,\nso all conversions and caveats of that function apply here.\n\n\n\n\n\n

luaL_checktype

\n[-0, +0, v]\n

void luaL_checktype (lua_State *L, int narg, int t);
\n\n

\nChecks whether the function argument narg has type t.\nSee lua_type for the encoding of types for t.\n\n\n\n\n\n

luaL_checkudata

\n[-0, +0, v]\n

void *luaL_checkudata (lua_State *L, int narg, const char *tname);
\n\n

\nChecks whether the function argument narg is a userdata\nof the type tname (see luaL_newmetatable).\n\n\n\n\n\n

luaL_dofile

\n[-0, +?, m]\n

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

\nLoads and runs the given file.\nIt is defined as the following macro:\n\n

\n     (luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))\n

\nIt returns 0 if there are no errors\nor 1 in case of errors.\n\n\n\n\n\n

luaL_dostring

\n[-0, +?, m]\n

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

\nLoads and runs the given string.\nIt is defined as the following macro:\n\n

\n     (luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))\n

\nIt returns 0 if there are no errors\nor 1 in case of errors.\n\n\n\n\n\n

luaL_error

\n[-0, +0, v]\n

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

\nRaises an error.\nThe error message format is given by fmt\nplus any extra arguments,\nfollowing the same rules of lua_pushfstring.\nIt also adds at the beginning of the message the file name and\nthe line number where the error occurred,\nif this information is available.\n\n\n

\nThis function never returns,\nbut it is an idiom to use it in C functions\nas return luaL_error(args).\n\n\n\n\n\n

luaL_getmetafield

\n[-0, +(0|1), m]\n

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

\nPushes onto the stack the field e from the metatable\nof the object at index obj.\nIf the object does not have a metatable,\nor if the metatable does not have this field,\nreturns 0 and pushes nothing.\n\n\n\n\n\n

luaL_getmetatable

\n[-0, +1, -]\n

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

\nPushes onto the stack the metatable associated with name tname\nin the registry (see luaL_newmetatable).\n\n\n\n\n\n

luaL_gsub

\n[-0, +1, m]\n

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

\nCreates a copy of string s by replacing\nany occurrence of the string p\nwith the string r.\nPushes the resulting string on the stack and returns it.\n\n\n\n\n\n

luaL_loadbuffer

\n[-0, +1, m]\n

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

\nLoads a buffer as a Lua chunk.\nThis function uses lua_load to load the chunk in the\nbuffer pointed to by buff with size sz.\n\n\n

\nThis function returns the same results as lua_load.\nname is the chunk name,\nused for debug information and error messages.\n\n\n\n\n\n

luaL_loadfile

\n[-0, +1, m]\n

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

\nLoads a file as a Lua chunk.\nThis function uses lua_load to load the chunk in the file\nnamed filename.\nIf filename is NULL,\nthen it loads from the standard input.\nThe first line in the file is ignored if it starts with a #.\n\n\n

\nThis function returns the same results as lua_load,\nbut it has an extra error code LUA_ERRFILE\nif it cannot open/read the file.\n\n\n

\nAs lua_load, this function only loads the chunk;\nit does not run it.\n\n\n\n\n\n

luaL_loadstring

\n[-0, +1, m]\n

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

\nLoads a string as a Lua chunk.\nThis function uses lua_load to load the chunk in\nthe zero-terminated string s.\n\n\n

\nThis function returns the same results as lua_load.\n\n\n

\nAlso as lua_load, this function only loads the chunk;\nit does not run it.\n\n\n\n\n\n

luaL_newmetatable

\n[-0, +1, m]\n

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

\nIf the registry already has the key tname,\nreturns 0.\nOtherwise,\ncreates a new table to be used as a metatable for userdata,\nadds it to the registry with key tname,\nand returns 1.\n\n\n

\nIn both cases pushes onto the stack the final value associated\nwith tname in the registry.\n\n\n\n\n\n

luaL_newstate

\n[-0, +0, -]\n

lua_State *luaL_newstate (void);
\n\n

\nCreates a new Lua state.\nIt calls lua_newstate with an\nallocator based on the standard C realloc function\nand then sets a panic function (see lua_atpanic) that prints\nan error message to the standard error output in case of fatal\nerrors.\n\n\n

\nReturns the new state,\nor NULL if there is a memory allocation error.\n\n\n\n\n\n

luaL_openlibs

\n[-0, +0, m]\n

void luaL_openlibs (lua_State *L);
\n\n

\nOpens all standard Lua libraries into the given state.\n\n\n\n\n\n

luaL_optint

\n[-0, +0, v]\n

int luaL_optint (lua_State *L, int narg, int d);
\n\n

\nIf the function argument narg is a number,\nreturns this number cast to an int.\nIf this argument is absent or is nil,\nreturns d.\nOtherwise, raises an error.\n\n\n\n\n\n

luaL_optinteger

\n[-0, +0, v]\n

lua_Integer luaL_optinteger (lua_State *L,\n                             int narg,\n                             lua_Integer d);
\n\n

\nIf the function argument narg is a number,\nreturns this number cast to a lua_Integer.\nIf this argument is absent or is nil,\nreturns d.\nOtherwise, raises an error.\n\n\n\n\n\n

luaL_optlong

\n[-0, +0, v]\n

long luaL_optlong (lua_State *L, int narg, long d);
\n\n

\nIf the function argument narg is a number,\nreturns this number cast to a long.\nIf this argument is absent or is nil,\nreturns d.\nOtherwise, raises an error.\n\n\n\n\n\n

luaL_optlstring

\n[-0, +0, v]\n

const char *luaL_optlstring (lua_State *L,\n                             int narg,\n                             const char *d,\n                             size_t *l);
\n\n

\nIf the function argument narg is a string,\nreturns this string.\nIf this argument is absent or is nil,\nreturns d.\nOtherwise, raises an error.\n\n\n

\nIf l is not NULL,\nfills the position *l with the results's length.\n\n\n\n\n\n

luaL_optnumber

\n[-0, +0, v]\n

lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number d);
\n\n

\nIf the function argument narg is a number,\nreturns this number.\nIf this argument is absent or is nil,\nreturns d.\nOtherwise, raises an error.\n\n\n\n\n\n

luaL_optstring

\n[-0, +0, v]\n

const char *luaL_optstring (lua_State *L,\n                            int narg,\n                            const char *d);
\n\n

\nIf the function argument narg is a string,\nreturns this string.\nIf this argument is absent or is nil,\nreturns d.\nOtherwise, raises an error.\n\n\n\n\n\n

luaL_prepbuffer

\n[-0, +0, -]\n

char *luaL_prepbuffer (luaL_Buffer *B);
\n\n

\nReturns an address to a space of size LUAL_BUFFERSIZE\nwhere you can copy a string to be added to buffer B\n(see luaL_Buffer).\nAfter copying the string into this space you must call\nluaL_addsize with the size of the string to actually add \nit to the buffer.\n\n\n\n\n\n

luaL_pushresult

\n[-?, +1, m]\n

void luaL_pushresult (luaL_Buffer *B);
\n\n

\nFinishes the use of buffer B leaving the final string on\nthe top of the stack.\n\n\n\n\n\n

luaL_ref

\n[-1, +0, m]\n

int luaL_ref (lua_State *L, int t);
\n\n

\nCreates and returns a reference,\nin the table at index t,\nfor the object at the top of the stack (and pops the object).\n\n\n

\nA reference is a unique integer key.\nAs long as you do not manually add integer keys into table t,\nluaL_ref ensures the uniqueness of the key it returns.\nYou can retrieve an object referred by reference r\nby calling lua_rawgeti(L, t, r).\nFunction luaL_unref frees a reference and its associated object.\n\n\n

\nIf the object at the top of the stack is nil,\nluaL_ref returns the constant LUA_REFNIL.\nThe constant LUA_NOREF is guaranteed to be different\nfrom any reference returned by luaL_ref.\n\n\n\n\n\n

luaL_Reg

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

\nType for arrays of functions to be registered by\nluaL_register.\nname is the function name and func is a pointer to\nthe function.\nAny array of luaL_Reg must end with an sentinel entry\nin which both name and func are NULL.\n\n\n\n\n\n

luaL_register

\n[-(0|1), +1, m]\n

void luaL_register (lua_State *L,\n                    const char *libname,\n                    const luaL_Reg *l);
\n\n

\nOpens a library.\n\n\n

\nWhen called with libname equal to NULL,\nit simply registers all functions in the list l\n(see luaL_Reg) into the table on the top of the stack.\n\n\n

\nWhen called with a non-null libname,\nluaL_register creates a new table t,\nsets it as the value of the global variable libname,\nsets it as the value of package.loaded[libname],\nand registers on it all functions in the list l.\nIf there is a table in package.loaded[libname] or in\nvariable libname,\nreuses this table instead of creating a new one.\n\n\n

\nIn any case the function leaves the table\non the top of the stack.\n\n\n\n\n\n

luaL_typename

\n[-0, +0, -]\n

const char *luaL_typename (lua_State *L, int index);
\n\n

\nReturns the name of the type of the value at the given index.\n\n\n\n\n\n

luaL_typerror

\n[-0, +0, v]\n

int luaL_typerror (lua_State *L, int narg, const char *tname);
\n\n

\nGenerates an error with a message like the following:\n\n

\n     location: bad argument narg to 'func' (tname expected, got rt)\n

\nwhere location is produced by luaL_where,\nfunc is the name of the current function,\nand rt is the type name of the actual argument.\n\n\n\n\n\n

luaL_unref

\n[-0, +0, -]\n

void luaL_unref (lua_State *L, int t, int ref);
\n\n

\nReleases reference ref from the table at index t\n(see luaL_ref).\nThe entry is removed from the table,\nso that the referred object can be collected.\nThe reference ref is also freed to be used again.\n\n\n

\nIf ref is LUA_NOREF or LUA_REFNIL,\nluaL_unref does nothing.\n\n\n\n\n\n

luaL_where

\n[-0, +1, m]\n

void luaL_where (lua_State *L, int lvl);
\n\n

\nPushes onto the stack a string identifying the current position\nof the control at level lvl in the call stack.\nTypically this string has the following format:\n\n

\n     chunkname:currentline:\n

\nLevel 0 is the running function,\nlevel 1 is the function that called the running function,\netc.\n\n\n

\nThis function is used to build a prefix for error messages.\n\n\n\n\n\n\n\n

5 - Standard Libraries

\n\n

\nThe standard Lua libraries provide useful functions\nthat are implemented directly through the C API.\nSome of these functions provide essential services to the language\n(e.g., type and getmetatable);\nothers provide access to \"outside\" services (e.g., I/O);\nand others could be implemented in Lua itself,\nbut are quite useful or have critical performance requirements that\ndeserve an implementation in C (e.g., table.sort).\n\n\n

\nAll libraries are implemented through the official C API\nand are provided as separate C modules.\nCurrently, Lua has the following standard libraries:\n\n

    \n\n
  • basic library,
    • which includes the coroutine sub-library;\n\n
  • package library;
    • \n\n
  • string manipulation;
    • \n\n
  • table manipulation;
    • \n\n
  • mathematical functions (sin, log, etc.);
    • \n\n
  • input and output;
    • \n\n
  • operating system facilities;
    • \n\n
  • debug facilities.
    • \n\n

\nExcept for the basic and package libraries,\neach library provides all its functions as fields of a global table\nor as methods of its objects.\n\n\n

\nTo have access to these libraries,\nthe C host program should call the luaL_openlibs function,\nwhich opens all standard libraries.\nAlternatively,\nit can open them individually by calling\nluaopen_base (for the basic library),\nluaopen_package (for the package library),\nluaopen_string (for the string library),\nluaopen_table (for the table library),\nluaopen_math (for the mathematical library),\nluaopen_io (for the I/O library),\nluaopen_os (for the Operating System library),\nand luaopen_debug (for the debug library).\nThese functions are declared in lualib.h\nand should not be called directly:\nyou must call them like any other Lua C function,\ne.g., by using lua_call.\n\n\n\n

5.1 - Basic Functions

\n\n

\nThe basic library provides some core functions to Lua.\nIf you do not include this library in your application,\nyou should check carefully whether you need to provide \nimplementations for some of its facilities.\n\n\n

\n

assert (v [, message])

\nIssues an error when\nthe value of its argument v is false (i.e., nil or false);\notherwise, returns all its arguments.\nmessage is an error message;\nwhen absent, it defaults to \"assertion failed!\"\n\n\n\n\n

\n

collectgarbage (opt [, arg])

\n\n\n

\nThis function is a generic interface to the garbage collector.\nIt performs different functions according to its first argument, opt:\n\n

    \n\n
  • \"stop\":\nstops the garbage collector.\n
    • \n\n
  • \"restart\":\nrestarts the garbage collector.\n
    • \n\n
  • \"collect\":\nperforms a full garbage-collection cycle.\n
    • \n\n
  • \"count\":\nreturns the total memory in use by Lua (in Kbytes).\n
    • \n\n
  • \"step\":\nperforms a garbage-collection step.\nThe step \"size\" is controlled by arg\n(larger values mean more steps) in a non-specified way.\nIf you want to control the step size\nyou must experimentally tune the value of arg.\nReturns true if the step finished a collection cycle.\n
    • \n\n
  • \"setpause\":\nsets arg as the new value for the pause of\nthe collector (see §2.10).\nReturns the previous value for pause.\n
    • \n\n
  • \"setstepmul\":\nsets arg as the new value for the step multiplier of\nthe collector (see §2.10).\nReturns the previous value for step.\n
    • \n\n
\n\n\n\n

\n

dofile (filename)

\nOpens the named file and executes its contents as a Lua chunk.\nWhen called without arguments,\ndofile executes the contents of the standard input (stdin).\nReturns all values returned by the chunk.\nIn case of errors, dofile propagates the error\nto its caller (that is, dofile does not run in protected mode).\n\n\n\n\n

\n

error (message [, level])

\nTerminates the last protected function called\nand returns message as the error message.\nFunction error never returns.\n\n\n

\nUsually, error adds some information about the error position\nat the beginning of the message.\nThe level argument specifies how to get the error position.\nWith level 1 (the default), the error position is where the\nerror function was called.\nLevel 2 points the error to where the function\nthat called error was called; and so on.\nPassing a level 0 avoids the addition of error position information\nto the message.\n\n\n\n\n

\n

_G

\nA global variable (not a function) that\nholds the global environment (that is, _G._G = _G).\nLua itself does not use this variable;\nchanging its value does not affect any environment,\nnor vice-versa.\n(Use setfenv to change environments.)\n\n\n\n\n

\n

getfenv ([f])

\nReturns the current environment in use by the function.\nf can be a Lua function or a number\nthat specifies the function at that stack level:\nLevel 1 is the function calling getfenv.\nIf the given function is not a Lua function,\nor if f is 0,\ngetfenv returns the global environment.\nThe default for f is 1.\n\n\n\n\n

\n

getmetatable (object)

\n\n\n

\nIf object does not have a metatable, returns nil.\nOtherwise,\nif the object's metatable has a \"__metatable\" field,\nreturns the associated value.\nOtherwise, returns the metatable of the given object.\n\n\n\n\n

\n

ipairs (t)

\n\n\n

\nReturns three values: an iterator function, the table t, and 0,\nso that the construction\n\n

\n     for i,v in ipairs(t) do body end\n

\nwill iterate over the pairs (1,t[1]), (2,t[2]), ···,\nup to the first integer key absent from the table.\n\n\n\n\n

\n

load (func [, chunkname])

\n\n\n

\nLoads a chunk using function func to get its pieces.\nEach call to func must return a string that concatenates\nwith previous results.\nA return of an empty string, nil, or no value signals the end of the chunk.\n\n\n

\nIf there are no errors, \nreturns the compiled chunk as a function;\notherwise, returns nil plus the error message.\nThe environment of the returned function is the global environment.\n\n\n

\nchunkname is used as the chunk name for error messages\nand debug information.\nWhen absent,\nit defaults to \"=(load)\".\n\n\n\n\n

\n

loadfile ([filename])

\n\n\n

\nSimilar to load,\nbut gets the chunk from file filename\nor from the standard input,\nif no file name is given.\n\n\n\n\n

\n

loadstring (string [, chunkname])

\n\n\n

\nSimilar to load,\nbut gets the chunk from the given string.\n\n\n

\nTo load and run a given string, use the idiom\n\n

\n     assert(loadstring(s))()\n
\n\n

\nWhen absent,\nchunkname defaults to the given string.\n\n\n\n\n

\n

next (table [, index])

\n\n\n

\nAllows a program to traverse all fields of a table.\nIts first argument is a table and its second argument\nis an index in this table.\nnext returns the next index of the table\nand its associated value.\nWhen called with nil as its second argument,\nnext returns an initial index\nand its associated value.\nWhen called with the last index,\nor with nil in an empty table,\nnext returns nil.\nIf the second argument is absent, then it is interpreted as nil.\nIn particular,\nyou can use next(t) to check whether a table is empty.\n\n\n

\nThe order in which the indices are enumerated is not specified,\neven for numeric indices.\n(To traverse a table in numeric order,\nuse a numerical for or the ipairs function.)\n\n\n

\nThe behavior of next is undefined if,\nduring the traversal,\nyou assign any value to a non-existent field in the table.\nYou may however modify existing fields.\nIn particular, you may clear existing fields.\n\n\n\n\n

\n

pairs (t)

\n\n\n

\nReturns three values: the next function, the table t, and nil,\nso that the construction\n\n

\n     for k,v in pairs(t) do body end\n

\nwill iterate over all key–value pairs of table t.\n\n\n

\nSee function next for the caveats of modifying\nthe table during its traversal.\n\n\n\n\n

\n

pcall (f, arg1, ···)

\n\n\n

\nCalls function f with\nthe given arguments in protected mode.\nThis means that any error inside f is not propagated;\ninstead, pcall catches the error\nand returns a status code.\nIts first result is the status code (a boolean),\nwhich is true if the call succeeds without errors.\nIn such case, pcall also returns all results from the call,\nafter this first result.\nIn case of any error, pcall returns false plus the error message.\n\n\n\n\n

\n

print (···)

\nReceives any number of arguments,\nand prints their values to stdout,\nusing the tostring function to convert them to strings.\nprint is not intended for formatted output,\nbut only as a quick way to show a value,\ntypically for debugging.\nFor formatted output, use string.format.\n\n\n\n\n

\n

rawequal (v1, v2)

\nChecks whether v1 is equal to v2,\nwithout invoking any metamethod.\nReturns a boolean.\n\n\n\n\n

\n

rawget (table, index)

\nGets the real value of table[index],\nwithout invoking any metamethod.\ntable must be a table;\nindex may be any value.\n\n\n\n\n

\n

rawset (table, index, value)

\nSets the real value of table[index] to value,\nwithout invoking any metamethod.\ntable must be a table,\nindex any value different from nil,\nand value any Lua value.\n\n\n

\nThis function returns table.\n\n\n\n\n

\n

select (index, ···)

\n\n\n

\nIf index is a number,\nreturns all arguments after argument number index.\nOtherwise, index must be the string \"#\",\nand select returns the total number of extra arguments it received.\n\n\n\n\n

\n

setfenv (f, table)

\n\n\n

\nSets the environment to be used by the given function.\nf can be a Lua function or a number\nthat specifies the function at that stack level:\nLevel 1 is the function calling setfenv.\nsetfenv returns the given function.\n\n\n

\nAs a special case, when f is 0 setfenv changes\nthe environment of the running thread.\nIn this case, setfenv returns no values.\n\n\n\n\n

\n

setmetatable (table, metatable)

\n\n\n

\nSets the metatable for the given table.\n(You cannot change the metatable of other types from Lua, only from C.)\nIf metatable is nil,\nremoves the metatable of the given table.\nIf the original metatable has a \"__metatable\" field,\nraises an error.\n\n\n

\nThis function returns table.\n\n\n\n\n

\n

tonumber (e [, base])

\nTries to convert its argument to a number.\nIf the argument is already a number or a string convertible\nto a number, then tonumber returns this number;\notherwise, it returns nil.\n\n\n

\nAn optional argument specifies the base to interpret the numeral.\nThe base may be any integer between 2 and 36, inclusive.\nIn bases above 10, the letter 'A' (in either upper or lower case)\nrepresents 10, 'B' represents 11, and so forth,\nwith 'Z' representing 35.\nIn base 10 (the default), the number can have a decimal part,\nas well as an optional exponent part (see §2.1).\nIn other bases, only unsigned integers are accepted.\n\n\n\n\n

\n

tostring (e)

\nReceives an argument of any type and\nconverts it to a string in a reasonable format.\nFor complete control of how numbers are converted,\nuse string.format.\n\n\n

\nIf the metatable of e has a \"__tostring\" field,\nthen tostring calls the corresponding value\nwith e as argument,\nand uses the result of the call as its result.\n\n\n\n\n

\n

type (v)

\nReturns the type of its only argument, coded as a string.\nThe possible results of this function are\n\"nil\" (a string, not the value nil),\n\"number\",\n\"string\",\n\"boolean\",\n\"table\",\n\"function\",\n\"thread\",\nand \"userdata\".\n\n\n\n\n

\n

unpack (list [, i [, j]])

\nReturns the elements from the given table.\nThis function is equivalent to\n\n
\n     return list[i], list[i+1], ···, list[j]\n

\nexcept that the above code can be written only for a fixed number\nof elements.\nBy default, i is 1 and j is the length of the list,\nas defined by the length operator (see §2.5.5).\n\n\n\n\n

\n

_VERSION

\nA global variable (not a function) that\nholds a string containing the current interpreter version.\nThe current contents of this variable is \"Lua 5.1\".\n\n\n\n\n

\n

xpcall (f, err)

\n\n\n

\nThis function is similar to pcall,\nexcept that you can set a new error handler.\n\n\n

\nxpcall calls function f in protected mode,\nusing err as the error handler.\nAny error inside f is not propagated;\ninstead, xpcall catches the error,\ncalls the err function with the original error object,\nand returns a status code.\nIts first result is the status code (a boolean),\nwhich is true if the call succeeds without errors.\nIn this case, xpcall also returns all results from the call,\nafter this first result.\nIn case of any error,\nxpcall returns false plus the result from err.\n\n\n\n\n\n\n\n

5.2 - Coroutine Manipulation

\n\n

\nThe operations related to coroutines comprise a sub-library of\nthe basic library and come inside the table coroutine.\nSee §2.11 for a general description of coroutines.\n\n\n

\n

coroutine.create (f)

\n\n\n

\nCreates a new coroutine, with body f.\nf must be a Lua function.\nReturns this new coroutine,\nan object with type \"thread\".\n\n\n\n\n

\n

coroutine.resume (co [, val1, ···])

\n\n\n

\nStarts or continues the execution of coroutine co.\nThe first time you resume a coroutine,\nit starts running its body.\nThe values val1, ··· are passed\nas the arguments to the body function.\nIf the coroutine has yielded,\nresume restarts it;\nthe values val1, ··· are passed\nas the results from the yield.\n\n\n

\nIf the coroutine runs without any errors,\nresume returns true plus any values passed to yield\n(if the coroutine yields) or any values returned by the body function\n(if the coroutine terminates).\nIf there is any error,\nresume returns false plus the error message.\n\n\n\n\n

\n

coroutine.running ()

\n\n\n

\nReturns the running coroutine,\nor nil when called by the main thread.\n\n\n\n\n

\n

coroutine.status (co)

\n\n\n

\nReturns the status of coroutine co, as a string:\n\"running\",\nif the coroutine is running (that is, it called status);\n\"suspended\", if the coroutine is suspended in a call to yield,\nor if it has not started running yet;\n\"normal\" if the coroutine is active but not running\n(that is, it has resumed another coroutine);\nand \"dead\" if the coroutine has finished its body function,\nor if it has stopped with an error.\n\n\n\n\n

\n

coroutine.wrap (f)

\n\n\n

\nCreates a new coroutine, with body f.\nf must be a Lua function.\nReturns a function that resumes the coroutine each time it is called.\nAny arguments passed to the function behave as the\nextra arguments to resume.\nReturns the same values returned by resume,\nexcept the first boolean.\nIn case of error, propagates the error.\n\n\n\n\n

\n

coroutine.yield (···)

\n\n\n

\nSuspends the execution of the calling coroutine.\nThe coroutine cannot be running a C function,\na metamethod, or an iterator.\nAny arguments to yield are passed as extra results to resume.\n\n\n\n\n\n\n\n

5.3 - Modules

\n\n

\nThe package library provides basic\nfacilities for loading and building modules in Lua.\nIt exports two of its functions directly in the global environment:\nrequire and module.\nEverything else is exported in a table package.\n\n\n

\n

module (name [, ···])

\n\n\n

\nCreates a module.\nIf there is a table in package.loaded[name],\nthis table is the module.\nOtherwise, if there is a global table t with the given name,\nthis table is the module.\nOtherwise creates a new table t and\nsets it as the value of the global name and\nthe value of package.loaded[name].\nThis function also initializes t._NAME with the given name,\nt._M with the module (t itself),\nand t._PACKAGE with the package name\n(the full module name minus last component; see below).\nFinally, module sets t as the new environment\nof the current function and the new value of package.loaded[name],\nso that require returns t.\n\n\n

\nIf name is a compound name\n(that is, one with components separated by dots),\nmodule creates (or reuses, if they already exist)\ntables for each component.\nFor instance, if name is a.b.c,\nthen module stores the module table in field c of\nfield b of global a.\n\n\n

\nThis function can receive optional options after\nthe module name,\nwhere each option is a function to be applied over the module.\n\n\n\n\n

\n

require (modname)

\n\n\n

\nLoads the given module.\nThe function starts by looking into the package.loaded table\nto determine whether modname is already loaded.\nIf it is, then require returns the value stored\nat package.loaded[modname].\nOtherwise, it tries to find a loader for the module.\n\n\n

\nTo find a loader,\nrequire is guided by the package.loaders array.\nBy changing this array,\nwe can change how require looks for a module.\nThe following explanation is based on the default configuration\nfor package.loaders.\n\n\n

\nFirst require queries package.preload[modname].\nIf it has a value,\nthis value (which should be a function) is the loader.\nOtherwise require searches for a Lua loader using the\npath stored in package.path.\nIf that also fails, it searches for a C loader using the\npath stored in package.cpath.\nIf that also fails,\nit tries an all-in-one loader (see package.loaders).\n\n\n

\nOnce a loader is found,\nrequire calls the loader with a single argument, modname.\nIf the loader returns any value,\nrequire assigns the returned value to package.loaded[modname].\nIf the loader returns no value and\nhas not assigned any value to package.loaded[modname],\nthen require assigns true to this entry.\nIn any case, require returns the\nfinal value of package.loaded[modname].\n\n\n

\nIf there is any error loading or running the module,\nor if it cannot find any loader for the module,\nthen require signals an error. \n\n\n\n\n

\n

package.cpath

\n\n\n

\nThe path used by require to search for a C loader.\n\n\n

\nLua initializes the C path package.cpath in the same way\nit initializes the Lua path package.path,\nusing the environment variable LUA_CPATH\nor a default path defined in luaconf.h.\n\n\n\n\n

\n\n

package.loaded

\n\n\n

\nA table used by require to control which\nmodules are already loaded.\nWhen you require a module modname and\npackage.loaded[modname] is not false,\nrequire simply returns the value stored there.\n\n\n\n\n

\n

package.loaders

\n\n\n

\nA table used by require to control how to load modules.\n\n\n

\nEach entry in this table is a searcher function.\nWhen looking for a module,\nrequire calls each of these searchers in ascending order,\nwith the module name (the argument given to require) as its\nsole parameter.\nThe function can return another function (the module loader)\nor a string explaining why it did not find that module\n(or nil if it has nothing to say).\nLua initializes this table with four functions.\n\n\n

\nThe first searcher simply looks for a loader in the\npackage.preload table.\n\n\n

\nThe second searcher looks for a loader as a Lua library,\nusing the path stored at package.path.\nA path is a sequence of templates separated by semicolons.\nFor each template,\nthe searcher will change each interrogation\nmark in the template by filename,\nwhich is the module name with each dot replaced by a\n\"directory separator\" (such as \"/\" in Unix);\nthen it will try to open the resulting file name.\nSo, for instance, if the Lua path is the string\n\n

\n     \"./?.lua;./?.lc;/usr/local/?/init.lua\"\n

\nthe search for a Lua file for module foo\nwill try to open the files\n./foo.lua, ./foo.lc, and\n/usr/local/foo/init.lua, in that order.\n\n\n

\nThe third searcher looks for a loader as a C library,\nusing the path given by the variable package.cpath.\nFor instance,\nif the C path is the string\n\n

\n     \"./?.so;./?.dll;/usr/local/?/init.so\"\n

\nthe searcher for module foo\nwill try to open the files ./foo.so, ./foo.dll,\nand /usr/local/foo/init.so, in that order.\nOnce it finds a C library,\nthis searcher first uses a dynamic link facility to link the\napplication with the library.\nThen it tries to find a C function inside the library to\nbe used as the loader.\nThe name of this C function is the string \"luaopen_\"\nconcatenated with a copy of the module name where each dot\nis replaced by an underscore.\nMoreover, if the module name has a hyphen,\nits prefix up to (and including) the first hyphen is removed.\nFor instance, if the module name is a.v1-b.c,\nthe function name will be luaopen_b_c.\n\n\n

\nThe fourth searcher tries an all-in-one loader.\nIt searches the C path for a library for\nthe root name of the given module.\nFor instance, when requiring a.b.c,\nit will search for a C library for a.\nIf found, it looks into it for an open function for\nthe submodule;\nin our example, that would be luaopen_a_b_c.\nWith this facility, a package can pack several C submodules\ninto one single library,\nwith each submodule keeping its original open function.\n\n\n\n\n

\n

package.loadlib (libname, funcname)

\n\n\n

\nDynamically links the host program with the C library libname.\nInside this library, looks for a function funcname\nand returns this function as a C function.\n(So, funcname must follow the protocol (see lua_CFunction)).\n\n\n

\nThis is a low-level function.\nIt completely bypasses the package and module system.\nUnlike require,\nit does not perform any path searching and\ndoes not automatically adds extensions.\nlibname must be the complete file name of the C library,\nincluding if necessary a path and extension.\nfuncname must be the exact name exported by the C library\n(which may depend on the C compiler and linker used).\n\n\n

\nThis function is not supported by ANSI C.\nAs such, it is only available on some platforms\n(Windows, Linux, Mac OS X, Solaris, BSD,\nplus other Unix systems that support the dlfcn standard).\n\n\n\n\n

\n

package.path

\n\n\n

\nThe path used by require to search for a Lua loader.\n\n\n

\nAt start-up, Lua initializes this variable with\nthe value of the environment variable LUA_PATH or\nwith a default path defined in luaconf.h,\nif the environment variable is not defined.\nAny \";;\" in the value of the environment variable\nis replaced by the default path.\n\n\n\n\n

\n

package.preload

\n\n\n

\nA table to store loaders for specific modules\n(see require).\n\n\n\n\n

\n

package.seeall (module)

\n\n\n

\nSets a metatable for module with\nits __index field referring to the global environment,\nso that this module inherits values\nfrom the global environment.\nTo be used as an option to function module.\n\n\n\n\n\n\n\n

5.4 - String Manipulation

\n\n

\nThis library provides generic functions for string manipulation,\nsuch as finding and extracting substrings, and pattern matching.\nWhen indexing a string in Lua, the first character is at position 1\n(not at 0, as in C).\nIndices are allowed to be negative and are interpreted as indexing backwards,\nfrom the end of the string.\nThus, the last character is at position -1, and so on.\n\n\n

\nThe string library provides all its functions inside the table\nstring.\nIt also sets a metatable for strings\nwhere the __index field points to the string table.\nTherefore, you can use the string functions in object-oriented style.\nFor instance, string.byte(s, i)\ncan be written as s:byte(i).\n\n\n

\nThe string library assumes one-byte character encodings.\n\n\n

\n

string.byte (s [, i [, j]])

\nReturns the internal numerical codes of the characters s[i],\ns[i+1], ···, s[j].\nThe default value for i is 1;\nthe default value for j is i.\n\n\n

\nNote that numerical codes are not necessarily portable across platforms.\n\n\n\n\n

\n

string.char (···)

\nReceives zero or more integers.\nReturns a string with length equal to the number of arguments,\nin which each character has the internal numerical code equal\nto its corresponding argument.\n\n\n

\nNote that numerical codes are not necessarily portable across platforms.\n\n\n\n\n

\n

string.dump (function)

\n\n\n

\nReturns a string containing a binary representation of the given function,\nso that a later loadstring on this string returns\na copy of the function.\nfunction must be a Lua function without upvalues.\n\n\n\n\n

\n

string.find (s, pattern [, init [, plain]])

\nLooks for the first match of\npattern in the string s.\nIf it finds a match, then find returns the indices of s\nwhere this occurrence starts and ends;\notherwise, it returns nil.\nA third, optional numerical argument init specifies\nwhere to start the search;\nits default value is 1 and can be negative.\nA value of true as a fourth, optional argument plain\nturns off the pattern matching facilities,\nso the function does a plain \"find substring\" operation,\nwith no characters in pattern being considered \"magic\".\nNote that if plain is given, then init must be given as well.\n\n\n

\nIf the pattern has captures,\nthen in a successful match\nthe captured values are also returned,\nafter the two indices.\n\n\n\n\n

\n

string.format (formatstring, ···)

\nReturns a formatted version of its variable number of arguments\nfollowing the description given in its first argument (which must be a string).\nThe format string follows the same rules as the printf family of\nstandard C functions.\nThe only differences are that the options/modifiers\n*, l, L, n, p,\nand h are not supported\nand that there is an extra option, q.\nThe q option formats a string in a form suitable to be safely read\nback by the Lua interpreter:\nthe string is written between double quotes,\nand all double quotes, newlines, embedded zeros,\nand backslashes in the string\nare correctly escaped when written.\nFor instance, the call\n\n
\n     string.format('%q', 'a string with \"quotes\" and \\n new line')\n

\nwill produce the string:\n\n

\n     \"a string with \\\"quotes\\\" and \\\n      new line\"\n
\n\n

\nThe options c, d, E, e, f,\ng, G, i, o, u, X, and x all\nexpect a number as argument,\nwhereas q and s expect a string.\n\n\n

\nThis function does not accept string values\ncontaining embedded zeros,\nexcept as arguments to the q option.\n\n\n\n\n

\n

string.gmatch (s, pattern)

\nReturns an iterator function that,\neach time it is called,\nreturns the next captures from pattern over string s.\nIf pattern specifies no captures,\nthen the whole match is produced in each call.\n\n\n

\nAs an example, the following loop\n\n

\n     s = \"hello world from Lua\"\n     for w in string.gmatch(s, \"%a+\") do\n       print(w)\n     end\n

\nwill iterate over all the words from string s,\nprinting one per line.\nThe next example collects all pairs key=value from the\ngiven string into a table:\n\n

\n     t = {}\n     s = \"from=world, to=Lua\"\n     for k, v in string.gmatch(s, \"(%w+)=(%w+)\") do\n       t[k] = v\n     end\n
\n\n

\nFor this function, a '^' at the start of a pattern does not\nwork as an anchor, as this would prevent the iteration.\n\n\n\n\n

\n

string.gsub (s, pattern, repl [, n])

\nReturns a copy of s\nin which all (or the first n, if given)\noccurrences of the pattern have been\nreplaced by a replacement string specified by repl,\nwhich can be a string, a table, or a function.\ngsub also returns, as its second value,\nthe total number of matches that occurred.\n\n\n

\nIf repl is a string, then its value is used for replacement.\nThe character % works as an escape character:\nany sequence in repl of the form %n,\nwith n between 1 and 9,\nstands for the value of the n-th captured substring (see below).\nThe sequence %0 stands for the whole match.\nThe sequence %% stands for a single %.\n\n\n

\nIf repl is a table, then the table is queried for every match,\nusing the first capture as the key;\nif the pattern specifies no captures,\nthen the whole match is used as the key.\n\n\n

\nIf repl is a function, then this function is called every time a\nmatch occurs, with all captured substrings passed as arguments,\nin order;\nif the pattern specifies no captures,\nthen the whole match is passed as a sole argument.\n\n\n

\nIf the value returned by the table query or by the function call\nis a string or a number,\nthen it is used as the replacement string;\notherwise, if it is false or nil,\nthen there is no replacement\n(that is, the original match is kept in the string).\n\n\n

\nHere are some examples:\n\n

\n     x = string.gsub(\"hello world\", \"(%w+)\", \"%1 %1\")\n     --> x=\"hello hello world world\"\n     \n     x = string.gsub(\"hello world\", \"%w+\", \"%0 %0\", 1)\n     --> x=\"hello hello world\"\n     \n     x = string.gsub(\"hello world from Lua\", \"(%w+)%s*(%w+)\", \"%2 %1\")\n     --> x=\"world hello Lua from\"\n     \n     x = string.gsub(\"home = $HOME, user = $USER\", \"%$(%w+)\", os.getenv)\n     --> x=\"home = /home/roberto, user = roberto\"\n     \n     x = string.gsub(\"4+5 = $return 4+5$\", \"%$(.-)%$\", function (s)\n           return loadstring(s)()\n         end)\n     --> x=\"4+5 = 9\"\n     \n     local t = {name=\"lua\", version=\"5.1\"}\n     x = string.gsub(\"$name-$version.tar.gz\", \"%$(%w+)\", t)\n     --> x=\"lua-5.1.tar.gz\"\n
\n\n\n\n

\n

string.len (s)

\nReceives a string and returns its length.\nThe empty string \"\" has length 0.\nEmbedded zeros are counted,\nso \"a\\000bc\\000\" has length 5.\n\n\n\n\n

\n

string.lower (s)

\nReceives a string and returns a copy of this string with all\nuppercase letters changed to lowercase.\nAll other characters are left unchanged.\nThe definition of what an uppercase letter is depends on the current locale.\n\n\n\n\n

\n

string.match (s, pattern [, init])

\nLooks for the first match of\npattern in the string s.\nIf it finds one, then match returns\nthe captures from the pattern;\notherwise it returns nil.\nIf pattern specifies no captures,\nthen the whole match is returned.\nA third, optional numerical argument init specifies\nwhere to start the search;\nits default value is 1 and can be negative.\n\n\n\n\n

\n

string.rep (s, n)

\nReturns a string that is the concatenation of n copies of\nthe string s.\n\n\n\n\n

\n

string.reverse (s)

\nReturns a string that is the string s reversed.\n\n\n\n\n

\n

string.sub (s, i [, j])

\nReturns the substring of s that\nstarts at i and continues until j;\ni and j can be negative.\nIf j is absent, then it is assumed to be equal to -1\n(which is the same as the string length).\nIn particular,\nthe call string.sub(s,1,j) returns a prefix of s\nwith length j,\nand string.sub(s, -i) returns a suffix of s\nwith length i.\n\n\n\n\n

\n

string.upper (s)

\nReceives a string and returns a copy of this string with all\nlowercase letters changed to uppercase.\nAll other characters are left unchanged.\nThe definition of what a lowercase letter is depends on the current locale.\n\n\n\n

5.4.1 - Patterns

\n\n\n

Character Class:

\nA character class is used to represent a set of characters.\nThe following combinations are allowed in describing a character class:\n\n

    \n\n
  • x:\n(where x is not one of the magic characters\n^$()%.[]*+-?)\nrepresents the character x itself.\n
    • \n\n
  • .: (a dot) represents all characters.
    • \n\n
  • %a: represents all letters.
    • \n\n
  • %c: represents all control characters.
    • \n\n
  • %d: represents all digits.
    • \n\n
  • %l: represents all lowercase letters.
    • \n\n
  • %p: represents all punctuation characters.
    • \n\n
  • %s: represents all space characters.
    • \n\n
  • %u: represents all uppercase letters.
    • \n\n
  • %w: represents all alphanumeric characters.
    • \n\n
  • %x: represents all hexadecimal digits.
    • \n\n
  • %z: represents the character with representation 0.
    • \n\n
  • %x: (where x is any non-alphanumeric character)\nrepresents the character x.\nThis is the standard way to escape the magic characters.\nAny punctuation character (even the non magic)\ncan be preceded by a '%'\nwhen used to represent itself in a pattern.\n
    • \n\n
  • [set]:\nrepresents the class which is the union of all\ncharacters in set.\nA range of characters can be specified by\nseparating the end characters of the range with a '-'.\nAll classes %x described above can also be used as\ncomponents in set.\nAll other characters in set represent themselves.\nFor example, [%w_] (or [_%w])\nrepresents all alphanumeric characters plus the underscore,\n[0-7] represents the octal digits,\nand [0-7%l%-] represents the octal digits plus\nthe lowercase letters plus the '-' character.\n\n\n

    \nThe interaction between ranges and classes is not defined.\nTherefore, patterns like [%a-z] or [a-%%]\nhave no meaning.\n

    • \n\n
  • [^set]:\nrepresents the complement of set,\nwhere set is interpreted as above.\n
    • \n\n

\nFor all classes represented by single letters (%a, %c, etc.),\nthe corresponding uppercase letter represents the complement of the class.\nFor instance, %S represents all non-space characters.\n\n\n

\nThe definitions of letter, space, and other character groups\ndepend on the current locale.\nIn particular, the class [a-z] may not be equivalent to %l.\n\n\n\n\n\n

Pattern Item:

\nA pattern item can be\n\n

    \n\n
  • \na single character class,\nwhich matches any single character in the class;\n
    • \n\n
  • \na single character class followed by '*',\nwhich matches 0 or more repetitions of characters in the class.\nThese repetition items will always match the longest possible sequence;\n
    • \n\n
  • \na single character class followed by '+',\nwhich matches 1 or more repetitions of characters in the class.\nThese repetition items will always match the longest possible sequence;\n
    • \n\n
  • \na single character class followed by '-',\nwhich also matches 0 or more repetitions of characters in the class.\nUnlike '*',\nthese repetition items will always match the shortest possible sequence;\n
    • \n\n
  • \na single character class followed by '?',\nwhich matches 0 or 1 occurrence of a character in the class;\n
    • \n\n
  • \n%n, for n between 1 and 9;\nsuch item matches a substring equal to the n-th captured string\n(see below);\n
    • \n\n
  • \n%bxy, where x and y are two distinct characters;\nsuch item matches strings that start with x, end with y,\nand where the x and y are balanced.\nThis means that, if one reads the string from left to right,\ncounting +1 for an x and -1 for a y,\nthe ending y is the first y where the count reaches 0.\nFor instance, the item %b() matches expressions with\nbalanced parentheses.\n
    • \n\n
\n\n\n\n\n

Pattern:

\nA pattern is a sequence of pattern items.\nA '^' at the beginning of a pattern anchors the match at the\nbeginning of the subject string.\nA '$' at the end of a pattern anchors the match at the\nend of the subject string.\nAt other positions,\n'^' and '$' have no special meaning and represent themselves.\n\n\n\n\n\n

Captures:

\nA pattern can contain sub-patterns enclosed in parentheses;\nthey describe captures.\nWhen a match succeeds, the substrings of the subject string\nthat match captures are stored (captured) for future use.\nCaptures are numbered according to their left parentheses.\nFor instance, in the pattern \"(a*(.)%w(%s*))\",\nthe part of the string matching \"a*(.)%w(%s*)\" is\nstored as the first capture (and therefore has number 1);\nthe character matching \".\" is captured with number 2,\nand the part matching \"%s*\" has number 3.\n\n\n

\nAs a special case, the empty capture () captures\nthe current string position (a number).\nFor instance, if we apply the pattern \"()aa()\" on the\nstring \"flaaap\", there will be two captures: 3 and 5.\n\n\n

\nA pattern cannot contain embedded zeros. Use %z instead.\n\n\n\n\n\n\n\n\n\n\n\n

5.5 - Table Manipulation

\nThis library provides generic functions for table manipulation.\nIt provides all its functions inside the table table.\n\n\n

\nMost functions in the table library assume that the table\nrepresents an array or a list.\nFor these functions, when we talk about the \"length\" of a table\nwe mean the result of the length operator.\n\n\n

\n

table.concat (table [, sep [, i [, j]]])

\nGiven an array where all elements are strings or numbers,\nreturns table[i]..sep..table[i+1] ··· sep..table[j].\nThe default value for sep is the empty string,\nthe default for i is 1,\nand the default for j is the length of the table.\nIf i is greater than j, returns the empty string.\n\n\n\n\n

\n

table.insert (table, [pos,] value)

\n\n\n

\nInserts element value at position pos in table,\nshifting up other elements to open space, if necessary.\nThe default value for pos is n+1,\nwhere n is the length of the table (see §2.5.5),\nso that a call table.insert(t,x) inserts x at the end\nof table t.\n\n\n\n\n

\n

table.maxn (table)

\n\n\n

\nReturns the largest positive numerical index of the given table,\nor zero if the table has no positive numerical indices.\n(To do its job this function does a linear traversal of\nthe whole table.) \n\n\n\n\n

\n

table.remove (table [, pos])

\n\n\n

\nRemoves from table the element at position pos,\nshifting down other elements to close the space, if necessary.\nReturns the value of the removed element.\nThe default value for pos is n,\nwhere n is the length of the table,\nso that a call table.remove(t) removes the last element\nof table t.\n\n\n\n\n

\n

table.sort (table [, comp])

\nSorts table elements in a given order, in-place,\nfrom table[1] to table[n],\nwhere n is the length of the table.\nIf comp is given,\nthen it must be a function that receives two table elements,\nand returns true\nwhen the first is less than the second\n(so that not comp(a[i+1],a[i]) will be true after the sort).\nIf comp is not given,\nthen the standard Lua operator < is used instead.\n\n\n

\nThe sort algorithm is not stable;\nthat is, elements considered equal by the given order\nmay have their relative positions changed by the sort.\n\n\n\n\n\n\n\n

5.6 - Mathematical Functions

\n\n

\nThis library is an interface to the standard C math library.\nIt provides all its functions inside the table math.\n\n\n

\n

math.abs (x)

\n\n\n

\nReturns the absolute value of x.\n\n\n\n\n

\n

math.acos (x)

\n\n\n

\nReturns the arc cosine of x (in radians).\n\n\n\n\n

\n

math.asin (x)

\n\n\n

\nReturns the arc sine of x (in radians).\n\n\n\n\n

\n

math.atan (x)

\n\n\n

\nReturns the arc tangent of x (in radians).\n\n\n\n\n

\n

math.atan2 (y, x)

\n\n\n

\nReturns the arc tangent of y/x (in radians),\nbut uses the signs of both parameters to find the\nquadrant of the result.\n(It also handles correctly the case of x being zero.)\n\n\n\n\n

\n

math.ceil (x)

\n\n\n

\nReturns the smallest integer larger than or equal to x.\n\n\n\n\n

\n

math.cos (x)

\n\n\n

\nReturns the cosine of x (assumed to be in radians).\n\n\n\n\n

\n

math.cosh (x)

\n\n\n

\nReturns the hyperbolic cosine of x.\n\n\n\n\n

\n

math.deg (x)

\n\n\n

\nReturns the angle x (given in radians) in degrees.\n\n\n\n\n

\n

math.exp (x)

\n\n\n

\nReturns the value ex.\n\n\n\n\n

\n

math.floor (x)

\n\n\n

\nReturns the largest integer smaller than or equal to x.\n\n\n\n\n

\n

math.fmod (x, y)

\n\n\n

\nReturns the remainder of the division of x by y\nthat rounds the quotient towards zero.\n\n\n\n\n

\n

math.frexp (x)

\n\n\n

\nReturns m and e such that x = m2e,\ne is an integer and the absolute value of m is\nin the range [0.5, 1)\n(or zero when x is zero).\n\n\n\n\n

\n

math.huge

\n\n\n

\nThe value HUGE_VAL,\na value larger than or equal to any other numerical value.\n\n\n\n\n

\n

math.ldexp (m, e)

\n\n\n

\nReturns m2e (e should be an integer).\n\n\n\n\n

\n

math.log (x)

\n\n\n

\nReturns the natural logarithm of x.\n\n\n\n\n

\n

math.log10 (x)

\n\n\n

\nReturns the base-10 logarithm of x.\n\n\n\n\n

\n

math.max (x, ···)

\n\n\n

\nReturns the maximum value among its arguments.\n\n\n\n\n

\n

math.min (x, ···)

\n\n\n

\nReturns the minimum value among its arguments.\n\n\n\n\n

\n

math.modf (x)

\n\n\n

\nReturns two numbers,\nthe integral part of x and the fractional part of x.\n\n\n\n\n

\n

math.pi

\n\n\n

\nThe value of pi.\n\n\n\n\n

\n

math.pow (x, y)

\n\n\n

\nReturns xy.\n(You can also use the expression x^y to compute this value.)\n\n\n\n\n

\n

math.rad (x)

\n\n\n

\nReturns the angle x (given in degrees) in radians.\n\n\n\n\n

\n

math.random ([m [, n]])

\n\n\n

\nThis function is an interface to the simple\npseudo-random generator function rand provided by ANSI C.\n(No guarantees can be given for its statistical properties.)\n\n\n

\nWhen called without arguments,\nreturns a uniform pseudo-random real number\nin the range [0,1). \nWhen called with an integer number m,\nmath.random returns\na uniform pseudo-random integer in the range [1, m].\nWhen called with two integer numbers m and n,\nmath.random returns a uniform pseudo-random\ninteger in the range [m, n].\n\n\n\n\n

\n

math.randomseed (x)

\n\n\n

\nSets x as the \"seed\"\nfor the pseudo-random generator:\nequal seeds produce equal sequences of numbers.\n\n\n\n\n

\n

math.sin (x)

\n\n\n

\nReturns the sine of x (assumed to be in radians).\n\n\n\n\n

\n

math.sinh (x)

\n\n\n

\nReturns the hyperbolic sine of x.\n\n\n\n\n

\n

math.sqrt (x)

\n\n\n

\nReturns the square root of x.\n(You can also use the expression x^0.5 to compute this value.)\n\n\n\n\n

\n

math.tan (x)

\n\n\n

\nReturns the tangent of x (assumed to be in radians).\n\n\n\n\n

\n

math.tanh (x)

\n\n\n

\nReturns the hyperbolic tangent of x.\n\n\n\n\n\n\n\n

5.7 - Input and Output Facilities

\n\n

\nThe I/O library provides two different styles for file manipulation.\nThe first one uses implicit file descriptors;\nthat is, there are operations to set a default input file and a\ndefault output file,\nand all input/output operations are over these default files.\nThe second style uses explicit file descriptors.\n\n\n

\nWhen using implicit file descriptors,\nall operations are supplied by table io.\nWhen using explicit file descriptors,\nthe operation io.open returns a file descriptor\nand then all operations are supplied as methods of the file descriptor.\n\n\n

\nThe table io also provides\nthree predefined file descriptors with their usual meanings from C:\nio.stdin, io.stdout, and io.stderr.\nThe I/O library never closes these files.\n\n\n

\nUnless otherwise stated,\nall I/O functions return nil on failure\n(plus an error message as a second result and\na system-dependent error code as a third result)\nand some value different from nil on success.\n\n\n

\n

io.close ([file])

\n\n\n

\nEquivalent to file:close().\nWithout a file, closes the default output file.\n\n\n\n\n

\n

io.flush ()

\n\n\n

\nEquivalent to file:flush over the default output file.\n\n\n\n\n

\n

io.input ([file])

\n\n\n

\nWhen called with a file name, it opens the named file (in text mode),\nand sets its handle as the default input file.\nWhen called with a file handle,\nit simply sets this file handle as the default input file.\nWhen called without parameters,\nit returns the current default input file.\n\n\n

\nIn case of errors this function raises the error,\ninstead of returning an error code.\n\n\n\n\n

\n

io.lines ([filename])

\n\n\n

\nOpens the given file name in read mode\nand returns an iterator function that,\neach time it is called,\nreturns a new line from the file.\nTherefore, the construction\n\n

\n     for line in io.lines(filename) do body end\n

\nwill iterate over all lines of the file.\nWhen the iterator function detects the end of file,\nit returns nil (to finish the loop) and automatically closes the file.\n\n\n

\nThe call io.lines() (with no file name) is equivalent\nto io.input():lines();\nthat is, it iterates over the lines of the default input file.\nIn this case it does not close the file when the loop ends.\n\n\n\n\n

\n

io.open (filename [, mode])

\n\n\n

\nThis function opens a file,\nin the mode specified in the string mode.\nIt returns a new file handle,\nor, in case of errors, nil plus an error message.\n\n\n

\nThe mode string can be any of the following:\n\n

    \n
  • \"r\": read mode (the default);
    • \n
  • \"w\": write mode;
    • \n
  • \"a\": append mode;
    • \n
  • \"r+\": update mode, all previous data is preserved;
    • \n
  • \"w+\": update mode, all previous data is erased;
    • \n
  • \"a+\": append update mode, previous data is preserved,\n writing is only allowed at the end of file.
    • \n

\nThe mode string can also have a 'b' at the end,\nwhich is needed in some systems to open the file in binary mode.\nThis string is exactly what is used in the\nstandard C function fopen.\n\n\n\n\n

\n

io.output ([file])

\n\n\n

\nSimilar to io.input, but operates over the default output file.\n\n\n\n\n

\n

io.popen (prog [, mode])

\n\n\n

\nStarts program prog in a separated process and returns\na file handle that you can use to read data from this program\n(if mode is \"r\", the default)\nor to write data to this program\n(if mode is \"w\").\n\n\n

\nThis function is system dependent and is not available\non all platforms.\n\n\n\n\n

\n

io.read (···)

\n\n\n

\nEquivalent to io.input():read.\n\n\n\n\n

\n

io.tmpfile ()

\n\n\n

\nReturns a handle for a temporary file.\nThis file is opened in update mode\nand it is automatically removed when the program ends.\n\n\n\n\n

\n

io.type (obj)

\n\n\n

\nChecks whether obj is a valid file handle.\nReturns the string \"file\" if obj is an open file handle,\n\"closed file\" if obj is a closed file handle,\nor nil if obj is not a file handle.\n\n\n\n\n

\n

io.write (···)

\n\n\n

\nEquivalent to io.output():write.\n\n\n\n\n

\n

file:close ()

\n\n\n

\nCloses file.\nNote that files are automatically closed when\ntheir handles are garbage collected,\nbut that takes an unpredictable amount of time to happen.\n\n\n\n\n

\n

file:flush ()

\n\n\n

\nSaves any written data to file.\n\n\n\n\n

\n

file:lines ()

\n\n\n

\nReturns an iterator function that,\neach time it is called,\nreturns a new line from the file.\nTherefore, the construction\n\n

\n     for line in file:lines() do body end\n

\nwill iterate over all lines of the file.\n(Unlike io.lines, this function does not close the file\nwhen the loop ends.)\n\n\n\n\n

\n

file:read (···)

\n\n\n

\nReads the file file,\naccording to the given formats, which specify what to read.\nFor each format,\nthe function returns a string (or a number) with the characters read,\nor nil if it cannot read data with the specified format.\nWhen called without formats,\nit uses a default format that reads the entire next line\n(see below).\n\n\n

\nThe available formats are\n\n

    \n\n
  • \"*n\":\nreads a number;\nthis is the only format that returns a number instead of a string.\n
    • \n\n
  • \"*a\":\nreads the whole file, starting at the current position.\nOn end of file, it returns the empty string.\n
    • \n\n
  • \"*l\":\nreads the next line (skipping the end of line),\nreturning nil on end of file.\nThis is the default format.\n
    • \n\n
  • number:\nreads a string with up to this number of characters,\nreturning nil on end of file.\nIf number is zero,\nit reads nothing and returns an empty string,\nor nil on end of file.\n
    • \n\n
\n\n\n\n

\n

file:seek ([whence] [, offset])

\n\n\n

\nSets and gets the file position,\nmeasured from the beginning of the file,\nto the position given by offset plus a base\nspecified by the string whence, as follows:\n\n

    \n
  • \"set\": base is position 0 (beginning of the file);
    • \n
  • \"cur\": base is current position;
    • \n
  • \"end\": base is end of file;
    • \n

\nIn case of success, function seek returns the final file position,\nmeasured in bytes from the beginning of the file.\nIf this function fails, it returns nil,\nplus a string describing the error.\n\n\n

\nThe default value for whence is \"cur\",\nand for offset is 0.\nTherefore, the call file:seek() returns the current\nfile position, without changing it;\nthe call file:seek(\"set\") sets the position to the\nbeginning of the file (and returns 0);\nand the call file:seek(\"end\") sets the position to the\nend of the file, and returns its size.\n\n\n\n\n

\n

file:setvbuf (mode [, size])

\n\n\n

\nSets the buffering mode for an output file.\nThere are three available modes:\n\n

    \n\n
  • \"no\":\nno buffering; the result of any output operation appears immediately.\n
    • \n\n
  • \"full\":\nfull buffering; output operation is performed only\nwhen the buffer is full (or when you explicitly flush the file\n(see io.flush)).\n
    • \n\n
  • \"line\":\nline buffering; output is buffered until a newline is output\nor there is any input from some special files\n(such as a terminal device).\n
    • \n\n

\nFor the last two cases, size\nspecifies the size of the buffer, in bytes.\nThe default is an appropriate size.\n\n\n\n\n

\n

file:write (···)

\n\n\n

\nWrites the value of each of its arguments to\nthe file.\nThe arguments must be strings or numbers.\nTo write other values,\nuse tostring or string.format before write.\n\n\n\n\n\n\n\n

5.8 - Operating System Facilities

\n\n

\nThis library is implemented through table os.\n\n\n

\n

os.clock ()

\n\n\n

\nReturns an approximation of the amount in seconds of CPU time\nused by the program.\n\n\n\n\n

\n

os.date ([format [, time]])

\n\n\n

\nReturns a string or a table containing date and time,\nformatted according to the given string format.\n\n\n

\nIf the time argument is present,\nthis is the time to be formatted\n(see the os.time function for a description of this value).\nOtherwise, date formats the current time.\n\n\n

\nIf format starts with '!',\nthen the date is formatted in Coordinated Universal Time.\nAfter this optional character,\nif format is the string \"*t\",\nthen date returns a table with the following fields:\nyear (four digits), month (1--12), day (1--31),\nhour (0--23), min (0--59), sec (0--61),\nwday (weekday, Sunday is 1),\nyday (day of the year),\nand isdst (daylight saving flag, a boolean).\n\n\n

\nIf format is not \"*t\",\nthen date returns the date as a string,\nformatted according to the same rules as the C function strftime.\n\n\n

\nWhen called without arguments,\ndate returns a reasonable date and time representation that depends on\nthe host system and on the current locale\n(that is, os.date() is equivalent to os.date(\"%c\")).\n\n\n\n\n

\n

os.difftime (t2, t1)

\n\n\n

\nReturns the number of seconds from time t1 to time t2.\nIn POSIX, Windows, and some other systems,\nthis value is exactly t2-t1.\n\n\n\n\n

\n

os.execute ([command])

\n\n\n

\nThis function is equivalent to the C function system.\nIt passes command to be executed by an operating system shell.\nIt returns a status code, which is system-dependent.\nIf command is absent, then it returns nonzero if a shell is available\nand zero otherwise.\n\n\n\n\n

\n

os.exit ([code])

\n\n\n

\nCalls the C function exit,\nwith an optional code,\nto terminate the host program.\nThe default value for code is the success code.\n\n\n\n\n

\n

os.getenv (varname)

\n\n\n

\nReturns the value of the process environment variable varname,\nor nil if the variable is not defined.\n\n\n\n\n

\n

os.remove (filename)

\n\n\n

\nDeletes the file or directory with the given name.\nDirectories must be empty to be removed.\nIf this function fails, it returns nil,\nplus a string describing the error.\n\n\n\n\n

\n

os.rename (oldname, newname)

\n\n\n

\nRenames file or directory named oldname to newname.\nIf this function fails, it returns nil,\nplus a string describing the error.\n\n\n\n\n

\n

os.setlocale (locale [, category])

\n\n\n

\nSets the current locale of the program.\nlocale is a string specifying a locale;\ncategory is an optional string describing which category to change:\n\"all\", \"collate\", \"ctype\",\n\"monetary\", \"numeric\", or \"time\";\nthe default category is \"all\".\nThe function returns the name of the new locale,\nor nil if the request cannot be honored.\n\n\n

\nIf locale is the empty string,\nthe current locale is set to an implementation-defined native locale.\nIf locale is the string \"C\",\nthe current locale is set to the standard C locale.\n\n\n

\nWhen called with nil as the first argument,\nthis function only returns the name of the current locale\nfor the given category.\n\n\n\n\n

\n

os.time ([table])

\n\n\n

\nReturns the current time when called without arguments,\nor a time representing the date and time specified by the given table.\nThis table must have fields year, month, and day,\nand may have fields hour, min, sec, and isdst\n(for a description of these fields, see the os.date function).\n\n\n

\nThe returned value is a number, whose meaning depends on your system.\nIn POSIX, Windows, and some other systems, this number counts the number\nof seconds since some given start time (the \"epoch\").\nIn other systems, the meaning is not specified,\nand the number returned by time can be used only as an argument to\ndate and difftime.\n\n\n\n\n

\n

os.tmpname ()

\n\n\n

\nReturns a string with a file name that can\nbe used for a temporary file.\nThe file must be explicitly opened before its use\nand explicitly removed when no longer needed.\n\n\n

\nOn some systems (POSIX),\nthis function also creates a file with that name,\nto avoid security risks.\n(Someone else might create the file with wrong permissions\nin the time between getting the name and creating the file.)\nYou still have to open the file to use it\nand to remove it (even if you do not use it).\n\n\n

\nWhen possible,\nyou may prefer to use io.tmpfile,\nwhich automatically removes the file when the program ends.\n\n\n\n\n\n\n\n

5.9 - The Debug Library

\n\n

\nThis library provides\nthe functionality of the debug interface to Lua programs.\nYou should exert care when using this library.\nThe functions provided here should be used exclusively for debugging\nand similar tasks, such as profiling.\nPlease resist the temptation to use them as a\nusual programming tool:\nthey can be very slow.\nMoreover, several of these functions\nviolate some assumptions about Lua code\n(e.g., that variables local to a function\ncannot be accessed from outside or\nthat userdata metatables cannot be changed by Lua code)\nand therefore can compromise otherwise secure code.\n\n\n

\nAll functions in this library are provided\ninside the debug table.\nAll functions that operate over a thread\nhave an optional first argument which is the\nthread to operate over.\nThe default is always the current thread.\n\n\n

\n

debug.debug ()

\n\n\n

\nEnters an interactive mode with the user,\nrunning each string that the user enters.\nUsing simple commands and other debug facilities,\nthe user can inspect global and local variables,\nchange their values, evaluate expressions, and so on.\nA line containing only the word cont finishes this function,\nso that the caller continues its execution.\n\n\n

\nNote that commands for debug.debug are not lexically nested\nwithin any function, and so have no direct access to local variables.\n\n\n\n\n

\n

debug.getfenv (o)

\nReturns the environment of object o.\n\n\n\n\n

\n

debug.gethook ([thread])

\n\n\n

\nReturns the current hook settings of the thread, as three values:\nthe current hook function, the current hook mask,\nand the current hook count\n(as set by the debug.sethook function).\n\n\n\n\n

\n

debug.getinfo ([thread,] function [, what])

\n\n\n

\nReturns a table with information about a function.\nYou can give the function directly,\nor you can give a number as the value of function,\nwhich means the function running at level function of the call stack\nof the given thread:\nlevel 0 is the current function (getinfo itself);\nlevel 1 is the function that called getinfo;\nand so on.\nIf function is a number larger than the number of active functions,\nthen getinfo returns nil.\n\n\n

\nThe returned table can contain all the fields returned by lua_getinfo,\nwith the string what describing which fields to fill in.\nThe default for what is to get all information available,\nexcept the table of valid lines.\nIf present,\nthe option 'f'\nadds a field named func with the function itself.\nIf present,\nthe option 'L'\nadds a field named activelines with the table of\nvalid lines.\n\n\n

\nFor instance, the expression debug.getinfo(1,\"n\").name returns\na table with a name for the current function,\nif a reasonable name can be found,\nand the expression debug.getinfo(print)\nreturns a table with all available information\nabout the print function.\n\n\n\n\n

\n

debug.getlocal ([thread,] level, local)

\n\n\n

\nThis function returns the name and the value of the local variable\nwith index local of the function at level level of the stack.\n(The first parameter or local variable has index 1, and so on,\nuntil the last active local variable.)\nThe function returns nil if there is no local\nvariable with the given index,\nand raises an error when called with a level out of range.\n(You can call debug.getinfo to check whether the level is valid.)\n\n\n

\nVariable names starting with '(' (open parentheses)\nrepresent internal variables\n(loop control variables, temporaries, and C function locals).\n\n\n\n\n

\n

debug.getmetatable (object)

\n\n\n

\nReturns the metatable of the given object\nor nil if it does not have a metatable.\n\n\n\n\n

\n

debug.getregistry ()

\n\n\n

\nReturns the registry table (see §3.5).\n\n\n\n\n

\n

debug.getupvalue (func, up)

\n\n\n

\nThis function returns the name and the value of the upvalue\nwith index up of the function func.\nThe function returns nil if there is no upvalue with the given index.\n\n\n\n\n

\n

debug.setfenv (object, table)

\n\n\n

\nSets the environment of the given object to the given table.\nReturns object.\n\n\n\n\n

\n

debug.sethook ([thread,] hook, mask [, count])

\n\n\n

\nSets the given function as a hook.\nThe string mask and the number count describe\nwhen the hook will be called.\nThe string mask may have the following characters,\nwith the given meaning:\n\n

    \n
  • \"c\": the hook is called every time Lua calls a function;
    • \n
  • \"r\": the hook is called every time Lua returns from a function;
    • \n
  • \"l\": the hook is called every time Lua enters a new line of code.
    • \n

\nWith a count different from zero,\nthe hook is called after every count instructions.\n\n\n

\nWhen called without arguments,\ndebug.sethook turns off the hook.\n\n\n

\nWhen the hook is called, its first parameter is a string\ndescribing the event that has triggered its call:\n\"call\", \"return\" (or \"tail return\",\nwhen simulating a return from a tail call),\n\"line\", and \"count\".\nFor line events,\nthe hook also gets the new line number as its second parameter.\nInside a hook,\nyou can call getinfo with level 2 to get more information about\nthe running function\n(level 0 is the getinfo function,\nand level 1 is the hook function),\nunless the event is \"tail return\".\nIn this case, Lua is only simulating the return,\nand a call to getinfo will return invalid data.\n\n\n\n\n

\n

debug.setlocal ([thread,] level, local, value)

\n\n\n

\nThis function assigns the value value to the local variable\nwith index local of the function at level level of the stack.\nThe function returns nil if there is no local\nvariable with the given index,\nand raises an error when called with a level out of range.\n(You can call getinfo to check whether the level is valid.)\nOtherwise, it returns the name of the local variable.\n\n\n\n\n

\n

debug.setmetatable (object, table)

\n\n\n

\nSets the metatable for the given object to the given table\n(which can be nil).\n\n\n\n\n

\n

debug.setupvalue (func, up, value)

\n\n\n

\nThis function assigns the value value to the upvalue\nwith index up of the function func.\nThe function returns nil if there is no upvalue\nwith the given index.\nOtherwise, it returns the name of the upvalue.\n\n\n\n\n

\n

debug.traceback ([thread,] [message] [, level])

\n\n\n

\nReturns a string with a traceback of the call stack.\nAn optional message string is appended\nat the beginning of the traceback.\nAn optional level number tells at which level\nto start the traceback\n(default is 1, the function calling traceback).\n\n\n\n\n\n\n\n

6 - Lua Stand-alone

\n\n

\nAlthough Lua has been designed as an extension language,\nto be embedded in a host C program,\nit is also frequently used as a stand-alone language.\nAn interpreter for Lua as a stand-alone language,\ncalled simply lua,\nis provided with the standard distribution.\nThe stand-alone interpreter includes\nall standard libraries, including the debug library.\nIts usage is:\n\n

\n     lua [options] [script [args]]\n

\nThe options are:\n\n

    \n
  • -e stat: executes string stat;
    • \n
  • -l mod: \"requires\" mod;
    • \n
  • -i: enters interactive mode after running script;
    • \n
  • -v: prints version information;
    • \n
  • --: stops handling options;
    • \n
  • -: executes stdin as a file and stops handling options.
    • \n

\nAfter handling its options, lua runs the given script,\npassing to it the given args as string arguments.\nWhen called without arguments,\nlua behaves as lua -v -i\nwhen the standard input (stdin) is a terminal,\nand as lua - otherwise.\n\n\n

\nBefore running any argument,\nthe interpreter checks for an environment variable LUA_INIT.\nIf its format is @filename,\nthen lua executes the file.\nOtherwise, lua executes the string itself.\n\n\n

\nAll options are handled in order, except -i.\nFor instance, an invocation like\n\n

\n     $ lua -e'a=1' -e 'print(a)' script.lua\n

\nwill first set a to 1, then print the value of a (which is '1'),\nand finally run the file script.lua with no arguments.\n(Here $ is the shell prompt. Your prompt may be different.)\n\n\n

\nBefore starting to run the script,\nlua collects all arguments in the command line\nin a global table called arg.\nThe script name is stored at index 0,\nthe first argument after the script name goes to index 1,\nand so on.\nAny arguments before the script name\n(that is, the interpreter name plus the options)\ngo to negative indices.\nFor instance, in the call\n\n

\n     $ lua -la b.lua t1 t2\n

\nthe interpreter first runs the file a.lua,\nthen creates a table\n\n

\n     arg = { [-2] = \"lua\", [-1] = \"-la\",\n             [0] = \"b.lua\",\n             [1] = \"t1\", [2] = \"t2\" }\n

\nand finally runs the file b.lua.\nThe script is called with arg[1], arg[2], ···\nas arguments;\nit can also access these arguments with the vararg expression '...'.\n\n\n

\nIn interactive mode,\nif you write an incomplete statement,\nthe interpreter waits for its completion\nby issuing a different prompt.\n\n\n

\nIf the global variable _PROMPT contains a string,\nthen its value is used as the prompt.\nSimilarly, if the global variable _PROMPT2 contains a string,\nits value is used as the secondary prompt\n(issued during incomplete statements).\nTherefore, both prompts can be changed directly on the command line\nor in any Lua programs by assigning to _PROMPT.\nSee the next example:\n\n

\n     $ lua -e\"_PROMPT='myprompt> '\" -i\n

\n(The outer pair of quotes is for the shell,\nthe inner pair is for Lua.)\nNote the use of -i to enter interactive mode;\notherwise,\nthe program would just end silently\nright after the assignment to _PROMPT.\n\n\n

\nTo allow the use of Lua as a\nscript interpreter in Unix systems,\nthe stand-alone interpreter skips\nthe first line of a chunk if it starts with #.\nTherefore, Lua scripts can be made into executable programs\nby using chmod +x and the #! form,\nas in\n\n

\n     #!/usr/local/bin/lua\n

\n(Of course,\nthe location of the Lua interpreter may be different in your machine.\nIf lua is in your PATH,\nthen \n\n

\n     #!/usr/bin/env lua\n

\nis a more portable solution.) \n\n\n\n

7 - Incompatibilities with the Previous Version

\n\n

\nHere we list the incompatibilities that you may find when moving a program\nfrom Lua 5.0 to Lua 5.1.\nYou can avoid most of the incompatibilities compiling Lua with\nappropriate options (see file luaconf.h).\nHowever,\nall these compatibility options will be removed in the next version of Lua.\n\n\n\n

7.1 - Changes in the Language

\n
    \n\n
  • \nThe vararg system changed from the pseudo-argument arg with a\ntable with the extra arguments to the vararg expression.\n(See compile-time option LUA_COMPAT_VARARG in luaconf.h.)\n
    • \n\n
  • \nThere was a subtle change in the scope of the implicit\nvariables of the for statement and for the repeat statement.\n
    • \n\n
  • \nThe long string/long comment syntax ([[string]])\ndoes not allow nesting.\nYou can use the new syntax ([=[string]=]) in these cases.\n(See compile-time option LUA_COMPAT_LSTR in luaconf.h.)\n
    • \n\n
\n\n\n\n\n

7.2 - Changes in the Libraries

\n
    \n\n
  • \nFunction string.gfind was renamed string.gmatch.\n(See compile-time option LUA_COMPAT_GFIND in luaconf.h.)\n
    • \n\n
  • \nWhen string.gsub is called with a function as its\nthird argument,\nwhenever this function returns nil or false the\nreplacement string is the whole match,\ninstead of the empty string.\n
    • \n\n
  • \nFunction table.setn was deprecated.\nFunction table.getn corresponds\nto the new length operator (#);\nuse the operator instead of the function.\n(See compile-time option LUA_COMPAT_GETN in luaconf.h.)\n
    • \n\n
  • \nFunction loadlib was renamed package.loadlib.\n(See compile-time option LUA_COMPAT_LOADLIB in luaconf.h.)\n
    • \n\n
  • \nFunction math.mod was renamed math.fmod.\n(See compile-time option LUA_COMPAT_MOD in luaconf.h.)\n
    • \n\n
  • \nFunctions table.foreach and table.foreachi are deprecated.\nYou can use a for loop with pairs or ipairs instead.\n
    • \n\n
  • \nThere were substantial changes in function require due to\nthe new module system.\nHowever, the new behavior is mostly compatible with the old,\nbut require gets the path from package.path instead\nof from LUA_PATH.\n
    • \n\n
  • \nFunction collectgarbage has different arguments.\nFunction gcinfo is deprecated;\nuse collectgarbage(\"count\") instead.\n
    • \n\n
\n\n\n\n\n

7.3 - Changes in the API

\n
    \n\n
  • \nThe luaopen_* functions (to open libraries)\ncannot be called directly,\nlike a regular C function.\nThey must be called through Lua,\nlike a Lua function.\n
    • \n\n
  • \nFunction lua_open was replaced by lua_newstate to\nallow the user to set a memory-allocation function.\nYou can use luaL_newstate from the standard library to\ncreate a state with a standard allocation function\n(based on realloc).\n
    • \n\n
  • \nFunctions luaL_getn and luaL_setn\n(from the auxiliary library) are deprecated.\nUse lua_objlen instead of luaL_getn\nand nothing instead of luaL_setn.\n
    • \n\n
  • \nFunction luaL_openlib was replaced by luaL_register.\n
    • \n\n
  • \nFunction luaL_checkudata now throws an error when the given value\nis not a userdata of the expected type.\n(In Lua 5.0 it returned NULL.)\n
    • \n\n
\n\n\n\n\n

8 - The Complete Syntax of Lua

\n\n

\nHere is the complete syntax of Lua in extended BNF.\n(It does not describe operator precedences.)\n\n\n\n\n

\n\n\tchunk ::= {stat [`;´]} [laststat [`;´]]\n\n\tblock ::= chunk\n\n\tstat ::=  varlist `=´ explist | \n\t\t functioncall | \n\t\t do block end | \n\t\t while exp do block end | \n\t\t repeat block until exp | \n\t\t if exp then block {elseif exp then block} [else block] end | \n\t\t for Name `=´ exp `,´ exp [`,´ exp] do block end | \n\t\t for namelist in explist do block end | \n\t\t function funcname funcbody | \n\t\t local function Name funcbody | \n\t\t local namelist [`=´ explist] \n\n\tlaststat ::= return [explist] | break\n\n\tfuncname ::= Name {`.´ Name} [`:´ Name]\n\n\tvarlist ::= var {`,´ var}\n\n\tvar ::=  Name | prefixexp `[´ exp `]´ | prefixexp `.´ Name \n\n\tnamelist ::= Name {`,´ Name}\n\n\texplist ::= {exp `,´} exp\n\n\texp ::=  nil | false | true | Number | String | `...´ | function | \n\t\t prefixexp | tableconstructor | exp binop exp | unop exp \n\n\tprefixexp ::= var | functioncall | `(´ exp `)´\n\n\tfunctioncall ::=  prefixexp args | prefixexp `:´ Name args \n\n\targs ::=  `(´ [explist] `)´ | tableconstructor | String \n\n\tfunction ::= function funcbody\n\n\tfuncbody ::= `(´ [parlist] `)´ block end\n\n\tparlist ::= namelist [`,´ `...´] | `...´\n\n\ttableconstructor ::= `{´ [fieldlist] `}´\n\n\tfieldlist ::= field {fieldsep field} [fieldsep]\n\n\tfield ::= `[´ exp `]´ `=´ exp | Name `=´ exp | exp\n\n\tfieldsep ::= `,´ | `;´\n\n\tbinop ::= `+´ | `-´ | `*´ | `/´ | `^´ | `%´ | `..´ | \n\t\t `<´ | `<=´ | `>´ | `>=´ | `==´ | `~=´ | \n\t\t and | or\n\n\tunop ::= `-´ | not | `#´\n\n
\n\n

\n\n\n\n\n\n\n\n

\n\nLast update:\nMon Aug 18 13:25:46 BRT 2008\n\n\n\n\n\n" }, { "path": "doc/readme.html", "content": "\n\nLua documentation\n\n\n\n\n\n
\n

\n\"Lua\"\nDocumentation\n

\n\nThis is the documentation included in the source distribution of Lua 5.1.4.\n\n\n\nLua's\nofficial web site\ncontains updated documentation,\nespecially the\nreference manual.\n

\n\n

\n\nLast update:\nTue Aug 12 14:46:07 BRT 2008\n\n\n\n\n" }, { "path": "etc/README", "content": "This directory contains some useful files and code.\nUnlike the code in ../src, everything here is in the public domain.\n\nIf any of the makes fail, you're probably not using the same libraries\nused to build Lua. Set MYLIBS in Makefile accordingly.\n\nall.c\n\tFull Lua interpreter in a single file.\n\tDo \"make one\" for a demo.\n\nlua.hpp\n\tLua header files for C++ using 'extern \"C\"'.\n\nlua.ico\n\tA Lua icon for Windows (and web sites: save as favicon.ico).\n\tDrawn by hand by Markus Gritsch .\n\nlua.pc\n\tpkg-config data for Lua\n\nluavs.bat\n\tScript to build Lua under \"Visual Studio .NET Command Prompt\".\n\tRun it from the toplevel as etc\\luavs.bat.\n\nmin.c\n\tA minimal Lua interpreter.\n\tGood for learning and for starting your own.\n\tDo \"make min\" for a demo.\n\nnoparser.c\n\tLinking with noparser.o avoids loading the parsing modules in lualib.a.\n\tDo \"make noparser\" for a demo.\n\nstrict.lua\n\tTraps uses of undeclared global variables.\n\tDo \"make strict\" for a demo.\n\n" }, { "path": "etc/all.c", "content": "/*\n* all.c -- Lua core, libraries and interpreter in a single file\n*/\n\n#define luaall_c\n\n#include \"lapi.c\"\n#include \"lcode.c\"\n#include \"ldebug.c\"\n#include \"ldo.c\"\n#include \"ldump.c\"\n#include \"lfunc.c\"\n#include \"lgc.c\"\n#include \"llex.c\"\n#include \"lmem.c\"\n#include \"lobject.c\"\n#include \"lopcodes.c\"\n#include \"lparser.c\"\n#include \"lstate.c\"\n#include \"lstring.c\"\n#include \"ltable.c\"\n#include \"ltm.c\"\n#include \"lundump.c\"\n#include \"lvm.c\"\n#include \"lzio.c\"\n\n#include \"lauxlib.c\"\n#include \"lbaselib.c\"\n#include \"ldblib.c\"\n#include \"liolib.c\"\n#include \"linit.c\"\n#include \"lmathlib.c\"\n#include \"loadlib.c\"\n#include \"loslib.c\"\n#include \"lstrlib.c\"\n#include \"ltablib.c\"\n\n#include \"lua.c\"\n" }, { "path": "etc/embed_jit.c", "content": "/*\n* min.c -- a minimal Lua interpreter\n* loads stdin only with minimal error handling.\n* no interaction, and no standard library, only a \"print\" function.\n*/\n\n#include \n\n#include \"lua.h\"\n#include \"lauxlib.h\"\n\nstatic int print(lua_State *L)\n{\n int n=lua_gettop(L);\n int i;\n for (i=1; i<=n; i++)\n {\n if (i>1) printf(\"\\t\");\n if (lua_isstring(L,i))\n printf(\"%s\",lua_tostring(L,i));\n else if (lua_isnil(L,i))\n printf(\"%s\",\"nil\");\n else if (lua_isboolean(L,i))\n printf(\"%s\",lua_toboolean(L,i) ? \"true\" : \"false\");\n else\n printf(\"%s:%p\",luaL_typename(L,i),lua_topointer(L,i));\n }\n printf(\"\\n\");\n return 0;\n}\n\nint main(int argc, char **argv)\n{\n lua_State *L=lua_open();\n char *file=NULL;\n lua_register(L,\"print\",print);\n if (argc > 1) {\n \tfile = argv[1];\n }\n if (luaL_dofile(L,file)!=0) fprintf(stderr,\"%s\\n\",lua_tostring(L,-1));\n lua_close(L);\n return 0;\n}\n" }, { "path": "etc/embed_jit.cpp", "content": "/*\n* min.c -- a minimal Lua interpreter\n* loads stdin only with minimal error handling.\n* no interaction, and no standard library, only a \"print\" function.\n*/\n\n#include \n\nextern \"C\" {\n#include \"lua.h\"\n#include \"lauxlib.h\"\n}\n\nstatic int print(lua_State *L)\n{\n int n=lua_gettop(L);\n int i;\n for (i=1; i<=n; i++)\n {\n if (i>1) printf(\"\\t\");\n if (lua_isstring(L,i))\n printf(\"%s\",lua_tostring(L,i));\n else if (lua_isnil(L,i))\n printf(\"%s\",\"nil\");\n else if (lua_isboolean(L,i))\n printf(\"%s\",lua_toboolean(L,i) ? \"true\" : \"false\");\n else\n printf(\"%s:%p\",luaL_typename(L,i),lua_topointer(L,i));\n }\n printf(\"\\n\");\n return 0;\n}\n\nint main(int argc, char **argv)\n{\n lua_State *L=lua_open();\n char *file=NULL;\n lua_register(L,\"print\",print);\n if (argc > 1) {\n \tfile = argv[1];\n }\n if (luaL_dofile(L,file)!=0) fprintf(stderr,\"%s\\n\",lua_tostring(L,-1));\n lua_close(L);\n return 0;\n}\n" }, { "path": "etc/lua.hpp", "content": "// lua.hpp\n// Lua header files for C++\n// <> not supplied automatically because Lua also compiles as C++\n\nextern \"C\" {\n#include \"lua.h\"\n#include \"lualib.h\"\n#include \"lauxlib.h\"\n}\n" }, { "path": "etc/lua.pc", "content": "# lua.pc -- pkg-config data for Lua\n\n# vars from install Makefile\n\n# grep '^V=' ../Makefile\nV= 5.1\n# grep '^R=' ../Makefile\nR= 5.1.4\n\n# grep '^INSTALL_.*=' ../Makefile | sed 's/INSTALL_TOP/prefix/'\nprefix= /usr\nINSTALL_BIN= ${prefix}/bin\nINSTALL_INC= ${prefix}/include\nINSTALL_LIB= ${prefix}/lib\nINSTALL_MAN= ${prefix}/man/man1\nINSTALL_LMOD= ${prefix}/share/lua/${V}\nINSTALL_CMOD= ${prefix}/lib/lua/${V}\n\n# canonical vars\nexec_prefix=${prefix}\nlibdir=${exec_prefix}/lib\nincludedir=${prefix}/include\n\nName: LLVM-Lua\nDescription: An Extensible Extension Language with JIT support from LLVM\nVersion: ${R}\nRequires: \nLibs: -L${libdir} -llua -lm `llvm-config --ldflags --libs core jit native bitreader bitwriter ipo`\nCflags: -I${includedir}\n\n# (end of lua.pc)\n" }, { "path": "etc/luavs.bat", "content": "@rem Script to build Lua under \"Visual Studio .NET Command Prompt\".\r\n@rem Do not run from this directory; run it from the toplevel: etc\\luavs.bat .\r\n@rem It creates lua51.dll, lua51.lib, lua.exe, and luac.exe in src.\r\n@rem (contributed by David Manura and Mike Pall)\r\n\r\n@setlocal\r\n@set MYCOMPILE=cl /nologo /MD /O2 /W3 /c /D_CRT_SECURE_NO_DEPRECATE\r\n@set MYLINK=link /nologo\r\n@set MYMT=mt /nologo\r\n\r\ncd src\r\n%MYCOMPILE% /DLUA_BUILD_AS_DLL l*.c\r\ndel lua.obj luac.obj\r\n%MYLINK% /DLL /out:lua51.dll l*.obj\r\nif exist lua51.dll.manifest^\r\n %MYMT% -manifest lua51.dll.manifest -outputresource:lua51.dll;2\r\n%MYCOMPILE% /DLUA_BUILD_AS_DLL lua.c\r\n%MYLINK% /out:lua.exe lua.obj lua51.lib\r\nif exist lua.exe.manifest^\r\n %MYMT% -manifest lua.exe.manifest -outputresource:lua.exe\r\n%MYCOMPILE% l*.c print.c\r\ndel lua.obj linit.obj lbaselib.obj ldblib.obj liolib.obj lmathlib.obj^\r\n loslib.obj ltablib.obj lstrlib.obj loadlib.obj\r\n%MYLINK% /out:luac.exe *.obj\r\nif exist luac.exe.manifest^\r\n %MYMT% -manifest luac.exe.manifest -outputresource:luac.exe\r\ndel *.obj *.manifest\r\ncd ..\r\n" }, { "path": "etc/min.c", "content": "/*\n* min.c -- a minimal Lua interpreter\n* loads stdin only with minimal error handling.\n* no interaction, and no standard library, only a \"print\" function.\n*/\n\n#include \n\n#include \"lua.h\"\n#include \"lauxlib.h\"\n\nstatic int print(lua_State *L)\n{\n int n=lua_gettop(L);\n int i;\n for (i=1; i<=n; i++)\n {\n if (i>1) printf(\"\\t\");\n if (lua_isstring(L,i))\n printf(\"%s\",lua_tostring(L,i));\n else if (lua_isnil(L,i))\n printf(\"%s\",\"nil\");\n else if (lua_isboolean(L,i))\n printf(\"%s\",lua_toboolean(L,i) ? \"true\" : \"false\");\n else\n printf(\"%s:%p\",luaL_typename(L,i),lua_topointer(L,i));\n }\n printf(\"\\n\");\n return 0;\n}\n\nint main(void)\n{\n lua_State *L=lua_open();\n lua_register(L,\"print\",print);\n if (luaL_dofile(L,NULL)!=0) fprintf(stderr,\"%s\\n\",lua_tostring(L,-1));\n lua_close(L);\n return 0;\n}\n" }, { "path": "etc/noparser.c", "content": "/*\n* The code below can be used to make a Lua core that does not contain the\n* parsing modules (lcode, llex, lparser), which represent 35% of the total core.\n* You'll only be able to load binary files and strings, precompiled with luac.\n* (Of course, you'll have to build luac with the original parsing modules!)\n*\n* To use this module, simply compile it (\"make noparser\" does that) and list\n* its object file before the Lua libraries. The linker should then not load\n* the parsing modules. To try it, do \"make luab\".\n*\n* If you also want to avoid the dump module (ldump.o), define NODUMP.\n* #define NODUMP\n*/\n\n#define LUA_CORE\n\n#include \"llex.h\"\n#include \"lparser.h\"\n#include \"lzio.h\"\n\nLUAI_FUNC void luaX_init (lua_State *L) {\n UNUSED(L);\n}\n\nLUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {\n UNUSED(z);\n UNUSED(buff);\n UNUSED(name);\n lua_pushliteral(L,\"parser not loaded\");\n lua_error(L);\n return NULL;\n}\n\n#ifdef NODUMP\n#include \"lundump.h\"\n\nLUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip) {\n UNUSED(f);\n UNUSED(w);\n UNUSED(data);\n UNUSED(strip);\n#if 1\n UNUSED(L);\n return 0;\n#else\n lua_pushliteral(L,\"dumper not loaded\");\n lua_error(L);\n#endif\n}\n#endif\n" }, { "path": "etc/strict.lua", "content": "--\n-- strict.lua\n-- checks uses of undeclared global variables\n-- All global variables must be 'declared' through a regular assignment\n-- (even assigning nil will do) in a main chunk before being used\n-- anywhere or assigned to inside a function.\n--\n\nlocal getinfo, error, rawset, rawget = debug.getinfo, error, rawset, rawget\n\nlocal mt = getmetatable(_G)\nif mt == nil then\n mt = {}\n setmetatable(_G, mt)\nend\n\nmt.__declared = {}\n\nlocal function what ()\n local d = getinfo(3, \"S\")\n return d and d.what or \"C\"\nend\n\nmt.__newindex = function (t, n, v)\n if not mt.__declared[n] then\n local w = what()\n if w ~= \"main\" and w ~= \"C\" then\n error(\"assign to undeclared variable '\"..n..\"'\", 2)\n end\n mt.__declared[n] = true\n end\n rawset(t, n, v)\nend\n \nmt.__index = function (t, n)\n if not mt.__declared[n] and what() ~= \"C\" then\n error(\"variable '\"..n..\"' is not declared\", 2)\n end\n return rawget(t, n)\nend\n\n" }, { "path": "gen_changelog.sh", "content": "#!/bin/sh\n#\n\nsvn2cl --authors=AUTHORS --break-before-msg --group-by-day -o ChangeLog\n\n" }, { "path": "llvm-lua/CMakeLists.txt", "content": "\n#\n# llvm-lua source\n#\nset(NON_LLVM_SRC\n\tlua_core.c\n\tlua_vm_ops_static.c\n\tload_jit_proto.c\n)\nset(LLVM_COMMON_SRC\n\tLLVMCompiler.cpp\n\tllvm_compiler.cpp\n\tload_embedded_bc.cpp\n\tload_vm_ops.cpp\n\tlua_vm_ops_bc.h\n\t${NON_LLVM_SRC}\n)\nset(NO_JIT_SRC\n\tno_jit.c\n\t${NON_LLVM_SRC}\n)\nset(EMB_BCS\n\tlua_vm_ops_bc.h\n\tliblua_main_bc.h\n)\nset(LLVM_LUA_SRC\n\tllvm-lua.cpp\n\tlua_interpreter.c\n)\nset(LLVM_LUAC_SRC\n\tllvm-luac.cpp\n\tlua_compiler.c\n\tLLVMDumper.cpp\n\tllvm_dumper.cpp\n\tload_liblua_main.cpp\n\tliblua_main_bc.h\n)\nset(LLVM_LUA_LIB_SRC\n\tlua_interpreter.c\n\t${LLVM_COMMON_SRC}\n)\nset(LLVM_LUA_BINS)\nset(LUA_COMPILER)\n\ninclude_directories(${CMAKE_CURRENT_SOURCE_DIR}\n\t\t\t\t${PROJECT_SOURCE_DIR}/src\n\t\t\t\t${CMAKE_CURRENT_BINARY_DIR})\n\nconfigure_file(\n\t\"${CMAKE_CURRENT_SOURCE_DIR}/llvm_lua_config.h.in\"\n\t\"${CMAKE_CURRENT_BINARY_DIR}/llvm_lua_config.h\"\n\t@ONLY\n)\n\nadd_executable(bin2c bin2c.c)\n\n# cflags for LLVM bitcode files.\nif(CMAKE_BUILD_TYPE STREQUAL \"Release\")\n\tset(BC_CFLAGS \"${COMMON_CFLAGS} ${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_RELEASE}\")\nelse()\n\tset(BC_CFLAGS \"${COMMON_CFLAGS} ${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_DEBUG}\")\nendif()\nstring(REGEX REPLACE \"[ \\t\\n]+\" \";\" BC_CFLAGS ${BC_CFLAGS})\n# setup cross-compiler flags.\nif(CROSS_COMPILE)\n\tif(NOT CROSS_ISYSTEM STREQUAL \"\")\n\t\tset(BC_CFLAGS ${BC_CFLAGS} -nostdinc)\n\t\tstring(REGEX REPLACE \":([^:]+)\" \";-isystem;\\\\1\" ISYSTEM_FLAGS \"${CROSS_ISYSTEM}\")\n\t\tset(BC_CFLAGS ${BC_CFLAGS} -Wno-gnu-designator -isystem ${ISYSTEM_FLAGS})\n\tendif()\n\tset(BC_CFLAGS ${BC_CFLAGS} -ccc-host-triple ${CROSS_TRIPLE})\n\tif(NOT CROSS_CPU STREQUAL \"\")\n\t\tset(BC_CFLAGS ${BC_CFLAGS} -mcpu=${CROSS_CPU})\n\tendif()\n\t# don't need shared library support for cross-compiler\n\tset(WANT_SHARED_LIBRARY FALSE)\nendif(CROSS_COMPILE)\n# ignore unused parameters in lua_vm_ops* files.\nset(BC_CFLAGS ${BC_CFLAGS} -Wno-unused-parameter)\nset(BC_CFLAGS ${BC_CFLAGS} -c -emit-llvm -I../src)\n\n#\n# Embedded LLVM bitcode files\n#\nadd_llvm_bc_library(lua_vm_ops lua_vm_ops.c)\nadd_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/lua_vm_ops_bc.h\n\tCOMMAND bin2c -z -c ${CMAKE_CURRENT_BINARY_DIR}/lua_vm_ops.bc ${CMAKE_CURRENT_BINARY_DIR}/lua_vm_ops_bc.h\n\tWORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}\n\tDEPENDS bin2c ${CMAKE_CURRENT_BINARY_DIR}/lua_vm_ops.bc\n)\nadd_llvm_bc_library(liblua_main lua_main.c ${NO_JIT_SRC})\nadd_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/liblua_main_bc.h\n\tCOMMAND bin2c -z -c ${CMAKE_CURRENT_BINARY_DIR}/liblua_main.bc ${CMAKE_CURRENT_BINARY_DIR}/liblua_main_bc.h\n\tWORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}\n\tDEPENDS bin2c ${CMAKE_CURRENT_BINARY_DIR}/liblua_main.bc\n)\n\n#\n# Lua library.\n#\nset(LLVM_LUA_LIBS)\n\nif(WANT_STATIC_LIBRARY)\n\t# llvm-lua static library.\n\tadd_library(llvm-lua_static STATIC ${LLVM_LUA_LIB_SRC})\n\tadd_target_properties(llvm-lua_static COMPILE_FLAGS \"${COMMON_CFLAGS} ${LLVM_CFLAGS}\")\n\tadd_target_properties(llvm-lua_static LINK_FLAGS \"${LD_FLAGS} ${COMMON_LDFLAGS} ${LLVM_LFLAGS}\")\n\ttarget_link_libraries(llvm-lua_static ${LIBS} ${LLVM_ALL_LIBS})\n\n\t# link lua interpreter with static library\n\tset(LLVM_LUA_MAIN_LIB llvm-lua_static)\n\tset(LLVM_LUA_LIBS ${LLVM_LUA_LIBS} llvm-lua_static)\n\n\tif (WANT_NOJIT_LIBRARIES)\n\t\t# lua static library without LLVM JIT support.\n\t\tadd_library(llvm-lua_nojit_static STATIC ${NO_JIT_SRC})\n\t\tadd_target_properties(llvm-lua_nojit_static COMPILE_FLAGS \"${COMMON_CFLAGS}\")\n\t\tadd_target_properties(llvm-lua_nojit_static LINK_FLAGS \"${LD_FLAGS} ${COMMON_LDFLAGS}\")\n\t\ttarget_link_libraries(llvm-lua_nojit_static ${LIBS})\n\n\t\tset(LLVM_LUA_LIBS ${LLVM_LUA_LIBS} llvm-lua_nojit_static)\n\tendif (WANT_NOJIT_LIBRARIES)\nendif(WANT_STATIC_LIBRARY)\n\nif(WANT_SHARED_LIBRARY)\n\t# llvm-lua dynamic library\n\tadd_library(llvm-lua_dynamic SHARED ${LLVM_LUA_LIB_SRC})\n\tadd_target_properties(llvm-lua_dynamic COMPILE_FLAGS \"${COMMON_CFLAGS} ${LLVM_CFLAGS}\")\n\tadd_target_properties(llvm-lua_dynamic LINK_FLAGS \"${LD_FLAGS} ${COMMON_LDFLAGS} ${LLVM_LFLAGS}\")\n\ttarget_link_libraries(llvm-lua_dynamic ${LIBS} ${LLVM_ALL_LIBS})\n\tset_target_properties(llvm-lua_dynamic PROPERTIES OUTPUT_NAME llvm-lua)\n\n\t# link lua interpreter with dynamic library\n\tset(LLVM_LUA_MAIN_LIB llvm-lua_dynamic)\n\tset(LLVM_LUA_LIBS ${LLVM_LUA_LIBS} llvm-lua_dynamic)\n\n\tif (WANT_NOJIT_LIBRARIES)\n\t\t# lua dynamic library without LLVM JIT support.\n\t\tadd_library(llvm-lua_nojit_dynamic SHARED ${NO_JIT_SRC})\n\t\tadd_target_properties(llvm-lua_nojit_dynamic COMPILE_FLAGS \"${COMMON_CFLAGS}\")\n\t\tadd_target_properties(llvm-lua_nojit_dynamic LINK_FLAGS \"${LD_FLAGS} ${COMMON_LDFLAGS}\")\n\t\ttarget_link_libraries(llvm-lua_nojit_dynamic ${LIBS})\n\t\tset_target_properties(llvm-lua_nojit_dynamic PROPERTIES OUTPUT_NAME llvm-lua_nojit)\n\n\t\tset(LLVM_LUA_LIBS ${LLVM_LUA_LIBS} llvm-lua_nojit_dynamic)\n\tendif (WANT_NOJIT_LIBRARIES)\nendif(WANT_SHARED_LIBRARY)\n\n#\n# static library liblua_main.a\n#\nif(NOT CROSS_COMPILE)\n\tadd_library(llvm-lua_main STATIC lua_main.c ${NO_JIT_SRC})\n\tadd_target_properties(llvm-lua_main COMPILE_FLAGS \"${COMMON_CFLAGS}\")\n\tadd_target_properties(llvm-lua_main LINK_FLAGS \"${LD_FLAGS} ${COMMON_LDFLAGS}\")\n\n\tset(LLVM_LUA_LIBS ${LLVM_LUA_LIBS} llvm-lua_main)\nendif(NOT CROSS_COMPILE)\n\n# set library version & soversion\nif(LLVM_LUA_LIBS)\n\tset_target_properties(${LLVM_LUA_LIBS} PROPERTIES\n\t\tVERSION ${LLVM_LUA_VERSION}\n\t\tSOVERSION ${LLVM_LUA_SOVERSION}\n\t\tCLEAN_DIRECT_OUTPUT 1\n\t)\nendif(LLVM_LUA_LIBS)\n\n# set rpath & handle framework\nif(APPLE)\n\tset(INSTALL_NAME_DIR)\n\t# Set Dynamic Library and Framework properties\n\tif(WANT_FRAMEWORK)\n\t\tset_target_properties(llvm-lua_dynamic PROPERTIES\n\t\t\tFRAMEWORK TRUE\n\t\t\tFRAMEWORK_VERSION \"${LUA_FRAMEWORK_VERSION_NUMBER}\"\n\t\t\tPUBLIC_HEADER \"${LUA_LIB_HEADERS}\"\n\t\t\tRESOURCE \"${RESOURCE_FILES}\"\n\t\t)\n\t\tset(INSTALL_NAME_DIR ${CMAKE_FRAMEWORK_INSTALL_NAME_DIR})\n\n\t\t# Short Version is the \"marketing version\". It is the version\n\t\t# the user sees in an information panel.\n\t\tset(MACOSX_FRAMEWORK_SHORT_VERSION_STRING\n\t\t\t\t\t\t\"${LLVM_LUA_VERSION_MAJOR}.${LLVM_LUA_VERSION_MINOR}.${LLVM_LUA_VERSION_PATCH}\")\n\t\t# Bundle version is the version the OS looks at.\n\t\tset(MACOSX_FRAMEWORK_BUNDLE_VERSION\n\t\t\t\t\t\t\"${LLVM_LUA_VERSION_MAJOR}.${LLVM_LUA_VERSION_MINOR}.${LLVM_LUA_VERSION_PATCH}\")\n\t\tset(MACOSX_FRAMEWORK_IDENTIFIER \"org.lua.llvm-lua\")\n\telseif(WANT_SHARED_LIBRARY)\n\t\tset_target_properties(llvm-lua_dynamic PROPERTIES\n\t\t\tFRAMEWORK FALSE\n\t\t)\n\t\tset(INSTALL_NAME_DIR ${CMAKE_DYLIB_INSTALL_NAME_DIR})\n\tendif(WANT_FRAMEWORK)\n\n\tif(INSTALL_NAME_DIR)\n\t\tset_target_properties(llvm-lua_dynamic PROPERTIES\n\t\t\tINSTALL_NAME_DIR ${INSTALL_NAME_DIR}\n\t\t\tBUILD_WITH_INSTALL_RPATH ${CMAKE_BUILD_WITH_INSTALL_RPATH}\n\t\t)\n\telse(INSTALL_NAME_DIR)\n\t\t# no install_name folder force BUILD_WITH_INSTALL_RPATH to OFF\n\t\tset_property(TARGET llvm-lua_dynamic PROPERTY BUILD_WITH_INSTALL_RPATH OFF)\n\tendif(INSTALL_NAME_DIR)\n\n\tset(CMAKE_OSX_ARCHITECTURES ${OSX_ARCHITECTURES})\nelseif(WANT_SHARED_LIBRARY)\n\tset_target_properties(llvm-lua_dynamic PROPERTIES\n\t\tINSTALL_RPATH ${CMAKE_INSTALL_RPATH}\n\t\tBUILD_WITH_INSTALL_RPATH ${CMAKE_BUILD_WITH_INSTALL_RPATH}\n\t)\nendif(APPLE)\n\n#\n# Lua compiler\n#\nadd_executable(llvm-luac ${LLVM_LUAC_SRC})\nadd_target_properties(llvm-luac COMPILE_FLAGS \"${COMMON_CFLAGS} ${LLVM_CFLAGS}\")\nadd_target_properties(llvm-luac LINK_FLAGS\n\t\"${LD_FLAGS} ${COMMON_LDFLAGS} ${LLVM_LFLAGS}\")\ntarget_link_libraries(llvm-luac ${LLVM_LUA_MAIN_LIB} ${LLVM_ALL_LIBS})\nset(LLVM_LUA_BINS llvm-luac)\n\n#\n# build as a cross-compiler\n#\nif(CROSS_COMPILE)\n\tset(LUA_COMPILER \"${CMAKE_CURRENT_BINARY_DIR}/lua-cross-compiler\")\n\tset_target_properties(llvm-luac PROPERTIES OUTPUT_NAME ${CROSS_TRIPLE}-llvm-luac)\n\tconfigure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/lua-cross-compiler.in\" \"${LUA_COMPILER}\" @ONLY)\nelse(CROSS_COMPILE)\n\tset(LUA_COMPILER \"${CMAKE_CURRENT_BINARY_DIR}/lua-compiler\")\n\tconfigure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/lua-compiler.in\" \"${LUA_COMPILER}\" @ONLY)\nendif(CROSS_COMPILE)\n\n#\n# Lua stand-alone interpreter\n#\nif(NOT CROSS_COMPILE)\n\tadd_executable(llvm-lua_binary ${LLVM_LUA_SRC})\n\tadd_target_properties(llvm-lua_binary COMPILE_FLAGS \"${COMMON_CFLAGS} ${LLVM_CFLAGS}\")\n\tadd_target_properties(llvm-lua_binary LINK_FLAGS\n\t\t\"${LD_FLAGS} ${COMMON_LDFLAGS} ${LLVM_LFLAGS}\")\n\ttarget_link_libraries(llvm-lua_binary ${LLVM_LUA_MAIN_LIB} ${LLVM_JIT_LIBS})\n\t# rename llvm-lua.bin to llvm-lua\n\tset_target_properties(llvm-lua_binary PROPERTIES OUTPUT_NAME llvm-lua)\n\tset(LLVM_LUA_BINS ${LLVM_LUA_BINS} llvm-lua_binary)\nendif(NOT CROSS_COMPILE)\n\n#\n# install llvm-lua/llvm-luac & library.\n#\nif(APPLE AND WANT_SHARED_LIBRARY AND WANT_FRAMEWORK)\n\t# Make directory: llvm-lua.framework/Versions/5.1/MacOS\n\tadd_custom_command(\n\t\tTARGET llvm-lua_dynamic\n\t\tPOST_BUILD\n\t\tCOMMAND ${CMAKE_COMMAND}\n\t\tARGS -E make_directory \"${llvm_lua_BINARY_DIR}/${LUA_FRAMEWORK_NAME}/${LUA_FRAMEWORK_VERSIONED_EXECUTABLE_DIR}\"\n\t\tCOMMENT \"Command line tools\")\n\n\t# Make directory: llvm-lua.framework/Versions/5.1/lib\n\tadd_custom_command(\n\t\tTARGET llvm-lua_dynamic\n\t\tPOST_BUILD\n\t\tCOMMAND ${CMAKE_COMMAND}\n\t\tARGS -E make_directory \"${llvm_lua_BINARY_DIR}/${LUA_FRAMEWORK_NAME}/${LUA_FRAMEWORK_VERSIONED_LIB_DIR}\"\n\t\tCOMMENT \"Static lib\")\n\n\t# Copy llvm-lua to: llvm-lua.framework/Versions/5.1/MacOS/llvm-lua\n\tadd_custom_command(\n\t\tTARGET llvm-lua_dynamic llvm-lua_binary\n\t\tPOST_BUILD\n\t\tCOMMAND ${CMAKE_COMMAND}\n\t\tARGS -E copy \"${llvm_lua_BINARY_DIR}/llvm-lua\" \"${llvm_lua_BINARY_DIR}/${LUA_FRAMEWORK_NAME}/${LUA_FRAMEWORK_VERSIONED_EXECUTABLE_DIR}/llvm-lua\"\n\t\tCOMMENT \"Command line tools\")\n\n\t# Copy llvm-luac to: llvm-lua.framework/Versions/5.1/MacOS/llvm-luac\n\tadd_custom_command(\n\t\tTARGET llvm-lua_dynamic llvm-luac\n\t\tPOST_BUILD\n\t\tCOMMAND ${CMAKE_COMMAND}\n\t\tARGS -E copy ${llvm_lua_BINARY_DIR}/llvm-luac ${llvm_lua_BINARY_DIR}/${LUA_FRAMEWORK_NAME}/${LUA_FRAMEWORK_VERSIONED_EXECUTABLE_DIR}/llvm-luac\n\t\tCOMMENT \"Command line tools\")\n\n\t# Copy liblua.a to: llvm-lua.framework/Versions/5.1/lib/liblua.a\n\tadd_custom_command(\n\t\tTARGET llvm-lua_dynamic llvm-lua_static\n\t\tPOST_BUILD\n\t\tCOMMAND ${CMAKE_COMMAND}\n\t\tARGS -E copy \"${llvm_lua_BINARY_DIR}/liblua.a\" \"${llvm_lua_BINARY_DIR}/${LUA_FRAMEWORK_NAME}/${LUA_FRAMEWORK_VERSIONED_LIB_DIR}/liblua.a\"\n\t\tCOMMENT \"Static lib\")\n\n\t# Will install framework to /Library/Frameworks directory or user specified\n\tinstall(TARGETS llvm-lua_dynamic\n\t\tFRAMEWORK DESTINATION ${CMAKE_FRAMEWORK_INSTALL_DIR}\n\t)\n\n\tif(LUA_FRAMEWORK_SYMLINKS)\n\t\tinstall(CODE \"EXEC_PROGRAM(${CMAKE_COMMAND} ARGS -E make_directory \\\"$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin\\\")\")\n\n\t\t# create a symbolic link for llvm-lua\n\t\t# and add it to the install manifest\n\t\tinstall(CODE \"EXEC_PROGRAM(${CMAKE_COMMAND} ARGS -E create_symlink \\\"${CMAKE_FRAMEWORK_INSTALL_DIR}/${LUA_FRAMEWORK_NAME}/${LUA_FRAMEWORK_CURRENT_EXECUTABLE_DIR}/llvm-lua\\\" \\\"$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/lua\\\")\n\t\tlist(APPEND CMAKE_INSTALL_MANIFEST_FILES \\\"${CMAKE_INSTALL_PREFIX}/bin/llvm-lua\\\")\n\t\t\")\n\n\t\t# create a symbolic link for llvm-luac\n\t\t# and add it to the install manifest\n\t\tinstall(CODE \"EXEC_PROGRAM(${CMAKE_COMMAND} ARGS -E create_symlink \\\"${CMAKE_FRAMEWORK_INSTALL_DIR}/${LUA_FRAMEWORK_NAME}/${LUA_FRAMEWORK_CURRENT_EXECUTABLE_DIR}/llvm-luac\\\" \\\"$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/luac\\\")\n\t\tlist(APPEND CMAKE_INSTALL_MANIFEST_FILES \\\"${CMAKE_INSTALL_PREFIX}/bin/llvm-luac\\\")\n\t\t\")\n\tendif(LUA_FRAMEWORK_SYMLINKS)\n\nelse(APPLE AND WANT_SHARED_LIBRARY AND WANT_FRAMEWORK)\n\tinstall(TARGETS ${LLVM_LUA_BINS}\n\t\tRUNTIME DESTINATION bin\n\t)\n\tinstall(FILES ${LUA_COMPILER}\n\t\tDESTINATION bin\n\t\tPERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE\n\t\tWORLD_READ WORLD_EXECUTE\n\t)\n\n\tif(LLVM_LUA_LIBS)\n\t\tinstall(TARGETS ${LLVM_LUA_LIBS}\n\t\t\tLIBRARY DESTINATION lib\n\t\t\tARCHIVE DESTINATION lib\n\t\t)\n\tendif(LLVM_LUA_LIBS)\n\nendif(APPLE AND WANT_SHARED_LIBRARY AND WANT_FRAMEWORK)\n\n" }, { "path": "llvm-lua/COPYRIGHT.llvm-lua", "content": "Copyright (c) 2008 Robert G. Jakabosky\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\nMIT License: http://www.opensource.org/licenses/mit-license.php\n\n" }, { "path": "llvm-lua/LLVMCompiler.cpp", "content": "/*\n Copyright (c) 2009 Robert G. Jakabosky\n \n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n \n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n \n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n THE SOFTWARE.\n\n MIT License: http://www.opensource.org/licenses/mit-license.php\n*/\n\n#include \"llvm/LLVMContext.h\"\n#include \"llvm/DerivedTypes.h\"\n#include \"llvm/ExecutionEngine/ExecutionEngine.h\"\n#include \"llvm/Module.h\"\n#include \"llvm/PassManager.h\"\n#include \"llvm/Analysis/Verifier.h\"\n#include \"llvm/Target/TargetData.h\"\n#include \"llvm/Target/TargetMachine.h\"\n#include \"llvm/Target/TargetOptions.h\" \n#include \"llvm/Transforms/Scalar.h\"\n#include \"llvm/Transforms/IPO.h\"\n#include \"llvm/Transforms/Utils/Cloning.h\"\n#include \"llvm/Support/IRBuilder.h\"\n#include \"llvm/Support/Timer.h\"\n#include \"llvm/Support/CommandLine.h\"\n#include \n#include \n#include \n#include \n\n#include \"LLVMCompiler.h\"\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n#include \"lopcodes.h\"\n#include \"lobject.h\"\n#include \"lstate.h\"\n#include \"ldo.h\"\n#include \"lmem.h\"\n#include \"lcoco.h\"\n#ifdef __cplusplus\n}\n#endif\n#include \"load_vm_ops.h\"\n\n/*\n * Using lazing compilation requires large 512K c-stacks for each coroutine.\n */\nstatic bool NoLazyCompilation = true;\nstatic unsigned int OptLevel = 3;\n\nstatic llvm::cl::opt Fast(\"fast\",\n llvm::cl::desc(\"Generate code quickly, \"\n \"potentially sacrificing code quality\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt OpCodeStats(\"opcode-stats\",\n llvm::cl::desc(\"Generate stats on compiled Lua opcodes.\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt RunOpCodeStats(\"runtime-opcode-stats\",\n llvm::cl::desc(\"Generate stats on executed Lua opcodes.\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt PrintRunOpCodes(\"print-runtime-opcodes\",\n llvm::cl::desc(\"Print each opcode before executing it.\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt CompileLargeFunctions(\"compile-large-functions\",\n llvm::cl::desc(\"Compile all Lua functions even really large functions.\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt MaxFunctionSize(\"max-func-size\",\n llvm::cl::desc(\"Functions larger then this will not be compiled.\"),\n llvm::cl::value_desc(\"int\"),\n llvm::cl::init(200));\n\nstatic llvm::cl::opt DontInlineOpcodes(\"do-not-inline-opcodes\",\n llvm::cl::desc(\"Turn off inlining of opcode functions.\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt VerifyFunctions(\"verify-functions\",\n llvm::cl::desc(\"Verify each compiled function.\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt DumpFunctions(\"dump-functions\",\n llvm::cl::desc(\"Dump LLVM IR for each function.\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt DebugOpCodes(\"g\",\n llvm::cl::desc(\"Allow debugging of Lua code.\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt DisableOpt(\"O0\",\n llvm::cl::desc(\"Disable optimizations.\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt OptLevelO1(\"O1\",\n llvm::cl::desc(\"Optimization level 1.\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt OptLevelO2(\"O2\",\n llvm::cl::desc(\"Optimization level 2.\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt OptLevelO3(\"O3\",\n llvm::cl::desc(\"Optimization level 3.\"),\n llvm::cl::init(false));\n\n#define BRANCH_COND -1\n#define BRANCH_NONE -2\n\n//===----------------------------------------------------------------------===//\n// Lua bytecode to LLVM IR compiler\n//===----------------------------------------------------------------------===//\n\nllvm::Type *LLVMCompiler::get_var_type(val_t type, hint_t hints) {\n\tswitch(type) {\n\tcase VAR_T_VOID:\n\t\treturn llvm::Type::getVoidTy(getCtx());\n\tcase VAR_T_INT:\n\tcase VAR_T_ARG_A:\n\tcase VAR_T_ARG_B:\n\tcase VAR_T_ARG_BK:\n\tcase VAR_T_ARG_Bx:\n\tcase VAR_T_ARG_Bx_NUM_CONSTANT:\n\tcase VAR_T_ARG_B_FB2INT:\n\tcase VAR_T_ARG_sBx:\n\tcase VAR_T_ARG_C:\n\tcase VAR_T_ARG_CK:\n\tcase VAR_T_ARG_C_NUM_CONSTANT:\n\tcase VAR_T_ARG_C_NEXT_INSTRUCTION:\n\tcase VAR_T_ARG_C_FB2INT:\n\tcase VAR_T_PC_OFFSET:\n\tcase VAR_T_INSTRUCTION:\n\tcase VAR_T_NEXT_INSTRUCTION:\n\t\treturn llvm::Type::getInt32Ty(getCtx());\n\tcase VAR_T_LUA_STATE_PTR:\n\t\treturn Ty_lua_State_ptr;\n\tcase VAR_T_K:\n\t\treturn Ty_TValue_ptr;\n\tcase VAR_T_CL:\n\t\treturn Ty_LClosure_ptr;\n\tcase VAR_T_OP_VALUE_0:\n\tcase VAR_T_OP_VALUE_1:\n\tcase VAR_T_OP_VALUE_2:\n\t\tif(hints & HINT_USE_LONG) {\n\t\t\treturn llvm::Type::getInt64Ty(getCtx());\n\t\t}\n\t\treturn llvm::Type::getDoubleTy(getCtx());\n\tdefault:\n\t\tfprintf(stderr, \"Error: missing var_type=%d\\n\", type);\n\t\texit(1);\n\t\tbreak;\n\t}\n\treturn NULL;\n}\n\nllvm::Value *LLVMCompiler::get_proto_constant(TValue *constant) {\n\tllvm::Value *val = NULL;\n\tswitch(ttype(constant)) {\n\tcase LUA_TBOOLEAN:\n\t\tval = llvm::ConstantInt::get(getCtx(), llvm::APInt(sizeof(LUA_NUMBER), !l_isfalse(constant)));\n\t\tbreak;\n\tcase LUA_TNUMBER:\n\t\tval = llvm::ConstantFP::get(getCtx(), llvm::APFloat(nvalue(constant)));\n\t\tbreak;\n\tcase LUA_TSTRING:\n\t\tbreak;\n\tcase LUA_TNIL:\n\tdefault:\n\t\tbreak;\n\t}\n\treturn val;\n}\n\nLLVMCompiler::LLVMCompiler(int useJIT) {\n\tstd::string error;\n\tllvm::Timer load_ops(\"load_ops\");\n\tllvm::Timer load_jit(\"load_jit\");\n\tllvm::FunctionType *func_type;\n\tllvm::Function *func;\n\tstd::vector func_args;\n\tconst vm_func_info *func_info;\n\tint opcode;\n\n\t// set OptLevel\n\tif(OptLevelO1) OptLevel = 1;\n\tif(OptLevelO2) OptLevel = 2;\n\tif(OptLevelO3) OptLevel = 3;\n\tif(DisableOpt) OptLevel = 0;\n\t// create timers.\n\tlua_to_llvm = new llvm::Timer(\"lua_to_llvm\");\n\tcodegen = new llvm::Timer(\"codegen\");\n\tstrip_code = false;\n\n\t// initialize opcode data arrays.\n\topcode_data_len = 0;\n\top_hints = NULL;\n\top_values = NULL;\n\top_blocks = NULL;\n\tneed_op_block = NULL;\n\tresize_opcode_data(MaxFunctionSize);\n\n\tif(llvm::TimePassesIsEnabled) load_ops.startTimer();\n\n\tif(OpCodeStats) {\n\t\topcode_stats = new int[NUM_OPCODES];\n\t\tfor(int i = 0; i < NUM_OPCODES; i++) {\n\t\t\topcode_stats[i] = 0;\n\t\t}\n\t}\n\n\tif(!useJIT) {\n\t\t// running as static compiler, so don't use Lazy loading.\n\t\tNoLazyCompilation = true;\n\t}\n\t// load vm op functions\n\tM = load_vm_ops(getCtx(), NoLazyCompilation);\n\n\t// get important struct types.\n\tTy_TValue = M->getTypeByName(\"struct.lua_TValue\");\n\tif(Ty_TValue == NULL) {\n\t\tTy_TValue = M->getTypeByName(\"struct.TValue\");\n\t}\n\tTy_TValue_ptr = llvm::PointerType::getUnqual(Ty_TValue);\n\tTy_LClosure = M->getTypeByName(\"struct.LClosure\");\n\tTy_LClosure_ptr = llvm::PointerType::getUnqual(Ty_LClosure);\n\tTy_lua_State = M->getTypeByName(\"struct.lua_State\");\n\tTy_lua_State_ptr = llvm::PointerType::getUnqual(Ty_lua_State);\n\t// setup argument lists.\n\tfunc_args.clear();\n\tfunc_args.push_back(Ty_lua_State_ptr);\n\tlua_func_type = llvm::FunctionType::get(llvm::Type::getInt32Ty(getCtx()), func_args, false);\n\t// define extern vm_next_OP\n\tvm_next_OP = M->getFunction(\"vm_next_OP\");\n\tif(vm_next_OP == NULL) {\n\t\tfunc_args.clear();\n\t\tfunc_args.push_back(Ty_lua_State_ptr);\n\t\tfunc_args.push_back(Ty_LClosure_ptr);\n\t\tfunc_args.push_back(llvm::Type::getInt32Ty(getCtx()));\n\t\tfunc_type = llvm::FunctionType::get(llvm::Type::getVoidTy(getCtx()), func_args, false);\n\t\tvm_next_OP = llvm::Function::Create(func_type,\n\t\t\tllvm::Function::ExternalLinkage, \"vm_next_OP\", M);\n\t}\n\t// define extern vm_print_OP\n\tvm_print_OP = M->getFunction(\"vm_print_OP\");\n\tif(vm_print_OP == NULL) {\n\t\tfunc_args.clear();\n\t\tfunc_args.push_back(Ty_lua_State_ptr);\n\t\tfunc_args.push_back(Ty_LClosure_ptr);\n\t\tfunc_args.push_back(llvm::Type::getInt32Ty(getCtx()));\n\t\tfunc_args.push_back(llvm::Type::getInt32Ty(getCtx()));\n\t\tfunc_type = llvm::FunctionType::get(llvm::Type::getVoidTy(getCtx()), func_args, false);\n\t\tvm_print_OP = llvm::Function::Create(func_type,\n\t\t\tllvm::Function::ExternalLinkage, \"vm_print_OP\", M);\n\t}\n\t// function for counting each executed op.\n\tif(RunOpCodeStats) {\n\t\tvm_count_OP = M->getFunction(\"vm_count_OP\");\n\t\tif(vm_count_OP == NULL) {\n\t\t\tfunc_args.clear();\n\t\t\tfunc_args.push_back(llvm::Type::getInt32Ty(getCtx()));\n\t\t\tfunc_type = llvm::FunctionType::get(llvm::Type::getVoidTy(getCtx()), func_args, false);\n\t\t\tvm_count_OP = llvm::Function::Create(func_type,\n\t\t\t\tllvm::Function::ExternalLinkage, \"vm_count_OP\", M);\n\t\t}\n\t\tfor(int i = 0; i < NUM_OPCODES; i++) {\n\t\t\tvm_op_run_count[i] = 0;\n\t\t}\n\t}\n\t// define extern vm_mini_vm\n\tvm_mini_vm = M->getFunction(\"vm_mini_vm\");\n\tif(vm_mini_vm == NULL) {\n\t\tfunc_args.clear();\n\t\tfunc_args.push_back(Ty_lua_State_ptr);\n\t\tfunc_args.push_back(Ty_LClosure_ptr);\n\t\tfunc_args.push_back(llvm::Type::getInt32Ty(getCtx()));\n\t\tfunc_args.push_back(llvm::Type::getInt32Ty(getCtx()));\n\t\tfunc_type = llvm::FunctionType::get(llvm::Type::getVoidTy(getCtx()), func_args, false);\n\t\tvm_mini_vm = llvm::Function::Create(func_type,\n\t\t\tllvm::Function::ExternalLinkage, \"vm_mini_vm\", M);\n\t}\n\t// define extern vm_get_current_closure\n\tvm_get_current_closure = M->getFunction(\"vm_get_current_closure\");\n\t// define extern vm_get_current_constants\n\tvm_get_current_constants = M->getFunction(\"vm_get_current_constants\");\n\t// define extern vm_get_number\n\tvm_get_number = M->getFunction(\"vm_get_number\");\n\t// define extern vm_get_long\n\tvm_get_long = M->getFunction(\"vm_get_long\");\n\t// define extern vm_set_number\n\tvm_set_number = M->getFunction(\"vm_set_number\");\n\t// define extern vm_set_long\n\tvm_set_long = M->getFunction(\"vm_set_long\");\n\n\n\t// create prototype for vm_* functions.\n\tvm_op_funcs = new OPFunc *[NUM_OPCODES];\n\tfor(int i = 0; i < NUM_OPCODES; i++) vm_op_funcs[i] = NULL; // clear list.\n\tfor(int i = 0; true; i++) {\n\t\tfunc_info = &vm_op_functions[i];\n\t\topcode = func_info->opcode;\n\t\tif(opcode < 0) break;\n\t\tvm_op_funcs[opcode] = new OPFunc(func_info, vm_op_funcs[opcode]);\n\t\tfunc = M->getFunction(func_info->name);\n\t\tif(func != NULL) {\n\t\t\tvm_op_funcs[opcode]->func = func;\n\t\t\tvm_op_funcs[opcode]->compiled = !useJIT; // lazy compile ops when JIT is enabled.\n\t\t\tcontinue;\n\t\t}\n\t\tfunc_args.clear();\n\t\tfor(int x = 0; func_info->params[x] != VAR_T_VOID; x++) {\n\t\t\tfunc_args.push_back(get_var_type(func_info->params[x], func_info->hint));\n\t\t}\n\t\tfunc_type = llvm::FunctionType::get(\n\t\t\tget_var_type(func_info->ret_type, func_info->hint), func_args, false);\n\t\tfunc = llvm::Function::Create(func_type, llvm::Function::ExternalLinkage,\n\t\t\t\t\t\t\tfunc_info->name, M);\n\t\tvm_op_funcs[opcode]->func = func;\n\t\tvm_op_funcs[opcode]->compiled = true; // built-in op function.\n\t}\n\n\tif(llvm::TimePassesIsEnabled) load_ops.stopTimer();\n\n\tif(llvm::TimePassesIsEnabled) load_jit.startTimer();\n\t// Create the JIT.\n\tif(useJIT) {\n\t\tllvm::EngineBuilder engine(M);\n\n\t\tllvm::TargetOptions options;\n\t\toptions.GuaranteedTailCallOpt = true;\n\t\toptions.JITEmitDebugInfo = false;\n\t\toptions.JITExceptionHandling = false;\n\t\tengine.setTargetOptions(options);\n\n\t\tllvm::CodeGenOpt::Level optLevel = llvm::CodeGenOpt::Aggressive;\n\t\tif(Fast) {\n\t\t\toptLevel = llvm::CodeGenOpt::Default;\n\t\t}\n#ifdef LUA_CPP_SUPPORT\n\t\tllvm::ExceptionHandling = true; \n#endif\n\t\tengine.setErrorStr(&error);\n\t\tengine.setOptLevel(optLevel);\n\t\tTheExecutionEngine = engine.create();\n\t\tif(!TheExecutionEngine) {\n\t\t\tprintf(\"Error creating JIT engine: %s\\n\", error.c_str());\n\t\t}\n\t\tif (NoLazyCompilation)\n\t\t\tTheExecutionEngine->DisableLazyCompilation();\n\n\t\tTheExecutionEngine->runStaticConstructorsDestructors(false);\n\n\t\tif (NoLazyCompilation) {\n\t\t\tTheExecutionEngine->getPointerToFunction(vm_get_current_closure);\n\t\t\tTheExecutionEngine->getPointerToFunction(vm_get_current_constants);\n\t\t\tTheExecutionEngine->getPointerToFunction(vm_get_number);\n\t\t\tTheExecutionEngine->getPointerToFunction(vm_get_long);\n\t\t\tTheExecutionEngine->getPointerToFunction(vm_set_number);\n\t\t\tTheExecutionEngine->getPointerToFunction(vm_set_long);\n\t\t}\n\t} else {\n\t\tTheExecutionEngine = NULL;\n\t}\n\n\tif(OptLevel > 1) {\n\t\tTheFPM = new llvm::FunctionPassManager(M);\n\t\t\n\t\t/*\n\t\t * Function Pass Manager.\n\t\t */\n\t\t// Set up the optimizer pipeline. Start with registering info about how the\n\t\t// target lays out data structures.\n\t\tif(useJIT) {\n\t\t\tTheFPM->add(new llvm::TargetData(*TheExecutionEngine->getTargetData()));\n\t\t} else {\n\t\t\tTheFPM->add(new llvm::TargetData(M));\n\t\t}\n\t\t// mem2reg\n\t\tTheFPM->add(llvm::createPromoteMemoryToRegisterPass());\n\t\t// Do simple \"peephole\" optimizations and bit-twiddling optzns.\n\t\tTheFPM->add(llvm::createInstructionCombiningPass());\n\t\t// Dead code Elimination\n\t\tTheFPM->add(llvm::createDeadCodeEliminationPass());\n\t\tif(OptLevel > 2) {\n\t\t\t// BlockPlacement\n\t\t\tTheFPM->add(llvm::createBlockPlacementPass());\n\t\t\t// Reassociate expressions.\n\t\t\tTheFPM->add(llvm::createReassociatePass());\n\t\t\t// Simplify the control flow graph (deleting unreachable blocks, etc).\n\t\t\tTheFPM->add(llvm::createCFGSimplificationPass());\n\t\t}\n\t} else {\n\t\tTheFPM = NULL;\n\t}\n\t\n\tif(llvm::TimePassesIsEnabled) load_jit.stopTimer();\n}\n\nvoid print_opcode_stats(int *stats, const char *stats_name) {\n\tint order[NUM_OPCODES];\n\tint max=0;\n\tint width=1;\n\tfor(int opcode = 0; opcode < NUM_OPCODES; opcode++) {\n\t\torder[opcode] = opcode;\n\t\tif(max < stats[opcode]) max = stats[opcode];\n\t\tfor(int n = 0; n < opcode; n++) {\n\t\t\tif(stats[opcode] >= stats[order[n]]) {\n\t\t\t\t// insert here.\n\t\t\t\tmemmove(&order[n + 1], &order[n], (opcode - n) * sizeof(int));\n\t\t\t\torder[n] = opcode;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\t// calc width.\n\twhile(max >= 10) { width++; max /= 10; }\n\t// sort by count.\n\tfprintf(stderr, \"===================== %s =======================\\n\", stats_name);\n\tint opcode;\n\tfor(int i = 0; i < NUM_OPCODES; i++) {\n\t\topcode = order[i];\n\t\tif(stats[opcode] == 0) continue;\n\t\tfprintf(stderr, \"%*d: %s(%d)\\n\", width, stats[opcode], luaP_opnames[opcode], opcode);\n\t}\n}\n\nLLVMCompiler::~LLVMCompiler() {\n\tstd::string error;\n\t// print opcode stats.\n\tif(OpCodeStats) {\n\t\tprint_opcode_stats(opcode_stats, \"Compiled OpCode counts\");\n\t\tdelete opcode_stats;\n\t}\n\tif(RunOpCodeStats) {\n\t\tprint_opcode_stats(vm_op_run_count, \"Compiled OpCode counts\");\n\t}\n\n\tresize_opcode_data(0);\n\n\tdelete lua_to_llvm;\n\tdelete codegen;\n\tif(TheFPM) delete TheFPM;\n\tTheFPM = NULL;\n\n\tfor(int i = 0; i < NUM_OPCODES; i++) {\n\t\tif(vm_op_funcs[i]) delete vm_op_funcs[i];\n\t}\n\tdelete[] vm_op_funcs;\n\n\t// Print out all of the generated code.\n\t//M->dump();\n\n\tif(TheExecutionEngine) {\n\t\tTheExecutionEngine->freeMachineCodeForFunction(vm_get_current_closure);\n\t\tTheExecutionEngine->freeMachineCodeForFunction(vm_get_current_constants);\n\t\tTheExecutionEngine->freeMachineCodeForFunction(vm_get_number);\n\t\tTheExecutionEngine->freeMachineCodeForFunction(vm_get_long);\n\t\tTheExecutionEngine->freeMachineCodeForFunction(vm_set_number);\n\t\tTheExecutionEngine->freeMachineCodeForFunction(vm_set_long);\n\t\tTheExecutionEngine->runStaticConstructorsDestructors(true);\n\t\tif(!TheExecutionEngine->removeModule(M)) {\n\t\t\tprintf(\"Failed find Module in execution engine.\\n\");\n\t\t\texit(1);\n\t\t}\n\t\tdelete TheExecutionEngine;\n\t}\n\tif(M) {\n\t\tdelete M;\n\t\tM = NULL;\n\t}\n}\n\nvoid LLVMCompiler::resize_opcode_data(int code_len) {\n\t// free old arrays.\n\tif(opcode_data_len > 0) {\n\t\t// free old data.\n\t\tclear_opcode_data(opcode_data_len);\n\t\tif(op_hints) delete[] op_hints;\n\t\tif(op_values) delete[] op_values;\n\t\tif(op_blocks) delete[] op_blocks;\n\t\tif(need_op_block) delete[] need_op_block;\n\t}\n\t// allocate new arrays\n\topcode_data_len = code_len;\n\tif(code_len == 0) return;\n\top_hints = new hint_t[code_len];\n\top_values = new OPValues *[code_len];\n\top_blocks = new llvm::BasicBlock *[code_len];\n\tneed_op_block = new bool[code_len];\n\tfor(int i = 0; i < code_len; i++) {\n\t\top_hints[i] = HINT_NONE;\n\t\top_values[i] = NULL;\n\t\top_blocks[i] = NULL;\n\t\tneed_op_block[i] = false;\n\t}\n}\n\nvoid LLVMCompiler::clear_opcode_data(int code_len) {\n\tif(code_len > opcode_data_len) {\n\t\tresize_opcode_data(code_len);\n\t\treturn;\n\t}\n\tfor(int i = 0; i < code_len; i++) {\n\t\top_hints[i] = HINT_NONE;\n\t\tif(op_values[i]) {\n\t\t\tdelete op_values[i];\n\t\t\top_values[i] = NULL;\n\t\t}\n\t\top_blocks[i] = NULL;\n\t\tneed_op_block[i] = false;\n\t}\n}\n\n/*\n * Pre-Compile all loaded functions.\n */\nvoid LLVMCompiler::compileAll(lua_State *L, Proto *parent) {\n\tint i;\n\t/* pre-compile parent */\n\tcompile(L, parent);\n\t/* pre-compile all children */\n\tfor(i = 0; i < parent->sizep; i++) {\n\t\tcompileAll(L, parent->p[i]);\n\t}\n}\n\nvoid LLVMCompiler::compile(lua_State *L, Proto *p)\n{\n\tInstruction *code=p->code;\n\tTValue *k=p->k;\n\tint code_len=p->sizecode;\n\tOPFunc *opfunc;\n\tllvm::Function *func;\n\tllvm::BasicBlock *true_block=NULL;\n\tllvm::BasicBlock *false_block=NULL;\n\tllvm::BasicBlock *current_block=NULL;\n\tllvm::BasicBlock *entry_block=NULL;\n\tllvm::Value *brcond=NULL;\n\tllvm::Value *func_L;\n\tllvm::Value *func_cl;\n\tllvm::Value *func_k;\n\tconst vm_func_info *func_info;\n\tstd::vector args;\n\tllvm::CallInst *call=NULL;\n\tstd::vector inlineList;\n\tstd::string name;\n\tchar name_buf[128];\n\t//char locals[LUAI_MAXVARS];\n\tbool inline_call=false;\n\tint strip_ops=0;\n\tint branch;\n\tInstruction op_intr;\n\tint opcode;\n\tint mini_op_repeat=0;\n\tint i;\n\tllvm::IRBuilder<> Builder(getCtx());\n\n#ifndef COCO_DISABLE\n\t// Don't run the JIT from a coroutine.\n\tif(!luaCOCO_mainthread(L)) {\n\t\treturn;\n\t}\n#endif\n\tif(code_len >= MaxFunctionSize) {\n\t\tif(TheExecutionEngine != NULL && !CompileLargeFunctions) {\n\t\t\t// don't JIT large functions.\n\t\t\treturn;\n\t\t} else {\n\t\t\t// make sure there is room to compile large functions.\n\t\t\tif(code_len > opcode_data_len) {\n\t\t\t\tresize_opcode_data(code_len);\n\t\t\t}\n\t\t}\n\t}\n\n\tif(llvm::TimePassesIsEnabled) lua_to_llvm->startTimer();\n\t// create function.\n\tname = getstr(p->source);\n\tif(name.size() > 32) {\n\t\tname = name.substr(0,32);\n\t}\n\t// replace non-alphanum characters with '_'\n\tfor(size_t n = 0; n < name.size(); n++) {\n\t\tchar c = name[n];\n\t\tif((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) {\n\t\t\tcontinue;\n\t\t}\n\t\tif(c == '\\n' || c == '\\r') {\n\t\t\tname = name.substr(0,n);\n\t\t\tbreak;\n\t\t}\n\t\tname[n] = '_';\n\t}\n\tsnprintf(name_buf,128,\"_%d_%d\",p->linedefined, p->lastlinedefined);\n\tname += name_buf;\n\tfunc = llvm::Function::Create(lua_func_type, llvm::Function::ExternalLinkage, name, M);\n\t// name arg1 = \"L\"\n\tfunc_L = func->arg_begin();\n\tfunc_L->setName(\"L\");\n\t// entry block\n\tentry_block = llvm::BasicBlock::Create(getCtx(),\"entry\", func);\n\tBuilder.SetInsertPoint(entry_block);\n\t// get LClosure & constants.\n\tcall=Builder.CreateCall(vm_get_current_closure, func_L);\n\tinlineList.push_back(call);\n\tfunc_cl=call;\n\tcall=Builder.CreateCall(vm_get_current_constants, func_cl);\n\tinlineList.push_back(call);\n\tfunc_k=call;\n\n\t// find all jump/branch destinations and create a new basic block at that opcode.\n\t// also build hints for some opcodes.\n\tfor(i = 0; i < code_len; i++) {\n\t\top_intr=code[i];\n\t\topcode = GET_OPCODE(op_intr);\n\t\t// combind simple ops into one function call.\n\t\tif(is_mini_vm_op(opcode)) {\n\t\t\tmini_op_repeat++;\n\t\t} else {\n\t\t\tif(mini_op_repeat >= 3 && OptLevel > 1) {\n\t\t\t\top_hints[i - mini_op_repeat] |= HINT_MINI_VM;\n\t\t\t}\n\t\t\tmini_op_repeat = 0;\n\t\t}\n\t\tswitch (opcode) {\n\t\t\tcase OP_LOADBOOL:\n\t\t\t\tbranch = i+1;\n\t\t\t\t// check C operand if C!=0 then skip over the next op_block.\n\t\t\t\tif(GETARG_C(op_intr) != 0)\n\t\t\t\t\t++branch;\n\t\t\t\tneed_op_block[branch] = true;\n\t\t\t\tbreak;\n\t\t\tcase OP_LOADK: {\n\t\t\t\t// check if arg Bx is a number constant.\n\t\t\t\tTValue *rb = k + INDEXK(GETARG_Bx(op_intr));\n\t\t\t\tif(ttisnumber(rb)) op_hints[i] |= HINT_Bx_NUM_CONSTANT;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase OP_JMP:\n\t\t\t\t// always branch to the offset stored in operand sBx\n\t\t\t\tbranch = i + 1 + GETARG_sBx(op_intr);\n\t\t\t\tneed_op_block[branch] = true;\n\t\t\t\tbreak;\n\t\t\tcase OP_TAILCALL:\n\t\t\t\tbranch = i+1;\n\t\t\t\tneed_op_block[0] = true; /* branch to start of function if this is a recursive tail-call. */\n\t\t\t\tneed_op_block[branch] = true; /* branch to return instruction if not recursive. */\n\t\t\t\tbreak;\n\t\t\tcase OP_EQ:\n\t\t\tcase OP_LT:\n\t\t\tcase OP_LE:\n\t\t\t\t// check if arg C is a number constant.\n\t\t\t\tif(ISK(GETARG_C(op_intr))) {\n\t\t\t\t\tTValue *rc = k + INDEXK(GETARG_C(op_intr));\n\t\t\t\t\tif(ttisnumber(rc)) op_hints[i] |= HINT_C_NUM_CONSTANT;\n\t\t\t\t}\n\t\t\t\tif(GETARG_A(op_intr) == 1) {\n\t\t\t\t\top_hints[i] |= HINT_NOT;\n\t\t\t\t}\n\t\t\t\t// fall-through\n\t\t\tcase OP_TEST:\n\t\t\tcase OP_TESTSET:\n\t\t\tcase OP_TFORLOOP:\n\t\t\t\tbranch = ++i + 1;\n\t\t\t\top_intr=code[i];\n\t\t\t\tneed_op_block[branch + GETARG_sBx(op_intr)] = true; /* inline JMP op. */\n\t\t\t\tneed_op_block[branch] = true;\n\t\t\t\tbreak;\n\t\t\tcase OP_FORLOOP:\n\t\t\t\tbranch = i+1;\n\t\t\t\tneed_op_block[branch] = true;\n\t\t\t\tbranch += GETARG_sBx(op_intr);\n\t\t\t\tneed_op_block[branch] = true;\n\t\t\t\tbreak;\n\t\t\tcase OP_FORPREP:\n\t\t\t\tbranch = i + 1 + GETARG_sBx(op_intr);\n\t\t\t\tneed_op_block[branch] = true;\n\t\t\t\tneed_op_block[branch + 1] = true;\n\t\t\t\t// test if init/plimit/pstep are number constants.\n\t\t\t\tif(OptLevel > 1 && i >= 3) {\n\t\t\t\t\tlua_Number nums[3];\n\t\t\t\t\tbool found_val[3] = { false, false , false };\n\t\t\t\t\tbool is_const_num[3] = { false, false, false };\n\t\t\t\t\tbool all_longs=true;\n\t\t\t\t\tint found=0;\n\t\t\t\t\tOPValues *vals = new OPValues(4);\n\t\t\t\t\tint forprep_ra = GETARG_A(op_intr);\n\t\t\t\t\tbool no_jmp_end_point = true; // don't process ops after finding a jmp end point.\n\t\t\t\t\t// find & load constants for init/plimit/pstep\n\t\t\t\t\tfor(int x = 1; x < 6 && found < 3 && no_jmp_end_point; ++x) {\n\t\t\t\t\t\tconst TValue *tmp;\n\t\t\t\t\t\tInstruction op_intr2;\n\t\t\t\t\t\tint ra;\n\n\t\t\t\t\t\tif((i - x) < 0) break;\n\t\t\t\t\t\top_intr2 = code[i - x];\n\t\t\t\t\t\t// get 'a' register.\n\t\t\t\t\t\tra = GETARG_A(op_intr2);\n\t\t\t\t\t\tra -= forprep_ra;\n\t\t\t\t\t\t// check for jmp end-point.\n\t\t\t\t\t\tno_jmp_end_point = !(need_op_block[i - x]);\n\t\t\t\t\t\t// check that the 'a' register is for one of the value we are interested in.\n\t\t\t\t\t\tif(ra < 0 || ra > 2) continue;\n\t\t\t\t\t\t// only process this opcode if we haven't seen this value before.\n\t\t\t\t\t\tif(found_val[ra]) continue;\n\t\t\t\t\t\tfound_val[ra] = true;\n\t\t\t\t\t\tfound++;\n\t\t\t\t\t\tif(GET_OPCODE(op_intr2) == OP_LOADK) {\n\t\t\t\t\t\t\ttmp = k + GETARG_Bx(op_intr2);\n\t\t\t\t\t\t\tif(ttisnumber(tmp)) {\n\t\t\t\t\t\t\t\tlua_Number num=nvalue(tmp);\n\t\t\t\t\t\t\t\tnums[ra] = num;\n\t\t\t\t\t\t\t\t// test if number is a whole number\n\t\t\t\t\t\t\t\tall_longs &= (floor(num) == num);\n\t\t\t\t\t\t\t\tvals->set(ra,llvm::ConstantFP::get(getCtx(), llvm::APFloat(num)));\n\t\t\t\t\t\t\t\tis_const_num[ra] = true;\n\t\t\t\t\t\t\t\top_hints[i - x] |= HINT_SKIP_OP;\n\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tall_longs = false;\n\t\t\t\t\t}\n\t\t\t\t\tall_longs &= (found == 3);\n\t\t\t\t\t// create for_idx OP_FORPREP will inialize it.\n\t\t\t\t\top_hints[branch] = HINT_FOR_N_N_N;\n\t\t\t\t\tif(all_longs) {\n\t\t\t\t\t\tvals->set(3, Builder.CreateAlloca(llvm::Type::getInt64Ty(getCtx()), 0, \"for_idx\"));\n\t\t\t\t\t\top_hints[branch] |= HINT_USE_LONG;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tvals->set(3, Builder.CreateAlloca(llvm::Type::getDoubleTy(getCtx()), 0, \"for_idx\"));\n\t\t\t\t\t}\n\t\t\t\t\top_values[branch] = vals;\n\t\t\t\t\t// check if step, init, limit are constants\n\t\t\t\t\tif(is_const_num[2]) {\n\t\t\t\t\t\t// step is a constant\n\t\t\t\t\t\tif(is_const_num[0]) {\n\t\t\t\t\t\t\t// init & step are constants.\n\t\t\t\t\t\t\tif(is_const_num[1]) {\n\t\t\t\t\t\t\t\t// all are constants.\n\t\t\t\t\t\t\t\top_hints[i] = HINT_FOR_N_N_N;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t// limit is variable.\n\t\t\t\t\t\t\t\top_hints[i] = HINT_FOR_N_M_N;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\top_values[i] = new OPValues(3);\n\t\t\t\t\t\t\top_values[i]->set(0, vals->get(0));\n\t\t\t\t\t\t\top_values[i]->set(2, vals->get(2));\n\t\t\t\t\t\t} else if(is_const_num[1]) {\n\t\t\t\t\t\t\t// init is variable, limit & step are constants.\n\t\t\t\t\t\t\top_hints[i] = HINT_FOR_M_N_N;\n\t\t\t\t\t\t\top_values[i] = new OPValues(3);\n\t\t\t\t\t\t\top_values[i]->set(1, vals->get(1));\n\t\t\t\t\t\t\top_values[i]->set(2, vals->get(2));\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// check the direct of step.\n\t\t\t\t\t\tif(nums[2] > 0) {\n\t\t\t\t\t\t\top_hints[branch] |= HINT_UP;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\top_hints[branch] |= HINT_DOWN;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif(op_hints[i] == HINT_NONE) {\n\t\t\t\t\t\t// don't skip LOADK ops, since we are not inlining them.\n\t\t\t\t\t\tfor(int x=i-3; x < i; x++) {\n\t\t\t\t\t\t\tif(op_hints[x] & HINT_SKIP_OP) op_hints[x] &= ~(HINT_SKIP_OP);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif(all_longs) {\n\t\t\t\t\t\tfor(int x = 0; x < 3; ++x) {\n\t\t\t\t\t\t\tvals->set(x,llvm::ConstantInt::get(getCtx(), llvm::APInt(64,(lua_Long)nums[x])));\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\t// make sure OP_FORPREP doesn't subtract 'step' from 'init'\n\t\t\t\t\top_hints[i] |= HINT_NO_SUB;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase OP_SETLIST:\n\t\t\t\t// if C == 0, then next code value is count value.\n\t\t\t\tif(GETARG_C(op_intr) == 0) {\n\t\t\t\t\ti++;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase OP_ADD:\n\t\t\tcase OP_SUB:\n\t\t\tcase OP_MUL:\n\t\t\tcase OP_DIV:\n\t\t\tcase OP_MOD:\n\t\t\tcase OP_POW:\n\t\t\t\t// check if arg C is a number constant.\n\t\t\t\tif(ISK(GETARG_C(op_intr))) {\n\t\t\t\t\tTValue *rc = k + INDEXK(GETARG_C(op_intr));\n\t\t\t\t\tif(ttisnumber(rc)) op_hints[i] |= HINT_C_NUM_CONSTANT;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tbreak;\n\t\t}\n\t\t// update local variable type hints.\n\t\t//vm_op_hint_locals(locals, p->maxstacksize, k, op_intr);\n\t}\n\t// pre-create basic blocks.\n\tfor(i = 0; i < code_len; i++) {\n\t\tif(need_op_block[i]) {\n\t\t\top_intr=code[i];\n\t\t\topcode = GET_OPCODE(op_intr);\n\t\t\tsnprintf(name_buf,128,\"op_block_%s_%d\",luaP_opnames[opcode],i);\n\t\t\top_blocks[i] = llvm::BasicBlock::Create(getCtx(),name_buf, func);\n\t\t} else {\n\t\t\top_blocks[i] = NULL;\n\t\t}\n\t}\n\t// branch \"entry\" to first block.\n\tif(need_op_block[0]) {\n\t\tBuilder.CreateBr(op_blocks[0]);\n\t} else {\n\t\tcurrent_block = entry_block;\n\t}\n\t// gen op calls.\n\tfor(i = 0; i < code_len; i++) {\n\t\tif(op_blocks[i] != NULL) {\n\t\t\tif(current_block) {\n\t\t\t\t// add branch to new block.\n\t\t\t\tBuilder.CreateBr(op_blocks[i]);\n\t\t\t}\n\t\t\tBuilder.SetInsertPoint(op_blocks[i]);\n\t\t\tcurrent_block = op_blocks[i];\n\t\t}\n\t\t// skip dead unreachable code.\n\t\tif(current_block == NULL) {\n\t\t\tif(strip_code) strip_ops++;\n\t\t\tcontinue;\n\t\t}\n\t\tbranch = i+1;\n\t\top_intr=code[i];\n\t\topcode = GET_OPCODE(op_intr);\n\t\topfunc = vm_op_funcs[opcode];\n\t\t// combind multiple simple ops into one call.\n\t\tif(op_hints[i] & HINT_MINI_VM) {\n\t\t\tint op_count = 1;\n\t\t\t// count mini ops and check for any branch end-points.\n\t\t\twhile(is_mini_vm_op(GET_OPCODE(code[i + op_count])) &&\n\t\t\t\t\t(op_hints[i + op_count] & HINT_SKIP_OP) == 0) {\n\t\t\t\t// branch end-point in middle of mini ops block.\n\t\t\t\tif(need_op_block[i + op_count]) {\n\t\t\t\t\top_hints[i + op_count] |= HINT_MINI_VM; // mark start of new mini vm ops.\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\top_count++;\n\t\t\t}\n\t\t\tif(op_count >= 3) {\n\t\t\t\t// large block of mini ops add function call to vm_mini_vm()\n\t\t\t\tBuilder.CreateCall4(vm_mini_vm, func_L, func_cl,\n\t\t\t\t\tllvm::ConstantInt::get(getCtx(), llvm::APInt(32,op_count)),\n\t\t\t\t\tllvm::ConstantInt::get(getCtx(), llvm::APInt(32,i - strip_ops)));\n\t\t\t\tif(strip_code && strip_ops > 0) {\n\t\t\t\t\twhile(op_count > 0) {\n\t\t\t\t\t\tcode[i - strip_ops] = code[i];\n\t\t\t\t\t\ti++;\n\t\t\t\t\t\top_count--;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\ti += op_count;\n\t\t\t\t}\n\t\t\t\ti--;\n\t\t\t\tcontinue;\n\t\t\t} else {\n\t\t\t\t// mini ops block too small.\n\t\t\t\top_hints[i] &= ~(HINT_MINI_VM);\n\t\t\t}\n\t\t}\n\t\t// find op function with matching hint.\n\t\twhile(opfunc->next != NULL && (opfunc->info->hint & op_hints[i]) != opfunc->info->hint) {\n\t\t\topfunc = opfunc->next;\n\t\t}\n\t\tif(OpCodeStats) {\n\t\t\topcode_stats[opcode]++;\n\t\t}\n\t\t//fprintf(stderr, \"%d: '%s' (%d) = 0x%08X, hint=0x%X\\n\", i, luaP_opnames[opcode], opcode, op_intr, op_hints[i]);\n\t\t//fprintf(stderr, \"%d: func: '%s', func hints=0x%X\\n\", i, opfunc->info->name,opfunc->info->hint);\n\t\tif(PrintRunOpCodes) {\n\t\t\tBuilder.CreateCall4(vm_print_OP, func_L, func_cl,\n\t\t\t\tllvm::ConstantInt::get(getCtx(), llvm::APInt(32,op_intr)),\n\t\t\t\tllvm::ConstantInt::get(getCtx(), llvm::APInt(32,i)));\n\t\t}\n\t\tif(RunOpCodeStats) {\n\t\t\tBuilder.CreateCall(vm_count_OP, llvm::ConstantInt::get(getCtx(), llvm::APInt(32,op_intr)));\n\t\t}\n\t\tif(DebugOpCodes) {\n\t\t\t/* vm_next_OP function is used to call count/line debug hooks. */\n\t\t\tBuilder.CreateCall3(vm_next_OP, func_L, func_cl, llvm::ConstantInt::get(getCtx(), llvm::APInt(32,i)));\n\t\t}\n\t\tif(op_hints[i] & HINT_SKIP_OP) {\n\t\t\tif(strip_code) strip_ops++;\n\t\t\tcontinue;\n\t\t}\n\t\tif(strip_code) {\n\t\t\t// strip all opcodes.\n\t\t\tstrip_ops++;\n\t\t\tif(strip_ops > 0 && strip_ops < (i+1)) {\n\t\t\t\t// move opcodes we want to keep to new position.\n\t\t\t\tcode[(i+1) - strip_ops] = op_intr;\n\t\t\t}\n\t\t}\n\t\t// setup arguments for opcode function.\n\t\tfunc_info = opfunc->info;\n\t\tif(func_info == NULL) {\n\t\t\tfprintf(stderr, \"Error missing vm_OP_* function for opcode: %d\\n\", opcode);\n\t\t\treturn;\n\t\t}\n\t\t// special handling of OP_FORLOOP\n\t\tif(opcode == OP_FORLOOP) {\n\t\t\tllvm::BasicBlock *loop_test;\n\t\t\tllvm::BasicBlock *prep_block;\n\t\t\tllvm::BasicBlock *incr_block;\n\t\t\tllvm::Value *init,*step,*idx_var,*cur_idx,*next_idx;\n\t\t\tllvm::PHINode *PN;\n\t\t\tOPValues *vals;\n\n\t\t\tvals=op_values[i];\n\t\t\tif(vals != NULL) {\n\t\t\t\t// get init value from forprep block\n\t\t\t\tinit = vals->get(0);\n\t\t\t\t// get for loop 'idx' variable.\n\t\t\t\tstep = vals->get(2);\n\t\t\t\tidx_var = vals->get(3);\n\t\t\t\tassert(idx_var != NULL);\n\t\t\t\tincr_block = current_block;\n\t\t\t\tcur_idx = Builder.CreateLoad(idx_var);\n\t\t\t\tif(op_hints[i] & HINT_USE_LONG) {\n\t\t\t\t\tnext_idx = Builder.CreateAdd(cur_idx, step, \"next_idx\");\n\t\t\t\t} else {\n\t\t\t\t\tnext_idx = Builder.CreateFAdd(cur_idx, step, \"next_idx\");\n\t\t\t\t}\n\t\t\t\tBuilder.CreateStore(next_idx, idx_var); // store 'for_init' value.\n\t\t\t\t// create extra BasicBlock for vm_OP_FORLOOP_*\n\t\t\t\tsnprintf(name_buf,128,\"op_block_%s_%d_loop_test\",luaP_opnames[opcode],i);\n\t\t\t\tloop_test = llvm::BasicBlock::Create(getCtx(),name_buf, func);\n\t\t\t\t// create unconditional jmp from current block to loop test block\n\t\t\t\tBuilder.CreateBr(loop_test);\n\t\t\t\t// create unconditional jmp from forprep block to loop test block\n\t\t\t\tprep_block = op_blocks[branch + GETARG_sBx(op_intr) - 1];\n\t\t\t\tBuilder.SetInsertPoint(prep_block);\n\t\t\t\tBuilder.CreateBr(loop_test);\n\t\t\t\t// set current_block to loop_test block\n\t\t\t\tcurrent_block = loop_test;\n\t\t\t\tBuilder.SetInsertPoint(current_block);\n\t\t\t\t// Emit merge block\n\t\t\t\tif(op_hints[i] & HINT_USE_LONG) {\n\t\t\t\t\tPN = Builder.CreatePHI(llvm::Type::getInt64Ty(getCtx()), 2, \"idx\");\n\t\t\t\t} else {\n\t\t\t\t\tPN = Builder.CreatePHI(llvm::Type::getDoubleTy(getCtx()), 2, \"idx\");\n\t\t\t\t}\n\t\t\t\tPN->addIncoming(init, prep_block);\n\t\t\t\tPN->addIncoming(next_idx, incr_block);\n\t\t\t\tvals->set(0, PN);\n\t\t\t}\n\t\t}\n\t\targs.clear();\n\t\tfor(int x = 0; func_info->params[x] != VAR_T_VOID ; x++) {\n\t\t\tllvm::Value *val=NULL;\n\t\t\tswitch(func_info->params[x]) {\n\t\t\tcase VAR_T_ARG_A:\n\t\t\t\tval = llvm::ConstantInt::get(getCtx(), llvm::APInt(32,GETARG_A(op_intr)));\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_ARG_C:\n\t\t\t\tval = llvm::ConstantInt::get(getCtx(), llvm::APInt(32,GETARG_C(op_intr)));\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_ARG_C_FB2INT:\n\t\t\t\tval = llvm::ConstantInt::get(getCtx(), llvm::APInt(32,luaO_fb2int(GETARG_C(op_intr))));\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_ARG_Bx_NUM_CONSTANT:\n\t\t\t\tval = get_proto_constant(k + INDEXK(GETARG_Bx(op_intr)));\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_ARG_C_NUM_CONSTANT:\n\t\t\t\tval = get_proto_constant(k + INDEXK(GETARG_C(op_intr)));\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_ARG_C_NEXT_INSTRUCTION: {\n\t\t\t\tint c = GETARG_C(op_intr);\n\t\t\t\t// if C == 0, then next code value is used as ARG_C.\n\t\t\t\tif(c == 0) {\n\t\t\t\t\tif((i+1) < code_len) {\n\t\t\t\t\t\tc = code[i+1];\n\t\t\t\t\t\tif(strip_code) strip_ops++;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tval = llvm::ConstantInt::get(getCtx(), llvm::APInt(32,c));\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase VAR_T_ARG_B:\n\t\t\t\tval = llvm::ConstantInt::get(getCtx(), llvm::APInt(32,GETARG_B(op_intr)));\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_ARG_B_FB2INT:\n\t\t\t\tval = llvm::ConstantInt::get(getCtx(), llvm::APInt(32,luaO_fb2int(GETARG_B(op_intr))));\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_ARG_Bx:\n\t\t\t\tval = llvm::ConstantInt::get(getCtx(), llvm::APInt(32,GETARG_Bx(op_intr)));\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_ARG_sBx:\n\t\t\t\tval = llvm::ConstantInt::get(getCtx(), llvm::APInt(32,GETARG_sBx(op_intr)));\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_PC_OFFSET:\n\t\t\t\tval = llvm::ConstantInt::get(getCtx(), llvm::APInt(32,i + 1 - strip_ops));\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_INSTRUCTION:\n\t\t\t\tval = llvm::ConstantInt::get(getCtx(), llvm::APInt(32,op_intr));\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_NEXT_INSTRUCTION:\n\t\t\t\tval = llvm::ConstantInt::get(getCtx(), llvm::APInt(32,code[i+1]));\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_LUA_STATE_PTR:\n\t\t\t\tval = func_L;\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_K:\n\t\t\t\tval = func_k;\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_CL:\n\t\t\t\tval = func_cl;\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_OP_VALUE_0:\n\t\t\t\tif(op_values[i] != NULL) val = op_values[i]->get(0);\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_OP_VALUE_1:\n\t\t\t\tif(op_values[i] != NULL) val = op_values[i]->get(1);\n\t\t\t\tbreak;\n\t\t\tcase VAR_T_OP_VALUE_2:\n\t\t\t\tif(op_values[i] != NULL) val = op_values[i]->get(2);\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tfprintf(stderr, \"Error: not implemented!\\n\");\n\t\t\t\treturn;\n\t\t\tcase VAR_T_VOID:\n\t\t\t\tfprintf(stderr, \"Error: invalid value type!\\n\");\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif(val == NULL) {\n\t\t\t\tfprintf(stderr, \"Error: Missing parameter '%d' for this opcode(%d) function=%s!\\n\", x,\n\t\t\t\t\topcode, func_info->name);\n\t\t\t\texit(1);\n\t\t\t}\n\t\t\targs.push_back(val);\n\t\t}\n\t\t// create call to opcode function.\n\t\tif(func_info->ret_type != VAR_T_VOID) {\n\t\t\tcall=Builder.CreateCall(opfunc->func, args, \"retval\");\n\t\t} else {\n\t\t\tcall=Builder.CreateCall(opfunc->func, args);\n\t\t}\n\t\tinline_call = false;\n\t\t// handle retval from opcode function.\n\t\tswitch (opcode) {\n\t\t\tcase OP_LOADBOOL:\n\t\t\t\t// check C operand if C!=0 then skip over the next op_block.\n\t\t\t\tif(GETARG_C(op_intr) != 0) branch += 1;\n\t\t\t\telse branch = BRANCH_NONE;\n\t\t\t\tinline_call = true;\n\t\t\t\tbreak;\n\t\t\tcase OP_LOADK:\n\t\t\tcase OP_LOADNIL:\n\t\t\tcase OP_GETGLOBAL:\n\t\t\tcase OP_GETTABLE:\n\t\t\tcase OP_SETGLOBAL:\n\t\t\tcase OP_SETTABLE:\n\t\t\tcase OP_NEWTABLE:\n\t\t\tcase OP_SELF:\n\t\t\tcase OP_ADD:\n\t\t\tcase OP_SUB:\n\t\t\tcase OP_MUL:\n\t\t\tcase OP_DIV:\n\t\t\tcase OP_MOD:\n\t\t\tcase OP_POW:\n\t\t\tcase OP_UNM:\n\t\t\tcase OP_NOT:\n\t\t\tcase OP_LEN:\n\t\t\tcase OP_CONCAT:\n\t\t\tcase OP_GETUPVAL:\n\t\t\tcase OP_MOVE:\n\t\t\t\tinline_call = true;\n\t\t\t\tbranch = BRANCH_NONE;\n\t\t\t\tbreak;\n\t\t\tcase OP_CLOSE:\n\t\t\tcase OP_SETUPVAL:\n\t\t\t\tinline_call = false;\n\t\t\t\tbranch = BRANCH_NONE;\n\t\t\t\tbreak;\n\t\t\tcase OP_VARARG:\n\t\t\tcase OP_CALL:\n\t\t\t\tbranch = BRANCH_NONE;\n\t\t\t\tbreak;\n\t\t\tcase OP_TAILCALL:\n\t\t\t\t//call->setTailCall(true);\n\t\t\t\tbrcond=call;\n\t\t\t\tbrcond=Builder.CreateICmpNE(brcond,\n\t\t\t\t\t\tllvm::ConstantInt::get(getCtx(), llvm::APInt(32, PCRTAILRECUR)), \"brcond\");\n\t\t\t\ti++; // skip return opcode.\n\t\t\t\tfalse_block = op_blocks[0]; // branch to start of function if this is a recursive tail-call.\n\t\t\t\ttrue_block = op_blocks[i]; // branch to return instruction if not recursive.\n\t\t\t\tBuilder.CreateCondBr(brcond, true_block, false_block);\n\t\t\t\tBuilder.SetInsertPoint(op_blocks[i]);\n\t\t\t\tBuilder.CreateRet(call);\n\t\t\t\tcurrent_block = NULL; // have terminator\n\t\t\t\tbranch = BRANCH_NONE;\n\t\t\t\tbreak;\n\t\t\tcase OP_JMP:\n\t\t\t\t// always branch to the offset stored in operand sBx\n\t\t\t\tbranch += GETARG_sBx(op_intr);\n\t\t\t\t// call vm_OP_JMP just in case luai_threadyield is defined.\n\t\t\t\tinline_call = true;\n\t\t\t\tbreak;\n\t\t\tcase OP_EQ:\n\t\t\tcase OP_LT:\n\t\t\tcase OP_LE:\n\t\t\tcase OP_TEST:\n\t\t\tcase OP_TESTSET:\n\t\t\t\tinline_call = true;\n\t\t\tcase OP_TFORLOOP:\n\t\t\t\tbrcond=call;\n\t\t\t\tbrcond=Builder.CreateICmpNE(brcond, llvm::ConstantInt::get(getCtx(), llvm::APInt(32,0)), \"brcond\");\n\t\t\t\tfalse_block=op_blocks[branch+1];\n\t\t\t\t/* inlined JMP op. */\n\t\t\t\tbranch = ++i + 1;\n\t\t\t\tif(strip_code) {\n\t\t\t\t\tstrip_ops++;\n\t\t\t\t\tif(strip_ops > 0 && strip_ops < (i+1)) {\n\t\t\t\t\t\t// move opcodes we want to keep to new position.\n\t\t\t\t\t\tcode[(i+1) - strip_ops] = code[i];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\top_intr=code[i];\n\t\t\t\tbranch += GETARG_sBx(op_intr);\n\t\t\t\ttrue_block=op_blocks[branch];\n\t\t\t\tbranch = BRANCH_COND; // do conditional branch\n\t\t\t\tbreak;\n\t\t\tcase OP_FORLOOP: {\n\t\t\t\tllvm::Function *set_func=vm_set_number;\n\t\t\t\tllvm::CallInst *call2;\n\t\t\t\tOPValues *vals;\n\n\t\t\t\tinline_call = true;\n\t\t\t\tbrcond=call;\n\t\t\t\tbrcond=Builder.CreateICmpNE(brcond, llvm::ConstantInt::get(getCtx(), llvm::APInt(32,0)), \"brcond\");\n\t\t\t\ttrue_block=op_blocks[branch + GETARG_sBx(op_intr)];\n\t\t\t\tfalse_block=op_blocks[branch];\n\t\t\t\tbranch = BRANCH_COND; // do conditional branch\n\n\t\t\t\t// update external index if needed.\n\t\t\t\tvals=op_values[i];\n\t\t\t\tif(vals != NULL) {\n\t\t\t\t\tllvm::BasicBlock *idx_block;\n\t\t\t\t\tif(op_hints[i] & HINT_USE_LONG) {\n\t\t\t\t\t\tset_func = vm_set_long;\n\t\t\t\t\t}\n\t\t\t\t\t// create extra BasicBlock\n\t\t\t\t\tsnprintf(name_buf,128,\"op_block_%s_%d_set_for_idx\",luaP_opnames[opcode],i);\n\t\t\t\t\tidx_block = llvm::BasicBlock::Create(getCtx(),name_buf, func);\n\t\t\t\t\tBuilder.SetInsertPoint(idx_block);\n\t\t\t\t\t// copy idx value to Lua-stack.\n\t\t\t\t\tcall2=Builder.CreateCall3(set_func,func_L,\n\t\t\t\t\t\tllvm::ConstantInt::get(getCtx(), llvm::APInt(32,(GETARG_A(op_intr) + 3))), vals->get(0));\n\t\t\t\t\tinlineList.push_back(call2);\n\t\t\t\t\t// create jmp to true_block\n\t\t\t\t\tBuilder.CreateBr(true_block);\n\t\t\t\t\ttrue_block = idx_block;\n\t\t\t\t\tBuilder.SetInsertPoint(current_block);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase OP_FORPREP: {\n\t\t\t\tllvm::Function *get_func=vm_get_number;\n\t\t\t\tllvm::Value *idx_var,*init;\n\t\t\t\tllvm::CallInst *call2;\n\t\t\t\tOPValues *vals;\n\n\t\t\t\t//inline_call = true;\n\t\t\t\top_blocks[i] = current_block;\n\t\t\t\tbranch += GETARG_sBx(op_intr);\n\t\t\t\tvals=op_values[branch];\n\t\t\t\t// if no saved value, then use slow method.\n\t\t\t\tif(vals == NULL) break;\n\t\t\t\tif(op_hints[branch] & HINT_USE_LONG) {\n\t\t\t\t\tget_func = vm_get_long;\n\t\t\t\t}\n\t\t\t\t// get non-constant init from Lua stack.\n\t\t\t\tif(vals->get(0) == NULL) {\n\t\t\t\t\tcall2=Builder.CreateCall2(get_func,func_L,\n\t\t\t\t\t\tllvm::ConstantInt::get(getCtx(), llvm::APInt(32,(GETARG_A(op_intr) + 0))), \"for_init\");\n\t\t\t\t\tinlineList.push_back(call2);\n\t\t\t\t\tvals->set(0, call2);\n\t\t\t\t}\n\t\t\t\tinit = vals->get(0);\n\t\t\t\t// get non-constant limit from Lua stack.\n\t\t\t\tif(vals->get(1) == NULL) {\n\t\t\t\t\tcall2=Builder.CreateCall2(get_func,func_L,\n\t\t\t\t\t\tllvm::ConstantInt::get(getCtx(), llvm::APInt(32,(GETARG_A(op_intr) + 1))), \"for_limit\");\n\t\t\t\t\tinlineList.push_back(call2);\n\t\t\t\t\tvals->set(1, call2);\n\t\t\t\t}\n\t\t\t\t// get non-constant step from Lua stack.\n\t\t\t\tif(vals->get(2) == NULL) {\n\t\t\t\t\tcall2=Builder.CreateCall2(get_func,func_L,\n\t\t\t\t\t\tllvm::ConstantInt::get(getCtx(), llvm::APInt(32,(GETARG_A(op_intr) + 2))), \"for_step\");\n\t\t\t\t\tinlineList.push_back(call2);\n\t\t\t\t\tvals->set(2, call2);\n\t\t\t\t}\n\t\t\t\t// get for loop 'idx' variable.\n\t\t\t\tassert(vals->get(3) != NULL);\n\t\t\t\tidx_var = vals->get(3);\n\t\t\t\tBuilder.CreateStore(init, idx_var); // store 'for_init' value.\n\t\t\t\tvals->set(0, init);\n\t\t\t\tcurrent_block = NULL; // have terminator\n\t\t\t\tbranch = BRANCH_NONE;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase OP_SETLIST:\n\t\t\t\t// if C == 0, then next code value is used as ARG_C.\n\t\t\t\tif(GETARG_C(op_intr) == 0) {\n\t\t\t\t\ti++;\n\t\t\t\t}\n\t\t\t\tbranch = BRANCH_NONE;\n\t\t\t\tbreak;\n\t\t\tcase OP_CLOSURE: {\n\t\t\t\tProto *p2 = p->p[GETARG_Bx(op_intr)];\n\t\t\t\tint nups = p2->nups;\n\t\t\t\tif(strip_code && strip_ops > 0) {\n\t\t\t\t\twhile(nups > 0) {\n\t\t\t\t\t\ti++;\n\t\t\t\t\t\tcode[i - strip_ops] = code[i];\n\t\t\t\t\t\tnups--;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\ti += nups;\n\t\t\t\t}\n\t\t\t\tbranch = BRANCH_NONE;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase OP_RETURN: {\n\t\t\t\tcall->setTailCall(true);\n\t\t\t\tBuilder.CreateRet(call);\n\t\t\t\tbranch = BRANCH_NONE;\n\t\t\t\tcurrent_block = NULL; // have terminator\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tdefault:\n\t\t\t\tfprintf(stderr, \"Bad opcode: opcode=%d\\n\", opcode);\n\t\t\t\tbreak;\n\t\t}\n\t\tif(OptLevel > 0 && inline_call && !DontInlineOpcodes) {\n\t\t\tinlineList.push_back(call);\n\t\t} else if(!opfunc->compiled) {\n\t\t\t// only compile opcode functions that are not inlined.\n\t\t\topfunc->compiled = true;\n\t\t\tTheExecutionEngine->getPointerToFunction(opfunc->func);\n\t\t}\n\t\t// branch to next block.\n\t\tif(branch >= 0 && branch < code_len) {\n\t\t\tBuilder.CreateBr(op_blocks[branch]);\n\t\t\tcurrent_block = NULL; // have terminator\n\t\t} else if(branch == BRANCH_COND) {\n\t\t\tBuilder.CreateCondBr(brcond, true_block, false_block);\n\t\t\tcurrent_block = NULL; // have terminator\n\t\t}\n\t}\n\t// free opcode values and clear hints.\n\tclear_opcode_data(code_len);\n\t// strip Lua bytecode and debug info.\n\tif(strip_code && strip_ops > 0) {\n\t\tcode_len -= strip_ops;\n\t\tluaM_reallocvector(L, p->code, p->sizecode, code_len, Instruction);\n\t\tp->sizecode = code_len;\n\t\tluaM_reallocvector(L, p->lineinfo, p->sizelineinfo, 0, int);\n\t\tp->sizelineinfo = 0;\n\t\tluaM_reallocvector(L, p->locvars, p->sizelocvars, 0, LocVar);\n\t\tp->sizelocvars = 0;\n\t\tluaM_reallocvector(L, p->upvalues, p->sizeupvalues, 0, TString *);\n\t\tp->sizeupvalues = 0;\n\t}\n\tif(DumpFunctions) func->dump();\n\t// only run function inliner & optimization passes on same functions.\n\tif(OptLevel > 0 && !DontInlineOpcodes) {\n\t\tllvm::InlineFunctionInfo IFI;\n\t\tfor(std::vector::iterator I=inlineList.begin(); I != inlineList.end() ; I++) {\n\t\t\tInlineFunction(*I, IFI);\n\t\t}\n\t\t// Validate the generated code, checking for consistency.\n\t\tif(VerifyFunctions) verifyFunction(*func);\n\t\t// Optimize the function.\n\t\tif(TheFPM) TheFPM->run(*func);\n\t}\n\tif(llvm::TimePassesIsEnabled) lua_to_llvm->stopTimer();\n\n\tif(llvm::TimePassesIsEnabled) codegen->startTimer();\n\t// finished.\n\tif(TheExecutionEngine != NULL) {\n\t\tunion {\n\t\t\tvoid *ptr;\n\t\t\tlua_CFunction func;\n\t\t} jit_func;\n\t\tjit_func.ptr = TheExecutionEngine->getPointerToFunction(func);\n\t\tp->jit_func = jit_func.func;\n\t} else {\n\t\tp->jit_func = NULL;\n\t}\n\tp->func_ref = func;\n\tif(llvm::TimePassesIsEnabled) codegen->stopTimer();\n}\n\nvoid LLVMCompiler::free(lua_State *L, Proto *p)\n{\n\tllvm::Function *func;\n\tunion {\n\t\tvoid *ptr;\n\t\tlua_CFunction func;\n\t} jit_func;\n\t(void)L;\n\n\tif(TheExecutionEngine == NULL) return;\n\n\tjit_func.func = p->jit_func;\n\tfunc=(llvm::Function *)TheExecutionEngine->getGlobalValueAtAddress(jit_func.ptr);\n\tif(func != NULL) {\n\t\tTheExecutionEngine->freeMachineCodeForFunction(func);\n\t\tfunc->removeFromParent();\n\t\tdelete func;\n\t}\n}\n\n" }, { "path": "llvm-lua/LLVMCompiler.h", "content": "/*\n Copyright (c) 2009 Robert G. Jakabosky\n \n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n \n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n \n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n THE SOFTWARE.\n\n MIT License: http://www.opensource.org/licenses/mit-license.php\n*/\n\n#ifndef LLVMCOMPILER_h\n#define LLVMCOMPILER_h\n\n#include \"llvm/Support/IRBuilder.h\"\n#include \"llvm/Module.h\"\n#include \"llvm/LLVMContext.h\"\n\n#include \"lua_core.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \"lobject.h\"\n\n#include \"lua_vm_ops.h\"\n\n#ifdef __cplusplus\n}\n#endif\n\nnamespace llvm {\nclass FunctionPassManager;\nclass ExecutionEngine;\nclass Timer;\n}\n\nclass LLVMCompiler {\nprivate:\n\tclass OPFunc {\n\tpublic:\n\t\tconst vm_func_info *info;\n\t\tbool compiled;\n\t\tllvm::Function *func;\n\t\tOPFunc *next;\n\n\t\tOPFunc(const vm_func_info *info_, OPFunc *next_) :\n\t\t\t\tinfo(info_), compiled(false), func(NULL), next(next_) {}\n\t\t~OPFunc() {\n\t\t\tif(next) delete next;\n\t\t}\n\t};\n\tclass OPValues {\n\tprivate:\n\t\tint len;\n\t\tllvm::Value **values;\n\t\n\tpublic:\n\t\tOPValues(int len_) : len(len_), values(new llvm::Value *[len_]) {\n\t\t\tfor(int i = 0; i < len; ++i) {\n\t\t\t\tvalues[i] = NULL;\n\t\t\t}\n\t\t}\n\t\n\t\t~OPValues() {\n\t\t\tdelete[] values;\n\t\t}\n\t\tvoid set(int idx, llvm::Value *val) {\n\t\t\tassert(idx >= 0 && idx < len);\n\t\t\tvalues[idx] = val;\n\t\t}\n\t\tllvm::Value *get(int idx) {\n\t\t\tassert(idx >= 0 && idx < len);\n\t\t\treturn values[idx];\n\t\t}\n\t};\n\nprivate:\n\tllvm::LLVMContext Context;\n\tllvm::Module *M;\n\tllvm::FunctionPassManager *TheFPM;\n\tllvm::ExecutionEngine *TheExecutionEngine;\n\tbool strip_code;\n\n\t// struct types.\n\tllvm::Type *Ty_TValue;\n\tllvm::Type *Ty_TValue_ptr;\n\tllvm::Type *Ty_LClosure;\n\tllvm::Type *Ty_LClosure_ptr;\n\tllvm::Type *Ty_lua_State;\n\tllvm::Type *Ty_lua_State_ptr;\n\t// common function types.\n\tllvm::FunctionType *lua_func_type;\n\t// functions to get LClosure & constants pointer.\n\tllvm::Function *vm_get_current_closure;\n\tllvm::Function *vm_get_current_constants;\n\tllvm::Function *vm_get_number;\n\tllvm::Function *vm_get_long;\n\tllvm::Function *vm_set_number;\n\tllvm::Function *vm_set_long;\n\t// function for counting each executed op.\n\tllvm::Function *vm_count_OP;\n\t// function for print each executed op.\n\tllvm::Function *vm_print_OP;\n\t// function for handling count/line debug hooks.\n\tllvm::Function *vm_next_OP;\n\t// function for handling a block of simple opcodes.\n\tllvm::Function *vm_mini_vm;\n\t// available op function for each opcode.\n\tOPFunc **vm_op_funcs;\n\t// count compiled opcodes.\n\tint *opcode_stats;\n\n\t// timers\n\tllvm::Timer *lua_to_llvm;\n\tllvm::Timer *codegen;\n\n\t// opcode hints/values/blocks/need_block arrays used in compile() method.\n\tint opcode_data_len; // length of opcode arrays.\n\thint_t *op_hints;\n\tOPValues **op_values;\n\tllvm::BasicBlock **op_blocks;\n\tbool *need_op_block;\n\t// resize the opcode hint data arrays.\n\tvoid resize_opcode_data(int code_len);\n\t// reset/clear the opcode hint data arrays.\n\tvoid clear_opcode_data(int code_len);\n\npublic:\n\tLLVMCompiler(int useJIT);\n\t~LLVMCompiler();\n\n\t/*\n\t * set code stripping mode.\n\t */\n\tvoid setStripCode(bool strip) {\n\t\tstrip_code = strip;\n\t}\n\n\t/*\n\t * return the module.\n\t */\n\tllvm::Module *getModule() {\n\t\treturn M;\n\t}\n\n\tllvm::LLVMContext& getCtx() {\n\t\treturn Context;\n\t}\n\n\tllvm::FunctionType *get_lua_func_type() {\n\t\treturn lua_func_type;\n\t}\n\n\tllvm::Type *get_var_type(val_t type, hint_t hints);\n\n\tllvm::Value *get_proto_constant(TValue *constant);\n\t\n\t/*\n\t * Pre-Compile all loaded functions.\n\t */\n\tvoid compileAll(lua_State *L, Proto *parent);\n\n\tvoid compile(lua_State *L, Proto *p);\n\n\tvoid free(lua_State *L, Proto *p);\n};\n\n#endif\n\n" }, { "path": "llvm-lua/LLVMDumper.cpp", "content": "/*\n Copyright (c) 2009 Robert G. Jakabosky\n \n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n \n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n \n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n THE SOFTWARE.\n\n MIT License: http://www.opensource.org/licenses/mit-license.php\n*/\n\n#include \"llvm/DerivedTypes.h\"\n#include \"llvm/Module.h\"\n#include \"llvm/Target/TargetData.h\"\n#include \"llvm/Linker.h\"\n#include \"llvm/Analysis/Verifier.h\"\n#include \"llvm/Bitcode/ReaderWriter.h\"\n#include \"llvm/Support/CommandLine.h\"\n#include \"llvm/Support/raw_ostream.h\"\n#include \n#include \n#include \n#include \n\n#include \"LLVMCompiler.h\"\n#include \"LLVMDumper.h\"\n#include \"lstate.h\"\n#include \"load_jit_proto.h\"\n#include \"load_liblua_main.h\"\n\nstatic llvm::cl::opt LuaModule(\"lua-module\",\n llvm::cl::desc(\"Generate a Lua Module instead of a standalone exe.\"),\n llvm::cl::init(false));\n\nstatic llvm::cl::opt NoMain(\"no-main\",\n llvm::cl::desc(\"Don't link in liblua_main.bc.\"),\n llvm::cl::init(false));\n\n//===----------------------------------------------------------------------===//\n// Dump a compilable bitcode module.\n//===----------------------------------------------------------------------===//\n\nLLVMDumper::LLVMDumper(LLVMCompiler *compiler_) : compiler(compiler_) {\n\tstd::vector fields;\n\tllvm::TargetData *type_info;\n\tllvm::Type *value_type;\n\tllvm::ArrayType *pad_type;\n\tint num_size;\n\tint ptr_size;\n\tint max_size=0;\n\tint pad_size=0;\n\n\tM = compiler->getModule();\n\t// get target size of pointer & double\n\ttype_info = new llvm::TargetData(M);\n\tnum_size = type_info->getTypeStoreSize(llvm::Type::getDoubleTy(getCtx()));\n\tmax_size = num_size;\n\tptr_size = type_info->getPointerSize();\n\tif(ptr_size > max_size) max_size = ptr_size;\n\tdelete type_info;\n\n\tlua_func_type = compiler->get_lua_func_type();\n\tlua_func_type_ptr = llvm::PointerType::get(lua_func_type, 0);\n\tTy_str_ptr=llvm::PointerType::get(llvm::IntegerType::get(getCtx(), 8), 0);\n\t//\n\t// create constant_type structure type.\n\t//\n\n\t// union.constant_value\n\t\t// TODO: handle LUA_NUMBER types other then 'double'.\n\tfields.push_back(llvm::Type::getDoubleTy(getCtx()));\n\tTy_constant_value = llvm::StructType::create(getCtx(), fields, \"union.constant_value\", false);\n\n\t// struct.constant_type\n\tfields.clear();\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // type\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // length\n\tfields.push_back(Ty_constant_value); // val\n\tTy_constant_type = llvm::StructType::create(getCtx(), fields, \"struct.constant_type\", false);\n\tTy_constant_type_ptr = llvm::PointerType::get(Ty_constant_type, 0);\n\n\t// struct.constant_num_type\n\tfields.clear();\n\tfields.push_back(llvm::Type::getDoubleTy(getCtx())); // double\n\tvalue_type = llvm::StructType::get(getCtx(), fields, false);\n\tfields.clear();\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // type\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // length\n\tfields.push_back(value_type); // val (double)\n\tTy_constant_num_type = llvm::StructType::create(getCtx(), fields, \"struct.constant_num_type\", false);\n\tnum_padding = NULL;\n\n\t// struct.constant_bool_type\n\tfields.clear();\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // boolean\n\tpad_size = max_size - 4;\n\tif(pad_size > 0) {\n\t\tpad_type = llvm::ArrayType::get(llvm::IntegerType::get(getCtx(), 8), pad_size);\n\t\tbool_padding = llvm::Constant::getNullValue(pad_type);\n\t\tfields.push_back(pad_type); // padding\n\t} else {\n\t\tbool_padding = NULL;\n\t}\n\tvalue_type = llvm::StructType::get(getCtx(), fields, false);\n\tfields.clear();\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // type\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // length\n\tfields.push_back(value_type); // val (boolean)\n\tTy_constant_bool_type = llvm::StructType::create(getCtx(), fields, \"struct.constant_bool_type\", false);\n\n\t// struct.constant_str_type\n\tfields.clear();\n\tfields.push_back(Ty_str_ptr); // char *\n\tpad_size = max_size - ptr_size;\n\tif(pad_size > 0) {\n\t\tpad_type = llvm::ArrayType::get(llvm::IntegerType::get(getCtx(), 8), pad_size);\n\t\tstr_padding = llvm::Constant::getNullValue(pad_type);\n\t\tfields.push_back(pad_type); // padding\n\t} else {\n\t\tstr_padding = NULL;\n\t}\n\tvalue_type = llvm::StructType::get(getCtx(), fields, false);\n\tfields.clear();\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // type\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // length\n\tfields.push_back(value_type); // val (char *)\n\tTy_constant_str_type = llvm::StructType::create(getCtx(), fields, \"struct.constant_str_type\", false);\n\n\t//\n\t// create jit_LocVar structure type.\n\t//\n\tfields.clear();\n\tfields.push_back(Ty_str_ptr); // varname\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // startpc\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // endpc\n\tTy_jit_LocVar = llvm::StructType::create(getCtx(), fields, \"struct.jit_LocVar\", false);\n\tTy_jit_LocVar_ptr = llvm::PointerType::get(Ty_jit_LocVar, 0);\n\n\t//\n\t// create jit_proto structure type.\n\t//\n\tfields.clear();\n\n\tTy_jit_proto = llvm::StructType::create(getCtx(), \"struct.jit_proto\");\n\tfields.push_back(Ty_str_ptr); // name\n\tfields.push_back(lua_func_type_ptr); // jit_func\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // linedefined\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // lastlinedefined\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 8)); // nups\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 8)); // numparams\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 8)); // is_vararg\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 8)); // maxstacksize\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 16)); // sizek\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 16)); // sizelocvars\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // sizeupvalues\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // sizep\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // sizecode\n\tfields.push_back(llvm::IntegerType::get(getCtx(), 32)); // sizelineinfo\n\tfields.push_back(Ty_constant_type_ptr); // k\n\tfields.push_back(Ty_jit_LocVar_ptr); // locvars\n\tfields.push_back(llvm::PointerType::get(Ty_str_ptr, 0)); // upvalues\n\tfields.push_back(llvm::PointerType::get(Ty_jit_proto, 0)); // p\n\tfields.push_back(llvm::PointerType::get(llvm::IntegerType::get(getCtx(), 32), 0)); // code\n\tfields.push_back(llvm::PointerType::get(llvm::IntegerType::get(getCtx(), 32), 0)); // lineinfo\n\tTy_jit_proto->setBody(fields, false);\n\tTy_jit_proto_ptr = llvm::PointerType::get(Ty_jit_proto, 0);\n}\n\nvoid LLVMDumper::dump(const char *output, lua_State *L, Proto *p, int stripping) {\n\tllvm::raw_fd_ostream *out;\n\tstd::string error;\n\tllvm::Module *liblua_main = NULL;\n\n\tout = new llvm::raw_fd_ostream(output, error, llvm::raw_fd_ostream::F_Binary);\n\tif(error.empty()) {\n\t\tcompiler->setStripCode(stripping);\n\t\t// Internalize all opcode functions.\n\t\tfor (llvm::Module::iterator I = M->begin(), E = M->end(); I != E; ++I) {\n\t\t\tllvm::Function *Fn = &*I;\n\t\t\tif (!Fn->isDeclaration())\n\t\t\t\tFn->setLinkage(llvm::GlobalValue::getLinkOnceLinkage(true));\n\t\t}\n\t\t// Compile all Lua prototypes to LLVM IR\n\t\tcompiler->compileAll(L, p);\n\t\tif(LuaModule) {\n\t\t\t// Dump proto info to static variable and create 'luaopen_' function.\n\t\t\tdump_lua_module(p, output);\n\t\t} else {\n\t\t\t// Dump proto info to global for standalone exe.\n\t\t\tdump_standalone(p);\n\t\t\t// link with liblua_main.bc\n\t\t\tif(!NoMain) {\n\t\t\t\tliblua_main = load_liblua_main(getCtx(), true);\n\t\t\t\tif(llvm::Linker::LinkModules(M, liblua_main, llvm::Linker::DestroySource, &error)) {\n\t\t\t\t\tfprintf(stderr, \"Failed to link compiled Lua script with embedded 'liblua_main.bc': %s\",\n\t\t\t\t\t\terror.c_str());\n\t\t\t\t\texit(1);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tllvm::verifyModule(*M);\n\t\tllvm::WriteBitcodeToFile(M, *out);\n\t\tdelete out;\n\t} else {\n\t\tdelete out;\n\t\tfprintf(stderr, \"Failed to open output file: %s\",\n\t\t\terror.c_str());\n\t\texit(1);\n\t}\n}\n\nllvm::Constant *LLVMDumper::get_ptr(llvm::Constant *val) {\n\tstd::vector idxList;\n\tidxList.push_back(llvm::Constant::getNullValue(llvm::IntegerType::get(getCtx(), 32)));\n\tidxList.push_back(llvm::Constant::getNullValue(llvm::IntegerType::get(getCtx(), 32)));\n\treturn llvm::ConstantExpr::getGetElementPtr(val, idxList);\n}\n\nllvm::Constant *LLVMDumper::get_global_str(const char *str) {\n\tllvm::Constant *str_const = llvm::ConstantDataArray::getString(getCtx(), str, true);\n\tllvm::GlobalVariable *var_str = new llvm::GlobalVariable(*M, str_const->getType(), true,\n\t\tllvm::GlobalValue::InternalLinkage, str_const, \".str\");\n\treturn get_ptr(var_str);\n}\n\nllvm::GlobalVariable *LLVMDumper::dump_constants(Proto *p) {\n\tllvm::GlobalVariable *constant;\n\tllvm::Constant *array_struct;\n\tstd::vector array_struct_fields;\n\n\tfor(int i = 0; i < p->sizek; i++) {\n\t\tint const_type = 0;\n\t\tint const_length = 0;\n\t\tllvm::StructType *type;\n\t\tstd::vector tmp_struct;\n\t\tllvm::Constant *value;\n\t\tTValue *tval = &(p->k[i]);\n\t\tconst_length = 0;\n\t\tswitch(ttype(tval)) {\n\t\t\tcase LUA_TSTRING:\n\t\t\t\tconst_type = TYPE_STRING;\n\t\t\t\tconst_length = tsvalue(tval)->len;\n\t\t\t\ttype = Ty_constant_str_type;\n\t\t\t\ttmp_struct.push_back(get_global_str(svalue(tval)));\n\t\t\t\tif(str_padding != NULL) {\n\t\t\t\t\ttmp_struct.push_back(str_padding);\n\t\t\t\t}\n\t\t\t\tvalue = llvm::ConstantStruct::getAnon(getCtx(), tmp_struct, false);\n\t\t\t\tbreak;\n\t\t\tcase LUA_TBOOLEAN:\n\t\t\t\tconst_type = TYPE_BOOLEAN;\n\t\t\t\ttype = Ty_constant_bool_type;\n\t\t\t\ttmp_struct.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32, !l_isfalse(tval))));\n\t\t\t\tif(bool_padding != NULL) {\n\t\t\t\t\ttmp_struct.push_back(bool_padding);\n\t\t\t\t}\n\t\t\t\tvalue = llvm::ConstantStruct::getAnon(getCtx(), tmp_struct, false);\n\t\t\t\tbreak;\n\t\t\tcase LUA_TNUMBER:\n\t\t\t\tconst_type = TYPE_NUMBER;\n\t\t\t\ttype = Ty_constant_num_type;\n\t\t\t\ttmp_struct.push_back(llvm::ConstantFP::get(getCtx(), llvm::APFloat(nvalue(tval))));\n\t\t\t\tif(num_padding != NULL) {\n\t\t\t\t\ttmp_struct.push_back(num_padding);\n\t\t\t\t}\n\t\t\t\tvalue = llvm::ConstantStruct::getAnon(getCtx(), tmp_struct, false);\n\t\t\t\tbreak;\n\t\t\tcase LUA_TNIL:\n\t\t\tdefault:\n\t\t\t\tconst_type = TYPE_NIL;\n\t\t\t\ttype = Ty_constant_bool_type;\n\t\t\t\ttmp_struct.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32, 0)));\n\t\t\t\tif(bool_padding != NULL) {\n\t\t\t\t\ttmp_struct.push_back(bool_padding);\n\t\t\t\t}\n\t\t\t\tvalue = llvm::ConstantStruct::getAnon(getCtx(), tmp_struct, false);\n\t\t\t\tbreak;\n\t\t}\n\t\ttmp_struct.clear();\n\t\ttmp_struct.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32, const_type)));\n\t\ttmp_struct.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32, const_length)));\n\t\ttmp_struct.push_back(value);\n\t\tarray_struct_fields.push_back(llvm::ConstantStruct::get(type, tmp_struct));\n\t}\n\n\tarray_struct = llvm::ConstantStruct::getAnon(getCtx(), array_struct_fields, false);\n\tconstant = new llvm::GlobalVariable(*M, array_struct->getType(), true,\n\t\tllvm::GlobalValue::InternalLinkage, array_struct, \".constants\");\n\t//constant->setAlignment(32);\n\treturn constant;\n}\n\nllvm::GlobalVariable *LLVMDumper::dump_locvars(Proto *p) {\n\tllvm::GlobalVariable *constant;\n\tllvm::Constant *array_struct;\n\tstd::vector array_struct_fields;\n\tstd::vector tmp_struct;\n\n\tfor(int i = 0; i < p->sizelocvars; i++) {\n\t\tLocVar *locvar = &(p->locvars[i]);\n\t\ttmp_struct.clear();\n\t\ttmp_struct.push_back(get_global_str(getstr(locvar->varname)));\n\t\ttmp_struct.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32, locvar->startpc)));\n\t\ttmp_struct.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32, locvar->endpc)));\n\t\tarray_struct_fields.push_back(llvm::ConstantStruct::get(Ty_jit_LocVar, tmp_struct));\n\t}\n\n\tarray_struct = llvm::ConstantStruct::getAnon(getCtx(), array_struct_fields, false);\n\tconstant = new llvm::GlobalVariable(*M, array_struct->getType(), true,\n\t\tllvm::GlobalValue::InternalLinkage, array_struct, \".locvars\");\n\t//constant->setAlignment(32);\n\treturn constant;\n}\n\nllvm::GlobalVariable *LLVMDumper::dump_upvalues(Proto *p) {\n\tllvm::GlobalVariable *constant;\n\tllvm::Constant *array_struct;\n\tstd::vector array_struct_fields;\n\n\tfor(int i = 0; i < p->sizeupvalues; i++) {\n\t\tarray_struct_fields.push_back(get_global_str(getstr(p->upvalues[i])));\n\t}\n\n\tarray_struct = llvm::ConstantStruct::getAnon(getCtx(), array_struct_fields, false);\n\tconstant = new llvm::GlobalVariable(*M, array_struct->getType(), true,\n\t\tllvm::GlobalValue::InternalLinkage, array_struct, \".upvalues\");\n\t//constant->setAlignment(32);\n\treturn constant;\n}\n\nllvm::Constant *LLVMDumper::dump_proto(Proto *p) {\n\tstd::vector jit_proto_fields;\n\tstd::vector tmp_array;\n\tllvm::Function *func = (llvm::Function *)p->func_ref;\n\tllvm::GlobalVariable *tmp_global;\n\tllvm::Constant *tmp_constant;\n\n\t// name\n\tjit_proto_fields.push_back(get_global_str(getstr(p->source)));\n\t// jit_func\n\tif(func) {\n\t\tjit_proto_fields.push_back(func);\n\t} else {\n\t\tjit_proto_fields.push_back(llvm::Constant::getNullValue(lua_func_type_ptr));\n\t}\n\t// linedefined\n\tjit_proto_fields.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32,p->linedefined)));\n\t// lastlinedefined\n\tjit_proto_fields.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32,p->lastlinedefined)));\n\t// nups\n\tjit_proto_fields.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(8,p->nups)));\n\t// numparams\n\tjit_proto_fields.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(8,p->numparams)));\n\t// is_vararg\n\tjit_proto_fields.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(8,p->is_vararg)));\n\t// maxstacksize\n\tjit_proto_fields.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(8,p->maxstacksize)));\n\t// sizek\n\tjit_proto_fields.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(16,p->sizek)));\n\t// sizelocvars\n\tjit_proto_fields.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(16,p->sizelocvars)));\n\t// sizeupvalues\n\tjit_proto_fields.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32,p->sizeupvalues)));\n\t// sizep\n\tjit_proto_fields.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32,p->sizep)));\n\t// sizecode\n\tjit_proto_fields.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32,p->sizecode)));\n\t// sizelineinfo\n\tjit_proto_fields.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32,p->sizelineinfo)));\n\t// k\n\tjit_proto_fields.push_back(\n\t\tllvm::ConstantExpr::getCast(llvm::Instruction::BitCast,\n\t\t\tdump_constants(p), Ty_constant_type_ptr));\n\t// locvars\n\tjit_proto_fields.push_back(\n\t\tllvm::ConstantExpr::getCast(llvm::Instruction::BitCast,\n\t\t\tdump_locvars(p), Ty_jit_LocVar_ptr));\n\t// upvalues\n\tjit_proto_fields.push_back(\n\t\tllvm::ConstantExpr::getCast(llvm::Instruction::BitCast,\n\t\t\tdump_upvalues(p), llvm::PointerType::get(Ty_str_ptr, 0)));\n\t// p\n\tif(p->sizep > 0) {\n\t\ttmp_array.clear();\n\t\tfor(int i = 0; i < p->sizep; i++) {\n\t\t\ttmp_array.push_back(dump_proto(p->p[i]));\n\t\t}\n\t\ttmp_constant = llvm::ConstantArray::get(llvm::ArrayType::get(Ty_jit_proto,p->sizep),tmp_array);\n\t\ttmp_global = new llvm::GlobalVariable(*M, tmp_constant->getType(), false,\n\t\t\tllvm::GlobalValue::InternalLinkage, tmp_constant, \".sub_protos\");\n\t\tjit_proto_fields.push_back(get_ptr(tmp_global));\n\t} else {\n\t\tjit_proto_fields.push_back(llvm::Constant::getNullValue(Ty_jit_proto_ptr));\n\t}\n\t// code\n\tif(p->sizecode > 0) {\n\t\ttmp_array.clear();\n\t\tfor(int i = 0; i < p->sizecode; i++) {\n\t\t\ttmp_array.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32,p->code[i])));\n\t\t}\n\t\ttmp_constant = llvm::ConstantArray::get(llvm::ArrayType::get(llvm::IntegerType::get(getCtx(), 32),p->sizecode),tmp_array);\n\t\ttmp_global = new llvm::GlobalVariable(*M, tmp_constant->getType(), false,\n\t\t\tllvm::GlobalValue::InternalLinkage, tmp_constant, \".proto_code\");\n\t\tjit_proto_fields.push_back(get_ptr(tmp_global));\n\t} else {\n\t\tjit_proto_fields.push_back(llvm::Constant::getNullValue(llvm::PointerType::get(llvm::IntegerType::get(getCtx(), 32), 0)));\n\t}\n\t// lineinfo\n\tif(p->sizelineinfo > 0) {\n\t\ttmp_array.clear();\n\t\tfor(int i = 0; i < p->sizelineinfo; i++) {\n\t\t\ttmp_array.push_back(llvm::ConstantInt::get(getCtx(), llvm::APInt(32,p->lineinfo[i])));\n\t\t}\n\t\ttmp_constant = llvm::ConstantArray::get(llvm::ArrayType::get(llvm::IntegerType::get(getCtx(), 32),p->sizelineinfo),tmp_array);\n\t\ttmp_global = new llvm::GlobalVariable(*M, tmp_constant->getType(), false,\n\t\t\tllvm::GlobalValue::InternalLinkage, tmp_constant, \".proto_lineinfo\");\n\t\tjit_proto_fields.push_back(get_ptr(tmp_global));\n\t} else {\n\t\tjit_proto_fields.push_back(llvm::Constant::getNullValue(llvm::PointerType::get(llvm::IntegerType::get(getCtx(), 32), 0)));\n\t}\n\n\treturn llvm::ConstantStruct::get(Ty_jit_proto, jit_proto_fields);\n}\n\nvoid LLVMDumper::dump_standalone(Proto *p) {\n\t//\n\t// dump protos to a global variable for re-loading.\n\t//\n\tllvm::Constant *jit_proto = dump_proto(p);\n\t//llvm::GlobalVariable *gjit_proto_init = \n\tnew llvm::GlobalVariable(*M, Ty_jit_proto, false,\n\t\tllvm::GlobalValue::ExternalLinkage, jit_proto, \"jit_proto_init\");\n\t//gjit_proto_init->setAlignment(32);\n}\n\nvoid LLVMDumper::dump_lua_module(Proto *p, std::string mod_name) {\n\tllvm::IRBuilder<> Builder(getCtx());\n\tllvm::Function *func;\n\tllvm::Function *load_compiled_module_func;\n\tllvm::BasicBlock *block=NULL;\n\tllvm::Value *func_L;\n\tllvm::CallInst *call=NULL;\n\tstd::vector func_args;\n\tllvm::FunctionType *func_type;\n\tstd::string name = \"luaopen_\";\n\tstd::string tmp;\n\tsize_t n;\n\n\t//\n\t// normalize mod_name.\n\t//\n\n\t// remove '.bc' from end of mod_name.\n\tn = mod_name.size()-3;\n\tif(n > 0) {\n\t\ttmp = mod_name.substr(n, 3);\n\t\tif(tmp[0] == '.') {\n\t\t\tif(tmp[1] == 'b' || tmp[1] == 'B') {\n\t\t\t\tif(tmp[2] == 'c' || tmp[2] == 'C') {\n\t\t\t\t\tmod_name = mod_name.substr(0, n);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t// convert non-alphanum chars to '_'\n\tfor(n = 0; n < mod_name.size(); n++) {\n\t\tchar c = mod_name[n];\n\t\tif((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) continue;\n\t\tif(c == '\\n' || c == '\\r') {\n\t\t\tmod_name = mod_name.substr(0,n);\n\t\t\tbreak;\n\t\t}\n\t\tmod_name[n] = '_';\n\t}\n\n\t//\n\t// dump protos to a static variable for re-loading.\n\t//\n\tllvm::Constant *jit_proto = dump_proto(p);\n\tllvm::GlobalVariable *gjit_proto_init = new llvm::GlobalVariable(*M, Ty_jit_proto, false,\n\t\tllvm::GlobalValue::InternalLinkage, jit_proto, \"jit_proto_init\");\n\t//gjit_proto_init->setAlignment(32);\n\n\t//\n\t// dump 'luaopen_' for loading the module.\n\t//\n\tname.append(mod_name);\n\tfunc = llvm::Function::Create(lua_func_type, llvm::Function::ExternalLinkage, name, M);\n\t// name arg1 = \"L\"\n\tfunc_L = func->arg_begin();\n\tfunc_L->setName(\"L\");\n\t// entry block\n\tblock = llvm::BasicBlock::Create(getCtx(), \"entry\", func);\n\tBuilder.SetInsertPoint(block);\n\t// call 'load_compiled_module'\n\tload_compiled_module_func = M->getFunction(\"load_compiled_module\");\n\tif(load_compiled_module_func == NULL) {\n\t\tfunc_args.clear();\n\t\tfunc_args.push_back(func_L->getType());\n\t\tfunc_args.push_back(Ty_jit_proto_ptr);\n\t\tfunc_type = llvm::FunctionType::get(llvm::IntegerType::get(getCtx(), 32), func_args, false);\n\t\tload_compiled_module_func = llvm::Function::Create(func_type,\n\t\t\tllvm::Function::ExternalLinkage, \"load_compiled_module\", M);\n\t}\n\tcall=Builder.CreateCall2(load_compiled_module_func, func_L, gjit_proto_init);\n\tcall->setTailCall(true);\n\tBuilder.CreateRet(call);\n\n\t//func->dump();\n}\n\n" }, { "path": "llvm-lua/LLVMDumper.h", "content": "/*\n Copyright (c) 2009 Robert G. Jakabosky\n \n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n \n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n \n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n THE SOFTWARE.\n\n MIT License: http://www.opensource.org/licenses/mit-license.php\n*/\n\n#ifndef LLVMDUMPER_h\n#define LLVMDUMPER_h\n\n#include \"llvm/Module.h\"\n#include \"lua_core.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \"lobject.h\"\n\n#ifdef __cplusplus\n}\n#endif\n\nnamespace llvm {\nclass Module;\nclass Type;\nclass StructType;\nclass FunctionType;\nclass Constant;\nclass GlobalVariable;\n}\n\nclass LLVMCompiler;\n\nclass LLVMDumper {\nprivate:\n\tLLVMCompiler *compiler;\n\tllvm::Module *M;\n\n\t// types.\n\tllvm::Type *Ty_str_ptr;\n\tllvm::StructType *Ty_constant_value;\n\tllvm::StructType *Ty_constant_type;\n\tllvm::Type *Ty_constant_type_ptr;\n\tllvm::StructType *Ty_constant_num_type;\n\tllvm::Constant *num_padding;\n\tllvm::StructType *Ty_constant_bool_type;\n\tllvm::Constant *bool_padding;\n\tllvm::StructType *Ty_constant_str_type;\n\tllvm::Constant *str_padding;\n\tllvm::StructType *Ty_jit_LocVar;\n\tllvm::Type *Ty_jit_LocVar_ptr;\n\tllvm::StructType *Ty_jit_proto;\n\tllvm::Type *Ty_jit_proto_ptr;\n\tllvm::FunctionType *lua_func_type;\n\tllvm::Type *lua_func_type_ptr;\n\npublic:\n\tLLVMDumper(LLVMCompiler *compiler);\n\n\tvoid dump(const char *output, lua_State *L, Proto *p, int stripping);\n\n\tllvm::LLVMContext& getCtx() const {\n\t\treturn compiler->getCtx();\n\t}\n\nprivate:\n\tllvm::Constant *get_ptr(llvm::Constant *val);\n\n\tllvm::Constant *get_global_str(const char *str);\n\n\tllvm::GlobalVariable *dump_constants(Proto *p);\n\n\tllvm::GlobalVariable *dump_locvars(Proto *p);\n\n\tllvm::GlobalVariable *dump_upvalues(Proto *p);\n\n\tllvm::Constant *dump_proto(Proto *p);\n\n\tvoid dump_standalone(Proto *p);\n\n\tvoid dump_lua_module(Proto *p, std::string mod_name);\n\n};\n#endif\n\n" }, { "path": "llvm-lua/TODO", "content": "\noptimizations:\n* When the internal index/limit/step variable of a OP_FORLOOP get moved to the C-Stack the space on the Lua-stack is unused. We should be able to decrease the maxstacksize by re-using those stack slots.\n* Try to inline some table/global lookups if they have a constant key.\n\n" }, { "path": "llvm-lua/bin2c.c", "content": "/*\n * bin2c.c\n *\n * convert a binary file into a C source vector\n *\n * THE \"BEER-WARE LICENSE\" (Revision 3.1415):\n * sandro AT sigala DOT it wrote this file. As long as you retain this notice you can do\n * whatever you want with this stuff. If we meet some day, and you think this stuff is\n * worth it, you can buy me a beer in return. Sandro Sigala\n *\n * syntax: bin2c [-c] [-z] \n *\n * -c add the \"const\" keyword to definition\n * -z terminate the array with a zero (useful for embedded C strings)\n *\n * examples:\n * bin2c -c myimage.png myimage_png.cpp\n * bin2c -z sometext.txt sometext_txt.cpp\n */\n \n#include \n#include \n#include \n#include \n \n#ifndef PATH_MAX\n#define PATH_MAX 1024\n#endif\n \nint useconst = 0;\nint zeroterminated = 0;\n \nint myfgetc(FILE *f)\n{\n\tint c = fgetc(f);\n\tif (c == EOF && zeroterminated)\n\t{\n\t\tzeroterminated = 0;\n\t\treturn 0;\n\t}\n\treturn c;\n}\n \nvoid process(const char *ifname, const char *ofname)\n{\n\tFILE *ifile, *ofile;\n\tifile = fopen(ifname, \"rb\");\n\tif (ifile == NULL)\n\t{\n\t\tfprintf(stderr, \"cannot open %s for reading\\n\", ifname);\n\t\texit(1);\n\t}\n\tofile = fopen(ofname, \"wb\");\n\tif (ofile == NULL)\n\t{\n\t\tfprintf(stderr, \"cannot open %s for writing\\n\", ofname);\n\t\texit(1);\n\t}\n\tchar buf[PATH_MAX], *p;\n\tconst char *cp;\n\tif ((cp = strrchr(ifname, '/')) != NULL)\n\t{\n\t\t++cp;\n\t} else {\n\t\tif ((cp = strrchr(ifname, '\\\\')) != NULL)\n\t\t\t++cp;\n\t\telse\n\t\t\tcp = ifname;\n\t}\n\tstrcpy(buf, cp);\n\tfor (p = buf; *p != '\\0'; ++p)\n\t{\n\t\tif (!isalnum(*p))\n\t\t\t*p = '_';\n\t}\n\tfprintf(ofile, \"static %sunsigned char %s[] = {\\n\", useconst ? \"const \" : \"\", buf);\n\tint c, col = 1;\n\twhile ((c = myfgetc(ifile)) != EOF)\n\t{\n\t\tif (col >= 78 - 6)\n\t\t{\n\t\t\tfputc('\\n', ofile);\n\t\t\tcol = 1;\n\t\t}\n\t\tfprintf(ofile, \"0x%.2x,\", c);\n\t\tcol += 6;\n\t}\n\tfprintf(ofile, \"\\n};\\n\");\n \n\tfclose(ifile);\n\tfclose(ofile);\n}\n \nvoid usage(void)\n{\n\tfprintf(stderr, \"usage: bin2c [-cz] \\n\");\n\texit(1);\n}\n \nint main(int argc, char **argv)\n{\n\twhile (argc > 3)\n\t{\n\t\tif (!strcmp(argv[1], \"-c\"))\n\t\t{\n\t\t\tuseconst = 1;\n\t\t\t--argc;\n\t\t\t++argv;\n\t\t} else if (!strcmp(argv[1], \"-z\"))\n\t\t{\n\t\t\tzeroterminated = 1;\n\t\t\t--argc;\n\t\t\t++argv;\n\t\t} else {\n\t\t\tusage();\n\t\t}\n\t}\n\tif (argc != 3)\n\t{\n\t\tusage();\n\t}\n\tprocess(argv[1], argv[2]);\n\treturn 0;\n}\n\n" }, { "path": "llvm-lua/compile_all.sh", "content": "#!/usr/bin/env bash\n#\n\nOPTS=\"\"\nFILES=\"\"\n# parse command line parameters.\nfor arg in \"$@\" ; do\n\tcase \"$arg\" in\n\t-*) OPTS=\"$OPTS $arg\" ;;\n\t*) FILES=\"$FILES $arg\" ;;\n\tesac\ndone\n\nfor script in $FILES; do\n\techo \"Compiling script: $script\"\n\tlua-compiler $OPTS $script\n\t#./lua-compiler $OPTS $script\ndone\n\n" }, { "path": "llvm-lua/hook_parser.c", "content": "/*\n** See Copyright Notice in lua.h\n*/\n\n/*\n* hook_parser.c - Add a hook to the parser in ldo.c\n*\n* Most of this code is from ldo.c\n*/\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#if !ENABLE_PARSER_HOOK\n\n#include \"ldo.c\"\n\nint llvm_precall_lua (lua_State *L, StkId func, int nresults) {\n return luaD_precall_lua(L, func, nresults);\n}\n\n#else\n\n#include \"llvm_compiler.h\"\n\n#define luaD_protectedparser luaD_protectedparser_old\n#include \"ldo.c\"\n#undef luaD_protectedparser\n\nstatic void llvm_f_parser (lua_State *L, void *ud) {\n int i;\n Proto *tf;\n Closure *cl;\n struct SParser *p = cast(struct SParser *, ud);\n int c = luaZ_lookahead(p->z);\n luaC_checkGC(L);\n set_block_gc(L); /* stop collector during parsing */\n tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,\n &p->buff, p->name);\n llvm_compiler_compile_all(L, tf);\n cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));\n cl->l.p = tf;\n for (i = 0; i < tf->nups; i++) /* initialize eventual upvalues */\n cl->l.upvals[i] = luaF_newupval(L);\n setclvalue(L, L->top, cl);\n incr_top(L);\n unset_block_gc(L);\n}\n\n\nint luaD_protectedparser (lua_State *L, ZIO *z, const char *name) {\n struct SParser p;\n int status;\n p.z = z; p.name = name;\n luaZ_initbuffer(L, &p.buff);\n status = luaD_pcall(L, llvm_f_parser, &p, savestack(L, L->top), L->errfunc);\n luaZ_freebuffer(L, &p.buff);\n return status;\n}\n\nint llvm_precall_jit (lua_State *L, StkId func, int nresults) {\n Closure *cl;\n ptrdiff_t funcr;\n CallInfo *ci;\n StkId st, base;\n Proto *p;\n\n funcr = savestack(L, func);\n cl = clvalue(func);\n p = cl->l.p;\n luaD_checkstack(L, p->maxstacksize);\n func = restorestack(L, funcr);\n base = func + 1;\n if (L->top > base + p->numparams)\n L->top = base + p->numparams;\n ci = L->ci; /* now `enter' new function */\n ci->func = func;\n L->base = ci->base = base;\n ci->top = L->base + p->maxstacksize;\n lua_assert(ci->top <= L->stack_last);\n L->savedpc = p->code; /* starting point */\n ci->nresults = nresults;\n for (st = L->top; st < ci->top; st++)\n setnilvalue(st);\n L->top = ci->top;\n if (L->hookmask & LUA_MASKCALL) {\n L->savedpc++; /* hooks assume 'pc' is already incremented */\n luaD_callhook(L, LUA_HOOKCALL, -1);\n L->savedpc--; /* correct 'pc' */\n }\n return (p->jit_func)(L); /* do the actual call */\n}\n\nint llvm_precall_jit_vararg (lua_State *L, StkId func, int nresults) {\n Closure *cl;\n ptrdiff_t funcr;\n CallInfo *ci;\n StkId st, base;\n Proto *p;\n int nargs;\n\n funcr = savestack(L, func);\n cl = clvalue(func);\n p = cl->l.p;\n luaD_checkstack(L, p->maxstacksize);\n func = restorestack(L, funcr);\n nargs = cast_int(L->top - func) - 1;\n base = adjust_varargs(L, p, nargs);\n func = restorestack(L, funcr); /* previous call may change the stack */\n ci = L->ci; /* now `enter' new function */\n ci->func = func;\n L->base = ci->base = base;\n ci->top = L->base + p->maxstacksize;\n lua_assert(ci->top <= L->stack_last);\n L->savedpc = p->code; /* starting point */\n ci->nresults = nresults;\n for (st = L->top; st < ci->top; st++)\n setnilvalue(st);\n L->top = ci->top;\n if (L->hookmask & LUA_MASKCALL) {\n L->savedpc++; /* hooks assume 'pc' is already incremented */\n luaD_callhook(L, LUA_HOOKCALL, -1);\n L->savedpc--; /* correct 'pc' */\n }\n return (p->jit_func)(L); /* do the actual call */\n}\n\nint llvm_precall_lua (lua_State *L, StkId func, int nresults) {\n Closure *cl;\n Proto *p;\n\n cl = clvalue(func);\n p = cl->l.p;\n /* check if Function needs to be compiled. */\n if(p->jit_func == NULL) {\n llvm_compiler_compile(L, p);\n }\n if(p->jit_func != NULL) {\n if (!p->is_vararg) { /* no varargs? */\n cl->l.precall = llvm_precall_jit;\n return llvm_precall_jit(L, func, nresults);\n } else {\n cl->l.precall = llvm_precall_jit_vararg;\n return llvm_precall_jit_vararg(L, func, nresults);\n }\n }\n /* function didn't compile, fall-back to lua interpreter */\n cl->l.precall = luaD_precall_lua;\n return luaD_precall_lua(L, func, nresults);\n}\n\n#endif\n\n#ifdef __cplusplus\n}\n#endif\n\n" }, { "path": "llvm-lua/llvm-lua.cpp", "content": "/*\n Copyright (c) 2009 Robert G. Jakabosky\n\n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n THE SOFTWARE.\n\n MIT License: http://www.opensource.org/licenses/mit-license.php\n*/\n\n#include \n\n#include \"llvm_compiler.h\"\n#include \"lua_interpreter.h\"\n\n#include \"llvm/Support/CommandLine.h\"\n#include \"llvm/Support/ManagedStatic.h\"\n\nnamespace {\n llvm::cl::opt\n InputFile(llvm::cl::Positional, llvm::cl::desc(\"