├── COPYRIGHT
├── HISTORY
├── INSTALL
├── Makefile
├── README
├── doc
    ├── 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
└── test
    ├── README
    ├── bisect.lua
    ├── cf.lua
    ├── echo.lua
    ├── env.lua
    ├── factorial.lua
    ├── fib.lua
    ├── fibfor.lua
    ├── globals.lua
    ├── hello.lua
    ├── life.lua
    ├── luac.lua
    ├── printf.lua
    ├── readonly.lua
    ├── sieve.lua
    ├── sort.lua
    ├── table.lua
    ├── trace-calls.lua
    ├── trace-globals.lua
    └── xd.lua


/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-2012 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.5
 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/cover.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsnyder/lua/5ca4b4e3f1d37ad0a6ecf390e41109018f02e8d1/doc/cover.png


--------------------------------------------------------------------------------
/doc/logo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsnyder/lua/5ca4b4e3f1d37ad0a6ecf390e41109018f02e8d1/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: Helvetica, Arial, sans-serif ;
 5 | 	text-align: justify ;
 6 | 	margin-right: 30px ;
 7 | 	margin-left: 30px ;
 8 | }
 9 | 
10 | h1, h2, h3, h4 {
11 | 	font-family: Verdana, Geneva, sans-serif ;
12 | 	font-weight: normal ;
13 | 	font-style: italic ;
14 | }
15 | 
16 | h2 {
17 | 	padding-top: 0.4em ;
18 | 	padding-bottom: 0.4em ;
19 | 	padding-left: 30px ;
20 | 	padding-right: 30px ;
21 | 	margin-left: -30px ;
22 | 	background-color: #E0E0FF ;
23 | }
24 | 
25 | h3 {
26 | 	padding-left: 0.5em ;
27 | 	border-left: solid #E0E0FF 1em ;
28 | }
29 | 
30 | table h3 {
31 | 	padding-left: 0px ;
32 | 	border-left: none ;
33 | }
34 | 
35 | a:link {
36 | 	color: #000080 ;
37 | 	background-color: inherit ;
38 | 	text-decoration: none ;
39 | }
40 | 
41 | a:visited {
42 | 	background-color: inherit ;
43 | 	text-decoration: none ;
44 | }
45 | 
46 | a:link:hover, a:visited:hover {
47 | 	color: #000080 ;
48 | 	background-color: #E0E0FF ;
49 | }
50 | 
51 | a:link:active, a:visited:active {
52 | 	color: #FF0000 ;
53 | }
54 | 
55 | hr {
56 | 	border: 0 ;
57 | 	height: 1px ;
58 | 	color: #a0a0a0 ;
59 | 	background-color: #a0a0a0 ;
60 | }
61 | 
62 | :target {
63 | 	background-color: #F8F8F8 ;
64 | 	padding: 8px ;
65 | 	border: solid #a0a0a0 2px ;
66 | }
67 | 
68 | .footer {
69 | 	color: gray ;
70 | 	font-size: small ;
71 | }
72 | 
73 | input[type=text] {
74 | 	border: solid #a0a0a0 2px ;
75 | 	border-radius: 2em ;
76 | 	-moz-border-radius: 2em ;
77 | 	background-image: url('images/search.png') ;
78 | 	background-repeat: no-repeat;
79 | 	background-position: 4px center ;
80 | 	padding-left: 20px ;
81 | 	height: 2em ;
82 | }
83 | 
84 | 


