├── .gitignore ├── COPYRIGHT ├── HISTORY ├── INSTALL ├── Makefile ├── README ├── doc ├── amazon.gif ├── contents.html ├── cover.png ├── logo.gif ├── lua.1 ├── lua.css ├── lua.html ├── luac.1 ├── luac.html ├── manual.css ├── manual.html └── readme.html ├── etc ├── Makefile ├── README ├── all.c ├── lua.hpp ├── lua.ico ├── lua.pc ├── luavs.bat ├── min.c ├── noparser.c └── strict.lua ├── src ├── Makefile ├── lapi.c ├── lapi.h ├── lauxlib.c ├── lauxlib.h ├── lbaselib.c ├── lcode.c ├── lcode.h ├── ldblib.c ├── ldebug.c ├── ldebug.h ├── ldo.c ├── ldo.h ├── ldump.c ├── lfunc.c ├── lfunc.h ├── lgc.c ├── lgc.h ├── linit.c ├── liolib.c ├── llex.c ├── llex.h ├── llimits.h ├── lmathlib.c ├── lmem.c ├── lmem.h ├── loadlib.c ├── lobject.c ├── lobject.h ├── lopcodes.c ├── lopcodes.h ├── loslib.c ├── lparser.c ├── lparser.h ├── lstate.c ├── lstate.h ├── lstring.c ├── lstring.h ├── lstrlib.c ├── ltable.c ├── ltable.h ├── ltablib.c ├── ltm.c ├── ltm.h ├── lua.c ├── lua.h ├── luac.c ├── luaconf.h ├── lualib.h ├── lundump.c ├── lundump.h ├── lvm.c ├── lvm.h ├── lzio.c ├── lzio.h ├── print.c └── tags └── test ├── Makefile ├── README ├── bisect.lua ├── cf.lua ├── echo.lua ├── env.lua ├── factorial.lua ├── fib.lua ├── fibfor.lua ├── globals.lua ├── hello.lua ├── life.lua ├── luac.lua ├── my.lua ├── printf.lua ├── readonly.lua ├── sieve.lua ├── sort.lua ├── table.lua ├── test.c ├── testusrdata.c ├── trace-calls.lua ├── trace-globals.lua └── xd.lua /.gitignore: -------------------------------------------------------------------------------- 1 | cscope* 2 | tags* 3 | -------------------------------------------------------------------------------- /COPYRIGHT: -------------------------------------------------------------------------------- 1 | Lua License 2 | ----------- 3 | 4 | Lua is licensed under the terms of the MIT license reproduced below. 5 | This means that Lua is free software and can be used for both academic 6 | and commercial purposes at absolutely no cost. 7 | 8 | For details and rationale, see http://www.lua.org/license.html . 9 | 10 | =============================================================================== 11 | 12 | Copyright (C) 1994-2008 Lua.org, PUC-Rio. 13 | 14 | Permission is hereby granted, free of charge, to any person obtaining a copy 15 | of this software and associated documentation files (the "Software"), to deal 16 | in the Software without restriction, including without limitation the rights 17 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 18 | copies of the Software, and to permit persons to whom the Software is 19 | furnished to do so, subject to the following conditions: 20 | 21 | The above copyright notice and this permission notice shall be included in 22 | all copies or substantial portions of the Software. 23 | 24 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 25 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 26 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 27 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 28 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 29 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 30 | THE SOFTWARE. 31 | 32 | =============================================================================== 33 | 34 | (end of COPYRIGHT) 35 | -------------------------------------------------------------------------------- /HISTORY: -------------------------------------------------------------------------------- 1 | HISTORY for Lua 5.1 2 | 3 | * Changes from version 5.0 to 5.1 4 | ------------------------------- 5 | Language: 6 | + new module system. 7 | + new semantics for control variables of fors. 8 | + new semantics for setn/getn. 9 | + new syntax/semantics for varargs. 10 | + new long strings and comments. 11 | + new `mod' operator (`%') 12 | + new length operator #t 13 | + metatables for all types 14 | API: 15 | + new functions: lua_createtable, lua_get(set)field, lua_push(to)integer. 16 | + user supplies memory allocator (lua_open becomes lua_newstate). 17 | + luaopen_* functions must be called through Lua. 18 | Implementation: 19 | + new configuration scheme via luaconf.h. 20 | + incremental garbage collection. 21 | + better handling of end-of-line in the lexer. 22 | + fully reentrant parser (new Lua function `load') 23 | + better support for 64-bit machines. 24 | + native loadlib support for Mac OS X. 25 | + standard distribution in only one library (lualib.a merged into lua.a) 26 | 27 | * Changes from version 4.0 to 5.0 28 | ------------------------------- 29 | Language: 30 | + lexical scoping. 31 | + Lua coroutines. 32 | + standard libraries now packaged in tables. 33 | + tags replaced by metatables and tag methods replaced by metamethods, 34 | stored in metatables. 35 | + proper tail calls. 36 | + each function can have its own global table, which can be shared. 37 | + new __newindex metamethod, called when we insert a new key into a table. 38 | + new block comments: --[[ ... ]]. 39 | + new generic for. 40 | + new weak tables. 41 | + new boolean type. 42 | + new syntax "local function". 43 | + (f()) returns the first value returned by f. 44 | + {f()} fills a table with all values returned by f. 45 | + \n ignored in [[\n . 46 | + fixed and-or priorities. 47 | + more general syntax for function definition (e.g. function a.x.y:f()...end). 48 | + more general syntax for function calls (e.g. (print or write)(9)). 49 | + new functions (time/date, tmpfile, unpack, require, load*, etc.). 50 | API: 51 | + chunks are loaded by using lua_load; new luaL_loadfile and luaL_loadbuffer. 52 | + introduced lightweight userdata, a simple "void*" without a metatable. 53 | + new error handling protocol: the core no longer prints error messages; 54 | all errors are reported to the caller on the stack. 55 | + new lua_atpanic for host cleanup. 56 | + new, signal-safe, hook scheme. 57 | Implementation: 58 | + new license: MIT. 59 | + new, faster, register-based virtual machine. 60 | + support for external multithreading and coroutines. 61 | + new and consistent error message format. 62 | + the core no longer needs "stdio.h" for anything (except for a single 63 | use of sprintf to convert numbers to strings). 64 | + lua.c now runs the environment variable LUA_INIT, if present. It can 65 | be "@filename", to run a file, or the chunk itself. 66 | + support for user extensions in lua.c. 67 | sample implementation given for command line editing. 68 | + new dynamic loading library, active by default on several platforms. 69 | + safe garbage-collector metamethods. 70 | + precompiled bytecodes checked for integrity (secure binary dostring). 71 | + strings are fully aligned. 72 | + position capture in string.find. 73 | + read('*l') can read lines with embedded zeros. 74 | 75 | * Changes from version 3.2 to 4.0 76 | ------------------------------- 77 | Language: 78 | + new "break" and "for" statements (both numerical and for tables). 79 | + uniform treatment of globals: globals are now stored in a Lua table. 80 | + improved error messages. 81 | + no more '$debug': full speed *and* full debug information. 82 | + new read form: read(N) for next N bytes. 83 | + general read patterns now deprecated. 84 | (still available with -DCOMPAT_READPATTERNS.) 85 | + all return values are passed as arguments for the last function 86 | (old semantics still available with -DLUA_COMPAT_ARGRET) 87 | + garbage collection tag methods for tables now deprecated. 88 | + there is now only one tag method for order. 89 | API: 90 | + New API: fully re-entrant, simpler, and more efficient. 91 | + New debug API. 92 | Implementation: 93 | + faster than ever: cleaner virtual machine and new hashing algorithm. 94 | + non-recursive garbage-collector algorithm. 95 | + reduced memory usage for programs with many strings. 96 | + improved treatment for memory allocation errors. 97 | + improved support for 16-bit machines (we hope). 98 | + code now compiles unmodified as both ANSI C and C++. 99 | + numbers in bases other than 10 are converted using strtoul. 100 | + new -f option in Lua to support #! scripts. 101 | + luac can now combine text and binaries. 102 | 103 | * Changes from version 3.1 to 3.2 104 | ------------------------------- 105 | + redirected all output in Lua's core to _ERRORMESSAGE and _ALERT. 106 | + increased limit on the number of constants and globals per function 107 | (from 2^16 to 2^24). 108 | + debugging info (lua_debug and hooks) moved into lua_state and new API 109 | functions provided to get and set this info. 110 | + new debug lib gives full debugging access within Lua. 111 | + new table functions "foreachi", "sort", "tinsert", "tremove", "getn". 112 | + new io functions "flush", "seek". 113 | 114 | * Changes from version 3.0 to 3.1 115 | ------------------------------- 116 | + NEW FEATURE: anonymous functions with closures (via "upvalues"). 117 | + new syntax: 118 | - local variables in chunks. 119 | - better scope control with DO block END. 120 | - constructors can now be also written: { record-part; list-part }. 121 | - more general syntax for function calls and lvalues, e.g.: 122 | f(x).y=1 123 | o:f(x,y):g(z) 124 | f"string" is sugar for f("string") 125 | + strings may now contain arbitrary binary data (e.g., embedded zeros). 126 | + major code re-organization and clean-up; reduced module interdependecies. 127 | + no arbitrary limits on the total number of constants and globals. 128 | + support for multiple global contexts. 129 | + better syntax error messages. 130 | + new traversal functions "foreach" and "foreachvar". 131 | + the default for numbers is now double. 132 | changing it to use floats or longs is easy. 133 | + complete debug information stored in pre-compiled chunks. 134 | + sample interpreter now prompts user when run interactively, and also 135 | handles control-C interruptions gracefully. 136 | 137 | * Changes from version 2.5 to 3.0 138 | ------------------------------- 139 | + NEW CONCEPT: "tag methods". 140 | Tag methods replace fallbacks as the meta-mechanism for extending the 141 | semantics of Lua. Whereas fallbacks had a global nature, tag methods 142 | work on objects having the same tag (e.g., groups of tables). 143 | Existing code that uses fallbacks should work without change. 144 | + new, general syntax for constructors {[exp] = exp, ... }. 145 | + support for handling variable number of arguments in functions (varargs). 146 | + support for conditional compilation ($if ... $else ... $end). 147 | + cleaner semantics in API simplifies host code. 148 | + better support for writing libraries (auxlib.h). 149 | + better type checking and error messages in the standard library. 150 | + luac can now also undump. 151 | 152 | * Changes from version 2.4 to 2.5 153 | ------------------------------- 154 | + io and string libraries are now based on pattern matching; 155 | the old libraries are still available for compatibility 156 | + dofile and dostring can now return values (via return statement) 157 | + better support for 16- and 64-bit machines 158 | + expanded documentation, with more examples 159 | 160 | * Changes from version 2.2 to 2.4 161 | ------------------------------- 162 | + external compiler creates portable binary files that can be loaded faster 163 | + interface for debugging and profiling 164 | + new "getglobal" fallback 165 | + new functions for handling references to Lua objects 166 | + new functions in standard lib 167 | + only one copy of each string is stored 168 | + expanded documentation, with more examples 169 | 170 | * Changes from version 2.1 to 2.2 171 | ------------------------------- 172 | + functions now may be declared with any "lvalue" as a name 173 | + garbage collection of functions 174 | + support for pipes 175 | 176 | * Changes from version 1.1 to 2.1 177 | ------------------------------- 178 | + object-oriented support 179 | + fallbacks 180 | + simplified syntax for tables 181 | + many internal improvements 182 | 183 | (end of HISTORY) 184 | -------------------------------------------------------------------------------- /INSTALL: -------------------------------------------------------------------------------- 1 | INSTALL for Lua 5.1 2 | 3 | * Building Lua 4 | ------------ 5 | Lua is built in the src directory, but the build process can be 6 | controlled from the top-level Makefile. 7 | 8 | Building Lua on Unix systems should be very easy. First do "make" and 9 | see if your platform is listed. If so, just do "make xxx", where xxx 10 | is your platform name. The platforms currently supported are: 11 | aix ansi bsd freebsd generic linux macosx mingw posix solaris 12 | 13 | If your platform is not listed, try the closest one or posix, generic, 14 | ansi, in this order. 15 | 16 | See below for customization instructions and for instructions on how 17 | to build with other Windows compilers. 18 | 19 | If you want to check that Lua has been built correctly, do "make test" 20 | after building Lua. Also, have a look at the example programs in test. 21 | 22 | * Installing Lua 23 | -------------- 24 | Once you have built Lua, you may want to install it in an official 25 | place in your system. In this case, do "make install". The official 26 | place and the way to install files are defined in Makefile. You must 27 | have the right permissions to install files. 28 | 29 | If you want to build and install Lua in one step, do "make xxx install", 30 | where xxx is your platform name. 31 | 32 | If you want to install Lua locally, then do "make local". This will 33 | create directories bin, include, lib, man, and install Lua there as 34 | follows: 35 | 36 | bin: lua luac 37 | include: lua.h luaconf.h lualib.h lauxlib.h lua.hpp 38 | lib: liblua.a 39 | man/man1: lua.1 luac.1 40 | 41 | These are the only directories you need for development. 42 | 43 | There are man pages for lua and luac, in both nroff and html, and a 44 | reference manual in html in doc, some sample code in test, and some 45 | useful stuff in etc. You don't need these directories for development. 46 | 47 | If you want to install Lua locally, but in some other directory, do 48 | "make install INSTALL_TOP=xxx", where xxx is your chosen directory. 49 | 50 | See below for instructions for Windows and other systems. 51 | 52 | * Customization 53 | ------------- 54 | Three things can be customized by editing a file: 55 | - Where and how to install Lua -- edit Makefile. 56 | - How to build Lua -- edit src/Makefile. 57 | - Lua features -- edit src/luaconf.h. 58 | 59 | You don't actually need to edit the Makefiles because you may set the 60 | relevant variables when invoking make. 61 | 62 | On the other hand, if you need to select some Lua features, you'll need 63 | to edit src/luaconf.h. The edited file will be the one installed, and 64 | it will be used by any Lua clients that you build, to ensure consistency. 65 | 66 | We strongly recommend that you enable dynamic loading. This is done 67 | automatically for all platforms listed above that have this feature 68 | (and also Windows). See src/luaconf.h and also src/Makefile. 69 | 70 | * Building Lua on Windows and other systems 71 | ----------------------------------------- 72 | If you're not using the usual Unix tools, then the instructions for 73 | building Lua depend on the compiler you use. You'll need to create 74 | projects (or whatever your compiler uses) for building the library, 75 | the interpreter, and the compiler, as follows: 76 | 77 | library: lapi.c lcode.c ldebug.c ldo.c ldump.c lfunc.c lgc.c llex.c 78 | lmem.c lobject.c lopcodes.c lparser.c lstate.c lstring.c 79 | ltable.c ltm.c lundump.c lvm.c lzio.c 80 | lauxlib.c lbaselib.c ldblib.c liolib.c lmathlib.c loslib.c 81 | ltablib.c lstrlib.c loadlib.c linit.c 82 | 83 | interpreter: library, lua.c 84 | 85 | compiler: library, luac.c print.c 86 | 87 | If you use Visual Studio .NET, you can use etc/luavs.bat in its 88 | "Command Prompt". 89 | 90 | If all you want is to build the Lua interpreter, you may put all .c files 91 | in a single project, except for luac.c and print.c. Or just use etc/all.c. 92 | 93 | To use Lua as a library in your own programs, you'll need to know how to 94 | create and use libraries with your compiler. 95 | 96 | As mentioned above, you may edit luaconf.h to select some features before 97 | building Lua. 98 | 99 | (end of INSTALL) 100 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | # makefile for installing Lua 2 | # see INSTALL for installation instructions 3 | # see src/Makefile and src/luaconf.h for further customization 4 | 5 | # == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT ======================= 6 | 7 | # Your platform. See PLATS for possible values. 8 | PLAT= none 9 | 10 | # Where to install. The installation starts in the src and doc directories, 11 | # so take care if INSTALL_TOP is not an absolute path. 12 | INSTALL_TOP= /usr/local 13 | INSTALL_BIN= $(INSTALL_TOP)/bin 14 | INSTALL_INC= $(INSTALL_TOP)/include 15 | INSTALL_LIB= $(INSTALL_TOP)/lib 16 | INSTALL_MAN= $(INSTALL_TOP)/man/man1 17 | # 18 | # You probably want to make INSTALL_LMOD and INSTALL_CMOD consistent with 19 | # LUA_ROOT, LUA_LDIR, and LUA_CDIR in luaconf.h (and also with etc/lua.pc). 20 | INSTALL_LMOD= $(INSTALL_TOP)/share/lua/$V 21 | INSTALL_CMOD= $(INSTALL_TOP)/lib/lua/$V 22 | 23 | # How to install. If your install program does not support "-p", then you 24 | # may have to run ranlib on the installed liblua.a (do "make ranlib"). 25 | INSTALL= install -p 26 | INSTALL_EXEC= $(INSTALL) -m 0755 27 | INSTALL_DATA= $(INSTALL) -m 0644 28 | # 29 | # If you don't have install you can use cp instead. 30 | # INSTALL= cp -p 31 | # INSTALL_EXEC= $(INSTALL) 32 | # INSTALL_DATA= $(INSTALL) 33 | 34 | # Utilities. 35 | MKDIR= mkdir -p 36 | RANLIB= ranlib 37 | 38 | # == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE ========= 39 | 40 | # Convenience platforms targets. 41 | PLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris 42 | 43 | # What to install. 44 | TO_BIN= lua luac 45 | TO_INC= lua.h luaconf.h lualib.h lauxlib.h ../etc/lua.hpp 46 | TO_LIB= liblua.a 47 | TO_MAN= lua.1 luac.1 48 | 49 | # Lua version and release. 50 | V= 5.1 51 | R= 5.1.4 52 | 53 | all: $(PLAT) 54 | 55 | $(PLATS) clean: 56 | cd src && $(MAKE) $@ 57 | 58 | test: dummy 59 | src/lua test/hello.lua 60 | 61 | install: dummy 62 | cd src && $(MKDIR) $(INSTALL_BIN) $(INSTALL_INC) $(INSTALL_LIB) $(INSTALL_MAN) $(INSTALL_LMOD) $(INSTALL_CMOD) 63 | cd src && $(INSTALL_EXEC) $(TO_BIN) $(INSTALL_BIN) 64 | cd src && $(INSTALL_DATA) $(TO_INC) $(INSTALL_INC) 65 | cd src && $(INSTALL_DATA) $(TO_LIB) $(INSTALL_LIB) 66 | cd doc && $(INSTALL_DATA) $(TO_MAN) $(INSTALL_MAN) 67 | 68 | ranlib: 69 | cd src && cd $(INSTALL_LIB) && $(RANLIB) $(TO_LIB) 70 | 71 | local: 72 | $(MAKE) install INSTALL_TOP=.. 73 | 74 | none: 75 | @echo "Please do" 76 | @echo " make PLATFORM" 77 | @echo "where PLATFORM is one of these:" 78 | @echo " $(PLATS)" 79 | @echo "See INSTALL for complete instructions." 80 | 81 | # make may get confused with test/ and INSTALL in a case-insensitive OS 82 | dummy: 83 | 84 | # echo config parameters 85 | echo: 86 | @echo "" 87 | @echo "These are the parameters currently set in src/Makefile to build Lua $R:" 88 | @echo "" 89 | @cd src && $(MAKE) -s echo 90 | @echo "" 91 | @echo "These are the parameters currently set in Makefile to install Lua $R:" 92 | @echo "" 93 | @echo "PLAT = $(PLAT)" 94 | @echo "INSTALL_TOP = $(INSTALL_TOP)" 95 | @echo "INSTALL_BIN = $(INSTALL_BIN)" 96 | @echo "INSTALL_INC = $(INSTALL_INC)" 97 | @echo "INSTALL_LIB = $(INSTALL_LIB)" 98 | @echo "INSTALL_MAN = $(INSTALL_MAN)" 99 | @echo "INSTALL_LMOD = $(INSTALL_LMOD)" 100 | @echo "INSTALL_CMOD = $(INSTALL_CMOD)" 101 | @echo "INSTALL_EXEC = $(INSTALL_EXEC)" 102 | @echo "INSTALL_DATA = $(INSTALL_DATA)" 103 | @echo "" 104 | @echo "See also src/luaconf.h ." 105 | @echo "" 106 | 107 | # echo private config parameters 108 | pecho: 109 | @echo "V = $(V)" 110 | @echo "R = $(R)" 111 | @echo "TO_BIN = $(TO_BIN)" 112 | @echo "TO_INC = $(TO_INC)" 113 | @echo "TO_LIB = $(TO_LIB)" 114 | @echo "TO_MAN = $(TO_MAN)" 115 | 116 | # echo config parameters as Lua code 117 | # uncomment the last sed expression if you want nil instead of empty strings 118 | lecho: 119 | @echo "-- installation parameters for Lua $R" 120 | @echo "VERSION = '$V'" 121 | @echo "RELEASE = '$R'" 122 | @$(MAKE) echo | grep = | sed -e 's/= /= "/' -e 's/$$/"/' #-e 's/""/nil/' 123 | @echo "-- EOF" 124 | 125 | # list targets that do not create files (but not all makes understand .PHONY) 126 | .PHONY: all $(PLATS) clean test install local none dummy echo pecho lecho 127 | 128 | # (end of Makefile) 129 | -------------------------------------------------------------------------------- /README: -------------------------------------------------------------------------------- 1 | README for Lua 5.1 2 | 3 | See INSTALL for installation instructions. 4 | See HISTORY for a summary of changes since the last released version. 5 | 6 | * What is Lua? 7 | ------------ 8 | Lua is a powerful, light-weight programming language designed for extending 9 | applications. Lua is also frequently used as a general-purpose, stand-alone 10 | language. Lua is free software. 11 | 12 | For complete information, visit Lua's web site at http://www.lua.org/ . 13 | For an executive summary, see http://www.lua.org/about.html . 14 | 15 | Lua has been used in many different projects around the world. 16 | For a short list, see http://www.lua.org/uses.html . 17 | 18 | * Availability 19 | ------------ 20 | Lua is freely available for both academic and commercial purposes. 21 | See COPYRIGHT and http://www.lua.org/license.html for details. 22 | Lua can be downloaded at http://www.lua.org/download.html . 23 | 24 | * Installation 25 | ------------ 26 | Lua is implemented in pure ANSI C, and compiles unmodified in all known 27 | platforms that have an ANSI C compiler. In most Unix-like platforms, simply 28 | do "make" with a suitable target. See INSTALL for detailed instructions. 29 | 30 | * Origin 31 | ------ 32 | Lua is developed at Lua.org, a laboratory of the Department of Computer 33 | Science of PUC-Rio (the Pontifical Catholic University of Rio de Janeiro 34 | in Brazil). 35 | For more information about the authors, see http://www.lua.org/authors.html . 36 | 37 | (end of README) 38 | -------------------------------------------------------------------------------- /doc/amazon.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lichuang/Lua-5.1.4-codedump/7e5a0089d4a3199318230c2832c3e5c103f55437/doc/amazon.gif -------------------------------------------------------------------------------- /doc/contents.html: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lichuang/Lua-5.1.4-codedump/7e5a0089d4a3199318230c2832c3e5c103f55437/doc/contents.html -------------------------------------------------------------------------------- /doc/cover.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lichuang/Lua-5.1.4-codedump/7e5a0089d4a3199318230c2832c3e5c103f55437/doc/cover.png -------------------------------------------------------------------------------- /doc/logo.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lichuang/Lua-5.1.4-codedump/7e5a0089d4a3199318230c2832c3e5c103f55437/doc/logo.gif -------------------------------------------------------------------------------- /doc/lua.1: -------------------------------------------------------------------------------- 1 | .\" $Id: lua.man,v 1.11 2006/01/06 16:03:34 lhf Exp $ 2 | .TH LUA 1 "$Date: 2006/01/06 16:03:34 $" 3 | .SH NAME 4 | lua \- Lua interpreter 5 | .SH SYNOPSIS 6 | .B lua 7 | [ 8 | .I options 9 | ] 10 | [ 11 | .I script 12 | [ 13 | .I args 14 | ] 15 | ] 16 | .SH DESCRIPTION 17 | .B lua 18 | is the stand-alone Lua interpreter. 19 | It loads and executes Lua programs, 20 | either in textual source form or 21 | in precompiled binary form. 22 | (Precompiled binaries are output by 23 | .BR luac , 24 | the Lua compiler.) 25 | .B lua 26 | can be used as a batch interpreter and also interactively. 27 | .LP 28 | The given 29 | .I options 30 | (see below) 31 | are executed and then 32 | the Lua program in file 33 | .I script 34 | is loaded and executed. 35 | The given 36 | .I args 37 | are available to 38 | .I script 39 | as strings in a global table named 40 | .BR arg . 41 | If these arguments contain spaces or other characters special to the shell, 42 | then they should be quoted 43 | (but note that the quotes will be removed by the shell). 44 | The arguments in 45 | .B arg 46 | start at 0, 47 | which contains the string 48 | .RI ' script '. 49 | The index of the last argument is stored in 50 | .BR arg.n . 51 | The arguments given in the command line before 52 | .IR script , 53 | including the name of the interpreter, 54 | are available in negative indices in 55 | .BR arg . 56 | .LP 57 | At the very start, 58 | before even handling the command line, 59 | .B lua 60 | executes the contents of the environment variable 61 | .BR LUA_INIT , 62 | if it is defined. 63 | If the value of 64 | .B LUA_INIT 65 | is of the form 66 | .RI '@ filename ', 67 | then 68 | .I filename 69 | is executed. 70 | Otherwise, the string is assumed to be a Lua statement and is executed. 71 | .LP 72 | Options start with 73 | .B '\-' 74 | and are described below. 75 | You can use 76 | .B "'\--'" 77 | to signal the end of options. 78 | .LP 79 | If no arguments are given, 80 | then 81 | .B "\-v \-i" 82 | is assumed when the standard input is a terminal; 83 | otherwise, 84 | .B "\-" 85 | is assumed. 86 | .LP 87 | In interactive mode, 88 | .B lua 89 | prompts the user, 90 | reads lines from the standard input, 91 | and executes them as they are read. 92 | If a line does not contain a complete statement, 93 | then a secondary prompt is displayed and 94 | lines are read until a complete statement is formed or 95 | a syntax error is found. 96 | So, one way to interrupt the reading of an incomplete statement is 97 | to force a syntax error: 98 | adding a 99 | .B ';' 100 | in the middle of a statement is a sure way of forcing a syntax error 101 | (except inside multiline strings and comments; these must be closed explicitly). 102 | If a line starts with 103 | .BR '=' , 104 | then 105 | .B lua 106 | displays the values of all the expressions in the remainder of the 107 | line. The expressions must be separated by commas. 108 | The primary prompt is the value of the global variable 109 | .BR _PROMPT , 110 | if this value is a string; 111 | otherwise, the default prompt is used. 112 | Similarly, the secondary prompt is the value of the global variable 113 | .BR _PROMPT2 . 114 | So, 115 | to change the prompts, 116 | set the corresponding variable to a string of your choice. 117 | You can do that after calling the interpreter 118 | or on the command line 119 | (but in this case you have to be careful with quotes 120 | if the prompt string contains a space; otherwise you may confuse the shell.) 121 | The default prompts are "> " and ">> ". 122 | .SH OPTIONS 123 | .TP 124 | .B \- 125 | load and execute the standard input as a file, 126 | that is, 127 | not interactively, 128 | even when the standard input is a terminal. 129 | .TP 130 | .BI \-e " stat" 131 | execute statement 132 | .IR stat . 133 | You need to quote 134 | .I stat 135 | if it contains spaces, quotes, 136 | or other characters special to the shell. 137 | .TP 138 | .B \-i 139 | enter interactive mode after 140 | .I script 141 | is executed. 142 | .TP 143 | .BI \-l " name" 144 | call 145 | .BI require(' name ') 146 | before executing 147 | .IR script . 148 | Typically used to load libraries. 149 | .TP 150 | .B \-v 151 | show version information. 152 | .SH "SEE ALSO" 153 | .BR luac (1) 154 | .br 155 | http://www.lua.org/ 156 | .SH DIAGNOSTICS 157 | Error messages should be self explanatory. 158 | .SH AUTHORS 159 | R. Ierusalimschy, 160 | L. H. de Figueiredo, 161 | and 162 | W. Celes 163 | .\" EOF 164 | -------------------------------------------------------------------------------- /doc/lua.css: -------------------------------------------------------------------------------- 1 | body { 2 | color: #000000 ; 3 | background-color: #FFFFFF ; 4 | font-family: sans-serif ; 5 | text-align: justify ; 6 | margin-right: 20px ; 7 | margin-left: 20px ; 8 | } 9 | 10 | h1, h2, h3, h4 { 11 | font-weight: normal ; 12 | font-style: italic ; 13 | } 14 | 15 | a:link { 16 | color: #000080 ; 17 | background-color: inherit ; 18 | text-decoration: none ; 19 | } 20 | 21 | a:visited { 22 | background-color: inherit ; 23 | text-decoration: none ; 24 | } 25 | 26 | a:link:hover, a:visited:hover { 27 | color: #000080 ; 28 | background-color: #E0E0FF ; 29 | } 30 | 31 | a:link:active, a:visited:active { 32 | color: #FF0000 ; 33 | } 34 | 35 | hr { 36 | border: 0 ; 37 | height: 1px ; 38 | color: #a0a0a0 ; 39 | background-color: #a0a0a0 ; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /doc/lua.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | LUA man page 5 | 6 | 7 | 8 | 9 | 10 |