--------------------------------------------------------------------------------
/doc/lua.html:
--------------------------------------------------------------------------------
  1 | <!-- $Id: lua.man,v 1.11 2006/01/06 16:03:34 lhf Exp $ -->
  2 | <HTML>
  3 | <HEAD>
  4 | <TITLE>LUA man page</TITLE>
  5 | <LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
  6 | </HEAD>
  7 | 
  8 | <BODY BGCOLOR="#FFFFFF">
  9 | 
 10 | <H2>NAME</H2>
 11 | lua - Lua interpreter
 12 | <H2>SYNOPSIS</H2>
 13 | <B>lua</B>
 14 | [
 15 | <I>options</I>
 16 | ]
 17 | [
 18 | <I>script</I>
 19 | [
 20 | <I>args</I>
 21 | ]
 22 | ]
 23 | <H2>DESCRIPTION</H2>
 24 | <B>lua</B>
 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 | <B>luac</B>,
 31 | the Lua compiler.)
 32 | <B>lua</B>
 33 | can be used as a batch interpreter and also interactively.
 34 | <P>
 35 | The given
 36 | <I>options</I>
 37 | (see below)
 38 | are executed and then
 39 | the Lua program in file
 40 | <I>script</I>
 41 | is loaded and executed.
 42 | The given
 43 | <I>args</I>
 44 | are available to
 45 | <I>script</I>
 46 | as strings in a global table named
 47 | <B>arg</B>.
 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 | <B>arg</B>
 53 | start at 0,
 54 | which contains the string
 55 | '<I>script</I>'.
 56 | The index of the last argument is stored in
 57 | <B>arg.n</B>.
 58 | The arguments given in the command line before
 59 | <I>script</I>,
 60 | including the name of the interpreter,
 61 | are available in negative indices in
 62 | <B>arg</B>.
 63 | <P>
 64 | At the very start,
 65 | before even handling the command line,
 66 | <B>lua</B>
 67 | executes the contents of the environment variable
 68 | <B>LUA_INIT</B>,
 69 | if it is defined.
 70 | If the value of
 71 | <B>LUA_INIT</B>
 72 | is of the form
 73 | '@<I>filename</I>',
 74 | then
 75 | <I>filename</I>
 76 | is executed.
 77 | Otherwise, the string is assumed to be a Lua statement and is executed.
 78 | <P>
 79 | Options start with
 80 | <B>'-'</B>
 81 | and are described below.
 82 | You can use
 83 | <B>'--'</B>
 84 | to signal the end of options.
 85 | <P>
 86 | If no arguments are given,
 87 | then
 88 | <B>"-v -i"</B>
 89 | is assumed when the standard input is a terminal;
 90 | otherwise,
 91 | <B>"-"</B>
 92 | is assumed.
 93 | <P>
 94 | In interactive mode,
 95 | <B>lua</B>
 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 | <B>';'</B>
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 | <B>'='</B>,
111 | then
112 | <B>lua</B>
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 | <B>_PROMPT</B>,
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 | <B>_PROMPT2</B>.
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 "&gt; " and "&gt;&gt; ".
129 | <H2>OPTIONS</H2>
130 | <P>
131 | <B>-</B>
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 | <P>
137 | <B>-e </B><I>stat</I>
138 | execute statement
139 | <I>stat</I>.
140 | You need to quote
141 | <I>stat </I>
142 | if it contains spaces, quotes,
143 | or other characters special to the shell.
144 | <P>
145 | <B>-i</B>
146 | enter interactive mode after
147 | <I>script</I>
148 | is executed.
149 | <P>
150 | <B>-l </B><I>name</I>
151 | call
152 | <B>require</B>('<I>name</I>')
153 | before executing
154 | <I>script</I>.
155 | Typically used to load libraries.
156 | <P>
157 | <B>-v</B>
158 | show version information.
159 | <H2>SEE ALSO</H2>
160 | <B>luac</B>(1)
161 | <BR>
162 | <A HREF="http://www.lua.org/">http://www.lua.org/</A>
163 | <H2>DIAGNOSTICS</H2>
164 | Error messages should be self explanatory.
165 | <H2>AUTHORS</H2>
166 | R. Ierusalimschy,
167 | L. H. de Figueiredo,
168 | and
169 | W. Celes
170 | <!-- EOF -->
171 | </BODY>
172 | </HTML>
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 | <!-- $Id: luac.man,v 1.28 2006/01/06 16:03:34 lhf Exp $ -->
  2 | <HTML>
  3 | <HEAD>
  4 | <TITLE>LUAC man page</TITLE>
  5 | <LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
  6 | </HEAD>
  7 | 
  8 | <BODY BGCOLOR="#FFFFFF">
  9 | 
 10 | <H2>NAME</H2>
 11 | luac - Lua compiler
 12 | <H2>SYNOPSIS</H2>
 13 | <B>luac</B>
 14 | [
 15 | <I>options</I>
 16 | ] [
 17 | <I>filenames</I>
 18 | ]
 19 | <H2>DESCRIPTION</H2>
 20 | <B>luac</B>
 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 | <P>
 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 | <P>
 31 | Precompiling does not imply faster execution
 32 | because in Lua chunks are always compiled into bytecodes before being executed.
 33 | <B>luac</B>
 34 | simply allows those bytecodes to be saved in a file for later execution.
 35 | <P>
 36 | Precompiled chunks are not necessarily smaller than the corresponding source.
 37 | The main goal in precompiling is faster loading.
 38 | <P>
 39 | The binary files created by
 40 | <B>luac</B>
 41 | are portable only among architectures with the same word size and byte order.
 42 | <P>
 43 | <B>luac</B>
 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 | <B>luac.out</B>,
 49 | but you can change this with the
 50 | <B>-o</B>
 51 | option.
 52 | <P>
 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 | <P>
 61 | You can use
 62 | <B>'-'</B>
 63 | to indicate the standard input as a source file
 64 | and
 65 | <B>'--'</B>
 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 | <B>'-'</B>).
 70 | <P>
 71 | The internal format of the binary files produced by
 72 | <B>luac</B>
 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 | <P>
 77 | <H2>OPTIONS</H2>
 78 | Options must be separate.
 79 | <P>
 80 | <B>-l</B>
 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 | <B>luac</B>
 85 | loads
 86 | <B>luac.out</B>
 87 | and lists its contents.
 88 | <P>
 89 | <B>-o </B><I>file</I>
 90 | output to
 91 | <I>file</I>,
 92 | instead of the default
 93 | <B>luac.out</B>.
 94 | (You can use
 95 | <B>'-'</B>
 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 | <P>
102 | <B>-p</B>
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 | <B>luac</B>
114 | loads
115 | <B>luac.out</B>
116 | and tests its contents.
117 | No messages are displayed if the file passes the integrity test.
118 | <P>
119 | <B>-s</B>
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 | <P>
127 | <B>-v</B>
128 | show version information.
129 | <H2>FILES</H2>
130 | <P>
131 | <B>luac.out</B>
132 | default output file
133 | <H2>SEE ALSO</H2>
134 | <B>lua</B>(1)
135 | <BR>
136 | <A HREF="http://www.lua.org/">http://www.lua.org/</A>
137 | <H2>DIAGNOSTICS</H2>
138 | Error messages should be self explanatory.
139 | <H2>AUTHORS</H2>
140 | L. H. de Figueiredo,
141 | R. Ierusalimschy and
142 | W. Celes
143 | <!-- EOF -->
144 | </BODY>
145 | </HTML>
146 | 


--------------------------------------------------------------------------------
/doc/manual.css:
--------------------------------------------------------------------------------
 1 | h3 code {
 2 | 	font-family: inherit ;
 3 | 	font-size: inherit ;
 4 | }
 5 | 
 6 | pre, code {
 7 | 	font-size: 12pt ;
 8 | }
 9 | 
10 | span.apii {
11 | 	float: right ;
12 | 	font-family: inherit ;
13 | 	font-style: normal ;
14 | 	font-size: small ;
15 | 	color: gray ;
16 | }
17 | 
18 | p+h1, ul+h1 {
19 | 	padding-top: 0.4em ;
20 | 	padding-bottom: 0.4em ;
21 | 	padding-left: 30px ;
22 | 	margin-left: -30px ;
23 | 	background-color: #E0E0FF ;
24 | }
25 | 


--------------------------------------------------------------------------------
/doc/readme.html:
--------------------------------------------------------------------------------
 1 | <HTML>
 2 | <HEAD>
 3 | <TITLE>Lua documentation</TITLE>
 4 | <LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
 5 | </HEAD>
 6 | 
 7 | <BODY>
 8 | 
 9 | <HR>
10 | <H1>
11 | <A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua" BORDER=0></A>
12 | Documentation
13 | </H1>
14 | 
15 | This is the documentation included in the source distribution of Lua 5.1.5.
16 | 
17 | <UL>
18 | <LI><A HREF="contents.html">Reference manual</A>
19 | <LI><A HREF="lua.html">lua man page</A>
20 | <LI><A HREF="luac.html">luac man page</A>
21 | <LI><A HREF="../README">lua/README</A>
22 | <LI><A HREF="../etc/README">lua/etc/README</A>
23 | <LI><A HREF="../test/README">lua/test/README</A>
24 | </UL>
25 | 
26 | Lua's
27 | <A HREF="http://www.lua.org/">official web site</A>
28 | contains updated documentation,
29 | especially the
30 | <A HREF="http://www.lua.org/manual/5.1/">reference manual</A>.
31 | <P>
32 | 
33 | <HR>
34 | <SMALL>
35 | Last update:
36 | Fri Feb  3 09:44:42 BRST 2012
37 | </SMALL>
38 | 
39 | </BODY>
40 | </HTML>
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 <gritsch@iue.tuwien.ac.at>.
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 | // <<extern "C">> 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/jsnyder/lua/5ca4b4e3f1d37ad0a6ecf390e41109018f02e8d1/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.5
 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 <stdio.h>
 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 | CORE_O=	lapi.o lcode.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o \
 27 | 	lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o  \
 28 | 	lundump.o lvm.o lzio.o
 29 | LIB_O=	lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o \
 30 | 	lstrlib.o loadlib.o linit.o
 31 | 
 32 | LUA_T=	lua
 33 | LUA_O=	lua.o
 34 | 
 35 | LUAC_T=	luac
 36 | LUAC_O=	luac.o print.o
 37 | 
 38 | ALL_O= $(CORE_O) $(LIB_O) $(LUA_O) $(LUAC_O)
 39 | ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
 40 | ALL_A= $(LUA_A)
 41 | 
 42 | default: $(PLAT)
 43 | 
 44 | all:	$(ALL_T)
 45 | 
 46 | o:	$(ALL_O)
 47 | 
 48 | a:	$(ALL_A)
 49 | 
 50 | $(LUA_A): $(CORE_O) $(LIB_O)
 51 | 	$(AR) $@ $(CORE_O) $(LIB_O)	# DLL needs all object files
 52 | 	$(RANLIB) $@
 53 | 
 54 | $(LUA_T): $(LUA_O) $(LUA_A)
 55 | 	$(CC) -o $@ $(MYLDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
 56 | 
 57 | $(LUAC_T): $(LUAC_O) $(LUA_A)
 58 | 	$(CC) -o $@ $(MYLDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
 59 | 
 60 | clean:
 61 | 	$(RM) $(ALL_T) $(ALL_O)
 62 | 
 63 | depend:
 64 | 	@$(CC) $(CFLAGS) -MM l*.c print.c
 65 | 
 66 | echo:
 67 | 	@echo "PLAT = $(PLAT)"
 68 | 	@echo "CC = $(CC)"
 69 | 	@echo "CFLAGS = $(CFLAGS)"
 70 | 	@echo "AR = $(AR)"
 71 | 	@echo "RANLIB = $(RANLIB)"
 72 | 	@echo "RM = $(RM)"
 73 | 	@echo "MYCFLAGS = $(MYCFLAGS)"
 74 | 	@echo "MYLDFLAGS = $(MYLDFLAGS)"
 75 | 	@echo "MYLIBS = $(MYLIBS)"
 76 | 
 77 | # convenience targets for popular platforms
 78 | 
 79 | none:
 80 | 	@echo "Please choose a platform:"
 81 | 	@echo "   $(PLATS)"
 82 | 
 83 | aix:
 84 | 	$(MAKE) all CC="xlc" CFLAGS="-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl" MYLDFLAGS="-brtl -bexpall"
 85 | 
 86 | ansi:
 87 | 	$(MAKE) all MYCFLAGS=-DLUA_ANSI
 88 | 
 89 | bsd:
 90 | 	$(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-Wl,-E"
 91 | 
 92 | freebsd:
 93 | 	$(MAKE) all MYCFLAGS="-DLUA_USE_LINUX" MYLIBS="-Wl,-E -lreadline"
 94 | 
 95 | generic:
 96 | 	$(MAKE) all MYCFLAGS=
 97 | 
 98 | linux:
 99 | 	$(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-Wl,-E -ldl -lreadline -lhistory -lncurses"
100 | 
101 | macosx:
102 | 	$(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-lreadline"
103 | # use this on Mac OS X 10.3-
104 | #	$(MAKE) all MYCFLAGS=-DLUA_USE_MACOSX
105 | 
106 | mingw:
107 | 	$(MAKE) "LUA_A=lua51.dll" "LUA_T=lua.exe" \
108 | 	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
109 | 	"MYCFLAGS=-DLUA_BUILD_AS_DLL" "MYLIBS=" "MYLDFLAGS=-s" lua.exe
110 | 	$(MAKE) "LUAC_T=luac.exe" luac.exe
111 | 
112 | posix:
113 | 	$(MAKE) all MYCFLAGS=-DLUA_USE_POSIX
114 | 
115 | solaris:
116 | 	$(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl"
117 | 
118 | # list targets that do not create files (but not all makes understand .PHONY)
119 | .PHONY: all $(PLATS) default o a clean depend echo none
120 | 
121 | # DO NOT DELETE
122 | 
123 | lapi.o: lapi.c lua.h luaconf.h lapi.h lobject.h llimits.h ldebug.h \
124 |   lstate.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h \
125 |   lundump.h lvm.h
126 | lauxlib.o: lauxlib.c lua.h luaconf.h lauxlib.h
127 | lbaselib.o: lbaselib.c lua.h luaconf.h lauxlib.h lualib.h
128 | lcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
129 |   lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lgc.h \
130 |   ltable.h
131 | ldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h
132 | ldebug.o: ldebug.c lua.h luaconf.h lapi.h lobject.h llimits.h lcode.h \
133 |   llex.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \
134 |   lfunc.h lstring.h lgc.h ltable.h lvm.h
135 | ldo.o: ldo.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
136 |   lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lparser.h lstring.h \
137 |   ltable.h lundump.h lvm.h
138 | ldump.o: ldump.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \
139 |   lzio.h lmem.h lundump.h
140 | lfunc.o: lfunc.c lua.h luaconf.h lfunc.h lobject.h llimits.h lgc.h lmem.h \
141 |   lstate.h ltm.h lzio.h
142 | lgc.o: lgc.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
143 |   lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h
144 | linit.o: linit.c lua.h luaconf.h lualib.h lauxlib.h
145 | liolib.o: liolib.c lua.h luaconf.h lauxlib.h lualib.h
146 | llex.o: llex.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h ltm.h \
147 |   lzio.h lmem.h llex.h lparser.h lstring.h lgc.h ltable.h
148 | lmathlib.o: lmathlib.c lua.h luaconf.h lauxlib.h lualib.h
149 | lmem.o: lmem.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
150 |   ltm.h lzio.h lmem.h ldo.h
151 | loadlib.o: loadlib.c lua.h luaconf.h lauxlib.h lualib.h
152 | lobject.o: lobject.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h \
153 |   ltm.h lzio.h lmem.h lstring.h lgc.h lvm.h
154 | lopcodes.o: lopcodes.c lopcodes.h llimits.h lua.h luaconf.h
155 | loslib.o: loslib.c lua.h luaconf.h lauxlib.h lualib.h
156 | lparser.o: lparser.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
157 |   lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \
158 |   lfunc.h lstring.h lgc.h ltable.h
159 | lstate.o: lstate.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
160 |   ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h llex.h lstring.h ltable.h
161 | lstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \
162 |   ltm.h lzio.h lstring.h lgc.h
163 | lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h
164 | ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
165 |   ltm.h lzio.h lmem.h ldo.h lgc.h ltable.h
166 | ltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h
167 | ltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \
168 |   lmem.h lstring.h lgc.h ltable.h
169 | lua.o: lua.c lua.h luaconf.h lauxlib.h lualib.h
170 | luac.o: luac.c lua.h luaconf.h lauxlib.h ldo.h lobject.h llimits.h \
171 |   lstate.h ltm.h lzio.h lmem.h lfunc.h lopcodes.h lstring.h lgc.h \
172 |   lundump.h
173 | lundump.o: lundump.c lua.h luaconf.h ldebug.h lstate.h lobject.h \
174 |   llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h lundump.h
175 | lvm.o: lvm.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
176 |   lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h lvm.h
177 | lzio.o: lzio.c lua.h luaconf.h llimits.h lmem.h lstate.h lobject.h ltm.h \
178 |   lzio.h
179 | print.o: print.c ldebug.h lstate.h lua.h luaconf.h lobject.h llimits.h \
180 |   ltm.h lzio.h lmem.h lopcodes.h lundump.h
181 | 
182 | # (end of Makefile)
183 | 


--------------------------------------------------------------------------------
/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 <stddef.h>
 13 | #include <stdio.h>
 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 | typedef enum BinOpr {
27 |   OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
28 |   OPR_CONCAT,
29 |   OPR_NE, OPR_EQ,
30 |   OPR_LT, OPR_LE, OPR_GT, OPR_GE,
31 |   OPR_AND, OPR_OR,
32 |   OPR_NOBINOPR
33 | } BinOpr;
34 | 
35 | 
36 | typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
37 | 
38 | 
39 | #define getcode(fs,e)	((fs)->f->code[(e)->u.s.info])
40 | 
41 | #define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
42 | 
43 | #define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
44 | 
45 | LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
46 | LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
47 | LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
48 | LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
49 | LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
50 | LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
51 | LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
52 | LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
53 | LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
54 | LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
55 | LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
56 | LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
57 | LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
58 | LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
59 | LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
60 | LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
61 | LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
62 | LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
63 | LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
64 | LUAI_FUNC int luaK_jump (FuncState *fs);
65 | LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
66 | LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
67 | LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
68 | LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
69 | LUAI_FUNC int luaK_getlabel (FuncState *fs);
70 | LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);
71 | LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
72 | LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);
73 | LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
74 | 
75 | 
76 | #endif
77 | 


--------------------------------------------------------------------------------
/src/ldblib.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: ldblib.c,v 1.104.1.4 2009/08/04 18:50:18 roberto Exp $
  3 | ** Interface from Lua to its debug API
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <stdio.h>
  9 | #include <stdlib.h>
 10 | #include <string.h>
 11 | 
 12 | #define ldblib_c
 13 | #define LUA_LIB
 14 | 
 15 | #include "lua.h"
 16 | 
 17 | #include "lauxlib.h"
 18 | #include "lualib.h"
 19 | 
 20 | 
 21 | 
 22 | static int db_getregistry (lua_State *L) {
 23 |   lua_pushvalue(L, LUA_REGISTRYINDEX);
 24 |   return 1;
 25 | }
 26 | 
 27 | 
 28 | static int db_getmetatable (lua_State *L) {
 29 |   luaL_checkany(L, 1);
 30 |   if (!lua_getmetatable(L, 1)) {
 31 |     lua_pushnil(L);  /* no metatable */
 32 |   }
 33 |   return 1;
 34 | }
 35 | 
 36 | 
 37 | static int db_setmetatable (lua_State *L) {
 38 |   int t = lua_type(L, 2);
 39 |   luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
 40 |                     "nil or table expected");
 41 |   lua_settop(L, 2);
 42 |   lua_pushboolean(L, lua_setmetatable(L, 1));
 43 |   return 1;
 44 | }
 45 | 
 46 | 
 47 | static int db_getfenv (lua_State *L) {
 48 |   luaL_checkany(L, 1);
 49 |   lua_getfenv(L, 1);
 50 |   return 1;
 51 | }
 52 | 
 53 | 
 54 | static int db_setfenv (lua_State *L) {
 55 |   luaL_checktype(L, 2, LUA_TTABLE);
 56 |   lua_settop(L, 2);
 57 |   if (lua_setfenv(L, 1) == 0)
 58 |     luaL_error(L, LUA_QL("setfenv")
 59 |                   " cannot change environment of given object");
 60 |   return 1;
 61 | }
 62 | 
 63 | 
 64 | static void settabss (lua_State *L, const char *i, const char *v) {
 65 |   lua_pushstring(L, v);
 66 |   lua_setfield(L, -2, i);
 67 | }
 68 | 
 69 | 
 70 | static void settabsi (lua_State *L, const char *i, int v) {
 71 |   lua_pushinteger(L, v);
 72 |   lua_setfield(L, -2, i);
 73 | }
 74 | 
 75 | 
 76 | static lua_State *getthread (lua_State *L, int *arg) {
 77 |   if (lua_isthread(L, 1)) {
 78 |     *arg = 1;
 79 |     return lua_tothread(L, 1);
 80 |   }
 81 |   else {
 82 |     *arg = 0;
 83 |     return L;
 84 |   }
 85 | }
 86 | 
 87 | 
 88 | static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
 89 |   if (L == L1) {
 90 |     lua_pushvalue(L, -2);
 91 |     lua_remove(L, -3);
 92 |   }
 93 |   else
 94 |     lua_xmove(L1, L, 1);
 95 |   lua_setfield(L, -2, fname);
 96 | }
 97 | 
 98 | 
 99 | static int db_getinfo (lua_State *L) {
100 |   lua_Debug ar;
101 |   int arg;
102 |   lua_State *L1 = getthread(L, &arg);
103 |   const char *options = luaL_optstring(L, arg+2, "flnSu");
104 |   if (lua_isnumber(L, arg+1)) {
105 |     if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {
106 |       lua_pushnil(L);  /* level out of range */
107 |       return 1;
108 |     }
109 |   }
110 |   else if (lua_isfunction(L, arg+1)) {
111 |     lua_pushfstring(L, ">%s", options);
112 |     options = lua_tostring(L, -1);
113 |     lua_pushvalue(L, arg+1);
114 |     lua_xmove(L, L1, 1);
115 |   }
116 |   else
117 |     return luaL_argerror(L, arg+1, "function or level expected");
118 |   if (!lua_getinfo(L1, options, &ar))
119 |     return luaL_argerror(L, arg+2, "invalid option");
120 |   lua_createtable(L, 0, 2);
121 |   if (strchr(options, 'S')) {
122 |     settabss(L, "source", ar.source);
123 |     settabss(L, "short_src", ar.short_src);
124 |     settabsi(L, "linedefined", ar.linedefined);
125 |     settabsi(L, "lastlinedefined", ar.lastlinedefined);
126 |     settabss(L, "what", ar.what);
127 |   }
128 |   if (strchr(options, 'l'))
129 |     settabsi(L, "currentline", ar.currentline);
130 |   if (strchr(options, 'u'))
131 |     settabsi(L, "nups", ar.nups);
132 |   if (strchr(options, 'n')) {
133 |     settabss(L, "name", ar.name);
134 |     settabss(L, "namewhat", ar.namewhat);
135 |   }
136 |   if (strchr(options, 'L'))
137 |     treatstackoption(L, L1, "activelines");
138 |   if (strchr(options, 'f'))
139 |     treatstackoption(L, L1, "func");
140 |   return 1;  /* return table */
141 | }
142 |     
143 | 
144 | static int db_getlocal (lua_State *L) {
145 |   int arg;
146 |   lua_State *L1 = getthread(L, &arg);
147 |   lua_Debug ar;
148 |   const char *name;
149 |   if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
150 |     return luaL_argerror(L, arg+1, "level out of range");
151 |   name = lua_getlocal(L1, &ar, luaL_checkint(L, arg+2));
152 |   if (name) {
153 |     lua_xmove(L1, L, 1);
154 |     lua_pushstring(L, name);
155 |     lua_pushvalue(L, -2);
156 |     return 2;
157 |   }
158 |   else {
159 |     lua_pushnil(L);
160 |     return 1;
161 |   }
162 | }
163 | 
164 | 
165 | static int db_setlocal (lua_State *L) {
166 |   int arg;
167 |   lua_State *L1 = getthread(L, &arg);
168 |   lua_Debug ar;
169 |   if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
170 |     return luaL_argerror(L, arg+1, "level out of range");
171 |   luaL_checkany(L, arg+3);
172 |   lua_settop(L, arg+3);
173 |   lua_xmove(L, L1, 1);
174 |   lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2)));
175 |   return 1;
176 | }
177 | 
178 | 
179 | static int auxupvalue (lua_State *L, int get) {
180 |   const char *name;
181 |   int n = luaL_checkint(L, 2);
182 |   luaL_checktype(L, 1, LUA_TFUNCTION);
183 |   if (lua_iscfunction(L, 1)) return 0;  /* cannot touch C upvalues from Lua */
184 |   name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
185 |   if (name == NULL) return 0;
186 |   lua_pushstring(L, name);
187 |   lua_insert(L, -(get+1));
188 |   return get + 1;
189 | }
190 | 
191 | 
192 | static int db_getupvalue (lua_State *L) {
193 |   return auxupvalue(L, 1);
194 | }
195 | 
196 | 
197 | static int db_setupvalue (lua_State *L) {
198 |   luaL_checkany(L, 3);
199 |   return auxupvalue(L, 0);
200 | }
201 | 
202 | 
203 | 
204 | static const char KEY_HOOK = 'h';
205 | 
206 | 
207 | static void hookf (lua_State *L, lua_Debug *ar) {
208 |   static const char *const hooknames[] =
209 |     {"call", "return", "line", "count", "tail return"};
210 |   lua_pushlightuserdata(L, (void *)&KEY_HOOK);
211 |   lua_rawget(L, LUA_REGISTRYINDEX);
212 |   lua_pushlightuserdata(L, L);
213 |   lua_rawget(L, -2);
214 |   if (lua_isfunction(L, -1)) {
215 |     lua_pushstring(L, hooknames[(int)ar->event]);
216 |     if (ar->currentline >= 0)
217 |       lua_pushinteger(L, ar->currentline);
218 |     else lua_pushnil(L);
219 |     lua_assert(lua_getinfo(L, "lS", ar));
220 |     lua_call(L, 2, 0);
221 |   }
222 | }
223 | 
224 | 
225 | static int makemask (const char *smask, int count) {
226 |   int mask = 0;
227 |   if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
228 |   if (strchr(smask, 'r')) mask |= LUA_MASKRET;
229 |   if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
230 |   if (count > 0) mask |= LUA_MASKCOUNT;
231 |   return mask;
232 | }
233 | 
234 | 
235 | static char *unmakemask (int mask, char *smask) {
236 |   int i = 0;
237 |   if (mask & LUA_MASKCALL) smask[i++] = 'c';
238 |   if (mask & LUA_MASKRET) smask[i++] = 'r';
239 |   if (mask & LUA_MASKLINE) smask[i++] = 'l';
240 |   smask[i] = '\0';
241 |   return smask;
242 | }
243 | 
244 | 
245 | static void gethooktable (lua_State *L) {
246 |   lua_pushlightuserdata(L, (void *)&KEY_HOOK);
247 |   lua_rawget(L, LUA_REGISTRYINDEX);
248 |   if (!lua_istable(L, -1)) {
249 |     lua_pop(L, 1);
250 |     lua_createtable(L, 0, 1);
251 |     lua_pushlightuserdata(L, (void *)&KEY_HOOK);
252 |     lua_pushvalue(L, -2);
253 |     lua_rawset(L, LUA_REGISTRYINDEX);
254 |   }
255 | }
256 | 
257 | 
258 | static int db_sethook (lua_State *L) {
259 |   int arg, mask, count;
260 |   lua_Hook func;
261 |   lua_State *L1 = getthread(L, &arg);
262 |   if (lua_isnoneornil(L, arg+1)) {
263 |     lua_settop(L, arg+1);
264 |     func = NULL; mask = 0; count = 0;  /* turn off hooks */
265 |   }
266 |   else {
267 |     const char *smask = luaL_checkstring(L, arg+2);
268 |     luaL_checktype(L, arg+1, LUA_TFUNCTION);
269 |     count = luaL_optint(L, arg+3, 0);
270 |     func = hookf; mask = makemask(smask, count);
271 |   }
272 |   gethooktable(L);
273 |   lua_pushlightuserdata(L, L1);
274 |   lua_pushvalue(L, arg+1);
275 |   lua_rawset(L, -3);  /* set new hook */
276 |   lua_pop(L, 1);  /* remove hook table */
277 |   lua_sethook(L1, func, mask, count);  /* set hooks */
278 |   return 0;
279 | }
280 | 
281 | 
282 | static int db_gethook (lua_State *L) {
283 |   int arg;
284 |   lua_State *L1 = getthread(L, &arg);
285 |   char buff[5];
286 |   int mask = lua_gethookmask(L1);
287 |   lua_Hook hook = lua_gethook(L1);
288 |   if (hook != NULL && hook != hookf)  /* external hook? */
289 |     lua_pushliteral(L, "external hook");
290 |   else {
291 |     gethooktable(L);
292 |     lua_pushlightuserdata(L, L1);
293 |     lua_rawget(L, -2);   /* get hook */
294 |     lua_remove(L, -2);  /* remove hook table */
295 |   }
296 |   lua_pushstring(L, unmakemask(mask, buff));
297 |   lua_pushinteger(L, lua_gethookcount(L1));
298 |   return 3;
299 | }
300 | 
301 | 
302 | static int db_debug (lua_State *L) {
303 |   for (;;) {
304 |     char buffer[250];
305 |     fputs("lua_debug> ", stderr);
306 |     if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
307 |         strcmp(buffer, "cont\n") == 0)
308 |       return 0;
309 |     if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
310 |         lua_pcall(L, 0, 0, 0)) {
311 |       fputs(lua_tostring(L, -1), stderr);
312 |       fputs("\n", stderr);
313 |     }
314 |     lua_settop(L, 0);  /* remove eventual returns */
315 |   }
316 | }
317 | 
318 | 
319 | #define LEVELS1	12	/* size of the first part of the stack */
320 | #define LEVELS2	10	/* size of the second part of the stack */
321 | 
322 | static int db_errorfb (lua_State *L) {
323 |   int level;
324 |   int firstpart = 1;  /* still before eventual `...' */
325 |   int arg;
326 |   lua_State *L1 = getthread(L, &arg);
327 |   lua_Debug ar;
328 |   if (lua_isnumber(L, arg+2)) {
329 |     level = (int)lua_tointeger(L, arg+2);
330 |     lua_pop(L, 1);
331 |   }
332 |   else
333 |     level = (L == L1) ? 1 : 0;  /* level 0 may be this own function */
334 |   if (lua_gettop(L) == arg)
335 |     lua_pushliteral(L, "");
336 |   else if (!lua_isstring(L, arg+1)) return 1;  /* message is not a string */
337 |   else lua_pushliteral(L, "\n");
338 |   lua_pushliteral(L, "stack traceback:");
339 |   while (lua_getstack(L1, level++, &ar)) {
340 |     if (level > LEVELS1 && firstpart) {
341 |       /* no more than `LEVELS2' more levels? */
342 |       if (!lua_getstack(L1, level+LEVELS2, &ar))
343 |         level--;  /* keep going */
344 |       else {
345 |         lua_pushliteral(L, "\n\t...");  /* too many levels */
346 |         while (lua_getstack(L1, level+LEVELS2, &ar))  /* find last levels */
347 |           level++;
348 |       }
349 |       firstpart = 0;
350 |       continue;
351 |     }
352 |     lua_pushliteral(L, "\n\t");
353 |     lua_getinfo(L1, "Snl", &ar);
354 |     lua_pushfstring(L, "%s:", ar.short_src);
355 |     if (ar.currentline > 0)
356 |       lua_pushfstring(L, "%d:", ar.currentline);
357 |     if (*ar.namewhat != '\0')  /* is there a name? */
358 |         lua_pushfstring(L, " in function " LUA_QS, ar.name);
359 |     else {
360 |       if (*ar.what == 'm')  /* main? */
361 |         lua_pushfstring(L, " in main chunk");
362 |       else if (*ar.what == 'C' || *ar.what == 't')
363 |         lua_pushliteral(L, " ?");  /* C function or tail call */
364 |       else
365 |         lua_pushfstring(L, " in function <%s:%d>",
366 |                            ar.short_src, ar.linedefined);
367 |     }
368 |     lua_concat(L, lua_gettop(L) - arg);
369 |   }
370 |   lua_concat(L, lua_gettop(L) - arg);
371 |   return 1;
372 | }
373 | 
374 | 
375 | static const luaL_Reg dblib[] = {
376 |   {"debug", db_debug},
377 |   {"getfenv", db_getfenv},
378 |   {"gethook", db_gethook},
379 |   {"getinfo", db_getinfo},
380 |   {"getlocal", db_getlocal},
381 |   {"getregistry", db_getregistry},
382 |   {"getmetatable", db_getmetatable},
383 |   {"getupvalue", db_getupvalue},
384 |   {"setfenv", db_setfenv},
385 |   {"sethook", db_sethook},
386 |   {"setlocal", db_setlocal},
387 |   {"setmetatable", db_setmetatable},
388 |   {"setupvalue", db_setupvalue},
389 |   {"traceback", db_errorfb},
390 |   {NULL, NULL}
391 | };
392 | 
393 | 
394 | LUALIB_API int luaopen_debug (lua_State *L) {
395 |   luaL_register(L, LUA_DBLIBNAME, dblib);
396 |   return 1;
397 | }
398 | 
399 | 


--------------------------------------------------------------------------------
/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 <stddef.h>
  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; i<n; i++)
 85 |  {
 86 |   const TValue* o=&f->k[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; i<n; i++) DumpFunction(f->p[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; i<n; i++)
119 |  {
120 |   DumpString(f->locvars[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; i<n; i++) DumpString(f->upvalues[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 <stddef.h>
  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 | 
 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 |   while (nelems--) c->l.upvals[nelems] = NULL;
 40 |   return c;
 41 | }
 42 | 
 43 | 
 44 | UpVal *luaF_newupval (lua_State *L) {
 45 |   UpVal *uv = luaM_new(L, UpVal);
 46 |   luaC_link(L, obj2gco(uv), LUA_TUPVAL);
 47 |   uv->v = &uv->u.value;
 48 |   setnilvalue(uv->v);
 49 |   return uv;
 50 | }
 51 | 
 52 | 
 53 | UpVal *luaF_findupval (lua_State *L, StkId level) {
 54 |   global_State *g = G(L);
 55 |   GCObject **pp = &L->openupval;
 56 |   UpVal *p;
 57 |   UpVal *uv;
 58 |   while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {
 59 |     lua_assert(p->v != &p->u.value);
 60 |     if (p->v == level) {  /* found a corresponding upvalue? */
 61 |       if (isdead(g, obj2gco(p)))  /* is it dead? */
 62 |         changewhite(obj2gco(p));  /* ressurect it */
 63 |       return p;
 64 |     }
 65 |     pp = &p->next;
 66 |   }
 67 |   uv = luaM_new(L, UpVal);  /* not found: create a new one */
 68 |   uv->tt = LUA_TUPVAL;
 69 |   uv->marked = luaC_white(g);
 70 |   uv->v = level;  /* current value lives in the stack */
 71 |   uv->next = *pp;  /* chain it in the proper position */
 72 |   *pp = obj2gco(uv);
 73 |   uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */
 74 |   uv->u.l.next = g->uvhead.u.l.next;
 75 |   uv->u.l.next->u.l.prev = uv;
 76 |   g->uvhead.u.l.next = uv;
 77 |   lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
 78 |   return uv;
 79 | }
 80 | 
 81 | 
 82 | static void unlinkupval (UpVal *uv) {
 83 |   lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
 84 |   uv->u.l.next->u.l.prev = uv->u.l.prev;  /* remove from `uvhead' list */
 85 |   uv->u.l.prev->u.l.next = uv->u.l.next;
 86 | }
 87 | 
 88 | 
 89 | void luaF_freeupval (lua_State *L, UpVal *uv) {
 90 |   if (uv->v != &uv->u.value)  /* is it open? */
 91 |     unlinkupval(uv);  /* remove from open list */
 92 |   luaM_free(L, uv);  /* free upvalue */
 93 | }
 94 | 
 95 | 
 96 | void luaF_close (lua_State *L, StkId level) {
 97 |   UpVal *uv;
 98 |   global_State *g = G(L);
 99 |   while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {
100 |     GCObject *o = obj2gco(uv);
101 |     lua_assert(!isblack(o) && uv->v != &uv->u.value);
102 |     L->openupval = uv->next;  /* remove from `open' list */
103 |     if (isdead(g, o))
104 |       luaF_freeupval(L, uv);  /* free upvalue */
105 |     else {
106 |       unlinkupval(uv);
107 |       setobj(L, &uv->u.value, uv->v);
108 |       uv->v = &uv->u.value;  /* now current value lives here */
109 |       luaC_linkupval(L, uv);  /* link upvalue into `gcroot' list */
110 |     }
111 |   }
112 | }
113 | 
114 | 
115 | Proto *luaF_newproto (lua_State *L) {
116 |   Proto *f = luaM_new(L, Proto);
117 |   luaC_link(L, obj2gco(f), LUA_TPROTO);
118 |   f->k = NULL;
119 |   f->sizek = 0;
120 |   f->p = NULL;
121 |   f->sizep = 0;
122 |   f->code = NULL;
123 |   f->sizecode = 0;
124 |   f->sizelineinfo = 0;
125 |   f->sizeupvalues = 0;
126 |   f->nups = 0;
127 |   f->upvalues = NULL;
128 |   f->numparams = 0;
129 |   f->is_vararg = 0;
130 |   f->maxstacksize = 0;
131 |   f->lineinfo = NULL;
132 |   f->sizelocvars = 0;
133 |   f->locvars = NULL;
134 |   f->linedefined = 0;
135 |   f->lastlinedefined = 0;
136 |   f->source = NULL;
137 |   return f;
138 | }
139 | 
140 | 
141 | void luaF_freeproto (lua_State *L, Proto *f) {
142 |   luaM_freearray(L, f->code, f->sizecode, Instruction);
143 |   luaM_freearray(L, f->p, f->sizep, Proto *);
144 |   luaM_freearray(L, f->k, f->sizek, TValue);
145 |   luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
146 |   luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
147 |   luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);
148 |   luaM_free(L, f);
149 | }
150 | 
151 | 
152 | void luaF_freeclosure (lua_State *L, Closure *c) {
153 |   int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :
154 |                           sizeLclosure(c->l.nupvalues);
155 |   luaM_freemem(L, c, size);
156 | }
157 | 
158 | 
159 | /*
160 | ** Look for n-th local variable at line `line' in function `func'.
161 | ** Returns NULL if not found.
162 | */
163 | const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
164 |   int i;
165 |   for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
166 |     if (pc < f->locvars[i].endpc) {  /* is variable active? */
167 |       local_number--;
168 |       if (local_number == 0)
169 |         return getstr(f->locvars[i].varname);
170 |     }
171 |   }
172 |   return NULL;  /* not found */
173 | }
174 | 
175 | 


--------------------------------------------------------------------------------
/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 | #define KEYWEAKBIT	3
 59 | #define VALUEWEAKBIT	4
 60 | #define FIXEDBIT	5
 61 | #define SFIXEDBIT	6
 62 | #define WHITEBITS	bit2mask(WHITE0BIT, WHITE1BIT)
 63 | 
 64 | 
 65 | #define iswhite(x)      test2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
 66 | #define isblack(x)      testbit((x)->gch.marked, BLACKBIT)
 67 | #define isgray(x)	(!isblack(x) && !iswhite(x))
 68 | 
 69 | #define otherwhite(g)	(g->currentwhite ^ WHITEBITS)
 70 | #define isdead(g,v)	((v)->gch.marked & otherwhite(g) & WHITEBITS)
 71 | 
 72 | #define changewhite(x)	((x)->gch.marked ^= WHITEBITS)
 73 | #define gray2black(x)	l_setbit((x)->gch.marked, BLACKBIT)
 74 | 
 75 | #define valiswhite(x)	(iscollectable(x) && iswhite(gcvalue(x)))
 76 | 
 77 | #define luaC_white(g)	cast(lu_byte, (g)->currentwhite & WHITEBITS)
 78 | 
 79 | 
 80 | #define luaC_checkGC(L) { \
 81 |   condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1)); \
 82 |   if (G(L)->totalbytes >= G(L)->GCthreshold) \
 83 | 	luaC_step(L); }
 84 | 
 85 | 
 86 | #define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
 87 | 	luaC_barrierf(L,obj2gco(p),gcvalue(v)); }
 88 | 
 89 | #define luaC_barriert(L,t,v) { if (valiswhite(v) && isblack(obj2gco(t)))  \
 90 | 	luaC_barrierback(L,t); }
 91 | 
 92 | #define luaC_objbarrier(L,p,o)  \
 93 | 	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
 94 | 		luaC_barrierf(L,obj2gco(p),obj2gco(o)); }
 95 | 
 96 | #define luaC_objbarriert(L,t,o)  \
 97 |    { if (iswhite(obj2gco(o)) && isblack(obj2gco(t))) luaC_barrierback(L,t); }
 98 | 
 99 | LUAI_FUNC size_t luaC_separateudata (lua_State *L, int all);