NAME

11 | lua - Lua interpreter 12 |

SYNOPSIS

13 | lua 14 | [ 15 | options 16 | ] 17 | [ 18 | script 19 | [ 20 | args 21 | ] 22 | ] 23 |

DESCRIPTION

24 | lua 25 | is the stand-alone Lua interpreter. 26 | It loads and executes Lua programs, 27 | either in textual source form or 28 | in precompiled binary form. 29 | (Precompiled binaries are output by 30 | luac, 31 | the Lua compiler.) 32 | lua 33 | can be used as a batch interpreter and also interactively. 34 |

35 | The given 36 | options 37 | (see below) 38 | are executed and then 39 | the Lua program in file 40 | script 41 | is loaded and executed. 42 | The given 43 | args 44 | are available to 45 | script 46 | as strings in a global table named 47 | arg. 48 | If these arguments contain spaces or other characters special to the shell, 49 | then they should be quoted 50 | (but note that the quotes will be removed by the shell). 51 | The arguments in 52 | arg 53 | start at 0, 54 | which contains the string 55 | 'script'. 56 | The index of the last argument is stored in 57 | arg.n. 58 | The arguments given in the command line before 59 | script, 60 | including the name of the interpreter, 61 | are available in negative indices in 62 | arg. 63 |

64 | At the very start, 65 | before even handling the command line, 66 | lua 67 | executes the contents of the environment variable 68 | LUA_INIT, 69 | if it is defined. 70 | If the value of 71 | LUA_INIT 72 | is of the form 73 | '@filename', 74 | then 75 | filename 76 | is executed. 77 | Otherwise, the string is assumed to be a Lua statement and is executed. 78 |

79 | Options start with 80 | '-' 81 | and are described below. 82 | You can use 83 | '--' 84 | to signal the end of options. 85 |

86 | If no arguments are given, 87 | then 88 | "-v -i" 89 | is assumed when the standard input is a terminal; 90 | otherwise, 91 | "-" 92 | is assumed. 93 |

94 | In interactive mode, 95 | lua 96 | prompts the user, 97 | reads lines from the standard input, 98 | and executes them as they are read. 99 | If a line does not contain a complete statement, 100 | then a secondary prompt is displayed and 101 | lines are read until a complete statement is formed or 102 | a syntax error is found. 103 | So, one way to interrupt the reading of an incomplete statement is 104 | to force a syntax error: 105 | adding a 106 | ';' 107 | in the middle of a statement is a sure way of forcing a syntax error 108 | (except inside multiline strings and comments; these must be closed explicitly). 109 | If a line starts with 110 | '=', 111 | then 112 | lua 113 | displays the values of all the expressions in the remainder of the 114 | line. The expressions must be separated by commas. 115 | The primary prompt is the value of the global variable 116 | _PROMPT, 117 | if this value is a string; 118 | otherwise, the default prompt is used. 119 | Similarly, the secondary prompt is the value of the global variable 120 | _PROMPT2. 121 | So, 122 | to change the prompts, 123 | set the corresponding variable to a string of your choice. 124 | You can do that after calling the interpreter 125 | or on the command line 126 | (but in this case you have to be careful with quotes 127 | if the prompt string contains a space; otherwise you may confuse the shell.) 128 | The default prompts are "> " and ">> ". 129 |

OPTIONS

130 |

131 | - 132 | load and execute the standard input as a file, 133 | that is, 134 | not interactively, 135 | even when the standard input is a terminal. 136 |

137 | -e stat 138 | execute statement 139 | stat. 140 | You need to quote 141 | stat 142 | if it contains spaces, quotes, 143 | or other characters special to the shell. 144 |

145 | -i 146 | enter interactive mode after 147 | script 148 | is executed. 149 |

150 | -l name 151 | call 152 | require('name') 153 | before executing 154 | script. 155 | Typically used to load libraries. 156 |

157 | -v 158 | show version information. 159 |

SEE ALSO

160 | luac(1) 161 |
162 | http://www.lua.org/ 163 |

DIAGNOSTICS

164 | Error messages should be self explanatory. 165 |

AUTHORS

166 | R. Ierusalimschy, 167 | L. H. de Figueiredo, 168 | and 169 | W. Celes 170 | 171 | 172 | 173 | -------------------------------------------------------------------------------- /doc/luac.1: -------------------------------------------------------------------------------- 1 | .\" $Id: luac.man,v 1.28 2006/01/06 16:03:34 lhf Exp $ 2 | .TH LUAC 1 "$Date: 2006/01/06 16:03:34 $" 3 | .SH NAME 4 | luac \- Lua compiler 5 | .SH SYNOPSIS 6 | .B luac 7 | [ 8 | .I options 9 | ] [ 10 | .I filenames 11 | ] 12 | .SH DESCRIPTION 13 | .B luac 14 | is the Lua compiler. 15 | It translates programs written in the Lua programming language 16 | into binary files that can be later loaded and executed. 17 | .LP 18 | The main advantages of precompiling chunks are: 19 | faster loading, 20 | protecting source code from accidental user changes, 21 | and 22 | off-line syntax checking. 23 | .LP 24 | Pre-compiling does not imply faster execution 25 | because in Lua chunks are always compiled into bytecodes before being executed. 26 | .B luac 27 | simply allows those bytecodes to be saved in a file for later execution. 28 | .LP 29 | Pre-compiled chunks are not necessarily smaller than the corresponding source. 30 | The main goal in pre-compiling is faster loading. 31 | .LP 32 | The binary files created by 33 | .B luac 34 | are portable only among architectures with the same word size and byte order. 35 | .LP 36 | .B luac 37 | produces a single output file containing the bytecodes 38 | for all source files given. 39 | By default, 40 | the output file is named 41 | .BR luac.out , 42 | but you can change this with the 43 | .B \-o 44 | option. 45 | .LP 46 | In the command line, 47 | you can mix 48 | text files containing Lua source and 49 | binary files containing precompiled chunks. 50 | This is useful to combine several precompiled chunks, 51 | even from different (but compatible) platforms, 52 | into a single precompiled chunk. 53 | .LP 54 | You can use 55 | .B "'\-'" 56 | to indicate the standard input as a source file 57 | and 58 | .B "'\--'" 59 | to signal the end of options 60 | (that is, 61 | all remaining arguments will be treated as files even if they start with 62 | .BR "'\-'" ). 63 | .LP 64 | The internal format of the binary files produced by 65 | .B luac 66 | is likely to change when a new version of Lua is released. 67 | So, 68 | save the source files of all Lua programs that you precompile. 69 | .LP 70 | .SH OPTIONS 71 | Options must be separate. 72 | .TP 73 | .B \-l 74 | produce a listing of the compiled bytecode for Lua's virtual machine. 75 | Listing bytecodes is useful to learn about Lua's virtual machine. 76 | If no files are given, then 77 | .B luac 78 | loads 79 | .B luac.out 80 | and lists its contents. 81 | .TP 82 | .BI \-o " file" 83 | output to 84 | .IR file , 85 | instead of the default 86 | .BR luac.out . 87 | (You can use 88 | .B "'\-'" 89 | for standard output, 90 | but not on platforms that open standard output in text mode.) 91 | The output file may be a source file because 92 | all files are loaded before the output file is written. 93 | Be careful not to overwrite precious files. 94 | .TP 95 | .B \-p 96 | load files but do not generate any output file. 97 | Used mainly for syntax checking and for testing precompiled chunks: 98 | corrupted files will probably generate errors when loaded. 99 | Lua always performs a thorough integrity test on precompiled chunks. 100 | Bytecode that passes this test is completely safe, 101 | in the sense that it will not break the interpreter. 102 | However, 103 | there is no guarantee that such code does anything sensible. 104 | (None can be given, because the halting problem is unsolvable.) 105 | If no files are given, then 106 | .B luac 107 | loads 108 | .B luac.out 109 | and tests its contents. 110 | No messages are displayed if the file passes the integrity test. 111 | .TP 112 | .B \-s 113 | strip debug information before writing the output file. 114 | This saves some space in very large chunks, 115 | but if errors occur when running a stripped chunk, 116 | then the error messages may not contain the full information they usually do. 117 | For instance, 118 | line numbers and names of local variables are lost. 119 | .TP 120 | .B \-v 121 | show version information. 122 | .SH FILES 123 | .TP 15 124 | .B luac.out 125 | default output file 126 | .SH "SEE ALSO" 127 | .BR lua (1) 128 | .br 129 | http://www.lua.org/ 130 | .SH DIAGNOSTICS 131 | Error messages should be self explanatory. 132 | .SH AUTHORS 133 | L. H. de Figueiredo, 134 | R. Ierusalimschy and 135 | W. Celes 136 | .\" EOF 137 | -------------------------------------------------------------------------------- /doc/luac.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | LUAC man page 5 | 6 | 7 | 8 | 9 | 10 |

NAME

11 | luac - Lua compiler 12 |

SYNOPSIS

13 | luac 14 | [ 15 | options 16 | ] [ 17 | filenames 18 | ] 19 |

DESCRIPTION

20 | luac 21 | is the Lua compiler. 22 | It translates programs written in the Lua programming language 23 | into binary files that can be later loaded and executed. 24 |

25 | The main advantages of precompiling chunks are: 26 | faster loading, 27 | protecting source code from accidental user changes, 28 | and 29 | off-line syntax checking. 30 |

31 | Precompiling does not imply faster execution 32 | because in Lua chunks are always compiled into bytecodes before being executed. 33 | luac 34 | simply allows those bytecodes to be saved in a file for later execution. 35 |

36 | Precompiled chunks are not necessarily smaller than the corresponding source. 37 | The main goal in precompiling is faster loading. 38 |

39 | The binary files created by 40 | luac 41 | are portable only among architectures with the same word size and byte order. 42 |

43 | luac 44 | produces a single output file containing the bytecodes 45 | for all source files given. 46 | By default, 47 | the output file is named 48 | luac.out, 49 | but you can change this with the 50 | -o 51 | option. 52 |

53 | In the command line, 54 | you can mix 55 | text files containing Lua source and 56 | binary files containing precompiled chunks. 57 | This is useful because several precompiled chunks, 58 | even from different (but compatible) platforms, 59 | can be combined into a single precompiled chunk. 60 |

61 | You can use 62 | '-' 63 | to indicate the standard input as a source file 64 | and 65 | '--' 66 | to signal the end of options 67 | (that is, 68 | all remaining arguments will be treated as files even if they start with 69 | '-'). 70 |

71 | The internal format of the binary files produced by 72 | luac 73 | is likely to change when a new version of Lua is released. 74 | So, 75 | save the source files of all Lua programs that you precompile. 76 |

77 |

OPTIONS

78 | Options must be separate. 79 |

80 | -l 81 | produce a listing of the compiled bytecode for Lua's virtual machine. 82 | Listing bytecodes is useful to learn about Lua's virtual machine. 83 | If no files are given, then 84 | luac 85 | loads 86 | luac.out 87 | and lists its contents. 88 |

89 | -o file 90 | output to 91 | file, 92 | instead of the default 93 | luac.out. 94 | (You can use 95 | '-' 96 | for standard output, 97 | but not on platforms that open standard output in text mode.) 98 | The output file may be a source file because 99 | all files are loaded before the output file is written. 100 | Be careful not to overwrite precious files. 101 |

102 | -p 103 | load files but do not generate any output file. 104 | Used mainly for syntax checking and for testing precompiled chunks: 105 | corrupted files will probably generate errors when loaded. 106 | Lua always performs a thorough integrity test on precompiled chunks. 107 | Bytecode that passes this test is completely safe, 108 | in the sense that it will not break the interpreter. 109 | However, 110 | there is no guarantee that such code does anything sensible. 111 | (None can be given, because the halting problem is unsolvable.) 112 | If no files are given, then 113 | luac 114 | loads 115 | luac.out 116 | and tests its contents. 117 | No messages are displayed if the file passes the integrity test. 118 |

119 | -s 120 | strip debug information before writing the output file. 121 | This saves some space in very large chunks, 122 | but if errors occur when running a stripped chunk, 123 | then the error messages may not contain the full information they usually do. 124 | For instance, 125 | line numbers and names of local variables are lost. 126 |

127 | -v 128 | show version information. 129 |

FILES

130 |

131 | luac.out 132 | default output file 133 |

SEE ALSO

134 | lua(1) 135 |
136 | http://www.lua.org/ 137 |

DIAGNOSTICS

138 | Error messages should be self explanatory. 139 |

AUTHORS