100 | LUAI_FUNC void luaC_callGCTM (lua_State *L);
101 | LUAI_FUNC void luaC_freeall (lua_State *L);
102 | LUAI_FUNC void luaC_step (lua_State *L);
103 | LUAI_FUNC void luaC_fullgc (lua_State *L);
104 | LUAI_FUNC void luaC_link (lua_State *L, GCObject *o, lu_byte tt);
105 | LUAI_FUNC void luaC_linkupval (lua_State *L, UpVal *uv);
106 | LUAI_FUNC void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v);
107 | LUAI_FUNC void luaC_barrierback (lua_State *L, Table *t);
108 | 
109 | 
110 | #endif
111 | 


--------------------------------------------------------------------------------
/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 |     lua_pushcfunction(L, lib->func);
34 |     lua_pushstring(L, lib->name);
35 |     lua_call(L, 1, 0);
36 |   }
37 | }
38 | 
39 | 


--------------------------------------------------------------------------------
/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 | 
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 <limits.h>
 12 | #include <stddef.h>
 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 <stdlib.h>
  9 | #include <math.h>
 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 <stddef.h>
 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 <stddef.h>
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 <ctype.h>
  8 | #include <stdarg.h>
  9 | #include <stdio.h>
 10 | #include <stdlib.h>
 11 | #include <string.h>
 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 <stdarg.h>
 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 | 
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 | typedef struct Proto {
232 |   CommonHeader;
233 |   TValue *k;  /* constants used by the function */
234 |   Instruction *code;
235 |   struct Proto **p;  /* functions defined inside the function */
236 |   int *lineinfo;  /* map from opcodes to source lines */
237 |   struct LocVar *locvars;  /* information about local variables */
238 |   TString **upvalues;  /* upvalue names */
239 |   TString  *source;
240 |   int sizeupvalues;
241 |   int sizek;  /* size of `k' */
242 |   int sizecode;
243 |   int sizelineinfo;
244 |   int sizep;  /* size of `p' */
245 |   int sizelocvars;
246 |   int linedefined;
247 |   int lastlinedefined;
248 |   GCObject *gclist;
249 |   lu_byte nups;  /* number of upvalues */
250 |   lu_byte numparams;
251 |   lu_byte is_vararg;
252 |   lu_byte maxstacksize;
253 | } Proto;
254 | 
255 | 
256 | /* masks for new-style vararg */
257 | #define VARARG_HASARG		1
258 | #define VARARG_ISVARARG		2
259 | #define VARARG_NEEDSARG		4
260 | 
261 | 
262 | typedef struct LocVar {
263 |   TString *varname;
264 |   int startpc;  /* first point where variable is active */
265 |   int endpc;    /* first point where variable is dead */
266 | } LocVar;
267 | 
268 | 
269 | 
270 | /*
271 | ** Upvalues
272 | */
273 | 
274 | typedef struct UpVal {
275 |   CommonHeader;
276 |   TValue *v;  /* points to stack or to its own value */
277 |   union {
278 |     TValue value;  /* the value (when closed) */
279 |     struct {  /* double linked list (when open) */
280 |       struct UpVal *prev;
281 |       struct UpVal *next;
282 |     } l;
283 |   } u;
284 | } UpVal;
285 | 
286 | 
287 | /*
288 | ** Closures
289 | */
290 | 
291 | #define ClosureHeader \
292 | 	CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \
293 | 	struct Table *env
294 | 
295 | typedef struct CClosure {
296 |   ClosureHeader;
297 |   lua_CFunction f;
298 |   TValue upvalue[1];
299 | } CClosure;
300 | 
301 | 
302 | typedef struct LClosure {
303 |   ClosureHeader;
304 |   struct Proto *p;
305 |   UpVal *upvals[1];
306 | } LClosure;
307 | 
308 | 
309 | typedef union Closure {
310 |   CClosure c;
311 |   LClosure l;
312 | } Closure;
313 | 
314 | 
315 | #define iscfunction(o)	(ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC)
316 | #define isLfunction(o)	(ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC)
317 | 
318 | 
319 | /*
320 | ** Tables
321 | */
322 | 
323 | typedef union TKey {
324 |   struct {
325 |     TValuefields;
326 |     struct Node *next;  /* for chaining */
327 |   } nk;
328 |   TValue tvk;
329 | } TKey;
330 | 
331 | 
332 | typedef struct Node {
333 |   TValue i_val;
334 |   TKey i_key;
335 | } Node;
336 | 
337 | 
338 | typedef struct Table {
339 |   CommonHeader;
340 |   lu_byte flags;  /* 1<<p means tagmethod(p) is not present */ 
341 |   lu_byte lsizenode;  /* log2 of size of `node' array */
342 |   struct Table *metatable;
343 |   TValue *array;  /* array part */
344 |   Node *node;
345 |   Node *lastfree;  /* any free position is before this position */
346 |   GCObject *gclist;
347 |   int sizearray;  /* size of `array' array */
348 | } Table;
349 | 
350 | 
351 | 
352 | /*
353 | ** `module' operation for hashing (size is always a power of 2)
354 | */
355 | #define lmod(s,size) \
356 | 	(check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1)))))
357 | 
358 | 
359 | #define twoto(x)	(1<<(x))
360 | #define sizenode(t)	(twoto((t)->lsizenode))
361 | 
362 | 
363 | #define luaO_nilobject		(&luaO_nilobject_)
364 | 
365 | LUAI_DATA const TValue luaO_nilobject_;
366 | 
367 | #define ceillog2(x)	(luaO_log2((x)-1) + 1)
368 | 
369 | LUAI_FUNC int luaO_log2 (unsigned int x);
370 | LUAI_FUNC int luaO_int2fb (unsigned int x);
371 | LUAI_FUNC int luaO_fb2int (int x);
372 | LUAI_FUNC int luaO_rawequalObj (const TValue *t1, const TValue *t2);
373 | LUAI_FUNC int luaO_str2d (const char *s, lua_Number *result);
374 | LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
375 |                                                        va_list argp);
376 | LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
377 | LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len);
378 | 
379 | 
380 | #endif
381 | 
382 | 


--------------------------------------------------------------------------------
/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 | const lu_byte luaP_opmodes[NUM_OPCODES] = {
 62 | /*       T  A    B       C     mode		   opcode	*/
 63 |   opmode(0, 1, OpArgR, OpArgN, iABC) 		/* OP_MOVE */
 64 |  ,opmode(0, 1, OpArgK, OpArgN, iABx)		/* OP_LOADK */
 65 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_LOADBOOL */
 66 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LOADNIL */
 67 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_GETUPVAL */
 68 |  ,opmode(0, 1, OpArgK, OpArgN, iABx)		/* OP_GETGLOBAL */
 69 |  ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_GETTABLE */
 70 |  ,opmode(0, 0, OpArgK, OpArgN, iABx)		/* OP_SETGLOBAL */
 71 |  ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_SETUPVAL */
 72 |  ,opmode(0, 0, OpArgK, OpArgK, iABC)		/* OP_SETTABLE */
 73 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_NEWTABLE */
 74 |  ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_SELF */
 75 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_ADD */
 76 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SUB */
 77 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MUL */
 78 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_DIV */
 79 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MOD */
 80 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_POW */
 81 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_UNM */
 82 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_NOT */
 83 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LEN */
 84 |  ,opmode(0, 1, OpArgR, OpArgR, iABC)		/* OP_CONCAT */
 85 |  ,opmode(0, 0, OpArgR, OpArgN, iAsBx)		/* OP_JMP */
 86 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_EQ */
 87 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LT */
 88 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LE */
 89 |  ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TEST */
 90 |  ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TESTSET */
 91 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_CALL */
 92 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_TAILCALL */
 93 |  ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_RETURN */
 94 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORLOOP */
 95 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORPREP */
 96 |  ,opmode(1, 0, OpArgN, OpArgU, iABC)		/* OP_TFORLOOP */
 97 |  ,opmode(0, 0, OpArgU, OpArgU, iABC)		/* OP_SETLIST */
 98 |  ,opmode(0, 0, OpArgN, OpArgN, iABC)		/* OP_CLOSE */
 99 |  ,opmode(0, 1, OpArgU, OpArgN, iABx)		/* OP_CLOSURE */
100 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_VARARG */
101 | };
102 | 
103 | 


--------------------------------------------------------------------------------
/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<<SIZE_Bx)-1)
 58 | #define MAXARG_sBx        (MAXARG_Bx>>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<<SIZE_A)-1)
 66 | #define MAXARG_B        ((1<<SIZE_B)-1)
 67 | #define MAXARG_C        ((1<<SIZE_C)-1)
 68 | 
 69 | 
 70 | /* creates a mask with `n' 1 bits at position `p' */
 71 | #define MASK1(n,p)	((~((~(Instruction)0)<<n))<<p)
 72 | 
 73 | /* creates a mask with `n' 0 bits at position `p' */
 74 | #define MASK0(n,p)	(~MASK1(n,p))
 75 | 
 76 | /*
 77 | ** the following macros help to manipulate instructions
 78 | */
 79 | 
 80 | #define GET_OPCODE(i)	(cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
 81 | #define SET_OPCODE(i,o)	((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
 82 | 		((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
 83 | 
 84 | #define GETARG_A(i)	(cast(int, ((i)>>POS_A) & MASK1(SIZE_A,0)))
 85 | #define SETARG_A(i,u)	((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
 86 | 		((cast(Instruction, u)<<POS_A)&MASK1(SIZE_A,POS_A))))
 87 | 
 88 | #define GETARG_B(i)	(cast(int, ((i)>>POS_B) & MASK1(SIZE_B,0)))
 89 | #define SETARG_B(i,b)	((i) = (((i)&MASK0(SIZE_B,POS_B)) | \
 90 | 		((cast(Instruction, b)<<POS_B)&MASK1(SIZE_B,POS_B))))
 91 | 
 92 | #define GETARG_C(i)	(cast(int, ((i)>>POS_C) & MASK1(SIZE_C,0)))
 93 | #define SETARG_C(i,b)	((i) = (((i)&MASK0(SIZE_C,POS_C)) | \
 94 | 		((cast(Instruction, b)<<POS_C)&MASK1(SIZE_C,POS_C))))
 95 | 
 96 | #define GETARG_Bx(i)	(cast(int, ((i)>>POS_Bx) & MASK1(SIZE_Bx,0)))
 97 | #define SETARG_Bx(i,b)	((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \
 98 | 		((cast(Instruction, b)<<POS_Bx)&MASK1(SIZE_Bx,POS_Bx))))
 99 | 
100 | #define GETARG_sBx(i)	(GETARG_Bx(i)-MAXARG_sBx)
101 | #define SETARG_sBx(i,b)	SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
102 | 
103 | 
104 | #define CREATE_ABC(o,a,b,c)	((cast(Instruction, o)<<POS_OP) \
105 | 			| (cast(Instruction, a)<<POS_A) \
106 | 			| (cast(Instruction, b)<<POS_B) \
107 | 			| (cast(Instruction, c)<<POS_C))
108 | 
109 | #define CREATE_ABx(o,a,bc)	((cast(Instruction, o)<<POS_OP) \
110 | 			| (cast(Instruction, a)<<POS_A) \
111 | 			| (cast(Instruction, bc)<<POS_Bx))
112 | 
113 | 
114 | /*
115 | ** Macros to operate RK indices
116 | */
117 | 
118 | /* this bit 1 means constant (0 means register) */
119 | #define BITRK		(1 << (SIZE_B - 1))
120 | 
121 | /* test whether value is a constant */
122 | #define ISK(x)		((x) & BITRK)
123 | 
124 | /* gets the index of the constant */
125 | #define INDEXK(r)	((int)(r) & ~BITRK)
126 | 
127 | #define MAXINDEXRK	(BITRK - 1)
128 | 
129 | /* code a constant index as a RK value */
130 | #define RKASK(x)	((x) | BITRK)
131 | 
132 | 
133 | /*
134 | ** invalid register that fits in 8 bits
135 | */
136 | #define NO_REG		MAXARG_A
137 | 
138 | 
139 | /*
140 | ** R(x) - register
141 | ** Kst(x) - constant (in constant table)
142 | ** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
143 | */
144 | 
145 | 
146 | /*
147 | ** grep "ORDER OP" if you change these enums
148 | */
149 | 
150 | typedef enum {
151 | /*----------------------------------------------------------------------
152 | name		args	description
153 | ------------------------------------------------------------------------*/
154 | OP_MOVE,/*	A B	R(A) := R(B)					*/
155 | OP_LOADK,/*	A Bx	R(A) := Kst(Bx)					*/
156 | OP_LOADBOOL,/*	A B C	R(A) := (Bool)B; if (C) pc++			*/
157 | OP_LOADNIL,/*	A B	R(A) := ... := R(B) := nil			*/
158 | OP_GETUPVAL,/*	A B	R(A) := UpValue[B]				*/
159 | 
160 | OP_GETGLOBAL,/*	A Bx	R(A) := Gbl[Kst(Bx)]				*/
161 | OP_GETTABLE,/*	A B C	R(A) := R(B)[RK(C)]				*/
162 | 
163 | OP_SETGLOBAL,/*	A Bx	Gbl[Kst(Bx)] := R(A)				*/
164 | OP_SETUPVAL,/*	A B	UpValue[B] := R(A)				*/
165 | OP_SETTABLE,/*	A B C	R(A)[RK(B)] := RK(C)				*/
166 | 
167 | OP_NEWTABLE,/*	A B C	R(A) := {} (size = B,C)				*/
168 | 
169 | OP_SELF,/*	A B C	R(A+1) := R(B); R(A) := R(B)[RK(C)]		*/
170 | 
171 | OP_ADD,/*	A B C	R(A) := RK(B) + RK(C)				*/
172 | OP_SUB,/*	A B C	R(A) := RK(B) - RK(C)				*/
173 | OP_MUL,/*	A B C	R(A) := RK(B) * RK(C)				*/
174 | OP_DIV,/*	A B C	R(A) := RK(B) / RK(C)				*/
175 | OP_MOD,/*	A B C	R(A) := RK(B) % RK(C)				*/
176 | OP_POW,/*	A B C	R(A) := RK(B) ^ RK(C)				*/
177 | OP_UNM,/*	A B	R(A) := -R(B)					*/
178 | OP_NOT,/*	A B	R(A) := not R(B)				*/
179 | OP_LEN,/*	A B	R(A) := length of R(B)				*/
180 | 
181 | OP_CONCAT,/*	A B C	R(A) := R(B).. ... ..R(C)			*/
182 | 
183 | OP_JMP,/*	sBx	pc+=sBx					*/
184 | 
185 | OP_EQ,/*	A B C	if ((RK(B) == RK(C)) ~= A) then pc++		*/
186 | OP_LT,/*	A B C	if ((RK(B) <  RK(C)) ~= A) then pc++  		*/
187 | OP_LE,/*	A B C	if ((RK(B) <= RK(C)) ~= A) then pc++  		*/
188 | 
189 | OP_TEST,/*	A C	if not (R(A) <=> 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+1) then { pc+=sBx; R(A+3)=R(A) }*/
198 | OP_FORPREP,/*	A sBx	R(A)-=R(A+2); pc+=sBx				*/
199 | 
200 | OP_TFORLOOP,/*	A C	R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2)); 
201 |                         if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++	*/ 
202 | OP_SETLIST,/*	A B C	R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B	*/
203 | 
204 | OP_CLOSE,/*	A 	close all variables in the stack up to (>=) 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 <errno.h>
  9 | #include <locale.h>
 10 | #include <stdlib.h>
 11 | #include <string.h>
 12 | #include <time.h>
 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 | typedef struct expdesc {
38 |   expkind k;
39 |   union {
40 |     struct { int info, aux; } s;
41 |     lua_Number nval;
42 |   } u;
43 |   int t;  /* patch list of `exit when true' */
44 |   int f;  /* patch list of `exit when false' */
45 | } expdesc;
46 | 
47 | 
48 | typedef struct upvaldesc {
49 |   lu_byte k;
50 |   lu_byte info;
51 | } upvaldesc;
52 | 
53 | 
54 | struct BlockCnt;  /* defined in lparser.c */
55 | 
56 | 
57 | /* state needed to generate code for a given function */
58 | typedef struct FuncState {
59 |   Proto *f;  /* current function header */
60 |   Table *h;  /* table to find (and reuse) elements in `k' */
61 |   struct FuncState *prev;  /* enclosing function */
62 |   struct LexState *ls;  /* lexical state */
63 |   struct lua_State *L;  /* copy of the Lua state */
64 |   struct BlockCnt *bl;  /* chain of current blocks */
65 |   int pc;  /* next position to code (equivalent to `ncode') */
66 |   int lasttarget;   /* `pc' of last `jump target' */
67 |   int jpc;  /* list of pending jumps to `pc' */
68 |   int freereg;  /* first free register */
69 |   int nk;  /* number of elements in `k' */
70 |   int np;  /* number of elements in `p' */
71 |   short nlocvars;  /* number of elements in `locvars' */
72 |   lu_byte nactvar;  /* number of active local variables */
73 |   upvaldesc upvalues[LUAI_MAXUPVALUES];  /* upvalues */
74 |   unsigned short actvar[LUAI_MAXVARS];  /* declared-variable stack */
75 | } FuncState;
76 | 
77 | 
78 | LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
79 |                                             const char *name);
80 | 
81 | 
82 | #endif
83 | 