140 | L. H. de Figueiredo, 141 | R. Ierusalimschy and 142 | W. Celes 143 | 144 | 145 | 146 | -------------------------------------------------------------------------------- /doc/manual.css: -------------------------------------------------------------------------------- 1 | h3 code { 2 | font-family: inherit ; 3 | } 4 | 5 | pre { 6 | font-size: 105% ; 7 | } 8 | 9 | span.apii { 10 | float: right ; 11 | font-family: inherit ; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /doc/readme.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | Lua documentation 4 | 5 | 6 | 7 | 8 | 9 |
10 |

11 | Lua 12 | Documentation 13 |

14 | 15 | This is the documentation included in the source distribution of Lua 5.1.4. 16 | 17 | 25 | 26 | Lua's 27 | official web site 28 | contains updated documentation, 29 | especially the 30 | reference manual. 31 |

32 | 33 |

34 | 35 | Last update: 36 | Tue Aug 12 14:46:07 BRT 2008 37 | 38 | 39 | 40 | 41 | -------------------------------------------------------------------------------- /etc/Makefile: -------------------------------------------------------------------------------- 1 | # makefile for Lua etc 2 | 3 | TOP= .. 4 | LIB= $(TOP)/src 5 | INC= $(TOP)/src 6 | BIN= $(TOP)/src 7 | SRC= $(TOP)/src 8 | TST= $(TOP)/test 9 | 10 | CC= gcc 11 | CFLAGS= -O2 -Wall -I$(INC) $(MYCFLAGS) 12 | MYCFLAGS= 13 | MYLDFLAGS= -Wl,-E 14 | MYLIBS= -lm 15 | #MYLIBS= -lm -Wl,-E -ldl -lreadline -lhistory -lncurses 16 | RM= rm -f 17 | 18 | default: 19 | @echo 'Please choose a target: min noparser one strict clean' 20 | 21 | min: min.c 22 | $(CC) $(CFLAGS) $@.c -L$(LIB) -llua $(MYLIBS) 23 | echo 'print"Hello there!"' | ./a.out 24 | 25 | noparser: noparser.o 26 | $(CC) noparser.o $(SRC)/lua.o -L$(LIB) -llua $(MYLIBS) 27 | $(BIN)/luac $(TST)/hello.lua 28 | -./a.out luac.out 29 | -./a.out -e'a=1' 30 | 31 | one: 32 | $(CC) $(CFLAGS) all.c $(MYLIBS) 33 | ./a.out $(TST)/hello.lua 34 | 35 | strict: 36 | -$(BIN)/lua -e 'print(a);b=2' 37 | -$(BIN)/lua -lstrict -e 'print(a)' 38 | -$(BIN)/lua -e 'function f() b=2 end f()' 39 | -$(BIN)/lua -lstrict -e 'function f() b=2 end f()' 40 | 41 | clean: 42 | $(RM) a.out core core.* *.o luac.out 43 | 44 | .PHONY: default min noparser one strict clean 45 | -------------------------------------------------------------------------------- /etc/README: -------------------------------------------------------------------------------- 1 | This directory contains some useful files and code. 2 | Unlike the code in ../src, everything here is in the public domain. 3 | 4 | If any of the makes fail, you're probably not using the same libraries 5 | used to build Lua. Set MYLIBS in Makefile accordingly. 6 | 7 | all.c 8 | Full Lua interpreter in a single file. 9 | Do "make one" for a demo. 10 | 11 | lua.hpp 12 | Lua header files for C++ using 'extern "C"'. 13 | 14 | lua.ico 15 | A Lua icon for Windows (and web sites: save as favicon.ico). 16 | Drawn by hand by Markus Gritsch . 17 | 18 | lua.pc 19 | pkg-config data for Lua 20 | 21 | luavs.bat 22 | Script to build Lua under "Visual Studio .NET Command Prompt". 23 | Run it from the toplevel as etc\luavs.bat. 24 | 25 | min.c 26 | A minimal Lua interpreter. 27 | Good for learning and for starting your own. 28 | Do "make min" for a demo. 29 | 30 | noparser.c 31 | Linking with noparser.o avoids loading the parsing modules in lualib.a. 32 | Do "make noparser" for a demo. 33 | 34 | strict.lua 35 | Traps uses of undeclared global variables. 36 | Do "make strict" for a demo. 37 | 38 | -------------------------------------------------------------------------------- /etc/all.c: -------------------------------------------------------------------------------- 1 | /* 2 | * all.c -- Lua core, libraries and interpreter in a single file 3 | */ 4 | 5 | #define luaall_c 6 | 7 | #include "lapi.c" 8 | #include "lcode.c" 9 | #include "ldebug.c" 10 | #include "ldo.c" 11 | #include "ldump.c" 12 | #include "lfunc.c" 13 | #include "lgc.c" 14 | #include "llex.c" 15 | #include "lmem.c" 16 | #include "lobject.c" 17 | #include "lopcodes.c" 18 | #include "lparser.c" 19 | #include "lstate.c" 20 | #include "lstring.c" 21 | #include "ltable.c" 22 | #include "ltm.c" 23 | #include "lundump.c" 24 | #include "lvm.c" 25 | #include "lzio.c" 26 | 27 | #include "lauxlib.c" 28 | #include "lbaselib.c" 29 | #include "ldblib.c" 30 | #include "liolib.c" 31 | #include "linit.c" 32 | #include "lmathlib.c" 33 | #include "loadlib.c" 34 | #include "loslib.c" 35 | #include "lstrlib.c" 36 | #include "ltablib.c" 37 | 38 | #include "lua.c" 39 | -------------------------------------------------------------------------------- /etc/lua.hpp: -------------------------------------------------------------------------------- 1 | // lua.hpp 2 | // Lua header files for C++ 3 | // <> not supplied automatically because Lua also compiles as C++ 4 | 5 | extern "C" { 6 | #include "lua.h" 7 | #include "lualib.h" 8 | #include "lauxlib.h" 9 | } 10 | -------------------------------------------------------------------------------- /etc/lua.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lichuang/Lua-5.1.4-codedump/7e5a0089d4a3199318230c2832c3e5c103f55437/etc/lua.ico -------------------------------------------------------------------------------- /etc/lua.pc: -------------------------------------------------------------------------------- 1 | # lua.pc -- pkg-config data for Lua 2 | 3 | # vars from install Makefile 4 | 5 | # grep '^V=' ../Makefile 6 | V= 5.1 7 | # grep '^R=' ../Makefile 8 | R= 5.1.4 9 | 10 | # grep '^INSTALL_.*=' ../Makefile | sed 's/INSTALL_TOP/prefix/' 11 | prefix= /usr/local 12 | INSTALL_BIN= ${prefix}/bin 13 | INSTALL_INC= ${prefix}/include 14 | INSTALL_LIB= ${prefix}/lib 15 | INSTALL_MAN= ${prefix}/man/man1 16 | INSTALL_LMOD= ${prefix}/share/lua/${V} 17 | INSTALL_CMOD= ${prefix}/lib/lua/${V} 18 | 19 | # canonical vars 20 | exec_prefix=${prefix} 21 | libdir=${exec_prefix}/lib 22 | includedir=${prefix}/include 23 | 24 | Name: Lua 25 | Description: An Extensible Extension Language 26 | Version: ${R} 27 | Requires: 28 | Libs: -L${libdir} -llua -lm 29 | Cflags: -I${includedir} 30 | 31 | # (end of lua.pc) 32 | -------------------------------------------------------------------------------- /etc/luavs.bat: -------------------------------------------------------------------------------- 1 | @rem Script to build Lua under "Visual Studio .NET Command Prompt". 2 | @rem Do not run from this directory; run it from the toplevel: etc\luavs.bat . 3 | @rem It creates lua51.dll, lua51.lib, lua.exe, and luac.exe in src. 4 | @rem (contributed by David Manura and Mike Pall) 5 | 6 | @setlocal 7 | @set MYCOMPILE=cl /nologo /MD /O2 /W3 /c /D_CRT_SECURE_NO_DEPRECATE 8 | @set MYLINK=link /nologo 9 | @set MYMT=mt /nologo 10 | 11 | cd src 12 | %MYCOMPILE% /DLUA_BUILD_AS_DLL l*.c 13 | del lua.obj luac.obj 14 | %MYLINK% /DLL /out:lua51.dll l*.obj 15 | if exist lua51.dll.manifest^ 16 | %MYMT% -manifest lua51.dll.manifest -outputresource:lua51.dll;2 17 | %MYCOMPILE% /DLUA_BUILD_AS_DLL lua.c 18 | %MYLINK% /out:lua.exe lua.obj lua51.lib 19 | if exist lua.exe.manifest^ 20 | %MYMT% -manifest lua.exe.manifest -outputresource:lua.exe 21 | %MYCOMPILE% l*.c print.c 22 | del lua.obj linit.obj lbaselib.obj ldblib.obj liolib.obj lmathlib.obj^ 23 | loslib.obj ltablib.obj lstrlib.obj loadlib.obj 24 | %MYLINK% /out:luac.exe *.obj 25 | if exist luac.exe.manifest^ 26 | %MYMT% -manifest luac.exe.manifest -outputresource:luac.exe 27 | del *.obj *.manifest 28 | cd .. 29 | -------------------------------------------------------------------------------- /etc/min.c: -------------------------------------------------------------------------------- 1 | /* 2 | * min.c -- a minimal Lua interpreter 3 | * loads stdin only with minimal error handling. 4 | * no interaction, and no standard library, only a "print" function. 5 | */ 6 | 7 | #include 8 | 9 | #include "lua.h" 10 | #include "lauxlib.h" 11 | 12 | static int print(lua_State *L) 13 | { 14 | int n=lua_gettop(L); 15 | int i; 16 | for (i=1; i<=n; i++) 17 | { 18 | if (i>1) printf("\t"); 19 | if (lua_isstring(L,i)) 20 | printf("%s",lua_tostring(L,i)); 21 | else if (lua_isnil(L,i)) 22 | printf("%s","nil"); 23 | else if (lua_isboolean(L,i)) 24 | printf("%s",lua_toboolean(L,i) ? "true" : "false"); 25 | else 26 | printf("%s:%p",luaL_typename(L,i),lua_topointer(L,i)); 27 | } 28 | printf("\n"); 29 | return 0; 30 | } 31 | 32 | int main(void) 33 | { 34 | lua_State *L=lua_open(); 35 | lua_register(L,"print",print); 36 | if (luaL_dofile(L,NULL)!=0) fprintf(stderr,"%s\n",lua_tostring(L,-1)); 37 | lua_close(L); 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /etc/noparser.c: -------------------------------------------------------------------------------- 1 | /* 2 | * The code below can be used to make a Lua core that does not contain the 3 | * parsing modules (lcode, llex, lparser), which represent 35% of the total core. 4 | * You'll only be able to load binary files and strings, precompiled with luac. 5 | * (Of course, you'll have to build luac with the original parsing modules!) 6 | * 7 | * To use this module, simply compile it ("make noparser" does that) and list 8 | * its object file before the Lua libraries. The linker should then not load 9 | * the parsing modules. To try it, do "make luab". 10 | * 11 | * If you also want to avoid the dump module (ldump.o), define NODUMP. 12 | * #define NODUMP 13 | */ 14 | 15 | #define LUA_CORE 16 | 17 | #include "llex.h" 18 | #include "lparser.h" 19 | #include "lzio.h" 20 | 21 | LUAI_FUNC void luaX_init (lua_State *L) { 22 | UNUSED(L); 23 | } 24 | 25 | LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) { 26 | UNUSED(z); 27 | UNUSED(buff); 28 | UNUSED(name); 29 | lua_pushliteral(L,"parser not loaded"); 30 | lua_error(L); 31 | return NULL; 32 | } 33 | 34 | #ifdef NODUMP 35 | #include "lundump.h" 36 | 37 | LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip) { 38 | UNUSED(f); 39 | UNUSED(w); 40 | UNUSED(data); 41 | UNUSED(strip); 42 | #if 1 43 | UNUSED(L); 44 | return 0; 45 | #else 46 | lua_pushliteral(L,"dumper not loaded"); 47 | lua_error(L); 48 | #endif 49 | } 50 | #endif 51 | -------------------------------------------------------------------------------- /etc/strict.lua: -------------------------------------------------------------------------------- 1 | -- 2 | -- strict.lua 3 | -- checks uses of undeclared global variables 4 | -- All global variables must be 'declared' through a regular assignment 5 | -- (even assigning nil will do) in a main chunk before being used 6 | -- anywhere or assigned to inside a function. 7 | -- 8 | 9 | local getinfo, error, rawset, rawget = debug.getinfo, error, rawset, rawget 10 | 11 | local mt = getmetatable(_G) 12 | if mt == nil then 13 | mt = {} 14 | setmetatable(_G, mt) 15 | end 16 | 17 | mt.__declared = {} 18 | 19 | local function what () 20 | local d = getinfo(3, "S") 21 | return d and d.what or "C" 22 | end 23 | 24 | mt.__newindex = function (t, n, v) 25 | if not mt.__declared[n] then 26 | local w = what() 27 | if w ~= "main" and w ~= "C" then 28 | error("assign to undeclared variable '"..n.."'", 2) 29 | end 30 | mt.__declared[n] = true 31 | end 32 | rawset(t, n, v) 33 | end 34 | 35 | mt.__index = function (t, n) 36 | if not mt.__declared[n] and what() ~= "C" then 37 | error("variable '"..n.."' is not declared", 2) 38 | end 39 | return rawget(t, n) 40 | end 41 | 42 | -------------------------------------------------------------------------------- /src/Makefile: -------------------------------------------------------------------------------- 1 | # makefile for building Lua 2 | # see ../INSTALL for installation instructions 3 | # see ../Makefile and luaconf.h for further customization 4 | 5 | # == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT ======================= 6 | 7 | # Your platform. See PLATS for possible values. 8 | PLAT= none 9 | 10 | CC= gcc 11 | CFLAGS= -O2 -Wall $(MYCFLAGS) 12 | AR= ar rcu 13 | RANLIB= ranlib 14 | RM= rm -f 15 | LIBS= -lm $(MYLIBS) 16 | 17 | MYCFLAGS= 18 | MYLDFLAGS= 19 | MYLIBS= 20 | 21 | # == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE ========= 22 | 23 | PLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris 24 | 25 | LUA_A= liblua.a 26 | # 虚拟机核心 27 | # 文件名 作用 对外接口前缀 28 | # lapi.c C语言接口 lua_ 29 | # lcode.c 源码生成器 luaK_ 30 | # ldebug.c 调试库 luaG_ 31 | # ldo.c 函数调用及栈管理 luaD_ 32 | # ldump.c 序列化预编译的Lua字节码 33 | # lfunc.c 提供操作函数原型及闭包的辅助函数 luaF_ 34 | # lgc.c 垃圾回收 luaC_ 35 | # llex.c 词法分析器 luaX_ 36 | # lmem.c 内存管理 luaM_ 37 | # lobject.c 对象管理 luaO_ 38 | # lopcodes.c 字节码操作 luaP_ 39 | # lparser.c 语法分析器 luaY_ 40 | # lstate.c 全局状态机 luaE_ 41 | # lstring.c 字符串操作 luaS_ 42 | # ltable.c 表操作 luaH_ 43 | # ltm.c tag方法 luaT_ 44 | # lundump.c 加载预编译字节码 luaU_ 45 | # lvm.c lua虚拟机 luaV_ 46 | # lzio.c 缓存流接口 luaZ_ 47 | CORE_O= lapi.o lcode.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o \ 48 | lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o \ 49 | lundump.o lvm.o lzio.o 50 | 51 | # 内嵌库 52 | # 文件名 作用 对外接口前缀 53 | # lauxlib.c 库编写时需要用到的辅助函数库 luaL_ 54 | # lbaselib.c 基础库 55 | # ldblib.c 调试库 56 | # liolib.c IO库 57 | # lmathlib.c 标准数据库 58 | # loslib.c OS库 59 | # ltablib.c 表操作库 60 | # lstrlib.c 字符串操作库 61 | # loadlib.c 动态扩展库加载器 62 | # linit.c 负责内嵌库初始化 63 | LIB_O= lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o \ 64 | lstrlib.o loadlib.o linit.o 65 | 66 | 67 | # 解释器 68 | # 文件名 作用 对外接口前缀 69 | # lua.c 解释器 70 | LUA_T= lua 71 | LUA_O= lua.o 72 | 73 | # 编译器 74 | # 文件名 作用 对外接口前缀 75 | # luac.c 编译器 76 | LUAC_T= luac 77 | LUAC_O= luac.o print.o 78 | 79 | ALL_O= $(CORE_O) $(LIB_O) $(LUA_O) $(LUAC_O) 80 | ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T) 81 | ALL_A= $(LUA_A) 82 | 83 | default: $(PLAT) 84 | 85 | all: $(ALL_T) 86 | 87 | o: $(ALL_O) 88 | 89 | a: $(ALL_A) 90 | 91 | $(LUA_A): $(CORE_O) $(LIB_O) 92 | $(AR) $@ $? 93 | $(RANLIB) $@ 94 | 95 | $(LUA_T): $(LUA_O) $(LUA_A) 96 | $(CC) -o $@ $(MYLDFLAGS) $(LUA_O) $(LUA_A) $(LIBS) 97 | 98 | $(LUAC_T): $(LUAC_O) $(LUA_A) 99 | $(CC) -o $@ $(MYLDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS) 100 | 101 | clean: 102 | $(RM) $(ALL_T) $(ALL_O) 103 | 104 | depend: 105 | @$(CC) $(CFLAGS) -MM l*.c print.c 106 | 107 | echo: 108 | @echo "PLAT = $(PLAT)" 109 | @echo "CC = $(CC)" 110 | @echo "CFLAGS = $(CFLAGS)" 111 | @echo "AR = $(AR)" 112 | @echo "RANLIB = $(RANLIB)" 113 | @echo "RM = $(RM)" 114 | @echo "MYCFLAGS = $(MYCFLAGS)" 115 | @echo "MYLDFLAGS = $(MYLDFLAGS)" 116 | @echo "MYLIBS = $(MYLIBS)" 117 | 118 | # convenience targets for popular platforms 119 | 120 | none: 121 | @echo "Please choose a platform:" 122 | @echo " $(PLATS)" 123 | 124 | aix: 125 | $(MAKE) all CC="xlc" CFLAGS="-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl" MYLDFLAGS="-brtl -bexpall" 126 | 127 | ansi: 128 | $(MAKE) all MYCFLAGS=-DLUA_ANSI 129 | 130 | bsd: 131 | $(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-Wl,-E" 132 | 133 | freebsd: 134 | $(MAKE) all MYCFLAGS="-DLUA_USE_LINUX" MYLIBS="-Wl,-E -lreadline" 135 | 136 | generic: 137 | $(MAKE) all MYCFLAGS= 138 | 139 | linux: 140 | $(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-Wl,-E -ldl -lreadline -lhistory -lncurses" 141 | 142 | macosx: 143 | $(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-lreadline" 144 | # use this on Mac OS X 10.3- 145 | # $(MAKE) all MYCFLAGS=-DLUA_USE_MACOSX 146 | 147 | mingw: 148 | $(MAKE) "LUA_A=lua51.dll" "LUA_T=lua.exe" \ 149 | "AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \ 150 | "MYCFLAGS=-DLUA_BUILD_AS_DLL" "MYLIBS=" "MYLDFLAGS=-s" lua.exe 151 | $(MAKE) "LUAC_T=luac.exe" luac.exe 152 | 153 | posix: 154 | $(MAKE) all MYCFLAGS=-DLUA_USE_POSIX 155 | 156 | solaris: 157 | $(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl" 158 | 159 | # list targets that do not create files (but not all makes understand .PHONY) 160 | .PHONY: all $(PLATS) default o a clean depend echo none 161 | 162 | # DO NOT DELETE 163 | 164 | lapi.o: lapi.c lua.h luaconf.h lapi.h lobject.h llimits.h ldebug.h \ 165 | lstate.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h \ 166 | lundump.h lvm.h 167 | lauxlib.o: lauxlib.c lua.h luaconf.h lauxlib.h 168 | lbaselib.o: lbaselib.c lua.h luaconf.h lauxlib.h lualib.h 169 | lcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \ 170 | lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lgc.h \ 171 | ltable.h 172 | ldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h 173 | ldebug.o: ldebug.c lua.h luaconf.h lapi.h lobject.h llimits.h lcode.h \ 174 | llex.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \ 175 | lfunc.h lstring.h lgc.h ltable.h lvm.h 176 | ldo.o: ldo.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \ 177 | lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lparser.h lstring.h \ 178 | ltable.h lundump.h lvm.h 179 | ldump.o: ldump.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \ 180 | lzio.h lmem.h lundump.h 181 | lfunc.o: lfunc.c lua.h luaconf.h lfunc.h lobject.h llimits.h lgc.h lmem.h \ 182 | lstate.h ltm.h lzio.h 183 | lgc.o: lgc.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \ 184 | lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h 185 | linit.o: linit.c lua.h luaconf.h lualib.h lauxlib.h 186 | liolib.o: liolib.c lua.h luaconf.h lauxlib.h lualib.h 187 | llex.o: llex.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h ltm.h \ 188 | lzio.h lmem.h llex.h lparser.h lstring.h lgc.h ltable.h 189 | lmathlib.o: lmathlib.c lua.h luaconf.h lauxlib.h lualib.h 190 | lmem.o: lmem.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \ 191 | ltm.h lzio.h lmem.h ldo.h 192 | loadlib.o: loadlib.c lua.h luaconf.h lauxlib.h lualib.h 193 | lobject.o: lobject.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h \ 194 | ltm.h lzio.h lmem.h lstring.h lgc.h lvm.h 195 | lopcodes.o: lopcodes.c lopcodes.h llimits.h lua.h luaconf.h 196 | loslib.o: loslib.c lua.h luaconf.h lauxlib.h lualib.h 197 | lparser.o: lparser.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \ 198 | lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \ 199 | lfunc.h lstring.h lgc.h ltable.h 200 | lstate.o: lstate.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \ 201 | ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h llex.h lstring.h ltable.h 202 | lstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \ 203 | ltm.h lzio.h lstring.h lgc.h 204 | lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h 205 | ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \ 206 | ltm.h lzio.h lmem.h ldo.h lgc.h ltable.h 207 | ltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h 208 | ltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \ 209 | lmem.h lstring.h lgc.h ltable.h 210 | lua.o: lua.c lua.h luaconf.h lauxlib.h lualib.h 211 | luac.o: luac.c lua.h luaconf.h lauxlib.h ldo.h lobject.h llimits.h \ 212 | lstate.h ltm.h lzio.h lmem.h lfunc.h lopcodes.h lstring.h lgc.h \ 213 | lundump.h 214 | lundump.o: lundump.c lua.h luaconf.h ldebug.h lstate.h lobject.h \ 215 | llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h lundump.h 216 | lvm.o: lvm.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \ 217 | lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h lvm.h 218 | lzio.o: lzio.c lua.h luaconf.h llimits.h lmem.h lstate.h lobject.h ltm.h \ 219 | lzio.h 220 | print.o: print.c ldebug.h lstate.h lua.h luaconf.h lobject.h llimits.h \ 221 | ltm.h lzio.h lmem.h lopcodes.h lundump.h 222 | 223 | # (end of Makefile) 224 | -------------------------------------------------------------------------------- /src/lapi.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lapi.h,v 2.2.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Auxiliary functions from Lua API 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lapi_h 8 | #define lapi_h 9 | 10 | 11 | #include "lobject.h" 12 | 13 | 14 | LUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o); 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /src/lauxlib.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Auxiliary functions for building Lua libraries 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #ifndef lauxlib_h 9 | #define lauxlib_h 10 | 11 | 12 | #include 13 | #include 14 | 15 | #include "lua.h" 16 | 17 | 18 | #if defined(LUA_COMPAT_GETN) 19 | LUALIB_API int (luaL_getn) (lua_State *L, int t); 20 | LUALIB_API void (luaL_setn) (lua_State *L, int t, int n); 21 | #else 22 | #define luaL_getn(L,i) ((int)lua_objlen(L, i)) 23 | #define luaL_setn(L,i,j) ((void)0) /* no op! */ 24 | #endif 25 | 26 | #if defined(LUA_COMPAT_OPENLIB) 27 | #define luaI_openlib luaL_openlib 28 | #endif 29 | 30 | 31 | /* extra error code for `luaL_load' */ 32 | #define LUA_ERRFILE (LUA_ERRERR+1) 33 | 34 | 35 | typedef struct luaL_Reg { 36 | const char *name; 37 | lua_CFunction func; 38 | } luaL_Reg; 39 | 40 | 41 | 42 | LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname, 43 | const luaL_Reg *l, int nup); 44 | LUALIB_API void (luaL_register) (lua_State *L, const char *libname, 45 | const luaL_Reg *l); 46 | LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e); 47 | LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e); 48 | LUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname); 49 | LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg); 50 | LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg, 51 | size_t *l); 52 | LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg, 53 | const char *def, size_t *l); 54 | LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg); 55 | LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def); 56 | 57 | LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg); 58 | LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg, 59 | lua_Integer def); 60 | 61 | LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg); 62 | LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t); 63 | LUALIB_API void (luaL_checkany) (lua_State *L, int narg); 64 | 65 | LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname); 66 | LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname); 67 | 68 | LUALIB_API void (luaL_where) (lua_State *L, int lvl); 69 | LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...); 70 | 71 | LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def, 72 | const char *const lst[]); 73 | 74 | LUALIB_API int (luaL_ref) (lua_State *L, int t); 75 | LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref); 76 | 77 | LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename); 78 | LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz, 79 | const char *name); 80 | LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s); 81 | 82 | LUALIB_API lua_State *(luaL_newstate) (void); 83 | 84 | 85 | LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p, 86 | const char *r); 87 | 88 | LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx, 89 | const char *fname, int szhint); 90 | 91 | 92 | 93 | 94 | /* 95 | ** =============================================================== 96 | ** some useful macros 97 | ** =============================================================== 98 | */ 99 | 100 | #define luaL_argcheck(L, cond,numarg,extramsg) \ 101 | ((void)((cond) || luaL_argerror(L, (numarg), (extramsg)))) 102 | #define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) 103 | #define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) 104 | #define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) 105 | #define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) 106 | #define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) 107 | #define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) 108 | 109 | #define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) 110 | 111 | #define luaL_dofile(L, fn) \ 112 | (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0)) 113 | 114 | #define luaL_dostring(L, s) \ 115 | (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0)) 116 | 117 | #define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) 118 | 119 | #define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) 120 | 121 | /* 122 | ** {====================================================== 123 | ** Generic Buffer manipulation 124 | ** ======================================================= 125 | */ 126 | 127 | 128 | 129 | typedef struct luaL_Buffer { 130 | char *p; /* current position in buffer */ 131 | int lvl; /* number of strings in the stack (level) */ 132 | lua_State *L; 133 | char buffer[LUAL_BUFFERSIZE]; 134 | } luaL_Buffer; 135 | 136 | #define luaL_addchar(B,c) \ 137 | ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \ 138 | (*(B)->p++ = (char)(c))) 139 | 140 | /* compatibility only */ 141 | #define luaL_putchar(B,c) luaL_addchar(B,c) 142 | 143 | #define luaL_addsize(B,n) ((B)->p += (n)) 144 | 145 | LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B); 146 | LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B); 147 | LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l); 148 | LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s); 149 | LUALIB_API void (luaL_addvalue) (luaL_Buffer *B); 150 | LUALIB_API void (luaL_pushresult) (luaL_Buffer *B); 151 | 152 | 153 | /* }====================================================== */ 154 | 155 | 156 | /* compatibility with ref system */ 157 | 158 | /* pre-defined references */ 159 | #define LUA_NOREF (-2) 160 | #define LUA_REFNIL (-1) 161 | 162 | #define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \ 163 | (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0)) 164 | 165 | #define lua_unref(L,ref) luaL_unref(L, LUA_REGISTRYINDEX, (ref)) 166 | 167 | #define lua_getref(L,ref) lua_rawgeti(L, LUA_REGISTRYINDEX, (ref)) 168 | 169 | 170 | #define luaL_reg luaL_Reg 171 | 172 | #endif 173 | 174 | 175 | -------------------------------------------------------------------------------- /src/lcode.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lcode.h,v 1.48.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Code generator for Lua 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lcode_h 8 | #define lcode_h 9 | 10 | #include "llex.h" 11 | #include "lobject.h" 12 | #include "lopcodes.h" 13 | #include "lparser.h" 14 | 15 | 16 | /* 17 | ** Marks the end of a patch list. It is an invalid value both as an absolute 18 | ** address, and as a list link (would link an element to itself). 19 | */ 20 | #define NO_JUMP (-1) 21 | 22 | 23 | /* 24 | ** grep "ORDER OPR" if you change these enums 25 | */ 26 | // 二元操作符 27 | typedef enum BinOpr { 28 | OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW, 29 | OPR_CONCAT, 30 | OPR_NE, OPR_EQ, 31 | OPR_LT, OPR_LE, OPR_GT, OPR_GE, 32 | OPR_AND, OPR_OR, 33 | OPR_NOBINOPR // 非二元操作符 34 | } BinOpr; 35 | 36 | // 一元操作符,MINUS是求负数 37 | typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr; 38 | 39 | 40 | #define getcode(fs,e) ((fs)->f->code[(e)->u.s.info]) 41 | 42 | #define luaK_codeAsBx(fs,o,A,sBx) luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx) 43 | 44 | #define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) 45 | 46 | LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx); 47 | LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C); 48 | LUAI_FUNC void luaK_fixline (FuncState *fs, int line); 49 | LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n); 50 | LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n); 51 | LUAI_FUNC void luaK_checkstack (FuncState *fs, int n); 52 | LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s); 53 | LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r); 54 | LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e); 55 | LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e); 56 | LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e); 57 | LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e); 58 | LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e); 59 | LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key); 60 | LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k); 61 | LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e); 62 | LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e); 63 | LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults); 64 | LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e); 65 | LUAI_FUNC int luaK_jump (FuncState *fs); 66 | LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret); 67 | LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target); 68 | LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list); 69 | LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2); 70 | LUAI_FUNC int luaK_getlabel (FuncState *fs); 71 | LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v); 72 | LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v); 73 | LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2); 74 | LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore); 75 | 76 | 77 | #endif 78 | -------------------------------------------------------------------------------- /src/ldebug.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: ldebug.h,v 2.3.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Auxiliary functions from Debug Interface module 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef ldebug_h 8 | #define ldebug_h 9 | 10 | 11 | #include "lstate.h" 12 | 13 | 14 | #define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1) 15 | 16 | #define getline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : 0) 17 | 18 | #define resethookcount(L) (L->hookcount = L->basehookcount) 19 | 20 | 21 | LUAI_FUNC void luaG_typeerror (lua_State *L, const TValue *o, 22 | const char *opname); 23 | LUAI_FUNC void luaG_concaterror (lua_State *L, StkId p1, StkId p2); 24 | LUAI_FUNC void luaG_aritherror (lua_State *L, const TValue *p1, 25 | const TValue *p2); 26 | LUAI_FUNC int luaG_ordererror (lua_State *L, const TValue *p1, 27 | const TValue *p2); 28 | LUAI_FUNC void luaG_runerror (lua_State *L, const char *fmt, ...); 29 | LUAI_FUNC void luaG_errormsg (lua_State *L); 30 | LUAI_FUNC int luaG_checkcode (const Proto *pt); 31 | LUAI_FUNC int luaG_checkopenop (Instruction i); 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /src/ldo.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: ldo.h,v 2.7.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Stack and Call structure of Lua 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef ldo_h 8 | #define ldo_h 9 | 10 | 11 | #include "lobject.h" 12 | #include "lstate.h" 13 | #include "lzio.h" 14 | 15 | 16 | #define luaD_checkstack(L,n) \ 17 | if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue)) \ 18 | luaD_growstack(L, n); \ 19 | else condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1)); 20 | 21 | 22 | #define incr_top(L) {luaD_checkstack(L,1); L->top++;} 23 | 24 | #define savestack(L,p) ((char *)(p) - (char *)L->stack) 25 | #define restorestack(L,n) ((TValue *)((char *)L->stack + (n))) 26 | 27 | #define saveci(L,p) ((char *)(p) - (char *)L->base_ci) 28 | #define restoreci(L,n) ((CallInfo *)((char *)L->base_ci + (n))) 29 | 30 | 31 | /* results from luaD_precall */ 32 | #define PCRLUA 0 /* initiated a call to a Lua function */ 33 | #define PCRC 1 /* did a call to a C function */ 34 | #define PCRYIELD 2 /* C funtion yielded */ 35 | 36 | 37 | /* type of protected functions, to be ran by `runprotected' */ 38 | typedef void (*Pfunc) (lua_State *L, void *ud); 39 | 40 | LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name); 41 | LUAI_FUNC void luaD_callhook (lua_State *L, int event, int line); 42 | LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults); 43 | LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults); 44 | LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u, 45 | ptrdiff_t oldtop, ptrdiff_t ef); 46 | LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult); 47 | LUAI_FUNC void luaD_reallocCI (lua_State *L, int newsize); 48 | LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize); 49 | LUAI_FUNC void luaD_growstack (lua_State *L, int n); 50 | 51 | LUAI_FUNC void luaD_throw (lua_State *L, int errcode); 52 | LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud); 53 | 54 | LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop); 55 | 56 | #endif 57 | 58 | -------------------------------------------------------------------------------- /src/ldump.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: ldump.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** save precompiled Lua chunks 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #include 8 | 9 | #define ldump_c 10 | #define LUA_CORE 11 | 12 | #include "lua.h" 13 | 14 | #include "lobject.h" 15 | #include "lstate.h" 16 | #include "lundump.h" 17 | 18 | typedef struct { 19 | lua_State* L; 20 | lua_Writer writer; 21 | void* data; 22 | int strip; 23 | int status; 24 | } DumpState; 25 | 26 | #define DumpMem(b,n,size,D) DumpBlock(b,(n)*(size),D) 27 | #define DumpVar(x,D) DumpMem(&x,1,sizeof(x),D) 28 | 29 | static void DumpBlock(const void* b, size_t size, DumpState* D) 30 | { 31 | if (D->status==0) 32 | { 33 | lua_unlock(D->L); 34 | D->status=(*D->writer)(D->L,b,size,D->data); 35 | lua_lock(D->L); 36 | } 37 | } 38 | 39 | static void DumpChar(int y, DumpState* D) 40 | { 41 | char x=(char)y; 42 | DumpVar(x,D); 43 | } 44 | 45 | static void DumpInt(int x, DumpState* D) 46 | { 47 | DumpVar(x,D); 48 | } 49 | 50 | static void DumpNumber(lua_Number x, DumpState* D) 51 | { 52 | DumpVar(x,D); 53 | } 54 | 55 | static void DumpVector(const void* b, int n, size_t size, DumpState* D) 56 | { 57 | DumpInt(n,D); 58 | DumpMem(b,n,size,D); 59 | } 60 | 61 | static void DumpString(const TString* s, DumpState* D) 62 | { 63 | if (s==NULL || getstr(s)==NULL) 64 | { 65 | size_t size=0; 66 | DumpVar(size,D); 67 | } 68 | else 69 | { 70 | size_t size=s->tsv.len+1; /* include trailing '\0' */ 71 | DumpVar(size,D); 72 | DumpBlock(getstr(s),size,D); 73 | } 74 | } 75 | 76 | #define DumpCode(f,D) DumpVector(f->code,f->sizecode,sizeof(Instruction),D) 77 | 78 | static void DumpFunction(const Proto* f, const TString* p, DumpState* D); 79 | 80 | static void DumpConstants(const Proto* f, DumpState* D) 81 | { 82 | int i,n=f->sizek; 83 | DumpInt(n,D); 84 | for (i=0; ik[i]; 87 | DumpChar(ttype(o),D); 88 | switch (ttype(o)) 89 | { 90 | case LUA_TNIL: 91 | break; 92 | case LUA_TBOOLEAN: 93 | DumpChar(bvalue(o),D); 94 | break; 95 | case LUA_TNUMBER: 96 | DumpNumber(nvalue(o),D); 97 | break; 98 | case LUA_TSTRING: 99 | DumpString(rawtsvalue(o),D); 100 | break; 101 | default: 102 | lua_assert(0); /* cannot happen */ 103 | break; 104 | } 105 | } 106 | n=f->sizep; 107 | DumpInt(n,D); 108 | for (i=0; ip[i],f->source,D); 109 | } 110 | 111 | static void DumpDebug(const Proto* f, DumpState* D) 112 | { 113 | int i,n; 114 | n= (D->strip) ? 0 : f->sizelineinfo; 115 | DumpVector(f->lineinfo,n,sizeof(int),D); 116 | n= (D->strip) ? 0 : f->sizelocvars; 117 | DumpInt(n,D); 118 | for (i=0; ilocvars[i].varname,D); 121 | DumpInt(f->locvars[i].startpc,D); 122 | DumpInt(f->locvars[i].endpc,D); 123 | } 124 | n= (D->strip) ? 0 : f->sizeupvalues; 125 | DumpInt(n,D); 126 | for (i=0; iupvalues[i],D); 127 | } 128 | 129 | static void DumpFunction(const Proto* f, const TString* p, DumpState* D) 130 | { 131 | DumpString((f->source==p || D->strip) ? NULL : f->source,D); 132 | DumpInt(f->linedefined,D); 133 | DumpInt(f->lastlinedefined,D); 134 | DumpChar(f->nups,D); 135 | DumpChar(f->numparams,D); 136 | DumpChar(f->is_vararg,D); 137 | DumpChar(f->maxstacksize,D); 138 | DumpCode(f,D); 139 | DumpConstants(f,D); 140 | DumpDebug(f,D); 141 | } 142 | 143 | static void DumpHeader(DumpState* D) 144 | { 145 | char h[LUAC_HEADERSIZE]; 146 | luaU_header(h); 147 | DumpBlock(h,LUAC_HEADERSIZE,D); 148 | } 149 | 150 | /* 151 | ** dump Lua function as precompiled chunk 152 | */ 153 | int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip) 154 | { 155 | DumpState D; 156 | D.L=L; 157 | D.writer=w; 158 | D.data=data; 159 | D.strip=strip; 160 | D.status=0; 161 | DumpHeader(&D); 162 | DumpFunction(f,NULL,&D); 163 | return D.status; 164 | } 165 | -------------------------------------------------------------------------------- /src/lfunc.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lfunc.c,v 2.12.1.2 2007/12/28 14:58:43 roberto Exp $ 3 | ** Auxiliary functions to manipulate prototypes and closures 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #include 9 | 10 | #define lfunc_c 11 | #define LUA_CORE 12 | 13 | #include "lua.h" 14 | 15 | #include "lfunc.h" 16 | #include "lgc.h" 17 | #include "lmem.h" 18 | #include "lobject.h" 19 | #include "lstate.h" 20 | 21 | 22 | 23 | Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e) { 24 | Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems))); 25 | luaC_link(L, obj2gco(c), LUA_TFUNCTION); 26 | c->c.isC = 1; 27 | c->c.env = e; 28 | c->c.nupvalues = cast_byte(nelems); 29 | return c; 30 | } 31 | 32 | // 创建一个lua函数调用, nelems是该函数的upval数量 33 | Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) { 34 | Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems))); 35 | luaC_link(L, obj2gco(c), LUA_TFUNCTION); 36 | c->l.isC = 0; 37 | c->l.env = e; 38 | c->l.nupvalues = cast_byte(nelems); 39 | // 首先将upval数组置空 40 | while (nelems--) c->l.upvals[nelems] = NULL; 41 | return c; 42 | } 43 | 44 | 45 | UpVal *luaF_newupval (lua_State *L) { 46 | UpVal *uv = luaM_new(L, UpVal); 47 | luaC_link(L, obj2gco(uv), LUA_TUPVAL); 48 | // 初始时uv->v指向uv->u.value（此时是closed状态） 49 | uv->v = &uv->u.value; 50 | setnilvalue(uv->v); 51 | return uv; 52 | } 53 | 54 | 55 | UpVal *luaF_findupval (lua_State *L, StkId level) { 56 | global_State *g = G(L); 57 | GCObject **pp = &L->openupval; 58 | UpVal *p; 59 | UpVal *uv; 60 | while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) { 61 | lua_assert(p->v != &p->u.value); 62 | if (p->v == level) { /* found a corresponding upvalue? */ 63 | if (isdead(g, obj2gco(p))) /* is it dead? */ 64 | changewhite(obj2gco(p)); /* ressurect it */ 65 | return p; 66 | } 67 | pp = &p->next; 68 | } 69 | uv = luaM_new(L, UpVal); /* not found: create a new one */ 70 | uv->tt = LUA_TUPVAL; 71 | uv->marked = luaC_white(g); 72 | // 有值则指向level（此时是open状态） 73 | uv->v = level; /* current value lives in the stack */ 74 | uv->next = *pp; /* chain it in the proper position */ 75 | *pp = obj2gco(uv); 76 | uv->u.l.prev = &g->uvhead; /* double link it in `uvhead' list */ 77 | uv->u.l.next = g->uvhead.u.l.next; 78 | uv->u.l.next->u.l.prev = uv; 79 | g->uvhead.u.l.next = uv; 80 | lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv); 81 | return uv; 82 | } 83 | 84 | // 从uvhead链表中删除 85 | static void unlinkupval (UpVal *uv) { 86 | lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv); 87 | uv->u.l.next->u.l.prev = uv->u.l.prev; /* remove from `uvhead' list */ 88 | uv->u.l.prev->u.l.next = uv->u.l.next; 89 | } 90 | 91 | 92 | void luaF_freeupval (lua_State *L, UpVal *uv) { 93 | if (uv->v != &uv->u.value) /* is it open? */ 94 | unlinkupval(uv); /* remove from open list */ 95 | luaM_free(L, uv); /* free upvalue */ 96 | } 97 | 98 | 99 | void luaF_close (lua_State *L, StkId level) { 100 | UpVal *uv; 101 | global_State *g = G(L); 102 | while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) { 103 | GCObject *o = obj2gco(uv); 104 | lua_assert(!isblack(o) && uv->v != &uv->u.value); 105 | L->openupval = uv->next; /* remove from `open' list */ 106 | if (isdead(g, o)) 107 | // 如果upval已经死了，直接删除 108 | luaF_freeupval(L, uv); /* free upvalue */ 109 | else { 110 | // 从uvhead链表中删除 111 | unlinkupval(uv); 112 | // 将所指向的值保存在value中,表示这个upval已经close了 113 | // 为什么需要保存这个值呢?因为后面可能还会被引用到,这一点当前还是未知的 114 | setobj(L, &uv->u.value, uv->v); 115 | // v指向value 116 | uv->v = &uv->u.value; /* now current value lives here */ 117 | // 将这个upval链接到gcroot链表中 118 | luaC_linkupval(L, uv); /* link upvalue into `gcroot' list */ 119 | } 120 | } 121 | } 122 | 123 | 124 | Proto *luaF_newproto (lua_State *L) { 125 | Proto *f = luaM_new(L, Proto); 126 | luaC_link(L, obj2gco(f), LUA_TPROTO); 127 | f->k = NULL; 128 | f->sizek = 0; 129 | f->p = NULL; 130 | f->sizep = 0; 131 | f->code = NULL; 132 | f->sizecode = 0; 133 | f->sizelineinfo = 0; 134 | f->sizeupvalues = 0; 135 | f->nups = 0; 136 | f->upvalues = NULL; 137 | f->numparams = 0; 138 | f->is_vararg = 0; 139 | f->maxstacksize = 0; 140 | f->lineinfo = NULL; 141 | f->sizelocvars = 0; 142 | f->locvars = NULL; 143 | f->linedefined = 0; 144 | f->lastlinedefined = 0; 145 | f->source = NULL; 146 | return f; 147 | } 148 | 149 | 150 | void luaF_freeproto (lua_State *L, Proto *f) { 151 | luaM_freearray(L, f->code, f->sizecode, Instruction); 152 | luaM_freearray(L, f->p, f->sizep, Proto *); 153 | luaM_freearray(L, f->k, f->sizek, TValue); 154 | luaM_freearray(L, f->lineinfo, f->sizelineinfo, int); 155 | luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar); 156 | luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *); 157 | luaM_free(L, f); 158 | } 159 | 160 | 161 | void luaF_freeclosure (lua_State *L, Closure *c) { 162 | int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) : 163 | sizeLclosure(c->l.nupvalues); 164 | luaM_freemem(L, c, size); 165 | } 166 | 167 | 168 | /* 169 | ** Look for n-th local variable at line `line' in function `func'. 170 | ** Returns NULL if not found. 171 | */ 172 | const char *luaF_getlocalname (const Proto *f, int local_number, int pc) { 173 | int i; 174 | for (i = 0; isizelocvars && f->locvars[i].startpc <= pc; i++) { 175 | if (pc < f->locvars[i].endpc) { /* is variable active? */ 176 | local_number--; 177 | if (local_number == 0) 178 | return getstr(f->locvars[i].varname); 179 | } 180 | } 181 | return NULL; /* not found */ 182 | } 183 | 184 | -------------------------------------------------------------------------------- /src/lfunc.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lfunc.h,v 2.4.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Auxiliary functions to manipulate prototypes and closures 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lfunc_h 8 | #define lfunc_h 9 | 10 | 11 | #include "lobject.h" 12 | 13 | 14 | #define sizeCclosure(n) (cast(int, sizeof(CClosure)) + \ 15 | cast(int, sizeof(TValue)*((n)-1))) 16 | 17 | #define sizeLclosure(n) (cast(int, sizeof(LClosure)) + \ 18 | cast(int, sizeof(TValue *)*((n)-1))) 19 | 20 | 21 | LUAI_FUNC Proto *luaF_newproto (lua_State *L); 22 | LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e); 23 | LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e); 24 | LUAI_FUNC UpVal *luaF_newupval (lua_State *L); 25 | LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level); 26 | LUAI_FUNC void luaF_close (lua_State *L, StkId level); 27 | LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f); 28 | LUAI_FUNC void luaF_freeclosure (lua_State *L, Closure *c); 29 | LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv); 30 | LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number, 31 | int pc); 32 | 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/lgc.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lgc.h,v 2.15.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Garbage Collector 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lgc_h 8 | #define lgc_h 9 | 10 | 11 | #include "lobject.h" 12 | 13 | 14 | /* 15 | ** Possible states of the Garbage Collector 16 | */ 17 | #define GCSpause 0 18 | #define GCSpropagate 1 19 | #define GCSsweepstring 2 20 | #define GCSsweep 3 21 | #define GCSfinalize 4 22 | 23 | 24 | /* 25 | ** some userful bit tricks 26 | */ 27 | #define resetbits(x,m) ((x) &= cast(lu_byte, ~(m))) 28 | #define setbits(x,m) ((x) |= (m)) 29 | #define testbits(x,m) ((x) & (m)) 30 | #define bitmask(b) (1<<(b)) 31 | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) 32 | #define l_setbit(x,b) setbits(x, bitmask(b)) 33 | #define resetbit(x,b) resetbits(x, bitmask(b)) 34 | #define testbit(x,b) testbits(x, bitmask(b)) 35 | #define set2bits(x,b1,b2) setbits(x, (bit2mask(b1, b2))) 36 | #define reset2bits(x,b1,b2) resetbits(x, (bit2mask(b1, b2))) 37 | #define test2bits(x,b1,b2) testbits(x, (bit2mask(b1, b2))) 38 | 39 | 40 | 41 | /* 42 | ** Layout for bit use in `marked' field: 43 | ** bit 0 - object is white (type 0) 44 | ** bit 1 - object is white (type 1) 45 | ** bit 2 - object is black 46 | ** bit 3 - for userdata: has been finalized 47 | ** bit 3 - for tables: has weak keys 48 | ** bit 4 - for tables: has weak values 49 | ** bit 5 - object is fixed (should not be collected) 50 | ** bit 6 - object is "super" fixed (only the main thread) 51 | */ 52 | 53 | 54 | #define WHITE0BIT 0 55 | #define WHITE1BIT 1 56 | #define BLACKBIT 2 57 | #define FINALIZEDBIT 3 58 | // 弱key 59 | #define KEYWEAKBIT 3 60 | // 弱值 61 | #define VALUEWEAKBIT 4 62 | // 标记这个GC对象不可回收 63 | #define FIXEDBIT 5 64 | #define SFIXEDBIT 6 65 | // 两种白色的或 66 | #define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) 67 | 68 | // 将mark位与两个白色位进行比较，只要其中一个置位就是白色的 69 | #define iswhite(x) test2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT) 70 | // 将mark位与黑色位进行比较 71 | #define isblack(x) testbit((x)->gch.marked, BLACKBIT) 72 | // 既不是白色，也不是黑色 73 | #define isgray(x) (!isblack(x) && !iswhite(x)) 74 | // 不是当前的白色 75 | #define otherwhite(g) (g->currentwhite ^ WHITEBITS) 76 | 77 | // 如果结点的白色是otherwhite，那么就是一个死结点 78 | // 这个函数都是在mark阶段过后使用的,所以此时的otherwhite其实就是本次GC的白色 79 | #define isdead(g,v) ((v)->gch.marked & otherwhite(g) & WHITEBITS) 80 | 81 | // 将节点mark为白色,同时清除黑色/灰色等 82 | #define changewhite(x) ((x)->gch.marked ^= WHITEBITS) 83 | #define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT) 84 | 85 | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) 86 | 87 | // 返回当前的白色 88 | #define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS) 89 | 90 | // 如果大于阙值,就启动一次GC 91 | #define luaC_checkGC(L) { \ 92 | condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1)); \ 93 | if (G(L)->totalbytes >= G(L)->GCthreshold) \ 94 | luaC_step(L); } 95 | 96 | 97 | #define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \ 98 | luaC_barrierf(L,obj2gco(p),gcvalue(v)); } 99 | 100 | // 回退成黑色 101 | #define luaC_barriert(L,t,v) { if (valiswhite(v) && isblack(obj2gco(t))) \ 102 | luaC_barrierback(L,t); } 103 | 104 | #define luaC_objbarrier(L,p,o) \ 105 | { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \ 106 | luaC_barrierf(L,obj2gco(p),obj2gco(o)); } 107 | 108 | #define luaC_objbarriert(L,t,o) \ 109 | { if (iswhite(obj2gco(o)) && isblack(obj2gco(t))) luaC_barrierback(L,t); } 110 | 111 | LUAI_FUNC size_t luaC_separateudata (lua_State *L, int all); 112 | LUAI_FUNC void luaC_callGCTM (lua_State *L); 113 | LUAI_FUNC void luaC_freeall (lua_State *L); 114 | LUAI_FUNC void luaC_step (lua_State *L); 115 | LUAI_FUNC void luaC_fullgc (lua_State *L); 116 | LUAI_FUNC void luaC_link (lua_State *L, GCObject *o, lu_byte tt); 117 | LUAI_FUNC void luaC_linkupval (lua_State *L, UpVal *uv); 118 | LUAI_FUNC void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v); 119 | LUAI_FUNC void luaC_barrierback (lua_State *L, Table *t); 120 | 121 | 122 | #endif 123 | -------------------------------------------------------------------------------- /src/linit.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: linit.c,v 1.14.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Initialization of libraries for lua.c 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #define linit_c 9 | #define LUA_LIB 10 | 11 | #include "lua.h" 12 | 13 | #include "lualib.h" 14 | #include "lauxlib.h" 15 | 16 | 17 | static const luaL_Reg lualibs[] = { 18 | {"", luaopen_base}, 19 | {LUA_LOADLIBNAME, luaopen_package}, 20 | {LUA_TABLIBNAME, luaopen_table}, 21 | {LUA_IOLIBNAME, luaopen_io}, 22 | {LUA_OSLIBNAME, luaopen_os}, 23 | {LUA_STRLIBNAME, luaopen_string}, 24 | {LUA_MATHLIBNAME, luaopen_math}, 25 | {LUA_DBLIBNAME, luaopen_debug}, 26 | {NULL, NULL} 27 | }; 28 | 29 | 30 | LUALIB_API void luaL_openlibs (lua_State *L) { 31 | const luaL_Reg *lib = lualibs; 32 | for (; lib->func; lib++) { 33 | // 向函数栈push函数结构体 34 | lua_pushcfunction(L, lib->func); 35 | // 向函数栈push库名(这里似乎没有必要push名字进去) 36 | lua_pushstring(L, lib->name); 37 | // 调用注册的C函数, 也就是上面的一堆luaopen_*函数 38 | // 问题: 为什么这里不直接调用呢?非得压入lua栈中调用? 39 | // 传入1的原因是要跳过上一步压入的函数名,0的意思是这些函数全都返回值为0即没有返回值 40 | lua_call(L, 1, 0); 41 | } 42 | } 43 | 44 | -------------------------------------------------------------------------------- /src/llex.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: llex.h,v 1.58.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Lexical Analyzer 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef llex_h 8 | #define llex_h 9 | 10 | #include "lobject.h" 11 | #include "lzio.h" 12 | 13 | // 256个字符 14 | #define FIRST_RESERVED 257 15 | 16 | /* maximum length of a reserved word */ 17 | #define TOKEN_LEN (sizeof("function")/sizeof(char)) 18 | 19 | 20 | /* 21 | * WARNING: if you change the order of this enumeration, 22 | * grep "ORDER RESERVED" 23 | */ 24 | enum RESERVED { 25 | /* terminal symbols denoted by reserved words */ 26 | TK_AND = FIRST_RESERVED, TK_BREAK, 27 | TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION, 28 | TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT, 29 | TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE, 30 | /* other terminal symbols */ 31 | TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_NUMBER, 32 | TK_NAME, TK_STRING, TK_EOS 33 | }; 34 | 35 | /* number of reserved words */ 36 | #define NUM_RESERVED (cast(int, TK_WHILE-FIRST_RESERVED+1)) 37 | 38 | 39 | /* array with token `names' */ 40 | LUAI_DATA const char *const luaX_tokens []; 41 | 42 | // 存放数据信息：字符串或者数字 43 | typedef union { 44 | lua_Number r; 45 | TString *ts; 46 | } SemInfo; /* semantics information */ 47 | 48 | 49 | typedef struct Token { 50 | int token; 51 | SemInfo seminfo; 52 | } Token; 53 | 54 | // 保存词法分析状态的数据结构 55 | typedef struct LexState { 56 | int current; /* current character (charint) */ 57 | int linenumber; /* input line counter */ 58 | int lastline; /* line of last token `consumed' */ 59 | Token t; /* current token */ 60 | Token lookahead; /* look ahead token */ 61 | struct FuncState *fs; /* `FuncState' is private to the parser */ 62 | struct lua_State *L; 63 | ZIO *z; /* input stream */ 64 | Mbuffer *buff; /* buffer for tokens */ 65 | TString *source; /* current source name */ 66 | char decpoint; /* locale decimal point */ 67 | } LexState; 68 | 69 | 70 | LUAI_FUNC void luaX_init (lua_State *L); 71 | LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, 72 | TString *source); 73 | LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l); 74 | LUAI_FUNC void luaX_next (LexState *ls); 75 | LUAI_FUNC void luaX_lookahead (LexState *ls); 76 | LUAI_FUNC void luaX_lexerror (LexState *ls, const char *msg, int token); 77 | LUAI_FUNC void luaX_syntaxerror (LexState *ls, const char *s); 78 | LUAI_FUNC const char *luaX_token2str (LexState *ls, int token); 79 | 80 | 81 | #endif 82 | -------------------------------------------------------------------------------- /src/llimits.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: llimits.h,v 1.69.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Limits, basic types, and some other `installation-dependent' definitions 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef llimits_h 8 | #define llimits_h 9 | 10 | 11 | #include 12 | #include 13 | 14 | 15 | #include "lua.h" 16 | 17 | 18 | typedef LUAI_UINT32 lu_int32; 19 | 20 | typedef LUAI_UMEM lu_mem; 21 | 22 | typedef LUAI_MEM l_mem; 23 | 24 | 25 | 26 | /* chars used as small naturals (so that `char' is reserved for characters) */ 27 | typedef unsigned char lu_byte; 28 | 29 | 30 | #define MAX_SIZET ((size_t)(~(size_t)0)-2) 31 | 32 | #define MAX_LUMEM ((lu_mem)(~(lu_mem)0)-2) 33 | 34 | 35 | #define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */ 36 | 37 | /* 38 | ** conversion of pointer to integer 39 | ** this is for hashing only; there is no problem if the integer 40 | ** cannot hold the whole pointer value 41 | */ 42 | #define IntPoint(p) ((unsigned int)(lu_mem)(p)) 43 | 44 | 45 | 46 | /* type to ensure maximum alignment */ 47 | typedef LUAI_USER_ALIGNMENT_T L_Umaxalign; 48 | 49 | 50 | /* result of a `usual argument conversion' over lua_Number */ 51 | typedef LUAI_UACNUMBER l_uacNumber; 52 | 53 | 54 | /* internal assertions for in-house debugging */ 55 | #ifdef lua_assert 56 | 57 | #define check_exp(c,e) (lua_assert(c), (e)) 58 | #define api_check(l,e) lua_assert(e) 59 | 60 | #else 61 | 62 | #define lua_assert(c) ((void)0) 63 | #define check_exp(c,e) (e) 64 | #define api_check luai_apicheck 65 | 66 | #endif 67 | 68 | 69 | #ifndef UNUSED 70 | #define UNUSED(x) ((void)(x)) /* to avoid warnings */ 71 | #endif 72 | 73 | 74 | #ifndef cast 75 | #define cast(t, exp) ((t)(exp)) 76 | #endif 77 | 78 | #define cast_byte(i) cast(lu_byte, (i)) 79 | #define cast_num(i) cast(lua_Number, (i)) 80 | #define cast_int(i) cast(int, (i)) 81 | 82 | 83 | 84 | /* 85 | ** type for virtual-machine instructions 86 | ** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h) 87 | */ 88 | typedef lu_int32 Instruction; 89 | 90 | 91 | 92 | /* maximum stack for a Lua function */ 93 | #define MAXSTACK 250 94 | 95 | 96 | 97 | /* minimum size for the string table (must be power of 2) */ 98 | #ifndef MINSTRTABSIZE 99 | #define MINSTRTABSIZE 32 100 | #endif 101 | 102 | 103 | /* minimum size for string buffer */ 104 | #ifndef LUA_MINBUFFER 105 | #define LUA_MINBUFFER 32 106 | #endif 107 | 108 | 109 | #ifndef lua_lock 110 | #define lua_lock(L) ((void) 0) 111 | #define lua_unlock(L) ((void) 0) 112 | #endif 113 | 114 | #ifndef luai_threadyield 115 | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} 116 | #endif 117 | 118 | 119 | /* 120 | ** macro to control inclusion of some hard tests on stack reallocation 121 | */ 122 | #ifndef HARDSTACKTESTS 123 | #define condhardstacktests(x) ((void)0) 124 | #else 125 | #define condhardstacktests(x) x 126 | #endif 127 | 128 | #endif 129 | -------------------------------------------------------------------------------- /src/lmathlib.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lmathlib.c,v 1.67.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Standard mathematical library 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #include 9 | #include 10 | 11 | #define lmathlib_c 12 | #define LUA_LIB 13 | 14 | #include "lua.h" 15 | 16 | #include "lauxlib.h" 17 | #include "lualib.h" 18 | 19 | 20 | #undef PI 21 | #define PI (3.14159265358979323846) 22 | #define RADIANS_PER_DEGREE (PI/180.0) 23 | 24 | 25 | 26 | static int math_abs (lua_State *L) { 27 | lua_pushnumber(L, fabs(luaL_checknumber(L, 1))); 28 | return 1; 29 | } 30 | 31 | static int math_sin (lua_State *L) { 32 | lua_pushnumber(L, sin(luaL_checknumber(L, 1))); 33 | return 1; 34 | } 35 | 36 | static int math_sinh (lua_State *L) { 37 | lua_pushnumber(L, sinh(luaL_checknumber(L, 1))); 38 | return 1; 39 | } 40 | 41 | static int math_cos (lua_State *L) { 42 | lua_pushnumber(L, cos(luaL_checknumber(L, 1))); 43 | return 1; 44 | } 45 | 46 | static int math_cosh (lua_State *L) { 47 | lua_pushnumber(L, cosh(luaL_checknumber(L, 1))); 48 | return 1; 49 | } 50 | 51 | static int math_tan (lua_State *L) { 52 | lua_pushnumber(L, tan(luaL_checknumber(L, 1))); 53 | return 1; 54 | } 55 | 56 | static int math_tanh (lua_State *L) { 57 | lua_pushnumber(L, tanh(luaL_checknumber(L, 1))); 58 | return 1; 59 | } 60 | 61 | static int math_asin (lua_State *L) { 62 | lua_pushnumber(L, asin(luaL_checknumber(L, 1))); 63 | return 1; 64 | } 65 | 66 | static int math_acos (lua_State *L) { 67 | lua_pushnumber(L, acos(luaL_checknumber(L, 1))); 68 | return 1; 69 | } 70 | 71 | static int math_atan (lua_State *L) { 72 | lua_pushnumber(L, atan(luaL_checknumber(L, 1))); 73 | return 1; 74 | } 75 | 76 | static int math_atan2 (lua_State *L) { 77 | lua_pushnumber(L, atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2))); 78 | return 1; 79 | } 80 | 81 | static int math_ceil (lua_State *L) { 82 | lua_pushnumber(L, ceil(luaL_checknumber(L, 1))); 83 | return 1; 84 | } 85 | 86 | static int math_floor (lua_State *L) { 87 | lua_pushnumber(L, floor(luaL_checknumber(L, 1))); 88 | return 1; 89 | } 90 | 91 | static int math_fmod (lua_State *L) { 92 | lua_pushnumber(L, fmod(luaL_checknumber(L, 1), luaL_checknumber(L, 2))); 93 | return 1; 94 | } 95 | 96 | static int math_modf (lua_State *L) { 97 | double ip; 98 | double fp = modf(luaL_checknumber(L, 1), &ip); 99 | lua_pushnumber(L, ip); 100 | lua_pushnumber(L, fp); 101 | return 2; 102 | } 103 | 104 | static int math_sqrt (lua_State *L) { 105 | lua_pushnumber(L, sqrt(luaL_checknumber(L, 1))); 106 | return 1; 107 | } 108 | 109 | static int math_pow (lua_State *L) { 110 | lua_pushnumber(L, pow(luaL_checknumber(L, 1), luaL_checknumber(L, 2))); 111 | return 1; 112 | } 113 | 114 | static int math_log (lua_State *L) { 115 | lua_pushnumber(L, log(luaL_checknumber(L, 1))); 116 | return 1; 117 | } 118 | 119 | static int math_log10 (lua_State *L) { 120 | lua_pushnumber(L, log10(luaL_checknumber(L, 1))); 121 | return 1; 122 | } 123 | 124 | static int math_exp (lua_State *L) { 125 | lua_pushnumber(L, exp(luaL_checknumber(L, 1))); 126 | return 1; 127 | } 128 | 129 | static int math_deg (lua_State *L) { 130 | lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE); 131 | return 1; 132 | } 133 | 134 | static int math_rad (lua_State *L) { 135 | lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE); 136 | return 1; 137 | } 138 | 139 | static int math_frexp (lua_State *L) { 140 | int e; 141 | lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e)); 142 | lua_pushinteger(L, e); 143 | return 2; 144 | } 145 | 146 | static int math_ldexp (lua_State *L) { 147 | lua_pushnumber(L, ldexp(luaL_checknumber(L, 1), luaL_checkint(L, 2))); 148 | return 1; 149 | } 150 | 151 | 152 | 153 | static int math_min (lua_State *L) { 154 | int n = lua_gettop(L); /* number of arguments */ 155 | lua_Number dmin = luaL_checknumber(L, 1); 156 | int i; 157 | for (i=2; i<=n; i++) { 158 | lua_Number d = luaL_checknumber(L, i); 159 | if (d < dmin) 160 | dmin = d; 161 | } 162 | lua_pushnumber(L, dmin); 163 | return 1; 164 | } 165 | 166 | 167 | static int math_max (lua_State *L) { 168 | int n = lua_gettop(L); /* number of arguments */ 169 | lua_Number dmax = luaL_checknumber(L, 1); 170 | int i; 171 | for (i=2; i<=n; i++) { 172 | lua_Number d = luaL_checknumber(L, i); 173 | if (d > dmax) 174 | dmax = d; 175 | } 176 | lua_pushnumber(L, dmax); 177 | return 1; 178 | } 179 | 180 | 181 | static int math_random (lua_State *L) { 182 | /* the `%' avoids the (rare) case of r==1, and is needed also because on 183 | some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */ 184 | lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX; 185 | switch (lua_gettop(L)) { /* check number of arguments */ 186 | case 0: { /* no arguments */ 187 | lua_pushnumber(L, r); /* Number between 0 and 1 */ 188 | break; 189 | } 190 | case 1: { /* only upper limit */ 191 | int u = luaL_checkint(L, 1); 192 | luaL_argcheck(L, 1<=u, 1, "interval is empty"); 193 | lua_pushnumber(L, floor(r*u)+1); /* int between 1 and `u' */ 194 | break; 195 | } 196 | case 2: { /* lower and upper limits */ 197 | int l = luaL_checkint(L, 1); 198 | int u = luaL_checkint(L, 2); 199 | luaL_argcheck(L, l<=u, 2, "interval is empty"); 200 | lua_pushnumber(L, floor(r*(u-l+1))+l); /* int between `l' and `u' */ 201 | break; 202 | } 203 | default: return luaL_error(L, "wrong number of arguments"); 204 | } 205 | return 1; 206 | } 207 | 208 | 209 | static int math_randomseed (lua_State *L) { 210 | srand(luaL_checkint(L, 1)); 211 | return 0; 212 | } 213 | 214 | 215 | static const luaL_Reg mathlib[] = { 216 | {"abs", math_abs}, 217 | {"acos", math_acos}, 218 | {"asin", math_asin}, 219 | {"atan2", math_atan2}, 220 | {"atan", math_atan}, 221 | {"ceil", math_ceil}, 222 | {"cosh", math_cosh}, 223 | {"cos", math_cos}, 224 | {"deg", math_deg}, 225 | {"exp", math_exp}, 226 | {"floor", math_floor}, 227 | {"fmod", math_fmod}, 228 | {"frexp", math_frexp}, 229 | {"ldexp", math_ldexp}, 230 | {"log10", math_log10}, 231 | {"log", math_log}, 232 | {"max", math_max}, 233 | {"min", math_min}, 234 | {"modf", math_modf}, 235 | {"pow", math_pow}, 236 | {"rad", math_rad}, 237 | {"random", math_random}, 238 | {"randomseed", math_randomseed}, 239 | {"sinh", math_sinh}, 240 | {"sin", math_sin}, 241 | {"sqrt", math_sqrt}, 242 | {"tanh", math_tanh}, 243 | {"tan", math_tan}, 244 | {NULL, NULL} 245 | }; 246 | 247 | 248 | /* 249 | ** Open math library 250 | */ 251 | LUALIB_API int luaopen_math (lua_State *L) { 252 | luaL_register(L, LUA_MATHLIBNAME, mathlib); 253 | lua_pushnumber(L, PI); 254 | lua_setfield(L, -2, "pi"); 255 | lua_pushnumber(L, HUGE_VAL); 256 | lua_setfield(L, -2, "huge"); 257 | #if defined(LUA_COMPAT_MOD) 258 | lua_getfield(L, -1, "fmod"); 259 | lua_setfield(L, -2, "mod"); 260 | #endif 261 | return 1; 262 | } 263 | 264 | -------------------------------------------------------------------------------- /src/lmem.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lmem.c,v 1.70.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Interface to Memory Manager 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #include 9 | 10 | #define lmem_c 11 | #define LUA_CORE 12 | 13 | #include "lua.h" 14 | 15 | #include "ldebug.h" 16 | #include "ldo.h" 17 | #include "lmem.h" 18 | #include "lobject.h" 19 | #include "lstate.h" 20 | 21 | 22 | 23 | /* 24 | ** About the realloc function: 25 | ** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize); 26 | ** (`osize' is the old size, `nsize' is the new size) 27 | ** 28 | ** Lua ensures that (ptr == NULL) iff (osize == 0). 29 | ** 30 | ** * frealloc(ud, NULL, 0, x) creates a new block of size `x' 31 | ** 32 | ** * frealloc(ud, p, x, 0) frees the block `p' 33 | ** (in this specific case, frealloc must return NULL). 34 | ** particularly, frealloc(ud, NULL, 0, 0) does nothing 35 | ** (which is equivalent to free(NULL) in ANSI C) 36 | ** 37 | ** frealloc returns NULL if it cannot create or reallocate the area 38 | ** (any reallocation to an equal or smaller size cannot fail!) 39 | */ 40 | 41 | 42 | 43 | #define MINSIZEARRAY 4 44 | 45 | 46 | void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems, 47 | int limit, const char *errormsg) { 48 | void *newblock; 49 | int newsize; 50 | if (*size >= limit/2) { /* cannot double it? */ 51 | if (*size >= limit) /* cannot grow even a little? */ 52 | luaG_runerror(L, errormsg); 53 | newsize = limit; /* still have at least one free place */ 54 | } 55 | else { 56 | newsize = (*size)*2; 57 | if (newsize < MINSIZEARRAY) 58 | newsize = MINSIZEARRAY; /* minimum size */ 59 | } 60 | newblock = luaM_reallocv(L, block, *size, newsize, size_elems); 61 | *size = newsize; /* update only when everything else is OK */ 62 | return newblock; 63 | } 64 | 65 | 66 | void *luaM_toobig (lua_State *L) { 67 | luaG_runerror(L, "memory allocation error: block too big"); 68 | return NULL; /* to avoid warnings */ 69 | } 70 | 71 | 72 | 73 | /* 74 | ** generic allocation routine. 75 | */ 76 | void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) { 77 | global_State *g = G(L); 78 | lua_assert((osize == 0) == (block == NULL)); 79 | block = (*g->frealloc)(g->ud, block, osize, nsize); 80 | if (block == NULL && nsize > 0) 81 | luaD_throw(L, LUA_ERRMEM); 82 | lua_assert((nsize == 0) == (block == NULL)); 83 | g->totalbytes = (g->totalbytes - osize) + nsize; 84 | return block; 85 | } 86 | 87 | -------------------------------------------------------------------------------- /src/lmem.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lmem.h,v 1.31.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Interface to Memory Manager 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lmem_h 8 | #define lmem_h 9 | 10 | 11 | #include 12 | 13 | #include "llimits.h" 14 | #include "lua.h" 15 | 16 | #define MEMERRMSG "not enough memory" 17 | 18 | 19 | #define luaM_reallocv(L,b,on,n,e) \ 20 | ((cast(size_t, (n)+1) <= MAX_SIZET/(e)) ? /* +1 to avoid warnings */ \ 21 | luaM_realloc_(L, (b), (on)*(e), (n)*(e)) : \ 22 | luaM_toobig(L)) 23 | 24 | #define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0) 25 | #define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0) 26 | #define luaM_freearray(L, b, n, t) luaM_reallocv(L, (b), n, 0, sizeof(t)) 27 | 28 | #define luaM_malloc(L,t) luaM_realloc_(L, NULL, 0, (t)) 29 | #define luaM_new(L,t) cast(t *, luaM_malloc(L, sizeof(t))) 30 | #define luaM_newvector(L,n,t) \ 31 | cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t))) 32 | 33 | #define luaM_growvector(L,v,nelems,size,t,limit,e) \ 34 | if ((nelems)+1 > (size)) \ 35 | ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e))) 36 | 37 | #define luaM_reallocvector(L, v,oldn,n,t) \ 38 | ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t)))) 39 | 40 | 41 | LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize, 42 | size_t size); 43 | LUAI_FUNC void *luaM_toobig (lua_State *L); 44 | LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size, 45 | size_t size_elem, int limit, 46 | const char *errormsg); 47 | 48 | #endif 49 | 50 | -------------------------------------------------------------------------------- /src/lobject.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lobject.c,v 2.22.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Some generic functions over Lua objects 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | #define lobject_c 14 | #define LUA_CORE 15 | 16 | #include "lua.h" 17 | 18 | #include "ldo.h" 19 | #include "lmem.h" 20 | #include "lobject.h" 21 | #include "lstate.h" 22 | #include "lstring.h" 23 | #include "lvm.h" 24 | 25 | 26 | 27 | const TValue luaO_nilobject_ = {{NULL}, LUA_TNIL}; 28 | 29 | 30 | /* 31 | ** converts an integer to a "floating point byte", represented as 32 | ** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if 33 | ** eeeee != 0 and (xxx) otherwise. 34 | */ 35 | int luaO_int2fb (unsigned int x) { 36 | int e = 0; /* expoent */ 37 | while (x >= 16) { 38 | x = (x+1) >> 1; 39 | e++; 40 | } 41 | if (x < 8) return x; 42 | else return ((e+1) << 3) | (cast_int(x) - 8); 43 | } 44 | 45 | 46 | /* converts back */ 47 | int luaO_fb2int (int x) { 48 | int e = (x >> 3) & 31; 49 | if (e == 0) return x; 50 | else return ((x & 7)+8) << (e - 1); 51 | } 52 | 53 | 54 | int luaO_log2 (unsigned int x) { 55 | static const lu_byte log_2[256] = { 56 | 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, 57 | 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, 58 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 59 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 60 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 61 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 62 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 63 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8 64 | }; 65 | int l = -1; 66 | while (x >= 256) { l += 8; x >>= 8; } 67 | return l + log_2[x]; 68 | 69 | } 70 | 71 | 72 | int luaO_rawequalObj (const TValue *t1, const TValue *t2) { 73 | if (ttype(t1) != ttype(t2)) return 0; 74 | else switch (ttype(t1)) { 75 | case LUA_TNIL: 76 | return 1; 77 | case LUA_TNUMBER: 78 | return luai_numeq(nvalue(t1), nvalue(t2)); 79 | case LUA_TBOOLEAN: 80 | return bvalue(t1) == bvalue(t2); /* boolean true must be 1 !! */ 81 | case LUA_TLIGHTUSERDATA: 82 | return pvalue(t1) == pvalue(t2); 83 | default: 84 | lua_assert(iscollectable(t1)); 85 | return gcvalue(t1) == gcvalue(t2); 86 | } 87 | } 88 | 89 | 90 | int luaO_str2d (const char *s, lua_Number *result) { 91 | char *endptr; 92 | *result = lua_str2number(s, &endptr); 93 | if (endptr == s) return 0; /* conversion failed */ 94 | if (*endptr == 'x' || *endptr == 'X') /* maybe an hexadecimal constant? */ 95 | *result = cast_num(strtoul(s, &endptr, 16)); 96 | if (*endptr == '\0') return 1; /* most common case */ 97 | while (isspace(cast(unsigned char, *endptr))) endptr++; 98 | if (*endptr != '\0') return 0; /* invalid trailing characters? */ 99 | return 1; 100 | } 101 | 102 | 103 | 104 | static void pushstr (lua_State *L, const char *str) { 105 | setsvalue2s(L, L->top, luaS_new(L, str)); 106 | incr_top(L); 107 | } 108 | 109 | 110 | /* this function handles only `%d', `%c', %f, %p, and `%s' formats */ 111 | const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) { 112 | int n = 1; 113 | pushstr(L, ""); 114 | for (;;) { 115 | const char *e = strchr(fmt, '%'); 116 | if (e == NULL) break; 117 | setsvalue2s(L, L->top, luaS_newlstr(L, fmt, e-fmt)); 118 | incr_top(L); 119 | switch (*(e+1)) { 120 | case 's': { 121 | const char *s = va_arg(argp, char *); 122 | if (s == NULL) s = "(null)"; 123 | pushstr(L, s); 124 | break; 125 | } 126 | case 'c': { 127 | char buff[2]; 128 | buff[0] = cast(char, va_arg(argp, int)); 129 | buff[1] = '\0'; 130 | pushstr(L, buff); 131 | break; 132 | } 133 | case 'd': { 134 | setnvalue(L->top, cast_num(va_arg(argp, int))); 135 | incr_top(L); 136 | break; 137 | } 138 | case 'f': { 139 | setnvalue(L->top, cast_num(va_arg(argp, l_uacNumber))); 140 | incr_top(L); 141 | break; 142 | } 143 | case 'p': { 144 | char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */ 145 | sprintf(buff, "%p", va_arg(argp, void *)); 146 | pushstr(L, buff); 147 | break; 148 | } 149 | case '%': { 150 | pushstr(L, "%"); 151 | break; 152 | } 153 | default: { 154 | char buff[3]; 155 | buff[0] = '%'; 156 | buff[1] = *(e+1); 157 | buff[2] = '\0'; 158 | pushstr(L, buff); 159 | break; 160 | } 161 | } 162 | n += 2; 163 | fmt = e+2; 164 | } 165 | pushstr(L, fmt); 166 | luaV_concat(L, n+1, cast_int(L->top - L->base) - 1); 167 | L->top -= n; 168 | return svalue(L->top - 1); 169 | } 170 | 171 | 172 | const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) { 173 | const char *msg; 174 | va_list argp; 175 | va_start(argp, fmt); 176 | msg = luaO_pushvfstring(L, fmt, argp); 177 | va_end(argp); 178 | return msg; 179 | } 180 | 181 | 182 | void luaO_chunkid (char *out, const char *source, size_t bufflen) { 183 | if (*source == '=') { 184 | strncpy(out, source+1, bufflen); /* remove first char */ 185 | out[bufflen-1] = '\0'; /* ensures null termination */ 186 | } 187 | else { /* out = "source", or "...source" */ 188 | if (*source == '@') { 189 | size_t l; 190 | source++; /* skip the `@' */ 191 | bufflen -= sizeof(" '...' "); 192 | l = strlen(source); 193 | strcpy(out, ""); 194 | if (l > bufflen) { 195 | source += (l-bufflen); /* get last part of file name */ 196 | strcat(out, "..."); 197 | } 198 | strcat(out, source); 199 | } 200 | else { /* out = [string "string"] */ 201 | size_t len = strcspn(source, "\n\r"); /* stop at first newline */ 202 | bufflen -= sizeof(" [string \"...\"] "); 203 | if (len > bufflen) len = bufflen; 204 | strcpy(out, "[string \""); 205 | if (source[len] != '\0') { /* must truncate? */ 206 | strncat(out, source, len); 207 | strcat(out, "..."); 208 | } 209 | else 210 | strcat(out, source); 211 | strcat(out, "\"]"); 212 | } 213 | } 214 | } 215 | -------------------------------------------------------------------------------- /src/lobject.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lobject.h,v 2.20.1.2 2008/08/06 13:29:48 roberto Exp $ 3 | ** Type definitions for Lua objects 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #ifndef lobject_h 9 | #define lobject_h 10 | 11 | 12 | #include 13 | 14 | 15 | #include "llimits.h" 16 | #include "lua.h" 17 | 18 | 19 | /* tags for values visible from Lua */ 20 | #define LAST_TAG LUA_TTHREAD 21 | 22 | #define NUM_TAGS (LAST_TAG+1) 23 | 24 | 25 | /* 26 | ** Extra tags for non-values 27 | */ 28 | #define LUA_TPROTO (LAST_TAG+1) 29 | #define LUA_TUPVAL (LAST_TAG+2) 30 | #define LUA_TDEADKEY (LAST_TAG+3) 31 | 32 | 33 | /* 34 | ** Union of all collectable objects 35 | */ 36 | typedef union GCObject GCObject; 37 | 38 | 39 | /* 40 | ** Common Header for all collectable objects (in macro form, to be 41 | ** included in other objects) 42 | */ 43 | #define CommonHeader GCObject *next; lu_byte tt; lu_byte marked 44 | 45 | 46 | /* 47 | ** Common header in struct form 48 | */ 49 | typedef struct GCheader { 50 | CommonHeader; 51 | } GCheader; 52 | 53 | 54 | 55 | 56 | /* 57 | ** Union of all Lua values 58 | */ 59 | typedef union { 60 | GCObject *gc; 61 | void *p; 62 | lua_Number n; 63 | int b; 64 | } Value; 65 | 66 | 67 | /* 68 | ** Tagged Values 69 | */ 70 | 71 | #define TValuefields Value value; int tt 72 | 73 | typedef struct lua_TValue { 74 | TValuefields; 75 | } TValue; 76 | 77 | 78 | /* Macros to test type */ 79 | #define ttisnil(o) (ttype(o) == LUA_TNIL) 80 | #define ttisnumber(o) (ttype(o) == LUA_TNUMBER) 81 | #define ttisstring(o) (ttype(o) == LUA_TSTRING) 82 | #define ttistable(o) (ttype(o) == LUA_TTABLE) 83 | #define ttisfunction(o) (ttype(o) == LUA_TFUNCTION) 84 | #define ttisboolean(o) (ttype(o) == LUA_TBOOLEAN) 85 | #define ttisuserdata(o) (ttype(o) == LUA_TUSERDATA) 86 | #define ttisthread(o) (ttype(o) == LUA_TTHREAD) 87 | #define ttislightuserdata(o) (ttype(o) == LUA_TLIGHTUSERDATA) 88 | 89 | /* Macros to access values */ 90 | #define ttype(o) ((o)->tt) 91 | #define gcvalue(o) check_exp(iscollectable(o), (o)->value.gc) 92 | #define pvalue(o) check_exp(ttislightuserdata(o), (o)->value.p) 93 | #define nvalue(o) check_exp(ttisnumber(o), (o)->value.n) 94 | #define rawtsvalue(o) check_exp(ttisstring(o), &(o)->value.gc->ts) 95 | #define tsvalue(o) (&rawtsvalue(o)->tsv) 96 | #define rawuvalue(o) check_exp(ttisuserdata(o), &(o)->value.gc->u) 97 | #define uvalue(o) (&rawuvalue(o)->uv) 98 | #define clvalue(o) check_exp(ttisfunction(o), &(o)->value.gc->cl) 99 | #define hvalue(o) check_exp(ttistable(o), &(o)->value.gc->h) 100 | #define bvalue(o) check_exp(ttisboolean(o), (o)->value.b) 101 | #define thvalue(o) check_exp(ttisthread(o), &(o)->value.gc->th) 102 | 103 | #define l_isfalse(o) (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0)) 104 | 105 | /* 106 | ** for internal debug only 107 | */ 108 | #define checkconsistency(obj) \ 109 | lua_assert(!iscollectable(obj) || (ttype(obj) == (obj)->value.gc->gch.tt)) 110 | 111 | #define checkliveness(g,obj) \ 112 | lua_assert(!iscollectable(obj) || \ 113 | ((ttype(obj) == (obj)->value.gc->gch.tt) && !isdead(g, (obj)->value.gc))) 114 | 115 | 116 | /* Macros to set values */ 117 | #define setnilvalue(obj) ((obj)->tt=LUA_TNIL) 118 | 119 | #define setnvalue(obj,x) \ 120 | { TValue *i_o=(obj); i_o->value.n=(x); i_o->tt=LUA_TNUMBER; } 121 | 122 | #define setpvalue(obj,x) \ 123 | { TValue *i_o=(obj); i_o->value.p=(x); i_o->tt=LUA_TLIGHTUSERDATA; } 124 | 125 | #define setbvalue(obj,x) \ 126 | { TValue *i_o=(obj); i_o->value.b=(x); i_o->tt=LUA_TBOOLEAN; } 127 | 128 | #define setsvalue(L,obj,x) \ 129 | { TValue *i_o=(obj); \ 130 | i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TSTRING; \ 131 | checkliveness(G(L),i_o); } 132 | 133 | #define setuvalue(L,obj,x) \ 134 | { TValue *i_o=(obj); \ 135 | i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TUSERDATA; \ 136 | checkliveness(G(L),i_o); } 137 | 138 | #define setthvalue(L,obj,x) \ 139 | { TValue *i_o=(obj); \ 140 | i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTHREAD; \ 141 | checkliveness(G(L),i_o); } 142 | 143 | #define setclvalue(L,obj,x) \ 144 | { TValue *i_o=(obj); \ 145 | i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TFUNCTION; \ 146 | checkliveness(G(L),i_o); } 147 | 148 | #define sethvalue(L,obj,x) \ 149 | { TValue *i_o=(obj); \ 150 | i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTABLE; \ 151 | checkliveness(G(L),i_o); } 152 | 153 | #define setptvalue(L,obj,x) \ 154 | { TValue *i_o=(obj); \ 155 | i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TPROTO; \ 156 | checkliveness(G(L),i_o); } 157 | 158 | 159 | 160 | 161 | #define setobj(L,obj1,obj2) \ 162 | { const TValue *o2=(obj2); TValue *o1=(obj1); \ 163 | o1->value = o2->value; o1->tt=o2->tt; \ 164 | checkliveness(G(L),o1); } 165 | 166 | 167 | /* 168 | ** different types of sets, according to destination 169 | */ 170 | 171 | /* from stack to (same) stack */ 172 | #define setobjs2s setobj 173 | /* to stack (not from same stack) */ 174 | #define setobj2s setobj 175 | #define setsvalue2s setsvalue 176 | #define sethvalue2s sethvalue 177 | #define setptvalue2s setptvalue 178 | /* from table to same table */ 179 | #define setobjt2t setobj 180 | /* to table */ 181 | #define setobj2t setobj 182 | /* to new object */ 183 | #define setobj2n setobj 184 | #define setsvalue2n setsvalue 185 | 186 | #define setttype(obj, tt) (ttype(obj) = (tt)) 187 | 188 | // 只有这些类型的数据 才是可回收的数据 189 | #define iscollectable(o) (ttype(o) >= LUA_TSTRING) 190 | 191 | 192 | 193 | typedef TValue *StkId; /* index to stack elements */ 194 | 195 | 196 | /* 197 | ** String headers for string table 198 | */ 199 | typedef union TString { 200 | L_Umaxalign dummy; /* ensures maximum alignment for strings */ 201 | struct { 202 | CommonHeader; 203 | lu_byte reserved; 204 | unsigned int hash; 205 | size_t len; 206 | } tsv; 207 | } TString; 208 | 209 | 210 | #define getstr(ts) cast(const char *, (ts) + 1) 211 | #define svalue(o) getstr(rawtsvalue(o)) 212 | 213 | 214 | // 这里为什么需要使用union类型？ 215 | typedef union Udata { 216 | L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */ 217 | struct { 218 | CommonHeader; 219 | struct Table *metatable; 220 | struct Table *env; 221 | size_t len; 222 | } uv; 223 | } Udata; 224 | 225 | 226 | 227 | 228 | /* 229 | ** Function Prototypes 230 | */ 231 | // 存放函数原型的数据结构 232 | typedef struct Proto { 233 | CommonHeader; 234 | TValue *k; /* constants used by the function */ 235 | // 存放函数体的opcode 236 | Instruction *code; 237 | // 在这个函数中定义的函数 238 | struct Proto **p; /* functions defined inside the function */ 239 | int *lineinfo; /* map from opcodes to source lines */ 240 | // 存放局部变量的数组 241 | struct LocVar *locvars; /* information about local variables */ 242 | TString **upvalues; /* upvalue names */ 243 | TString *source; 244 | int sizeupvalues; 245 | int sizek; /* size of `k' */ 246 | int sizecode; 247 | int sizelineinfo; 248 | int sizep; /* size of `p' */ 249 | int sizelocvars; 250 | int linedefined; 251 | int lastlinedefined; 252 | GCObject *gclist; 253 | lu_byte nups; /* number of upvalues */ 254 | lu_byte numparams; 255 | lu_byte is_vararg; 256 | lu_byte maxstacksize; 257 | } Proto; 258 | 259 | 260 | /* masks for new-style vararg */ 261 | #define VARARG_HASARG 1 262 | #define VARARG_ISVARARG 2 263 | #define VARARG_NEEDSARG 4 264 | 265 | // 存放局部变量的结构体 266 | typedef struct LocVar { 267 | TString *varname; 268 | int startpc; /* first point where variable is active */ 269 | int endpc; /* first point where variable is dead */ 270 | } LocVar; 271 | 272 | 273 | 274 | /* 275 | ** Upvalues 276 | */ 277 | 278 | typedef struct UpVal { 279 | CommonHeader; 280 | TValue *v; /* points to stack or to its own value */ 281 | union { 282 | // 当这个upval被close时,保存upval的值,后面可能还会被引用到 283 | TValue value; /* the value (when closed) */ 284 | // 当这个upval还在open状态时,以下链表串连在openupval链表中 285 | struct { /* double linked list (when open) */ 286 | struct UpVal *prev; 287 | struct UpVal *next; 288 | } l; 289 | } u; 290 | } UpVal; 291 | 292 | 293 | /* 294 | ** Closures 295 | */ 296 | 297 | #define ClosureHeader \ 298 | CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \ 299 | struct Table *env 300 | 301 | typedef struct CClosure { 302 | ClosureHeader; 303 | lua_CFunction f; 304 | TValue upvalue[1]; 305 | } CClosure; 306 | 307 | 308 | typedef struct LClosure { 309 | ClosureHeader; 310 | struct Proto *p; 311 | UpVal *upvals[1]; 312 | } LClosure; 313 | 314 | 315 | typedef union Closure { 316 | CClosure c; 317 | LClosure l; 318 | } Closure; 319 | 320 | 321 | #define iscfunction(o) (ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC) 322 | #define isLfunction(o) (ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC) 323 | 324 | 325 | /* 326 | ** Tables 327 | */ 328 | 329 | typedef union TKey { 330 | struct { 331 | TValuefields; 332 | struct Node *next; /* for chaining */ 333 | } nk; 334 | TValue tvk; 335 | } TKey; 336 | 337 | // 每个节点都有key和val 338 | typedef struct Node { 339 | TValue i_val; 340 | TKey i_key; 341 | } Node; 342 | 343 | 344 | typedef struct Table { 345 | CommonHeader; 346 | lu_byte flags; /* 1<

lsizenode)) 370 | 371 | 372 | #define luaO_nilobject (&luaO_nilobject_) 373 | 374 | LUAI_DATA const TValue luaO_nilobject_; 375 | 376 | #define ceillog2(x) (luaO_log2((x)-1) + 1) 377 | 378 | LUAI_FUNC int luaO_log2 (unsigned int x); 379 | LUAI_FUNC int luaO_int2fb (unsigned int x); 380 | LUAI_FUNC int luaO_fb2int (int x); 381 | LUAI_FUNC int luaO_rawequalObj (const TValue *t1, const TValue *t2); 382 | LUAI_FUNC int luaO_str2d (const char *s, lua_Number *result); 383 | LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt, 384 | va_list argp); 385 | LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...); 386 | LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len); 387 | 388 | 389 | #endif 390 | 391 | -------------------------------------------------------------------------------- /src/lopcodes.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lopcodes.c,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** See Copyright Notice in lua.h 4 | */ 5 | 6 | 7 | #define lopcodes_c 8 | #define LUA_CORE 9 | 10 | 11 | #include "lopcodes.h" 12 | 13 | 14 | /* ORDER OP */ 15 | 16 | const char *const luaP_opnames[NUM_OPCODES+1] = { 17 | "MOVE", 18 | "LOADK", 19 | "LOADBOOL", 20 | "LOADNIL", 21 | "GETUPVAL", 22 | "GETGLOBAL", 23 | "GETTABLE", 24 | "SETGLOBAL", 25 | "SETUPVAL", 26 | "SETTABLE", 27 | "NEWTABLE", 28 | "SELF", 29 | "ADD", 30 | "SUB", 31 | "MUL", 32 | "DIV", 33 | "MOD", 34 | "POW", 35 | "UNM", 36 | "NOT", 37 | "LEN", 38 | "CONCAT", 39 | "JMP", 40 | "EQ", 41 | "LT", 42 | "LE", 43 | "TEST", 44 | "TESTSET", 45 | "CALL", 46 | "TAILCALL", 47 | "RETURN", 48 | "FORLOOP", 49 | "FORPREP", 50 | "TFORLOOP", 51 | "SETLIST", 52 | "CLOSE", 53 | "CLOSURE", 54 | "VARARG", 55 | NULL 56 | }; 57 | 58 | 59 | #define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m)) 60 | 61 | // Tmode为1表示是逻辑测试类语句 62 | const lu_byte luaP_opmodes[NUM_OPCODES] = { 63 | /* T A B C mode opcode */ 64 | opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_MOVE */ 65 | ,opmode(0, 1, OpArgK, OpArgN, iABx) /* OP_LOADK */ 66 | ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_LOADBOOL */ 67 | ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_LOADNIL */ 68 | ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_GETUPVAL */ 69 | ,opmode(0, 1, OpArgK, OpArgN, iABx) /* OP_GETGLOBAL */ 70 | ,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_GETTABLE */ 71 | ,opmode(0, 0, OpArgK, OpArgN, iABx) /* OP_SETGLOBAL */ 72 | ,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_SETUPVAL */ 73 | ,opmode(0, 0, OpArgK, OpArgK, iABC) /* OP_SETTABLE */ 74 | ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_NEWTABLE */ 75 | ,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_SELF */ 76 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_ADD */ 77 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_SUB */ 78 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MUL */ 79 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_DIV */ 80 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MOD */ 81 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_POW */ 82 | ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_UNM */ 83 | ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_NOT */ 84 | ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_LEN */ 85 | ,opmode(0, 1, OpArgR, OpArgR, iABC) /* OP_CONCAT */ 86 | ,opmode(0, 0, OpArgR, OpArgN, iAsBx) /* OP_JMP */ 87 | ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_EQ */ 88 | ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LT */ 89 | ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LE */ 90 | ,opmode(1, 1, OpArgR, OpArgU, iABC) /* OP_TEST */ 91 | ,opmode(1, 1, OpArgR, OpArgU, iABC) /* OP_TESTSET */ 92 | ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_CALL */ 93 | ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_TAILCALL */ 94 | ,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_RETURN */ 95 | ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORLOOP */ 96 | ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORPREP */ 97 | ,opmode(1, 0, OpArgN, OpArgU, iABC) /* OP_TFORLOOP */ 98 | ,opmode(0, 0, OpArgU, OpArgU, iABC) /* OP_SETLIST */ 99 | ,opmode(0, 0, OpArgN, OpArgN, iABC) /* OP_CLOSE */ 100 | ,opmode(0, 1, OpArgU, OpArgN, iABx) /* OP_CLOSURE */ 101 | ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_VARARG */ 102 | }; 103 | 104 | -------------------------------------------------------------------------------- /src/lopcodes.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lopcodes.h,v 1.125.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Opcodes for Lua virtual machine 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lopcodes_h 8 | #define lopcodes_h 9 | 10 | #include "llimits.h" 11 | 12 | 13 | /*=========================================================================== 14 | We assume that instructions are unsigned numbers. 15 | All instructions have an opcode in the first 6 bits. 16 | Instructions can have the following fields: 17 | `A' : 8 bits 18 | `B' : 9 bits 19 | `C' : 9 bits 20 | `Bx' : 18 bits (`B' and `C' together) 21 | `sBx' : signed Bx 22 | 23 | A signed argument is represented in excess K; that is, the number 24 | value is the unsigned value minus K. K is exactly the maximum value 25 | for that argument (so that -max is represented by 0, and +max is 26 | represented by 2*max), which is half the maximum for the corresponding 27 | unsigned argument. 28 | ===========================================================================*/ 29 | 30 | 31 | enum OpMode {iABC, iABx, iAsBx}; /* basic instruction format */ 32 | 33 | 34 | /* 35 | ** size and position of opcode arguments. 36 | */ 37 | #define SIZE_C 9 38 | #define SIZE_B 9 39 | #define SIZE_Bx (SIZE_C + SIZE_B) 40 | #define SIZE_A 8 41 | 42 | #define SIZE_OP 6 43 | 44 | #define POS_OP 0 45 | #define POS_A (POS_OP + SIZE_OP) 46 | #define POS_C (POS_A + SIZE_A) 47 | #define POS_B (POS_C + SIZE_C) 48 | #define POS_Bx POS_C 49 | 50 | 51 | /* 52 | ** limits for opcode arguments. 53 | ** we use (signed) int to manipulate most arguments, 54 | ** so they must fit in LUAI_BITSINT-1 bits (-1 for sign) 55 | */ 56 | #if SIZE_Bx < LUAI_BITSINT-1 57 | #define MAXARG_Bx ((1<>1) /* `sBx' is signed */ 59 | #else 60 | #define MAXARG_Bx MAX_INT 61 | #define MAXARG_sBx MAX_INT 62 | #endif 63 | 64 | 65 | #define MAXARG_A ((1<>POS_OP) & MASK1(SIZE_OP,0))) 81 | #define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ 82 | ((cast(Instruction, o)<>POS_A) & MASK1(SIZE_A,0))) 85 | #define SETARG_A(i,u) ((i) = (((i)&MASK0(SIZE_A,POS_A)) | \ 86 | ((cast(Instruction, u)<>POS_B) & MASK1(SIZE_B,0))) 89 | #define SETARG_B(i,b) ((i) = (((i)&MASK0(SIZE_B,POS_B)) | \ 90 | ((cast(Instruction, b)<>POS_C) & MASK1(SIZE_C,0))) 93 | #define SETARG_C(i,b) ((i) = (((i)&MASK0(SIZE_C,POS_C)) | \ 94 | ((cast(Instruction, b)<>POS_Bx) & MASK1(SIZE_Bx,0))) 97 | #define SETARG_Bx(i,b) ((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \ 98 | ((cast(Instruction, b)< C) then pc++ */ 190 | OP_TESTSET,/* A B C if (R(B) <=> C) then R(A) := R(B) else pc++ */ 191 | 192 | OP_CALL,/* A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */ 193 | OP_TAILCALL,/* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */ 194 | OP_RETURN,/* A B return R(A), ... ,R(A+B-2) (see note) */ 195 | 196 | OP_FORLOOP,/* A sBx R(A)+=R(A+2); 197 | if R(A) =) R(A)*/ 205 | OP_CLOSURE,/* A Bx R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n)) */ 206 | 207 | OP_VARARG/* A B R(A), R(A+1), ..., R(A+B-1) = vararg */ 208 | } OpCode; 209 | 210 | 211 | #define NUM_OPCODES (cast(int, OP_VARARG) + 1) 212 | 213 | 214 | 215 | /*=========================================================================== 216 | Notes: 217 | (*) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1, 218 | and can be 0: OP_CALL then sets `top' to last_result+1, so 219 | next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'. 220 | 221 | (*) In OP_VARARG, if (B == 0) then use actual number of varargs and 222 | set top (like in OP_CALL with C == 0). 223 | 224 | (*) In OP_RETURN, if (B == 0) then return up to `top' 225 | 226 | (*) In OP_SETLIST, if (B == 0) then B = `top'; 227 | if (C == 0) then next `instruction' is real C 228 | 229 | (*) For comparisons, A specifies what condition the test should accept 230 | (true or false). 231 | 232 | (*) All `skips' (pc++) assume that next instruction is a jump 233 | ===========================================================================*/ 234 | 235 | 236 | /* 237 | ** masks for instruction properties. The format is: 238 | ** bits 0-1: op mode 239 | ** bits 2-3: C arg mode 240 | ** bits 4-5: B arg mode 241 | ** bit 6: instruction set register A 242 | ** bit 7: operator is a test 243 | */ 244 | 245 | enum OpArgMask { 246 | OpArgN, /* argument is not used */ 247 | OpArgU, /* argument is used */ 248 | OpArgR, /* argument is a register or a jump offset */ 249 | OpArgK /* argument is a constant or register/constant */ 250 | }; 251 | 252 | LUAI_DATA const lu_byte luaP_opmodes[NUM_OPCODES]; 253 | 254 | #define getOpMode(m) (cast(enum OpMode, luaP_opmodes[m] & 3)) 255 | #define getBMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3)) 256 | #define getCMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3)) 257 | #define testAMode(m) (luaP_opmodes[m] & (1 << 6)) 258 | #define testTMode(m) (luaP_opmodes[m] & (1 << 7)) 259 | 260 | 261 | LUAI_DATA const char *const luaP_opnames[NUM_OPCODES+1]; /* opcode names */ 262 | 263 | 264 | /* number of list items to accumulate before a SETLIST instruction */ 265 | #define LFIELDS_PER_FLUSH 50 266 | 267 | 268 | #endif 269 | -------------------------------------------------------------------------------- /src/loslib.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: loslib.c,v 1.19.1.3 2008/01/18 16:38:18 roberto Exp $ 3 | ** Standard Operating System library 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #define loslib_c 15 | #define LUA_LIB 16 | 17 | #include "lua.h" 18 | 19 | #include "lauxlib.h" 20 | #include "lualib.h" 21 | 22 | 23 | static int os_pushresult (lua_State *L, int i, const char *filename) { 24 | int en = errno; /* calls to Lua API may change this value */ 25 | if (i) { 26 | lua_pushboolean(L, 1); 27 | return 1; 28 | } 29 | else { 30 | lua_pushnil(L); 31 | lua_pushfstring(L, "%s: %s", filename, strerror(en)); 32 | lua_pushinteger(L, en); 33 | return 3; 34 | } 35 | } 36 | 37 | 38 | static int os_execute (lua_State *L) { 39 | lua_pushinteger(L, system(luaL_optstring(L, 1, NULL))); 40 | return 1; 41 | } 42 | 43 | 44 | static int os_remove (lua_State *L) { 45 | const char *filename = luaL_checkstring(L, 1); 46 | return os_pushresult(L, remove(filename) == 0, filename); 47 | } 48 | 49 | 50 | static int os_rename (lua_State *L) { 51 | const char *fromname = luaL_checkstring(L, 1); 52 | const char *toname = luaL_checkstring(L, 2); 53 | return os_pushresult(L, rename(fromname, toname) == 0, fromname); 54 | } 55 | 56 | 57 | static int os_tmpname (lua_State *L) { 58 | char buff[LUA_TMPNAMBUFSIZE]; 59 | int err; 60 | lua_tmpnam(buff, err); 61 | if (err) 62 | return luaL_error(L, "unable to generate a unique filename"); 63 | lua_pushstring(L, buff); 64 | return 1; 65 | } 66 | 67 | 68 | static int os_getenv (lua_State *L) { 69 | lua_pushstring(L, getenv(luaL_checkstring(L, 1))); /* if NULL push nil */ 70 | return 1; 71 | } 72 | 73 | 74 | static int os_clock (lua_State *L) { 75 | lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC); 76 | return 1; 77 | } 78 | 79 | 80 | /* 81 | ** {====================================================== 82 | ** Time/Date operations 83 | ** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S, 84 | ** wday=%w+1, yday=%j, isdst=? } 85 | ** ======================================================= 86 | */ 87 | 88 | static void setfield (lua_State *L, const char *key, int value) { 89 | lua_pushinteger(L, value); 90 | lua_setfield(L, -2, key); 91 | } 92 | 93 | static void setboolfield (lua_State *L, const char *key, int value) { 94 | if (value < 0) /* undefined? */ 95 | return; /* does not set field */ 96 | lua_pushboolean(L, value); 97 | lua_setfield(L, -2, key); 98 | } 99 | 100 | static int getboolfield (lua_State *L, const char *key) { 101 | int res; 102 | lua_getfield(L, -1, key); 103 | res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1); 104 | lua_pop(L, 1); 105 | return res; 106 | } 107 | 108 | 109 | static int getfield (lua_State *L, const char *key, int d) { 110 | int res; 111 | lua_getfield(L, -1, key); 112 | if (lua_isnumber(L, -1)) 113 | res = (int)lua_tointeger(L, -1); 114 | else { 115 | if (d < 0) 116 | return luaL_error(L, "field " LUA_QS " missing in date table", key); 117 | res = d; 118 | } 119 | lua_pop(L, 1); 120 | return res; 121 | } 122 | 123 | 124 | static int os_date (lua_State *L) { 125 | const char *s = luaL_optstring(L, 1, "%c"); 126 | time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL)); 127 | struct tm *stm; 128 | if (*s == '!') { /* UTC? */ 129 | stm = gmtime(&t); 130 | s++; /* skip `!' */ 131 | } 132 | else 133 | stm = localtime(&t); 134 | if (stm == NULL) /* invalid date? */ 135 | lua_pushnil(L); 136 | else if (strcmp(s, "*t") == 0) { 137 | lua_createtable(L, 0, 9); /* 9 = number of fields */ 138 | setfield(L, "sec", stm->tm_sec); 139 | setfield(L, "min", stm->tm_min); 140 | setfield(L, "hour", stm->tm_hour); 141 | setfield(L, "day", stm->tm_mday); 142 | setfield(L, "month", stm->tm_mon+1); 143 | setfield(L, "year", stm->tm_year+1900); 144 | setfield(L, "wday", stm->tm_wday+1); 145 | setfield(L, "yday", stm->tm_yday+1); 146 | setboolfield(L, "isdst", stm->tm_isdst); 147 | } 148 | else { 149 | char cc[3]; 150 | luaL_Buffer b; 151 | cc[0] = '%'; cc[2] = '\0'; 152 | luaL_buffinit(L, &b); 153 | for (; *s; s++) { 154 | if (*s != '%' || *(s + 1) == '\0') /* no conversion specifier? */ 155 | luaL_addchar(&b, *s); 156 | else { 157 | size_t reslen; 158 | char buff[200]; /* should be big enough for any conversion result */ 159 | cc[1] = *(++s); 160 | reslen = strftime(buff, sizeof(buff), cc, stm); 161 | luaL_addlstring(&b, buff, reslen); 162 | } 163 | } 164 | luaL_pushresult(&b); 165 | } 166 | return 1; 167 | } 168 | 169 | 170 | static int os_time (lua_State *L) { 171 | time_t t; 172 | if (lua_isnoneornil(L, 1)) /* called without args? */ 173 | t = time(NULL); /* get current time */ 174 | else { 175 | struct tm ts; 176 | luaL_checktype(L, 1, LUA_TTABLE); 177 | lua_settop(L, 1); /* make sure table is at the top */ 178 | ts.tm_sec = getfield(L, "sec", 0); 179 | ts.tm_min = getfield(L, "min", 0); 180 | ts.tm_hour = getfield(L, "hour", 12); 181 | ts.tm_mday = getfield(L, "day", -1); 182 | ts.tm_mon = getfield(L, "month", -1) - 1; 183 | ts.tm_year = getfield(L, "year", -1) - 1900; 184 | ts.tm_isdst = getboolfield(L, "isdst"); 185 | t = mktime(&ts); 186 | } 187 | if (t == (time_t)(-1)) 188 | lua_pushnil(L); 189 | else 190 | lua_pushnumber(L, (lua_Number)t); 191 | return 1; 192 | } 193 | 194 | 195 | static int os_difftime (lua_State *L) { 196 | lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)), 197 | (time_t)(luaL_optnumber(L, 2, 0)))); 198 | return 1; 199 | } 200 | 201 | /* }====================================================== */ 202 | 203 | 204 | static int os_setlocale (lua_State *L) { 205 | static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, 206 | LC_NUMERIC, LC_TIME}; 207 | static const char *const catnames[] = {"all", "collate", "ctype", "monetary", 208 | "numeric", "time", NULL}; 209 | const char *l = luaL_optstring(L, 1, NULL); 210 | int op = luaL_checkoption(L, 2, "all", catnames); 211 | lua_pushstring(L, setlocale(cat[op], l)); 212 | return 1; 213 | } 214 | 215 | 216 | static int os_exit (lua_State *L) { 217 | exit(luaL_optint(L, 1, EXIT_SUCCESS)); 218 | } 219 | 220 | static const luaL_Reg syslib[] = { 221 | {"clock", os_clock}, 222 | {"date", os_date}, 223 | {"difftime", os_difftime}, 224 | {"execute", os_execute}, 225 | {"exit", os_exit}, 226 | {"getenv", os_getenv}, 227 | {"remove", os_remove}, 228 | {"rename", os_rename}, 229 | {"setlocale", os_setlocale}, 230 | {"time", os_time}, 231 | {"tmpname", os_tmpname}, 232 | {NULL, NULL} 233 | }; 234 | 235 | /* }====================================================== */ 236 | 237 | 238 | 239 | LUALIB_API int luaopen_os (lua_State *L) { 240 | luaL_register(L, LUA_OSLIBNAME, syslib); 241 | return 1; 242 | } 243 | 244 | -------------------------------------------------------------------------------- /src/lparser.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lparser.h,v 1.57.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Lua Parser 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lparser_h 8 | #define lparser_h 9 | 10 | #include "llimits.h" 11 | #include "lobject.h" 12 | #include "lzio.h" 13 | 14 | 15 | /* 16 | ** Expression descriptor 17 | */ 18 | 19 | typedef enum { 20 | VVOID, /* no value */ 21 | VNIL, 22 | VTRUE, 23 | VFALSE, 24 | VK, /* info = index of constant in `k' */ 25 | VKNUM, /* nval = numerical value */ 26 | VLOCAL, /* info = local register */ 27 | VUPVAL, /* info = index of upvalue in `upvalues' */ 28 | VGLOBAL, /* info = index of table; aux = index of global name in `k' */ 29 | VINDEXED, /* info = table register; aux = index register (or `k') */ 30 | VJMP, /* info = instruction pc */ 31 | VRELOCABLE, /* info = instruction pc */ 32 | VNONRELOC, /* info = result register */ 33 | VCALL, /* info = instruction pc */ 34 | VVARARG /* info = instruction pc */ 35 | } expkind; 36 | 37 | // 存放表达式的数据结构 38 | typedef struct expdesc { 39 | // 表达式类型 40 | expkind k; 41 | // 保存表达式信息的联合体 42 | union { 43 | struct { // info 和aux里面存储的数据信息，根据不同的表达式类型有区分，见前面expkind的注释 44 | int info, 45 | aux; } s; 46 | lua_Number nval; // 类型为数字的时候存储具体的数据 47 | } u; 48 | int t; /* patch list of `exit when true' */ 49 | int f; /* patch list of `exit when false' */ 50 | } expdesc; 51 | 52 | 53 | typedef struct upvaldesc { 54 | lu_byte k; 55 | lu_byte info; 56 | } upvaldesc; 57 | 58 | 59 | struct BlockCnt; /* defined in lparser.c */ 60 | 61 | 62 | /* state needed to generate code for a given function */ 63 | typedef struct FuncState { 64 | Proto *f; /* current function header */ 65 | Table *h; /* table to find (and reuse) elements in `k' */ 66 | struct FuncState *prev; /* enclosing function */ 67 | struct LexState *ls; /* lexical state */ 68 | struct lua_State *L; /* copy of the Lua state */ 69 | struct BlockCnt *bl; /* chain of current blocks */ 70 | int pc; /* next position to code (equivalent to `ncode') */ 71 | int lasttarget; /* `pc' of last `jump target' */ 72 | // 这里存放的是所有空悬,也就是没有确定好跳转位置的pc链表 73 | int jpc; /* list of pending jumps to `pc' */ 74 | int freereg; /* first free register */ 75 | int nk; /* number of elements in `k' */ 76 | int np; /* number of elements in `p' */ 77 | short nlocvars; /* number of elements in `locvars' */ 78 | lu_byte nactvar; /* number of active local variables */ 79 | upvaldesc upvalues[LUAI_MAXUPVALUES]; /* upvalues */ 80 | unsigned short actvar[LUAI_MAXVARS]; /* declared-variable stack */ 81 | } FuncState; 82 | 83 | 84 | LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, 85 | const char *name); 86 | 87 | 88 | #endif 89 | -------------------------------------------------------------------------------- /src/lstate.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lstate.c,v 2.36.1.2 2008/01/03 15:20:39 roberto Exp $ 3 | ** Global State 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #include 9 | 10 | #define lstate_c 11 | #define LUA_CORE 12 | 13 | #include "lua.h" 14 | 15 | #include "ldebug.h" 16 | #include "ldo.h" 17 | #include "lfunc.h" 18 | #include "lgc.h" 19 | #include "llex.h" 20 | #include "lmem.h" 21 | #include "lstate.h" 22 | #include "lstring.h" 23 | #include "ltable.h" 24 | #include "ltm.h" 25 | 26 | 27 | #define state_size(x) (sizeof(x) + LUAI_EXTRASPACE) 28 | #define fromstate(l) (cast(lu_byte *, (l)) - LUAI_EXTRASPACE) 29 | #define tostate(l) (cast(lua_State *, cast(lu_byte *, l) + LUAI_EXTRASPACE)) 30 | 31 | 32 | /* 33 | ** Main thread combines a thread state and the global state 34 | */ 35 | typedef struct LG { 36 | lua_State l; 37 | global_State g; 38 | } LG; 39 | 40 | 41 | 42 | static void stack_init (lua_State *L1, lua_State *L) { 43 | /* initialize CallInfo array */ 44 | // 创建CallInfo数组 45 | L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo); 46 | L1->ci = L1->base_ci; 47 | L1->size_ci = BASIC_CI_SIZE; 48 | L1->end_ci = L1->base_ci + L1->size_ci - 1; 49 | /* initialize stack array */ 50 | // 创建TValue数组 51 | L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue); 52 | L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK; 53 | L1->top = L1->stack; 54 | L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1; 55 | /* initialize first ci */ 56 | // 没看懂这个下面几句什么意思 57 | L1->ci->func = L1->top; 58 | // 这里的作用是把当前top所在区域的值set成nil,然后top++ 59 | // 在top++之前,从上一句代码可以看出,top指向的位置是L1->ci->func,也就是把L1->ci->func set为nil 60 | setnilvalue(L1->top++); /* `function' entry for this `ci' */ 61 | // 执行这句调用之后, base = top = stack + 1, 但是base是存放什么值的呢?? 62 | L1->base = L1->ci->base = L1->top; 63 | // 这里的意思是,每个lua函数最开始预留LUA_MINSTACK个栈位置,不够的时候再增加,见luaD_checkstack函数 64 | L1->ci->top = L1->top + LUA_MINSTACK; 65 | } 66 | 67 | 68 | static void freestack (lua_State *L, lua_State *L1) { 69 | luaM_freearray(L, L1->base_ci, L1->size_ci, CallInfo); 70 | luaM_freearray(L, L1->stack, L1->stacksize, TValue); 71 | } 72 | 73 | 74 | /* 75 | ** open parts that may cause memory-allocation errors 76 | */ 77 | static void f_luaopen (lua_State *L, void *ud) { 78 | global_State *g = G(L); 79 | UNUSED(ud); 80 | // 初始化堆栈 81 | stack_init(L, L); /* init stack */ 82 | // 初始化全局表 83 | sethvalue(L, gt(L), luaH_new(L, 0, 2)); /* table of globals */ 84 | // 初始化寄存器 85 | sethvalue(L, registry(L), luaH_new(L, 0, 2)); /* registry */ 86 | luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */ 87 | luaT_init(L); 88 | luaX_init(L); 89 | // 初始化not enough memory这个字符串并且标记为不可回收 90 | luaS_fix(luaS_newliteral(L, MEMERRMSG)); 91 | g->GCthreshold = 4*g->totalbytes; 92 | } 93 | 94 | 95 | static void preinit_state (lua_State *L, global_State *g) { 96 | G(L) = g; 97 | L->stack = NULL; 98 | L->stacksize = 0; 99 | L->errorJmp = NULL; 100 | L->hook = NULL; 101 | L->hookmask = 0; 102 | L->basehookcount = 0; 103 | L->allowhook = 1; 104 | resethookcount(L); 105 | L->openupval = NULL; 106 | L->size_ci = 0; 107 | L->nCcalls = L->baseCcalls = 0; 108 | L->status = 0; 109 | L->base_ci = L->ci = NULL; 110 | L->savedpc = NULL; 111 | L->errfunc = 0; 112 | setnilvalue(gt(L)); 113 | } 114 | 115 | 116 | static void close_state (lua_State *L) { 117 | global_State *g = G(L); 118 | luaF_close(L, L->stack); /* close all upvalues for this thread */ 119 | luaC_freeall(L); /* collect all objects */ 120 | lua_assert(g->rootgc == obj2gco(L)); 121 | lua_assert(g->strt.nuse == 0); 122 | luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *); 123 | luaZ_freebuffer(L, &g->buff); 124 | freestack(L, L); 125 | lua_assert(g->totalbytes == sizeof(LG)); 126 | (*g->frealloc)(g->ud, fromstate(L), state_size(LG), 0); 127 | } 128 | 129 | 130 | lua_State *luaE_newthread (lua_State *L) { 131 | lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State))); 132 | luaC_link(L, obj2gco(L1), LUA_TTHREAD); 133 | preinit_state(L1, G(L)); 134 | stack_init(L1, L); /* init stack */ 135 | setobj2n(L, gt(L1), gt(L)); /* share table of globals */ 136 | L1->hookmask = L->hookmask; 137 | L1->basehookcount = L->basehookcount; 138 | L1->hook = L->hook; 139 | resethookcount(L1); 140 | lua_assert(iswhite(obj2gco(L1))); 141 | return L1; 142 | } 143 | 144 | 145 | void luaE_freethread (lua_State *L, lua_State *L1) { 146 | luaF_close(L1, L1->stack); /* close all upvalues for this thread */ 147 | lua_assert(L1->openupval == NULL); 148 | luai_userstatefree(L1); 149 | freestack(L, L1); 150 | luaM_freemem(L, fromstate(L1), state_size(lua_State)); 151 | } 152 | 153 | 154 | LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) { 155 | int i; 156 | lua_State *L; 157 | global_State *g; 158 | void *l = (*f)(ud, NULL, 0, state_size(LG)); 159 | if (l == NULL) return NULL; 160 | L = tostate(l); 161 | g = &((LG *)L)->g; 162 | L->next = NULL; 163 | L->tt = LUA_TTHREAD; 164 | g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT); 165 | L->marked = luaC_white(g); 166 | set2bits(L->marked, FIXEDBIT, SFIXEDBIT); 167 | preinit_state(L, g); 168 | g->frealloc = f; 169 | g->ud = ud; 170 | g->mainthread = L; 171 | g->uvhead.u.l.prev = &g->uvhead; 172 | g->uvhead.u.l.next = &g->uvhead; 173 | g->GCthreshold = 0; /* mark it as unfinished state */ 174 | g->strt.size = 0; 175 | g->strt.nuse = 0; 176 | g->strt.hash = NULL; 177 | setnilvalue(registry(L)); 178 | luaZ_initbuffer(L, &g->buff); 179 | g->panic = NULL; 180 | g->gcstate = GCSpause; 181 | g->rootgc = obj2gco(L); 182 | g->sweepstrgc = 0; 183 | g->sweepgc = &g->rootgc; 184 | g->gray = NULL; 185 | g->grayagain = NULL; 186 | g->weak = NULL; 187 | g->tmudata = NULL; 188 | g->totalbytes = sizeof(LG); 189 | g->gcpause = LUAI_GCPAUSE; 190 | g->gcstepmul = LUAI_GCMUL; 191 | g->gcdept = 0; 192 | for (i=0; imt[i] = NULL; 193 | if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) { 194 | /* memory allocation error: free partial state */ 195 | close_state(L); 196 | L = NULL; 197 | } 198 | else 199 | luai_userstateopen(L); 200 | return L; 201 | } 202 | 203 | 204 | static void callallgcTM (lua_State *L, void *ud) { 205 | UNUSED(ud); 206 | luaC_callGCTM(L); /* call GC metamethods for all udata */ 207 | } 208 | 209 | 210 | LUA_API void lua_close (lua_State *L) { 211 | L = G(L)->mainthread; /* only the main thread can be closed */ 212 | lua_lock(L); 213 | luaF_close(L, L->stack); /* close all upvalues for this thread */ 214 | luaC_separateudata(L, 1); /* separate udata that have GC metamethods */ 215 | L->errfunc = 0; /* no error function during GC metamethods */ 216 | do { /* repeat until no more errors */ 217 | L->ci = L->base_ci; 218 | L->base = L->top = L->ci->base; 219 | L->nCcalls = L->baseCcalls = 0; 220 | } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0); 221 | lua_assert(G(L)->tmudata == NULL); 222 | luai_userstateclose(L); 223 | close_state(L); 224 | } 225 | 226 | -------------------------------------------------------------------------------- /src/lstate.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lstate.h,v 2.24.1.2 2008/01/03 15:20:39 roberto Exp $ 3 | ** Global State 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lstate_h 8 | #define lstate_h 9 | 10 | #include "lua.h" 11 | 12 | #include "lobject.h" 13 | #include "ltm.h" 14 | #include "lzio.h" 15 | 16 | 17 | 18 | struct lua_longjmp; /* defined in ldo.c */ 19 | 20 | 21 | /* table of globals */ 22 | #define gt(L) (&L->l_gt) 23 | 24 | /* registry */ 25 | #define registry(L) (&G(L)->l_registry) 26 | 27 | 28 | /* extra stack space to handle TM calls and some other extras */ 29 | #define EXTRA_STACK 5 30 | 31 | 32 | #define BASIC_CI_SIZE 8 33 | 34 | #define BASIC_STACK_SIZE (2*LUA_MINSTACK) 35 | 36 | 37 | 38 | typedef struct stringtable { 39 | GCObject **hash; 40 | lu_int32 nuse; /* number of elements */ 41 | int size; // hash桶数组大小 42 | } stringtable; 43 | 44 | 45 | /* 46 | ** informations about a call 47 | */ 48 | typedef struct CallInfo { 49 | StkId base; /* base for this function */ 50 | StkId func; /* function index in the stack */ 51 | StkId top; /* top for this function */ 52 | const Instruction *savedpc; 53 | int nresults; /* expected number of results from this function */ 54 | int tailcalls; /* number of tail calls lost under this entry */ 55 | } CallInfo; 56 | 57 | 58 | 59 | #define curr_func(L) (clvalue(L->ci->func)) 60 | #define ci_func(ci) (clvalue((ci)->func)) 61 | #define f_isLua(ci) (!ci_func(ci)->c.isC) 62 | #define isLua(ci) (ttisfunction((ci)->func) && f_isLua(ci)) 63 | 64 | 65 | /* 66 | ** `global state', shared by all threads of this state 67 | */ 68 | typedef struct global_State { 69 | stringtable strt; /* hash table for strings */ 70 | lua_Alloc frealloc; /* function to reallocate memory */ 71 | void *ud; /* auxiliary data to `frealloc' */ 72 | lu_byte currentwhite; 73 | lu_byte gcstate; /* state of garbage collector */ 74 | int sweepstrgc; /* position of sweep in `strt' */ 75 | GCObject *rootgc; /* list of all collectable objects */ 76 | GCObject **sweepgc; /* position of sweep in `rootgc' */ 77 | GCObject *gray; /* list of gray objects */ 78 | GCObject *grayagain; /* list of objects to be traversed atomically */ 79 | GCObject *weak; /* list of weak tables (to be cleared) */ 80 | // 所有有GC方法的udata都放在tmudata链表中 81 | GCObject *tmudata; /* last element of list of userdata to be GC */ 82 | Mbuffer buff; /* temporary buffer for string concatentation */ 83 | // 一个阈值，当这个totalbytes大于这个阈值时进行自动GC 84 | lu_mem GCthreshold; 85 | // 保存当前分配的总内存数量 86 | lu_mem totalbytes; /* number of bytes currently allocated */ 87 | // 一个估算值，根据这个计算GCthreshold 88 | lu_mem estimate; /* an estimate of number of bytes actually in use */ 89 | // 当前待GC的数据大小，其实就是累加totalbytes和GCthreshold的差值 90 | lu_mem gcdept; /* how much GC is `behind schedule' */ 91 | // 可以配置的一个值，不是计算出来的，根据这个计算GCthreshold，以此来控制下一次GC触发的时间 92 | int gcpause; /* size of pause between successive GCs */ 93 | // 每次进行GC操作回收的数据比例，见lgc.c/luaC_step函数 94 | int gcstepmul; /* GC `granularity' */ 95 | lua_CFunction panic; /* to be called in unprotected errors */ 96 | TValue l_registry; 97 | struct lua_State *mainthread; 98 | UpVal uvhead; /* head of double-linked list of all open upvalues */ 99 | struct Table *mt[NUM_TAGS]; /* metatables for basic types */ 100 | TString *tmname[TM_N]; /* array with tag-method names */ 101 | } global_State; 102 | 103 | 104 | /* 105 | ** `per thread' state 106 | */ 107 | struct lua_State { 108 | CommonHeader; 109 | lu_byte status; 110 | StkId top; /* first free slot in the stack */ 111 | StkId base; /* base of current function */ 112 | global_State *l_G; 113 | CallInfo *ci; /* call info for current function */ 114 | const Instruction *savedpc; /* `savedpc' of current function */ 115 | StkId stack_last; /* last free slot in the stack */ 116 | StkId stack; /* stack base */ 117 | CallInfo *end_ci; /* points after end of ci array*/ 118 | CallInfo *base_ci; /* array of CallInfo's */ 119 | int stacksize; 120 | int size_ci; /* size of array `base_ci' */ 121 | unsigned short nCcalls; /* number of nested C calls */ 122 | unsigned short baseCcalls; /* nested C calls when resuming coroutine */ 123 | lu_byte hookmask; 124 | lu_byte allowhook; 125 | int basehookcount; 126 | int hookcount; 127 | lua_Hook hook; 128 | TValue l_gt; /* table of globals */ 129 | TValue env; /* temporary place for environments */ 130 | GCObject *openupval; /* list of open upvalues in this stack */ 131 | GCObject *gclist; 132 | struct lua_longjmp *errorJmp; /* current error recover point */ 133 | ptrdiff_t errfunc; /* current error handling function (stack index) */ 134 | }; 135 | 136 | 137 | #define G(L) (L->l_G) 138 | 139 | 140 | /* 141 | ** Union of all collectable objects 142 | */ 143 | union GCObject { 144 | GCheader gch; 145 | union TString ts; 146 | union Udata u; 147 | union Closure cl; 148 | struct Table h; 149 | struct Proto p; 150 | struct UpVal uv; 151 | struct lua_State th; /* thread */ 152 | }; 153 | 154 | 155 | /* macros to convert a GCObject into a specific value */ 156 | #define rawgco2ts(o) check_exp((o)->gch.tt == LUA_TSTRING, &((o)->ts)) 157 | #define gco2ts(o) (&rawgco2ts(o)->tsv) 158 | #define rawgco2u(o) check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u)) 159 | #define gco2u(o) (&rawgco2u(o)->uv) 160 | #define gco2cl(o) check_exp((o)->gch.tt == LUA_TFUNCTION, &((o)->cl)) 161 | #define gco2h(o) check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h)) 162 | #define gco2p(o) check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p)) 163 | #define gco2uv(o) check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv)) 164 | #define ngcotouv(o) \ 165 | check_exp((o) == NULL || (o)->gch.tt == LUA_TUPVAL, &((o)->uv)) 166 | #define gco2th(o) check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th)) 167 | 168 | /* macro to convert any Lua object into a GCObject */ 169 | #define obj2gco(v) (cast(GCObject *, (v))) 170 | 171 | 172 | LUAI_FUNC lua_State *luaE_newthread (lua_State *L); 173 | LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1); 174 | 175 | #endif 176 | -------------------------------------------------------------------------------- /src/lstring.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lstring.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** String table (keeps all strings handled by Lua) 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #include 9 | 10 | #define lstring_c 11 | #define LUA_CORE 12 | 13 | #include "lua.h" 14 | 15 | #include "lmem.h" 16 | #include "lobject.h" 17 | #include "lstate.h" 18 | #include "lstring.h" 19 | 20 | 21 | // 对保存string的hash桶进行resize 22 | void luaS_resize (lua_State *L, int newsize) { 23 | GCObject **newhash; 24 | stringtable *tb; 25 | int i; 26 | if (G(L)->gcstate == GCSsweepstring) 27 | return; /* cannot resize during GC traverse */ 28 | newhash = luaM_newvector(L, newsize, GCObject *); 29 | tb = &G(L)->strt; 30 | for (i=0; isize; i++) { 33 | GCObject *p = tb->hash[i]; 34 | while (p) { /* for each node in the list */ 35 | GCObject *next = p->gch.next; /* save next */ 36 | unsigned int h = gco2ts(p)->hash; 37 | // 重新计算hash桶索引，这次需要mod新的hash桶大小 38 | int h1 = lmod(h, newsize); /* new position */ 39 | lua_assert(cast_int(h%newsize) == lmod(h, newsize)); 40 | p->gch.next = newhash[h1]; /* chain it */ 41 | newhash[h1] = p; 42 | p = next; 43 | } 44 | } 45 | luaM_freearray(L, tb->hash, tb->size, TString *); 46 | tb->size = newsize; 47 | tb->hash = newhash; 48 | } 49 | 50 | 51 | static TString *newlstr (lua_State *L, const char *str, size_t l, 52 | unsigned int h) { 53 | TString *ts; 54 | stringtable *tb; 55 | if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char)) 56 | luaM_toobig(L); 57 | ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString))); 58 | ts->tsv.len = l; 59 | ts->tsv.hash = h; 60 | ts->tsv.marked = luaC_white(G(L)); 61 | ts->tsv.tt = LUA_TSTRING; 62 | ts->tsv.reserved = 0; 63 | memcpy(ts+1, str, l*sizeof(char)); 64 | ((char *)(ts+1))[l] = '\0'; /* ending 0 */ 65 | tb = &G(L)->strt; 66 | h = lmod(h, tb->size); 67 | ts->tsv.next = tb->hash[h]; /* chain new entry */ 68 | tb->hash[h] = obj2gco(ts); 69 | tb->nuse++; 70 | // 在hash桶数组大小小于MAX_INT/2的情况下， 71 | // 只要字符串数量大于桶数组数量就开始成倍的扩充桶的容量 72 | if (tb->nuse > cast(lu_int32, tb->size) && tb->size <= MAX_INT/2) 73 | luaS_resize(L, tb->size*2); /* too crowded */ 74 | return ts; 75 | } 76 | 77 | 78 | TString *luaS_newlstr (lua_State *L, const char *str, size_t l) { 79 | GCObject *o; 80 | unsigned int h = cast(unsigned int, l); /* seed */ 81 | size_t step = (l>>5)+1; /* if string is too long, don't hash all its chars */ 82 | size_t l1; 83 | for (l1=l; l1>=step; l1-=step) /* compute hash */ 84 | h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1])); 85 | for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)]; 86 | o != NULL; 87 | o = o->gch.next) { 88 | TString *ts = rawgco2ts(o); 89 | if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) { 90 | /* string may be dead */ 91 | if (isdead(G(L), o)) changewhite(o); 92 | return ts; 93 | } 94 | } 95 | return newlstr(L, str, l, h); /* not found */ 96 | } 97 | 98 | 99 | Udata *luaS_newudata (lua_State *L, size_t s, Table *e) { 100 | Udata *u; 101 | if (s > MAX_SIZET - sizeof(Udata)) 102 | luaM_toobig(L); 103 | u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata))); 104 | u->uv.marked = luaC_white(G(L)); /* is not finalized */ 105 | u->uv.tt = LUA_TUSERDATA; 106 | u->uv.len = s; 107 | u->uv.metatable = NULL; 108 | u->uv.env = e; 109 | /* chain it on udata list (after main thread) */ 110 | // 这样让udata链接在mainthread之后，一定是整个GC链表的最后 111 | u->uv.next = G(L)->mainthread->next; 112 | G(L)->mainthread->next = obj2gco(u); 113 | return u; 114 | } 115 | 116 | -------------------------------------------------------------------------------- /src/lstring.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lstring.h,v 1.43.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** String table (keep all strings handled by Lua) 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lstring_h 8 | #define lstring_h 9 | 10 | 11 | #include "lgc.h" 12 | #include "lobject.h" 13 | #include "lstate.h" 14 | 15 | 16 | #define sizestring(s) (sizeof(union TString)+((s)->len+1)*sizeof(char)) 17 | 18 | #define sizeudata(u) (sizeof(union Udata)+(u)->len) 19 | 20 | #define luaS_new(L, s) (luaS_newlstr(L, s, strlen(s))) 21 | #define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ 22 | (sizeof(s)/sizeof(char))-1)) 23 | 24 | // 标记这个GC对象不可回收 25 | #define luaS_fix(s) l_setbit((s)->tsv.marked, FIXEDBIT) 26 | 27 | LUAI_FUNC void luaS_resize (lua_State *L, int newsize); 28 | LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e); 29 | LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l); 30 | 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /src/ltable.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: ltable.h,v 2.10.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Lua tables (hash) 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef ltable_h 8 | #define ltable_h 9 | 10 | #include "lobject.h" 11 | 12 | 13 | #define gnode(t,i) (&(t)->node[i]) 14 | #define gkey(n) (&(n)->i_key.nk) 15 | #define gval(n) (&(n)->i_val) 16 | #define gnext(n) ((n)->i_key.nk.next) 17 | 18 | #define key2tval(n) (&(n)->i_key.tvk) 19 | 20 | 21 | LUAI_FUNC const TValue *luaH_getnum (Table *t, int key); 22 | LUAI_FUNC TValue *luaH_setnum (lua_State *L, Table *t, int key); 23 | LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key); 24 | LUAI_FUNC TValue *luaH_setstr (lua_State *L, Table *t, TString *key); 25 | LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key); 26 | LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key); 27 | LUAI_FUNC Table *luaH_new (lua_State *L, int narray, int lnhash); 28 | LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize); 29 | LUAI_FUNC void luaH_free (lua_State *L, Table *t); 30 | LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key); 31 | LUAI_FUNC int luaH_getn (Table *t); 32 | 33 | 34 | #if defined(LUA_DEBUG) 35 | LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key); 36 | LUAI_FUNC int luaH_isdummy (Node *n); 37 | #endif 38 | 39 | 40 | #endif 41 | -------------------------------------------------------------------------------- /src/ltablib.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: ltablib.c,v 1.38.1.3 2008/02/14 16:46:58 roberto Exp $ 3 | ** Library for Table Manipulation 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #include 9 | 10 | #define ltablib_c 11 | #define LUA_LIB 12 | 13 | #include "lua.h" 14 | 15 | #include "lauxlib.h" 16 | #include "lualib.h" 17 | 18 | 19 | #define aux_getn(L,n) (luaL_checktype(L, n, LUA_TTABLE), luaL_getn(L, n)) 20 | 21 | 22 | static int foreachi (lua_State *L) { 23 | int i; 24 | int n = aux_getn(L, 1); 25 | luaL_checktype(L, 2, LUA_TFUNCTION); 26 | for (i=1; i <= n; i++) { 27 | lua_pushvalue(L, 2); /* function */ 28 | lua_pushinteger(L, i); /* 1st argument */ 29 | lua_rawgeti(L, 1, i); /* 2nd argument */ 30 | lua_call(L, 2, 1); 31 | if (!lua_isnil(L, -1)) 32 | return 1; 33 | lua_pop(L, 1); /* remove nil result */ 34 | } 35 | return 0; 36 | } 37 | 38 | 39 | static int foreach (lua_State *L) { 40 | luaL_checktype(L, 1, LUA_TTABLE); 41 | luaL_checktype(L, 2, LUA_TFUNCTION); 42 | lua_pushnil(L); /* first key */ 43 | while (lua_next(L, 1)) { 44 | lua_pushvalue(L, 2); /* function */ 45 | lua_pushvalue(L, -3); /* key */ 46 | lua_pushvalue(L, -3); /* value */ 47 | lua_call(L, 2, 1); 48 | if (!lua_isnil(L, -1)) 49 | return 1; 50 | lua_pop(L, 2); /* remove value and result */ 51 | } 52 | return 0; 53 | } 54 | 55 | 56 | static int maxn (lua_State *L) { 57 | lua_Number max = 0; 58 | luaL_checktype(L, 1, LUA_TTABLE); 59 | lua_pushnil(L); /* first key */ 60 | while (lua_next(L, 1)) { 61 | lua_pop(L, 1); /* remove value */ 62 | if (lua_type(L, -1) == LUA_TNUMBER) { 63 | lua_Number v = lua_tonumber(L, -1); 64 | if (v > max) max = v; 65 | } 66 | } 67 | lua_pushnumber(L, max); 68 | return 1; 69 | } 70 | 71 | 72 | static int getn (lua_State *L) { 73 | lua_pushinteger(L, aux_getn(L, 1)); 74 | return 1; 75 | } 76 | 77 | 78 | static int setn (lua_State *L) { 79 | luaL_checktype(L, 1, LUA_TTABLE); 80 | #ifndef luaL_setn 81 | luaL_setn(L, 1, luaL_checkint(L, 2)); 82 | #else 83 | luaL_error(L, LUA_QL("setn") " is obsolete"); 84 | #endif 85 | lua_pushvalue(L, 1); 86 | return 1; 87 | } 88 | 89 | 90 | static int tinsert (lua_State *L) { 91 | int e = aux_getn(L, 1) + 1; /* first empty element */ 92 | int pos; /* where to insert new element */ 93 | switch (lua_gettop(L)) { 94 | case 2: { /* called with only 2 arguments */ 95 | pos = e; /* insert new element at the end */ 96 | break; 97 | } 98 | case 3: { 99 | int i; 100 | pos = luaL_checkint(L, 2); /* 2nd argument is the position */ 101 | if (pos > e) e = pos; /* `grow' array if necessary */ 102 | for (i = e; i > pos; i--) { /* move up elements */ 103 | lua_rawgeti(L, 1, i-1); 104 | lua_rawseti(L, 1, i); /* t[i] = t[i-1] */ 105 | } 106 | break; 107 | } 108 | default: { 109 | return luaL_error(L, "wrong number of arguments to " LUA_QL("insert")); 110 | } 111 | } 112 | luaL_setn(L, 1, e); /* new size */ 113 | lua_rawseti(L, 1, pos); /* t[pos] = v */ 114 | return 0; 115 | } 116 | 117 | 118 | static int tremove (lua_State *L) { 119 | int e = aux_getn(L, 1); 120 | int pos = luaL_optint(L, 2, e); 121 | if (!(1 <= pos && pos <= e)) /* position is outside bounds? */ 122 | return 0; /* nothing to remove */ 123 | luaL_setn(L, 1, e - 1); /* t.n = n-1 */ 124 | lua_rawgeti(L, 1, pos); /* result = t[pos] */ 125 | for ( ;pos= P */ 226 | while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) { 227 | if (i>u) luaL_error(L, "invalid order function for sorting"); 228 | lua_pop(L, 1); /* remove a[i] */ 229 | } 230 | /* repeat --j until a[j] <= P */ 231 | while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) { 232 | if (j 9 | 10 | #define ltm_c 11 | #define LUA_CORE 12 | 13 | #include "lua.h" 14 | 15 | #include "lobject.h" 16 | #include "lstate.h" 17 | #include "lstring.h" 18 | #include "ltable.h" 19 | #include "ltm.h" 20 | 21 | 22 | 23 | const char *const luaT_typenames[] = { 24 | "nil", "boolean", "userdata", "number", 25 | "string", "table", "function", "userdata", "thread", 26 | "proto", "upval" 27 | }; 28 | 29 | 30 | void luaT_init (lua_State *L) { 31 | static const char *const luaT_eventname[] = { /* ORDER TM */ 32 | "__index", "__newindex", 33 | "__gc", "__mode", "__eq", 34 | "__add", "__sub", "__mul", "__div", "__mod", 35 | "__pow", "__unm", "__len", "__lt", "__le", 36 | "__concat", "__call" 37 | }; 38 | int i; 39 | // 初始化meta method 40 | for (i=0; itmname[i] = luaS_new(L, luaT_eventname[i]); 42 | luaS_fix(G(L)->tmname[i]); /* never collect these names */ 43 | } 44 | } 45 | 46 | 47 | /* 48 | ** function to be used with macro "fasttm": optimized for absence of 49 | ** tag methods 50 | */ 51 | const TValue *luaT_gettm (Table *events, TMS event, TString *ename) { 52 | const TValue *tm = luaH_getstr(events, ename); 53 | // 这里这个条件是什么原因?? 54 | lua_assert(event <= TM_EQ); 55 | if (ttisnil(tm)) { /* no tag method? */ 56 | // 如果没有这个meta method，那么标记上，避免下一次再次进入这个函数 57 | events->flags |= cast_byte(1u<metatable; 69 | break; 70 | case LUA_TUSERDATA: 71 | mt = uvalue(o)->metatable; 72 | break; 73 | default: 74 | mt = G(L)->mt[ttype(o)]; 75 | } 76 | return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject); 77 | } 78 | 79 | -------------------------------------------------------------------------------- /src/ltm.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: ltm.h,v 2.6.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Tag methods 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef ltm_h 8 | #define ltm_h 9 | 10 | 11 | #include "lobject.h" 12 | 13 | 14 | /* 15 | * WARNING: if you change the order of this enumeration, 16 | * grep "ORDER TM" 17 | */ 18 | typedef enum { 19 | TM_INDEX, 20 | TM_NEWINDEX, 21 | TM_GC, 22 | TM_MODE, 23 | TM_EQ, /* last tag method with `fast' access */ 24 | TM_ADD, 25 | TM_SUB, 26 | TM_MUL, 27 | TM_DIV, 28 | TM_MOD, 29 | TM_POW, 30 | TM_UNM, 31 | TM_LEN, 32 | TM_LT, 33 | TM_LE, 34 | TM_CONCAT, 35 | TM_CALL, 36 | TM_N /* number of elements in the enum */ 37 | } TMS; 38 | 39 | 40 | 41 | #define gfasttm(g,et,e) ((et) == NULL ? NULL : \ 42 | ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) 43 | 44 | #define fasttm(l,et,e) gfasttm(G(l), et, e) 45 | 46 | LUAI_DATA const char *const luaT_typenames[]; 47 | 48 | 49 | LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename); 50 | LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, 51 | TMS event); 52 | LUAI_FUNC void luaT_init (lua_State *L); 53 | 54 | #endif 55 | -------------------------------------------------------------------------------- /src/luac.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: luac.c,v 1.54 2006/06/02 17:37:11 lhf Exp $ 3 | ** Lua compiler (saves bytecodes to files; also list bytecodes) 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #define luac_c 13 | #define LUA_CORE 14 | 15 | #include "lua.h" 16 | #include "lauxlib.h" 17 | 18 | #include "ldo.h" 19 | #include "lfunc.h" 20 | #include "lmem.h" 21 | #include "lobject.h" 22 | #include "lopcodes.h" 23 | #include "lstring.h" 24 | #include "lundump.h" 25 | 26 | #define PROGNAME "luac" /* default program name */ 27 | #define OUTPUT PROGNAME ".out" /* default output file */ 28 | 29 | static int listing=0; /* list bytecodes? */ 30 | static int dumping=1; /* dump bytecodes? */ 31 | static int stripping=0; /* strip debug information? */ 32 | static char Output[]={ OUTPUT }; /* default output file name */ 33 | static const char* output=Output; /* actual output file name */ 34 | static const char* progname=PROGNAME; /* actual program name */ 35 | 36 | static void fatal(const char* message) 37 | { 38 | fprintf(stderr,"%s: %s\n",progname,message); 39 | exit(EXIT_FAILURE); 40 | } 41 | 42 | static void cannot(const char* what) 43 | { 44 | fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno)); 45 | exit(EXIT_FAILURE); 46 | } 47 | 48 | static void usage(const char* message) 49 | { 50 | if (*message=='-') 51 | fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message); 52 | else 53 | fprintf(stderr,"%s: %s\n",progname,message); 54 | fprintf(stderr, 55 | "usage: %s [options] [filenames].\n" 56 | "Available options are:\n" 57 | " - process stdin\n" 58 | " -l list\n" 59 | " -o name output to file " LUA_QL("name") " (default is \"%s\")\n" 60 | " -p parse only\n" 61 | " -s strip debug information\n" 62 | " -v show version information\n" 63 | " -- stop handling options\n", 64 | progname,Output); 65 | exit(EXIT_FAILURE); 66 | } 67 | 68 | #define IS(s) (strcmp(argv[i],s)==0) 69 | 70 | static int doargs(int argc, char* argv[]) 71 | { 72 | int i; 73 | int version=0; 74 | if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0]; 75 | for (i=1; itop+(i))->l.p) 118 | 119 | static const Proto* combine(lua_State* L, int n) 120 | { 121 | if (n==1) 122 | return toproto(L,-1); 123 | else 124 | { 125 | int i,pc; 126 | Proto* f=luaF_newproto(L); 127 | setptvalue2s(L,L->top,f); incr_top(L); 128 | f->source=luaS_newliteral(L,"=(" PROGNAME ")"); 129 | f->maxstacksize=1; 130 | pc=2*n+1; 131 | f->code=luaM_newvector(L,pc,Instruction); 132 | f->sizecode=pc; 133 | f->p=luaM_newvector(L,n,Proto*); 134 | f->sizep=n; 135 | pc=0; 136 | for (i=0; ip[i]=toproto(L,i-n-1); 139 | f->code[pc++]=CREATE_ABx(OP_CLOSURE,0,i); 140 | f->code[pc++]=CREATE_ABC(OP_CALL,0,1,1); 141 | } 142 | f->code[pc++]=CREATE_ABC(OP_RETURN,0,1,0); 143 | return f; 144 | } 145 | } 146 | 147 | static int writer(lua_State* L, const void* p, size_t size, void* u) 148 | { 149 | UNUSED(L); 150 | return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0); 151 | } 152 | 153 | struct Smain { 154 | int argc; 155 | char** argv; 156 | }; 157 | 158 | static int pmain(lua_State* L) 159 | { 160 | struct Smain* s = (struct Smain*)lua_touserdata(L, 1); 161 | int argc=s->argc; 162 | char** argv=s->argv; 163 | const Proto* f; 164 | int i; 165 | if (!lua_checkstack(L,argc)) fatal("too many input files"); 166 | for (i=0; i1); 173 | if (dumping) 174 | { 175 | FILE* D= (output==NULL) ? stdout : fopen(output,"wb"); 176 | if (D==NULL) cannot("open"); 177 | lua_lock(L); 178 | luaU_dump(L,f,writer,D,stripping); 179 | lua_unlock(L); 180 | if (ferror(D)) cannot("write"); 181 | if (fclose(D)) cannot("close"); 182 | } 183 | return 0; 184 | } 185 | 186 | int main(int argc, char* argv[]) 187 | { 188 | lua_State* L; 189 | struct Smain s; 190 | int i=doargs(argc,argv); 191 | argc-=i; argv+=i; 192 | if (argc<=0) usage("no input files given"); 193 | L=lua_open(); 194 | if (L==NULL) fatal("not enough memory for state"); 195 | s.argc=argc; 196 | s.argv=argv; 197 | if (lua_cpcall(L,pmain,&s)!=0) fatal(lua_tostring(L,-1)); 198 | lua_close(L); 199 | return EXIT_SUCCESS; 200 | } 201 | -------------------------------------------------------------------------------- /src/lualib.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lualib.h,v 1.36.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Lua standard libraries 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #ifndef lualib_h 9 | #define lualib_h 10 | 11 | #include "lua.h" 12 | 13 | 14 | /* Key to file-handle type */ 15 | #define LUA_FILEHANDLE "FILE*" 16 | 17 | 18 | #define LUA_COLIBNAME "coroutine" 19 | LUALIB_API int (luaopen_base) (lua_State *L); 20 | 21 | #define LUA_TABLIBNAME "table" 22 | LUALIB_API int (luaopen_table) (lua_State *L); 23 | 24 | #define LUA_IOLIBNAME "io" 25 | LUALIB_API int (luaopen_io) (lua_State *L); 26 | 27 | #define LUA_OSLIBNAME "os" 28 | LUALIB_API int (luaopen_os) (lua_State *L); 29 | 30 | #define LUA_STRLIBNAME "string" 31 | LUALIB_API int (luaopen_string) (lua_State *L); 32 | 33 | #define LUA_MATHLIBNAME "math" 34 | LUALIB_API int (luaopen_math) (lua_State *L); 35 | 36 | #define LUA_DBLIBNAME "debug" 37 | LUALIB_API int (luaopen_debug) (lua_State *L); 38 | 39 | #define LUA_LOADLIBNAME "package" 40 | LUALIB_API int (luaopen_package) (lua_State *L); 41 | 42 | 43 | /* open all previous libraries */ 44 | LUALIB_API void (luaL_openlibs) (lua_State *L); 45 | 46 | 47 | 48 | #ifndef lua_assert 49 | #define lua_assert(x) ((void)0) 50 | #endif 51 | 52 | 53 | #endif 54 | -------------------------------------------------------------------------------- /src/lundump.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lundump.c,v 2.7.1.4 2008/04/04 19:51:41 roberto Exp $ 3 | ** load precompiled Lua chunks 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #include 8 | 9 | #define lundump_c 10 | #define LUA_CORE 11 | 12 | #include "lua.h" 13 | 14 | #include "ldebug.h" 15 | #include "ldo.h" 16 | #include "lfunc.h" 17 | #include "lmem.h" 18 | #include "lobject.h" 19 | #include "lstring.h" 20 | #include "lundump.h" 21 | #include "lzio.h" 22 | 23 | typedef struct { 24 | lua_State* L; 25 | ZIO* Z; 26 | Mbuffer* b; 27 | const char* name; 28 | } LoadState; 29 | 30 | #ifdef LUAC_TRUST_BINARIES 31 | #define IF(c,s) 32 | #define error(S,s) 33 | #else 34 | #define IF(c,s) if (c) error(S,s) 35 | 36 | static void error(LoadState* S, const char* why) 37 | { 38 | luaO_pushfstring(S->L,"%s: %s in precompiled chunk",S->name,why); 39 | luaD_throw(S->L,LUA_ERRSYNTAX); 40 | } 41 | #endif 42 | 43 | #define LoadMem(S,b,n,size) LoadBlock(S,b,(n)*(size)) 44 | #define LoadByte(S) (lu_byte)LoadChar(S) 45 | #define LoadVar(S,x) LoadMem(S,&x,1,sizeof(x)) 46 | #define LoadVector(S,b,n,size) LoadMem(S,b,n,size) 47 | 48 | static void LoadBlock(LoadState* S, void* b, size_t size) 49 | { 50 | size_t r=luaZ_read(S->Z,b,size); 51 | IF (r!=0, "unexpected end"); 52 | } 53 | 54 | static int LoadChar(LoadState* S) 55 | { 56 | char x; 57 | LoadVar(S,x); 58 | return x; 59 | } 60 | 61 | static int LoadInt(LoadState* S) 62 | { 63 | int x; 64 | LoadVar(S,x); 65 | IF (x<0, "bad integer"); 66 | return x; 67 | } 68 | 69 | static lua_Number LoadNumber(LoadState* S) 70 | { 71 | lua_Number x; 72 | LoadVar(S,x); 73 | return x; 74 | } 75 | 76 | static TString* LoadString(LoadState* S) 77 | { 78 | size_t size; 79 | LoadVar(S,size); 80 | if (size==0) 81 | return NULL; 82 | else 83 | { 84 | char* s=luaZ_openspace(S->L,S->b,size); 85 | LoadBlock(S,s,size); 86 | return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */ 87 | } 88 | } 89 | 90 | static void LoadCode(LoadState* S, Proto* f) 91 | { 92 | int n=LoadInt(S); 93 | f->code=luaM_newvector(S->L,n,Instruction); 94 | f->sizecode=n; 95 | LoadVector(S,f->code,n,sizeof(Instruction)); 96 | } 97 | 98 | static Proto* LoadFunction(LoadState* S, TString* p); 99 | 100 | static void LoadConstants(LoadState* S, Proto* f) 101 | { 102 | int i,n; 103 | n=LoadInt(S); 104 | f->k=luaM_newvector(S->L,n,TValue); 105 | f->sizek=n; 106 | for (i=0; ik[i]); 107 | for (i=0; ik[i]; 110 | int t=LoadChar(S); 111 | switch (t) 112 | { 113 | case LUA_TNIL: 114 | setnilvalue(o); 115 | break; 116 | case LUA_TBOOLEAN: 117 | setbvalue(o,LoadChar(S)!=0); 118 | break; 119 | case LUA_TNUMBER: 120 | setnvalue(o,LoadNumber(S)); 121 | break; 122 | case LUA_TSTRING: 123 | setsvalue2n(S->L,o,LoadString(S)); 124 | break; 125 | default: 126 | error(S,"bad constant"); 127 | break; 128 | } 129 | } 130 | n=LoadInt(S); 131 | f->p=luaM_newvector(S->L,n,Proto*); 132 | f->sizep=n; 133 | for (i=0; ip[i]=NULL; 134 | for (i=0; ip[i]=LoadFunction(S,f->source); 135 | } 136 | 137 | static void LoadDebug(LoadState* S, Proto* f) 138 | { 139 | int i,n; 140 | n=LoadInt(S); 141 | f->lineinfo=luaM_newvector(S->L,n,int); 142 | f->sizelineinfo=n; 143 | LoadVector(S,f->lineinfo,n,sizeof(int)); 144 | n=LoadInt(S); 145 | f->locvars=luaM_newvector(S->L,n,LocVar); 146 | f->sizelocvars=n; 147 | for (i=0; ilocvars[i].varname=NULL; 148 | for (i=0; ilocvars[i].varname=LoadString(S); 151 | f->locvars[i].startpc=LoadInt(S); 152 | f->locvars[i].endpc=LoadInt(S); 153 | } 154 | n=LoadInt(S); 155 | f->upvalues=luaM_newvector(S->L,n,TString*); 156 | f->sizeupvalues=n; 157 | for (i=0; iupvalues[i]=NULL; 158 | for (i=0; iupvalues[i]=LoadString(S); 159 | } 160 | 161 | static Proto* LoadFunction(LoadState* S, TString* p) 162 | { 163 | Proto* f; 164 | if (++S->L->nCcalls > LUAI_MAXCCALLS) error(S,"code too deep"); 165 | f=luaF_newproto(S->L); 166 | setptvalue2s(S->L,S->L->top,f); incr_top(S->L); 167 | f->source=LoadString(S); if (f->source==NULL) f->source=p; 168 | f->linedefined=LoadInt(S); 169 | f->lastlinedefined=LoadInt(S); 170 | f->nups=LoadByte(S); 171 | f->numparams=LoadByte(S); 172 | f->is_vararg=LoadByte(S); 173 | f->maxstacksize=LoadByte(S); 174 | LoadCode(S,f); 175 | LoadConstants(S,f); 176 | LoadDebug(S,f); 177 | IF (!luaG_checkcode(f), "bad code"); 178 | S->L->top--; 179 | S->L->nCcalls--; 180 | return f; 181 | } 182 | 183 | static void LoadHeader(LoadState* S) 184 | { 185 | char h[LUAC_HEADERSIZE]; 186 | char s[LUAC_HEADERSIZE]; 187 | luaU_header(h); 188 | LoadBlock(S,s,LUAC_HEADERSIZE); 189 | IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header"); 190 | } 191 | 192 | /* 193 | ** load precompiled chunk 194 | */ 195 | Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name) 196 | { 197 | LoadState S; 198 | if (*name=='@' || *name=='=') 199 | S.name=name+1; 200 | else if (*name==LUA_SIGNATURE[0]) 201 | S.name="binary string"; 202 | else 203 | S.name=name; 204 | S.L=L; 205 | S.Z=Z; 206 | S.b=buff; 207 | LoadHeader(&S); 208 | return LoadFunction(&S,luaS_newliteral(L,"=?")); 209 | } 210 | 211 | /* 212 | * make header 213 | */ 214 | void luaU_header (char* h) 215 | { 216 | int x=1; 217 | memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-1); 218 | h+=sizeof(LUA_SIGNATURE)-1; 219 | *h++=(char)LUAC_VERSION; 220 | *h++=(char)LUAC_FORMAT; 221 | *h++=(char)*(char*)&x; /* endianness */ 222 | *h++=(char)sizeof(int); 223 | *h++=(char)sizeof(size_t); 224 | *h++=(char)sizeof(Instruction); 225 | *h++=(char)sizeof(lua_Number); 226 | *h++=(char)(((lua_Number)0.5)==0); /* is lua_Number integral? */ 227 | } 228 | -------------------------------------------------------------------------------- /src/lundump.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lundump.h,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** load precompiled Lua chunks 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lundump_h 8 | #define lundump_h 9 | 10 | #include "lobject.h" 11 | #include "lzio.h" 12 | 13 | /* load one chunk; from lundump.c */ 14 | LUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name); 15 | 16 | /* make header; from lundump.c */ 17 | LUAI_FUNC void luaU_header (char* h); 18 | 19 | /* dump one chunk; from ldump.c */ 20 | LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip); 21 | 22 | #ifdef luac_c 23 | /* print one chunk; from print.c */ 24 | LUAI_FUNC void luaU_print (const Proto* f, int full); 25 | #endif 26 | 27 | /* for header of binary files -- this is Lua 5.1 */ 28 | #define LUAC_VERSION 0x51 29 | 30 | /* for header of binary files -- this is the official format */ 31 | #define LUAC_FORMAT 0 32 | 33 | /* size of header of binary files */ 34 | #define LUAC_HEADERSIZE 12 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /src/lvm.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lvm.h,v 2.5.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Lua virtual machine 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lvm_h 8 | #define lvm_h 9 | 10 | 11 | #include "ldo.h" 12 | #include "lobject.h" 13 | #include "ltm.h" 14 | 15 | 16 | #define tostring(L,o) ((ttype(o) == LUA_TSTRING) || (luaV_tostring(L, o))) 17 | 18 | #define tonumber(o,n) (ttype(o) == LUA_TNUMBER || \ 19 | (((o) = luaV_tonumber(o,n)) != NULL)) 20 | 21 | #define equalobj(L,o1,o2) \ 22 | (ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2)) 23 | 24 | 25 | LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r); 26 | LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2); 27 | LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n); 28 | LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj); 29 | LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key, 30 | StkId val); 31 | LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key, 32 | StkId val); 33 | LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls); 34 | LUAI_FUNC void luaV_concat (lua_State *L, int total, int last); 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /src/lzio.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lzio.c,v 1.31.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** a generic input stream interface 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #include 9 | 10 | #define lzio_c 11 | #define LUA_CORE 12 | 13 | #include "lua.h" 14 | 15 | #include "llimits.h" 16 | #include "lmem.h" 17 | #include "lstate.h" 18 | #include "lzio.h" 19 | 20 | 21 | int luaZ_fill (ZIO *z) { 22 | size_t size; 23 | lua_State *L = z->L; 24 | const char *buff; 25 | lua_unlock(L); 26 | buff = z->reader(L, z->data, &size); 27 | lua_lock(L); 28 | if (buff == NULL || size == 0) return EOZ; 29 | z->n = size - 1; 30 | z->p = buff; 31 | return char2int(*(z->p++)); 32 | } 33 | 34 | // 向前预读一个数据 35 | int luaZ_lookahead (ZIO *z) { 36 | if (z->n == 0) { 37 | // 如果当前缓冲区没有元素可读,则继续从输入中读取数据 38 | if (luaZ_fill(z) == EOZ) 39 | // 如果没有数据可读了 40 | return EOZ; 41 | else { 42 | // 否则,读到了数据,则将指针和计数器加1 43 | z->n++; /* luaZ_fill removed first byte; put back it */ 44 | z->p--; 45 | } 46 | } 47 | // OK了,将它作为字符返回 48 | return char2int(*z->p); 49 | } 50 | 51 | 52 | void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) { 53 | z->L = L; 54 | z->reader = reader; 55 | z->data = data; 56 | z->n = 0; 57 | z->p = NULL; 58 | } 59 | 60 | 61 | /* --------------------------------------------------------------- read --- */ 62 | size_t luaZ_read (ZIO *z, void *b, size_t n) { 63 | while (n) { 64 | size_t m; 65 | if (luaZ_lookahead(z) == EOZ) 66 | return n; /* return number of missing bytes */ 67 | m = (n <= z->n) ? n : z->n; /* min. between n and z->n */ 68 | memcpy(b, z->p, m); 69 | z->n -= m; 70 | z->p += m; 71 | b = (char *)b + m; 72 | n -= m; 73 | } 74 | return 0; 75 | } 76 | 77 | /* ------------------------------------------------------------------------ */ 78 | char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) { 79 | if (n > buff->buffsize) { 80 | if (n < LUA_MINBUFFER) n = LUA_MINBUFFER; 81 | luaZ_resizebuffer(L, buff, n); 82 | } 83 | return buff->buffer; 84 | } 85 | 86 | 87 | -------------------------------------------------------------------------------- /src/lzio.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lzio.h,v 1.21.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Buffered streams 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #ifndef lzio_h 9 | #define lzio_h 10 | 11 | #include "lua.h" 12 | 13 | #include "lmem.h" 14 | 15 | 16 | #define EOZ (-1) /* end of stream */ 17 | 18 | typedef struct Zio ZIO; 19 | 20 | #define char2int(c) cast(int, cast(unsigned char, (c))) 21 | 22 | #define zgetc(z) (((z)->n--)>0 ? char2int(*(z)->p++) : luaZ_fill(z)) 23 | 24 | typedef struct Mbuffer { 25 | char *buffer; 26 | size_t n; 27 | size_t buffsize; 28 | } Mbuffer; 29 | 30 | #define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0) 31 | 32 | #define luaZ_buffer(buff) ((buff)->buffer) 33 | #define luaZ_sizebuffer(buff) ((buff)->buffsize) 34 | #define luaZ_bufflen(buff) ((buff)->n) 35 | 36 | #define luaZ_resetbuffer(buff) ((buff)->n = 0) 37 | 38 | 39 | #define luaZ_resizebuffer(L, buff, size) \ 40 | (luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \ 41 | (buff)->buffsize = size) 42 | 43 | #define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) 44 | 45 | 46 | LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n); 47 | LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, 48 | void *data); 49 | LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n); /* read next n bytes */ 50 | LUAI_FUNC int luaZ_lookahead (ZIO *z); 51 | 52 | 53 | 54 | /* --------- Private Part ------------------ */ 55 | 56 | struct Zio { 57 | size_t n; /* bytes still unread */ 58 | const char *p; /* current position in buffer */ 59 | lua_Reader reader; 60 | void* data; /* additional data */ 61 | lua_State *L; /* Lua state (for reader) */ 62 | }; 63 | 64 | 65 | LUAI_FUNC int luaZ_fill (ZIO *z); 66 | 67 | #endif 68 | -------------------------------------------------------------------------------- /src/print.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: print.c,v 1.55a 2006/05/31 13:30:05 lhf Exp $ 3 | ** print bytecodes 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #define luac_c 11 | #define LUA_CORE 12 | 13 | #include "ldebug.h" 14 | #include "lobject.h" 15 | #include "lopcodes.h" 16 | #include "lundump.h" 17 | 18 | #define PrintFunction luaU_print 19 | 20 | #define Sizeof(x) ((int)sizeof(x)) 21 | #define VOID(p) ((const void*)(p)) 22 | 23 | static void PrintString(const TString* ts) 24 | { 25 | const char* s=getstr(ts); 26 | size_t i,n=ts->tsv.len; 27 | putchar('"'); 28 | for (i=0; ik[i]; 54 | switch (ttype(o)) 55 | { 56 | case LUA_TNIL: 57 | printf("nil"); 58 | break; 59 | case LUA_TBOOLEAN: 60 | printf(bvalue(o) ? "true" : "false"); 61 | break; 62 | case LUA_TNUMBER: 63 | printf(LUA_NUMBER_FMT,nvalue(o)); 64 | break; 65 | case LUA_TSTRING: 66 | PrintString(rawtsvalue(o)); 67 | break; 68 | default: /* cannot happen */ 69 | printf("? type=%d",ttype(o)); 70 | break; 71 | } 72 | } 73 | 74 | static void PrintCode(const Proto* f) 75 | { 76 | const Instruction* code=f->code; 77 | int pc,n=f->sizecode; 78 | for (pc=0; pc0) printf("[%d]\t",line); else printf("[-]\t"); 90 | printf("%-9s\t",luaP_opnames[o]); 91 | switch (getOpMode(o)) 92 | { 93 | case iABC: 94 | printf("%d",a); 95 | if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (-1-INDEXK(b)) : b); 96 | if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (-1-INDEXK(c)) : c); 97 | break; 98 | case iABx: 99 | if (getBMode(o)==OpArgK) printf("%d %d",a,-1-bx); else printf("%d %d",a,bx); 100 | break; 101 | case iAsBx: 102 | if (o==OP_JMP) printf("%d",sbx); else printf("%d %d",a,sbx); 103 | break; 104 | } 105 | switch (o) 106 | { 107 | case OP_LOADK: 108 | printf("\t; "); PrintConstant(f,bx); 109 | break; 110 | case OP_GETUPVAL: 111 | case OP_SETUPVAL: 112 | printf("\t; %s", (f->sizeupvalues>0) ? getstr(f->upvalues[b]) : "-"); 113 | break; 114 | case OP_GETGLOBAL: 115 | case OP_SETGLOBAL: 116 | printf("\t; %s",svalue(&f->k[bx])); 117 | break; 118 | case OP_GETTABLE: 119 | case OP_SELF: 120 | if (ISK(c)) { printf("\t; "); PrintConstant(f,INDEXK(c)); } 121 | break; 122 | case OP_SETTABLE: 123 | case OP_ADD: 124 | case OP_SUB: 125 | case OP_MUL: 126 | case OP_DIV: 127 | case OP_POW: 128 | case OP_EQ: 129 | case OP_LT: 130 | case OP_LE: 131 | if (ISK(b) || ISK(c)) 132 | { 133 | printf("\t; "); 134 | if (ISK(b)) PrintConstant(f,INDEXK(b)); else printf("-"); 135 | printf(" "); 136 | if (ISK(c)) PrintConstant(f,INDEXK(c)); else printf("-"); 137 | } 138 | break; 139 | case OP_JMP: 140 | case OP_FORLOOP: 141 | case OP_FORPREP: 142 | printf("\t; to %d",sbx+pc+2); 143 | break; 144 | case OP_CLOSURE: 145 | printf("\t; %p",VOID(f->p[bx])); 146 | break; 147 | case OP_SETLIST: 148 | if (c==0) printf("\t; %d",(int)code[++pc]); 149 | else printf("\t; %d",c); 150 | break; 151 | default: 152 | break; 153 | } 154 | printf("\n"); 155 | } 156 | } 157 | 158 | #define SS(x) (x==1)?"":"s" 159 | #define S(x) x,SS(x) 160 | 161 | static void PrintHeader(const Proto* f) 162 | { 163 | const char* s=getstr(f->source); 164 | if (*s=='@' || *s=='=') 165 | s++; 166 | else if (*s==LUA_SIGNATURE[0]) 167 | s="(bstring)"; 168 | else 169 | s="(string)"; 170 | printf("\n%s <%s:%d,%d> (%d instruction%s, %d bytes at %p)\n", 171 | (f->linedefined==0)?"main":"function",s, 172 | f->linedefined,f->lastlinedefined, 173 | S(f->sizecode),f->sizecode*Sizeof(Instruction),VOID(f)); 174 | printf("%d%s param%s, %d slot%s, %d upvalue%s, ", 175 | f->numparams,f->is_vararg?"+":"",SS(f->numparams), 176 | S(f->maxstacksize),S(f->nups)); 177 | printf("%d local%s, %d constant%s, %d function%s\n", 178 | S(f->sizelocvars),S(f->sizek),S(f->sizep)); 179 | } 180 | 181 | static void PrintConstants(const Proto* f) 182 | { 183 | int i,n=f->sizek; 184 | printf("constants (%d) for %p:\n",n,VOID(f)); 185 | for (i=0; isizelocvars; 196 | printf("locals (%d) for %p:\n",n,VOID(f)); 197 | for (i=0; ilocvars[i].varname),f->locvars[i].startpc+1,f->locvars[i].endpc+1); 201 | } 202 | } 203 | 204 | static void PrintUpvalues(const Proto* f) 205 | { 206 | int i,n=f->sizeupvalues; 207 | printf("upvalues (%d) for %p:\n",n,VOID(f)); 208 | if (f->upvalues==NULL) return; 209 | for (i=0; iupvalues[i])); 212 | } 213 | } 214 | 215 | void PrintFunction(const Proto* f, int full) 216 | { 217 | int i,n=f->sizep; 218 | PrintHeader(f); 219 | PrintCode(f); 220 | if (full) 221 | { 222 | PrintConstants(f); 223 | PrintLocals(f); 224 | PrintUpvalues(f); 225 | } 226 | for (i=0; ip[i],full); 227 | } 228 | -------------------------------------------------------------------------------- /src/tags: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lichuang/Lua-5.1.4-codedump/7e5a0089d4a3199318230c2832c3e5c103f55437/src/tags -------------------------------------------------------------------------------- /test/Makefile: -------------------------------------------------------------------------------- 1 | all: 2 | gcc -g -o test.o -c test.c 3 | gcc -g -o test test.o -rdynamic -llua -ldl -lm 4 | gcc -g -o testusrdata.o -c testusrdata.c 5 | gcc -g -o testusrdata testusrdata.o -rdynamic -llua -ldl -lm 6 | 7 | clean: 8 | rm test test.o 9 | -------------------------------------------------------------------------------- /test/README: -------------------------------------------------------------------------------- 1 | These are simple tests for Lua. Some of them contain useful code. 2 | They are meant to be run to make sure Lua is built correctly and also 3 | to be read, to see how Lua programs look. 4 | 5 | Here is a one-line summary of each program: 6 | 7 | bisect.lua bisection method for solving non-linear equations 8 | cf.lua temperature conversion table (celsius to farenheit) 9 | echo.lua echo command line arguments 10 | env.lua environment variables as automatic global variables 11 | factorial.lua factorial without recursion 12 | fib.lua fibonacci function with cache 13 | fibfor.lua fibonacci numbers with coroutines and generators 14 | globals.lua report global variable usage 15 | hello.lua the first program in every language 16 | life.lua Conway's Game of Life 17 | luac.lua bare-bones luac 18 | printf.lua an implementation of printf 19 | readonly.lua make global variables readonly 20 | sieve.lua the sieve of of Eratosthenes programmed with coroutines 21 | sort.lua two implementations of a sort function 22 | table.lua make table, grouping all data for the same item 23 | trace-calls.lua trace calls 24 | trace-globals.lua trace assigments to global variables 25 | xd.lua hex dump 26 | 27 | -------------------------------------------------------------------------------- /test/bisect.lua: -------------------------------------------------------------------------------- 1 | -- bisection method for solving non-linear equations 2 | 3 | delta=1e-6 -- tolerance 4 | 5 | function bisect(f,a,b,fa,fb) 6 | local c=(a+b)/2 7 | io.write(n," c=",c," a=",a," b=",b,"\n") 8 | if c==a or c==b or math.abs(a-b)y end) 58 | show("after reverse selection sort",x) 59 | qsort(x,1,n,function (x,y) return x 2 | #include 3 | #include 4 | #include 5 | 6 | int main(int argc, char *argv[]) { 7 | char *file = NULL; 8 | if (argc == 1) { 9 | file = "my.lua"; 10 | } else { 11 | file = argv[1]; 12 | } 13 | 14 | lua_State *L = lua_open(); 15 | luaL_openlibs(L); 16 | luaL_dofile(L, file); 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /test/testusrdata.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #define BITS_PER_WORD (CHAR_BIT * sizeof(int)) 7 | #define I_WORD(i) ((unsigned int)(i))/BITS_PER_WORD 8 | #define I_BIT(i) (1 << ((unsigned int)(i)%BITS_PER_WORD)) 9 | 10 | typedef struct NumArray { 11 | int size; 12 | unsigned int values[1]; 13 | } NumArray; 14 | 15 | int newArray(lua_State* L) 16 | { 17 | //1. 检查第一个参数是否为整型。以及该参数的值是否大于等于1. 18 | int n = luaL_checkint(L,1); 19 | int i; 20 | luaL_argcheck(L, n >= 1, 1, "invalid size."); 21 | size_t nbytes = sizeof(NumArray) + I_WORD(n - 1) * sizeof(int); 22 | //2. 参数表示Lua为userdata分配的字节数。同时将分配后的userdata对象压入栈中。 23 | NumArray* a = (NumArray*)lua_newuserdata(L,nbytes); 24 | a->size = n; 25 | for (i = 0; i < I_WORD(n - 1); ++i) 26 | a->values[i] = 0; 27 | //获取注册表变量myarray，该key的值为metatable。 28 | luaL_getmetatable(L,"myarray"); 29 | //将userdata的元表设置为和myarray关联的table。同时将栈顶元素弹出。 30 | lua_setmetatable(L,-2); 31 | return 1; 32 | } 33 | 34 | int setArray(lua_State* L) 35 | { 36 | //1. Lua传给该函数的第一个参数必须是userdata，该对象的元表也必须是注册表中和myarray关联的table。 37 | //否则该函数报错并终止程序。 38 | NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray"); 39 | int index = luaL_checkint(L,2) - 1; 40 | //2. 由于任何类型的数据都可以成为布尔值，因此这里使用any只是为了确保有3个参数。 41 | luaL_checkany(L,3); 42 | luaL_argcheck(L,a != NULL,1,"'array' expected."); 43 | luaL_argcheck(L,0 <= index && index < a->size,2,"index out of range."); 44 | if (lua_toboolean(L,3)) 45 | a->values[I_WORD(index)] |= I_BIT(index); 46 | else 47 | a->values[I_WORD(index)] &= ~I_BIT(index); 48 | return 0; 49 | } 50 | 51 | int getArray(lua_State* L) 52 | { 53 | NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray"); 54 | int index = luaL_checkint(L,2) - 1; 55 | luaL_argcheck(L, a != NULL, 1, "'array' expected."); 56 | luaL_argcheck(L, 0 <= index && index < a->size,2,"index out of range"); 57 | lua_pushboolean(L,a->values[I_WORD(index)] & I_BIT(index)); 58 | return 1; 59 | } 60 | 61 | int getSize(lua_State* L) 62 | { 63 | NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray"); 64 | luaL_argcheck(L,a != NULL,1,"'array' expected."); 65 | lua_pushinteger(L,a->size); 66 | return 1; 67 | } 68 | 69 | int array2string(lua_State* L) 70 | { 71 | NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray"); 72 | lua_pushfstring(L,"array(%d)",a->size); 73 | return 1; 74 | } 75 | 76 | static luaL_Reg arraylib_f [] = { 77 | {"new", newArray}, 78 | {NULL, NULL} 79 | }; 80 | 81 | static luaL_Reg arraylib_m [] = { 82 | {"set", setArray}, 83 | {"get", getArray}, 84 | {"size", getSize}, 85 | {"__tostring", array2string}, //print(a)时Lua会调用该元方法。 86 | {NULL, NULL} 87 | }; 88 | 89 | int luaopen_testuserdata(lua_State* L) 90 | { 91 | //1. 创建元表，并将该元表指定给newArray函数新创建的userdata。在Lua中userdata也是以table的身份表现的。 92 | //这样在调用对象函数时，可以通过验证其metatable的名称来确定参数userdata是否合法。 93 | luaL_newmetatable(L,"myarray"); 94 | lua_pushvalue(L,-1); 95 | //2. 为了实现面对对象的调用方式，需要将元表的__index字段指向自身，同时再将arraylib_m数组中的函数注册到 96 | //元表中，之后基于这些注册函数的调用就可以以面向对象的形式调用了。 97 | //lua_setfield在执行后会将栈顶的table弹出。 98 | lua_setfield(L,-2,"__index"); 99 | //将这些成员函数注册给元表，以保证Lua在寻找方法时可以定位。NULL参数表示将用栈顶的table代替第二个参数。 100 | luaL_register(L,NULL,arraylib_m); 101 | //这里只注册的工厂方法。 102 | luaL_register(L,"testuserdata",arraylib_f); 103 | return 1; 104 | } 105 | 106 | int main(){ 107 | char *file = NULL; 108 | file = "my.lua"; 109 | 110 | lua_State *L = lua_open(); 111 | luaL_openlibs(L); 112 | luaopen_testuserdata(L); 113 | if (luaL_dofile(L, file)) { 114 | printf("error: %s\n", lua_tostring(L, -1)); 115 | } 116 | 117 | return 0; 118 | } 119 | 120 | -------------------------------------------------------------------------------- /test/trace-calls.lua: -------------------------------------------------------------------------------- 1 | -- trace calls 2 | -- example: lua -ltrace-calls bisect.lua 3 | 4 | local level=0 5 | 6 | local function hook(event) 7 | local t=debug.getinfo(3) 8 | io.write(level," >>> ",string.rep(" ",level)) 9 | if t~=nil and t.currentline>=0 then io.write(t.short_src,":",t.currentline," ") end 10 | t=debug.getinfo(2) 11 | if event=="call" then 12 | level=level+1 13 | else 14 | level=level-1 if level<0 then level=0 end 15 | end 16 | if t.what=="main" then 17 | if event=="call" then 18 | io.write("begin ",t.short_src) 19 | else 20 | io.write("end ",t.short_src) 21 | end 22 | elseif t.what=="Lua" then 23 | -- table.foreach(t,print) 24 | io.write(event," ",t.name or "(Lua)"," <",t.linedefined,":",t.short_src,">") 25 | else 26 | io.write(event," ",t.name or "(C)"," [",t.what,"] ") 27 | end 28 | io.write("\n") 29 | end 30 | 31 | debug.sethook(hook,"cr") 32 | level=0 33 | -------------------------------------------------------------------------------- /test/trace-globals.lua: -------------------------------------------------------------------------------- 1 | -- trace assigments to global variables 2 | 3 | do 4 | -- a tostring that quotes strings. note the use of the original tostring. 5 | local _tostring=tostring 6 | local tostring=function(a) 7 | if type(a)=="string" then 8 | return string.format("%q",a) 9 | else 10 | return _tostring(a) 11 | end 12 | end 13 | 14 | local log=function (name,old,new) 15 | local t=debug.getinfo(3,"Sl") 16 | local line=t.currentline 17 | io.write(t.short_src) 18 | if line>=0 then io.write(":",line) end 19 | io.write(": ",name," is now ",tostring(new)," (was ",tostring(old),")","\n") 20 | end 21 | 22 | local g={} 23 | local set=function (t,name,value) 24 | log(name,g[name],value) 25 | g[name]=value 26 | end 27 | setmetatable(getfenv(),{__index=g,__newindex=set}) 28 | end 29 | 30 | -- an example 31 | 32 | a=1 33 | b=2 34 | a=10 35 | b=20 36 | b=nil 37 | b=200 38 | print(a,b,c) 39 | -------------------------------------------------------------------------------- /test/xd.lua: -------------------------------------------------------------------------------- 1 | -- hex dump 2 | -- usage: lua xd.lua < file 3 | 4 | local offset=0 5 | while true do 6 | local s=io.read(16) 7 | if s==nil then return end 8 | io.write(string.format("%08X ",offset)) 9 | string.gsub(s,"(.)", 10 | function (c) io.write(string.format("%02X ",string.byte(c))) end) 11 | io.write(string.rep(" ",3*(16-string.len(s)))) 12 | io.write(" ",string.gsub(s,"%c","."),"\n") 13 | offset=offset+16 14 | end 15 | --------------------------------------------------------------------------------