--------------------------------------------------------------------------------
/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 <stddef.h>
  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 |   L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);
 45 |   L1->ci = L1->base_ci;
 46 |   L1->size_ci = BASIC_CI_SIZE;
 47 |   L1->end_ci = L1->base_ci + L1->size_ci - 1;
 48 |   /* initialize stack array */
 49 |   L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue);
 50 |   L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;
 51 |   L1->top = L1->stack;
 52 |   L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
 53 |   /* initialize first ci */
 54 |   L1->ci->func = L1->top;
 55 |   setnilvalue(L1->top++);  /* `function' entry for this `ci' */
 56 |   L1->base = L1->ci->base = L1->top;
 57 |   L1->ci->top = L1->top + LUA_MINSTACK;
 58 | }
 59 | 
 60 | 
 61 | static void freestack (lua_State *L, lua_State *L1) {
 62 |   luaM_freearray(L, L1->base_ci, L1->size_ci, CallInfo);
 63 |   luaM_freearray(L, L1->stack, L1->stacksize, TValue);
 64 | }
 65 | 
 66 | 
 67 | /*
 68 | ** open parts that may cause memory-allocation errors
 69 | */
 70 | static void f_luaopen (lua_State *L, void *ud) {
 71 |   global_State *g = G(L);
 72 |   UNUSED(ud);
 73 |   stack_init(L, L);  /* init stack */
 74 |   sethvalue(L, gt(L), luaH_new(L, 0, 2));  /* table of globals */
 75 |   sethvalue(L, registry(L), luaH_new(L, 0, 2));  /* registry */
 76 |   luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
 77 |   luaT_init(L);
 78 |   luaX_init(L);
 79 |   luaS_fix(luaS_newliteral(L, MEMERRMSG));
 80 |   g->GCthreshold = 4*g->totalbytes;
 81 | }
 82 | 
 83 | 
 84 | static void preinit_state (lua_State *L, global_State *g) {
 85 |   G(L) = g;
 86 |   L->stack = NULL;
 87 |   L->stacksize = 0;
 88 |   L->errorJmp = NULL;
 89 |   L->hook = NULL;
 90 |   L->hookmask = 0;
 91 |   L->basehookcount = 0;
 92 |   L->allowhook = 1;
 93 |   resethookcount(L);
 94 |   L->openupval = NULL;
 95 |   L->size_ci = 0;
 96 |   L->nCcalls = L->baseCcalls = 0;
 97 |   L->status = 0;
 98 |   L->base_ci = L->ci = NULL;
 99 |   L->savedpc = NULL;
100 |   L->errfunc = 0;
101 |   setnilvalue(gt(L));
102 | }
103 | 
104 | 
105 | static void close_state (lua_State *L) {
106 |   global_State *g = G(L);
107 |   luaF_close(L, L->stack);  /* close all upvalues for this thread */
108 |   luaC_freeall(L);  /* collect all objects */
109 |   lua_assert(g->rootgc == obj2gco(L));
110 |   lua_assert(g->strt.nuse == 0);
111 |   luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
112 |   luaZ_freebuffer(L, &g->buff);
113 |   freestack(L, L);
114 |   lua_assert(g->totalbytes == sizeof(LG));
115 |   (*g->frealloc)(g->ud, fromstate(L), state_size(LG), 0);
116 | }
117 | 
118 | 
119 | lua_State *luaE_newthread (lua_State *L) {
120 |   lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));
121 |   luaC_link(L, obj2gco(L1), LUA_TTHREAD);
122 |   preinit_state(L1, G(L));
123 |   stack_init(L1, L);  /* init stack */
124 |   setobj2n(L, gt(L1), gt(L));  /* share table of globals */
125 |   L1->hookmask = L->hookmask;
126 |   L1->basehookcount = L->basehookcount;
127 |   L1->hook = L->hook;
128 |   resethookcount(L1);
129 |   lua_assert(iswhite(obj2gco(L1)));
130 |   return L1;
131 | }
132 | 
133 | 
134 | void luaE_freethread (lua_State *L, lua_State *L1) {
135 |   luaF_close(L1, L1->stack);  /* close all upvalues for this thread */
136 |   lua_assert(L1->openupval == NULL);
137 |   luai_userstatefree(L1);
138 |   freestack(L, L1);
139 |   luaM_freemem(L, fromstate(L1), state_size(lua_State));
140 | }
141 | 
142 | 
143 | LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
144 |   int i;
145 |   lua_State *L;
146 |   global_State *g;
147 |   void *l = (*f)(ud, NULL, 0, state_size(LG));
148 |   if (l == NULL) return NULL;
149 |   L = tostate(l);
150 |   g = &((LG *)L)->g;
151 |   L->next = NULL;
152 |   L->tt = LUA_TTHREAD;
153 |   g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
154 |   L->marked = luaC_white(g);
155 |   set2bits(L->marked, FIXEDBIT, SFIXEDBIT);
156 |   preinit_state(L, g);
157 |   g->frealloc = f;
158 |   g->ud = ud;
159 |   g->mainthread = L;
160 |   g->uvhead.u.l.prev = &g->uvhead;
161 |   g->uvhead.u.l.next = &g->uvhead;
162 |   g->GCthreshold = 0;  /* mark it as unfinished state */
163 |   g->strt.size = 0;
164 |   g->strt.nuse = 0;
165 |   g->strt.hash = NULL;
166 |   setnilvalue(registry(L));
167 |   luaZ_initbuffer(L, &g->buff);
168 |   g->panic = NULL;
169 |   g->gcstate = GCSpause;
170 |   g->rootgc = obj2gco(L);
171 |   g->sweepstrgc = 0;
172 |   g->sweepgc = &g->rootgc;
173 |   g->gray = NULL;
174 |   g->grayagain = NULL;
175 |   g->weak = NULL;
176 |   g->tmudata = NULL;
177 |   g->totalbytes = sizeof(LG);
178 |   g->gcpause = LUAI_GCPAUSE;
179 |   g->gcstepmul = LUAI_GCMUL;
180 |   g->gcdept = 0;
181 |   for (i=0; i<NUM_TAGS; i++) g->mt[i] = NULL;
182 |   if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
183 |     /* memory allocation error: free partial state */
184 |     close_state(L);
185 |     L = NULL;
186 |   }
187 |   else
188 |     luai_userstateopen(L);
189 |   return L;
190 | }
191 | 
192 | 
193 | static void callallgcTM (lua_State *L, void *ud) {
194 |   UNUSED(ud);
195 |   luaC_callGCTM(L);  /* call GC metamethods for all udata */
196 | }
197 | 
198 | 
199 | LUA_API void lua_close (lua_State *L) {
200 |   L = G(L)->mainthread;  /* only the main thread can be closed */
201 |   lua_lock(L);
202 |   luaF_close(L, L->stack);  /* close all upvalues for this thread */
203 |   luaC_separateudata(L, 1);  /* separate udata that have GC metamethods */
204 |   L->errfunc = 0;  /* no error function during GC metamethods */
205 |   do {  /* repeat until no more errors */
206 |     L->ci = L->base_ci;
207 |     L->base = L->top = L->ci->base;
208 |     L->nCcalls = L->baseCcalls = 0;
209 |   } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0);
210 |   lua_assert(G(L)->tmudata == NULL);
211 |   luai_userstateclose(L);
212 |   close_state(L);
213 | }
214 | 
215 | 


--------------------------------------------------------------------------------
/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;
 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 |   GCObject *tmudata;  /* last element of list of userdata to be GC */
 81 |   Mbuffer buff;  /* temporary buffer for string concatentation */
 82 |   lu_mem GCthreshold;
 83 |   lu_mem totalbytes;  /* number of bytes currently allocated */
 84 |   lu_mem estimate;  /* an estimate of number of bytes actually in use */
 85 |   lu_mem gcdept;  /* how much GC is `behind schedule' */
 86 |   int gcpause;  /* size of pause between successive GCs */
 87 |   int gcstepmul;  /* GC `granularity' */
 88 |   lua_CFunction panic;  /* to be called in unprotected errors */
 89 |   TValue l_registry;
 90 |   struct lua_State *mainthread;
 91 |   UpVal uvhead;  /* head of double-linked list of all open upvalues */
 92 |   struct Table *mt[NUM_TAGS];  /* metatables for basic types */
 93 |   TString *tmname[TM_N];  /* array with tag-method names */
 94 | } global_State;
 95 | 
 96 | 
 97 | /*
 98 | ** `per thread' state
 99 | */
100 | struct lua_State {
101 |   CommonHeader;
102 |   lu_byte status;
103 |   StkId top;  /* first free slot in the stack */
104 |   StkId base;  /* base of current function */
105 |   global_State *l_G;
106 |   CallInfo *ci;  /* call info for current function */
107 |   const Instruction *savedpc;  /* `savedpc' of current function */
108 |   StkId stack_last;  /* last free slot in the stack */
109 |   StkId stack;  /* stack base */
110 |   CallInfo *end_ci;  /* points after end of ci array*/
111 |   CallInfo *base_ci;  /* array of CallInfo's */
112 |   int stacksize;
113 |   int size_ci;  /* size of array `base_ci' */
114 |   unsigned short nCcalls;  /* number of nested C calls */
115 |   unsigned short baseCcalls;  /* nested C calls when resuming coroutine */
116 |   lu_byte hookmask;
117 |   lu_byte allowhook;
118 |   int basehookcount;
119 |   int hookcount;
120 |   lua_Hook hook;
121 |   TValue l_gt;  /* table of globals */
122 |   TValue env;  /* temporary place for environments */
123 |   GCObject *openupval;  /* list of open upvalues in this stack */
124 |   GCObject *gclist;
125 |   struct lua_longjmp *errorJmp;  /* current error recover point */
126 |   ptrdiff_t errfunc;  /* current error handling function (stack index) */
127 | };
128 | 
129 | 
130 | #define G(L)	(L->l_G)
131 | 
132 | 
133 | /*
134 | ** Union of all collectable objects
135 | */
136 | union GCObject {
137 |   GCheader gch;
138 |   union TString ts;
139 |   union Udata u;
140 |   union Closure cl;
141 |   struct Table h;
142 |   struct Proto p;
143 |   struct UpVal uv;
144 |   struct lua_State th;  /* thread */
145 | };
146 | 
147 | 
148 | /* macros to convert a GCObject into a specific value */
149 | #define rawgco2ts(o)	check_exp((o)->gch.tt == LUA_TSTRING, &((o)->ts))
150 | #define gco2ts(o)	(&rawgco2ts(o)->tsv)
151 | #define rawgco2u(o)	check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u))
152 | #define gco2u(o)	(&rawgco2u(o)->uv)
153 | #define gco2cl(o)	check_exp((o)->gch.tt == LUA_TFUNCTION, &((o)->cl))
154 | #define gco2h(o)	check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))
155 | #define gco2p(o)	check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))
156 | #define gco2uv(o)	check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv))
157 | #define ngcotouv(o) \
158 | 	check_exp((o) == NULL || (o)->gch.tt == LUA_TUPVAL, &((o)->uv))
159 | #define gco2th(o)	check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
160 | 
161 | /* macro to convert any Lua object into a GCObject */
162 | #define obj2gco(v)	(cast(GCObject *, (v)))
163 | 
164 | 
165 | LUAI_FUNC lua_State *luaE_newthread (lua_State *L);
166 | LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
167 | 
168 | #endif
169 | 
170 | 


--------------------------------------------------------------------------------
/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 <string.h>
  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 | 
 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; i<newsize; i++) newhash[i] = NULL;
 31 |   /* rehash */
 32 |   for (i=0; i<tb->size; 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 |       int h1 = lmod(h, newsize);  /* new position */
 38 |       lua_assert(cast_int(h%newsize) == lmod(h, newsize));
 39 |       p->gch.next = newhash[h1];  /* chain it */
 40 |       newhash[h1] = p;
 41 |       p = next;
 42 |     }
 43 |   }
 44 |   luaM_freearray(L, tb->hash, tb->size, TString *);
 45 |   tb->size = newsize;
 46 |   tb->hash = newhash;
 47 | }
 48 | 
 49 | 
 50 | static TString *newlstr (lua_State *L, const char *str, size_t l,
 51 |                                        unsigned int h) {
 52 |   TString *ts;
 53 |   stringtable *tb;
 54 |   if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
 55 |     luaM_toobig(L);
 56 |   ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
 57 |   ts->tsv.len = l;
 58 |   ts->tsv.hash = h;
 59 |   ts->tsv.marked = luaC_white(G(L));
 60 |   ts->tsv.tt = LUA_TSTRING;
 61 |   ts->tsv.reserved = 0;
 62 |   memcpy(ts+1, str, l*sizeof(char));
 63 |   ((char *)(ts+1))[l] = '\0';  /* ending 0 */
 64 |   tb = &G(L)->strt;
 65 |   h = lmod(h, tb->size);
 66 |   ts->tsv.next = tb->hash[h];  /* chain new entry */
 67 |   tb->hash[h] = obj2gco(ts);
 68 |   tb->nuse++;
 69 |   if (tb->nuse > cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
 70 |     luaS_resize(L, tb->size*2);  /* too crowded */
 71 |   return ts;
 72 | }
 73 | 
 74 | 
 75 | TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
 76 |   GCObject *o;
 77 |   unsigned int h = cast(unsigned int, l);  /* seed */
 78 |   size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
 79 |   size_t l1;
 80 |   for (l1=l; l1>=step; l1-=step)  /* compute hash */
 81 |     h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
 82 |   for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
 83 |        o != NULL;
 84 |        o = o->gch.next) {
 85 |     TString *ts = rawgco2ts(o);
 86 |     if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) {
 87 |       /* string may be dead */
 88 |       if (isdead(G(L), o)) changewhite(o);
 89 |       return ts;
 90 |     }
 91 |   }
 92 |   return newlstr(L, str, l, h);  /* not found */
 93 | }
 94 | 
 95 | 
 96 | Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
 97 |   Udata *u;
 98 |   if (s > MAX_SIZET - sizeof(Udata))
 99 |     luaM_toobig(L);
100 |   u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));
101 |   u->uv.marked = luaC_white(G(L));  /* is not finalized */
102 |   u->uv.tt = LUA_TUSERDATA;
103 |   u->uv.len = s;
104 |   u->uv.metatable = NULL;
105 |   u->uv.env = e;
106 |   /* chain it on udata list (after main thread) */
107 |   u->uv.next = G(L)->mainthread->next;
108 |   G(L)->mainthread->next = obj2gco(u);
109 |   return u;
110 | }
111 | 
112 | 


--------------------------------------------------------------------------------
/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 | #define luaS_fix(s)	l_setbit((s)->tsv.marked, FIXEDBIT)
25 | 
26 | LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
27 | LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e);
28 | LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
29 | 
30 | 
31 | #endif
32 | 


--------------------------------------------------------------------------------
/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 <stddef.h>
  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<e; pos++) {
126 |     lua_rawgeti(L, 1, pos+1);
127 |     lua_rawseti(L, 1, pos);  /* t[pos] = t[pos+1] */
128 |   }
129 |   lua_pushnil(L);
130 |   lua_rawseti(L, 1, e);  /* t[e] = nil */
131 |   return 1;
132 | }
133 | 
134 | 
135 | static void addfield (lua_State *L, luaL_Buffer *b, int i) {
136 |   lua_rawgeti(L, 1, i);
137 |   if (!lua_isstring(L, -1))
138 |     luaL_error(L, "invalid value (%s) at index %d in table for "
139 |                   LUA_QL("concat"), luaL_typename(L, -1), i);
140 |     luaL_addvalue(b);
141 | }
142 | 
143 | 
144 | static int tconcat (lua_State *L) {
145 |   luaL_Buffer b;
146 |   size_t lsep;
147 |   int i, last;
148 |   const char *sep = luaL_optlstring(L, 2, "", &lsep);
149 |   luaL_checktype(L, 1, LUA_TTABLE);
150 |   i = luaL_optint(L, 3, 1);
151 |   last = luaL_opt(L, luaL_checkint, 4, luaL_getn(L, 1));
152 |   luaL_buffinit(L, &b);
153 |   for (; i < last; i++) {
154 |     addfield(L, &b, i);
155 |     luaL_addlstring(&b, sep, lsep);
156 |   }
157 |   if (i == last)  /* add last value (if interval was not empty) */
158 |     addfield(L, &b, i);
159 |   luaL_pushresult(&b);
160 |   return 1;
161 | }
162 | 
163 | 
164 | 
165 | /*
166 | ** {======================================================
167 | ** Quicksort
168 | ** (based on `Algorithms in MODULA-3', Robert Sedgewick;
169 | **  Addison-Wesley, 1993.)
170 | */
171 | 
172 | 
173 | static void set2 (lua_State *L, int i, int j) {
174 |   lua_rawseti(L, 1, i);
175 |   lua_rawseti(L, 1, j);
176 | }
177 | 
178 | static int sort_comp (lua_State *L, int a, int b) {
179 |   if (!lua_isnil(L, 2)) {  /* function? */
180 |     int res;
181 |     lua_pushvalue(L, 2);
182 |     lua_pushvalue(L, a-1);  /* -1 to compensate function */
183 |     lua_pushvalue(L, b-2);  /* -2 to compensate function and `a' */
184 |     lua_call(L, 2, 1);
185 |     res = lua_toboolean(L, -1);
186 |     lua_pop(L, 1);
187 |     return res;
188 |   }
189 |   else  /* a < b? */
190 |     return lua_lessthan(L, a, b);
191 | }
192 | 
193 | static void auxsort (lua_State *L, int l, int u) {
194 |   while (l < u) {  /* for tail recursion */
195 |     int i, j;
196 |     /* sort elements a[l], a[(l+u)/2] and a[u] */
197 |     lua_rawgeti(L, 1, l);
198 |     lua_rawgeti(L, 1, u);
199 |     if (sort_comp(L, -1, -2))  /* a[u] < a[l]? */
200 |       set2(L, l, u);  /* swap a[l] - a[u] */
201 |     else
202 |       lua_pop(L, 2);
203 |     if (u-l == 1) break;  /* only 2 elements */
204 |     i = (l+u)/2;
205 |     lua_rawgeti(L, 1, i);
206 |     lua_rawgeti(L, 1, l);
207 |     if (sort_comp(L, -2, -1))  /* a[i]<a[l]? */
208 |       set2(L, i, l);
209 |     else {
210 |       lua_pop(L, 1);  /* remove a[l] */
211 |       lua_rawgeti(L, 1, u);
212 |       if (sort_comp(L, -1, -2))  /* a[u]<a[i]? */
213 |         set2(L, i, u);
214 |       else
215 |         lua_pop(L, 2);
216 |     }
217 |     if (u-l == 2) break;  /* only 3 elements */
218 |     lua_rawgeti(L, 1, i);  /* Pivot */
219 |     lua_pushvalue(L, -1);
220 |     lua_rawgeti(L, 1, u-1);
221 |     set2(L, i, u-1);
222 |     /* a[l] <= P == a[u-1] <= a[u], only need to sort from l+1 to u-2 */
223 |     i = l; j = u-1;
224 |     for (;;) {  /* invariant: a[l..i] <= P <= a[j..u] */
225 |       /* repeat ++i until a[i] >= 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<l) luaL_error(L, "invalid order function for sorting");
233 |         lua_pop(L, 1);  /* remove a[j] */
234 |       }
235 |       if (j<i) {
236 |         lua_pop(L, 3);  /* pop pivot, a[i], a[j] */
237 |         break;
238 |       }
239 |       set2(L, i, j);
240 |     }
241 |     lua_rawgeti(L, 1, u-1);
242 |     lua_rawgeti(L, 1, i);
243 |     set2(L, u-1, i);  /* swap pivot (a[u-1]) with a[i] */
244 |     /* a[l..i-1] <= a[i] == P <= a[i+1..u] */
245 |     /* adjust so that smaller half is in [j..i] and larger one in [l..u] */
246 |     if (i-l < u-i) {
247 |       j=l; i=i-1; l=i+2;
248 |     }
249 |     else {
250 |       j=i+1; i=u; u=j-2;
251 |     }
252 |     auxsort(L, j, i);  /* call recursively the smaller one */
253 |   }  /* repeat the routine for the larger one */
254 | }
255 | 
256 | static int sort (lua_State *L) {
257 |   int n = aux_getn(L, 1);
258 |   luaL_checkstack(L, 40, "");  /* assume array is smaller than 2^40 */
259 |   if (!lua_isnoneornil(L, 2))  /* is there a 2nd argument? */
260 |     luaL_checktype(L, 2, LUA_TFUNCTION);
261 |   lua_settop(L, 2);  /* make sure there is two arguments */
262 |   auxsort(L, 1, n);
263 |   return 0;
264 | }
265 | 
266 | /* }====================================================== */
267 | 
268 | 
269 | static const luaL_Reg tab_funcs[] = {
270 |   {"concat", tconcat},
271 |   {"foreach", foreach},
272 |   {"foreachi", foreachi},
273 |   {"getn", getn},
274 |   {"maxn", maxn},
275 |   {"insert", tinsert},
276 |   {"remove", tremove},
277 |   {"setn", setn},
278 |   {"sort", sort},
279 |   {NULL, NULL}
280 | };
281 | 
282 | 
283 | LUALIB_API int luaopen_table (lua_State *L) {
284 |   luaL_register(L, LUA_TABLIBNAME, tab_funcs);
285 |   return 1;
286 | }
287 | 
288 | 


--------------------------------------------------------------------------------
/src/ltm.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ltm.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
 3 | ** Tag methods
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #include <string.h>
 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 |   for (i=0; i<TM_N; i++) {
40 |     G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
41 |     luaS_fix(G(L)->tmname[i]);  /* never collect these names */
42 |   }
43 | }
44 | 
45 | 
46 | /*
47 | ** function to be used with macro "fasttm": optimized for absence of
48 | ** tag methods
49 | */
50 | const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
51 |   const TValue *tm = luaH_getstr(events, ename);
52 |   lua_assert(event <= TM_EQ);
53 |   if (ttisnil(tm)) {  /* no tag method? */
54 |     events->flags |= cast_byte(1u<<event);  /* cache this fact */
55 |     return NULL;
56 |   }
57 |   else return tm;
58 | }
59 | 
60 | 
61 | const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
62 |   Table *mt;
63 |   switch (ttype(o)) {
64 |     case LUA_TTABLE:
65 |       mt = hvalue(o)->metatable;
66 |       break;
67 |     case LUA_TUSERDATA:
68 |       mt = uvalue(o)->metatable;
69 |       break;
70 |     default:
71 |       mt = G(L)->mt[ttype(o)];
72 |   }
73 |   return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject);
74 | }
75 | 
76 | 


--------------------------------------------------------------------------------
/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 <errno.h>
  8 | #include <stdio.h>
  9 | #include <stdlib.h>
 10 | #include <string.h>
 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; i<argc; i++)
 76 |  {
 77 |   if (*argv[i]!='-')			/* end of options; keep it */
 78 |    break;
 79 |   else if (IS("--"))			/* end of options; skip it */
 80 |   {
 81 |    ++i;
 82 |    if (version) ++version;
 83 |    break;
 84 |   }
 85 |   else if (IS("-"))			/* end of options; use stdin */
 86 |    break;
 87 |   else if (IS("-l"))			/* list */
 88 |    ++listing;
 89 |   else if (IS("-o"))			/* output file */
 90 |   {
 91 |    output=argv[++i];
 92 |    if (output==NULL || *output==0) usage(LUA_QL("-o") " needs argument");
 93 |    if (IS("-")) output=NULL;
 94 |   }
 95 |   else if (IS("-p"))			/* parse only */
 96 |    dumping=0;
 97 |   else if (IS("-s"))			/* strip debug information */
 98 |    stripping=1;
 99 |   else if (IS("-v"))			/* show version */
100 |    ++version;
101 |   else					/* unknown option */
102 |    usage(argv[i]);
103 |  }
104 |  if (i==argc && (listing || !dumping))
105 |  {
106 |   dumping=0;
107 |   argv[--i]=Output;
108 |  }
109 |  if (version)
110 |  {
111 |   printf("%s  %s\n",LUA_RELEASE,LUA_COPYRIGHT);
112 |   if (version==argc-1) exit(EXIT_SUCCESS);
113 |  }
114 |  return i;
115 | }
116 | 
117 | #define toproto(L,i) (clvalue(L->top+(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; i<n; i++)
137 |   {
138 |    f->p[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; i<argc; i++)
167 |  {
168 |   const char* filename=IS("-") ? NULL : argv[i];
169 |   if (luaL_loadfile(L,filename)!=0) fatal(lua_tostring(L,-1));
170 |  }
171 |  f=combine(L,argc);
172 |  if (listing) luaU_print(f,listing>1);
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 <string.h>
  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; i<n; i++) setnilvalue(&f->k[i]);
107 |  for (i=0; i<n; i++)
108 |  {
109 |   TValue* o=&f->k[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; i<n; i++) f->p[i]=NULL;
134 |  for (i=0; i<n; i++) f->p[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; i<n; i++) f->locvars[i].varname=NULL;
148 |  for (i=0; i<n; i++)
149 |  {
150 |   f->locvars[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; i<n; i++) f->upvalues[i]=NULL;
158 |  for (i=0; i<n; i++) f->upvalues[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 <string.h>
 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 |     if (luaZ_fill(z) == EOZ)
38 |       return EOZ;
39 |     else {
40 |       z->n++;  /* luaZ_fill removed first byte; put back it */
41 |       z->p--;
42 |     }
43 |   }
44 |   return char2int(*z->p);
45 | }
46 | 
47 | 
48 | void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {
49 |   z->L = L;
50 |   z->reader = reader;
51 |   z->data = data;
52 |   z->n = 0;
53 |   z->p = NULL;
54 | }
55 | 
56 | 
57 | /* --------------------------------------------------------------- read --- */
58 | size_t luaZ_read (ZIO *z, void *b, size_t n) {
59 |   while (n) {
60 |     size_t m;
61 |     if (luaZ_lookahead(z) == EOZ)
62 |       return n;  /* return number of missing bytes */
63 |     m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
64 |     memcpy(b, z->p, m);
65 |     z->n -= m;
66 |     z->p += m;
67 |     b = (char *)b + m;
68 |     n -= m;
69 |   }
70 |   return 0;
71 | }
72 | 
73 | /* ------------------------------------------------------------------------ */
74 | char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) {
75 |   if (n > buff->buffsize) {
76 |     if (n < LUA_MINBUFFER) n = LUA_MINBUFFER;
77 |     luaZ_resizebuffer(L, buff, n);
78 |   }
79 |   return buff->buffer;
80 | }
81 | 
82 | 
83 | 


--------------------------------------------------------------------------------
/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 <ctype.h>
  8 | #include <stdio.h>
  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; i<n; i++)
 29 |  {
 30 |   int c=s[i];
 31 |   switch (c)
 32 |   {
 33 |    case '"': printf("\\\""); break;
 34 |    case '\\': printf("\\\\"); break;
 35 |    case '\a': printf("\\a"); break;
 36 |    case '\b': printf("\\b"); break;
 37 |    case '\f': printf("\\f"); break;
 38 |    case '\n': printf("\\n"); break;
 39 |    case '\r': printf("\\r"); break;
 40 |    case '\t': printf("\\t"); break;
 41 |    case '\v': printf("\\v"); break;
 42 |    default:	if (isprint((unsigned char)c))
 43 |    			putchar(c);
 44 | 		else
 45 | 			printf("\\%03u",(unsigned char)c);
 46 |   }
 47 |  }
 48 |  putchar('"');
 49 | }
 50 | 
 51 | static void PrintConstant(const Proto* f, int i)
 52 | {
 53 |  const TValue* o=&f->k[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; pc<n; pc++)
 79 |  {
 80 |   Instruction i=code[pc];
 81 |   OpCode o=GET_OPCODE(i);
 82 |   int a=GETARG_A(i);
 83 |   int b=GETARG_B(i);
 84 |   int c=GETARG_C(i);
 85 |   int bx=GETARG_Bx(i);
 86 |   int sbx=GETARG_sBx(i);
 87 |   int line=getline(f,pc);
 88 |   printf("\t%d\t",pc+1);
 89 |   if (line>0) 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; i<n; i++)
186 |  {
187 |   printf("\t%d\t",i+1);
188 |   PrintConstant(f,i);
189 |   printf("\n");
190 |  }
191 | }
192 | 
193 | static void PrintLocals(const Proto* f)
194 | {
195 |  int i,n=f->sizelocvars;
196 |  printf("locals (%d) for %p:\n",n,VOID(f));
197 |  for (i=0; i<n; i++)
198 |  {
199 |   printf("\t%d\t%s\t%d\t%d\n",
200 |   i,getstr(f->locvars[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; i<n; i++)
210 |  {
211 |   printf("\t%d\t%s\n",i,getstr(f->upvalues[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; i<n; i++) PrintFunction(f->p[i],full);
227 | }
228 | 


--------------------------------------------------------------------------------
/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)<delta then return c,b-a end
 9 |  n=n+1
10 |  local fc=f(c)
11 |  if fa*fc<0 then return bisect(f,a,c,fa,fc) else return bisect(f,c,b,fc,fb) end
12 | end
13 | 
14 | -- find root of f in the inverval [a,b]. needs f(a)*f(b)<0
15 | function solve(f,a,b)
16 |  n=0
17 |  local z,e=bisect(f,a,b,f(a),f(b))
18 |  io.write(string.format("after %d steps, root is %.17g with error %.1e, f=%.1e\n",n,z,e,f(z)))
19 | end
20 | 
21 | -- our function
22 | function f(x)
23 |  return x*x*x-x-1
24 | end
25 | 
26 | -- find zero in [1,2]
27 | solve(f,1,2)
28 | 


--------------------------------------------------------------------------------
/test/cf.lua:
--------------------------------------------------------------------------------
 1 | -- temperature conversion table (celsius to farenheit)
 2 | 
 3 | for c0=-20,50-1,10 do
 4 | 	io.write("C ")
 5 | 	for c=c0,c0+10-1 do
 6 | 		io.write(string.format("%3.0f ",c))
 7 | 	end
 8 | 	io.write("\n")
 9 | 	
10 | 	io.write("F ")
11 | 	for c=c0,c0+10-1 do
12 | 		f=(9/5)*c+32
13 | 		io.write(string.format("%3.0f ",f))
14 | 	end
15 | 	io.write("\n\n")
16 | end
17 | 


--------------------------------------------------------------------------------
/test/echo.lua:
--------------------------------------------------------------------------------
1 | -- echo command line arguments
2 | 
3 | for i=0,table.getn(arg) do
4 |  print(i,arg[i])
5 | end
6 | 


--------------------------------------------------------------------------------
/test/env.lua:
--------------------------------------------------------------------------------
1 | -- read environment variables as if they were global variables
2 | 
3 | local f=function (t,i) return os.getenv(i) end
4 | setmetatable(getfenv(),{__index=f})
5 | 
6 | -- an example
7 | print(a,USER,PATH)
8 | 


--------------------------------------------------------------------------------
/test/factorial.lua:
--------------------------------------------------------------------------------
 1 | -- function closures are powerful
 2 | 
 3 | -- traditional fixed-point operator from functional programming
 4 | Y = function (g)
 5 |       local a = function (f) return f(f) end
 6 |       return a(function (f)
 7 |                  return g(function (x)
 8 |                              local c=f(f)
 9 |                              return c(x)
10 |                            end)
11 |                end)
12 | end
13 | 
14 | 
15 | -- factorial without recursion
16 | F = function (f)
17 |       return function (n)
18 |                if n == 0 then return 1
19 |                else return n*f(n-1) end
20 |              end
21 |     end
22 | 
23 | factorial = Y(F)   -- factorial is the fixed point of F
24 | 
25 | -- now test it
26 | function test(x)
27 | 	io.write(x,"! = ",factorial(x),"\n")
28 | end
29 | 
30 | for n=0,16 do
31 | 	test(n)
32 | end
33 | 


--------------------------------------------------------------------------------
/test/fib.lua:
--------------------------------------------------------------------------------
 1 | -- fibonacci function with cache
 2 | 
 3 | -- very inefficient fibonacci function
 4 | function fib(n)
 5 | 	N=N+1
 6 | 	if n<2 then
 7 | 		return n
 8 | 	else
 9 | 		return fib(n-1)+fib(n-2)
10 | 	end
11 | end
12 | 
13 | -- a general-purpose value cache
14 | function cache(f)
15 | 	local c={}
16 | 	return function (x)
17 | 		local y=c[x]
18 | 		if not y then
19 | 			y=f(x)
20 | 			c[x]=y
21 | 		end
22 | 		return y
23 | 	end
24 | end
25 | 
26 | -- run and time it
27 | function test(s,f)
28 | 	N=0
29 | 	local c=os.clock()
30 | 	local v=f(n)
31 | 	local t=os.clock()-c
32 | 	print(s,n,v,t,N)
33 | end
34 | 
35 | n=arg[1] or 24		-- for other values, do lua fib.lua XX
36 | n=tonumber(n)
37 | print("","n","value","time","evals")
38 | test("plain",fib)
39 | fib=cache(fib)
40 | test("cached",fib)
41 | 


--------------------------------------------------------------------------------
/test/fibfor.lua:
--------------------------------------------------------------------------------
 1 | -- example of for with generator functions
 2 | 
 3 | function generatefib (n)
 4 |   return coroutine.wrap(function ()
 5 |     local a,b = 1, 1
 6 |     while a <= n do
 7 |       coroutine.yield(a)
 8 |       a, b = b, a+b
 9 |     end
10 |   end)
11 | end
12 | 
13 | for i in generatefib(1000) do print(i) end
14 | 


--------------------------------------------------------------------------------
/test/globals.lua:
--------------------------------------------------------------------------------
 1 | -- reads luac listings and reports global variable usage
 2 | -- lines where a global is written to are marked with "*"
 3 | -- typical usage: luac -p -l file.lua | lua globals.lua | sort | lua table.lua
 4 | 
 5 | while 1 do
 6 |  local s=io.read()
 7 |  if s==nil then break end
 8 |  local ok,_,l,op,g=string.find(s,"%[%-?(%d*)%]%s*([GS])ETGLOBAL.-;%s+(.*)$")
 9 |  if ok then
10 |   if op=="S" then op="*" else op="" end
11 |   io.write(g,"\t",l,op,"\n")
12 |  end
13 | end
14 | 


--------------------------------------------------------------------------------
/test/hello.lua:
--------------------------------------------------------------------------------
1 | -- the first program in every language
2 | 
3 | io.write("Hello world, from ",_VERSION,"!\n")
4 | 


--------------------------------------------------------------------------------
/test/life.lua:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsnyder/lua/5ca4b4e3f1d37ad0a6ecf390e41109018f02e8d1/test/life.lua


--------------------------------------------------------------------------------
/test/luac.lua:
--------------------------------------------------------------------------------
1 | -- bare-bones luac in Lua
2 | -- usage: lua luac.lua file.lua
3 | 
4 | assert(arg[1]~=nil and arg[2]==nil,"usage: lua luac.lua file.lua")
5 | f=assert(io.open("luac.out","wb"))
6 | assert(f:write(string.dump(assert(loadfile(arg[1])))))
7 | assert(f:close())
8 | 


--------------------------------------------------------------------------------
/test/printf.lua:
--------------------------------------------------------------------------------
1 | -- an implementation of printf
2 | 
3 | function printf(...)
4 |  io.write(string.format(...))
5 | end
6 | 
7 | printf("Hello %s from %s on %s\n",os.getenv"USER" or "there",_VERSION,os.date())
8 | 


--------------------------------------------------------------------------------
/test/readonly.lua:
--------------------------------------------------------------------------------
 1 | -- make global variables readonly
 2 | 
 3 | local f=function (t,i) error("cannot redefine global variable `"..i.."'",2) end
 4 | local g={}
 5 | local G=getfenv()
 6 | setmetatable(g,{__index=G,__newindex=f})
 7 | setfenv(1,g)
 8 | 
 9 | -- an example
10 | rawset(g,"x",3)
11 | x=2
12 | y=1	-- cannot redefine `y'
13 | 


--------------------------------------------------------------------------------
/test/sieve.lua:
--------------------------------------------------------------------------------
 1 | -- the sieve of of Eratosthenes programmed with coroutines
 2 | -- typical usage: lua -e N=1000 sieve.lua | column
 3 | 
 4 | -- generate all the numbers from 2 to n
 5 | function gen (n)
 6 |   return coroutine.wrap(function ()
 7 |     for i=2,n do coroutine.yield(i) end
 8 |   end)
 9 | end
10 | 
11 | -- filter the numbers generated by `g', removing multiples of `p'
12 | function filter (p, g)
13 |   return coroutine.wrap(function ()
14 |     while 1 do
15 |       local n = g()
16 |       if n == nil then return end
17 |       if math.mod(n, p) ~= 0 then coroutine.yield(n) end
18 |     end
19 |   end)
20 | end
21 | 
22 | N=N or 1000		-- from command line
23 | x = gen(N)		-- generate primes up to N
24 | while 1 do
25 |   local n = x()		-- pick a number until done
26 |   if n == nil then break end
27 |   print(n)		-- must be a prime number
28 |   x = filter(n, x)	-- now remove its multiples
29 | end
30 | 


--------------------------------------------------------------------------------
/test/sort.lua:
--------------------------------------------------------------------------------
 1 | -- two implementations of a sort function
 2 | -- this is an example only. Lua has now a built-in function "sort"
 3 | 
 4 | -- extracted from Programming Pearls, page 110
 5 | function qsort(x,l,u,f)
 6 |  if l<u then
 7 |   local m=math.random(u-(l-1))+l-1	-- choose a random pivot in range l..u
 8 |   x[l],x[m]=x[m],x[l]			-- swap pivot to first position
 9 |   local t=x[l]				-- pivot value
10 |   m=l
11 |   local i=l+1
12 |   while i<=u do
13 |     -- invariant: x[l+1..m] < t <= x[m+1..i-1]
14 |     if f(x[i],t) then
15 |       m=m+1
16 |       x[m],x[i]=x[i],x[m]		-- swap x[i] and x[m]
17 |     end
18 |     i=i+1
19 |   end
20 |   x[l],x[m]=x[m],x[l]			-- swap pivot to a valid place
21 |   -- x[l+1..m-1] < x[m] <= x[m+1..u]
22 |   qsort(x,l,m-1,f)
23 |   qsort(x,m+1,u,f)
24 |  end
25 | end
26 | 
27 | function selectionsort(x,n,f)
28 |  local i=1
29 |  while i<=n do
30 |   local m,j=i,i+1
31 |   while j<=n do
32 |    if f(x[j],x[m]) then m=j end
33 |    j=j+1
34 |   end
35 |  x[i],x[m]=x[m],x[i]			-- swap x[i] and x[m]
36 |  i=i+1
37 |  end
38 | end
39 | 
40 | function show(m,x)
41 |  io.write(m,"\n\t")
42 |  local i=1
43 |  while x[i] do
44 |   io.write(x[i])
45 |   i=i+1
46 |   if x[i] then io.write(",") end
47 |  end
48 |  io.write("\n")
49 | end
50 | 
51 | function testsorts(x)
52 |  local n=1
53 |  while x[n] do n=n+1 end; n=n-1		-- count elements
54 |  show("original",x)
55 |  qsort(x,1,n,function (x,y) return x<y end)
56 |  show("after quicksort",x)
57 |  selectionsort(x,n,function (x,y) return x>y end)
58 |  show("after reverse selection sort",x)
59 |  qsort(x,1,n,function (x,y) return x<y end)
60 |  show("after quicksort again",x)
61 | end
62 | 
63 | -- array to be sorted
64 | x={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"}
65 | 
66 | testsorts(x)
67 | 


--------------------------------------------------------------------------------
/test/table.lua:
--------------------------------------------------------------------------------
 1 | -- make table, grouping all data for the same item
 2 | -- input is 2 columns (item, data)
 3 | 
 4 | local A
 5 | while 1 do
 6 |  local l=io.read()
 7 |  if l==nil then break end
 8 |  local _,_,a,b=string.find(l,'"?([_%w]+)"?%s*(.*)$')
 9 |  if a~=A then A=a io.write("\n",a,":") end
10 |  io.write(" ",b)
11 | end
12 | io.write("\n")
13 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------