Context Navigation

source: bootcd/isolinux/syslinux-6.03/com32/lua/doc/manual.html

Last change on this file was e16e8f2, checked in by Edwin Eefting <edwin@datux.nl>, 3 years ago
bootstuff
Property mode set to `100644`
File size: 299.1 KB

Rev	Line
[e16e8f2]	1	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
	2	<html>
	3
	4	<head>
	5	<title>Lua 5.2 Reference Manual</title>
	6	<link rel="stylesheet" type="text/css" href="lua.css">
	7	<link rel="stylesheet" type="text/css" href="manual.css">
	8	<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
	9	</head>
	10
	11	<body>
	12
	13	<hr>
	14	<h1>
	15	<a href="http://www.lua.org/"><img src="logo.gif" alt="" border="0"></a>
	16	Lua 5.2 Reference Manual
	17	</h1>
	18
	19	by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
	20	<p>
	21	<small>
	22	Copyright © 2011–2013 Lua.org, PUC-Rio.
	23	Freely available under the terms of the
	24	<a href="http://www.lua.org/license.html">Lua license</a>.
	25	</small>
	26	<hr>
	27	<p>
	28
	29	<a href="contents.html#contents">contents</A>
	30	·
	31	<a href="contents.html#index">index</A>
	32
	33	<!-- ====================================================================== -->
	34	<p>
	35
	36	<!-- $Id: manual.of,v 1.103 2013/03/14 18:51:56 roberto Exp $ -->
	37
	38
	39
	40
	41	<h1>1 – <a name="1">Introduction</a></h1>
	42
	43	<p>
	44	Lua is an extension programming language designed to support
	45	general procedural programming with data description
	46	facilities.
	47	It also offers good support for object-oriented programming,
	48	functional programming, and data-driven programming.
	49	Lua is intended to be used as a powerful, lightweight,
	50	embeddable scripting language for any program that needs one.
	51	Lua is implemented as a library, written in <em>clean C</em>,
	52	the common subset of Standard C and C++.
	53
	54
	55	<p>
	56	Being an extension language, Lua has no notion of a "main" program:
	57	it only works <em>embedded</em> in a host client,
	58	called the <em>embedding program</em> or simply the <em>host</em>.
	59	The host program can invoke functions to execute a piece of Lua code,
	60	can write and read Lua variables,
	61	and can register C functions to be called by Lua code.
	62	Through the use of C functions, Lua can be augmented to cope with
	63	a wide range of different domains,
	64	thus creating customized programming languages sharing a syntactical framework.
	65	The Lua distribution includes a sample host program called <code>lua</code>,
	66	which uses the Lua library to offer a complete, standalone Lua interpreter,
	67	for interactive or batch use.
	68
	69
	70	<p>
	71	Lua is free software,
	72	and is provided as usual with no guarantees,
	73	as stated in its license.
	74	The implementation described in this manual is available
	75	at Lua's official web site, <code>www.lua.org</code>.
	76
	77
	78	<p>
	79	Like any other reference manual,
	80	this document is dry in places.
	81	For a discussion of the decisions behind the design of Lua,
	82	see the technical papers available at Lua's web site.
	83	For a detailed introduction to programming in Lua,
	84	see Roberto's book, <em>Programming in Lua</em>.
	85
	86
	87
	88	<h1>2 – <a name="2">Basic Concepts</a></h1>
	89
	90	<p>
	91	This section describes the basic concepts of the language.
	92
	93
	94
	95	<h2>2.1 – <a name="2.1">Values and Types</a></h2>
	96
	97	<p>
	98	Lua is a <em>dynamically typed language</em>.
	99	This means that
	100	variables do not have types; only values do.
	101	There are no type definitions in the language.
	102	All values carry their own type.
	103
	104
	105	<p>
	106	All values in Lua are <em>first-class values</em>.
	107	This means that all values can be stored in variables,
	108	passed as arguments to other functions, and returned as results.
	109
	110
	111	<p>
	112	There are eight basic types in Lua:
	113	<em>nil</em>, <em>boolean</em>, <em>number</em>,
	114	<em>string</em>, <em>function</em>, <em>userdata</em>,
	115	<em>thread</em>, and <em>table</em>.
	116	<em>Nil</em> is the type of the value <b>nil</b>,
	117	whose main property is to be different from any other value;
	118	it usually represents the absence of a useful value.
	119	<em>Boolean</em> is the type of the values <b>false</b> and <b>true</b>.
	120	Both <b>nil</b> and <b>false</b> make a condition false;
	121	any other value makes it true.
	122	<em>Number</em> represents real (double-precision floating-point) numbers.
	123	Operations on numbers follow the same rules of
	124	the underlying C implementation,
	125	which, in turn, usually follows the IEEE 754 standard.
	126	(It is easy to build Lua interpreters that use other
	127	internal representations for numbers,
	128	such as single-precision floats or long integers;
	129	see file <code>luaconf.h</code>.)
	130	<em>String</em> represents immutable sequences of bytes.
	131
	132	Lua is 8-bit clean:
	133	strings can contain any 8-bit value,
	134	including embedded zeros ('<code>\0</code>').
	135
	136
	137	<p>
	138	Lua can call (and manipulate) functions written in Lua and
	139	functions written in C
	140	(see <a href="#3.4.9">§3.4.9</a>).
	141
	142
	143	<p>
	144	The type <em>userdata</em> is provided to allow arbitrary C data to
	145	be stored in Lua variables.
	146	A userdata value is a pointer to a block of raw memory.
	147	There are two kinds of userdata:
	148	full userdata, where the block of memory is managed by Lua,
	149	and light userdata, where the block of memory is managed by the host.
	150	Userdata has no predefined operations in Lua,
	151	except assignment and identity test.
	152	By using <em>metatables</em>,
	153	the programmer can define operations for full userdata values
	154	(see <a href="#2.4">§2.4</a>).
	155	Userdata values cannot be created or modified in Lua,
	156	only through the C API.
	157	This guarantees the integrity of data owned by the host program.
	158
	159
	160	<p>
	161	The type <em>thread</em> represents independent threads of execution
	162	and it is used to implement coroutines (see <a href="#2.6">§2.6</a>).
	163	Do not confuse Lua threads with operating-system threads.
	164	Lua supports coroutines on all systems,
	165	even those that do not support threads.
	166
	167
	168	<p>
	169	The type <em>table</em> implements associative arrays,
	170	that is, arrays that can be indexed not only with numbers,
	171	but with any Lua value except <b>nil</b> and NaN
	172	(<em>Not a Number</em>, a special numeric value used to represent
	173	undefined or unrepresentable results, such as <code>0/0</code>).
	174	Tables can be <em>heterogeneous</em>;
	175	that is, they can contain values of all types (except <b>nil</b>).
	176	Any key with value <b>nil</b> is not considered part of the table.
	177	Conversely, any key that is not part of a table has
	178	an associated value <b>nil</b>.
	179
	180
	181	<p>
	182	Tables are the sole data structuring mechanism in Lua;
	183	they can be used to represent ordinary arrays, sequences,
	184	symbol tables, sets, records, graphs, trees, etc.
	185	To represent records, Lua uses the field name as an index.
	186	The language supports this representation by
	187	providing <code>a.name</code> as syntactic sugar for <code>a["name"]</code>.
	188	There are several convenient ways to create tables in Lua
	189	(see <a href="#3.4.8">§3.4.8</a>).
	190
	191
	192	<p>
	193	We use the term <em>sequence</em> to denote a table where
	194	the set of all positive numeric keys is equal to <em>{1..n}</em>
	195	for some integer <em>n</em>,
	196	which is called the length of the sequence (see <a href="#3.4.6">§3.4.6</a>).
	197
	198
	199	<p>
	200	Like indices,
	201	the values of table fields can be of any type.
	202	In particular,
	203	because functions are first-class values,
	204	table fields can contain functions.
	205	Thus tables can also carry <em>methods</em> (see <a href="#3.4.10">§3.4.10</a>).
	206
	207
	208	<p>
	209	The indexing of tables follows
	210	the definition of raw equality in the language.
	211	The expressions <code>a[i]</code> and <code>a[j]</code>
	212	denote the same table element
	213	if and only if <code>i</code> and <code>j</code> are raw equal
	214	(that is, equal without metamethods).
	215
	216
	217	<p>
	218	Tables, functions, threads, and (full) userdata values are <em>objects</em>:
	219	variables do not actually <em>contain</em> these values,
	220	only <em>references</em> to them.
	221	Assignment, parameter passing, and function returns
	222	always manipulate references to such values;
	223	these operations do not imply any kind of copy.
	224
	225
	226	<p>
	227	The library function <a href="#pdf-type"><code>type</code></a> returns a string describing the type
	228	of a given value (see <a href="#6.1">§6.1</a>).
	229
	230
	231
	232
	233
	234	<h2>2.2 – <a name="2.2">Environments and the Global Environment</a></h2>
	235
	236	<p>
	237	As will be discussed in <a href="#3.2">§3.2</a> and <a href="#3.3.3">§3.3.3</a>,
	238	any reference to a global name <code>var</code> is syntactically translated
	239	to <code>_ENV.var</code>.
	240	Moreover, every chunk is compiled in the scope of
	241	an external local variable called <code>_ENV</code> (see <a href="#3.3.2">§3.3.2</a>),
	242	so <code>_ENV</code> itself is never a global name in a chunk.
	243
	244
	245	<p>
	246	Despite the existence of this external <code>_ENV</code> variable and
	247	the translation of global names,
	248	<code>_ENV</code> is a completely regular name.
	249	In particular,
	250	you can define new variables and parameters with that name.
	251	Each reference to a global name uses the <code>_ENV</code> that is
	252	visible at that point in the program,
	253	following the usual visibility rules of Lua (see <a href="#3.5">§3.5</a>).
	254
	255
	256	<p>
	257	Any table used as the value of <code>_ENV</code> is called an <em>environment</em>.
	258
	259
	260	<p>
	261	Lua keeps a distinguished environment called the <em>global environment</em>.
	262	This value is kept at a special index in the C registry (see <a href="#4.5">§4.5</a>).
	263	In Lua, the variable <a href="#pdf-_G"><code>_G</code></a> is initialized with this same value.
	264
	265
	266	<p>
	267	When Lua compiles a chunk,
	268	it initializes the value of its <code>_ENV</code> upvalue
	269	with the global environment (see <a href="#pdf-load"><code>load</code></a>).
	270	Therefore, by default,
	271	global variables in Lua code refer to entries in the global environment.
	272	Moreover, all standard libraries are loaded in the global environment
	273	and several functions there operate on that environment.
	274	You can use <a href="#pdf-load"><code>load</code></a> (or <a href="#pdf-loadfile"><code>loadfile</code></a>)
	275	to load a chunk with a different environment.
	276	(In C, you have to load the chunk and then change the value
	277	of its first upvalue.)
	278
	279
	280	<p>
	281	If you change the global environment in the registry
	282	(through C code or the debug library),
	283	all chunks loaded after the change will get the new environment.
	284	Previously loaded chunks are not affected, however,
	285	as each has its own reference to the environment in its <code>_ENV</code> variable.
	286	Moreover, the variable <a href="#pdf-_G"><code>_G</code></a>
	287	(which is stored in the original global environment)
	288	is never updated by Lua.
	289
	290
	291
	292
	293
	294	<h2>2.3 – <a name="2.3">Error Handling</a></h2>
	295
	296	<p>
	297	Because Lua is an embedded extension language,
	298	all Lua actions start from C code in the host program
	299	calling a function from the Lua library (see <a href="#lua_pcall"><code>lua_pcall</code></a>).
	300	Whenever an error occurs during
	301	the compilation or execution of a Lua chunk,
	302	control returns to the host,
	303	which can take appropriate measures
	304	(such as printing an error message).
	305
	306
	307	<p>
	308	Lua code can explicitly generate an error by calling the
	309	<a href="#pdf-error"><code>error</code></a> function.
	310	If you need to catch errors in Lua,
	311	you can use <a href="#pdf-pcall"><code>pcall</code></a> or <a href="#pdf-xpcall"><code>xpcall</code></a>
	312	to call a given function in <em>protected mode</em>.
	313
	314
	315	<p>
	316	Whenever there is an error,
	317	an <em>error object</em> (also called an <em>error message</em>)
	318	is propagated with information about the error.
	319	Lua itself only generates errors where the error object is a string,
	320	but programs may generate errors with
	321	any value for the error object.
	322
	323
	324	<p>
	325	When you use <a href="#pdf-xpcall"><code>xpcall</code></a> or <a href="#lua_pcall"><code>lua_pcall</code></a>,
	326	you may give a <em>message handler</em>
	327	to be called in case of errors.
	328	This function is called with the original error message
	329	and returns a new error message.
	330	It is called before the error unwinds the stack,
	331	so that it can gather more information about the error,
	332	for instance by inspecting the stack and creating a stack traceback.
	333	This message handler is still protected by the protected call;
	334	so, an error inside the message handler
	335	will call the message handler again.
	336	If this loop goes on, Lua breaks it and returns an appropriate message.
	337
	338
	339
	340
	341
	342	<h2>2.4 – <a name="2.4">Metatables and Metamethods</a></h2>
	343
	344	<p>
	345	Every value in Lua can have a <em>metatable</em>.
	346	This <em>metatable</em> is an ordinary Lua table
	347	that defines the behavior of the original value
	348	under certain special operations.
	349	You can change several aspects of the behavior
	350	of operations over a value by setting specific fields in its metatable.
	351	For instance, when a non-numeric value is the operand of an addition,
	352	Lua checks for a function in the field "<code>__add</code>" of the value's metatable.
	353	If it finds one,
	354	Lua calls this function to perform the addition.
	355
	356
	357	<p>
	358	The keys in a metatable are derived from the <em>event</em> names;
	359	the corresponding values are called <em>metamethods</em>.
	360	In the previous example, the event is <code>"add"</code>
	361	and the metamethod is the function that performs the addition.
	362
	363
	364	<p>
	365	You can query the metatable of any value
	366	using the <a href="#pdf-getmetatable"><code>getmetatable</code></a> function.
	367
	368
	369	<p>
	370	You can replace the metatable of tables
	371	using the <a href="#pdf-setmetatable"><code>setmetatable</code></a> function.
	372	You cannot change the metatable of other types from Lua
	373	(except by using the debug library);
	374	you must use the C API for that.
	375
	376
	377	<p>
	378	Tables and full userdata have individual metatables
	379	(although multiple tables and userdata can share their metatables).
	380	Values of all other types share one single metatable per type;
	381	that is, there is one single metatable for all numbers,
	382	one for all strings, etc.
	383	By default, a value has no metatable,
	384	but the string library sets a metatable for the string type (see <a href="#6.4">§6.4</a>).
	385
	386
	387	<p>
	388	A metatable controls how an object behaves in arithmetic operations,
	389	order comparisons, concatenation, length operation, and indexing.
	390	A metatable also can define a function to be called
	391	when a userdata or a table is garbage collected.
	392	When Lua performs one of these operations over a value,
	393	it checks whether this value has a metatable with the corresponding event.
	394	If so, the value associated with that key (the metamethod)
	395	controls how Lua will perform the operation.
	396
	397
	398	<p>
	399	Metatables control the operations listed next.
	400	Each operation is identified by its corresponding name.
	401	The key for each operation is a string with its name prefixed by
	402	two underscores, '<code>__</code>';
	403	for instance, the key for operation "add" is the
	404	string "<code>__add</code>".
	405
	406
	407	<p>
	408	The semantics of these operations is better explained by a Lua function
	409	describing how the interpreter executes the operation.
	410	The code shown here in Lua is only illustrative;
	411	the real behavior is hard coded in the interpreter
	412	and it is much more efficient than this simulation.
	413	All functions used in these descriptions
	414	(<a href="#pdf-rawget"><code>rawget</code></a>, <a href="#pdf-tonumber"><code>tonumber</code></a>, etc.)
	415	are described in <a href="#6.1">§6.1</a>.
	416	In particular, to retrieve the metamethod of a given object,
	417	we use the expression
	418
	419	<pre>
	420	metatable(obj)[event]
	421	</pre><p>
	422	This should be read as
	423
	424	<pre>
	425	rawget(getmetatable(obj) or {}, event)
	426	</pre><p>
	427	This means that the access to a metamethod does not invoke other metamethods,
	428	and access to objects with no metatables does not fail
	429	(it simply results in <b>nil</b>).
	430
	431
	432	<p>
	433	For the unary <code>-</code> and <code>#</code> operators,
	434	the metamethod is called with a dummy second argument.
	435	This extra argument is only to simplify Lua's internals;
	436	it may be removed in future versions and therefore it is not present
	437	in the following code.
	438	(For most uses this extra argument is irrelevant.)
	439
	440
	441
	442	<ul>
	443
	444	<li><b>"add": </b>
	445	the <code>+</code> operation.
	446
	447
	448
	449	<p>
	450	The function <code>getbinhandler</code> below defines how Lua chooses a handler
	451	for a binary operation.
	452	First, Lua tries the first operand.
	453	If its type does not define a handler for the operation,
	454	then Lua tries the second operand.
	455
	456	<pre>
	457	function getbinhandler (op1, op2, event)
	458	return metatable(op1)[event] or metatable(op2)[event]
	459	end
	460	</pre><p>
	461	By using this function,
	462	the behavior of the <code>op1 + op2</code> is
	463
	464	<pre>
	465	function add_event (op1, op2)
	466	local o1, o2 = tonumber(op1), tonumber(op2)
	467	if o1 and o2 then -- both operands are numeric?
	468	return o1 + o2 -- '+' here is the primitive 'add'
	469	else -- at least one of the operands is not numeric
	470	local h = getbinhandler(op1, op2, "__add")
	471	if h then
	472	-- call the handler with both operands
	473	return (h(op1, op2))
	474	else -- no handler available: default behavior
	475	error(···)
	476	end
	477	end
	478	end
	479	</pre><p>
	480	</li>
	481
	482	<li><b>"sub": </b>
	483	the <code>-</code> operation.
	484
	485	Behavior similar to the "add" operation.
	486	</li>
	487
	488	<li><b>"mul": </b>
	489	the <code>*</code> operation.
	490
	491	Behavior similar to the "add" operation.
	492	</li>
	493
	494	<li><b>"div": </b>
	495	the <code>/</code> operation.
	496
	497	Behavior similar to the "add" operation.
	498	</li>
	499
	500	<li><b>"mod": </b>
	501	the <code>%</code> operation.
	502
	503	Behavior similar to the "add" operation,
	504	with the operation
	505	<code>o1 - floor(o1/o2)*o2</code> as the primitive operation.
	506	</li>
	507
	508	<li><b>"pow": </b>
	509	the <code>^</code> (exponentiation) operation.
	510
	511	Behavior similar to the "add" operation,
	512	with the function <code>pow</code> (from the C math library)
	513	as the primitive operation.
	514	</li>
	515
	516	<li><b>"unm": </b>
	517	the unary <code>-</code> operation.
	518
	519
	520	<pre>
	521	function unm_event (op)
	522	local o = tonumber(op)
	523	if o then -- operand is numeric?
	524	return -o -- '-' here is the primitive 'unm'
	525	else -- the operand is not numeric.
	526	-- Try to get a handler from the operand
	527	local h = metatable(op).__unm
	528	if h then
	529	-- call the handler with the operand
	530	return (h(op))
	531	else -- no handler available: default behavior
	532	error(···)
	533	end
	534	end
	535	end
	536	</pre><p>
	537	</li>
	538
	539	<li><b>"concat": </b>
	540	the <code>..</code> (concatenation) operation.
	541
	542
	543	<pre>
	544	function concat_event (op1, op2)
	545	if (type(op1) == "string" or type(op1) == "number") and
	546	(type(op2) == "string" or type(op2) == "number") then
	547	return op1 .. op2 -- primitive string concatenation
	548	else
	549	local h = getbinhandler(op1, op2, "__concat")
	550	if h then
	551	return (h(op1, op2))
	552	else
	553	error(···)
	554	end
	555	end
	556	end
	557	</pre><p>
	558	</li>
	559
	560	<li><b>"len": </b>
	561	the <code>#</code> operation.
	562
	563
	564	<pre>
	565	function len_event (op)
	566	if type(op) == "string" then
	567	return strlen(op) -- primitive string length
	568	else
	569	local h = metatable(op).__len
	570	if h then
	571	return (h(op)) -- call handler with the operand
	572	elseif type(op) == "table" then
	573	return #op -- primitive table length
	574	else -- no handler available: error
	575	error(···)
	576	end
	577	end
	578	end
	579	</pre><p>
	580	See <a href="#3.4.6">§3.4.6</a> for a description of the length of a table.
	581	</li>
	582
	583	<li><b>"eq": </b>
	584	the <code>==</code> operation.
	585
	586	The function <code>getequalhandler</code> defines how Lua chooses a metamethod
	587	for equality.
	588	A metamethod is selected only when both values
	589	being compared have the same type
	590	and the same metamethod for the selected operation,
	591	and the values are either tables or full userdata.
	592
	593	<pre>
	594	function getequalhandler (op1, op2)
	595	if type(op1) ~= type(op2) or
	596	(type(op1) ~= "table" and type(op1) ~= "userdata") then
	597	return nil -- different values
	598	end
	599	local mm1 = metatable(op1).__eq
	600	local mm2 = metatable(op2).__eq
	601	if mm1 == mm2 then return mm1 else return nil end
	602	end
	603	</pre><p>
	604	The "eq" event is defined as follows:
	605
	606	<pre>
	607	function eq_event (op1, op2)
	608	if op1 == op2 then -- primitive equal?
	609	return true -- values are equal
	610	end
	611	-- try metamethod
	612	local h = getequalhandler(op1, op2)
	613	if h then
	614	return not not h(op1, op2)
	615	else
	616	return false
	617	end
	618	end
	619	</pre><p>
	620	Note that the result is always a boolean.
	621	</li>
	622
	623	<li><b>"lt": </b>
	624	the <code><</code> operation.
	625
	626
	627	<pre>
	628	function lt_event (op1, op2)
	629	if type(op1) == "number" and type(op2) == "number" then
	630	return op1 < op2 -- numeric comparison
	631	elseif type(op1) == "string" and type(op2) == "string" then
	632	return op1 < op2 -- lexicographic comparison
	633	else
	634	local h = getbinhandler(op1, op2, "__lt")
	635	if h then
	636	return not not h(op1, op2)
	637	else
	638	error(···)
	639	end
	640	end
	641	end
	642	</pre><p>
	643	Note that the result is always a boolean.
	644	</li>
	645
	646	<li><b>"le": </b>
	647	the <code><=</code> operation.
	648
	649
	650	<pre>
	651	function le_event (op1, op2)
	652	if type(op1) == "number" and type(op2) == "number" then
	653	return op1 <= op2 -- numeric comparison
	654	elseif type(op1) == "string" and type(op2) == "string" then
	655	return op1 <= op2 -- lexicographic comparison
	656	else
	657	local h = getbinhandler(op1, op2, "__le")
	658	if h then
	659	return not not h(op1, op2)
	660	else
	661	h = getbinhandler(op1, op2, "__lt")
	662	if h then
	663	return not h(op2, op1)
	664	else
	665	error(···)
	666	end
	667	end
	668	end
	669	end
	670	</pre><p>
	671	Note that, in the absence of a "le" metamethod,
	672	Lua tries the "lt", assuming that <code>a <= b</code> is
	673	equivalent to <code>not (b < a)</code>.
	674
	675
	676	<p>
	677	As with the other comparison operators,
	678	the result is always a boolean.
	679	</li>
	680
	681	<li><b>"index": </b>
	682	The indexing access <code>table[key]</code>.
	683	Note that the metamethod is tried only
	684	when <code>key</code> is not present in <code>table</code>.
	685	(When <code>table</code> is not a table,
	686	no key is ever present,
	687	so the metamethod is always tried.)
	688
	689
	690	<pre>
	691	function gettable_event (table, key)
	692	local h
	693	if type(table) == "table" then
	694	local v = rawget(table, key)
	695	-- if key is present, return raw value
	696	if v ~= nil then return v end
	697	h = metatable(table).__index
	698	if h == nil then return nil end
	699	else
	700	h = metatable(table).__index
	701	if h == nil then
	702	error(···)
	703	end
	704	end
	705	if type(h) == "function" then
	706	return (h(table, key)) -- call the handler
	707	else return h[key] -- or repeat operation on it
	708	end
	709	end
	710	</pre><p>
	711	</li>
	712
	713	<li><b>"newindex": </b>
	714	The indexing assignment <code>table[key] = value</code>.
	715	Note that the metamethod is tried only
	716	when <code>key</code> is not present in <code>table</code>.
	717
	718
	719	<pre>
	720	function settable_event (table, key, value)
	721	local h
	722	if type(table) == "table" then
	723	local v = rawget(table, key)
	724	-- if key is present, do raw assignment
	725	if v ~= nil then rawset(table, key, value); return end
	726	h = metatable(table).__newindex
	727	if h == nil then rawset(table, key, value); return end
	728	else
	729	h = metatable(table).__newindex
	730	if h == nil then
	731	error(···)
	732	end
	733	end
	734	if type(h) == "function" then
	735	h(table, key,value) -- call the handler
	736	else h[key] = value -- or repeat operation on it
	737	end
	738	end
	739	</pre><p>
	740	</li>
	741
	742	<li><b>"call": </b>
	743	called when Lua calls a value.
	744
	745
	746	<pre>
	747	function function_event (func, ...)
	748	if type(func) == "function" then
	749	return func(...) -- primitive call
	750	else
	751	local h = metatable(func).__call
	752	if h then
	753	return h(func, ...)
	754	else
	755	error(···)
	756	end
	757	end
	758	end
	759	</pre><p>
	760	</li>
	761
	762	</ul>
	763
	764
	765
	766
	767	<h2>2.5 – <a name="2.5">Garbage Collection</a></h2>
	768
	769	<p>
	770	Lua performs automatic memory management.
	771	This means that
	772	you have to worry neither about allocating memory for new objects
	773	nor about freeing it when the objects are no longer needed.
	774	Lua manages memory automatically by running
	775	a <em>garbage collector</em> to collect all <em>dead objects</em>
	776	(that is, objects that are no longer accessible from Lua).
	777	All memory used by Lua is subject to automatic management:
	778	strings, tables, userdata, functions, threads, internal structures, etc.
	779
	780
	781	<p>
	782	Lua implements an incremental mark-and-sweep collector.
	783	It uses two numbers to control its garbage-collection cycles:
	784	the <em>garbage-collector pause</em> and
	785	the <em>garbage-collector step multiplier</em>.
	786	Both use percentage points as units
	787	(e.g., a value of 100 means an internal value of 1).
	788
	789
	790	<p>
	791	The garbage-collector pause
	792	controls how long the collector waits before starting a new cycle.
	793	Larger values make the collector less aggressive.
	794	Values smaller than 100 mean the collector will not wait to
	795	start a new cycle.
	796	A value of 200 means that the collector waits for the total memory in use
	797	to double before starting a new cycle.
	798
	799
	800	<p>
	801	The garbage-collector step multiplier
	802	controls the relative speed of the collector relative to
	803	memory allocation.
	804	Larger values make the collector more aggressive but also increase
	805	the size of each incremental step.
	806	Values smaller than 100 make the collector too slow and
	807	can result in the collector never finishing a cycle.
	808	The default is 200,
	809	which means that the collector runs at "twice"
	810	the speed of memory allocation.
	811
	812
	813	<p>
	814	If you set the step multiplier to a very large number
	815	(larger than 10% of the maximum number of
	816	bytes that the program may use),
	817	the collector behaves like a stop-the-world collector.
	818	If you then set the pause to 200,
	819	the collector behaves as in old Lua versions,
	820	doing a complete collection every time Lua doubles its
	821	memory usage.
	822
	823
	824	<p>
	825	You can change these numbers by calling <a href="#lua_gc"><code>lua_gc</code></a> in C
	826	or <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> in Lua.
	827	You can also use these functions to control
	828	the collector directly (e.g., stop and restart it).
	829
	830
	831	<p>
	832	As an experimental feature in Lua 5.2,
	833	you can change the collector's operation mode
	834	from incremental to <em>generational</em>.
	835	A <em>generational collector</em> assumes that most objects die young,
	836	and therefore it traverses only young (recently created) objects.
	837	This behavior can reduce the time used by the collector,
	838	but also increases memory usage (as old dead objects may accumulate).
	839	To mitigate this second problem,
	840	from time to time the generational collector performs a full collection.
	841	Remember that this is an experimental feature;
	842	you are welcome to try it,
	843	but check your gains.
	844
	845
	846
	847	<h3>2.5.1 – <a name="2.5.1">Garbage-Collection Metamethods</a></h3>
	848
	849	<p>
	850	You can set garbage-collector metamethods for tables
	851	and, using the C API,
	852	for full userdata (see <a href="#2.4">§2.4</a>).
	853	These metamethods are also called <em>finalizers</em>.
	854	Finalizers allow you to coordinate Lua's garbage collection
	855	with external resource management
	856	(such as closing files, network or database connections,
	857	or freeing your own memory).
	858
	859
	860	<p>
	861	For an object (table or userdata) to be finalized when collected,
	862	you must <em>mark</em> it for finalization.
	863
	864	You mark an object for finalization when you set its metatable
	865	and the metatable has a field indexed by the string "<code>__gc</code>".
	866	Note that if you set a metatable without a <code>__gc</code> field
	867	and later create that field in the metatable,
	868	the object will not be marked for finalization.
	869	However, after an object is marked,
	870	you can freely change the <code>__gc</code> field of its metatable.
	871
	872
	873	<p>
	874	When a marked object becomes garbage,
	875	it is not collected immediately by the garbage collector.
	876	Instead, Lua puts it in a list.
	877	After the collection,
	878	Lua does the equivalent of the following function
	879	for each object in that list:
	880
	881	<pre>
	882	function gc_event (obj)
	883	local h = metatable(obj).__gc
	884	if type(h) == "function" then
	885	h(obj)
	886	end
	887	end
	888	</pre>
	889
	890	<p>
	891	At the end of each garbage-collection cycle,
	892	the finalizers for objects are called in
	893	the reverse order that they were marked for collection,
	894	among those collected in that cycle;
	895	that is, the first finalizer to be called is the one associated
	896	with the object marked last in the program.
	897	The execution of each finalizer may occur at any point during
	898	the execution of the regular code.
	899
	900
	901	<p>
	902	Because the object being collected must still be used by the finalizer,
	903	it (and other objects accessible only through it)
	904	must be <em>resurrected</em> by Lua.
	905	Usually, this resurrection is transient,
	906	and the object memory is freed in the next garbage-collection cycle.
	907	However, if the finalizer stores the object in some global place
	908	(e.g., a global variable),
	909	then there is a permanent resurrection.
	910	In any case,
	911	the object memory is freed only when it becomes completely inaccessible;
	912	its finalizer will never be called twice.
	913
	914
	915	<p>
	916	When you close a state (see <a href="#lua_close"><code>lua_close</code></a>),
	917	Lua calls the finalizers of all objects marked for finalization,
	918	following the reverse order that they were marked.
	919	If any finalizer marks new objects for collection during that phase,
	920	these new objects will not be finalized.
	921
	922
	923
	924
	925
	926	<h3>2.5.2 – <a name="2.5.2">Weak Tables</a></h3>
	927
	928	<p>
	929	A <em>weak table</em> is a table whose elements are
	930	<em>weak references</em>.
	931	A weak reference is ignored by the garbage collector.
	932	In other words,
	933	if the only references to an object are weak references,
	934	then the garbage collector will collect that object.
	935
	936
	937	<p>
	938	A weak table can have weak keys, weak values, or both.
	939	A table with weak keys allows the collection of its keys,
	940	but prevents the collection of its values.
	941	A table with both weak keys and weak values allows the collection of
	942	both keys and values.
	943	In any case, if either the key or the value is collected,
	944	the whole pair is removed from the table.
	945	The weakness of a table is controlled by the
	946	<code>__mode</code> field of its metatable.
	947	If the <code>__mode</code> field is a string containing the character '<code>k</code>',
	948	the keys in the table are weak.
	949	If <code>__mode</code> contains '<code>v</code>',
	950	the values in the table are weak.
	951
	952
	953	<p>
	954	A table with weak keys and strong values
	955	is also called an <em>ephemeron table</em>.
	956	In an ephemeron table,
	957	a value is considered reachable only if its key is reachable.
	958	In particular,
	959	if the only reference to a key comes through its value,
	960	the pair is removed.
	961
	962
	963	<p>
	964	Any change in the weakness of a table may take effect only
	965	at the next collect cycle.
	966	In particular, if you change the weakness to a stronger mode,
	967	Lua may still collect some items from that table
	968	before the change takes effect.
	969
	970
	971	<p>
	972	Only objects that have an explicit construction
	973	are removed from weak tables.
	974	Values, such as numbers and light C functions,
	975	are not subject to garbage collection,
	976	and therefore are not removed from weak tables
	977	(unless its associated value is collected).
	978	Although strings are subject to garbage collection,
	979	they do not have an explicit construction,
	980	and therefore are not removed from weak tables.
	981
	982
	983	<p>
	984	Resurrected objects
	985	(that is, objects being finalized
	986	and objects accessible only through objects being finalized)
	987	have a special behavior in weak tables.
	988	They are removed from weak values before running their finalizers,
	989	but are removed from weak keys only in the next collection
	990	after running their finalizers, when such objects are actually freed.
	991	This behavior allows the finalizer to access properties
	992	associated with the object through weak tables.
	993
	994
	995	<p>
	996	If a weak table is among the resurrected objects in a collection cycle,
	997	it may not be properly cleared until the next cycle.
	998
	999
	1000
	1001
	1002
	1003
	1004
	1005	<h2>2.6 – <a name="2.6">Coroutines</a></h2>
	1006
	1007	<p>
	1008	Lua supports coroutines,
	1009	also called <em>collaborative multithreading</em>.
	1010	A coroutine in Lua represents an independent thread of execution.
	1011	Unlike threads in multithread systems, however,
	1012	a coroutine only suspends its execution by explicitly calling
	1013	a yield function.
	1014
	1015
	1016	<p>
	1017	You create a coroutine by calling <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>.
	1018	Its sole argument is a function
	1019	that is the main function of the coroutine.
	1020	The <code>create</code> function only creates a new coroutine and
	1021	returns a handle to it (an object of type <em>thread</em>);
	1022	it does not start the coroutine.
	1023
	1024
	1025	<p>
	1026	You execute a coroutine by calling <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
	1027	When you first call <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
	1028	passing as its first argument
	1029	a thread returned by <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>,
	1030	the coroutine starts its execution,
	1031	at the first line of its main function.
	1032	Extra arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> are passed on
	1033	to the coroutine main function.
	1034	After the coroutine starts running,
	1035	it runs until it terminates or <em>yields</em>.
	1036
	1037
	1038	<p>
	1039	A coroutine can terminate its execution in two ways:
	1040	normally, when its main function returns
	1041	(explicitly or implicitly, after the last instruction);
	1042	and abnormally, if there is an unprotected error.
	1043	In the first case, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>true</b>,
	1044	plus any values returned by the coroutine main function.
	1045	In case of errors, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>false</b>
	1046	plus an error message.
	1047
	1048
	1049	<p>
	1050	A coroutine yields by calling <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>.
	1051	When a coroutine yields,
	1052	the corresponding <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns immediately,
	1053	even if the yield happens inside nested function calls
	1054	(that is, not in the main function,
	1055	but in a function directly or indirectly called by the main function).
	1056	In the case of a yield, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> also returns <b>true</b>,
	1057	plus any values passed to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>.
	1058	The next time you resume the same coroutine,
	1059	it continues its execution from the point where it yielded,
	1060	with the call to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a> returning any extra
	1061	arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
	1062
	1063
	1064	<p>
	1065	Like <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>,
	1066	the <a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> function also creates a coroutine,
	1067	but instead of returning the coroutine itself,
	1068	it returns a function that, when called, resumes the coroutine.
	1069	Any arguments passed to this function
	1070	go as extra arguments to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
	1071	<a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> returns all the values returned by <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
	1072	except the first one (the boolean error code).
	1073	Unlike <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
	1074	<a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> does not catch errors;
	1075	any error is propagated to the caller.
	1076
	1077
	1078	<p>
	1079	As an example of how coroutines work,
	1080	consider the following code:
	1081
	1082	<pre>
	1083	function foo (a)
	1084	print("foo", a)
	1085	return coroutine.yield(2*a)
	1086	end
	1087
	1088	co = coroutine.create(function (a,b)
	1089	print("co-body", a, b)
	1090	local r = foo(a+1)
	1091	print("co-body", r)
	1092	local r, s = coroutine.yield(a+b, a-b)
	1093	print("co-body", r, s)
	1094	return b, "end"
	1095	end)
	1096
	1097	print("main", coroutine.resume(co, 1, 10))
	1098	print("main", coroutine.resume(co, "r"))
	1099	print("main", coroutine.resume(co, "x", "y"))
	1100	print("main", coroutine.resume(co, "x", "y"))
	1101	</pre><p>
	1102	When you run it, it produces the following output:
	1103
	1104	<pre>
	1105	co-body 1 10
	1106	foo 2
	1107	main true 4
	1108	co-body r
	1109	main true 11 -9
	1110	co-body x y
	1111	main true 10 end
	1112	main false cannot resume dead coroutine
	1113	</pre>
	1114
	1115	<p>
	1116	You can also create and manipulate coroutines through the C API:
	1117	see functions <a href="#lua_newthread"><code>lua_newthread</code></a>, <a href="#lua_resume"><code>lua_resume</code></a>,
	1118	and <a href="#lua_yield"><code>lua_yield</code></a>.
	1119
	1120
	1121
	1122
	1123
	1124	<h1>3 – <a name="3">The Language</a></h1>
	1125
	1126	<p>
	1127	This section describes the lexis, the syntax, and the semantics of Lua.
	1128	In other words,
	1129	this section describes
	1130	which tokens are valid,
	1131	how they can be combined,
	1132	and what their combinations mean.
	1133
	1134
	1135	<p>
	1136	Language constructs will be explained using the usual extended BNF notation,
	1137	in which
	1138	{<em>a</em>} means 0 or more <em>a</em>'s, and
	1139	[<em>a</em>] means an optional <em>a</em>.
	1140	Non-terminals are shown like non-terminal,
	1141	keywords are shown like <b>kword</b>,
	1142	and other terminal symbols are shown like ‘<b>=</b>’.
	1143	The complete syntax of Lua can be found in <a href="#9">§9</a>
	1144	at the end of this manual.
	1145
	1146
	1147
	1148	<h2>3.1 – <a name="3.1">Lexical Conventions</a></h2>
	1149
	1150	<p>
	1151	Lua is a free-form language.
	1152	It ignores spaces (including new lines) and comments
	1153	between lexical elements (tokens),
	1154	except as delimiters between names and keywords.
	1155
	1156
	1157	<p>
	1158	<em>Names</em>
	1159	(also called <em>identifiers</em>)
	1160	in Lua can be any string of letters,
	1161	digits, and underscores,
	1162	not beginning with a digit.
	1163	Identifiers are used to name variables, table fields, and labels.
	1164
	1165
	1166	<p>
	1167	The following <em>keywords</em> are reserved
	1168	and cannot be used as names:
	1169
	1170
	1171	<pre>
	1172	and break do else elseif end
	1173	false for function goto if in
	1174	local nil not or repeat return
	1175	then true until while
	1176	</pre>
	1177
	1178	<p>
	1179	Lua is a case-sensitive language:
	1180	<code>and</code> is a reserved word, but <code>And</code> and <code>AND</code>
	1181	are two different, valid names.
	1182	As a convention, names starting with an underscore followed by
	1183	uppercase letters (such as <a href="#pdf-_VERSION"><code>_VERSION</code></a>)
	1184	are reserved for variables used by Lua.
	1185
	1186
	1187	<p>
	1188	The following strings denote other tokens:
	1189
	1190	<pre>
	1191	+ - * / % ^ #
	1192	== ~= <= >= < > =
	1193	( ) { } [ ] ::
	1194	; : , . .. ...
	1195	</pre>
	1196
	1197	<p>
	1198	<em>Literal strings</em>
	1199	can be delimited by matching single or double quotes,
	1200	and can contain the following C-like escape sequences:
	1201	'<code>\a</code>' (bell),
	1202	'<code>\b</code>' (backspace),
	1203	'<code>\f</code>' (form feed),
	1204	'<code>\n</code>' (newline),
	1205	'<code>\r</code>' (carriage return),
	1206	'<code>\t</code>' (horizontal tab),
	1207	'<code>\v</code>' (vertical tab),
	1208	'<code>\\</code>' (backslash),
	1209	'<code>\"</code>' (quotation mark [double quote]),
	1210	and '<code>\'</code>' (apostrophe [single quote]).
	1211	A backslash followed by a real newline
	1212	results in a newline in the string.
	1213	The escape sequence '<code>\z</code>' skips the following span
	1214	of white-space characters,
	1215	including line breaks;
	1216	it is particularly useful to break and indent a long literal string
	1217	into multiple lines without adding the newlines and spaces
	1218	into the string contents.
	1219
	1220
	1221	<p>
	1222	A byte in a literal string can also be specified by its numerical value.
	1223	This can be done with the escape sequence <code>\x<em>XX</em></code>,
	1224	where <em>XX</em> is a sequence of exactly two hexadecimal digits,
	1225	or with the escape sequence <code>\<em>ddd</em></code>,
	1226	where <em>ddd</em> is a sequence of up to three decimal digits.
	1227	(Note that if a decimal escape is to be followed by a digit,
	1228	it must be expressed using exactly three digits.)
	1229	Strings in Lua can contain any 8-bit value, including embedded zeros,
	1230	which can be specified as '<code>\0</code>'.
	1231
	1232
	1233	<p>
	1234	Literal strings can also be defined using a long format
	1235	enclosed by <em>long brackets</em>.
	1236	We define an <em>opening long bracket of level <em>n</em></em> as an opening
	1237	square bracket followed by <em>n</em> equal signs followed by another
	1238	opening square bracket.
	1239	So, an opening long bracket of level 0 is written as <code>[[</code>,
	1240	an opening long bracket of level 1 is written as <code>[=[</code>,
	1241	and so on.
	1242	A <em>closing long bracket</em> is defined similarly;
	1243	for instance, a closing long bracket of level 4 is written as <code>]====]</code>.
	1244	A <em>long literal</em> starts with an opening long bracket of any level and
	1245	ends at the first closing long bracket of the same level.
	1246	It can contain any text except a closing bracket of the proper level.
	1247	Literals in this bracketed form can run for several lines,
	1248	do not interpret any escape sequences,
	1249	and ignore long brackets of any other level.
	1250	Any kind of end-of-line sequence
	1251	(carriage return, newline, carriage return followed by newline,
	1252	or newline followed by carriage return)
	1253	is converted to a simple newline.
	1254
	1255
	1256	<p>
	1257	Any byte in a literal string not
	1258	explicitly affected by the previous rules represents itself.
	1259	However, Lua opens files for parsing in text mode,
	1260	and the system file functions may have problems with
	1261	some control characters.
	1262	So, it is safer to represent
	1263	non-text data as a quoted literal with
	1264	explicit escape sequences for non-text characters.
	1265
	1266
	1267	<p>
	1268	For convenience,
	1269	when the opening long bracket is immediately followed by a newline,
	1270	the newline is not included in the string.
	1271	As an example, in a system using ASCII
	1272	(in which '<code>a</code>' is coded as 97,
	1273	newline is coded as 10, and '<code>1</code>' is coded as 49),
	1274	the five literal strings below denote the same string:
	1275
	1276	<pre>
	1277	a = 'alo\n123"'
	1278	a = "alo\n123\""
	1279	a = '\97lo\10\04923"'
	1280	a = [[alo
	1281	123"]]
	1282	a = [==[
	1283	alo
	1284	123"]==]
	1285	</pre>
	1286
	1287	<p>
	1288	A <em>numerical constant</em> can be written with an optional fractional part
	1289	and an optional decimal exponent,
	1290	marked by a letter '<code>e</code>' or '<code>E</code>'.
	1291	Lua also accepts hexadecimal constants,
	1292	which start with <code>0x</code> or <code>0X</code>.
	1293	Hexadecimal constants also accept an optional fractional part
	1294	plus an optional binary exponent,
	1295	marked by a letter '<code>p</code>' or '<code>P</code>'.
	1296	Examples of valid numerical constants are
	1297
	1298	<pre>
	1299	3 3.0 3.1416 314.16e-2 0.31416E1
	1300	0xff 0x0.1E 0xA23p-4 0X1.921FB54442D18P+1
	1301	</pre>
	1302
	1303	<p>
	1304	A <em>comment</em> starts with a double hyphen (<code>--</code>)
	1305	anywhere outside a string.
	1306	If the text immediately after <code>--</code> is not an opening long bracket,
	1307	the comment is a <em>short comment</em>,
	1308	which runs until the end of the line.
	1309	Otherwise, it is a <em>long comment</em>,
	1310	which runs until the corresponding closing long bracket.
	1311	Long comments are frequently used to disable code temporarily.
	1312
	1313
	1314
	1315
	1316
	1317	<h2>3.2 – <a name="3.2">Variables</a></h2>
	1318
	1319	<p>
	1320	Variables are places that store values.
	1321	There are three kinds of variables in Lua:
	1322	global variables, local variables, and table fields.
	1323
	1324
	1325	<p>
	1326	A single name can denote a global variable or a local variable
	1327	(or a function's formal parameter,
	1328	which is a particular kind of local variable):
	1329
	1330	<pre>
	1331	var ::= Name
	1332	</pre><p>
	1333	Name denotes identifiers, as defined in <a href="#3.1">§3.1</a>.
	1334
	1335
	1336	<p>
	1337	Any variable name is assumed to be global unless explicitly declared
	1338	as a local (see <a href="#3.3.7">§3.3.7</a>).
	1339	Local variables are <em>lexically scoped</em>:
	1340	local variables can be freely accessed by functions
	1341	defined inside their scope (see <a href="#3.5">§3.5</a>).
	1342
	1343
	1344	<p>
	1345	Before the first assignment to a variable, its value is <b>nil</b>.
	1346
	1347
	1348	<p>
	1349	Square brackets are used to index a table:
	1350
	1351	<pre>
	1352	var ::= prefixexp ‘<b>[</b>’ exp ‘<b>]</b>’
	1353	</pre><p>
	1354	The meaning of accesses to table fields can be changed via metatables.
	1355	An access to an indexed variable <code>t[i]</code> is equivalent to
	1356	a call <code>gettable_event(t,i)</code>.
	1357	(See <a href="#2.4">§2.4</a> for a complete description of the
	1358	<code>gettable_event</code> function.
	1359	This function is not defined or callable in Lua.
	1360	We use it here only for explanatory purposes.)
	1361
	1362
	1363	<p>
	1364	The syntax <code>var.Name</code> is just syntactic sugar for
	1365	<code>var["Name"]</code>:
	1366
	1367	<pre>
	1368	var ::= prefixexp ‘<b>.</b>’ Name
	1369	</pre>
	1370
	1371	<p>
	1372	An access to a global variable <code>x</code>
	1373	is equivalent to <code>_ENV.x</code>.
	1374	Due to the way that chunks are compiled,
	1375	<code>_ENV</code> is never a global name (see <a href="#2.2">§2.2</a>).
	1376
	1377
	1378
	1379
	1380
	1381	<h2>3.3 – <a name="3.3">Statements</a></h2>
	1382
	1383	<p>
	1384	Lua supports an almost conventional set of statements,
	1385	similar to those in Pascal or C.
	1386	This set includes
	1387	assignments, control structures, function calls,
	1388	and variable declarations.
	1389
	1390
	1391
	1392	<h3>3.3.1 – <a name="3.3.1">Blocks</a></h3>
	1393
	1394	<p>
	1395	A block is a list of statements,
	1396	which are executed sequentially:
	1397
	1398	<pre>
	1399	block ::= {stat}
	1400	</pre><p>
	1401	Lua has <em>empty statements</em>
	1402	that allow you to separate statements with semicolons,
	1403	start a block with a semicolon
	1404	or write two semicolons in sequence:
	1405
	1406	<pre>
	1407	stat ::= ‘<b>;</b>’
	1408	</pre>
	1409
	1410	<p>
	1411	Function calls and assignments
	1412	can start with an open parenthesis.
	1413	This possibility leads to an ambiguity in Lua's grammar.
	1414	Consider the following fragment:
	1415
	1416	<pre>
	1417	a = b + c
	1418	(print or io.write)('done')
	1419	</pre><p>
	1420	The grammar could see it in two ways:
	1421
	1422	<pre>
	1423	a = b + c(print or io.write)('done')
	1424
	1425	a = b + c; (print or io.write)('done')
	1426	</pre><p>
	1427	The current parser always sees such constructions
	1428	in the first way,
	1429	interpreting the open parenthesis
	1430	as the start of the arguments to a call.
	1431	To avoid this ambiguity,
	1432	it is a good practice to always precede with a semicolon
	1433	statements that start with a parenthesis:
	1434
	1435	<pre>
	1436	;(print or io.write)('done')
	1437	</pre>
	1438
	1439	<p>
	1440	A block can be explicitly delimited to produce a single statement:
	1441
	1442	<pre>
	1443	stat ::= <b>do</b> block <b>end</b>
	1444	</pre><p>
	1445	Explicit blocks are useful
	1446	to control the scope of variable declarations.
	1447	Explicit blocks are also sometimes used to
	1448	add a <b>return</b> statement in the middle
	1449	of another block (see <a href="#3.3.4">§3.3.4</a>).
	1450
	1451
	1452
	1453
	1454
	1455	<h3>3.3.2 – <a name="3.3.2">Chunks</a></h3>
	1456
	1457	<p>
	1458	The unit of compilation of Lua is called a <em>chunk</em>.
	1459	Syntactically,
	1460	a chunk is simply a block:
	1461
	1462	<pre>
	1463	chunk ::= block
	1464	</pre>
	1465
	1466	<p>
	1467	Lua handles a chunk as the body of an anonymous function
	1468	with a variable number of arguments
	1469	(see <a href="#3.4.10">§3.4.10</a>).
	1470	As such, chunks can define local variables,
	1471	receive arguments, and return values.
	1472	Moreover, such anonymous function is compiled as in the
	1473	scope of an external local variable called <code>_ENV</code> (see <a href="#2.2">§2.2</a>).
	1474	The resulting function always has <code>_ENV</code> as its only upvalue,
	1475	even if it does not use that variable.
	1476
	1477
	1478	<p>
	1479	A chunk can be stored in a file or in a string inside the host program.
	1480	To execute a chunk,
	1481	Lua first precompiles the chunk into instructions for a virtual machine,
	1482	and then it executes the compiled code
	1483	with an interpreter for the virtual machine.
	1484
	1485
	1486	<p>
	1487	Chunks can also be precompiled into binary form;
	1488	see program <code>luac</code> for details.
	1489	Programs in source and compiled forms are interchangeable;
	1490	Lua automatically detects the file type and acts accordingly.
	1491
	1492
	1493
	1494
	1495
	1496
	1497	<h3>3.3.3 – <a name="3.3.3">Assignment</a></h3>
	1498
	1499	<p>
	1500	Lua allows multiple assignments.
	1501	Therefore, the syntax for assignment
	1502	defines a list of variables on the left side
	1503	and a list of expressions on the right side.
	1504	The elements in both lists are separated by commas:
	1505
	1506	<pre>
	1507	stat ::= varlist ‘<b>=</b>’ explist
	1508	varlist ::= var {‘<b>,</b>’ var}
	1509	explist ::= exp {‘<b>,</b>’ exp}
	1510	</pre><p>
	1511	Expressions are discussed in <a href="#3.4">§3.4</a>.
	1512
	1513
	1514	<p>
	1515	Before the assignment,
	1516	the list of values is <em>adjusted</em> to the length of
	1517	the list of variables.
	1518	If there are more values than needed,
	1519	the excess values are thrown away.
	1520	If there are fewer values than needed,
	1521	the list is extended with as many <b>nil</b>'s as needed.
	1522	If the list of expressions ends with a function call,
	1523	then all values returned by that call enter the list of values,
	1524	before the adjustment
	1525	(except when the call is enclosed in parentheses; see <a href="#3.4">§3.4</a>).
	1526
	1527
	1528	<p>
	1529	The assignment statement first evaluates all its expressions
	1530	and only then are the assignments performed.
	1531	Thus the code
	1532
	1533	<pre>
	1534	i = 3
	1535	i, a[i] = i+1, 20
	1536	</pre><p>
	1537	sets <code>a[3]</code> to 20, without affecting <code>a[4]</code>
	1538	because the <code>i</code> in <code>a[i]</code> is evaluated (to 3)
	1539	before it is assigned 4.
	1540	Similarly, the line
	1541
	1542	<pre>
	1543	x, y = y, x
	1544	</pre><p>
	1545	exchanges the values of <code>x</code> and <code>y</code>,
	1546	and
	1547
	1548	<pre>
	1549	x, y, z = y, z, x
	1550	</pre><p>
	1551	cyclically permutes the values of <code>x</code>, <code>y</code>, and <code>z</code>.
	1552
	1553
	1554	<p>
	1555	The meaning of assignments to global variables
	1556	and table fields can be changed via metatables.
	1557	An assignment to an indexed variable <code>t[i] = val</code> is equivalent to
	1558	<code>settable_event(t,i,val)</code>.
	1559	(See <a href="#2.4">§2.4</a> for a complete description of the
	1560	<code>settable_event</code> function.
	1561	This function is not defined or callable in Lua.
	1562	We use it here only for explanatory purposes.)
	1563
	1564
	1565	<p>
	1566	An assignment to a global variable <code>x = val</code>
	1567	is equivalent to the assignment
	1568	<code>_ENV.x = val</code> (see <a href="#2.2">§2.2</a>).
	1569
	1570
	1571
	1572
	1573
	1574	<h3>3.3.4 – <a name="3.3.4">Control Structures</a></h3><p>
	1575	The control structures
	1576	<b>if</b>, <b>while</b>, and <b>repeat</b> have the usual meaning and
	1577	familiar syntax:
	1578
	1579
	1580
	1581
	1582	<pre>
	1583	stat ::= <b>while</b> exp <b>do</b> block <b>end</b>
	1584	stat ::= <b>repeat</b> block <b>until</b> exp
	1585	stat ::= <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b>
	1586	</pre><p>
	1587	Lua also has a <b>for</b> statement, in two flavors (see <a href="#3.3.5">§3.3.5</a>).
	1588
	1589
	1590	<p>
	1591	The condition expression of a
	1592	control structure can return any value.
	1593	Both <b>false</b> and <b>nil</b> are considered false.
	1594	All values different from <b>nil</b> and <b>false</b> are considered true
	1595	(in particular, the number 0 and the empty string are also true).
	1596
	1597
	1598	<p>
	1599	In the <b>repeat</b>–<b>until</b> loop,
	1600	the inner block does not end at the <b>until</b> keyword,
	1601	but only after the condition.
	1602	So, the condition can refer to local variables
	1603	declared inside the loop block.
	1604
	1605
	1606	<p>
	1607	The <b>goto</b> statement transfers the program control to a label.
	1608	For syntactical reasons,
	1609	labels in Lua are considered statements too:
	1610
	1611
	1612
	1613	<pre>
	1614	stat ::= <b>goto</b> Name
	1615	stat ::= label
	1616	label ::= ‘<b>::</b>’ Name ‘<b>::</b>’
	1617	</pre>
	1618
	1619	<p>
	1620	A label is visible in the entire block where it is defined,
	1621	except
	1622	inside nested blocks where a label with the same name is defined and
	1623	inside nested functions.
	1624	A goto may jump to any visible label as long as it does not
	1625	enter into the scope of a local variable.
	1626
	1627
	1628	<p>
	1629	Labels and empty statements are called <em>void statements</em>,
	1630	as they perform no actions.
	1631
	1632
	1633	<p>
	1634	The <b>break</b> statement terminates the execution of a
	1635	<b>while</b>, <b>repeat</b>, or <b>for</b> loop,
	1636	skipping to the next statement after the loop:
	1637
	1638
	1639	<pre>
	1640	stat ::= <b>break</b>
	1641	</pre><p>
	1642	A <b>break</b> ends the innermost enclosing loop.
	1643
	1644
	1645	<p>
	1646	The <b>return</b> statement is used to return values
	1647	from a function or a chunk (which is a function in disguise).
	1648
	1649	Functions can return more than one value,
	1650	so the syntax for the <b>return</b> statement is
	1651
	1652	<pre>
	1653	stat ::= <b>return</b> [explist] [‘<b>;</b>’]
	1654	</pre>
	1655
	1656	<p>
	1657	The <b>return</b> statement can only be written
	1658	as the last statement of a block.
	1659	If it is really necessary to <b>return</b> in the middle of a block,
	1660	then an explicit inner block can be used,
	1661	as in the idiom <code>do return end</code>,
	1662	because now <b>return</b> is the last statement in its (inner) block.
	1663
	1664
	1665
	1666
	1667
	1668	<h3>3.3.5 – <a name="3.3.5">For Statement</a></h3>
	1669
	1670	<p>
	1671
	1672	The <b>for</b> statement has two forms:
	1673	one numeric and one generic.
	1674
	1675
	1676	<p>
	1677	The numeric <b>for</b> loop repeats a block of code while a
	1678	control variable runs through an arithmetic progression.
	1679	It has the following syntax:
	1680
	1681	<pre>
	1682	stat ::= <b>for</b> Name ‘<b>=</b>’ exp ‘<b>,</b>’ exp [‘<b>,</b>’ exp] <b>do</b> block <b>end</b>
	1683	</pre><p>
	1684	The <em>block</em> is repeated for <em>name</em> starting at the value of
	1685	the first <em>exp</em>, until it passes the second <em>exp</em> by steps of the
	1686	third <em>exp</em>.
	1687	More precisely, a <b>for</b> statement like
	1688
	1689	<pre>
	1690	for v = <em>e1</em>, <em>e2</em>, <em>e3</em> do <em>block</em> end
	1691	</pre><p>
	1692	is equivalent to the code:
	1693
	1694	<pre>
	1695	do
	1696	local <em>var</em>, <em>limit</em>, <em>step</em> = tonumber(<em>e1</em>), tonumber(<em>e2</em>), tonumber(<em>e3</em>)
	1697	if not (<em>var</em> and <em>limit</em> and <em>step</em>) then error() end
	1698	while (<em>step</em> > 0 and <em>var</em> <= <em>limit</em>) or (<em>step</em> <= 0 and <em>var</em> >= <em>limit</em>) do
	1699	local v = <em>var</em>
	1700	<em>block</em>
	1701	<em>var</em> = <em>var</em> + <em>step</em>
	1702	end
	1703	end
	1704	</pre><p>
	1705	Note the following:
	1706
	1707	<ul>
	1708
	1709	<li>
	1710	All three control expressions are evaluated only once,
	1711	before the loop starts.
	1712	They must all result in numbers.
	1713	</li>
	1714
	1715	<li>
	1716	<code><em>var</em></code>, <code><em>limit</em></code>, and <code><em>step</em></code> are invisible variables.
	1717	The names shown here are for explanatory purposes only.
	1718	</li>
	1719
	1720	<li>
	1721	If the third expression (the step) is absent,
	1722	then a step of 1 is used.
	1723	</li>
	1724
	1725	<li>
	1726	You can use <b>break</b> to exit a <b>for</b> loop.
	1727	</li>
	1728
	1729	<li>
	1730	The loop variable <code>v</code> is local to the loop;
	1731	you cannot use its value after the <b>for</b> ends or is broken.
	1732	If you need this value,
	1733	assign it to another variable before breaking or exiting the loop.
	1734	</li>
	1735
	1736	</ul>
	1737
	1738	<p>
	1739	The generic <b>for</b> statement works over functions,
	1740	called <em>iterators</em>.
	1741	On each iteration, the iterator function is called to produce a new value,
	1742	stopping when this new value is <b>nil</b>.
	1743	The generic <b>for</b> loop has the following syntax:
	1744
	1745	<pre>
	1746	stat ::= <b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b>
	1747	namelist ::= Name {‘<b>,</b>’ Name}
	1748	</pre><p>
	1749	A <b>for</b> statement like
	1750
	1751	<pre>
	1752	for <em>var_1</em>, ···, <em>var_n</em> in <em>explist</em> do <em>block</em> end
	1753	</pre><p>
	1754	is equivalent to the code:
	1755
	1756	<pre>
	1757	do
	1758	local <em>f</em>, <em>s</em>, <em>var</em> = <em>explist</em>
	1759	while true do
	1760	local <em>var_1</em>, ···, <em>var_n</em> = <em>f</em>(<em>s</em>, <em>var</em>)
	1761	if <em>var_1</em> == nil then break end
	1762	<em>var</em> = <em>var_1</em>
	1763	<em>block</em>
	1764	end
	1765	end
	1766	</pre><p>
	1767	Note the following:
	1768
	1769	<ul>
	1770
	1771	<li>
	1772	<code><em>explist</em></code> is evaluated only once.
	1773	Its results are an <em>iterator</em> function,
	1774	a <em>state</em>,
	1775	and an initial value for the first <em>iterator variable</em>.
	1776	</li>
	1777
	1778	<li>
	1779	<code><em>f</em></code>, <code><em>s</em></code>, and <code><em>var</em></code> are invisible variables.
	1780	The names are here for explanatory purposes only.
	1781	</li>
	1782
	1783	<li>
	1784	You can use <b>break</b> to exit a <b>for</b> loop.
	1785	</li>
	1786
	1787	<li>
	1788	The loop variables <code><em>var_i</em></code> are local to the loop;
	1789	you cannot use their values after the <b>for</b> ends.
	1790	If you need these values,
	1791	then assign them to other variables before breaking or exiting the loop.
	1792	</li>
	1793
	1794	</ul>
	1795
	1796
	1797
	1798
	1799	<h3>3.3.6 – <a name="3.3.6">Function Calls as Statements</a></h3><p>
	1800	To allow possible side-effects,
	1801	function calls can be executed as statements:
	1802
	1803	<pre>
	1804	stat ::= functioncall
	1805	</pre><p>
	1806	In this case, all returned values are thrown away.
	1807	Function calls are explained in <a href="#3.4.9">§3.4.9</a>.
	1808
	1809
	1810
	1811
	1812
	1813	<h3>3.3.7 – <a name="3.3.7">Local Declarations</a></h3><p>
	1814	Local variables can be declared anywhere inside a block.
	1815	The declaration can include an initial assignment:
	1816
	1817	<pre>
	1818	stat ::= <b>local</b> namelist [‘<b>=</b>’ explist]
	1819	</pre><p>
	1820	If present, an initial assignment has the same semantics
	1821	of a multiple assignment (see <a href="#3.3.3">§3.3.3</a>).
	1822	Otherwise, all variables are initialized with <b>nil</b>.
	1823
	1824
	1825	<p>
	1826	A chunk is also a block (see <a href="#3.3.2">§3.3.2</a>),
	1827	and so local variables can be declared in a chunk outside any explicit block.
	1828
	1829
	1830	<p>
	1831	The visibility rules for local variables are explained in <a href="#3.5">§3.5</a>.
	1832
	1833
	1834
	1835
	1836
	1837
	1838
	1839	<h2>3.4 – <a name="3.4">Expressions</a></h2>
	1840
	1841	<p>
	1842	The basic expressions in Lua are the following:
	1843
	1844	<pre>
	1845	exp ::= prefixexp
	1846	exp ::= <b>nil</b> \| <b>false</b> \| <b>true</b>
	1847	exp ::= Number
	1848	exp ::= String
	1849	exp ::= functiondef
	1850	exp ::= tableconstructor
	1851	exp ::= ‘<b>...</b>’
	1852	exp ::= exp binop exp
	1853	exp ::= unop exp
	1854	prefixexp ::= var \| functioncall \| ‘<b>(</b>’ exp ‘<b>)</b>’
	1855	</pre>
	1856
	1857	<p>
	1858	Numbers and literal strings are explained in <a href="#3.1">§3.1</a>;
	1859	variables are explained in <a href="#3.2">§3.2</a>;
	1860	function definitions are explained in <a href="#3.4.10">§3.4.10</a>;
	1861	function calls are explained in <a href="#3.4.9">§3.4.9</a>;
	1862	table constructors are explained in <a href="#3.4.8">§3.4.8</a>.
	1863	Vararg expressions,
	1864	denoted by three dots ('<code>...</code>'), can only be used when
	1865	directly inside a vararg function;
	1866	they are explained in <a href="#3.4.10">§3.4.10</a>.
	1867
	1868
	1869	<p>
	1870	Binary operators comprise arithmetic operators (see <a href="#3.4.1">§3.4.1</a>),
	1871	relational operators (see <a href="#3.4.3">§3.4.3</a>), logical operators (see <a href="#3.4.4">§3.4.4</a>),
	1872	and the concatenation operator (see <a href="#3.4.5">§3.4.5</a>).
	1873	Unary operators comprise the unary minus (see <a href="#3.4.1">§3.4.1</a>),
	1874	the unary <b>not</b> (see <a href="#3.4.4">§3.4.4</a>),
	1875	and the unary <em>length operator</em> (see <a href="#3.4.6">§3.4.6</a>).
	1876
	1877
	1878	<p>
	1879	Both function calls and vararg expressions can result in multiple values.
	1880	If a function call is used as a statement (see <a href="#3.3.6">§3.3.6</a>),
	1881	then its return list is adjusted to zero elements,
	1882	thus discarding all returned values.
	1883	If an expression is used as the last (or the only) element
	1884	of a list of expressions,
	1885	then no adjustment is made
	1886	(unless the expression is enclosed in parentheses).
	1887	In all other contexts,
	1888	Lua adjusts the result list to one element,
	1889	either discarding all values except the first one
	1890	or adding a single <b>nil</b> if there are no values.
	1891
	1892
	1893	<p>
	1894	Here are some examples:
	1895
	1896	<pre>
	1897	f() -- adjusted to 0 results
	1898	g(f(), x) -- f() is adjusted to 1 result
	1899	g(x, f()) -- g gets x plus all results from f()
	1900	a,b,c = f(), x -- f() is adjusted to 1 result (c gets nil)
	1901	a,b = ... -- a gets the first vararg parameter, b gets
	1902	-- the second (both a and b can get nil if there
	1903	-- is no corresponding vararg parameter)
	1904
	1905	a,b,c = x, f() -- f() is adjusted to 2 results
	1906	a,b,c = f() -- f() is adjusted to 3 results
	1907	return f() -- returns all results from f()
	1908	return ... -- returns all received vararg parameters
	1909	return x,y,f() -- returns x, y, and all results from f()
	1910	{f()} -- creates a list with all results from f()
	1911	{...} -- creates a list with all vararg parameters
	1912	{f(), nil} -- f() is adjusted to 1 result
	1913	</pre>
	1914
	1915	<p>
	1916	Any expression enclosed in parentheses always results in only one value.
	1917	Thus,
	1918	<code>(f(x,y,z))</code> is always a single value,
	1919	even if <code>f</code> returns several values.
	1920	(The value of <code>(f(x,y,z))</code> is the first value returned by <code>f</code>
	1921	or <b>nil</b> if <code>f</code> does not return any values.)
	1922
	1923
	1924
	1925	<h3>3.4.1 – <a name="3.4.1">Arithmetic Operators</a></h3><p>
	1926	Lua supports the usual arithmetic operators:
	1927	the binary <code>+</code> (addition),
	1928	<code>-</code> (subtraction), <code>*</code> (multiplication),
	1929	<code>/</code> (division), <code>%</code> (modulo), and <code>^</code> (exponentiation);
	1930	and unary <code>-</code> (mathematical negation).
	1931	If the operands are numbers, or strings that can be converted to
	1932	numbers (see <a href="#3.4.2">§3.4.2</a>),
	1933	then all operations have the usual meaning.
	1934	Exponentiation works for any exponent.
	1935	For instance, <code>x^(-0.5)</code> computes the inverse of the square root of <code>x</code>.
	1936	Modulo is defined as
	1937
	1938	<pre>
	1939	a % b == a - math.floor(a/b)*b
	1940	</pre><p>
	1941	That is, it is the remainder of a division that rounds
	1942	the quotient towards minus infinity.
	1943
	1944
	1945
	1946
	1947
	1948	<h3>3.4.2 – <a name="3.4.2">Coercion</a></h3>
	1949
	1950	<p>
	1951	Lua provides automatic conversion between
	1952	string and number values at run time.
	1953	Any arithmetic operation applied to a string tries to convert
	1954	this string to a number, following the rules of the Lua lexer.
	1955	(The string may have leading and trailing spaces and a sign.)
	1956	Conversely, whenever a number is used where a string is expected,
	1957	the number is converted to a string, in a reasonable format.
	1958	For complete control over how numbers are converted to strings,
	1959	use the <code>format</code> function from the string library
	1960	(see <a href="#pdf-string.format"><code>string.format</code></a>).
	1961
	1962
	1963
	1964
	1965
	1966	<h3>3.4.3 – <a name="3.4.3">Relational Operators</a></h3><p>
	1967	The relational operators in Lua are
	1968
	1969	<pre>
	1970	== ~= < > <= >=
	1971	</pre><p>
	1972	These operators always result in <b>false</b> or <b>true</b>.
	1973
	1974
	1975	<p>
	1976	Equality (<code>==</code>) first compares the type of its operands.
	1977	If the types are different, then the result is <b>false</b>.
	1978	Otherwise, the values of the operands are compared.
	1979	Numbers and strings are compared in the usual way.
	1980	Tables, userdata, and threads
	1981	are compared by reference:
	1982	two objects are considered equal only if they are the same object.
	1983	Every time you create a new object
	1984	(a table, userdata, or thread),
	1985	this new object is different from any previously existing object.
	1986	Closures with the same reference are always equal.
	1987	Closures with any detectable difference
	1988	(different behavior, different definition) are always different.
	1989
	1990
	1991	<p>
	1992	You can change the way that Lua compares tables and userdata
	1993	by using the "eq" metamethod (see <a href="#2.4">§2.4</a>).
	1994
	1995
	1996	<p>
	1997	The conversion rules of <a href="#3.4.2">§3.4.2</a>
	1998	do not apply to equality comparisons.
	1999	Thus, <code>"0"==0</code> evaluates to <b>false</b>,
	2000	and <code>t[0]</code> and <code>t["0"]</code> denote different
	2001	entries in a table.
	2002
	2003
	2004	<p>
	2005	The operator <code>~=</code> is exactly the negation of equality (<code>==</code>).
	2006
	2007
	2008	<p>
	2009	The order operators work as follows.
	2010	If both arguments are numbers, then they are compared as such.
	2011	Otherwise, if both arguments are strings,
	2012	then their values are compared according to the current locale.
	2013	Otherwise, Lua tries to call the "lt" or the "le"
	2014	metamethod (see <a href="#2.4">§2.4</a>).
	2015	A comparison <code>a > b</code> is translated to <code>b < a</code>
	2016	and <code>a >= b</code> is translated to <code>b <= a</code>.
	2017
	2018
	2019
	2020
	2021
	2022	<h3>3.4.4 – <a name="3.4.4">Logical Operators</a></h3><p>
	2023	The logical operators in Lua are
	2024	<b>and</b>, <b>or</b>, and <b>not</b>.
	2025	Like the control structures (see <a href="#3.3.4">§3.3.4</a>),
	2026	all logical operators consider both <b>false</b> and <b>nil</b> as false
	2027	and anything else as true.
	2028
	2029
	2030	<p>
	2031	The negation operator <b>not</b> always returns <b>false</b> or <b>true</b>.
	2032	The conjunction operator <b>and</b> returns its first argument
	2033	if this value is <b>false</b> or <b>nil</b>;
	2034	otherwise, <b>and</b> returns its second argument.
	2035	The disjunction operator <b>or</b> returns its first argument
	2036	if this value is different from <b>nil</b> and <b>false</b>;
	2037	otherwise, <b>or</b> returns its second argument.
	2038	Both <b>and</b> and <b>or</b> use short-cut evaluation;
	2039	that is,
	2040	the second operand is evaluated only if necessary.
	2041	Here are some examples:
	2042
	2043	<pre>
	2044	10 or 20 --> 10
	2045	10 or error() --> 10
	2046	nil or "a" --> "a"
	2047	nil and 10 --> nil
	2048	false and error() --> false
	2049	false and nil --> false
	2050	false or nil --> nil
	2051	10 and 20 --> 20
	2052	</pre><p>
	2053	(In this manual,
	2054	<code>--></code> indicates the result of the preceding expression.)
	2055
	2056
	2057
	2058
	2059
	2060	<h3>3.4.5 – <a name="3.4.5">Concatenation</a></h3><p>
	2061	The string concatenation operator in Lua is
	2062	denoted by two dots ('<code>..</code>').
	2063	If both operands are strings or numbers, then they are converted to
	2064	strings according to the rules mentioned in <a href="#3.4.2">§3.4.2</a>.
	2065	Otherwise, the <code>__concat</code> metamethod is called (see <a href="#2.4">§2.4</a>).
	2066
	2067
	2068
	2069
	2070
	2071	<h3>3.4.6 – <a name="3.4.6">The Length Operator</a></h3>
	2072
	2073	<p>
	2074	The length operator is denoted by the unary prefix operator <code>#</code>.
	2075	The length of a string is its number of bytes
	2076	(that is, the usual meaning of string length when each
	2077	character is one byte).
	2078
	2079
	2080	<p>
	2081	A program can modify the behavior of the length operator for
	2082	any value but strings through the <code>__len</code> metamethod (see <a href="#2.4">§2.4</a>).
	2083
	2084
	2085	<p>
	2086	Unless a <code>__len</code> metamethod is given,
	2087	the length of a table <code>t</code> is only defined if the
	2088	table is a <em>sequence</em>,
	2089	that is,
	2090	the set of its positive numeric keys is equal to <em>{1..n}</em>
	2091	for some integer <em>n</em>.
	2092	In that case, <em>n</em> is its length.
	2093	Note that a table like
	2094
	2095	<pre>
	2096	{10, 20, nil, 40}
	2097	</pre><p>
	2098	is not a sequence, because it has the key <code>4</code>
	2099	but does not have the key <code>3</code>.
	2100	(So, there is no <em>n</em> such that the set <em>{1..n}</em> is equal
	2101	to the set of positive numeric keys of that table.)
	2102	Note, however, that non-numeric keys do not interfere
	2103	with whether a table is a sequence.
	2104
	2105
	2106
	2107
	2108
	2109	<h3>3.4.7 – <a name="3.4.7">Precedence</a></h3><p>
	2110	Operator precedence in Lua follows the table below,
	2111	from lower to higher priority:
	2112
	2113	<pre>
	2114	or
	2115	and
	2116	< > <= >= ~= ==
	2117	..
	2118	+ -
	2119	* / %
	2120	not # - (unary)
	2121	^
	2122	</pre><p>
	2123	As usual,
	2124	you can use parentheses to change the precedences of an expression.
	2125	The concatenation ('<code>..</code>') and exponentiation ('<code>^</code>')
	2126	operators are right associative.
	2127	All other binary operators are left associative.
	2128
	2129
	2130
	2131
	2132
	2133	<h3>3.4.8 – <a name="3.4.8">Table Constructors</a></h3><p>
	2134	Table constructors are expressions that create tables.
	2135	Every time a constructor is evaluated, a new table is created.
	2136	A constructor can be used to create an empty table
	2137	or to create a table and initialize some of its fields.
	2138	The general syntax for constructors is
	2139
	2140	<pre>
	2141	tableconstructor ::= ‘<b>{</b>’ [fieldlist] ‘<b>}</b>’
	2142	fieldlist ::= field {fieldsep field} [fieldsep]
	2143	field ::= ‘<b>[</b>’ exp ‘<b>]</b>’ ‘<b>=</b>’ exp \| Name ‘<b>=</b>’ exp \| exp
	2144	fieldsep ::= ‘<b>,</b>’ \| ‘<b>;</b>’
	2145	</pre>
	2146
	2147	<p>
	2148	Each field of the form <code>[exp1] = exp2</code> adds to the new table an entry
	2149	with key <code>exp1</code> and value <code>exp2</code>.
	2150	A field of the form <code>name = exp</code> is equivalent to
	2151	<code>["name"] = exp</code>.
	2152	Finally, fields of the form <code>exp</code> are equivalent to
	2153	<code>[i] = exp</code>, where <code>i</code> are consecutive numerical integers,
	2154	starting with 1.
	2155	Fields in the other formats do not affect this counting.
	2156	For example,
	2157
	2158	<pre>
	2159	a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
	2160	</pre><p>
	2161	is equivalent to
	2162
	2163	<pre>
	2164	do
	2165	local t = {}
	2166	t[f(1)] = g
	2167	t[1] = "x" -- 1st exp
	2168	t[2] = "y" -- 2nd exp
	2169	t.x = 1 -- t["x"] = 1
	2170	t[3] = f(x) -- 3rd exp
	2171	t[30] = 23
	2172	t[4] = 45 -- 4th exp
	2173	a = t
	2174	end
	2175	</pre>
	2176
	2177	<p>
	2178	If the last field in the list has the form <code>exp</code>
	2179	and the expression is a function call or a vararg expression,
	2180	then all values returned by this expression enter the list consecutively
	2181	(see <a href="#3.4.9">§3.4.9</a>).
	2182
	2183
	2184	<p>
	2185	The field list can have an optional trailing separator,
	2186	as a convenience for machine-generated code.
	2187
	2188
	2189
	2190
	2191
	2192	<h3>3.4.9 – <a name="3.4.9">Function Calls</a></h3><p>
	2193	A function call in Lua has the following syntax:
	2194
	2195	<pre>
	2196	functioncall ::= prefixexp args
	2197	</pre><p>
	2198	In a function call,
	2199	first prefixexp and args are evaluated.
	2200	If the value of prefixexp has type <em>function</em>,
	2201	then this function is called
	2202	with the given arguments.
	2203	Otherwise, the prefixexp "call" metamethod is called,
	2204	having as first parameter the value of prefixexp,
	2205	followed by the original call arguments
	2206	(see <a href="#2.4">§2.4</a>).
	2207
	2208
	2209	<p>
	2210	The form
	2211
	2212	<pre>
	2213	functioncall ::= prefixexp ‘<b>:</b>’ Name args
	2214	</pre><p>
	2215	can be used to call "methods".
	2216	A call <code>v:name(<em>args</em>)</code>
	2217	is syntactic sugar for <code>v.name(v,<em>args</em>)</code>,
	2218	except that <code>v</code> is evaluated only once.
	2219
	2220
	2221	<p>
	2222	Arguments have the following syntax:
	2223
	2224	<pre>
	2225	args ::= ‘<b>(</b>’ [explist] ‘<b>)</b>’
	2226	args ::= tableconstructor
	2227	args ::= String
	2228	</pre><p>
	2229	All argument expressions are evaluated before the call.
	2230	A call of the form <code>f{<em>fields</em>}</code> is
	2231	syntactic sugar for <code>f({<em>fields</em>})</code>;
	2232	that is, the argument list is a single new table.
	2233	A call of the form <code>f'<em>string</em>'</code>
	2234	(or <code>f"<em>string</em>"</code> or <code>f[[<em>string</em>]]</code>)
	2235	is syntactic sugar for <code>f('<em>string</em>')</code>;
	2236	that is, the argument list is a single literal string.
	2237
	2238
	2239	<p>
	2240	A call of the form <code>return <em>functioncall</em></code> is called
	2241	a <em>tail call</em>.
	2242	Lua implements <em>proper tail calls</em>
	2243	(or <em>proper tail recursion</em>):
	2244	in a tail call,
	2245	the called function reuses the stack entry of the calling function.
	2246	Therefore, there is no limit on the number of nested tail calls that
	2247	a program can execute.
	2248	However, a tail call erases any debug information about the
	2249	calling function.
	2250	Note that a tail call only happens with a particular syntax,
	2251	where the <b>return</b> has one single function call as argument;
	2252	this syntax makes the calling function return exactly
	2253	the returns of the called function.
	2254	So, none of the following examples are tail calls:
	2255
	2256	<pre>
	2257	return (f(x)) -- results adjusted to 1
	2258	return 2 * f(x)
	2259	return x, f(x) -- additional results
	2260	f(x); return -- results discarded
	2261	return x or f(x) -- results adjusted to 1
	2262	</pre>
	2263
	2264
	2265
	2266
	2267	<h3>3.4.10 – <a name="3.4.10">Function Definitions</a></h3>
	2268
	2269	<p>
	2270	The syntax for function definition is
	2271
	2272	<pre>
	2273	functiondef ::= <b>function</b> funcbody
	2274	funcbody ::= ‘<b>(</b>’ [parlist] ‘<b>)</b>’ block <b>end</b>
	2275	</pre>
	2276
	2277	<p>
	2278	The following syntactic sugar simplifies function definitions:
	2279
	2280	<pre>
	2281	stat ::= <b>function</b> funcname funcbody
	2282	stat ::= <b>local</b> <b>function</b> Name funcbody
	2283	funcname ::= Name {‘<b>.</b>’ Name} [‘<b>:</b>’ Name]
	2284	</pre><p>
	2285	The statement
	2286
	2287	<pre>
	2288	function f () <em>body</em> end
	2289	</pre><p>
	2290	translates to
	2291
	2292	<pre>
	2293	f = function () <em>body</em> end
	2294	</pre><p>
	2295	The statement
	2296
	2297	<pre>
	2298	function t.a.b.c.f () <em>body</em> end
	2299	</pre><p>
	2300	translates to
	2301
	2302	<pre>
	2303	t.a.b.c.f = function () <em>body</em> end
	2304	</pre><p>
	2305	The statement
	2306
	2307	<pre>
	2308	local function f () <em>body</em> end
	2309	</pre><p>
	2310	translates to
	2311
	2312	<pre>
	2313	local f; f = function () <em>body</em> end
	2314	</pre><p>
	2315	not to
	2316
	2317	<pre>
	2318	local f = function () <em>body</em> end
	2319	</pre><p>
	2320	(This only makes a difference when the body of the function
	2321	contains references to <code>f</code>.)
	2322
	2323
	2324	<p>
	2325	A function definition is an executable expression,
	2326	whose value has type <em>function</em>.
	2327	When Lua precompiles a chunk,
	2328	all its function bodies are precompiled too.
	2329	Then, whenever Lua executes the function definition,
	2330	the function is <em>instantiated</em> (or <em>closed</em>).
	2331	This function instance (or <em>closure</em>)
	2332	is the final value of the expression.
	2333
	2334
	2335	<p>
	2336	Parameters act as local variables that are
	2337	initialized with the argument values:
	2338
	2339	<pre>
	2340	parlist ::= namelist [‘<b>,</b>’ ‘<b>...</b>’] \| ‘<b>...</b>’
	2341	</pre><p>
	2342	When a function is called,
	2343	the list of arguments is adjusted to
	2344	the length of the list of parameters,
	2345	unless the function is a <em>vararg function</em>,
	2346	which is indicated by three dots ('<code>...</code>')
	2347	at the end of its parameter list.
	2348	A vararg function does not adjust its argument list;
	2349	instead, it collects all extra arguments and supplies them
	2350	to the function through a <em>vararg expression</em>,
	2351	which is also written as three dots.
	2352	The value of this expression is a list of all actual extra arguments,
	2353	similar to a function with multiple results.
	2354	If a vararg expression is used inside another expression
	2355	or in the middle of a list of expressions,
	2356	then its return list is adjusted to one element.
	2357	If the expression is used as the last element of a list of expressions,
	2358	then no adjustment is made
	2359	(unless that last expression is enclosed in parentheses).
	2360
	2361
	2362	<p>
	2363	As an example, consider the following definitions:
	2364
	2365	<pre>
	2366	function f(a, b) end
	2367	function g(a, b, ...) end
	2368	function r() return 1,2,3 end
	2369	</pre><p>
	2370	Then, we have the following mapping from arguments to parameters and
	2371	to the vararg expression:
	2372
	2373	<pre>
	2374	CALL PARAMETERS
	2375
	2376	f(3) a=3, b=nil
	2377	f(3, 4) a=3, b=4
	2378	f(3, 4, 5) a=3, b=4
	2379	f(r(), 10) a=1, b=10
	2380	f(r()) a=1, b=2
	2381
	2382	g(3) a=3, b=nil, ... --> (nothing)
	2383	g(3, 4) a=3, b=4, ... --> (nothing)
	2384	g(3, 4, 5, 8) a=3, b=4, ... --> 5 8
	2385	g(5, r()) a=5, b=1, ... --> 2 3
	2386	</pre>
	2387
	2388	<p>
	2389	Results are returned using the <b>return</b> statement (see <a href="#3.3.4">§3.3.4</a>).
	2390	If control reaches the end of a function
	2391	without encountering a <b>return</b> statement,
	2392	then the function returns with no results.
	2393
	2394
	2395	<p>
	2396
	2397	There is a system-dependent limit on the number of values
	2398	that a function may return.
	2399	This limit is guaranteed to be larger than 1000.
	2400
	2401
	2402	<p>
	2403	The <em>colon</em> syntax
	2404	is used for defining <em>methods</em>,
	2405	that is, functions that have an implicit extra parameter <code>self</code>.
	2406	Thus, the statement
	2407
	2408	<pre>
	2409	function t.a.b.c:f (<em>params</em>) <em>body</em> end
	2410	</pre><p>
	2411	is syntactic sugar for
	2412
	2413	<pre>
	2414	t.a.b.c.f = function (self, <em>params</em>) <em>body</em> end
	2415	</pre>
	2416
	2417
	2418
	2419
	2420
	2421
	2422	<h2>3.5 – <a name="3.5">Visibility Rules</a></h2>
	2423
	2424	<p>
	2425
	2426	Lua is a lexically scoped language.
	2427	The scope of a local variable begins at the first statement after
	2428	its declaration and lasts until the last non-void statement
	2429	of the innermost block that includes the declaration.
	2430	Consider the following example:
	2431
	2432	<pre>
	2433	x = 10 -- global variable
	2434	do -- new block
	2435	local x = x -- new 'x', with value 10
	2436	print(x) --> 10
	2437	x = x+1
	2438	do -- another block
	2439	local x = x+1 -- another 'x'
	2440	print(x) --> 12
	2441	end
	2442	print(x) --> 11
	2443	end
	2444	print(x) --> 10 (the global one)
	2445	</pre>
	2446
	2447	<p>
	2448	Notice that, in a declaration like <code>local x = x</code>,
	2449	the new <code>x</code> being declared is not in scope yet,
	2450	and so the second <code>x</code> refers to the outside variable.
	2451
	2452
	2453	<p>
	2454	Because of the lexical scoping rules,
	2455	local variables can be freely accessed by functions
	2456	defined inside their scope.
	2457	A local variable used by an inner function is called
	2458	an <em>upvalue</em>, or <em>external local variable</em>,
	2459	inside the inner function.
	2460
	2461
	2462	<p>
	2463	Notice that each execution of a <b>local</b> statement
	2464	defines new local variables.
	2465	Consider the following example:
	2466
	2467	<pre>
	2468	a = {}
	2469	local x = 20
	2470	for i=1,10 do
	2471	local y = 0
	2472	a[i] = function () y=y+1; return x+y end
	2473	end
	2474	</pre><p>
	2475	The loop creates ten closures
	2476	(that is, ten instances of the anonymous function).
	2477	Each of these closures uses a different <code>y</code> variable,
	2478	while all of them share the same <code>x</code>.
	2479
	2480
	2481
	2482
	2483
	2484	<h1>4 – <a name="4">The Application Program Interface</a></h1>
	2485
	2486	<p>
	2487
	2488	This section describes the C API for Lua, that is,
	2489	the set of C functions available to the host program to communicate
	2490	with Lua.
	2491	All API functions and related types and constants
	2492	are declared in the header file <a name="pdf-lua.h"><code>lua.h</code></a>.
	2493
	2494
	2495	<p>
	2496	Even when we use the term "function",
	2497	any facility in the API may be provided as a macro instead.
	2498	Except where stated otherwise,
	2499	all such macros use each of their arguments exactly once
	2500	(except for the first argument, which is always a Lua state),
	2501	and so do not generate any hidden side-effects.
	2502
	2503
	2504	<p>
	2505	As in most C libraries,
	2506	the Lua API functions do not check their arguments for validity or consistency.
	2507	However, you can change this behavior by compiling Lua
	2508	with the macro <a name="pdf-LUA_USE_APICHECK"><code>LUA_USE_APICHECK</code></a> defined.
	2509
	2510
	2511
	2512	<h2>4.1 – <a name="4.1">The Stack</a></h2>
	2513
	2514	<p>
	2515	Lua uses a <em>virtual stack</em> to pass values to and from C.
	2516	Each element in this stack represents a Lua value
	2517	(<b>nil</b>, number, string, etc.).
	2518
	2519
	2520	<p>
	2521	Whenever Lua calls C, the called function gets a new stack,
	2522	which is independent of previous stacks and of stacks of
	2523	C functions that are still active.
	2524	This stack initially contains any arguments to the C function
	2525	and it is where the C function pushes its results
	2526	to be returned to the caller (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
	2527
	2528
	2529	<p>
	2530	For convenience,
	2531	most query operations in the API do not follow a strict stack discipline.
	2532	Instead, they can refer to any element in the stack
	2533	by using an <em>index</em>:
	2534	A positive index represents an absolute stack position
	2535	(starting at 1);
	2536	a negative index represents an offset relative to the top of the stack.
	2537	More specifically, if the stack has <em>n</em> elements,
	2538	then index 1 represents the first element
	2539	(that is, the element that was pushed onto the stack first)
	2540	and
	2541	index <em>n</em> represents the last element;
	2542	index -1 also represents the last element
	2543	(that is, the element at the top)
	2544	and index <em>-n</em> represents the first element.
	2545
	2546
	2547
	2548
	2549
	2550	<h2>4.2 – <a name="4.2">Stack Size</a></h2>
	2551
	2552	<p>
	2553	When you interact with the Lua API,
	2554	you are responsible for ensuring consistency.
	2555	In particular,
	2556	<em>you are responsible for controlling stack overflow</em>.
	2557	You can use the function <a href="#lua_checkstack"><code>lua_checkstack</code></a>
	2558	to ensure that the stack has extra slots when pushing new elements.
	2559
	2560
	2561	<p>
	2562	Whenever Lua calls C,
	2563	it ensures that the stack has at least <a name="pdf-LUA_MINSTACK"><code>LUA_MINSTACK</code></a> extra slots.
	2564	<code>LUA_MINSTACK</code> is defined as 20,
	2565	so that usually you do not have to worry about stack space
	2566	unless your code has loops pushing elements onto the stack.
	2567
	2568
	2569	<p>
	2570	When you call a Lua function
	2571	without a fixed number of results (see <a href="#lua_call"><code>lua_call</code></a>),
	2572	Lua ensures that the stack has enough size for all results,
	2573	but it does not ensure any extra space.
	2574	So, before pushing anything in the stack after such a call
	2575	you should use <a href="#lua_checkstack"><code>lua_checkstack</code></a>.
	2576
	2577
	2578
	2579
	2580
	2581	<h2>4.3 – <a name="4.3">Valid and Acceptable Indices</a></h2>
	2582
	2583	<p>
	2584	Any function in the API that receives stack indices
	2585	works only with <em>valid indices</em> or <em>acceptable indices</em>.
	2586
	2587
	2588	<p>
	2589	A <em>valid index</em> is an index that refers to a
	2590	real position within the stack, that is,
	2591	its position lies between 1 and the stack top
	2592	(<code>1 ≤ abs(index) ≤ top</code>).
	2593
	2594	Usually, functions that can modify the value at an index
	2595	require valid indices.
	2596
	2597
	2598	<p>
	2599	Unless otherwise noted,
	2600	any function that accepts valid indices also accepts <em>pseudo-indices</em>,
	2601	which represent some Lua values that are accessible to C code
	2602	but which are not in the stack.
	2603	Pseudo-indices are used to access the registry
	2604	and the upvalues of a C function (see <a href="#4.4">§4.4</a>).
	2605
	2606
	2607	<p>
	2608	Functions that do not need a specific stack position,
	2609	but only a value in the stack (e.g., query functions),
	2610	can be called with acceptable indices.
	2611	An <em>acceptable index</em> can be any valid index,
	2612	including the pseudo-indices,
	2613	but it also can be any positive index after the stack top
	2614	within the space allocated for the stack,
	2615	that is, indices up to the stack size.
	2616	(Note that 0 is never an acceptable index.)
	2617	Except when noted otherwise,
	2618	functions in the API work with acceptable indices.
	2619
	2620
	2621	<p>
	2622	Acceptable indices serve to avoid extra tests
	2623	against the stack top when querying the stack.
	2624	For instance, a C function can query its third argument
	2625	without the need to first check whether there is a third argument,
	2626	that is, without the need to check whether 3 is a valid index.
	2627
	2628
	2629	<p>
	2630	For functions that can be called with acceptable indices,
	2631	any non-valid index is treated as if it
	2632	contains a value of a virtual type <a name="pdf-LUA_TNONE"><code>LUA_TNONE</code></a>,
	2633	which behaves like a nil value.
	2634
	2635
	2636
	2637
	2638
	2639	<h2>4.4 – <a name="4.4">C Closures</a></h2>
	2640
	2641	<p>
	2642	When a C function is created,
	2643	it is possible to associate some values with it,
	2644	thus creating a <em>C closure</em>
	2645	(see <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>);
	2646	these values are called <em>upvalues</em> and are
	2647	accessible to the function whenever it is called.
	2648
	2649
	2650	<p>
	2651	Whenever a C function is called,
	2652	its upvalues are located at specific pseudo-indices.
	2653	These pseudo-indices are produced by the macro
	2654	<a href="#lua_upvalueindex"><code>lua_upvalueindex</code></a>.
	2655	The first value associated with a function is at position
	2656	<code>lua_upvalueindex(1)</code>, and so on.
	2657	Any access to <code>lua_upvalueindex(<em>n</em>)</code>,
	2658	where <em>n</em> is greater than the number of upvalues of the
	2659	current function (but not greater than 256),
	2660	produces an acceptable but invalid index.
	2661
	2662
	2663
	2664
	2665
	2666	<h2>4.5 – <a name="4.5">Registry</a></h2>
	2667
	2668	<p>
	2669	Lua provides a <em>registry</em>,
	2670	a predefined table that can be used by any C code to
	2671	store whatever Lua values it needs to store.
	2672	The registry table is always located at pseudo-index
	2673	<a name="pdf-LUA_REGISTRYINDEX"><code>LUA_REGISTRYINDEX</code></a>,
	2674	which is a valid index.
	2675	Any C library can store data into this table,
	2676	but it should take care to choose keys
	2677	that are different from those used
	2678	by other libraries, to avoid collisions.
	2679	Typically, you should use as key a string containing your library name,
	2680	or a light userdata with the address of a C object in your code,
	2681	or any Lua object created by your code.
	2682	As with global names,
	2683	string keys starting with an underscore followed by
	2684	uppercase letters are reserved for Lua.
	2685
	2686
	2687	<p>
	2688	The integer keys in the registry are used by the reference mechanism,
	2689	implemented by the auxiliary library,
	2690	and by some predefined values.
	2691	Therefore, integer keys should not be used for other purposes.
	2692
	2693
	2694	<p>
	2695	When you create a new Lua state,
	2696	its registry comes with some predefined values.
	2697	These predefined values are indexed with integer keys
	2698	defined as constants in <code>lua.h</code>.
	2699	The following constants are defined:
	2700
	2701	<ul>
	2702	<li><b><a name="pdf-LUA_RIDX_MAINTHREAD"><code>LUA_RIDX_MAINTHREAD</code></a>: </b> At this index the registry has
	2703	the main thread of the state.
	2704	(The main thread is the one created together with the state.)
	2705	</li>
	2706
	2707	<li><b><a name="pdf-LUA_RIDX_GLOBALS"><code>LUA_RIDX_GLOBALS</code></a>: </b> At this index the registry has
	2708	the global environment.
	2709	</li>
	2710	</ul>
	2711
	2712
	2713
	2714
	2715	<h2>4.6 – <a name="4.6">Error Handling in C</a></h2>
	2716
	2717	<p>
	2718	Internally, Lua uses the C <code>longjmp</code> facility to handle errors.
	2719	(You can also choose to use exceptions if you compile Lua as C++;
	2720	search for <code>LUAI_THROW</code> in the source code.)
	2721	When Lua faces any error
	2722	(such as a memory allocation error, type errors, syntax errors,
	2723	and runtime errors)
	2724	it <em>raises</em> an error;
	2725	that is, it does a long jump.
	2726	A <em>protected environment</em> uses <code>setjmp</code>
	2727	to set a recovery point;
	2728	any error jumps to the most recent active recovery point.
	2729
	2730
	2731	<p>
	2732	If an error happens outside any protected environment,
	2733	Lua calls a <em>panic function</em> (see <a href="#lua_atpanic"><code>lua_atpanic</code></a>)
	2734	and then calls <code>abort</code>,
	2735	thus exiting the host application.
	2736	Your panic function can avoid this exit by
	2737	never returning
	2738	(e.g., doing a long jump to your own recovery point outside Lua).
	2739
	2740
	2741	<p>
	2742	The panic function runs as if it were a message handler (see <a href="#2.3">§2.3</a>);
	2743	in particular, the error message is at the top of the stack.
	2744	However, there is no guarantees about stack space.
	2745	To push anything on the stack,
	2746	the panic function should first check the available space (see <a href="#4.2">§4.2</a>).
	2747
	2748
	2749	<p>
	2750	Most functions in the API can throw an error,
	2751	for instance due to a memory allocation error.
	2752	The documentation for each function indicates whether
	2753	it can throw errors.
	2754
	2755
	2756	<p>
	2757	Inside a C function you can throw an error by calling <a href="#lua_error"><code>lua_error</code></a>.
	2758
	2759
	2760
	2761
	2762
	2763	<h2>4.7 – <a name="4.7">Handling Yields in C</a></h2>
	2764
	2765	<p>
	2766	Internally, Lua uses the C <code>longjmp</code> facility to yield a coroutine.
	2767	Therefore, if a function <code>foo</code> calls an API function
	2768	and this API function yields
	2769	(directly or indirectly by calling another function that yields),
	2770	Lua cannot return to <code>foo</code> any more,
	2771	because the <code>longjmp</code> removes its frame from the C stack.
	2772
	2773
	2774	<p>
	2775	To avoid this kind of problem,
	2776	Lua raises an error whenever it tries to yield across an API call,
	2777	except for three functions:
	2778	<a href="#lua_yieldk"><code>lua_yieldk</code></a>, <a href="#lua_callk"><code>lua_callk</code></a>, and <a href="#lua_pcallk"><code>lua_pcallk</code></a>.
	2779	All those functions receive a <em>continuation function</em>
	2780	(as a parameter called <code>k</code>) to continue execution after a yield.
	2781
	2782
	2783	<p>
	2784	We need to set some terminology to explain continuations.
	2785	We have a C function called from Lua which we will call
	2786	the <em>original function</em>.
	2787	This original function then calls one of those three functions in the C API,
	2788	which we will call the <em>callee function</em>,
	2789	that then yields the current thread.
	2790	(This can happen when the callee function is <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
	2791	or when the callee function is either <a href="#lua_callk"><code>lua_callk</code></a> or <a href="#lua_pcallk"><code>lua_pcallk</code></a>
	2792	and the function called by them yields.)
	2793
	2794
	2795	<p>
	2796	Suppose the running thread yields while executing the callee function.
	2797	After the thread resumes,
	2798	it eventually will finish running the callee function.
	2799	However,
	2800	the callee function cannot return to the original function,
	2801	because its frame in the C stack was destroyed by the yield.
	2802	Instead, Lua calls a <em>continuation function</em>,
	2803	which was given as an argument to the callee function.
	2804	As the name implies,
	2805	the continuation function should continue the task
	2806	of the original function.
	2807
	2808
	2809	<p>
	2810	Lua treats the continuation function as if it were the original function.
	2811	The continuation function receives the same Lua stack
	2812	from the original function,
	2813	in the same state it would be if the callee function had returned.
	2814	(For instance,
	2815	after a <a href="#lua_callk"><code>lua_callk</code></a> the function and its arguments are
	2816	removed from the stack and replaced by the results from the call.)
	2817	It also has the same upvalues.
	2818	Whatever it returns is handled by Lua as if it were the return
	2819	of the original function.
	2820
	2821
	2822	<p>
	2823	The only difference in the Lua state between the original function
	2824	and its continuation is the result of a call to <a href="#lua_getctx"><code>lua_getctx</code></a>.
	2825
	2826
	2827
	2828
	2829
	2830	<h2>4.8 – <a name="4.8">Functions and Types</a></h2>
	2831
	2832	<p>
	2833	Here we list all functions and types from the C API in
	2834	alphabetical order.
	2835	Each function has an indicator like this:
	2836	<span class="apii">[-o, +p, <em>x</em>]</span>
	2837
	2838
	2839	<p>
	2840	The first field, <code>o</code>,
	2841	is how many elements the function pops from the stack.
	2842	The second field, <code>p</code>,
	2843	is how many elements the function pushes onto the stack.
	2844	(Any function always pushes its results after popping its arguments.)
	2845	A field in the form <code>x\|y</code> means the function can push (or pop)
	2846	<code>x</code> or <code>y</code> elements,
	2847	depending on the situation;
	2848	an interrogation mark '<code>?</code>' means that
	2849	we cannot know how many elements the function pops/pushes
	2850	by looking only at its arguments
	2851	(e.g., they may depend on what is on the stack).
	2852	The third field, <code>x</code>,
	2853	tells whether the function may throw errors:
	2854	'<code>-</code>' means the function never throws any error;
	2855	'<code>e</code>' means the function may throw errors;
	2856	'<code>v</code>' means the function may throw an error on purpose.
	2857
	2858
	2859
	2860	<hr><h3><a name="lua_absindex"><code>lua_absindex</code></a></h3><p>
	2861	<span class="apii">[-0, +0, –]</span>
	2862	<pre>int lua_absindex (lua_State *L, int idx);</pre>
	2863
	2864	<p>
	2865	Converts the acceptable index <code>idx</code> into an absolute index
	2866	(that is, one that does not depend on the stack top).
	2867
	2868
	2869
	2870
	2871
	2872	<hr><h3><a name="lua_Alloc"><code>lua_Alloc</code></a></h3>
	2873	<pre>typedef void * (lua_Alloc) (void ud,
	2874	void *ptr,
	2875	size_t osize,
	2876	size_t nsize);</pre>
	2877
	2878	<p>
	2879	The type of the memory-allocation function used by Lua states.
	2880	The allocator function must provide a
	2881	functionality similar to <code>realloc</code>,
	2882	but not exactly the same.
	2883	Its arguments are
	2884	<code>ud</code>, an opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>;
	2885	<code>ptr</code>, a pointer to the block being allocated/reallocated/freed;
	2886	<code>osize</code>, the original size of the block or some code about what
	2887	is being allocated;
	2888	<code>nsize</code>, the new size of the block.
	2889
	2890
	2891	<p>
	2892	When <code>ptr</code> is not <code>NULL</code>,
	2893	<code>osize</code> is the size of the block pointed by <code>ptr</code>,
	2894	that is, the size given when it was allocated or reallocated.
	2895
	2896
	2897	<p>
	2898	When <code>ptr</code> is <code>NULL</code>,
	2899	<code>osize</code> encodes the kind of object that Lua is allocating.
	2900	<code>osize</code> is any of
	2901	<a href="#pdf-LUA_TSTRING"><code>LUA_TSTRING</code></a>, <a href="#pdf-LUA_TTABLE"><code>LUA_TTABLE</code></a>, <a href="#pdf-LUA_TFUNCTION"><code>LUA_TFUNCTION</code></a>,
	2902	<a href="#pdf-LUA_TUSERDATA"><code>LUA_TUSERDATA</code></a>, or <a href="#pdf-LUA_TTHREAD"><code>LUA_TTHREAD</code></a> when (and only when)
	2903	Lua is creating a new object of that type.
	2904	When <code>osize</code> is some other value,
	2905	Lua is allocating memory for something else.
	2906
	2907
	2908	<p>
	2909	Lua assumes the following behavior from the allocator function:
	2910
	2911
	2912	<p>
	2913	When <code>nsize</code> is zero,
	2914	the allocator should behave like <code>free</code>
	2915	and return <code>NULL</code>.
	2916
	2917
	2918	<p>
	2919	When <code>nsize</code> is not zero,
	2920	the allocator should behave like <code>realloc</code>.
	2921	The allocator returns <code>NULL</code>
	2922	if and only if it cannot fulfill the request.
	2923	Lua assumes that the allocator never fails when
	2924	<code>osize >= nsize</code>.
	2925
	2926
	2927	<p>
	2928	Here is a simple implementation for the allocator function.
	2929	It is used in the auxiliary library by <a href="#luaL_newstate"><code>luaL_newstate</code></a>.
	2930
	2931	<pre>
	2932	static void l_alloc (void ud, void *ptr, size_t osize,
	2933	size_t nsize) {
	2934	(void)ud; (void)osize; /* not used */
	2935	if (nsize == 0) {
	2936	free(ptr);
	2937	return NULL;
	2938	}
	2939	else
	2940	return realloc(ptr, nsize);
	2941	}
	2942	</pre><p>
	2943	Note that Standard C ensures
	2944	that <code>free(NULL)</code> has no effect and that
	2945	<code>realloc(NULL, size)</code> is equivalent to <code>malloc(size)</code>.
	2946	This code assumes that <code>realloc</code> does not fail when shrinking a block.
	2947	(Although Standard C does not ensure this behavior,
	2948	it seems to be a safe assumption.)
	2949
	2950
	2951
	2952
	2953
	2954	<hr><h3><a name="lua_arith"><code>lua_arith</code></a></h3><p>
	2955	<span class="apii">[-(2\|1), +1, <em>e</em>]</span>
	2956	<pre>void lua_arith (lua_State *L, int op);</pre>
	2957
	2958	<p>
	2959	Performs an arithmetic operation over the two values
	2960	(or one, in the case of negation)
	2961	at the top of the stack,
	2962	with the value at the top being the second operand,
	2963	pops these values, and pushes the result of the operation.
	2964	The function follows the semantics of the corresponding Lua operator
	2965	(that is, it may call metamethods).
	2966
	2967
	2968	<p>
	2969	The value of <code>op</code> must be one of the following constants:
	2970
	2971	<ul>
	2972
	2973	<li><b><a name="pdf-LUA_OPADD"><code>LUA_OPADD</code></a>: </b> performs addition (<code>+</code>)</li>
	2974	<li><b><a name="pdf-LUA_OPSUB"><code>LUA_OPSUB</code></a>: </b> performs subtraction (<code>-</code>)</li>
	2975	<li><b><a name="pdf-LUA_OPMUL"><code>LUA_OPMUL</code></a>: </b> performs multiplication (<code>*</code>)</li>
	2976	<li><b><a name="pdf-LUA_OPDIV"><code>LUA_OPDIV</code></a>: </b> performs division (<code>/</code>)</li>
	2977	<li><b><a name="pdf-LUA_OPMOD"><code>LUA_OPMOD</code></a>: </b> performs modulo (<code>%</code>)</li>
	2978	<li><b><a name="pdf-LUA_OPPOW"><code>LUA_OPPOW</code></a>: </b> performs exponentiation (<code>^</code>)</li>
	2979	<li><b><a name="pdf-LUA_OPUNM"><code>LUA_OPUNM</code></a>: </b> performs mathematical negation (unary <code>-</code>)</li>
	2980
	2981	</ul>
	2982
	2983
	2984
	2985
	2986	<hr><h3><a name="lua_atpanic"><code>lua_atpanic</code></a></h3><p>
	2987	<span class="apii">[-0, +0, –]</span>
	2988	<pre>lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);</pre>
	2989
	2990	<p>
	2991	Sets a new panic function and returns the old one (see <a href="#4.6">§4.6</a>).
	2992
	2993
	2994
	2995
	2996
	2997	<hr><h3><a name="lua_call"><code>lua_call</code></a></h3><p>
	2998	<span class="apii">[-(nargs+1), +nresults, <em>e</em>]</span>
	2999	<pre>void lua_call (lua_State *L, int nargs, int nresults);</pre>
	3000
	3001	<p>
	3002	Calls a function.
	3003
	3004
	3005	<p>
	3006	To call a function you must use the following protocol:
	3007	first, the function to be called is pushed onto the stack;
	3008	then, the arguments to the function are pushed
	3009	in direct order;
	3010	that is, the first argument is pushed first.
	3011	Finally you call <a href="#lua_call"><code>lua_call</code></a>;
	3012	<code>nargs</code> is the number of arguments that you pushed onto the stack.
	3013	All arguments and the function value are popped from the stack
	3014	when the function is called.
	3015	The function results are pushed onto the stack when the function returns.
	3016	The number of results is adjusted to <code>nresults</code>,
	3017	unless <code>nresults</code> is <a name="pdf-LUA_MULTRET"><code>LUA_MULTRET</code></a>.
	3018	In this case, all results from the function are pushed.
	3019	Lua takes care that the returned values fit into the stack space.
	3020	The function results are pushed onto the stack in direct order
	3021	(the first result is pushed first),
	3022	so that after the call the last result is on the top of the stack.
	3023
	3024
	3025	<p>
	3026	Any error inside the called function is propagated upwards
	3027	(with a <code>longjmp</code>).
	3028
	3029
	3030	<p>
	3031	The following example shows how the host program can do the
	3032	equivalent to this Lua code:
	3033
	3034	<pre>
	3035	a = f("how", t.x, 14)
	3036	</pre><p>
	3037	Here it is in C:
	3038
	3039	<pre>
	3040	lua_getglobal(L, "f"); /* function to be called */
	3041	lua_pushstring(L, "how"); /* 1st argument */
	3042	lua_getglobal(L, "t"); /* table to be indexed */
	3043	lua_getfield(L, -1, "x"); /* push result of t.x (2nd arg) */
	3044	lua_remove(L, -2); /* remove 't' from the stack */
	3045	lua_pushinteger(L, 14); /* 3rd argument */
	3046	lua_call(L, 3, 1); /* call 'f' with 3 arguments and 1 result */
	3047	lua_setglobal(L, "a"); /* set global 'a' */
	3048	</pre><p>
	3049	Note that the code above is "balanced":
	3050	at its end, the stack is back to its original configuration.
	3051	This is considered good programming practice.
	3052
	3053
	3054
	3055
	3056
	3057	<hr><h3><a name="lua_callk"><code>lua_callk</code></a></h3><p>
	3058	<span class="apii">[-(nargs + 1), +nresults, <em>e</em>]</span>
	3059	<pre>void lua_callk (lua_State *L, int nargs, int nresults, int ctx,
	3060	lua_CFunction k);</pre>
	3061
	3062	<p>
	3063	This function behaves exactly like <a href="#lua_call"><code>lua_call</code></a>,
	3064	but allows the called function to yield (see <a href="#4.7">§4.7</a>).
	3065
	3066
	3067
	3068
	3069
	3070	<hr><h3><a name="lua_CFunction"><code>lua_CFunction</code></a></h3>
	3071	<pre>typedef int (lua_CFunction) (lua_State L);</pre>
	3072
	3073	<p>
	3074	Type for C functions.
	3075
	3076
	3077	<p>
	3078	In order to communicate properly with Lua,
	3079	a C function must use the following protocol,
	3080	which defines the way parameters and results are passed:
	3081	a C function receives its arguments from Lua in its stack
	3082	in direct order (the first argument is pushed first).
	3083	So, when the function starts,
	3084	<code>lua_gettop(L)</code> returns the number of arguments received by the function.
	3085	The first argument (if any) is at index 1
	3086	and its last argument is at index <code>lua_gettop(L)</code>.
	3087	To return values to Lua, a C function just pushes them onto the stack,
	3088	in direct order (the first result is pushed first),
	3089	and returns the number of results.
	3090	Any other value in the stack below the results will be properly
	3091	discarded by Lua.
	3092	Like a Lua function, a C function called by Lua can also return
	3093	many results.
	3094
	3095
	3096	<p>
	3097	As an example, the following function receives a variable number
	3098	of numerical arguments and returns their average and sum:
	3099
	3100	<pre>
	3101	static int foo (lua_State *L) {
	3102	int n = lua_gettop(L); /* number of arguments */
	3103	lua_Number sum = 0;
	3104	int i;
	3105	for (i = 1; i <= n; i++) {
	3106	if (!lua_isnumber(L, i)) {
	3107	lua_pushstring(L, "incorrect argument");
	3108	lua_error(L);
	3109	}
	3110	sum += lua_tonumber(L, i);
	3111	}
	3112	lua_pushnumber(L, sum/n); /* first result */
	3113	lua_pushnumber(L, sum); /* second result */
	3114	return 2; /* number of results */
	3115	}
	3116	</pre>
	3117
	3118
	3119
	3120
	3121	<hr><h3><a name="lua_checkstack"><code>lua_checkstack</code></a></h3><p>
	3122	<span class="apii">[-0, +0, –]</span>
	3123	<pre>int lua_checkstack (lua_State *L, int extra);</pre>
	3124
	3125	<p>
	3126	Ensures that there are at least <code>extra</code> free stack slots in the stack.
	3127	It returns false if it cannot fulfill the request,
	3128	because it would cause the stack to be larger than a fixed maximum size
	3129	(typically at least a few thousand elements) or
	3130	because it cannot allocate memory for the new stack size.
	3131	This function never shrinks the stack;
	3132	if the stack is already larger than the new size,
	3133	it is left unchanged.
	3134
	3135
	3136
	3137
	3138
	3139	<hr><h3><a name="lua_close"><code>lua_close</code></a></h3><p>
	3140	<span class="apii">[-0, +0, –]</span>
	3141	<pre>void lua_close (lua_State *L);</pre>
	3142
	3143	<p>
	3144	Destroys all objects in the given Lua state
	3145	(calling the corresponding garbage-collection metamethods, if any)
	3146	and frees all dynamic memory used by this state.
	3147	On several platforms, you may not need to call this function,
	3148	because all resources are naturally released when the host program ends.
	3149	On the other hand, long-running programs that create multiple states,
	3150	such as daemons or web servers,
	3151	might need to close states as soon as they are not needed.
	3152
	3153
	3154
	3155
	3156
	3157	<hr><h3><a name="lua_compare"><code>lua_compare</code></a></h3><p>
	3158	<span class="apii">[-0, +0, <em>e</em>]</span>
	3159	<pre>int lua_compare (lua_State *L, int index1, int index2, int op);</pre>
	3160
	3161	<p>
	3162	Compares two Lua values.
	3163	Returns 1 if the value at index <code>index1</code> satisfies <code>op</code>
	3164	when compared with the value at index <code>index2</code>,
	3165	following the semantics of the corresponding Lua operator
	3166	(that is, it may call metamethods).
	3167	Otherwise returns 0.
	3168	Also returns 0 if any of the indices is non valid.
	3169
	3170
	3171	<p>
	3172	The value of <code>op</code> must be one of the following constants:
	3173
	3174	<ul>
	3175
	3176	<li><b><a name="pdf-LUA_OPEQ"><code>LUA_OPEQ</code></a>: </b> compares for equality (<code>==</code>)</li>
	3177	<li><b><a name="pdf-LUA_OPLT"><code>LUA_OPLT</code></a>: </b> compares for less than (<code><</code>)</li>
	3178	<li><b><a name="pdf-LUA_OPLE"><code>LUA_OPLE</code></a>: </b> compares for less or equal (<code><=</code>)</li>
	3179
	3180	</ul>
	3181
	3182
	3183
	3184
	3185	<hr><h3><a name="lua_concat"><code>lua_concat</code></a></h3><p>
	3186	<span class="apii">[-n, +1, <em>e</em>]</span>
	3187	<pre>void lua_concat (lua_State *L, int n);</pre>
	3188
	3189	<p>
	3190	Concatenates the <code>n</code> values at the top of the stack,
	3191	pops them, and leaves the result at the top.
	3192	If <code>n</code> is 1, the result is the single value on the stack
	3193	(that is, the function does nothing);
	3194	if <code>n</code> is 0, the result is the empty string.
	3195	Concatenation is performed following the usual semantics of Lua
	3196	(see <a href="#3.4.5">§3.4.5</a>).
	3197
	3198
	3199
	3200
	3201
	3202	<hr><h3><a name="lua_copy"><code>lua_copy</code></a></h3><p>
	3203	<span class="apii">[-0, +0, –]</span>
	3204	<pre>void lua_copy (lua_State *L, int fromidx, int toidx);</pre>
	3205
	3206	<p>
	3207	Moves the element at index <code>fromidx</code>
	3208	into the valid index <code>toidx</code>
	3209	without shifting any element
	3210	(therefore replacing the value at that position).
	3211
	3212
	3213
	3214
	3215
	3216	<hr><h3><a name="lua_createtable"><code>lua_createtable</code></a></h3><p>
	3217	<span class="apii">[-0, +1, <em>e</em>]</span>
	3218	<pre>void lua_createtable (lua_State *L, int narr, int nrec);</pre>
	3219
	3220	<p>
	3221	Creates a new empty table and pushes it onto the stack.
	3222	Parameter <code>narr</code> is a hint for how many elements the table
	3223	will have as a sequence;
	3224	parameter <code>nrec</code> is a hint for how many other elements
	3225	the table will have.
	3226	Lua may use these hints to preallocate memory for the new table.
	3227	This pre-allocation is useful for performance when you know in advance
	3228	how many elements the table will have.
	3229	Otherwise you can use the function <a href="#lua_newtable"><code>lua_newtable</code></a>.
	3230
	3231
	3232
	3233
	3234
	3235	<hr><h3><a name="lua_dump"><code>lua_dump</code></a></h3><p>
	3236	<span class="apii">[-0, +0, <em>e</em>]</span>
	3237	<pre>int lua_dump (lua_State L, lua_Writer writer, void data);</pre>
	3238
	3239	<p>
	3240	Dumps a function as a binary chunk.
	3241	Receives a Lua function on the top of the stack
	3242	and produces a binary chunk that,
	3243	if loaded again,
	3244	results in a function equivalent to the one dumped.
	3245	As it produces parts of the chunk,
	3246	<a href="#lua_dump"><code>lua_dump</code></a> calls function <code>writer</code> (see <a href="#lua_Writer"><code>lua_Writer</code></a>)
	3247	with the given <code>data</code>
	3248	to write them.
	3249
	3250
	3251	<p>
	3252	The value returned is the error code returned by the last
	3253	call to the writer;
	3254	0 means no errors.
	3255
	3256
	3257	<p>
	3258	This function does not pop the Lua function from the stack.
	3259
	3260
	3261
	3262
	3263
	3264	<hr><h3><a name="lua_error"><code>lua_error</code></a></h3><p>
	3265	<span class="apii">[-1, +0, <em>v</em>]</span>
	3266	<pre>int lua_error (lua_State *L);</pre>
	3267
	3268	<p>
	3269	Generates a Lua error.
	3270	The error message (which can actually be a Lua value of any type)
	3271	must be on the stack top.
	3272	This function does a long jump,
	3273	and therefore never returns
	3274	(see <a href="#luaL_error"><code>luaL_error</code></a>).
	3275
	3276
	3277
	3278
	3279
	3280	<hr><h3><a name="lua_gc"><code>lua_gc</code></a></h3><p>
	3281	<span class="apii">[-0, +0, <em>e</em>]</span>
	3282	<pre>int lua_gc (lua_State *L, int what, int data);</pre>
	3283
	3284	<p>
	3285	Controls the garbage collector.
	3286
	3287
	3288	<p>
	3289	This function performs several tasks,
	3290	according to the value of the parameter <code>what</code>:
	3291
	3292	<ul>
	3293
	3294	<li><b><code>LUA_GCSTOP</code>: </b>
	3295	stops the garbage collector.
	3296	</li>
	3297
	3298	<li><b><code>LUA_GCRESTART</code>: </b>
	3299	restarts the garbage collector.
	3300	</li>
	3301
	3302	<li><b><code>LUA_GCCOLLECT</code>: </b>
	3303	performs a full garbage-collection cycle.
	3304	</li>
	3305
	3306	<li><b><code>LUA_GCCOUNT</code>: </b>
	3307	returns the current amount of memory (in Kbytes) in use by Lua.
	3308	</li>
	3309
	3310	<li><b><code>LUA_GCCOUNTB</code>: </b>
	3311	returns the remainder of dividing the current amount of bytes of
	3312	memory in use by Lua by 1024.
	3313	</li>
	3314
	3315	<li><b><code>LUA_GCSTEP</code>: </b>
	3316	performs an incremental step of garbage collection.
	3317	The step "size" is controlled by <code>data</code>
	3318	(larger values mean more steps) in a non-specified way.
	3319	If you want to control the step size
	3320	you must experimentally tune the value of <code>data</code>.
	3321	The function returns 1 if the step finished a
	3322	garbage-collection cycle.
	3323	</li>
	3324
	3325	<li><b><code>LUA_GCSETPAUSE</code>: </b>
	3326	sets <code>data</code> as the new value
	3327	for the <em>pause</em> of the collector (see <a href="#2.5">§2.5</a>).
	3328	The function returns the previous value of the pause.
	3329	</li>
	3330
	3331	<li><b><code>LUA_GCSETSTEPMUL</code>: </b>
	3332	sets <code>data</code> as the new value for the <em>step multiplier</em> of
	3333	the collector (see <a href="#2.5">§2.5</a>).
	3334	The function returns the previous value of the step multiplier.
	3335	</li>
	3336
	3337	<li><b><code>LUA_GCISRUNNING</code>: </b>
	3338	returns a boolean that tells whether the collector is running
	3339	(i.e., not stopped).
	3340	</li>
	3341
	3342	<li><b><code>LUA_GCGEN</code>: </b>
	3343	changes the collector to generational mode
	3344	(see <a href="#2.5">§2.5</a>).
	3345	</li>
	3346
	3347	<li><b><code>LUA_GCINC</code>: </b>
	3348	changes the collector to incremental mode.
	3349	This is the default mode.
	3350	</li>
	3351
	3352	</ul>
	3353
	3354	<p>
	3355	For more details about these options,
	3356	see <a href="#pdf-collectgarbage"><code>collectgarbage</code></a>.
	3357
	3358
	3359
	3360
	3361
	3362	<hr><h3><a name="lua_getallocf"><code>lua_getallocf</code></a></h3><p>
	3363	<span class="apii">[-0, +0, –]</span>
	3364	<pre>lua_Alloc lua_getallocf (lua_State L, void *ud);</pre>
	3365
	3366	<p>
	3367	Returns the memory-allocation function of a given state.
	3368	If <code>ud</code> is not <code>NULL</code>, Lua stores in <code>*ud</code> the
	3369	opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>.
	3370
	3371
	3372
	3373
	3374
	3375	<hr><h3><a name="lua_getctx"><code>lua_getctx</code></a></h3><p>
	3376	<span class="apii">[-0, +0, –]</span>
	3377	<pre>int lua_getctx (lua_State L, int ctx);</pre>
	3378
	3379	<p>
	3380	This function is called by a continuation function (see <a href="#4.7">§4.7</a>)
	3381	to retrieve the status of the thread and a context information.
	3382
	3383
	3384	<p>
	3385	When called in the original function,
	3386	<a href="#lua_getctx"><code>lua_getctx</code></a> always returns <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>
	3387	and does not change the value of its argument <code>ctx</code>.
	3388	When called inside a continuation function,
	3389	<a href="#lua_getctx"><code>lua_getctx</code></a> returns <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> and sets
	3390	the value of <code>ctx</code> to be the context information
	3391	(the value passed as the <code>ctx</code> argument
	3392	to the callee together with the continuation function).
	3393
	3394
	3395	<p>
	3396	When the callee is <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
	3397	Lua may also call its continuation function
	3398	to handle errors during the call.
	3399	That is, upon an error in the function called by <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
	3400	Lua may not return to the original function
	3401	but instead may call the continuation function.
	3402	In that case, a call to <a href="#lua_getctx"><code>lua_getctx</code></a> will return the error code
	3403	(the value that would be returned by <a href="#lua_pcallk"><code>lua_pcallk</code></a>);
	3404	the value of <code>ctx</code> will be set to the context information,
	3405	as in the case of a yield.
	3406
	3407
	3408
	3409
	3410
	3411	<hr><h3><a name="lua_getfield"><code>lua_getfield</code></a></h3><p>
	3412	<span class="apii">[-0, +1, <em>e</em>]</span>
	3413	<pre>void lua_getfield (lua_State L, int index, const char k);</pre>
	3414
	3415	<p>
	3416	Pushes onto the stack the value <code>t[k]</code>,
	3417	where <code>t</code> is the value at the given index.
	3418	As in Lua, this function may trigger a metamethod
	3419	for the "index" event (see <a href="#2.4">§2.4</a>).
	3420
	3421
	3422
	3423
	3424
	3425	<hr><h3><a name="lua_getglobal"><code>lua_getglobal</code></a></h3><p>
	3426	<span class="apii">[-0, +1, <em>e</em>]</span>
	3427	<pre>void lua_getglobal (lua_State L, const char name);</pre>
	3428
	3429	<p>
	3430	Pushes onto the stack the value of the global <code>name</code>.
	3431
	3432
	3433
	3434
	3435
	3436	<hr><h3><a name="lua_getmetatable"><code>lua_getmetatable</code></a></h3><p>
	3437	<span class="apii">[-0, +(0\|1), –]</span>
	3438	<pre>int lua_getmetatable (lua_State *L, int index);</pre>
	3439
	3440	<p>
	3441	Pushes onto the stack the metatable of the value at the given index.
	3442	If the value does not have a metatable,
	3443	the function returns 0 and pushes nothing on the stack.
	3444
	3445
	3446
	3447
	3448
	3449	<hr><h3><a name="lua_gettable"><code>lua_gettable</code></a></h3><p>
	3450	<span class="apii">[-1, +1, <em>e</em>]</span>
	3451	<pre>void lua_gettable (lua_State *L, int index);</pre>
	3452
	3453	<p>
	3454	Pushes onto the stack the value <code>t[k]</code>,
	3455	where <code>t</code> is the value at the given index
	3456	and <code>k</code> is the value at the top of the stack.
	3457
	3458
	3459	<p>
	3460	This function pops the key from the stack
	3461	(putting the resulting value in its place).
	3462	As in Lua, this function may trigger a metamethod
	3463	for the "index" event (see <a href="#2.4">§2.4</a>).
	3464
	3465
	3466
	3467
	3468
	3469	<hr><h3><a name="lua_gettop"><code>lua_gettop</code></a></h3><p>
	3470	<span class="apii">[-0, +0, –]</span>
	3471	<pre>int lua_gettop (lua_State *L);</pre>
	3472
	3473	<p>
	3474	Returns the index of the top element in the stack.
	3475	Because indices start at 1,
	3476	this result is equal to the number of elements in the stack
	3477	(and so 0 means an empty stack).
	3478
	3479
	3480
	3481
	3482
	3483	<hr><h3><a name="lua_getuservalue"><code>lua_getuservalue</code></a></h3><p>
	3484	<span class="apii">[-0, +1, –]</span>
	3485	<pre>void lua_getuservalue (lua_State *L, int index);</pre>
	3486
	3487	<p>
	3488	Pushes onto the stack the Lua value associated with the userdata
	3489	at the given index.
	3490	This Lua value must be a table or <b>nil</b>.
	3491
	3492
	3493
	3494
	3495
	3496	<hr><h3><a name="lua_insert"><code>lua_insert</code></a></h3><p>
	3497	<span class="apii">[-1, +1, –]</span>
	3498	<pre>void lua_insert (lua_State *L, int index);</pre>
	3499
	3500	<p>
	3501	Moves the top element into the given valid index,
	3502	shifting up the elements above this index to open space.
	3503	This function cannot be called with a pseudo-index,
	3504	because a pseudo-index is not an actual stack position.
	3505
	3506
	3507
	3508
	3509
	3510	<hr><h3><a name="lua_Integer"><code>lua_Integer</code></a></h3>
	3511	<pre>typedef ptrdiff_t lua_Integer;</pre>
	3512
	3513	<p>
	3514	The type used by the Lua API to represent signed integral values.
	3515
	3516
	3517	<p>
	3518	By default it is a <code>ptrdiff_t</code>,
	3519	which is usually the largest signed integral type the machine handles
	3520	"comfortably".
	3521
	3522
	3523
	3524
	3525
	3526	<hr><h3><a name="lua_isboolean"><code>lua_isboolean</code></a></h3><p>
	3527	<span class="apii">[-0, +0, –]</span>
	3528	<pre>int lua_isboolean (lua_State *L, int index);</pre>
	3529
	3530	<p>
	3531	Returns 1 if the value at the given index is a boolean,
	3532	and 0 otherwise.
	3533
	3534
	3535
	3536
	3537
	3538	<hr><h3><a name="lua_iscfunction"><code>lua_iscfunction</code></a></h3><p>
	3539	<span class="apii">[-0, +0, –]</span>
	3540	<pre>int lua_iscfunction (lua_State *L, int index);</pre>
	3541
	3542	<p>
	3543	Returns 1 if the value at the given index is a C function,
	3544	and 0 otherwise.
	3545
	3546
	3547
	3548
	3549
	3550	<hr><h3><a name="lua_isfunction"><code>lua_isfunction</code></a></h3><p>
	3551	<span class="apii">[-0, +0, –]</span>
	3552	<pre>int lua_isfunction (lua_State *L, int index);</pre>
	3553
	3554	<p>
	3555	Returns 1 if the value at the given index is a function
	3556	(either C or Lua), and 0 otherwise.
	3557
	3558
	3559
	3560
	3561
	3562	<hr><h3><a name="lua_islightuserdata"><code>lua_islightuserdata</code></a></h3><p>
	3563	<span class="apii">[-0, +0, –]</span>
	3564	<pre>int lua_islightuserdata (lua_State *L, int index);</pre>
	3565
	3566	<p>
	3567	Returns 1 if the value at the given index is a light userdata,
	3568	and 0 otherwise.
	3569
	3570
	3571
	3572
	3573
	3574	<hr><h3><a name="lua_isnil"><code>lua_isnil</code></a></h3><p>
	3575	<span class="apii">[-0, +0, –]</span>
	3576	<pre>int lua_isnil (lua_State *L, int index);</pre>
	3577
	3578	<p>
	3579	Returns 1 if the value at the given index is <b>nil</b>,
	3580	and 0 otherwise.
	3581
	3582
	3583
	3584
	3585
	3586	<hr><h3><a name="lua_isnone"><code>lua_isnone</code></a></h3><p>
	3587	<span class="apii">[-0, +0, –]</span>
	3588	<pre>int lua_isnone (lua_State *L, int index);</pre>
	3589
	3590	<p>
	3591	Returns 1 if the given index is not valid,
	3592	and 0 otherwise.
	3593
	3594
	3595
	3596
	3597
	3598	<hr><h3><a name="lua_isnoneornil"><code>lua_isnoneornil</code></a></h3><p>
	3599	<span class="apii">[-0, +0, –]</span>
	3600	<pre>int lua_isnoneornil (lua_State *L, int index);</pre>
	3601
	3602	<p>
	3603	Returns 1 if the given index is not valid
	3604	or if the value at this index is <b>nil</b>,
	3605	and 0 otherwise.
	3606
	3607
	3608
	3609
	3610
	3611	<hr><h3><a name="lua_isnumber"><code>lua_isnumber</code></a></h3><p>
	3612	<span class="apii">[-0, +0, –]</span>
	3613	<pre>int lua_isnumber (lua_State *L, int index);</pre>
	3614
	3615	<p>
	3616	Returns 1 if the value at the given index is a number
	3617	or a string convertible to a number,
	3618	and 0 otherwise.
	3619
	3620
	3621
	3622
	3623
	3624	<hr><h3><a name="lua_isstring"><code>lua_isstring</code></a></h3><p>
	3625	<span class="apii">[-0, +0, –]</span>
	3626	<pre>int lua_isstring (lua_State *L, int index);</pre>
	3627
	3628	<p>
	3629	Returns 1 if the value at the given index is a string
	3630	or a number (which is always convertible to a string),
	3631	and 0 otherwise.
	3632
	3633
	3634
	3635
	3636
	3637	<hr><h3><a name="lua_istable"><code>lua_istable</code></a></h3><p>
	3638	<span class="apii">[-0, +0, –]</span>
	3639	<pre>int lua_istable (lua_State *L, int index);</pre>
	3640
	3641	<p>
	3642	Returns 1 if the value at the given index is a table,
	3643	and 0 otherwise.
	3644
	3645
	3646
	3647
	3648
	3649	<hr><h3><a name="lua_isthread"><code>lua_isthread</code></a></h3><p>
	3650	<span class="apii">[-0, +0, –]</span>
	3651	<pre>int lua_isthread (lua_State *L, int index);</pre>
	3652
	3653	<p>
	3654	Returns 1 if the value at the given index is a thread,
	3655	and 0 otherwise.
	3656
	3657
	3658
	3659
	3660
	3661	<hr><h3><a name="lua_isuserdata"><code>lua_isuserdata</code></a></h3><p>
	3662	<span class="apii">[-0, +0, –]</span>
	3663	<pre>int lua_isuserdata (lua_State *L, int index);</pre>
	3664
	3665	<p>
	3666	Returns 1 if the value at the given index is a userdata
	3667	(either full or light), and 0 otherwise.
	3668
	3669
	3670
	3671
	3672
	3673	<hr><h3><a name="lua_len"><code>lua_len</code></a></h3><p>
	3674	<span class="apii">[-0, +1, <em>e</em>]</span>
	3675	<pre>void lua_len (lua_State *L, int index);</pre>
	3676
	3677	<p>
	3678	Returns the "length" of the value at the given index;
	3679	it is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.6">§3.4.6</a>).
	3680	The result is pushed on the stack.
	3681
	3682
	3683
	3684
	3685
	3686	<hr><h3><a name="lua_load"><code>lua_load</code></a></h3><p>
	3687	<span class="apii">[-0, +1, –]</span>
	3688	<pre>int lua_load (lua_State *L,
	3689	lua_Reader reader,
	3690	void *data,
	3691	const char *source,
	3692	const char *mode);</pre>
	3693
	3694	<p>
	3695	Loads a Lua chunk (without running it).
	3696	If there are no errors,
	3697	<code>lua_load</code> pushes the compiled chunk as a Lua
	3698	function on top of the stack.
	3699	Otherwise, it pushes an error message.
	3700
	3701
	3702	<p>
	3703	The return values of <code>lua_load</code> are:
	3704
	3705	<ul>
	3706
	3707	<li><b><a href="#pdf-LUA_OK"><code>LUA_OK</code></a>: </b> no errors;</li>
	3708
	3709	<li><b><a name="pdf-LUA_ERRSYNTAX"><code>LUA_ERRSYNTAX</code></a>: </b>
	3710	syntax error during precompilation;</li>
	3711
	3712	<li><b><a href="#pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>: </b>
	3713	memory allocation error;</li>
	3714
	3715	<li><b><a href="#pdf-LUA_ERRGCMM"><code>LUA_ERRGCMM</code></a>: </b>
	3716	error while running a <code>__gc</code> metamethod.
	3717	(This error has no relation with the chunk being loaded.
	3718	It is generated by the garbage collector.)
	3719	</li>
	3720
	3721	</ul>
	3722
	3723	<p>
	3724	The <code>lua_load</code> function uses a user-supplied <code>reader</code> function
	3725	to read the chunk (see <a href="#lua_Reader"><code>lua_Reader</code></a>).
	3726	The <code>data</code> argument is an opaque value passed to the reader function.
	3727
	3728
	3729	<p>
	3730	The <code>source</code> argument gives a name to the chunk,
	3731	which is used for error messages and in debug information (see <a href="#4.9">§4.9</a>).
	3732
	3733
	3734	<p>
	3735	<code>lua_load</code> automatically detects whether the chunk is text or binary
	3736	and loads it accordingly (see program <code>luac</code>).
	3737	The string <code>mode</code> works as in function <a href="#pdf-load"><code>load</code></a>,
	3738	with the addition that
	3739	a <code>NULL</code> value is equivalent to the string "<code>bt</code>".
	3740
	3741
	3742	<p>
	3743	<code>lua_load</code> uses the stack internally,
	3744	so the reader function should always leave the stack
	3745	unmodified when returning.
	3746
	3747
	3748	<p>
	3749	If the resulting function has one upvalue,
	3750	this upvalue is set to the value of the global environment
	3751	stored at index <code>LUA_RIDX_GLOBALS</code> in the registry (see <a href="#4.5">§4.5</a>).
	3752	When loading main chunks,
	3753	this upvalue will be the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>).
	3754
	3755
	3756
	3757
	3758
	3759	<hr><h3><a name="lua_newstate"><code>lua_newstate</code></a></h3><p>
	3760	<span class="apii">[-0, +0, –]</span>
	3761	<pre>lua_State lua_newstate (lua_Alloc f, void ud);</pre>
	3762
	3763	<p>
	3764	Creates a new thread running in a new, independent state.
	3765	Returns <code>NULL</code> if cannot create the thread or the state
	3766	(due to lack of memory).
	3767	The argument <code>f</code> is the allocator function;
	3768	Lua does all memory allocation for this state through this function.
	3769	The second argument, <code>ud</code>, is an opaque pointer that Lua
	3770	passes to the allocator in every call.
	3771
	3772
	3773
	3774
	3775
	3776	<hr><h3><a name="lua_newtable"><code>lua_newtable</code></a></h3><p>
	3777	<span class="apii">[-0, +1, <em>e</em>]</span>
	3778	<pre>void lua_newtable (lua_State *L);</pre>
	3779
	3780	<p>
	3781	Creates a new empty table and pushes it onto the stack.
	3782	It is equivalent to <code>lua_createtable(L, 0, 0)</code>.
	3783
	3784
	3785
	3786
	3787
	3788	<hr><h3><a name="lua_newthread"><code>lua_newthread</code></a></h3><p>
	3789	<span class="apii">[-0, +1, <em>e</em>]</span>
	3790	<pre>lua_State lua_newthread (lua_State L);</pre>
	3791
	3792	<p>
	3793	Creates a new thread, pushes it on the stack,
	3794	and returns a pointer to a <a href="#lua_State"><code>lua_State</code></a> that represents this new thread.
	3795	The new thread returned by this function shares with the original thread
	3796	its global environment,
	3797	but has an independent execution stack.
	3798
	3799
	3800	<p>
	3801	There is no explicit function to close or to destroy a thread.
	3802	Threads are subject to garbage collection,
	3803	like any Lua object.
	3804
	3805
	3806
	3807
	3808
	3809	<hr><h3><a name="lua_newuserdata"><code>lua_newuserdata</code></a></h3><p>
	3810	<span class="apii">[-0, +1, <em>e</em>]</span>
	3811	<pre>void lua_newuserdata (lua_State L, size_t size);</pre>
	3812
	3813	<p>
	3814	This function allocates a new block of memory with the given size,
	3815	pushes onto the stack a new full userdata with the block address,
	3816	and returns this address.
	3817	The host program can freely use this memory.
	3818
	3819
	3820
	3821
	3822
	3823	<hr><h3><a name="lua_next"><code>lua_next</code></a></h3><p>
	3824	<span class="apii">[-1, +(2\|0), <em>e</em>]</span>
	3825	<pre>int lua_next (lua_State *L, int index);</pre>
	3826
	3827	<p>
	3828	Pops a key from the stack,
	3829	and pushes a key–value pair from the table at the given index
	3830	(the "next" pair after the given key).
	3831	If there are no more elements in the table,
	3832	then <a href="#lua_next"><code>lua_next</code></a> returns 0 (and pushes nothing).
	3833
	3834
	3835	<p>
	3836	A typical traversal looks like this:
	3837
	3838	<pre>
	3839	/* table is in the stack at index 't' */
	3840	lua_pushnil(L); /* first key */
	3841	while (lua_next(L, t) != 0) {
	3842	/* uses 'key' (at index -2) and 'value' (at index -1) */
	3843	printf("%s - %s\n",
	3844	lua_typename(L, lua_type(L, -2)),
	3845	lua_typename(L, lua_type(L, -1)));
	3846	/* removes 'value'; keeps 'key' for next iteration */
	3847	lua_pop(L, 1);
	3848	}
	3849	</pre>
	3850
	3851	<p>
	3852	While traversing a table,
	3853	do not call <a href="#lua_tolstring"><code>lua_tolstring</code></a> directly on a key,
	3854	unless you know that the key is actually a string.
	3855	Recall that <a href="#lua_tolstring"><code>lua_tolstring</code></a> may change
	3856	the value at the given index;
	3857	this confuses the next call to <a href="#lua_next"><code>lua_next</code></a>.
	3858
	3859
	3860	<p>
	3861	See function <a href="#pdf-next"><code>next</code></a> for the caveats of modifying
	3862	the table during its traversal.
	3863
	3864
	3865
	3866
	3867
	3868	<hr><h3><a name="lua_Number"><code>lua_Number</code></a></h3>
	3869	<pre>typedef double lua_Number;</pre>
	3870
	3871	<p>
	3872	The type of numbers in Lua.
	3873	By default, it is double, but that can be changed in <code>luaconf.h</code>.
	3874	Through this configuration file you can change
	3875	Lua to operate with another type for numbers (e.g., float or long).
	3876
	3877
	3878
	3879
	3880
	3881	<hr><h3><a name="lua_pcall"><code>lua_pcall</code></a></h3><p>
	3882	<span class="apii">[-(nargs + 1), +(nresults\|1), –]</span>
	3883	<pre>int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);</pre>
	3884
	3885	<p>
	3886	Calls a function in protected mode.
	3887
	3888
	3889	<p>
	3890	Both <code>nargs</code> and <code>nresults</code> have the same meaning as
	3891	in <a href="#lua_call"><code>lua_call</code></a>.
	3892	If there are no errors during the call,
	3893	<a href="#lua_pcall"><code>lua_pcall</code></a> behaves exactly like <a href="#lua_call"><code>lua_call</code></a>.
	3894	However, if there is any error,
	3895	<a href="#lua_pcall"><code>lua_pcall</code></a> catches it,
	3896	pushes a single value on the stack (the error message),
	3897	and returns an error code.
	3898	Like <a href="#lua_call"><code>lua_call</code></a>,
	3899	<a href="#lua_pcall"><code>lua_pcall</code></a> always removes the function
	3900	and its arguments from the stack.
	3901
	3902
	3903	<p>
	3904	If <code>msgh</code> is 0,
	3905	then the error message returned on the stack
	3906	is exactly the original error message.
	3907	Otherwise, <code>msgh</code> is the stack index of a
	3908	<em>message handler</em>.
	3909	(In the current implementation, this index cannot be a pseudo-index.)
	3910	In case of runtime errors,
	3911	this function will be called with the error message
	3912	and its return value will be the message
	3913	returned on the stack by <a href="#lua_pcall"><code>lua_pcall</code></a>.
	3914
	3915
	3916	<p>
	3917	Typically, the message handler is used to add more debug
	3918	information to the error message, such as a stack traceback.
	3919	Such information cannot be gathered after the return of <a href="#lua_pcall"><code>lua_pcall</code></a>,
	3920	since by then the stack has unwound.
	3921
	3922
	3923	<p>
	3924	The <a href="#lua_pcall"><code>lua_pcall</code></a> function returns one of the following codes
	3925	(defined in <code>lua.h</code>):
	3926
	3927	<ul>
	3928
	3929	<li><b><a name="pdf-LUA_OK"><code>LUA_OK</code></a> (0): </b>
	3930	success.</li>
	3931
	3932	<li><b><a name="pdf-LUA_ERRRUN"><code>LUA_ERRRUN</code></a>: </b>
	3933	a runtime error.
	3934	</li>
	3935
	3936	<li><b><a name="pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>: </b>
	3937	memory allocation error.
	3938	For such errors, Lua does not call the message handler.
	3939	</li>
	3940
	3941	<li><b><a name="pdf-LUA_ERRERR"><code>LUA_ERRERR</code></a>: </b>
	3942	error while running the message handler.
	3943	</li>
	3944
	3945	<li><b><a name="pdf-LUA_ERRGCMM"><code>LUA_ERRGCMM</code></a>: </b>
	3946	error while running a <code>__gc</code> metamethod.
	3947	(This error typically has no relation with the function being called.
	3948	It is generated by the garbage collector.)
	3949	</li>
	3950
	3951	</ul>
	3952
	3953
	3954
	3955
	3956	<hr><h3><a name="lua_pcallk"><code>lua_pcallk</code></a></h3><p>
	3957	<span class="apii">[-(nargs + 1), +(nresults\|1), –]</span>
	3958	<pre>int lua_pcallk (lua_State *L,
	3959	int nargs,
	3960	int nresults,
	3961	int errfunc,
	3962	int ctx,
	3963	lua_CFunction k);</pre>
	3964
	3965	<p>
	3966	This function behaves exactly like <a href="#lua_pcall"><code>lua_pcall</code></a>,
	3967	but allows the called function to yield (see <a href="#4.7">§4.7</a>).
	3968
	3969
	3970
	3971
	3972
	3973	<hr><h3><a name="lua_pop"><code>lua_pop</code></a></h3><p>
	3974	<span class="apii">[-n, +0, –]</span>
	3975	<pre>void lua_pop (lua_State *L, int n);</pre>
	3976
	3977	<p>
	3978	Pops <code>n</code> elements from the stack.
	3979
	3980
	3981
	3982
	3983
	3984	<hr><h3><a name="lua_pushboolean"><code>lua_pushboolean</code></a></h3><p>
	3985	<span class="apii">[-0, +1, –]</span>
	3986	<pre>void lua_pushboolean (lua_State *L, int b);</pre>
	3987
	3988	<p>
	3989	Pushes a boolean value with value <code>b</code> onto the stack.
	3990
	3991
	3992
	3993
	3994
	3995	<hr><h3><a name="lua_pushcclosure"><code>lua_pushcclosure</code></a></h3><p>
	3996	<span class="apii">[-n, +1, <em>e</em>]</span>
	3997	<pre>void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);</pre>
	3998
	3999	<p>
	4000	Pushes a new C closure onto the stack.
	4001
	4002
	4003	<p>
	4004	When a C function is created,
	4005	it is possible to associate some values with it,
	4006	thus creating a C closure (see <a href="#4.4">§4.4</a>);
	4007	these values are then accessible to the function whenever it is called.
	4008	To associate values with a C function,
	4009	first these values should be pushed onto the stack
	4010	(when there are multiple values, the first value is pushed first).
	4011	Then <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>
	4012	is called to create and push the C function onto the stack,
	4013	with the argument <code>n</code> telling how many values should be
	4014	associated with the function.
	4015	<a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a> also pops these values from the stack.
	4016
	4017
	4018	<p>
	4019	The maximum value for <code>n</code> is 255.
	4020
	4021
	4022	<p>
	4023	When <code>n</code> is zero,
	4024	this function creates a <em>light C function</em>,
	4025	which is just a pointer to the C function.
	4026	In that case, it never throws a memory error.
	4027
	4028
	4029
	4030
	4031
	4032	<hr><h3><a name="lua_pushcfunction"><code>lua_pushcfunction</code></a></h3><p>
	4033	<span class="apii">[-0, +1, –]</span>
	4034	<pre>void lua_pushcfunction (lua_State *L, lua_CFunction f);</pre>
	4035
	4036	<p>
	4037	Pushes a C function onto the stack.
	4038	This function receives a pointer to a C function
	4039	and pushes onto the stack a Lua value of type <code>function</code> that,
	4040	when called, invokes the corresponding C function.
	4041
	4042
	4043	<p>
	4044	Any function to be registered in Lua must
	4045	follow the correct protocol to receive its parameters
	4046	and return its results (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
	4047
	4048
	4049	<p>
	4050	<code>lua_pushcfunction</code> is defined as a macro:
	4051
	4052	<pre>
	4053	#define lua_pushcfunction(L,f) lua_pushcclosure(L,f,0)
	4054	</pre><p>
	4055	Note that <code>f</code> is used twice.
	4056
	4057
	4058
	4059
	4060
	4061	<hr><h3><a name="lua_pushfstring"><code>lua_pushfstring</code></a></h3><p>
	4062	<span class="apii">[-0, +1, <em>e</em>]</span>
	4063	<pre>const char lua_pushfstring (lua_State L, const char *fmt, ...);</pre>
	4064
	4065	<p>
	4066	Pushes onto the stack a formatted string
	4067	and returns a pointer to this string.
	4068	It is similar to the ANSI C function <code>sprintf</code>,
	4069	but has some important differences:
	4070
	4071	<ul>
	4072
	4073	<li>
	4074	You do not have to allocate space for the result:
	4075	the result is a Lua string and Lua takes care of memory allocation
	4076	(and deallocation, through garbage collection).
	4077	</li>
	4078
	4079	<li>
	4080	The conversion specifiers are quite restricted.
	4081	There are no flags, widths, or precisions.
	4082	The conversion specifiers can only be
	4083	'<code>%%</code>' (inserts a '<code>%</code>' in the string),
	4084	'<code>%s</code>' (inserts a zero-terminated string, with no size restrictions),
	4085	'<code>%f</code>' (inserts a <a href="#lua_Number"><code>lua_Number</code></a>),
	4086	'<code>%p</code>' (inserts a pointer as a hexadecimal numeral),
	4087	'<code>%d</code>' (inserts an <code>int</code>), and
	4088	'<code>%c</code>' (inserts an <code>int</code> as a byte).
	4089	</li>
	4090
	4091	</ul>
	4092
	4093
	4094
	4095
	4096	<hr><h3><a name="lua_pushglobaltable"><code>lua_pushglobaltable</code></a></h3><p>
	4097	<span class="apii">[-0, +1, –]</span>
	4098	<pre>void lua_pushglobaltable (lua_State *L);</pre>
	4099
	4100	<p>
	4101	Pushes the global environment onto the stack.
	4102
	4103
	4104
	4105
	4106
	4107	<hr><h3><a name="lua_pushinteger"><code>lua_pushinteger</code></a></h3><p>
	4108	<span class="apii">[-0, +1, –]</span>
	4109	<pre>void lua_pushinteger (lua_State *L, lua_Integer n);</pre>
	4110
	4111	<p>
	4112	Pushes a number with value <code>n</code> onto the stack.
	4113
	4114
	4115
	4116
	4117
	4118	<hr><h3><a name="lua_pushlightuserdata"><code>lua_pushlightuserdata</code></a></h3><p>
	4119	<span class="apii">[-0, +1, –]</span>
	4120	<pre>void lua_pushlightuserdata (lua_State L, void p);</pre>
	4121
	4122	<p>
	4123	Pushes a light userdata onto the stack.
	4124
	4125
	4126	<p>
	4127	Userdata represent C values in Lua.
	4128	A <em>light userdata</em> represents a pointer, a <code>void*</code>.
	4129	It is a value (like a number):
	4130	you do not create it, it has no individual metatable,
	4131	and it is not collected (as it was never created).
	4132	A light userdata is equal to "any"
	4133	light userdata with the same C address.
	4134
	4135
	4136
	4137
	4138
	4139	<hr><h3><a name="lua_pushliteral"><code>lua_pushliteral</code></a></h3><p>
	4140	<span class="apii">[-0, +1, <em>e</em>]</span>
	4141	<pre>const char lua_pushliteral (lua_State L, const char *s);</pre>
	4142
	4143	<p>
	4144	This macro is equivalent to <a href="#lua_pushlstring"><code>lua_pushlstring</code></a>,
	4145	but can be used only when <code>s</code> is a literal string.
	4146	It automatically provides the string length.
	4147
	4148
	4149
	4150
	4151
	4152	<hr><h3><a name="lua_pushlstring"><code>lua_pushlstring</code></a></h3><p>
	4153	<span class="apii">[-0, +1, <em>e</em>]</span>
	4154	<pre>const char lua_pushlstring (lua_State L, const char *s, size_t len);</pre>
	4155
	4156	<p>
	4157	Pushes the string pointed to by <code>s</code> with size <code>len</code>
	4158	onto the stack.
	4159	Lua makes (or reuses) an internal copy of the given string,
	4160	so the memory at <code>s</code> can be freed or reused immediately after
	4161	the function returns.
	4162	The string can contain any binary data,
	4163	including embedded zeros.
	4164
	4165
	4166	<p>
	4167	Returns a pointer to the internal copy of the string.
	4168
	4169
	4170
	4171
	4172
	4173	<hr><h3><a name="lua_pushnil"><code>lua_pushnil</code></a></h3><p>
	4174	<span class="apii">[-0, +1, –]</span>
	4175	<pre>void lua_pushnil (lua_State *L);</pre>
	4176
	4177	<p>
	4178	Pushes a nil value onto the stack.
	4179
	4180
	4181
	4182
	4183
	4184	<hr><h3><a name="lua_pushnumber"><code>lua_pushnumber</code></a></h3><p>
	4185	<span class="apii">[-0, +1, –]</span>
	4186	<pre>void lua_pushnumber (lua_State *L, lua_Number n);</pre>
	4187
	4188	<p>
	4189	Pushes a number with value <code>n</code> onto the stack.
	4190
	4191
	4192
	4193
	4194
	4195	<hr><h3><a name="lua_pushstring"><code>lua_pushstring</code></a></h3><p>
	4196	<span class="apii">[-0, +1, <em>e</em>]</span>
	4197	<pre>const char lua_pushstring (lua_State L, const char *s);</pre>
	4198
	4199	<p>
	4200	Pushes the zero-terminated string pointed to by <code>s</code>
	4201	onto the stack.
	4202	Lua makes (or reuses) an internal copy of the given string,
	4203	so the memory at <code>s</code> can be freed or reused immediately after
	4204	the function returns.
	4205
	4206
	4207	<p>
	4208	Returns a pointer to the internal copy of the string.
	4209
	4210
	4211	<p>
	4212	If <code>s</code> is <code>NULL</code>, pushes <b>nil</b> and returns <code>NULL</code>.
	4213
	4214
	4215
	4216
	4217
	4218	<hr><h3><a name="lua_pushthread"><code>lua_pushthread</code></a></h3><p>
	4219	<span class="apii">[-0, +1, –]</span>
	4220	<pre>int lua_pushthread (lua_State *L);</pre>
	4221
	4222	<p>
	4223	Pushes the thread represented by <code>L</code> onto the stack.
	4224	Returns 1 if this thread is the main thread of its state.
	4225
	4226
	4227
	4228
	4229
	4230	<hr><h3><a name="lua_pushunsigned"><code>lua_pushunsigned</code></a></h3><p>
	4231	<span class="apii">[-0, +1, –]</span>
	4232	<pre>void lua_pushunsigned (lua_State *L, lua_Unsigned n);</pre>
	4233
	4234	<p>
	4235	Pushes a number with value <code>n</code> onto the stack.
	4236
	4237
	4238
	4239
	4240
	4241	<hr><h3><a name="lua_pushvalue"><code>lua_pushvalue</code></a></h3><p>
	4242	<span class="apii">[-0, +1, –]</span>
	4243	<pre>void lua_pushvalue (lua_State *L, int index);</pre>
	4244
	4245	<p>
	4246	Pushes a copy of the element at the given index
	4247	onto the stack.
	4248
	4249
	4250
	4251
	4252
	4253	<hr><h3><a name="lua_pushvfstring"><code>lua_pushvfstring</code></a></h3><p>
	4254	<span class="apii">[-0, +1, <em>e</em>]</span>
	4255	<pre>const char lua_pushvfstring (lua_State L,
	4256	const char *fmt,
	4257	va_list argp);</pre>
	4258
	4259	<p>
	4260	Equivalent to <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>, except that it receives a <code>va_list</code>
	4261	instead of a variable number of arguments.
	4262
	4263
	4264
	4265
	4266
	4267	<hr><h3><a name="lua_rawequal"><code>lua_rawequal</code></a></h3><p>
	4268	<span class="apii">[-0, +0, –]</span>
	4269	<pre>int lua_rawequal (lua_State *L, int index1, int index2);</pre>
	4270
	4271	<p>
	4272	Returns 1 if the two values in indices <code>index1</code> and
	4273	<code>index2</code> are primitively equal
	4274	(that is, without calling metamethods).
	4275	Otherwise returns 0.
	4276	Also returns 0 if any of the indices are non valid.
	4277
	4278
	4279
	4280
	4281
	4282	<hr><h3><a name="lua_rawget"><code>lua_rawget</code></a></h3><p>
	4283	<span class="apii">[-1, +1, –]</span>
	4284	<pre>void lua_rawget (lua_State *L, int index);</pre>
	4285
	4286	<p>
	4287	Similar to <a href="#lua_gettable"><code>lua_gettable</code></a>, but does a raw access
	4288	(i.e., without metamethods).
	4289
	4290
	4291
	4292
	4293
	4294	<hr><h3><a name="lua_rawgeti"><code>lua_rawgeti</code></a></h3><p>
	4295	<span class="apii">[-0, +1, –]</span>
	4296	<pre>void lua_rawgeti (lua_State *L, int index, int n);</pre>
	4297
	4298	<p>
	4299	Pushes onto the stack the value <code>t[n]</code>,
	4300	where <code>t</code> is the table at the given index.
	4301	The access is raw;
	4302	that is, it does not invoke metamethods.
	4303
	4304
	4305
	4306
	4307
	4308	<hr><h3><a name="lua_rawgetp"><code>lua_rawgetp</code></a></h3><p>
	4309	<span class="apii">[-0, +1, –]</span>
	4310	<pre>void lua_rawgetp (lua_State L, int index, const void p);</pre>
	4311
	4312	<p>
	4313	Pushes onto the stack the value <code>t[k]</code>,
	4314	where <code>t</code> is the table at the given index and
	4315	<code>k</code> is the pointer <code>p</code> represented as a light userdata.
	4316	The access is raw;
	4317	that is, it does not invoke metamethods.
	4318
	4319
	4320
	4321
	4322
	4323	<hr><h3><a name="lua_rawlen"><code>lua_rawlen</code></a></h3><p>
	4324	<span class="apii">[-0, +0, –]</span>
	4325	<pre>size_t lua_rawlen (lua_State *L, int index);</pre>
	4326
	4327	<p>
	4328	Returns the raw "length" of the value at the given index:
	4329	for strings, this is the string length;
	4330	for tables, this is the result of the length operator ('<code>#</code>')
	4331	with no metamethods;
	4332	for userdata, this is the size of the block of memory allocated
	4333	for the userdata;
	4334	for other values, it is 0.
	4335
	4336
	4337
	4338
	4339
	4340	<hr><h3><a name="lua_rawset"><code>lua_rawset</code></a></h3><p>
	4341	<span class="apii">[-2, +0, <em>e</em>]</span>
	4342	<pre>void lua_rawset (lua_State *L, int index);</pre>
	4343
	4344	<p>
	4345	Similar to <a href="#lua_settable"><code>lua_settable</code></a>, but does a raw assignment
	4346	(i.e., without metamethods).
	4347
	4348
	4349
	4350
	4351
	4352	<hr><h3><a name="lua_rawseti"><code>lua_rawseti</code></a></h3><p>
	4353	<span class="apii">[-1, +0, <em>e</em>]</span>
	4354	<pre>void lua_rawseti (lua_State *L, int index, int n);</pre>
	4355
	4356	<p>
	4357	Does the equivalent of <code>t[n] = v</code>,
	4358	where <code>t</code> is the table at the given index
	4359	and <code>v</code> is the value at the top of the stack.
	4360
	4361
	4362	<p>
	4363	This function pops the value from the stack.
	4364	The assignment is raw;
	4365	that is, it does not invoke metamethods.
	4366
	4367
	4368
	4369
	4370
	4371	<hr><h3><a name="lua_rawsetp"><code>lua_rawsetp</code></a></h3><p>
	4372	<span class="apii">[-1, +0, <em>e</em>]</span>
	4373	<pre>void lua_rawsetp (lua_State L, int index, const void p);</pre>
	4374
	4375	<p>
	4376	Does the equivalent of <code>t[k] = v</code>,
	4377	where <code>t</code> is the table at the given index,
	4378	<code>k</code> is the pointer <code>p</code> represented as a light userdata,
	4379	and <code>v</code> is the value at the top of the stack.
	4380
	4381
	4382	<p>
	4383	This function pops the value from the stack.
	4384	The assignment is raw;
	4385	that is, it does not invoke metamethods.
	4386
	4387
	4388
	4389
	4390
	4391	<hr><h3><a name="lua_Reader"><code>lua_Reader</code></a></h3>
	4392	<pre>typedef const char * (lua_Reader) (lua_State L,
	4393	void *data,
	4394	size_t *size);</pre>
	4395
	4396	<p>
	4397	The reader function used by <a href="#lua_load"><code>lua_load</code></a>.
	4398	Every time it needs another piece of the chunk,
	4399	<a href="#lua_load"><code>lua_load</code></a> calls the reader,
	4400	passing along its <code>data</code> parameter.
	4401	The reader must return a pointer to a block of memory
	4402	with a new piece of the chunk
	4403	and set <code>size</code> to the block size.
	4404	The block must exist until the reader function is called again.
	4405	To signal the end of the chunk,
	4406	the reader must return <code>NULL</code> or set <code>size</code> to zero.
	4407	The reader function may return pieces of any size greater than zero.
	4408
	4409
	4410
	4411
	4412
	4413	<hr><h3><a name="lua_register"><code>lua_register</code></a></h3><p>
	4414	<span class="apii">[-0, +0, <em>e</em>]</span>
	4415	<pre>void lua_register (lua_State L, const char name, lua_CFunction f);</pre>
	4416
	4417	<p>
	4418	Sets the C function <code>f</code> as the new value of global <code>name</code>.
	4419	It is defined as a macro:
	4420
	4421	<pre>
	4422	#define lua_register(L,n,f) \
	4423	(lua_pushcfunction(L, f), lua_setglobal(L, n))
	4424	</pre>
	4425
	4426
	4427
	4428
	4429	<hr><h3><a name="lua_remove"><code>lua_remove</code></a></h3><p>
	4430	<span class="apii">[-1, +0, –]</span>
	4431	<pre>void lua_remove (lua_State *L, int index);</pre>
	4432
	4433	<p>
	4434	Removes the element at the given valid index,
	4435	shifting down the elements above this index to fill the gap.
	4436	This function cannot be called with a pseudo-index,
	4437	because a pseudo-index is not an actual stack position.
	4438
	4439
	4440
	4441
	4442
	4443	<hr><h3><a name="lua_replace"><code>lua_replace</code></a></h3><p>
	4444	<span class="apii">[-1, +0, –]</span>
	4445	<pre>void lua_replace (lua_State *L, int index);</pre>
	4446
	4447	<p>
	4448	Moves the top element into the given valid index
	4449	without shifting any element
	4450	(therefore replacing the value at the given index),
	4451	and then pops the top element.
	4452
	4453
	4454
	4455
	4456
	4457	<hr><h3><a name="lua_resume"><code>lua_resume</code></a></h3><p>
	4458	<span class="apii">[-?, +?, –]</span>
	4459	<pre>int lua_resume (lua_State L, lua_State from, int nargs);</pre>
	4460
	4461	<p>
	4462	Starts and resumes a coroutine in a given thread.
	4463
	4464
	4465	<p>
	4466	To start a coroutine,
	4467	you push onto the thread stack the main function plus any arguments;
	4468	then you call <a href="#lua_resume"><code>lua_resume</code></a>,
	4469	with <code>nargs</code> being the number of arguments.
	4470	This call returns when the coroutine suspends or finishes its execution.
	4471	When it returns, the stack contains all values passed to <a href="#lua_yield"><code>lua_yield</code></a>,
	4472	or all values returned by the body function.
	4473	<a href="#lua_resume"><code>lua_resume</code></a> returns
	4474	<a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> if the coroutine yields,
	4475	<a href="#pdf-LUA_OK"><code>LUA_OK</code></a> if the coroutine finishes its execution
	4476	without errors,
	4477	or an error code in case of errors (see <a href="#lua_pcall"><code>lua_pcall</code></a>).
	4478
	4479
	4480	<p>
	4481	In case of errors,
	4482	the stack is not unwound,
	4483	so you can use the debug API over it.
	4484	The error message is on the top of the stack.
	4485
	4486
	4487	<p>
	4488	To resume a coroutine,
	4489	you remove any results from the last <a href="#lua_yield"><code>lua_yield</code></a>,
	4490	put on its stack only the values to
	4491	be passed as results from <code>yield</code>,
	4492	and then call <a href="#lua_resume"><code>lua_resume</code></a>.
	4493
	4494
	4495	<p>
	4496	The parameter <code>from</code> represents the coroutine that is resuming <code>L</code>.
	4497	If there is no such coroutine,
	4498	this parameter can be <code>NULL</code>.
	4499
	4500
	4501
	4502
	4503
	4504	<hr><h3><a name="lua_setallocf"><code>lua_setallocf</code></a></h3><p>
	4505	<span class="apii">[-0, +0, –]</span>
	4506	<pre>void lua_setallocf (lua_State L, lua_Alloc f, void ud);</pre>
	4507
	4508	<p>
	4509	Changes the allocator function of a given state to <code>f</code>
	4510	with user data <code>ud</code>.
	4511
	4512
	4513
	4514
	4515
	4516	<hr><h3><a name="lua_setfield"><code>lua_setfield</code></a></h3><p>
	4517	<span class="apii">[-1, +0, <em>e</em>]</span>
	4518	<pre>void lua_setfield (lua_State L, int index, const char k);</pre>
	4519
	4520	<p>
	4521	Does the equivalent to <code>t[k] = v</code>,
	4522	where <code>t</code> is the value at the given index
	4523	and <code>v</code> is the value at the top of the stack.
	4524
	4525
	4526	<p>
	4527	This function pops the value from the stack.
	4528	As in Lua, this function may trigger a metamethod
	4529	for the "newindex" event (see <a href="#2.4">§2.4</a>).
	4530
	4531
	4532
	4533
	4534
	4535	<hr><h3><a name="lua_setglobal"><code>lua_setglobal</code></a></h3><p>
	4536	<span class="apii">[-1, +0, <em>e</em>]</span>
	4537	<pre>void lua_setglobal (lua_State L, const char name);</pre>
	4538
	4539	<p>
	4540	Pops a value from the stack and
	4541	sets it as the new value of global <code>name</code>.
	4542
	4543
	4544
	4545
	4546
	4547	<hr><h3><a name="lua_setmetatable"><code>lua_setmetatable</code></a></h3><p>
	4548	<span class="apii">[-1, +0, –]</span>
	4549	<pre>void lua_setmetatable (lua_State *L, int index);</pre>
	4550
	4551	<p>
	4552	Pops a table from the stack and
	4553	sets it as the new metatable for the value at the given index.
	4554
	4555
	4556
	4557
	4558
	4559	<hr><h3><a name="lua_settable"><code>lua_settable</code></a></h3><p>
	4560	<span class="apii">[-2, +0, <em>e</em>]</span>
	4561	<pre>void lua_settable (lua_State *L, int index);</pre>
	4562
	4563	<p>
	4564	Does the equivalent to <code>t[k] = v</code>,
	4565	where <code>t</code> is the value at the given index,
	4566	<code>v</code> is the value at the top of the stack,
	4567	and <code>k</code> is the value just below the top.
	4568
	4569
	4570	<p>
	4571	This function pops both the key and the value from the stack.
	4572	As in Lua, this function may trigger a metamethod
	4573	for the "newindex" event (see <a href="#2.4">§2.4</a>).
	4574
	4575
	4576
	4577
	4578
	4579	<hr><h3><a name="lua_settop"><code>lua_settop</code></a></h3><p>
	4580	<span class="apii">[-?, +?, –]</span>
	4581	<pre>void lua_settop (lua_State *L, int index);</pre>
	4582
	4583	<p>
	4584	Accepts any index, or 0,
	4585	and sets the stack top to this index.
	4586	If the new top is larger than the old one,
	4587	then the new elements are filled with <b>nil</b>.
	4588	If <code>index</code> is 0, then all stack elements are removed.
	4589
	4590
	4591
	4592
	4593
	4594	<hr><h3><a name="lua_setuservalue"><code>lua_setuservalue</code></a></h3><p>
	4595	<span class="apii">[-1, +0, –]</span>
	4596	<pre>void lua_setuservalue (lua_State *L, int index);</pre>
	4597
	4598	<p>
	4599	Pops a table or <b>nil</b> from the stack and sets it as
	4600	the new value associated to the userdata at the given index.
	4601
	4602
	4603
	4604
	4605
	4606	<hr><h3><a name="lua_State"><code>lua_State</code></a></h3>
	4607	<pre>typedef struct lua_State lua_State;</pre>
	4608
	4609	<p>
	4610	An opaque structure that points to a thread and indirectly
	4611	(through the thread) to the whole state of a Lua interpreter.
	4612	The Lua library is fully reentrant:
	4613	it has no global variables.
	4614	All information about a state is accessible through this structure.
	4615
	4616
	4617	<p>
	4618	A pointer to this structure must be passed as the first argument to
	4619	every function in the library, except to <a href="#lua_newstate"><code>lua_newstate</code></a>,
	4620	which creates a Lua state from scratch.
	4621
	4622
	4623
	4624
	4625
	4626	<hr><h3><a name="lua_status"><code>lua_status</code></a></h3><p>
	4627	<span class="apii">[-0, +0, –]</span>
	4628	<pre>int lua_status (lua_State *L);</pre>
	4629
	4630	<p>
	4631	Returns the status of the thread <code>L</code>.
	4632
	4633
	4634	<p>
	4635	The status can be 0 (<a href="#pdf-LUA_OK"><code>LUA_OK</code></a>) for a normal thread,
	4636	an error code if the thread finished the execution
	4637	of a <a href="#lua_resume"><code>lua_resume</code></a> with an error,
	4638	or <a name="pdf-LUA_YIELD"><code>LUA_YIELD</code></a> if the thread is suspended.
	4639
	4640
	4641	<p>
	4642	You can only call functions in threads with status <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>.
	4643	You can resume threads with status <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>
	4644	(to start a new coroutine) or <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a>
	4645	(to resume a coroutine).
	4646
	4647
	4648
	4649
	4650
	4651	<hr><h3><a name="lua_toboolean"><code>lua_toboolean</code></a></h3><p>
	4652	<span class="apii">[-0, +0, –]</span>
	4653	<pre>int lua_toboolean (lua_State *L, int index);</pre>
	4654
	4655	<p>
	4656	Converts the Lua value at the given index to a C boolean
	4657	value (0 or 1).
	4658	Like all tests in Lua,
	4659	<a href="#lua_toboolean"><code>lua_toboolean</code></a> returns true for any Lua value
	4660	different from <b>false</b> and <b>nil</b>;
	4661	otherwise it returns false.
	4662	(If you want to accept only actual boolean values,
	4663	use <a href="#lua_isboolean"><code>lua_isboolean</code></a> to test the value's type.)
	4664
	4665
	4666
	4667
	4668
	4669	<hr><h3><a name="lua_tocfunction"><code>lua_tocfunction</code></a></h3><p>
	4670	<span class="apii">[-0, +0, –]</span>
	4671	<pre>lua_CFunction lua_tocfunction (lua_State *L, int index);</pre>
	4672
	4673	<p>
	4674	Converts a value at the given index to a C function.
	4675	That value must be a C function;
	4676	otherwise, returns <code>NULL</code>.
	4677
	4678
	4679
	4680
	4681
	4682	<hr><h3><a name="lua_tointeger"><code>lua_tointeger</code></a></h3><p>
	4683	<span class="apii">[-0, +0, –]</span>
	4684	<pre>lua_Integer lua_tointeger (lua_State *L, int index);</pre>
	4685
	4686	<p>
	4687	Equivalent to <a href="#lua_tointegerx"><code>lua_tointegerx</code></a> with <code>isnum</code> equal to <code>NULL</code>.
	4688
	4689
	4690
	4691
	4692
	4693	<hr><h3><a name="lua_tointegerx"><code>lua_tointegerx</code></a></h3><p>
	4694	<span class="apii">[-0, +0, –]</span>
	4695	<pre>lua_Integer lua_tointegerx (lua_State L, int index, int isnum);</pre>
	4696
	4697	<p>
	4698	Converts the Lua value at the given index
	4699	to the signed integral type <a href="#lua_Integer"><code>lua_Integer</code></a>.
	4700	The Lua value must be a number or a string convertible to a number
	4701	(see <a href="#3.4.2">§3.4.2</a>);
	4702	otherwise, <code>lua_tointegerx</code> returns 0.
	4703
	4704
	4705	<p>
	4706	If the number is not an integer,
	4707	it is truncated in some non-specified way.
	4708
	4709
	4710	<p>
	4711	If <code>isnum</code> is not <code>NULL</code>,
	4712	its referent is assigned a boolean value that
	4713	indicates whether the operation succeeded.
	4714
	4715
	4716
	4717
	4718
	4719	<hr><h3><a name="lua_tolstring"><code>lua_tolstring</code></a></h3><p>
	4720	<span class="apii">[-0, +0, <em>e</em>]</span>
	4721	<pre>const char lua_tolstring (lua_State L, int index, size_t *len);</pre>
	4722
	4723	<p>
	4724	Converts the Lua value at the given index to a C string.
	4725	If <code>len</code> is not <code>NULL</code>,
	4726	it also sets <code>*len</code> with the string length.
	4727	The Lua value must be a string or a number;
	4728	otherwise, the function returns <code>NULL</code>.
	4729	If the value is a number,
	4730	then <code>lua_tolstring</code> also
	4731	<em>changes the actual value in the stack to a string</em>.
	4732	(This change confuses <a href="#lua_next"><code>lua_next</code></a>
	4733	when <code>lua_tolstring</code> is applied to keys during a table traversal.)
	4734
	4735
	4736	<p>
	4737	<code>lua_tolstring</code> returns a fully aligned pointer
	4738	to a string inside the Lua state.
	4739	This string always has a zero ('<code>\0</code>')
	4740	after its last character (as in C),
	4741	but can contain other zeros in its body.
	4742	Because Lua has garbage collection,
	4743	there is no guarantee that the pointer returned by <code>lua_tolstring</code>
	4744	will be valid after the corresponding value is removed from the stack.
	4745
	4746
	4747
	4748
	4749
	4750	<hr><h3><a name="lua_tonumber"><code>lua_tonumber</code></a></h3><p>
	4751	<span class="apii">[-0, +0, –]</span>
	4752	<pre>lua_Number lua_tonumber (lua_State *L, int index);</pre>
	4753
	4754	<p>
	4755	Equivalent to <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> with <code>isnum</code> equal to <code>NULL</code>.
	4756
	4757
	4758
	4759
	4760
	4761	<hr><h3><a name="lua_tonumberx"><code>lua_tonumberx</code></a></h3><p>
	4762	<span class="apii">[-0, +0, –]</span>
	4763	<pre>lua_Number lua_tonumberx (lua_State L, int index, int isnum);</pre>
	4764
	4765	<p>
	4766	Converts the Lua value at the given index
	4767	to the C type <a href="#lua_Number"><code>lua_Number</code></a> (see <a href="#lua_Number"><code>lua_Number</code></a>).
	4768	The Lua value must be a number or a string convertible to a number
	4769	(see <a href="#3.4.2">§3.4.2</a>);
	4770	otherwise, <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> returns 0.
	4771
	4772
	4773	<p>
	4774	If <code>isnum</code> is not <code>NULL</code>,
	4775	its referent is assigned a boolean value that
	4776	indicates whether the operation succeeded.
	4777
	4778
	4779
	4780
	4781
	4782	<hr><h3><a name="lua_topointer"><code>lua_topointer</code></a></h3><p>
	4783	<span class="apii">[-0, +0, –]</span>
	4784	<pre>const void lua_topointer (lua_State L, int index);</pre>
	4785
	4786	<p>
	4787	Converts the value at the given index to a generic
	4788	C pointer (<code>void*</code>).
	4789	The value can be a userdata, a table, a thread, or a function;
	4790	otherwise, <code>lua_topointer</code> returns <code>NULL</code>.
	4791	Different objects will give different pointers.
	4792	There is no way to convert the pointer back to its original value.
	4793
	4794
	4795	<p>
	4796	Typically this function is used only for debug information.
	4797
	4798
	4799
	4800
	4801
	4802	<hr><h3><a name="lua_tostring"><code>lua_tostring</code></a></h3><p>
	4803	<span class="apii">[-0, +0, <em>e</em>]</span>
	4804	<pre>const char lua_tostring (lua_State L, int index);</pre>
	4805
	4806	<p>
	4807	Equivalent to <a href="#lua_tolstring"><code>lua_tolstring</code></a> with <code>len</code> equal to <code>NULL</code>.
	4808
	4809
	4810
	4811
	4812
	4813	<hr><h3><a name="lua_tothread"><code>lua_tothread</code></a></h3><p>
	4814	<span class="apii">[-0, +0, –]</span>
	4815	<pre>lua_State lua_tothread (lua_State L, int index);</pre>
	4816
	4817	<p>
	4818	Converts the value at the given index to a Lua thread
	4819	(represented as <code>lua_State*</code>).
	4820	This value must be a thread;
	4821	otherwise, the function returns <code>NULL</code>.
	4822
	4823
	4824
	4825
	4826
	4827	<hr><h3><a name="lua_tounsigned"><code>lua_tounsigned</code></a></h3><p>
	4828	<span class="apii">[-0, +0, –]</span>
	4829	<pre>lua_Unsigned lua_tounsigned (lua_State *L, int index);</pre>
	4830
	4831	<p>
	4832	Equivalent to <a href="#lua_tounsignedx"><code>lua_tounsignedx</code></a> with <code>isnum</code> equal to <code>NULL</code>.
	4833
	4834
	4835
	4836
	4837
	4838	<hr><h3><a name="lua_tounsignedx"><code>lua_tounsignedx</code></a></h3><p>
	4839	<span class="apii">[-0, +0, –]</span>
	4840	<pre>lua_Unsigned lua_tounsignedx (lua_State L, int index, int isnum);</pre>
	4841
	4842	<p>
	4843	Converts the Lua value at the given index
	4844	to the unsigned integral type <a href="#lua_Unsigned"><code>lua_Unsigned</code></a>.
	4845	The Lua value must be a number or a string convertible to a number
	4846	(see <a href="#3.4.2">§3.4.2</a>);
	4847	otherwise, <code>lua_tounsignedx</code> returns 0.
	4848
	4849
	4850	<p>
	4851	If the number is not an integer,
	4852	it is truncated in some non-specified way.
	4853	If the number is outside the range of representable values,
	4854	it is normalized to the remainder of its division by
	4855	one more than the maximum representable value.
	4856
	4857
	4858	<p>
	4859	If <code>isnum</code> is not <code>NULL</code>,
	4860	its referent is assigned a boolean value that
	4861	indicates whether the operation succeeded.
	4862
	4863
	4864
	4865
	4866
	4867	<hr><h3><a name="lua_touserdata"><code>lua_touserdata</code></a></h3><p>
	4868	<span class="apii">[-0, +0, –]</span>
	4869	<pre>void lua_touserdata (lua_State L, int index);</pre>
	4870
	4871	<p>
	4872	If the value at the given index is a full userdata,
	4873	returns its block address.
	4874	If the value is a light userdata,
	4875	returns its pointer.
	4876	Otherwise, returns <code>NULL</code>.
	4877
	4878
	4879
	4880
	4881
	4882	<hr><h3><a name="lua_type"><code>lua_type</code></a></h3><p>
	4883	<span class="apii">[-0, +0, –]</span>
	4884	<pre>int lua_type (lua_State *L, int index);</pre>
	4885
	4886	<p>
	4887	Returns the type of the value in the given valid index,
	4888	or <code>LUA_TNONE</code> for a non-valid (but acceptable) index.
	4889	The types returned by <a href="#lua_type"><code>lua_type</code></a> are coded by the following constants
	4890	defined in <code>lua.h</code>:
	4891	<a name="pdf-LUA_TNIL"><code>LUA_TNIL</code></a>,
	4892	<a name="pdf-LUA_TNUMBER"><code>LUA_TNUMBER</code></a>,
	4893	<a name="pdf-LUA_TBOOLEAN"><code>LUA_TBOOLEAN</code></a>,
	4894	<a name="pdf-LUA_TSTRING"><code>LUA_TSTRING</code></a>,
	4895	<a name="pdf-LUA_TTABLE"><code>LUA_TTABLE</code></a>,
	4896	<a name="pdf-LUA_TFUNCTION"><code>LUA_TFUNCTION</code></a>,
	4897	<a name="pdf-LUA_TUSERDATA"><code>LUA_TUSERDATA</code></a>,
	4898	<a name="pdf-LUA_TTHREAD"><code>LUA_TTHREAD</code></a>,
	4899	and
	4900	<a name="pdf-LUA_TLIGHTUSERDATA"><code>LUA_TLIGHTUSERDATA</code></a>.
	4901
	4902
	4903
	4904
	4905
	4906	<hr><h3><a name="lua_typename"><code>lua_typename</code></a></h3><p>
	4907	<span class="apii">[-0, +0, –]</span>
	4908	<pre>const char lua_typename (lua_State L, int tp);</pre>
	4909
	4910	<p>
	4911	Returns the name of the type encoded by the value <code>tp</code>,
	4912	which must be one the values returned by <a href="#lua_type"><code>lua_type</code></a>.
	4913
	4914
	4915
	4916
	4917
	4918	<hr><h3><a name="lua_Unsigned"><code>lua_Unsigned</code></a></h3>
	4919	<pre>typedef unsigned long lua_Unsigned;</pre>
	4920
	4921	<p>
	4922	The type used by the Lua API to represent unsigned integral values.
	4923	It must have at least 32 bits.
	4924
	4925
	4926	<p>
	4927	By default it is an <code>unsigned int</code> or an <code>unsigned long</code>,
	4928	whichever can hold 32-bit values.
	4929
	4930
	4931
	4932
	4933
	4934	<hr><h3><a name="lua_upvalueindex"><code>lua_upvalueindex</code></a></h3><p>
	4935	<span class="apii">[-0, +0, –]</span>
	4936	<pre>int lua_upvalueindex (int i);</pre>
	4937
	4938	<p>
	4939	Returns the pseudo-index that represents the <code>i</code>-th upvalue of
	4940	the running function (see <a href="#4.4">§4.4</a>).
	4941
	4942
	4943
	4944
	4945
	4946	<hr><h3><a name="lua_version"><code>lua_version</code></a></h3><p>
	4947	<span class="apii">[-0, +0, <em>v</em>]</span>
	4948	<pre>const lua_Number lua_version (lua_State L);</pre>
	4949
	4950	<p>
	4951	Returns the address of the version number stored in the Lua core.
	4952	When called with a valid <a href="#lua_State"><code>lua_State</code></a>,
	4953	returns the address of the version used to create that state.
	4954	When called with <code>NULL</code>,
	4955	returns the address of the version running the call.
	4956
	4957
	4958
	4959
	4960
	4961	<hr><h3><a name="lua_Writer"><code>lua_Writer</code></a></h3>
	4962	<pre>typedef int (lua_Writer) (lua_State L,
	4963	const void* p,
	4964	size_t sz,
	4965	void* ud);</pre>
	4966
	4967	<p>
	4968	The type of the writer function used by <a href="#lua_dump"><code>lua_dump</code></a>.
	4969	Every time it produces another piece of chunk,
	4970	<a href="#lua_dump"><code>lua_dump</code></a> calls the writer,
	4971	passing along the buffer to be written (<code>p</code>),
	4972	its size (<code>sz</code>),
	4973	and the <code>data</code> parameter supplied to <a href="#lua_dump"><code>lua_dump</code></a>.
	4974
	4975
	4976	<p>
	4977	The writer returns an error code:
	4978	0 means no errors;
	4979	any other value means an error and stops <a href="#lua_dump"><code>lua_dump</code></a> from
	4980	calling the writer again.
	4981
	4982
	4983
	4984
	4985
	4986	<hr><h3><a name="lua_xmove"><code>lua_xmove</code></a></h3><p>
	4987	<span class="apii">[-?, +?, –]</span>
	4988	<pre>void lua_xmove (lua_State from, lua_State to, int n);</pre>
	4989
	4990	<p>
	4991	Exchange values between different threads of the same state.
	4992
	4993
	4994	<p>
	4995	This function pops <code>n</code> values from the stack <code>from</code>,
	4996	and pushes them onto the stack <code>to</code>.
	4997
	4998
	4999
	5000
	5001
	5002	<hr><h3><a name="lua_yield"><code>lua_yield</code></a></h3><p>
	5003	<span class="apii">[-?, +?, –]</span>
	5004	<pre>int lua_yield (lua_State *L, int nresults);</pre>
	5005
	5006	<p>
	5007	This function is equivalent to <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
	5008	but it has no continuation (see <a href="#4.7">§4.7</a>).
	5009	Therefore, when the thread resumes,
	5010	it returns to the function that called
	5011	the function calling <code>lua_yield</code>.
	5012
	5013
	5014
	5015
	5016
	5017	<hr><h3><a name="lua_yieldk"><code>lua_yieldk</code></a></h3><p>
	5018	<span class="apii">[-?, +?, –]</span>
	5019	<pre>int lua_yieldk (lua_State *L, int nresults, int ctx, lua_CFunction k);</pre>
	5020
	5021	<p>
	5022	Yields a coroutine.
	5023
	5024
	5025	<p>
	5026	This function should only be called as the
	5027	return expression of a C function, as follows:
	5028
	5029	<pre>
	5030	return lua_yieldk (L, n, i, k);
	5031	</pre><p>
	5032	When a C function calls <a href="#lua_yieldk"><code>lua_yieldk</code></a> in that way,
	5033	the running coroutine suspends its execution,
	5034	and the call to <a href="#lua_resume"><code>lua_resume</code></a> that started this coroutine returns.
	5035	The parameter <code>nresults</code> is the number of values from the stack
	5036	that are passed as results to <a href="#lua_resume"><code>lua_resume</code></a>.
	5037
	5038
	5039	<p>
	5040	When the coroutine is resumed again,
	5041	Lua calls the given continuation function <code>k</code> to continue
	5042	the execution of the C function that yielded (see <a href="#4.7">§4.7</a>).
	5043	This continuation function receives the same stack
	5044	from the previous function,
	5045	with the results removed and
	5046	replaced by the arguments passed to <a href="#lua_resume"><code>lua_resume</code></a>.
	5047	Moreover,
	5048	the continuation function may access the value <code>ctx</code>
	5049	by calling <a href="#lua_getctx"><code>lua_getctx</code></a>.
	5050
	5051
	5052
	5053
	5054
	5055
	5056
	5057	<h2>4.9 – <a name="4.9">The Debug Interface</a></h2>
	5058
	5059	<p>
	5060	Lua has no built-in debugging facilities.
	5061	Instead, it offers a special interface
	5062	by means of functions and <em>hooks</em>.
	5063	This interface allows the construction of different
	5064	kinds of debuggers, profilers, and other tools
	5065	that need "inside information" from the interpreter.
	5066
	5067
	5068
	5069	<hr><h3><a name="lua_Debug"><code>lua_Debug</code></a></h3>
	5070	<pre>typedef struct lua_Debug {
	5071	int event;
	5072	const char name; / (n) */
	5073	const char namewhat; / (n) */
	5074	const char what; / (S) */
	5075	const char source; / (S) */
	5076	int currentline; /* (l) */
	5077	int linedefined; /* (S) */
	5078	int lastlinedefined; /* (S) */
	5079	unsigned char nups; /* (u) number of upvalues */
	5080	unsigned char nparams; /* (u) number of parameters */
	5081	char isvararg; /* (u) */
	5082	char istailcall; /* (t) */
	5083	char short_src[LUA_IDSIZE]; /* (S) */
	5084	/* private part */
	5085	<em>other fields</em>
	5086	} lua_Debug;</pre>
	5087
	5088	<p>
	5089	A structure used to carry different pieces of
	5090	information about a function or an activation record.
	5091	<a href="#lua_getstack"><code>lua_getstack</code></a> fills only the private part
	5092	of this structure, for later use.
	5093	To fill the other fields of <a href="#lua_Debug"><code>lua_Debug</code></a> with useful information,
	5094	call <a href="#lua_getinfo"><code>lua_getinfo</code></a>.
	5095
	5096
	5097	<p>
	5098	The fields of <a href="#lua_Debug"><code>lua_Debug</code></a> have the following meaning:
	5099
	5100	<ul>
	5101
	5102	<li><b><code>source</code>: </b>
	5103	the source of the chunk that created the function.
	5104	If <code>source</code> starts with a '<code>@</code>',
	5105	it means that the function was defined in a file where
	5106	the file name follows the '<code>@</code>'.
	5107	If <code>source</code> starts with a '<code>=</code>',
	5108	the remainder of its contents describe the source in a user-dependent manner.
	5109	Otherwise,
	5110	the function was defined in a string where
	5111	<code>source</code> is that string.
	5112	</li>
	5113
	5114	<li><b><code>short_src</code>: </b>
	5115	a "printable" version of <code>source</code>, to be used in error messages.
	5116	</li>
	5117
	5118	<li><b><code>linedefined</code>: </b>
	5119	the line number where the definition of the function starts.
	5120	</li>
	5121
	5122	<li><b><code>lastlinedefined</code>: </b>
	5123	the line number where the definition of the function ends.
	5124	</li>
	5125
	5126	<li><b><code>what</code>: </b>
	5127	the string <code>"Lua"</code> if the function is a Lua function,
	5128	<code>"C"</code> if it is a C function,
	5129	<code>"main"</code> if it is the main part of a chunk.
	5130	</li>
	5131
	5132	<li><b><code>currentline</code>: </b>
	5133	the current line where the given function is executing.
	5134	When no line information is available,
	5135	<code>currentline</code> is set to -1.
	5136	</li>
	5137
	5138	<li><b><code>name</code>: </b>
	5139	a reasonable name for the given function.
	5140	Because functions in Lua are first-class values,
	5141	they do not have a fixed name:
	5142	some functions can be the value of multiple global variables,
	5143	while others can be stored only in a table field.
	5144	The <code>lua_getinfo</code> function checks how the function was
	5145	called to find a suitable name.
	5146	If it cannot find a name,
	5147	then <code>name</code> is set to <code>NULL</code>.
	5148	</li>
	5149
	5150	<li><b><code>namewhat</code>: </b>
	5151	explains the <code>name</code> field.
	5152	The value of <code>namewhat</code> can be
	5153	<code>"global"</code>, <code>"local"</code>, <code>"method"</code>,
	5154	<code>"field"</code>, <code>"upvalue"</code>, or <code>""</code> (the empty string),
	5155	according to how the function was called.
	5156	(Lua uses the empty string when no other option seems to apply.)
	5157	</li>
	5158
	5159	<li><b><code>istailcall</code>: </b>
	5160	true if this function invocation was called by a tail call.
	5161	In this case, the caller of this level is not in the stack.
	5162	</li>
	5163
	5164	<li><b><code>nups</code>: </b>
	5165	the number of upvalues of the function.
	5166	</li>
	5167
	5168	<li><b><code>nparams</code>: </b>
	5169	the number of fixed parameters of the function
	5170	(always 0 for C functions).
	5171	</li>
	5172
	5173	<li><b><code>isvararg</code>: </b>
	5174	true if the function is a vararg function
	5175	(always true for C functions).
	5176	</li>
	5177
	5178	</ul>
	5179
	5180
	5181
	5182
	5183	<hr><h3><a name="lua_gethook"><code>lua_gethook</code></a></h3><p>
	5184	<span class="apii">[-0, +0, –]</span>
	5185	<pre>lua_Hook lua_gethook (lua_State *L);</pre>
	5186
	5187	<p>
	5188	Returns the current hook function.
	5189
	5190
	5191
	5192
	5193
	5194	<hr><h3><a name="lua_gethookcount"><code>lua_gethookcount</code></a></h3><p>
	5195	<span class="apii">[-0, +0, –]</span>
	5196	<pre>int lua_gethookcount (lua_State *L);</pre>
	5197
	5198	<p>
	5199	Returns the current hook count.
	5200
	5201
	5202
	5203
	5204
	5205	<hr><h3><a name="lua_gethookmask"><code>lua_gethookmask</code></a></h3><p>
	5206	<span class="apii">[-0, +0, –]</span>
	5207	<pre>int lua_gethookmask (lua_State *L);</pre>
	5208
	5209	<p>
	5210	Returns the current hook mask.
	5211
	5212
	5213
	5214
	5215
	5216	<hr><h3><a name="lua_getinfo"><code>lua_getinfo</code></a></h3><p>
	5217	<span class="apii">[-(0\|1), +(0\|1\|2), <em>e</em>]</span>
	5218	<pre>int lua_getinfo (lua_State L, const char what, lua_Debug *ar);</pre>
	5219
	5220	<p>
	5221	Gets information about a specific function or function invocation.
	5222
	5223
	5224	<p>
	5225	To get information about a function invocation,
	5226	the parameter <code>ar</code> must be a valid activation record that was
	5227	filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or
	5228	given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).
	5229
	5230
	5231	<p>
	5232	To get information about a function you push it onto the stack
	5233	and start the <code>what</code> string with the character '<code>></code>'.
	5234	(In that case,
	5235	<code>lua_getinfo</code> pops the function from the top of the stack.)
	5236	For instance, to know in which line a function <code>f</code> was defined,
	5237	you can write the following code:
	5238
	5239	<pre>
	5240	lua_Debug ar;
	5241	lua_getglobal(L, "f"); /* get global 'f' */
	5242	lua_getinfo(L, ">S", &ar);
	5243	printf("%d\n", ar.linedefined);
	5244	</pre>
	5245
	5246	<p>
	5247	Each character in the string <code>what</code>
	5248	selects some fields of the structure <code>ar</code> to be filled or
	5249	a value to be pushed on the stack:
	5250
	5251	<ul>
	5252
	5253	<li><b>'<code>n</code>': </b> fills in the field <code>name</code> and <code>namewhat</code>;
	5254	</li>
	5255
	5256	<li><b>'<code>S</code>': </b>
	5257	fills in the fields <code>source</code>, <code>short_src</code>,
	5258	<code>linedefined</code>, <code>lastlinedefined</code>, and <code>what</code>;
	5259	</li>
	5260
	5261	<li><b>'<code>l</code>': </b> fills in the field <code>currentline</code>;
	5262	</li>
	5263
	5264	<li><b>'<code>t</code>': </b> fills in the field <code>istailcall</code>;
	5265	</li>
	5266
	5267	<li><b>'<code>u</code>': </b> fills in the fields
	5268	<code>nups</code>, <code>nparams</code>, and <code>isvararg</code>;
	5269	</li>
	5270
	5271	<li><b>'<code>f</code>': </b>
	5272	pushes onto the stack the function that is
	5273	running at the given level;
	5274	</li>
	5275
	5276	<li><b>'<code>L</code>': </b>
	5277	pushes onto the stack a table whose indices are the
	5278	numbers of the lines that are valid on the function.
	5279	(A <em>valid line</em> is a line with some associated code,
	5280	that is, a line where you can put a break point.
	5281	Non-valid lines include empty lines and comments.)
	5282	</li>
	5283
	5284	</ul>
	5285
	5286	<p>
	5287	This function returns 0 on error
	5288	(for instance, an invalid option in <code>what</code>).
	5289
	5290
	5291
	5292
	5293
	5294	<hr><h3><a name="lua_getlocal"><code>lua_getlocal</code></a></h3><p>
	5295	<span class="apii">[-0, +(0\|1), –]</span>
	5296	<pre>const char lua_getlocal (lua_State L, lua_Debug *ar, int n);</pre>
	5297
	5298	<p>
	5299	Gets information about a local variable of
	5300	a given activation record or a given function.
	5301
	5302
	5303	<p>
	5304	In the first case,
	5305	the parameter <code>ar</code> must be a valid activation record that was
	5306	filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or
	5307	given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).
	5308	The index <code>n</code> selects which local variable to inspect;
	5309	see <a href="#pdf-debug.getlocal"><code>debug.getlocal</code></a> for details about variable indices
	5310	and names.
	5311
	5312
	5313	<p>
	5314	<a href="#lua_getlocal"><code>lua_getlocal</code></a> pushes the variable's value onto the stack
	5315	and returns its name.
	5316
	5317
	5318	<p>
	5319	In the second case, <code>ar</code> should be <code>NULL</code> and the function
	5320	to be inspected must be at the top of the stack.
	5321	In this case, only parameters of Lua functions are visible
	5322	(as there is no information about what variables are active)
	5323	and no values are pushed onto the stack.
	5324
	5325
	5326	<p>
	5327	Returns <code>NULL</code> (and pushes nothing)
	5328	when the index is greater than
	5329	the number of active local variables.
	5330
	5331
	5332
	5333
	5334
	5335	<hr><h3><a name="lua_getstack"><code>lua_getstack</code></a></h3><p>
	5336	<span class="apii">[-0, +0, –]</span>
	5337	<pre>int lua_getstack (lua_State L, int level, lua_Debug ar);</pre>
	5338
	5339	<p>
	5340	Gets information about the interpreter runtime stack.
	5341
	5342
	5343	<p>
	5344	This function fills parts of a <a href="#lua_Debug"><code>lua_Debug</code></a> structure with
	5345	an identification of the <em>activation record</em>
	5346	of the function executing at a given level.
	5347	Level 0 is the current running function,
	5348	whereas level <em>n+1</em> is the function that has called level <em>n</em>
	5349	(except for tail calls, which do not count on the stack).
	5350	When there are no errors, <a href="#lua_getstack"><code>lua_getstack</code></a> returns 1;
	5351	when called with a level greater than the stack depth,
	5352	it returns 0.
	5353
	5354
	5355
	5356
	5357
	5358	<hr><h3><a name="lua_getupvalue"><code>lua_getupvalue</code></a></h3><p>
	5359	<span class="apii">[-0, +(0\|1), –]</span>
	5360	<pre>const char lua_getupvalue (lua_State L, int funcindex, int n);</pre>
	5361
	5362	<p>
	5363	Gets information about a closure's upvalue.
	5364	(For Lua functions,
	5365	upvalues are the external local variables that the function uses,
	5366	and that are consequently included in its closure.)
	5367	<a href="#lua_getupvalue"><code>lua_getupvalue</code></a> gets the index <code>n</code> of an upvalue,
	5368	pushes the upvalue's value onto the stack,
	5369	and returns its name.
	5370	<code>funcindex</code> points to the closure in the stack.
	5371	(Upvalues have no particular order,
	5372	as they are active through the whole function.
	5373	So, they are numbered in an arbitrary order.)
	5374
	5375
	5376	<p>
	5377	Returns <code>NULL</code> (and pushes nothing)
	5378	when the index is greater than the number of upvalues.
	5379	For C functions, this function uses the empty string <code>""</code>
	5380	as a name for all upvalues.
	5381
	5382
	5383
	5384
	5385
	5386	<hr><h3><a name="lua_Hook"><code>lua_Hook</code></a></h3>
	5387	<pre>typedef void (lua_Hook) (lua_State L, lua_Debug *ar);</pre>
	5388
	5389	<p>
	5390	Type for debugging hook functions.
	5391
	5392
	5393	<p>
	5394	Whenever a hook is called, its <code>ar</code> argument has its field
	5395	<code>event</code> set to the specific event that triggered the hook.
	5396	Lua identifies these events with the following constants:
	5397	<a name="pdf-LUA_HOOKCALL"><code>LUA_HOOKCALL</code></a>, <a name="pdf-LUA_HOOKRET"><code>LUA_HOOKRET</code></a>,
	5398	<a name="pdf-LUA_HOOKTAILCALL"><code>LUA_HOOKTAILCALL</code></a>, <a name="pdf-LUA_HOOKLINE"><code>LUA_HOOKLINE</code></a>,
	5399	and <a name="pdf-LUA_HOOKCOUNT"><code>LUA_HOOKCOUNT</code></a>.
	5400	Moreover, for line events, the field <code>currentline</code> is also set.
	5401	To get the value of any other field in <code>ar</code>,
	5402	the hook must call <a href="#lua_getinfo"><code>lua_getinfo</code></a>.
	5403
	5404
	5405	<p>
	5406	For call events, <code>event</code> can be <code>LUA_HOOKCALL</code>,
	5407	the normal value, or <code>LUA_HOOKTAILCALL</code>, for a tail call;
	5408	in this case, there will be no corresponding return event.
	5409
	5410
	5411	<p>
	5412	While Lua is running a hook, it disables other calls to hooks.
	5413	Therefore, if a hook calls back Lua to execute a function or a chunk,
	5414	this execution occurs without any calls to hooks.
	5415
	5416
	5417	<p>
	5418	Hook functions cannot have continuations,
	5419	that is, they cannot call <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
	5420	<a href="#lua_pcallk"><code>lua_pcallk</code></a>, or <a href="#lua_callk"><code>lua_callk</code></a> with a non-null <code>k</code>.
	5421
	5422
	5423	<p>
	5424	Hook functions can yield under the following conditions:
	5425	Only count and line events can yield
	5426	and they cannot yield any value;
	5427	to yield a hook function must finish its execution
	5428	calling <a href="#lua_yield"><code>lua_yield</code></a> with <code>nresults</code> equal to zero.
	5429
	5430
	5431
	5432
	5433
	5434	<hr><h3><a name="lua_sethook"><code>lua_sethook</code></a></h3><p>
	5435	<span class="apii">[-0, +0, –]</span>
	5436	<pre>int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);</pre>
	5437
	5438	<p>
	5439	Sets the debugging hook function.
	5440
	5441
	5442	<p>
	5443	Argument <code>f</code> is the hook function.
	5444	<code>mask</code> specifies on which events the hook will be called:
	5445	it is formed by a bitwise or of the constants
	5446	<a name="pdf-LUA_MASKCALL"><code>LUA_MASKCALL</code></a>,
	5447	<a name="pdf-LUA_MASKRET"><code>LUA_MASKRET</code></a>,
	5448	<a name="pdf-LUA_MASKLINE"><code>LUA_MASKLINE</code></a>,
	5449	and <a name="pdf-LUA_MASKCOUNT"><code>LUA_MASKCOUNT</code></a>.
	5450	The <code>count</code> argument is only meaningful when the mask
	5451	includes <code>LUA_MASKCOUNT</code>.
	5452	For each event, the hook is called as explained below:
	5453
	5454	<ul>
	5455
	5456	<li><b>The call hook: </b> is called when the interpreter calls a function.
	5457	The hook is called just after Lua enters the new function,
	5458	before the function gets its arguments.
	5459	</li>
	5460
	5461	<li><b>The return hook: </b> is called when the interpreter returns from a function.
	5462	The hook is called just before Lua leaves the function.
	5463	There is no standard way to access the values
	5464	to be returned by the function.
	5465	</li>
	5466
	5467	<li><b>The line hook: </b> is called when the interpreter is about to
	5468	start the execution of a new line of code,
	5469	or when it jumps back in the code (even to the same line).
	5470	(This event only happens while Lua is executing a Lua function.)
	5471	</li>
	5472
	5473	<li><b>The count hook: </b> is called after the interpreter executes every
	5474	<code>count</code> instructions.
	5475	(This event only happens while Lua is executing a Lua function.)
	5476	</li>
	5477
	5478	</ul>
	5479
	5480	<p>
	5481	A hook is disabled by setting <code>mask</code> to zero.
	5482
	5483
	5484
	5485
	5486
	5487	<hr><h3><a name="lua_setlocal"><code>lua_setlocal</code></a></h3><p>
	5488	<span class="apii">[-(0\|1), +0, –]</span>
	5489	<pre>const char lua_setlocal (lua_State L, lua_Debug *ar, int n);</pre>
	5490
	5491	<p>
	5492	Sets the value of a local variable of a given activation record.
	5493	Parameters <code>ar</code> and <code>n</code> are as in <a href="#lua_getlocal"><code>lua_getlocal</code></a>
	5494	(see <a href="#lua_getlocal"><code>lua_getlocal</code></a>).
	5495	<a href="#lua_setlocal"><code>lua_setlocal</code></a> assigns the value at the top of the stack
	5496	to the variable and returns its name.
	5497	It also pops the value from the stack.
	5498
	5499
	5500	<p>
	5501	Returns <code>NULL</code> (and pops nothing)
	5502	when the index is greater than
	5503	the number of active local variables.
	5504
	5505
	5506
	5507
	5508
	5509	<hr><h3><a name="lua_setupvalue"><code>lua_setupvalue</code></a></h3><p>
	5510	<span class="apii">[-(0\|1), +0, –]</span>
	5511	<pre>const char lua_setupvalue (lua_State L, int funcindex, int n);</pre>
	5512
	5513	<p>
	5514	Sets the value of a closure's upvalue.
	5515	It assigns the value at the top of the stack
	5516	to the upvalue and returns its name.
	5517	It also pops the value from the stack.
	5518	Parameters <code>funcindex</code> and <code>n</code> are as in the <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>
	5519	(see <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>).
	5520
	5521
	5522	<p>
	5523	Returns <code>NULL</code> (and pops nothing)
	5524	when the index is greater than the number of upvalues.
	5525
	5526
	5527
	5528
	5529
	5530	<hr><h3><a name="lua_upvalueid"><code>lua_upvalueid</code></a></h3><p>
	5531	<span class="apii">[-0, +0, –]</span>
	5532	<pre>void lua_upvalueid (lua_State L, int funcindex, int n);</pre>
	5533
	5534	<p>
	5535	Returns an unique identifier for the upvalue numbered <code>n</code>
	5536	from the closure at index <code>funcindex</code>.
	5537	Parameters <code>funcindex</code> and <code>n</code> are as in the <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>
	5538	(see <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>)
	5539	(but <code>n</code> cannot be greater than the number of upvalues).
	5540
	5541
	5542	<p>
	5543	These unique identifiers allow a program to check whether different
	5544	closures share upvalues.
	5545	Lua closures that share an upvalue
	5546	(that is, that access a same external local variable)
	5547	will return identical ids for those upvalue indices.
	5548
	5549
	5550
	5551
	5552
	5553	<hr><h3><a name="lua_upvaluejoin"><code>lua_upvaluejoin</code></a></h3><p>
	5554	<span class="apii">[-0, +0, –]</span>
	5555	<pre>void lua_upvaluejoin (lua_State *L, int funcindex1, int n1,
	5556	int funcindex2, int n2);</pre>
	5557
	5558	<p>
	5559	Make the <code>n1</code>-th upvalue of the Lua closure at index <code>funcindex1</code>
	5560	refer to the <code>n2</code>-th upvalue of the Lua closure at index <code>funcindex2</code>.
	5561
	5562
	5563
	5564
	5565
	5566
	5567
	5568	<h1>5 – <a name="5">The Auxiliary Library</a></h1>
	5569
	5570	<p>
	5571
	5572	The <em>auxiliary library</em> provides several convenient functions
	5573	to interface C with Lua.
	5574	While the basic API provides the primitive functions for all
	5575	interactions between C and Lua,
	5576	the auxiliary library provides higher-level functions for some
	5577	common tasks.
	5578
	5579
	5580	<p>
	5581	All functions and types from the auxiliary library
	5582	are defined in header file <code>lauxlib.h</code> and
	5583	have a prefix <code>luaL_</code>.
	5584
	5585
	5586	<p>
	5587	All functions in the auxiliary library are built on
	5588	top of the basic API,
	5589	and so they provide nothing that cannot be done with that API.
	5590	Nevertheless, the use of the auxiliary library ensures
	5591	more consistency to your code.
	5592
	5593
	5594	<p>
	5595	Several functions in the auxiliary library use internally some
	5596	extra stack slots.
	5597	When a function in the auxiliary library uses less than five slots,
	5598	it does not check the stack size;
	5599	it simply assumes that there are enough slots.
	5600
	5601
	5602	<p>
	5603	Several functions in the auxiliary library are used to
	5604	check C function arguments.
	5605	Because the error message is formatted for arguments
	5606	(e.g., "<code>bad argument #1</code>"),
	5607	you should not use these functions for other stack values.
	5608
	5609
	5610	<p>
	5611	Functions called <code>luaL_check*</code>
	5612	always throw an error if the check is not satisfied.
	5613
	5614
	5615
	5616	<h2>5.1 – <a name="5.1">Functions and Types</a></h2>
	5617
	5618	<p>
	5619	Here we list all functions and types from the auxiliary library
	5620	in alphabetical order.
	5621
	5622
	5623
	5624	<hr><h3><a name="luaL_addchar"><code>luaL_addchar</code></a></h3><p>
	5625	<span class="apii">[-?, +?, <em>e</em>]</span>
	5626	<pre>void luaL_addchar (luaL_Buffer *B, char c);</pre>
	5627
	5628	<p>
	5629	Adds the byte <code>c</code> to the buffer <code>B</code>
	5630	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
	5631
	5632
	5633
	5634
	5635
	5636	<hr><h3><a name="luaL_addlstring"><code>luaL_addlstring</code></a></h3><p>
	5637	<span class="apii">[-?, +?, <em>e</em>]</span>
	5638	<pre>void luaL_addlstring (luaL_Buffer B, const char s, size_t l);</pre>
	5639
	5640	<p>
	5641	Adds the string pointed to by <code>s</code> with length <code>l</code> to
	5642	the buffer <code>B</code>
	5643	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
	5644	The string can contain embedded zeros.
	5645
	5646
	5647
	5648
	5649
	5650	<hr><h3><a name="luaL_addsize"><code>luaL_addsize</code></a></h3><p>
	5651	<span class="apii">[-?, +?, <em>e</em>]</span>
	5652	<pre>void luaL_addsize (luaL_Buffer *B, size_t n);</pre>
	5653
	5654	<p>
	5655	Adds to the buffer <code>B</code> (see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>)
	5656	a string of length <code>n</code> previously copied to the
	5657	buffer area (see <a href="#luaL_prepbuffer"><code>luaL_prepbuffer</code></a>).
	5658
	5659
	5660
	5661
	5662
	5663	<hr><h3><a name="luaL_addstring"><code>luaL_addstring</code></a></h3><p>
	5664	<span class="apii">[-?, +?, <em>e</em>]</span>
	5665	<pre>void luaL_addstring (luaL_Buffer B, const char s);</pre>
	5666
	5667	<p>
	5668	Adds the zero-terminated string pointed to by <code>s</code>
	5669	to the buffer <code>B</code>
	5670	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
	5671	The string cannot contain embedded zeros.
	5672
	5673
	5674
	5675
	5676
	5677	<hr><h3><a name="luaL_addvalue"><code>luaL_addvalue</code></a></h3><p>
	5678	<span class="apii">[-1, +?, <em>e</em>]</span>
	5679	<pre>void luaL_addvalue (luaL_Buffer *B);</pre>
	5680
	5681	<p>
	5682	Adds the value at the top of the stack
	5683	to the buffer <code>B</code>
	5684	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
	5685	Pops the value.
	5686
	5687
	5688	<p>
	5689	This is the only function on string buffers that can (and must)
	5690	be called with an extra element on the stack,
	5691	which is the value to be added to the buffer.
	5692
	5693
	5694
	5695
	5696
	5697	<hr><h3><a name="luaL_argcheck"><code>luaL_argcheck</code></a></h3><p>
	5698	<span class="apii">[-0, +0, <em>v</em>]</span>
	5699	<pre>void luaL_argcheck (lua_State *L,
	5700	int cond,
	5701	int arg,
	5702	const char *extramsg);</pre>
	5703
	5704	<p>
	5705	Checks whether <code>cond</code> is true.
	5706	If not, raises an error with a standard message.
	5707
	5708
	5709
	5710
	5711
	5712	<hr><h3><a name="luaL_argerror"><code>luaL_argerror</code></a></h3><p>
	5713	<span class="apii">[-0, +0, <em>v</em>]</span>
	5714	<pre>int luaL_argerror (lua_State L, int arg, const char extramsg);</pre>
	5715
	5716	<p>
	5717	Raises an error with a standard message
	5718	that includes <code>extramsg</code> as a comment.
	5719
	5720
	5721	<p>
	5722	This function never returns,
	5723	but it is an idiom to use it in C functions
	5724	as <code>return luaL_argerror(<em>args</em>)</code>.
	5725
	5726
	5727
	5728
	5729
	5730	<hr><h3><a name="luaL_Buffer"><code>luaL_Buffer</code></a></h3>
	5731	<pre>typedef struct luaL_Buffer luaL_Buffer;</pre>
	5732
	5733	<p>
	5734	Type for a <em>string buffer</em>.
	5735
	5736
	5737	<p>
	5738	A string buffer allows C code to build Lua strings piecemeal.
	5739	Its pattern of use is as follows:
	5740
	5741	<ul>
	5742
	5743	<li>First declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>
	5744
	5745	<li>Then initialize it with a call <code>luaL_buffinit(L, &b)</code>.</li>
	5746
	5747	<li>
	5748	Then add string pieces to the buffer calling any of
	5749	the <code>luaL_add*</code> functions.
	5750	</li>
	5751
	5752	<li>
	5753	Finish by calling <code>luaL_pushresult(&b)</code>.
	5754	This call leaves the final string on the top of the stack.
	5755	</li>
	5756
	5757	</ul>
	5758
	5759	<p>
	5760	If you know beforehand the total size of the resulting string,
	5761	you can use the buffer like this:
	5762
	5763	<ul>
	5764
	5765	<li>First declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>
	5766
	5767	<li>Then initialize it and preallocate a space of
	5768	size <code>sz</code> with a call <code>luaL_buffinitsize(L, &b, sz)</code>.</li>
	5769
	5770	<li>Then copy the string into that space.</li>
	5771
	5772	<li>
	5773	Finish by calling <code>luaL_pushresultsize(&b, sz)</code>,
	5774	where <code>sz</code> is the total size of the resulting string
	5775	copied into that space.
	5776	</li>
	5777
	5778	</ul>
	5779
	5780	<p>
	5781	During its normal operation,
	5782	a string buffer uses a variable number of stack slots.
	5783	So, while using a buffer, you cannot assume that you know where
	5784	the top of the stack is.
	5785	You can use the stack between successive calls to buffer operations
	5786	as long as that use is balanced;
	5787	that is,
	5788	when you call a buffer operation,
	5789	the stack is at the same level
	5790	it was immediately after the previous buffer operation.
	5791	(The only exception to this rule is <a href="#luaL_addvalue"><code>luaL_addvalue</code></a>.)
	5792	After calling <a href="#luaL_pushresult"><code>luaL_pushresult</code></a> the stack is back to its
	5793	level when the buffer was initialized,
	5794	plus the final string on its top.
	5795
	5796
	5797
	5798
	5799
	5800	<hr><h3><a name="luaL_buffinit"><code>luaL_buffinit</code></a></h3><p>
	5801	<span class="apii">[-0, +0, –]</span>
	5802	<pre>void luaL_buffinit (lua_State L, luaL_Buffer B);</pre>
	5803
	5804	<p>
	5805	Initializes a buffer <code>B</code>.
	5806	This function does not allocate any space;
	5807	the buffer must be declared as a variable
	5808	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
	5809
	5810
	5811
	5812
	5813
	5814	<hr><h3><a name="luaL_buffinitsize"><code>luaL_buffinitsize</code></a></h3><p>
	5815	<span class="apii">[-?, +?, <em>e</em>]</span>
	5816	<pre>char luaL_buffinitsize (lua_State L, luaL_Buffer *B, size_t sz);</pre>
	5817
	5818	<p>
	5819	Equivalent to the sequence
	5820	<a href="#luaL_buffinit"><code>luaL_buffinit</code></a>, <a href="#luaL_prepbuffsize"><code>luaL_prepbuffsize</code></a>.
	5821
	5822
	5823
	5824
	5825
	5826	<hr><h3><a name="luaL_callmeta"><code>luaL_callmeta</code></a></h3><p>
	5827	<span class="apii">[-0, +(0\|1), <em>e</em>]</span>
	5828	<pre>int luaL_callmeta (lua_State L, int obj, const char e);</pre>
	5829
	5830	<p>
	5831	Calls a metamethod.
	5832
	5833
	5834	<p>
	5835	If the object at index <code>obj</code> has a metatable and this
	5836	metatable has a field <code>e</code>,
	5837	this function calls this field passing the object as its only argument.
	5838	In this case this function returns true and pushes onto the
	5839	stack the value returned by the call.
	5840	If there is no metatable or no metamethod,
	5841	this function returns false (without pushing any value on the stack).
	5842
	5843
	5844
	5845
	5846
	5847	<hr><h3><a name="luaL_checkany"><code>luaL_checkany</code></a></h3><p>
	5848	<span class="apii">[-0, +0, <em>v</em>]</span>
	5849	<pre>void luaL_checkany (lua_State *L, int arg);</pre>
	5850
	5851	<p>
	5852	Checks whether the function has an argument
	5853	of any type (including <b>nil</b>) at position <code>arg</code>.
	5854
	5855
	5856
	5857
	5858
	5859	<hr><h3><a name="luaL_checkint"><code>luaL_checkint</code></a></h3><p>
	5860	<span class="apii">[-0, +0, <em>v</em>]</span>
	5861	<pre>int luaL_checkint (lua_State *L, int arg);</pre>
	5862
	5863	<p>
	5864	Checks whether the function argument <code>arg</code> is a number
	5865	and returns this number cast to an <code>int</code>.
	5866
	5867
	5868
	5869
	5870
	5871	<hr><h3><a name="luaL_checkinteger"><code>luaL_checkinteger</code></a></h3><p>
	5872	<span class="apii">[-0, +0, <em>v</em>]</span>
	5873	<pre>lua_Integer luaL_checkinteger (lua_State *L, int arg);</pre>
	5874
	5875	<p>
	5876	Checks whether the function argument <code>arg</code> is a number
	5877	and returns this number cast to a <a href="#lua_Integer"><code>lua_Integer</code></a>.
	5878
	5879
	5880
	5881
	5882
	5883	<hr><h3><a name="luaL_checklong"><code>luaL_checklong</code></a></h3><p>
	5884	<span class="apii">[-0, +0, <em>v</em>]</span>
	5885	<pre>long luaL_checklong (lua_State *L, int arg);</pre>
	5886
	5887	<p>
	5888	Checks whether the function argument <code>arg</code> is a number
	5889	and returns this number cast to a <code>long</code>.
	5890
	5891
	5892
	5893
	5894
	5895	<hr><h3><a name="luaL_checklstring"><code>luaL_checklstring</code></a></h3><p>
	5896	<span class="apii">[-0, +0, <em>v</em>]</span>
	5897	<pre>const char luaL_checklstring (lua_State L, int arg, size_t *l);</pre>
	5898
	5899	<p>
	5900	Checks whether the function argument <code>arg</code> is a string
	5901	and returns this string;
	5902	if <code>l</code> is not <code>NULL</code> fills <code>*l</code>
	5903	with the string's length.
	5904
	5905
	5906	<p>
	5907	This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result,
	5908	so all conversions and caveats of that function apply here.
	5909
	5910
	5911
	5912
	5913
	5914	<hr><h3><a name="luaL_checknumber"><code>luaL_checknumber</code></a></h3><p>
	5915	<span class="apii">[-0, +0, <em>v</em>]</span>
	5916	<pre>lua_Number luaL_checknumber (lua_State *L, int arg);</pre>
	5917
	5918	<p>
	5919	Checks whether the function argument <code>arg</code> is a number
	5920	and returns this number.
	5921
	5922
	5923
	5924
	5925
	5926	<hr><h3><a name="luaL_checkoption"><code>luaL_checkoption</code></a></h3><p>
	5927	<span class="apii">[-0, +0, <em>v</em>]</span>
	5928	<pre>int luaL_checkoption (lua_State *L,
	5929	int arg,
	5930	const char *def,
	5931	const char *const lst[]);</pre>
	5932
	5933	<p>
	5934	Checks whether the function argument <code>arg</code> is a string and
	5935	searches for this string in the array <code>lst</code>
	5936	(which must be NULL-terminated).
	5937	Returns the index in the array where the string was found.
	5938	Raises an error if the argument is not a string or
	5939	if the string cannot be found.
	5940
	5941
	5942	<p>
	5943	If <code>def</code> is not <code>NULL</code>,
	5944	the function uses <code>def</code> as a default value when
	5945	there is no argument <code>arg</code> or when this argument is <b>nil</b>.
	5946
	5947
	5948	<p>
	5949	This is a useful function for mapping strings to C enums.
	5950	(The usual convention in Lua libraries is
	5951	to use strings instead of numbers to select options.)
	5952
	5953
	5954
	5955
	5956
	5957	<hr><h3><a name="luaL_checkstack"><code>luaL_checkstack</code></a></h3><p>
	5958	<span class="apii">[-0, +0, <em>v</em>]</span>
	5959	<pre>void luaL_checkstack (lua_State L, int sz, const char msg);</pre>
	5960
	5961	<p>
	5962	Grows the stack size to <code>top + sz</code> elements,
	5963	raising an error if the stack cannot grow to that size.
	5964	<code>msg</code> is an additional text to go into the error message
	5965	(or <code>NULL</code> for no additional text).
	5966
	5967
	5968
	5969
	5970
	5971	<hr><h3><a name="luaL_checkstring"><code>luaL_checkstring</code></a></h3><p>
	5972	<span class="apii">[-0, +0, <em>v</em>]</span>
	5973	<pre>const char luaL_checkstring (lua_State L, int arg);</pre>
	5974
	5975	<p>
	5976	Checks whether the function argument <code>arg</code> is a string
	5977	and returns this string.
	5978
	5979
	5980	<p>
	5981	This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result,
	5982	so all conversions and caveats of that function apply here.
	5983
	5984
	5985
	5986
	5987
	5988	<hr><h3><a name="luaL_checktype"><code>luaL_checktype</code></a></h3><p>
	5989	<span class="apii">[-0, +0, <em>v</em>]</span>
	5990	<pre>void luaL_checktype (lua_State *L, int arg, int t);</pre>
	5991
	5992	<p>
	5993	Checks whether the function argument <code>arg</code> has type <code>t</code>.
	5994	See <a href="#lua_type"><code>lua_type</code></a> for the encoding of types for <code>t</code>.
	5995
	5996
	5997
	5998
	5999
	6000	<hr><h3><a name="luaL_checkudata"><code>luaL_checkudata</code></a></h3><p>
	6001	<span class="apii">[-0, +0, <em>v</em>]</span>
	6002	<pre>void luaL_checkudata (lua_State L, int arg, const char *tname);</pre>
	6003
	6004	<p>
	6005	Checks whether the function argument <code>arg</code> is a userdata
	6006	of the type <code>tname</code> (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>) and
	6007	returns the userdata address (see <a href="#lua_touserdata"><code>lua_touserdata</code></a>).
	6008
	6009
	6010
	6011
	6012
	6013	<hr><h3><a name="luaL_checkunsigned"><code>luaL_checkunsigned</code></a></h3><p>
	6014	<span class="apii">[-0, +0, <em>v</em>]</span>
	6015	<pre>lua_Unsigned luaL_checkunsigned (lua_State *L, int arg);</pre>
	6016
	6017	<p>
	6018	Checks whether the function argument <code>arg</code> is a number
	6019	and returns this number cast to a <a href="#lua_Unsigned"><code>lua_Unsigned</code></a>.
	6020
	6021
	6022
	6023
	6024
	6025	<hr><h3><a name="luaL_checkversion"><code>luaL_checkversion</code></a></h3><p>
	6026	<span class="apii">[-0, +0, –]</span>
	6027	<pre>void luaL_checkversion (lua_State *L);</pre>
	6028
	6029	<p>
	6030	Checks whether the core running the call,
	6031	the core that created the Lua state,
	6032	and the code making the call are all using the same version of Lua.
	6033	Also checks whether the core running the call
	6034	and the core that created the Lua state
	6035	are using the same address space.
	6036
	6037
	6038
	6039
	6040
	6041	<hr><h3><a name="luaL_dofile"><code>luaL_dofile</code></a></h3><p>
	6042	<span class="apii">[-0, +?, <em>e</em>]</span>
	6043	<pre>int luaL_dofile (lua_State L, const char filename);</pre>
	6044
	6045	<p>
	6046	Loads and runs the given file.
	6047	It is defined as the following macro:
	6048
	6049	<pre>
	6050	(luaL_loadfile(L, filename) \|\| lua_pcall(L, 0, LUA_MULTRET, 0))
	6051	</pre><p>
	6052	It returns false if there are no errors
	6053	or true in case of errors.
	6054
	6055
	6056
	6057
	6058
	6059	<hr><h3><a name="luaL_dostring"><code>luaL_dostring</code></a></h3><p>
	6060	<span class="apii">[-0, +?, –]</span>
	6061	<pre>int luaL_dostring (lua_State L, const char str);</pre>
	6062
	6063	<p>
	6064	Loads and runs the given string.
	6065	It is defined as the following macro:
	6066
	6067	<pre>
	6068	(luaL_loadstring(L, str) \|\| lua_pcall(L, 0, LUA_MULTRET, 0))
	6069	</pre><p>
	6070	It returns false if there are no errors
	6071	or true in case of errors.
	6072
	6073
	6074
	6075
	6076
	6077	<hr><h3><a name="luaL_error"><code>luaL_error</code></a></h3><p>
	6078	<span class="apii">[-0, +0, <em>v</em>]</span>
	6079	<pre>int luaL_error (lua_State L, const char fmt, ...);</pre>
	6080
	6081	<p>
	6082	Raises an error.
	6083	The error message format is given by <code>fmt</code>
	6084	plus any extra arguments,
	6085	following the same rules of <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>.
	6086	It also adds at the beginning of the message the file name and
	6087	the line number where the error occurred,
	6088	if this information is available.
	6089
	6090
	6091	<p>
	6092	This function never returns,
	6093	but it is an idiom to use it in C functions
	6094	as <code>return luaL_error(<em>args</em>)</code>.
	6095
	6096
	6097
	6098
	6099
	6100	<hr><h3><a name="luaL_execresult"><code>luaL_execresult</code></a></h3><p>
	6101	<span class="apii">[-0, +3, <em>e</em>]</span>
	6102	<pre>int luaL_execresult (lua_State *L, int stat);</pre>
	6103
	6104	<p>
	6105	This function produces the return values for
	6106	process-related functions in the standard library
	6107	(<a href="#pdf-os.execute"><code>os.execute</code></a> and <a href="#pdf-io.close"><code>io.close</code></a>).
	6108
	6109
	6110
	6111
	6112
	6113	<hr><h3><a name="luaL_fileresult"><code>luaL_fileresult</code></a></h3><p>
	6114	<span class="apii">[-0, +(1\|3), <em>e</em>]</span>
	6115	<pre>int luaL_fileresult (lua_State L, int stat, const char fname);</pre>
	6116
	6117	<p>
	6118	This function produces the return values for
	6119	file-related functions in the standard library
	6120	(<a href="#pdf-io.open"><code>io.open</code></a>, <a href="#pdf-os.rename"><code>os.rename</code></a>, <a href="#pdf-file:seek"><code>file:seek</code></a>, etc.).
	6121
	6122
	6123
	6124
	6125
	6126	<hr><h3><a name="luaL_getmetafield"><code>luaL_getmetafield</code></a></h3><p>
	6127	<span class="apii">[-0, +(0\|1), <em>e</em>]</span>
	6128	<pre>int luaL_getmetafield (lua_State L, int obj, const char e);</pre>
	6129
	6130	<p>
	6131	Pushes onto the stack the field <code>e</code> from the metatable
	6132	of the object at index <code>obj</code>.
	6133	If the object does not have a metatable,
	6134	or if the metatable does not have this field,
	6135	returns false and pushes nothing.
	6136
	6137
	6138
	6139
	6140
	6141	<hr><h3><a name="luaL_getmetatable"><code>luaL_getmetatable</code></a></h3><p>
	6142	<span class="apii">[-0, +1, –]</span>
	6143	<pre>void luaL_getmetatable (lua_State L, const char tname);</pre>
	6144
	6145	<p>
	6146	Pushes onto the stack the metatable associated with name <code>tname</code>
	6147	in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
	6148
	6149
	6150
	6151
	6152
	6153	<hr><h3><a name="luaL_getsubtable"><code>luaL_getsubtable</code></a></h3><p>
	6154	<span class="apii">[-0, +1, <em>e</em>]</span>
	6155	<pre>int luaL_getsubtable (lua_State L, int idx, const char fname);</pre>
	6156
	6157	<p>
	6158	Ensures that the value <code>t[fname]</code>,
	6159	where <code>t</code> is the value at index <code>idx</code>,
	6160	is a table,
	6161	and pushes that table onto the stack.
	6162	Returns true if it finds a previous table there
	6163	and false if it creates a new table.
	6164
	6165
	6166
	6167
	6168
	6169	<hr><h3><a name="luaL_gsub"><code>luaL_gsub</code></a></h3><p>
	6170	<span class="apii">[-0, +1, <em>e</em>]</span>
	6171	<pre>const char luaL_gsub (lua_State L,
	6172	const char *s,
	6173	const char *p,
	6174	const char *r);</pre>
	6175
	6176	<p>
	6177	Creates a copy of string <code>s</code> by replacing
	6178	any occurrence of the string <code>p</code>
	6179	with the string <code>r</code>.
	6180	Pushes the resulting string on the stack and returns it.
	6181
	6182
	6183
	6184
	6185
	6186	<hr><h3><a name="luaL_len"><code>luaL_len</code></a></h3><p>
	6187	<span class="apii">[-0, +0, <em>e</em>]</span>
	6188	<pre>int luaL_len (lua_State *L, int index);</pre>
	6189
	6190	<p>
	6191	Returns the "length" of the value at the given index
	6192	as a number;
	6193	it is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.6">§3.4.6</a>).
	6194	Raises an error if the result of the operation is not a number.
	6195	(This case only can happen through metamethods.)
	6196
	6197
	6198
	6199
	6200
	6201	<hr><h3><a name="luaL_loadbuffer"><code>luaL_loadbuffer</code></a></h3><p>
	6202	<span class="apii">[-0, +1, –]</span>
	6203	<pre>int luaL_loadbuffer (lua_State *L,
	6204	const char *buff,
	6205	size_t sz,
	6206	const char *name);</pre>
	6207
	6208	<p>
	6209	Equivalent to <a href="#luaL_loadbufferx"><code>luaL_loadbufferx</code></a> with <code>mode</code> equal to <code>NULL</code>.
	6210
	6211
	6212
	6213
	6214
	6215	<hr><h3><a name="luaL_loadbufferx"><code>luaL_loadbufferx</code></a></h3><p>
	6216	<span class="apii">[-0, +1, –]</span>
	6217	<pre>int luaL_loadbufferx (lua_State *L,
	6218	const char *buff,
	6219	size_t sz,
	6220	const char *name,
	6221	const char *mode);</pre>
	6222
	6223	<p>
	6224	Loads a buffer as a Lua chunk.
	6225	This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the
	6226	buffer pointed to by <code>buff</code> with size <code>sz</code>.
	6227
	6228
	6229	<p>
	6230	This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>.
	6231	<code>name</code> is the chunk name,
	6232	used for debug information and error messages.
	6233	The string <code>mode</code> works as in function <a href="#lua_load"><code>lua_load</code></a>.
	6234
	6235
	6236
	6237
	6238
	6239	<hr><h3><a name="luaL_loadfile"><code>luaL_loadfile</code></a></h3><p>
	6240	<span class="apii">[-0, +1, <em>e</em>]</span>
	6241	<pre>int luaL_loadfile (lua_State L, const char filename);</pre>
	6242
	6243	<p>
	6244	Equivalent to <a href="#luaL_loadfilex"><code>luaL_loadfilex</code></a> with <code>mode</code> equal to <code>NULL</code>.
	6245
	6246
	6247
	6248
	6249
	6250	<hr><h3><a name="luaL_loadfilex"><code>luaL_loadfilex</code></a></h3><p>
	6251	<span class="apii">[-0, +1, <em>e</em>]</span>
	6252	<pre>int luaL_loadfilex (lua_State L, const char filename,
	6253	const char *mode);</pre>
	6254
	6255	<p>
	6256	Loads a file as a Lua chunk.
	6257	This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the file
	6258	named <code>filename</code>.
	6259	If <code>filename</code> is <code>NULL</code>,
	6260	then it loads from the standard input.
	6261	The first line in the file is ignored if it starts with a <code>#</code>.
	6262
	6263
	6264	<p>
	6265	The string <code>mode</code> works as in function <a href="#lua_load"><code>lua_load</code></a>.
	6266
	6267
	6268	<p>
	6269	This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>,
	6270	but it has an extra error code <a name="pdf-LUA_ERRFILE"><code>LUA_ERRFILE</code></a>
	6271	if it cannot open/read the file or the file has a wrong mode.
	6272
	6273
	6274	<p>
	6275	As <a href="#lua_load"><code>lua_load</code></a>, this function only loads the chunk;
	6276	it does not run it.
	6277
	6278
	6279
	6280
	6281
	6282	<hr><h3><a name="luaL_loadstring"><code>luaL_loadstring</code></a></h3><p>
	6283	<span class="apii">[-0, +1, –]</span>
	6284	<pre>int luaL_loadstring (lua_State L, const char s);</pre>
	6285
	6286	<p>
	6287	Loads a string as a Lua chunk.
	6288	This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in
	6289	the zero-terminated string <code>s</code>.
	6290
	6291
	6292	<p>
	6293	This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>.
	6294
	6295
	6296	<p>
	6297	Also as <a href="#lua_load"><code>lua_load</code></a>, this function only loads the chunk;
	6298	it does not run it.
	6299
	6300
	6301
	6302
	6303
	6304	<hr><h3><a name="luaL_newlib"><code>luaL_newlib</code></a></h3><p>
	6305	<span class="apii">[-0, +1, <em>e</em>]</span>
	6306	<pre>void luaL_newlib (lua_State L, const luaL_Reg l);</pre>
	6307
	6308	<p>
	6309	Creates a new table and registers there
	6310	the functions in list <code>l</code>.
	6311	It is implemented as the following macro:
	6312
	6313	<pre>
	6314	(luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
	6315	</pre>
	6316
	6317
	6318
	6319
	6320	<hr><h3><a name="luaL_newlibtable"><code>luaL_newlibtable</code></a></h3><p>
	6321	<span class="apii">[-0, +1, <em>e</em>]</span>
	6322	<pre>void luaL_newlibtable (lua_State *L, const luaL_Reg l[]);</pre>
	6323
	6324	<p>
	6325	Creates a new table with a size optimized
	6326	to store all entries in the array <code>l</code>
	6327	(but does not actually store them).
	6328	It is intended to be used in conjunction with <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a>
	6329	(see <a href="#luaL_newlib"><code>luaL_newlib</code></a>).
	6330
	6331
	6332	<p>
	6333	It is implemented as a macro.
	6334	The array <code>l</code> must be the actual array,
	6335	not a pointer to it.
	6336
	6337
	6338
	6339
	6340
	6341	<hr><h3><a name="luaL_newmetatable"><code>luaL_newmetatable</code></a></h3><p>
	6342	<span class="apii">[-0, +1, <em>e</em>]</span>
	6343	<pre>int luaL_newmetatable (lua_State L, const char tname);</pre>
	6344
	6345	<p>
	6346	If the registry already has the key <code>tname</code>,
	6347	returns 0.
	6348	Otherwise,
	6349	creates a new table to be used as a metatable for userdata,
	6350	adds it to the registry with key <code>tname</code>,
	6351	and returns 1.
	6352
	6353
	6354	<p>
	6355	In both cases pushes onto the stack the final value associated
	6356	with <code>tname</code> in the registry.
	6357
	6358
	6359
	6360
	6361
	6362	<hr><h3><a name="luaL_newstate"><code>luaL_newstate</code></a></h3><p>
	6363	<span class="apii">[-0, +0, –]</span>
	6364	<pre>lua_State *luaL_newstate (void);</pre>
	6365
	6366	<p>
	6367	Creates a new Lua state.
	6368	It calls <a href="#lua_newstate"><code>lua_newstate</code></a> with an
	6369	allocator based on the standard C <code>realloc</code> function
	6370	and then sets a panic function (see <a href="#4.6">§4.6</a>) that prints
	6371	an error message to the standard error output in case of fatal
	6372	errors.
	6373
	6374
	6375	<p>
	6376	Returns the new state,
	6377	or <code>NULL</code> if there is a memory allocation error.
	6378
	6379
	6380
	6381
	6382
	6383	<hr><h3><a name="luaL_openlibs"><code>luaL_openlibs</code></a></h3><p>
	6384	<span class="apii">[-0, +0, <em>e</em>]</span>
	6385	<pre>void luaL_openlibs (lua_State *L);</pre>
	6386
	6387	<p>
	6388	Opens all standard Lua libraries into the given state.
	6389
	6390
	6391
	6392
	6393
	6394	<hr><h3><a name="luaL_optint"><code>luaL_optint</code></a></h3><p>
	6395	<span class="apii">[-0, +0, <em>v</em>]</span>
	6396	<pre>int luaL_optint (lua_State *L, int arg, int d);</pre>
	6397
	6398	<p>
	6399	If the function argument <code>arg</code> is a number,
	6400	returns this number cast to an <code>int</code>.
	6401	If this argument is absent or is <b>nil</b>,
	6402	returns <code>d</code>.
	6403	Otherwise, raises an error.
	6404
	6405
	6406
	6407
	6408
	6409	<hr><h3><a name="luaL_optinteger"><code>luaL_optinteger</code></a></h3><p>
	6410	<span class="apii">[-0, +0, <em>v</em>]</span>
	6411	<pre>lua_Integer luaL_optinteger (lua_State *L,
	6412	int arg,
	6413	lua_Integer d);</pre>
	6414
	6415	<p>
	6416	If the function argument <code>arg</code> is a number,
	6417	returns this number cast to a <a href="#lua_Integer"><code>lua_Integer</code></a>.
	6418	If this argument is absent or is <b>nil</b>,
	6419	returns <code>d</code>.
	6420	Otherwise, raises an error.
	6421
	6422
	6423
	6424
	6425
	6426	<hr><h3><a name="luaL_optlong"><code>luaL_optlong</code></a></h3><p>
	6427	<span class="apii">[-0, +0, <em>v</em>]</span>
	6428	<pre>long luaL_optlong (lua_State *L, int arg, long d);</pre>
	6429
	6430	<p>
	6431	If the function argument <code>arg</code> is a number,
	6432	returns this number cast to a <code>long</code>.
	6433	If this argument is absent or is <b>nil</b>,
	6434	returns <code>d</code>.
	6435	Otherwise, raises an error.
	6436
	6437
	6438
	6439
	6440
	6441	<hr><h3><a name="luaL_optlstring"><code>luaL_optlstring</code></a></h3><p>
	6442	<span class="apii">[-0, +0, <em>v</em>]</span>
	6443	<pre>const char luaL_optlstring (lua_State L,
	6444	int arg,
	6445	const char *d,
	6446	size_t *l);</pre>
	6447
	6448	<p>
	6449	If the function argument <code>arg</code> is a string,
	6450	returns this string.
	6451	If this argument is absent or is <b>nil</b>,
	6452	returns <code>d</code>.
	6453	Otherwise, raises an error.
	6454
	6455
	6456	<p>
	6457	If <code>l</code> is not <code>NULL</code>,
	6458	fills the position <code>*l</code> with the result's length.
	6459
	6460
	6461
	6462
	6463
	6464	<hr><h3><a name="luaL_optnumber"><code>luaL_optnumber</code></a></h3><p>
	6465	<span class="apii">[-0, +0, <em>v</em>]</span>
	6466	<pre>lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number d);</pre>
	6467
	6468	<p>
	6469	If the function argument <code>arg</code> is a number,
	6470	returns this number.
	6471	If this argument is absent or is <b>nil</b>,
	6472	returns <code>d</code>.
	6473	Otherwise, raises an error.
	6474
	6475
	6476
	6477
	6478
	6479	<hr><h3><a name="luaL_optstring"><code>luaL_optstring</code></a></h3><p>
	6480	<span class="apii">[-0, +0, <em>v</em>]</span>
	6481	<pre>const char luaL_optstring (lua_State L,
	6482	int arg,
	6483	const char *d);</pre>
	6484
	6485	<p>
	6486	If the function argument <code>arg</code> is a string,
	6487	returns this string.
	6488	If this argument is absent or is <b>nil</b>,
	6489	returns <code>d</code>.
	6490	Otherwise, raises an error.
	6491
	6492
	6493
	6494
	6495
	6496	<hr><h3><a name="luaL_optunsigned"><code>luaL_optunsigned</code></a></h3><p>
	6497	<span class="apii">[-0, +0, <em>v</em>]</span>
	6498	<pre>lua_Unsigned luaL_optunsigned (lua_State *L,
	6499	int arg,
	6500	lua_Unsigned u);</pre>
	6501
	6502	<p>
	6503	If the function argument <code>arg</code> is a number,
	6504	returns this number cast to a <a href="#lua_Unsigned"><code>lua_Unsigned</code></a>.
	6505	If this argument is absent or is <b>nil</b>,
	6506	returns <code>u</code>.
	6507	Otherwise, raises an error.
	6508
	6509
	6510
	6511
	6512
	6513	<hr><h3><a name="luaL_prepbuffer"><code>luaL_prepbuffer</code></a></h3><p>
	6514	<span class="apii">[-?, +?, <em>e</em>]</span>
	6515	<pre>char luaL_prepbuffer (luaL_Buffer B);</pre>
	6516
	6517	<p>
	6518	Equivalent to <a href="#luaL_prepbuffsize"><code>luaL_prepbuffsize</code></a>
	6519	with the predefined size <a name="pdf-LUAL_BUFFERSIZE"><code>LUAL_BUFFERSIZE</code></a>.
	6520
	6521
	6522
	6523
	6524
	6525	<hr><h3><a name="luaL_prepbuffsize"><code>luaL_prepbuffsize</code></a></h3><p>
	6526	<span class="apii">[-?, +?, <em>e</em>]</span>
	6527	<pre>char luaL_prepbuffsize (luaL_Buffer B, size_t sz);</pre>
	6528
	6529	<p>
	6530	Returns an address to a space of size <code>sz</code>
	6531	where you can copy a string to be added to buffer <code>B</code>
	6532	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
	6533	After copying the string into this space you must call
	6534	<a href="#luaL_addsize"><code>luaL_addsize</code></a> with the size of the string to actually add
	6535	it to the buffer.
	6536
	6537
	6538
	6539
	6540
	6541	<hr><h3><a name="luaL_pushresult"><code>luaL_pushresult</code></a></h3><p>
	6542	<span class="apii">[-?, +1, <em>e</em>]</span>
	6543	<pre>void luaL_pushresult (luaL_Buffer *B);</pre>
	6544
	6545	<p>
	6546	Finishes the use of buffer <code>B</code> leaving the final string on
	6547	the top of the stack.
	6548
	6549
	6550
	6551
	6552
	6553	<hr><h3><a name="luaL_pushresultsize"><code>luaL_pushresultsize</code></a></h3><p>
	6554	<span class="apii">[-?, +1, <em>e</em>]</span>
	6555	<pre>void luaL_pushresultsize (luaL_Buffer *B, size_t sz);</pre>
	6556
	6557	<p>
	6558	Equivalent to the sequence <a href="#luaL_addsize"><code>luaL_addsize</code></a>, <a href="#luaL_pushresult"><code>luaL_pushresult</code></a>.
	6559
	6560
	6561
	6562
	6563
	6564	<hr><h3><a name="luaL_ref"><code>luaL_ref</code></a></h3><p>
	6565	<span class="apii">[-1, +0, <em>e</em>]</span>
	6566	<pre>int luaL_ref (lua_State *L, int t);</pre>
	6567
	6568	<p>
	6569	Creates and returns a <em>reference</em>,
	6570	in the table at index <code>t</code>,
	6571	for the object at the top of the stack (and pops the object).
	6572
	6573
	6574	<p>
	6575	A reference is a unique integer key.
	6576	As long as you do not manually add integer keys into table <code>t</code>,
	6577	<a href="#luaL_ref"><code>luaL_ref</code></a> ensures the uniqueness of the key it returns.
	6578	You can retrieve an object referred by reference <code>r</code>
	6579	by calling <code>lua_rawgeti(L, t, r)</code>.
	6580	Function <a href="#luaL_unref"><code>luaL_unref</code></a> frees a reference and its associated object.
	6581
	6582
	6583	<p>
	6584	If the object at the top of the stack is <b>nil</b>,
	6585	<a href="#luaL_ref"><code>luaL_ref</code></a> returns the constant <a name="pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>.
	6586	The constant <a name="pdf-LUA_NOREF"><code>LUA_NOREF</code></a> is guaranteed to be different
	6587	from any reference returned by <a href="#luaL_ref"><code>luaL_ref</code></a>.
	6588
	6589
	6590
	6591
	6592
	6593	<hr><h3><a name="luaL_Reg"><code>luaL_Reg</code></a></h3>
	6594	<pre>typedef struct luaL_Reg {
	6595	const char *name;
	6596	lua_CFunction func;
	6597	} luaL_Reg;</pre>
	6598
	6599	<p>
	6600	Type for arrays of functions to be registered by
	6601	<a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a>.
	6602	<code>name</code> is the function name and <code>func</code> is a pointer to
	6603	the function.
	6604	Any array of <a href="#luaL_Reg"><code>luaL_Reg</code></a> must end with an sentinel entry
	6605	in which both <code>name</code> and <code>func</code> are <code>NULL</code>.
	6606
	6607
	6608
	6609
	6610
	6611	<hr><h3><a name="luaL_requiref"><code>luaL_requiref</code></a></h3><p>
	6612	<span class="apii">[-0, +1, <em>e</em>]</span>
	6613	<pre>void luaL_requiref (lua_State L, const char modname,
	6614	lua_CFunction openf, int glb);</pre>
	6615
	6616	<p>
	6617	Calls function <code>openf</code> with string <code>modname</code> as an argument
	6618	and sets the call result in <code>package.loaded[modname]</code>,
	6619	as if that function has been called through <a href="#pdf-require"><code>require</code></a>.
	6620
	6621
	6622	<p>
	6623	If <code>glb</code> is true,
	6624	also stores the result into global <code>modname</code>.
	6625
	6626
	6627	<p>
	6628	Leaves a copy of that result on the stack.
	6629
	6630
	6631
	6632
	6633
	6634	<hr><h3><a name="luaL_setfuncs"><code>luaL_setfuncs</code></a></h3><p>
	6635	<span class="apii">[-nup, +0, <em>e</em>]</span>
	6636	<pre>void luaL_setfuncs (lua_State L, const luaL_Reg l, int nup);</pre>
	6637
	6638	<p>
	6639	Registers all functions in the array <code>l</code>
	6640	(see <a href="#luaL_Reg"><code>luaL_Reg</code></a>) into the table on the top of the stack
	6641	(below optional upvalues, see next).
	6642
	6643
	6644	<p>
	6645	When <code>nup</code> is not zero,
	6646	all functions are created sharing <code>nup</code> upvalues,
	6647	which must be previously pushed on the stack
	6648	on top of the library table.
	6649	These values are popped from the stack after the registration.
	6650
	6651
	6652
	6653
	6654
	6655	<hr><h3><a name="luaL_setmetatable"><code>luaL_setmetatable</code></a></h3><p>
	6656	<span class="apii">[-0, +0, –]</span>
	6657	<pre>void luaL_setmetatable (lua_State L, const char tname);</pre>
	6658
	6659	<p>
	6660	Sets the metatable of the object at the top of the stack
	6661	as the metatable associated with name <code>tname</code>
	6662	in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
	6663
	6664
	6665
	6666
	6667
	6668	<hr><h3><a name="luaL_testudata"><code>luaL_testudata</code></a></h3><p>
	6669	<span class="apii">[-0, +0, <em>e</em>]</span>
	6670	<pre>void luaL_testudata (lua_State L, int arg, const char *tname);</pre>
	6671
	6672	<p>
	6673	This function works like <a href="#luaL_checkudata"><code>luaL_checkudata</code></a>,
	6674	except that, when the test fails,
	6675	it returns <code>NULL</code> instead of throwing an error.
	6676
	6677
	6678
	6679
	6680
	6681	<hr><h3><a name="luaL_tolstring"><code>luaL_tolstring</code></a></h3><p>
	6682	<span class="apii">[-0, +1, <em>e</em>]</span>
	6683	<pre>const char luaL_tolstring (lua_State L, int idx, size_t *len);</pre>
	6684
	6685	<p>
	6686	Converts any Lua value at the given index to a C string
	6687	in a reasonable format.
	6688	The resulting string is pushed onto the stack and also
	6689	returned by the function.
	6690	If <code>len</code> is not <code>NULL</code>,
	6691	the function also sets <code>*len</code> with the string length.
	6692
	6693
	6694	<p>
	6695	If the value has a metatable with a <code>"__tostring"</code> field,
	6696	then <code>luaL_tolstring</code> calls the corresponding metamethod
	6697	with the value as argument,
	6698	and uses the result of the call as its result.
	6699
	6700
	6701
	6702
	6703
	6704	<hr><h3><a name="luaL_traceback"><code>luaL_traceback</code></a></h3><p>
	6705	<span class="apii">[-0, +1, <em>e</em>]</span>
	6706	<pre>void luaL_traceback (lua_State L, lua_State L1, const char *msg,
	6707	int level);</pre>
	6708
	6709	<p>
	6710	Creates and pushes a traceback of the stack <code>L1</code>.
	6711	If <code>msg</code> is not <code>NULL</code> it is appended
	6712	at the beginning of the traceback.
	6713	The <code>level</code> parameter tells at which level
	6714	to start the traceback.
	6715
	6716
	6717
	6718
	6719
	6720	<hr><h3><a name="luaL_typename"><code>luaL_typename</code></a></h3><p>
	6721	<span class="apii">[-0, +0, –]</span>
	6722	<pre>const char luaL_typename (lua_State L, int index);</pre>
	6723
	6724	<p>
	6725	Returns the name of the type of the value at the given index.
	6726
	6727
	6728
	6729
	6730
	6731	<hr><h3><a name="luaL_unref"><code>luaL_unref</code></a></h3><p>
	6732	<span class="apii">[-0, +0, –]</span>
	6733	<pre>void luaL_unref (lua_State *L, int t, int ref);</pre>
	6734
	6735	<p>
	6736	Releases reference <code>ref</code> from the table at index <code>t</code>
	6737	(see <a href="#luaL_ref"><code>luaL_ref</code></a>).
	6738	The entry is removed from the table,
	6739	so that the referred object can be collected.
	6740	The reference <code>ref</code> is also freed to be used again.
	6741
	6742
	6743	<p>
	6744	If <code>ref</code> is <a href="#pdf-LUA_NOREF"><code>LUA_NOREF</code></a> or <a href="#pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>,
	6745	<a href="#luaL_unref"><code>luaL_unref</code></a> does nothing.
	6746
	6747
	6748
	6749
	6750
	6751	<hr><h3><a name="luaL_where"><code>luaL_where</code></a></h3><p>
	6752	<span class="apii">[-0, +1, <em>e</em>]</span>
	6753	<pre>void luaL_where (lua_State *L, int lvl);</pre>
	6754
	6755	<p>
	6756	Pushes onto the stack a string identifying the current position
	6757	of the control at level <code>lvl</code> in the call stack.
	6758	Typically this string has the following format:
	6759
	6760	<pre>
	6761	<em>chunkname</em>:<em>currentline</em>:
	6762	</pre><p>
	6763	Level 0 is the running function,
	6764	level 1 is the function that called the running function,
	6765	etc.
	6766
	6767
	6768	<p>
	6769	This function is used to build a prefix for error messages.
	6770
	6771
	6772
	6773
	6774
	6775
	6776
	6777	<h1>6 – <a name="6">Standard Libraries</a></h1>
	6778
	6779	<p>
	6780	The standard Lua libraries provide useful functions
	6781	that are implemented directly through the C API.
	6782	Some of these functions provide essential services to the language
	6783	(e.g., <a href="#pdf-type"><code>type</code></a> and <a href="#pdf-getmetatable"><code>getmetatable</code></a>);
	6784	others provide access to "outside" services (e.g., I/O);
	6785	and others could be implemented in Lua itself,
	6786	but are quite useful or have critical performance requirements that
	6787	deserve an implementation in C (e.g., <a href="#pdf-table.sort"><code>table.sort</code></a>).
	6788
	6789
	6790	<p>
	6791	All libraries are implemented through the official C API
	6792	and are provided as separate C modules.
	6793	Currently, Lua has the following standard libraries:
	6794
	6795	<ul>
	6796
	6797	<li>basic library (<a href="#6.1">§6.1</a>);</li>
	6798
	6799	<li>coroutine library (<a href="#6.2">§6.2</a>);</li>
	6800
	6801	<li>package library (<a href="#6.3">§6.3</a>);</li>
	6802
	6803	<li>string manipulation (<a href="#6.4">§6.4</a>);</li>
	6804
	6805	<li>table manipulation (<a href="#6.5">§6.5</a>);</li>
	6806
	6807	<li>mathematical functions (<a href="#6.6">§6.6</a>) (sin, log, etc.);</li>
	6808
	6809	<li>bitwise operations (<a href="#6.7">§6.7</a>);</li>
	6810
	6811	<li>input and output (<a href="#6.8">§6.8</a>);</li>
	6812
	6813	<li>operating system facilities (<a href="#6.9">§6.9</a>);</li>
	6814
	6815	<li>debug facilities (<a href="#6.10">§6.10</a>).</li>
	6816
	6817	</ul><p>
	6818	Except for the basic and the package libraries,
	6819	each library provides all its functions as fields of a global table
	6820	or as methods of its objects.
	6821
	6822
	6823	<p>
	6824	To have access to these libraries,
	6825	the C host program should call the <a href="#luaL_openlibs"><code>luaL_openlibs</code></a> function,
	6826	which opens all standard libraries.
	6827	Alternatively,
	6828	the host program can open them individually by using
	6829	<a href="#luaL_requiref"><code>luaL_requiref</code></a> to call
	6830	<a name="pdf-luaopen_base"><code>luaopen_base</code></a> (for the basic library),
	6831	<a name="pdf-luaopen_package"><code>luaopen_package</code></a> (for the package library),
	6832	<a name="pdf-luaopen_coroutine"><code>luaopen_coroutine</code></a> (for the coroutine library),
	6833	<a name="pdf-luaopen_string"><code>luaopen_string</code></a> (for the string library),
	6834	<a name="pdf-luaopen_table"><code>luaopen_table</code></a> (for the table library),
	6835	<a name="pdf-luaopen_math"><code>luaopen_math</code></a> (for the mathematical library),
	6836	<a name="pdf-luaopen_bit32"><code>luaopen_bit32</code></a> (for the bit library),
	6837	<a name="pdf-luaopen_io"><code>luaopen_io</code></a> (for the I/O library),
	6838	<a name="pdf-luaopen_os"><code>luaopen_os</code></a> (for the Operating System library),
	6839	and <a name="pdf-luaopen_debug"><code>luaopen_debug</code></a> (for the debug library).
	6840	These functions are declared in <a name="pdf-lualib.h"><code>lualib.h</code></a>.
	6841
	6842
	6843
	6844	<h2>6.1 – <a name="6.1">Basic Functions</a></h2>
	6845
	6846	<p>
	6847	The basic library provides core functions to Lua.
	6848	If you do not include this library in your application,
	6849	you should check carefully whether you need to provide
	6850	implementations for some of its facilities.
	6851
	6852
	6853	<p>
	6854	<hr><h3><a name="pdf-assert"><code>assert (v [, message])</code></a></h3>
	6855	Issues an error when
	6856	the value of its argument <code>v</code> is false (i.e., <b>nil</b> or <b>false</b>);
	6857	otherwise, returns all its arguments.
	6858	<code>message</code> is an error message;
	6859	when absent, it defaults to "assertion failed!"
	6860
	6861
	6862
	6863
	6864	<p>
	6865	<hr><h3><a name="pdf-collectgarbage"><code>collectgarbage ([opt [, arg]])</code></a></h3>
	6866
	6867
	6868	<p>
	6869	This function is a generic interface to the garbage collector.
	6870	It performs different functions according to its first argument, <code>opt</code>:
	6871
	6872	<ul>
	6873
	6874	<li><b>"<code>collect</code>": </b>
	6875	performs a full garbage-collection cycle.
	6876	This is the default option.
	6877	</li>
	6878
	6879	<li><b>"<code>stop</code>": </b>
	6880	stops automatic execution of the garbage collector.
	6881	The collector will run only when explicitly invoked,
	6882	until a call to restart it.
	6883	</li>
	6884
	6885	<li><b>"<code>restart</code>": </b>
	6886	restarts automatic execution of the garbage collector.
	6887	</li>
	6888
	6889	<li><b>"<code>count</code>": </b>
	6890	returns the total memory in use by Lua (in Kbytes) and
	6891	a second value with the total memory in bytes modulo 1024.
	6892	The first value has a fractional part,
	6893	so the following equality is always true:
	6894
	6895	<pre>
	6896	k, b = collectgarbage("count")
	6897	assert(k1024 == math.floor(k)1024 + b)
	6898	</pre><p>
	6899	(The second result is useful when Lua is compiled
	6900	with a non floating-point type for numbers.)
	6901	</li>
	6902
	6903	<li><b>"<code>step</code>": </b>
	6904	performs a garbage-collection step.
	6905	The step "size" is controlled by <code>arg</code>
	6906	(larger values mean more steps) in a non-specified way.
	6907	If you want to control the step size
	6908	you must experimentally tune the value of <code>arg</code>.
	6909	Returns <b>true</b> if the step finished a collection cycle.
	6910	</li>
	6911
	6912	<li><b>"<code>setpause</code>": </b>
	6913	sets <code>arg</code> as the new value for the <em>pause</em> of
	6914	the collector (see <a href="#2.5">§2.5</a>).
	6915	Returns the previous value for <em>pause</em>.
	6916	</li>
	6917
	6918	<li><b>"<code>setstepmul</code>": </b>
	6919	sets <code>arg</code> as the new value for the <em>step multiplier</em> of
	6920	the collector (see <a href="#2.5">§2.5</a>).
	6921	Returns the previous value for <em>step</em>.
	6922	</li>
	6923
	6924	<li><b>"<code>isrunning</code>": </b>
	6925	returns a boolean that tells whether the collector is running
	6926	(i.e., not stopped).
	6927	</li>
	6928
	6929	<li><b>"<code>generational</code>": </b>
	6930	changes the collector to generational mode.
	6931	This is an experimental feature (see <a href="#2.5">§2.5</a>).
	6932	</li>
	6933
	6934	<li><b>"<code>incremental</code>": </b>
	6935	changes the collector to incremental mode.
	6936	This is the default mode.
	6937	</li>
	6938
	6939	</ul>
	6940
	6941
	6942
	6943	<p>
	6944	<hr><h3><a name="pdf-dofile"><code>dofile ([filename])</code></a></h3>
	6945	Opens the named file and executes its contents as a Lua chunk.
	6946	When called without arguments,
	6947	<code>dofile</code> executes the contents of the standard input (<code>stdin</code>).
	6948	Returns all values returned by the chunk.
	6949	In case of errors, <code>dofile</code> propagates the error
	6950	to its caller (that is, <code>dofile</code> does not run in protected mode).
	6951
	6952
	6953
	6954
	6955	<p>
	6956	<hr><h3><a name="pdf-error"><code>error (message [, level])</code></a></h3>
	6957	Terminates the last protected function called
	6958	and returns <code>message</code> as the error message.
	6959	Function <code>error</code> never returns.
	6960
	6961
	6962	<p>
	6963	Usually, <code>error</code> adds some information about the error position
	6964	at the beginning of the message, if the message is a string.
	6965	The <code>level</code> argument specifies how to get the error position.
	6966	With level 1 (the default), the error position is where the
	6967	<code>error</code> function was called.
	6968	Level 2 points the error to where the function
	6969	that called <code>error</code> was called; and so on.
	6970	Passing a level 0 avoids the addition of error position information
	6971	to the message.
	6972
	6973
	6974
	6975
	6976	<p>
	6977	<hr><h3><a name="pdf-_G"><code>_G</code></a></h3>
	6978	A global variable (not a function) that
	6979	holds the global environment (see <a href="#2.2">§2.2</a>).
	6980	Lua itself does not use this variable;
	6981	changing its value does not affect any environment,
	6982	nor vice-versa.
	6983
	6984
	6985
	6986
	6987	<p>
	6988	<hr><h3><a name="pdf-getmetatable"><code>getmetatable (object)</code></a></h3>
	6989
	6990
	6991	<p>
	6992	If <code>object</code> does not have a metatable, returns <b>nil</b>.
	6993	Otherwise,
	6994	if the object's metatable has a <code>"__metatable"</code> field,
	6995	returns the associated value.
	6996	Otherwise, returns the metatable of the given object.
	6997
	6998
	6999
	7000
	7001	<p>
	7002	<hr><h3><a name="pdf-ipairs"><code>ipairs (t)</code></a></h3>
	7003
	7004
	7005	<p>
	7006	If <code>t</code> has a metamethod <code>__ipairs</code>,
	7007	calls it with <code>t</code> as argument and returns the first three
	7008	results from the call.
	7009
	7010
	7011	<p>
	7012	Otherwise,
	7013	returns three values: an iterator function, the table <code>t</code>, and 0,
	7014	so that the construction
	7015
	7016	<pre>
	7017	for i,v in ipairs(t) do <em>body</em> end
	7018	</pre><p>
	7019	will iterate over the pairs (<code>1,t[1]</code>), (<code>2,t[2]</code>), ...,
	7020	up to the first integer key absent from the table.
	7021
	7022
	7023
	7024
	7025	<p>
	7026	<hr><h3><a name="pdf-load"><code>load (ld [, source [, mode [, env]]])</code></a></h3>
	7027
	7028
	7029	<p>
	7030	Loads a chunk.
	7031
	7032
	7033	<p>
	7034	If <code>ld</code> is a string, the chunk is this string.
	7035	If <code>ld</code> is a function,
	7036	<code>load</code> calls it repeatedly to get the chunk pieces.
	7037	Each call to <code>ld</code> must return a string that concatenates
	7038	with previous results.
	7039	A return of an empty string, <b>nil</b>, or no value signals the end of the chunk.
	7040
	7041
	7042	<p>
	7043	If there are no syntactic errors,
	7044	returns the compiled chunk as a function;
	7045	otherwise, returns <b>nil</b> plus the error message.
	7046
	7047
	7048	<p>
	7049	If the resulting function has upvalues,
	7050	the first upvalue is set to the value of <code>env</code>,
	7051	if that parameter is given,
	7052	or to the value of the global environment.
	7053	(When you load a main chunk,
	7054	the resulting function will always have exactly one upvalue,
	7055	the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>).
	7056	When you load a binary chunk created from a function (see <a href="#pdf-string.dump"><code>string.dump</code></a>),
	7057	the resulting function can have arbitrary upvalues.)
	7058
	7059
	7060	<p>
	7061	<code>source</code> is used as the source of the chunk for error messages
	7062	and debug information (see <a href="#4.9">§4.9</a>).
	7063	When absent,
	7064	it defaults to <code>ld</code>, if <code>ld</code> is a string,
	7065	or to "<code>=(load)</code>" otherwise.
	7066
	7067
	7068	<p>
	7069	The string <code>mode</code> controls whether the chunk can be text or binary
	7070	(that is, a precompiled chunk).
	7071	It may be the string "<code>b</code>" (only binary chunks),
	7072	"<code>t</code>" (only text chunks),
	7073	or "<code>bt</code>" (both binary and text).
	7074	The default is "<code>bt</code>".
	7075
	7076
	7077
	7078
	7079	<p>
	7080	<hr><h3><a name="pdf-loadfile"><code>loadfile ([filename [, mode [, env]]])</code></a></h3>
	7081
	7082
	7083	<p>
	7084	Similar to <a href="#pdf-load"><code>load</code></a>,
	7085	but gets the chunk from file <code>filename</code>
	7086	or from the standard input,
	7087	if no file name is given.
	7088
	7089
	7090
	7091
	7092	<p>
	7093	<hr><h3><a name="pdf-next"><code>next (table [, index])</code></a></h3>
	7094
	7095
	7096	<p>
	7097	Allows a program to traverse all fields of a table.
	7098	Its first argument is a table and its second argument
	7099	is an index in this table.
	7100	<code>next</code> returns the next index of the table
	7101	and its associated value.
	7102	When called with <b>nil</b> as its second argument,
	7103	<code>next</code> returns an initial index
	7104	and its associated value.
	7105	When called with the last index,
	7106	or with <b>nil</b> in an empty table,
	7107	<code>next</code> returns <b>nil</b>.
	7108	If the second argument is absent, then it is interpreted as <b>nil</b>.
	7109	In particular,
	7110	you can use <code>next(t)</code> to check whether a table is empty.
	7111
	7112
	7113	<p>
	7114	The order in which the indices are enumerated is not specified,
	7115	<em>even for numeric indices</em>.
	7116	(To traverse a table in numeric order,
	7117	use a numerical <b>for</b>.)
	7118
	7119
	7120	<p>
	7121	The behavior of <code>next</code> is undefined if,
	7122	during the traversal,
	7123	you assign any value to a non-existent field in the table.
	7124	You may however modify existing fields.
	7125	In particular, you may clear existing fields.
	7126
	7127
	7128
	7129
	7130	<p>
	7131	<hr><h3><a name="pdf-pairs"><code>pairs (t)</code></a></h3>
	7132
	7133
	7134	<p>
	7135	If <code>t</code> has a metamethod <code>__pairs</code>,
	7136	calls it with <code>t</code> as argument and returns the first three
	7137	results from the call.
	7138
	7139
	7140	<p>
	7141	Otherwise,
	7142	returns three values: the <a href="#pdf-next"><code>next</code></a> function, the table <code>t</code>, and <b>nil</b>,
	7143	so that the construction
	7144
	7145	<pre>
	7146	for k,v in pairs(t) do <em>body</em> end
	7147	</pre><p>
	7148	will iterate over all key–value pairs of table <code>t</code>.
	7149
	7150
	7151	<p>
	7152	See function <a href="#pdf-next"><code>next</code></a> for the caveats of modifying
	7153	the table during its traversal.
	7154
	7155
	7156
	7157
	7158	<p>
	7159	<hr><h3><a name="pdf-pcall"><code>pcall (f [, arg1, ···])</code></a></h3>
	7160
	7161
	7162	<p>
	7163	Calls function <code>f</code> with
	7164	the given arguments in <em>protected mode</em>.
	7165	This means that any error inside <code>f</code> is not propagated;
	7166	instead, <code>pcall</code> catches the error
	7167	and returns a status code.
	7168	Its first result is the status code (a boolean),
	7169	which is true if the call succeeds without errors.
	7170	In such case, <code>pcall</code> also returns all results from the call,
	7171	after this first result.
	7172	In case of any error, <code>pcall</code> returns <b>false</b> plus the error message.
	7173
	7174
	7175
	7176
	7177	<p>
	7178	<hr><h3><a name="pdf-print"><code>print (···)</code></a></h3>
	7179	Receives any number of arguments
	7180	and prints their values to <code>stdout</code>,
	7181	using the <a href="#pdf-tostring"><code>tostring</code></a> function to convert each argument to a string.
	7182	<code>print</code> is not intended for formatted output,
	7183	but only as a quick way to show a value,
	7184	for instance for debugging.
	7185	For complete control over the output,
	7186	use <a href="#pdf-string.format"><code>string.format</code></a> and <a href="#pdf-io.write"><code>io.write</code></a>.
	7187
	7188
	7189
	7190
	7191	<p>
	7192	<hr><h3><a name="pdf-rawequal"><code>rawequal (v1, v2)</code></a></h3>
	7193	Checks whether <code>v1</code> is equal to <code>v2</code>,
	7194	without invoking any metamethod.
	7195	Returns a boolean.
	7196
	7197
	7198
	7199
	7200	<p>
	7201	<hr><h3><a name="pdf-rawget"><code>rawget (table, index)</code></a></h3>
	7202	Gets the real value of <code>table[index]</code>,
	7203	without invoking any metamethod.
	7204	<code>table</code> must be a table;
	7205	<code>index</code> may be any value.
	7206
	7207
	7208
	7209
	7210	<p>
	7211	<hr><h3><a name="pdf-rawlen"><code>rawlen (v)</code></a></h3>
	7212	Returns the length of the object <code>v</code>,
	7213	which must be a table or a string,
	7214	without invoking any metamethod.
	7215	Returns an integer number.
	7216
	7217
	7218
	7219
	7220	<p>
	7221	<hr><h3><a name="pdf-rawset"><code>rawset (table, index, value)</code></a></h3>
	7222	Sets the real value of <code>table[index]</code> to <code>value</code>,
	7223	without invoking any metamethod.
	7224	<code>table</code> must be a table,
	7225	<code>index</code> any value different from <b>nil</b> and NaN,
	7226	and <code>value</code> any Lua value.
	7227
	7228
	7229	<p>
	7230	This function returns <code>table</code>.
	7231
	7232
	7233
	7234
	7235	<p>
	7236	<hr><h3><a name="pdf-select"><code>select (index, ···)</code></a></h3>
	7237
	7238
	7239	<p>
	7240	If <code>index</code> is a number,
	7241	returns all arguments after argument number <code>index</code>;
	7242	a negative number indexes from the end (-1 is the last argument).
	7243	Otherwise, <code>index</code> must be the string <code>"#"</code>,
	7244	and <code>select</code> returns the total number of extra arguments it received.
	7245
	7246
	7247
	7248
	7249	<p>
	7250	<hr><h3><a name="pdf-setmetatable"><code>setmetatable (table, metatable)</code></a></h3>
	7251
	7252
	7253	<p>
	7254	Sets the metatable for the given table.
	7255	(You cannot change the metatable of other types from Lua, only from C.)
	7256	If <code>metatable</code> is <b>nil</b>,
	7257	removes the metatable of the given table.
	7258	If the original metatable has a <code>"__metatable"</code> field,
	7259	raises an error.
	7260
	7261
	7262	<p>
	7263	This function returns <code>table</code>.
	7264
	7265
	7266
	7267
	7268	<p>
	7269	<hr><h3><a name="pdf-tonumber"><code>tonumber (e [, base])</code></a></h3>
	7270
	7271
	7272	<p>
	7273	When called with no <code>base</code>,
	7274	<code>tonumber</code> tries to convert its argument to a number.
	7275	If the argument is already a number or
	7276	a string convertible to a number (see <a href="#3.4.2">§3.4.2</a>),
	7277	then <code>tonumber</code> returns this number;
	7278	otherwise, it returns <b>nil</b>.
	7279
	7280
	7281	<p>
	7282	When called with <code>base</code>,
	7283	then <code>e</code> should be a string to be interpreted as
	7284	an integer numeral in that base.
	7285	The base may be any integer between 2 and 36, inclusive.
	7286	In bases above 10, the letter '<code>A</code>' (in either upper or lower case)
	7287	represents 10, '<code>B</code>' represents 11, and so forth,
	7288	with '<code>Z</code>' representing 35.
	7289	If the string <code>e</code> is not a valid numeral in the given base,
	7290	the function returns <b>nil</b>.
	7291
	7292
	7293
	7294
	7295	<p>
	7296	<hr><h3><a name="pdf-tostring"><code>tostring (v)</code></a></h3>
	7297	Receives a value of any type and
	7298	converts it to a string in a reasonable format.
	7299	(For complete control of how numbers are converted,
	7300	use <a href="#pdf-string.format"><code>string.format</code></a>.)
	7301
	7302
	7303	<p>
	7304	If the metatable of <code>v</code> has a <code>"__tostring"</code> field,
	7305	then <code>tostring</code> calls the corresponding value
	7306	with <code>v</code> as argument,
	7307	and uses the result of the call as its result.
	7308
	7309
	7310
	7311
	7312	<p>
	7313	<hr><h3><a name="pdf-type"><code>type (v)</code></a></h3>
	7314	Returns the type of its only argument, coded as a string.
	7315	The possible results of this function are
	7316	"<code>nil</code>" (a string, not the value <b>nil</b>),
	7317	"<code>number</code>",
	7318	"<code>string</code>",
	7319	"<code>boolean</code>",
	7320	"<code>table</code>",
	7321	"<code>function</code>",
	7322	"<code>thread</code>",
	7323	and "<code>userdata</code>".
	7324
	7325
	7326
	7327
	7328	<p>
	7329	<hr><h3><a name="pdf-_VERSION"><code>_VERSION</code></a></h3>
	7330	A global variable (not a function) that
	7331	holds a string containing the current interpreter version.
	7332	The current contents of this variable is "<code>Lua 5.2</code>".
	7333
	7334
	7335
	7336
	7337	<p>
	7338	<hr><h3><a name="pdf-xpcall"><code>xpcall (f, msgh [, arg1, ···])</code></a></h3>
	7339
	7340
	7341	<p>
	7342	This function is similar to <a href="#pdf-pcall"><code>pcall</code></a>,
	7343	except that it sets a new message handler <code>msgh</code>.
	7344
	7345
	7346
	7347
	7348
	7349
	7350
	7351	<h2>6.2 – <a name="6.2">Coroutine Manipulation</a></h2>
	7352
	7353	<p>
	7354	The operations related to coroutines comprise a sub-library of
	7355	the basic library and come inside the table <a name="pdf-coroutine"><code>coroutine</code></a>.
	7356	See <a href="#2.6">§2.6</a> for a general description of coroutines.
	7357
	7358
	7359	<p>
	7360	<hr><h3><a name="pdf-coroutine.create"><code>coroutine.create (f)</code></a></h3>
	7361
	7362
	7363	<p>
	7364	Creates a new coroutine, with body <code>f</code>.
	7365	<code>f</code> must be a Lua function.
	7366	Returns this new coroutine,
	7367	an object with type <code>"thread"</code>.
	7368
	7369
	7370
	7371
	7372	<p>
	7373	<hr><h3><a name="pdf-coroutine.resume"><code>coroutine.resume (co [, val1, ···])</code></a></h3>
	7374
	7375
	7376	<p>
	7377	Starts or continues the execution of coroutine <code>co</code>.
	7378	The first time you resume a coroutine,
	7379	it starts running its body.
	7380	The values <code>val1</code>, ... are passed
	7381	as the arguments to the body function.
	7382	If the coroutine has yielded,
	7383	<code>resume</code> restarts it;
	7384	the values <code>val1</code>, ... are passed
	7385	as the results from the yield.
	7386
	7387
	7388	<p>
	7389	If the coroutine runs without any errors,
	7390	<code>resume</code> returns <b>true</b> plus any values passed to <code>yield</code>
	7391	(if the coroutine yields) or any values returned by the body function
	7392	(if the coroutine terminates).
	7393	If there is any error,
	7394	<code>resume</code> returns <b>false</b> plus the error message.
	7395
	7396
	7397
	7398
	7399	<p>
	7400	<hr><h3><a name="pdf-coroutine.running"><code>coroutine.running ()</code></a></h3>
	7401
	7402
	7403	<p>
	7404	Returns the running coroutine plus a boolean,
	7405	true when the running coroutine is the main one.
	7406
	7407
	7408
	7409
	7410	<p>
	7411	<hr><h3><a name="pdf-coroutine.status"><code>coroutine.status (co)</code></a></h3>
	7412
	7413
	7414	<p>
	7415	Returns the status of coroutine <code>co</code>, as a string:
	7416	<code>"running"</code>,
	7417	if the coroutine is running (that is, it called <code>status</code>);
	7418	<code>"suspended"</code>, if the coroutine is suspended in a call to <code>yield</code>,
	7419	or if it has not started running yet;
	7420	<code>"normal"</code> if the coroutine is active but not running
	7421	(that is, it has resumed another coroutine);
	7422	and <code>"dead"</code> if the coroutine has finished its body function,
	7423	or if it has stopped with an error.
	7424
	7425
	7426
	7427
	7428	<p>
	7429	<hr><h3><a name="pdf-coroutine.wrap"><code>coroutine.wrap (f)</code></a></h3>
	7430
	7431
	7432	<p>
	7433	Creates a new coroutine, with body <code>f</code>.
	7434	<code>f</code> must be a Lua function.
	7435	Returns a function that resumes the coroutine each time it is called.
	7436	Any arguments passed to the function behave as the
	7437	extra arguments to <code>resume</code>.
	7438	Returns the same values returned by <code>resume</code>,
	7439	except the first boolean.
	7440	In case of error, propagates the error.
	7441
	7442
	7443
	7444
	7445	<p>
	7446	<hr><h3><a name="pdf-coroutine.yield"><code>coroutine.yield (···)</code></a></h3>
	7447
	7448
	7449	<p>
	7450	Suspends the execution of the calling coroutine.
	7451	Any arguments to <code>yield</code> are passed as extra results to <code>resume</code>.
	7452
	7453
	7454
	7455
	7456
	7457
	7458
	7459	<h2>6.3 – <a name="6.3">Modules</a></h2>
	7460
	7461	<p>
	7462	The package library provides basic
	7463	facilities for loading modules in Lua.
	7464	It exports one function directly in the global environment:
	7465	<a href="#pdf-require"><code>require</code></a>.
	7466	Everything else is exported in a table <a name="pdf-package"><code>package</code></a>.
	7467
	7468
	7469	<p>
	7470	<hr><h3><a name="pdf-require"><code>require (modname)</code></a></h3>
	7471
	7472
	7473	<p>
	7474	Loads the given module.
	7475	The function starts by looking into the <a href="#pdf-package.loaded"><code>package.loaded</code></a> table
	7476	to determine whether <code>modname</code> is already loaded.
	7477	If it is, then <code>require</code> returns the value stored
	7478	at <code>package.loaded[modname]</code>.
	7479	Otherwise, it tries to find a <em>loader</em> for the module.
	7480
	7481
	7482	<p>
	7483	To find a loader,
	7484	<code>require</code> is guided by the <a href="#pdf-package.searchers"><code>package.searchers</code></a> sequence.
	7485	By changing this sequence,
	7486	we can change how <code>require</code> looks for a module.
	7487	The following explanation is based on the default configuration
	7488	for <a href="#pdf-package.searchers"><code>package.searchers</code></a>.
	7489
	7490
	7491	<p>
	7492	First <code>require</code> queries <code>package.preload[modname]</code>.
	7493	If it has a value,
	7494	this value (which should be a function) is the loader.
	7495	Otherwise <code>require</code> searches for a Lua loader using the
	7496	path stored in <a href="#pdf-package.path"><code>package.path</code></a>.
	7497	If that also fails, it searches for a C loader using the
	7498	path stored in <a href="#pdf-package.cpath"><code>package.cpath</code></a>.
	7499	If that also fails,
	7500	it tries an <em>all-in-one</em> loader (see <a href="#pdf-package.searchers"><code>package.searchers</code></a>).
	7501
	7502
	7503	<p>
	7504	Once a loader is found,
	7505	<code>require</code> calls the loader with two arguments:
	7506	<code>modname</code> and an extra value dependent on how it got the loader.
	7507	(If the loader came from a file,
	7508	this extra value is the file name.)
	7509	If the loader returns any non-nil value,
	7510	<code>require</code> assigns the returned value to <code>package.loaded[modname]</code>.
	7511	If the loader does not return a non-nil value and
	7512	has not assigned any value to <code>package.loaded[modname]</code>,
	7513	then <code>require</code> assigns <b>true</b> to this entry.
	7514	In any case, <code>require</code> returns the
	7515	final value of <code>package.loaded[modname]</code>.
	7516
	7517
	7518	<p>
	7519	If there is any error loading or running the module,
	7520	or if it cannot find any loader for the module,
	7521	then <code>require</code> raises an error.
	7522
	7523
	7524
	7525
	7526	<p>
	7527	<hr><h3><a name="pdf-package.config"><code>package.config</code></a></h3>
	7528
	7529
	7530	<p>
	7531	A string describing some compile-time configurations for packages.
	7532	This string is a sequence of lines:
	7533
	7534	<ul>
	7535
	7536	<li>The first line is the directory separator string.
	7537	Default is '<code>\</code>' for Windows and '<code>/</code>' for all other systems.</li>
	7538
	7539	<li>The second line is the character that separates templates in a path.
	7540	Default is '<code>;</code>'.</li>
	7541
	7542	<li>The third line is the string that marks the
	7543	substitution points in a template.
	7544	Default is '<code>?</code>'.</li>
	7545
	7546	<li>The fourth line is a string that, in a path in Windows,
	7547	is replaced by the executable's directory.
	7548	Default is '<code>!</code>'.</li>
	7549
	7550	<li>The fifth line is a mark to ignore all text before it
	7551	when building the <code>luaopen_</code> function name.
	7552	Default is '<code>-</code>'.</li>
	7553
	7554	</ul>
	7555
	7556
	7557
	7558	<p>
	7559	<hr><h3><a name="pdf-package.cpath"><code>package.cpath</code></a></h3>
	7560
	7561
	7562	<p>
	7563	The path used by <a href="#pdf-require"><code>require</code></a> to search for a C loader.
	7564
	7565
	7566	<p>
	7567	Lua initializes the C path <a href="#pdf-package.cpath"><code>package.cpath</code></a> in the same way
	7568	it initializes the Lua path <a href="#pdf-package.path"><code>package.path</code></a>,
	7569	using the environment variable <a name="pdf-LUA_CPATH_5_2"><code>LUA_CPATH_5_2</code></a>
	7570	or the environment variable <a name="pdf-LUA_CPATH"><code>LUA_CPATH</code></a>
	7571	or a default path defined in <code>luaconf.h</code>.
	7572
	7573
	7574
	7575
	7576	<p>
	7577	<hr><h3><a name="pdf-package.loaded"><code>package.loaded</code></a></h3>
	7578
	7579
	7580	<p>
	7581	A table used by <a href="#pdf-require"><code>require</code></a> to control which
	7582	modules are already loaded.
	7583	When you require a module <code>modname</code> and
	7584	<code>package.loaded[modname]</code> is not false,
	7585	<a href="#pdf-require"><code>require</code></a> simply returns the value stored there.
	7586
	7587
	7588	<p>
	7589	This variable is only a reference to the real table;
	7590	assignments to this variable do not change the
	7591	table used by <a href="#pdf-require"><code>require</code></a>.
	7592
	7593
	7594
	7595
	7596	<p>
	7597	<hr><h3><a name="pdf-package.loadlib"><code>package.loadlib (libname, funcname)</code></a></h3>
	7598
	7599
	7600	<p>
	7601	Dynamically links the host program with the C library <code>libname</code>.
	7602
	7603
	7604	<p>
	7605	If <code>funcname</code> is "<code>*</code>",
	7606	then it only links with the library,
	7607	making the symbols exported by the library
	7608	available to other dynamically linked libraries.
	7609	Otherwise,
	7610	it looks for a function <code>funcname</code> inside the library
	7611	and returns this function as a C function.
	7612	So, <code>funcname</code> must follow the <a href="#lua_CFunction"><code>lua_CFunction</code></a> prototype
	7613	(see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
	7614
	7615
	7616	<p>
	7617	This is a low-level function.
	7618	It completely bypasses the package and module system.
	7619	Unlike <a href="#pdf-require"><code>require</code></a>,
	7620	it does not perform any path searching and
	7621	does not automatically adds extensions.
	7622	<code>libname</code> must be the complete file name of the C library,
	7623	including if necessary a path and an extension.
	7624	<code>funcname</code> must be the exact name exported by the C library
	7625	(which may depend on the C compiler and linker used).
	7626
	7627
	7628	<p>
	7629	This function is not supported by Standard C.
	7630	As such, it is only available on some platforms
	7631	(Windows, Linux, Mac OS X, Solaris, BSD,
	7632	plus other Unix systems that support the <code>dlfcn</code> standard).
	7633
	7634
	7635
	7636
	7637	<p>
	7638	<hr><h3><a name="pdf-package.path"><code>package.path</code></a></h3>
	7639
	7640
	7641	<p>
	7642	The path used by <a href="#pdf-require"><code>require</code></a> to search for a Lua loader.
	7643
	7644
	7645	<p>
	7646	At start-up, Lua initializes this variable with
	7647	the value of the environment variable <a name="pdf-LUA_PATH_5_2"><code>LUA_PATH_5_2</code></a> or
	7648	the environment variable <a name="pdf-LUA_PATH"><code>LUA_PATH</code></a> or
	7649	with a default path defined in <code>luaconf.h</code>,
	7650	if those environment variables are not defined.
	7651	Any "<code>;;</code>" in the value of the environment variable
	7652	is replaced by the default path.
	7653
	7654
	7655
	7656
	7657	<p>
	7658	<hr><h3><a name="pdf-package.preload"><code>package.preload</code></a></h3>
	7659
	7660
	7661	<p>
	7662	A table to store loaders for specific modules
	7663	(see <a href="#pdf-require"><code>require</code></a>).
	7664
	7665
	7666	<p>
	7667	This variable is only a reference to the real table;
	7668	assignments to this variable do not change the
	7669	table used by <a href="#pdf-require"><code>require</code></a>.
	7670
	7671
	7672
	7673
	7674	<p>
	7675	<hr><h3><a name="pdf-package.searchers"><code>package.searchers</code></a></h3>
	7676
	7677
	7678	<p>
	7679	A table used by <a href="#pdf-require"><code>require</code></a> to control how to load modules.
	7680
	7681
	7682	<p>
	7683	Each entry in this table is a <em>searcher function</em>.
	7684	When looking for a module,
	7685	<a href="#pdf-require"><code>require</code></a> calls each of these searchers in ascending order,
	7686	with the module name (the argument given to <a href="#pdf-require"><code>require</code></a>) as its
	7687	sole parameter.
	7688	The function can return another function (the module <em>loader</em>)
	7689	plus an extra value that will be passed to that loader,
	7690	or a string explaining why it did not find that module
	7691	(or <b>nil</b> if it has nothing to say).
	7692
	7693
	7694	<p>
	7695	Lua initializes this table with four searcher functions.
	7696
	7697
	7698	<p>
	7699	The first searcher simply looks for a loader in the
	7700	<a href="#pdf-package.preload"><code>package.preload</code></a> table.
	7701
	7702
	7703	<p>
	7704	The second searcher looks for a loader as a Lua library,
	7705	using the path stored at <a href="#pdf-package.path"><code>package.path</code></a>.
	7706	The search is done as described in function <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>.
	7707
	7708
	7709	<p>
	7710	The third searcher looks for a loader as a C library,
	7711	using the path given by the variable <a href="#pdf-package.cpath"><code>package.cpath</code></a>.
	7712	Again,
	7713	the search is done as described in function <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>.
	7714	For instance,
	7715	if the C path is the string
	7716
	7717	<pre>
	7718	"./?.so;./?.dll;/usr/local/?/init.so"
	7719	</pre><p>
	7720	the searcher for module <code>foo</code>
	7721	will try to open the files <code>./foo.so</code>, <code>./foo.dll</code>,
	7722	and <code>/usr/local/foo/init.so</code>, in that order.
	7723	Once it finds a C library,
	7724	this searcher first uses a dynamic link facility to link the
	7725	application with the library.
	7726	Then it tries to find a C function inside the library to
	7727	be used as the loader.
	7728	The name of this C function is the string "<code>luaopen_</code>"
	7729	concatenated with a copy of the module name where each dot
	7730	is replaced by an underscore.
	7731	Moreover, if the module name has a hyphen,
	7732	its prefix up to (and including) the first hyphen is removed.
	7733	For instance, if the module name is <code>a.v1-b.c</code>,
	7734	the function name will be <code>luaopen_b_c</code>.
	7735
	7736
	7737	<p>
	7738	The fourth searcher tries an <em>all-in-one loader</em>.
	7739	It searches the C path for a library for
	7740	the root name of the given module.
	7741	For instance, when requiring <code>a.b.c</code>,
	7742	it will search for a C library for <code>a</code>.
	7743	If found, it looks into it for an open function for
	7744	the submodule;
	7745	in our example, that would be <code>luaopen_a_b_c</code>.
	7746	With this facility, a package can pack several C submodules
	7747	into one single library,
	7748	with each submodule keeping its original open function.
	7749
	7750
	7751	<p>
	7752	All searchers except the first one (preload) return as the extra value
	7753	the file name where the module was found,
	7754	as returned by <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>.
	7755	The first searcher returns no extra value.
	7756
	7757
	7758
	7759
	7760	<p>
	7761	<hr><h3><a name="pdf-package.searchpath"><code>package.searchpath (name, path [, sep [, rep]])</code></a></h3>
	7762
	7763
	7764	<p>
	7765	Searches for the given <code>name</code> in the given <code>path</code>.
	7766
	7767
	7768	<p>
	7769	A path is a string containing a sequence of
	7770	<em>templates</em> separated by semicolons.
	7771	For each template,
	7772	the function replaces each interrogation mark (if any)
	7773	in the template with a copy of <code>name</code>
	7774	wherein all occurrences of <code>sep</code>
	7775	(a dot, by default)
	7776	were replaced by <code>rep</code>
	7777	(the system's directory separator, by default),
	7778	and then tries to open the resulting file name.
	7779
	7780
	7781	<p>
	7782	For instance, if the path is the string
	7783
	7784	<pre>
	7785	"./?.lua;./?.lc;/usr/local/?/init.lua"
	7786	</pre><p>
	7787	the search for the name <code>foo.a</code>
	7788	will try to open the files
	7789	<code>./foo/a.lua</code>, <code>./foo/a.lc</code>, and
	7790	<code>/usr/local/foo/a/init.lua</code>, in that order.
	7791
	7792
	7793	<p>
	7794	Returns the resulting name of the first file that it can
	7795	open in read mode (after closing the file),
	7796	or <b>nil</b> plus an error message if none succeeds.
	7797	(This error message lists all file names it tried to open.)
	7798
	7799
	7800
	7801
	7802
	7803
	7804
	7805	<h2>6.4 – <a name="6.4">String Manipulation</a></h2>
	7806
	7807	<p>
	7808	This library provides generic functions for string manipulation,
	7809	such as finding and extracting substrings, and pattern matching.
	7810	When indexing a string in Lua, the first character is at position 1
	7811	(not at 0, as in C).
	7812	Indices are allowed to be negative and are interpreted as indexing backwards,
	7813	from the end of the string.
	7814	Thus, the last character is at position -1, and so on.
	7815
	7816
	7817	<p>
	7818	The string library provides all its functions inside the table
	7819	<a name="pdf-string"><code>string</code></a>.
	7820	It also sets a metatable for strings
	7821	where the <code>__index</code> field points to the <code>string</code> table.
	7822	Therefore, you can use the string functions in object-oriented style.
	7823	For instance, <code>string.byte(s,i)</code>
	7824	can be written as <code>s:byte(i)</code>.
	7825
	7826
	7827	<p>
	7828	The string library assumes one-byte character encodings.
	7829
	7830
	7831	<p>
	7832	<hr><h3><a name="pdf-string.byte"><code>string.byte (s [, i [, j]])</code></a></h3>
	7833	Returns the internal numerical codes of the characters <code>s[i]</code>,
	7834	<code>s[i+1]</code>, ..., <code>s[j]</code>.
	7835	The default value for <code>i</code> is 1;
	7836	the default value for <code>j</code> is <code>i</code>.
	7837	These indices are corrected
	7838	following the same rules of function <a href="#pdf-string.sub"><code>string.sub</code></a>.
	7839
	7840
	7841	<p>
	7842	Numerical codes are not necessarily portable across platforms.
	7843
	7844
	7845
	7846
	7847	<p>
	7848	<hr><h3><a name="pdf-string.char"><code>string.char (···)</code></a></h3>
	7849	Receives zero or more integers.
	7850	Returns a string with length equal to the number of arguments,
	7851	in which each character has the internal numerical code equal
	7852	to its corresponding argument.
	7853
	7854
	7855	<p>
	7856	Numerical codes are not necessarily portable across platforms.
	7857
	7858
	7859
	7860
	7861	<p>
	7862	<hr><h3><a name="pdf-string.dump"><code>string.dump (function)</code></a></h3>
	7863
	7864
	7865	<p>
	7866	Returns a string containing a binary representation of the given function,
	7867	so that a later <a href="#pdf-load"><code>load</code></a> on this string returns
	7868	a copy of the function (but with new upvalues).
	7869
	7870
	7871
	7872
	7873	<p>
	7874	<hr><h3><a name="pdf-string.find"><code>string.find (s, pattern [, init [, plain]])</code></a></h3>
	7875
	7876
	7877	<p>
	7878	Looks for the first match of
	7879	<code>pattern</code> in the string <code>s</code>.
	7880	If it finds a match, then <code>find</code> returns the indices of <code>s</code>
	7881	where this occurrence starts and ends;
	7882	otherwise, it returns <b>nil</b>.
	7883	A third, optional numerical argument <code>init</code> specifies
	7884	where to start the search;
	7885	its default value is 1 and can be negative.
	7886	A value of <b>true</b> as a fourth, optional argument <code>plain</code>
	7887	turns off the pattern matching facilities,
	7888	so the function does a plain "find substring" operation,
	7889	with no characters in <code>pattern</code> being considered magic.
	7890	Note that if <code>plain</code> is given, then <code>init</code> must be given as well.
	7891
	7892
	7893	<p>
	7894	If the pattern has captures,
	7895	then in a successful match
	7896	the captured values are also returned,
	7897	after the two indices.
	7898
	7899
	7900
	7901
	7902	<p>
	7903	<hr><h3><a name="pdf-string.format"><code>string.format (formatstring, ···)</code></a></h3>
	7904
	7905
	7906	<p>
	7907	Returns a formatted version of its variable number of arguments
	7908	following the description given in its first argument (which must be a string).
	7909	The format string follows the same rules as the ANSI C function <code>sprintf</code>.
	7910	The only differences are that the options/modifiers
	7911	<code>*</code>, <code>h</code>, <code>L</code>, <code>l</code>, <code>n</code>,
	7912	and <code>p</code> are not supported
	7913	and that there is an extra option, <code>q</code>.
	7914	The <code>q</code> option formats a string between double quotes,
	7915	using escape sequences when necessary to ensure that
	7916	it can safely be read back by the Lua interpreter.
	7917	For instance, the call
	7918
	7919	<pre>
	7920	string.format('%q', 'a string with "quotes" and \n new line')
	7921	</pre><p>
	7922	may produce the string:
	7923
	7924	<pre>
	7925	"a string with \"quotes\" and \
	7926	new line"
	7927	</pre>
	7928
	7929	<p>
	7930	Options
	7931	<code>A</code> and <code>a</code> (when available),
	7932	<code>E</code>, <code>e</code>, <code>f</code>,
	7933	<code>G</code>, and <code>g</code> all expect a number as argument.
	7934	Options <code>c</code>, <code>d</code>,
	7935	<code>i</code>, <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code>
	7936	also expect a number,
	7937	but the range of that number may be limited by
	7938	the underlying C implementation.
	7939	For options <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code>,
	7940	the number cannot be negative.
	7941	Option <code>q</code> expects a string;
	7942	option <code>s</code> expects a string without embedded zeros.
	7943	If the argument to option <code>s</code> is not a string,
	7944	it is converted to one following the same rules of <a href="#pdf-tostring"><code>tostring</code></a>.
	7945
	7946
	7947
	7948
	7949	<p>
	7950	<hr><h3><a name="pdf-string.gmatch"><code>string.gmatch (s, pattern)</code></a></h3>
	7951	Returns an iterator function that,
	7952	each time it is called,
	7953	returns the next captures from <code>pattern</code> over the string <code>s</code>.
	7954	If <code>pattern</code> specifies no captures,
	7955	then the whole match is produced in each call.
	7956
	7957
	7958	<p>
	7959	As an example, the following loop
	7960	will iterate over all the words from string <code>s</code>,
	7961	printing one per line:
	7962
	7963	<pre>
	7964	s = "hello world from Lua"
	7965	for w in string.gmatch(s, "%a+") do
	7966	print(w)
	7967	end
	7968	</pre><p>
	7969	The next example collects all pairs <code>key=value</code> from the
	7970	given string into a table:
	7971
	7972	<pre>
	7973	t = {}
	7974	s = "from=world, to=Lua"
	7975	for k, v in string.gmatch(s, "(%w+)=(%w+)") do
	7976	t[k] = v
	7977	end
	7978	</pre>
	7979
	7980	<p>
	7981	For this function, a caret '<code>^</code>' at the start of a pattern does not
	7982	work as an anchor, as this would prevent the iteration.
	7983
	7984
	7985
	7986
	7987	<p>
	7988	<hr><h3><a name="pdf-string.gsub"><code>string.gsub (s, pattern, repl [, n])</code></a></h3>
	7989	Returns a copy of <code>s</code>
	7990	in which all (or the first <code>n</code>, if given)
	7991	occurrences of the <code>pattern</code> have been
	7992	replaced by a replacement string specified by <code>repl</code>,
	7993	which can be a string, a table, or a function.
	7994	<code>gsub</code> also returns, as its second value,
	7995	the total number of matches that occurred.
	7996	The name <code>gsub</code> comes from <em>Global SUBstitution</em>.
	7997
	7998
	7999	<p>
	8000	If <code>repl</code> is a string, then its value is used for replacement.
	8001	The character <code>%</code> works as an escape character:
	8002	any sequence in <code>repl</code> of the form <code>%<em>d</em></code>,
	8003	with <em>d</em> between 1 and 9,
	8004	stands for the value of the <em>d</em>-th captured substring.
	8005	The sequence <code>%0</code> stands for the whole match.
	8006	The sequence <code>%%</code> stands for a single <code>%</code>.
	8007
	8008
	8009	<p>
	8010	If <code>repl</code> is a table, then the table is queried for every match,
	8011	using the first capture as the key.
	8012
	8013
	8014	<p>
	8015	If <code>repl</code> is a function, then this function is called every time a
	8016	match occurs, with all captured substrings passed as arguments,
	8017	in order.
	8018
	8019
	8020	<p>
	8021	In any case,
	8022	if the pattern specifies no captures,
	8023	then it behaves as if the whole pattern was inside a capture.
	8024
	8025
	8026	<p>
	8027	If the value returned by the table query or by the function call
	8028	is a string or a number,
	8029	then it is used as the replacement string;
	8030	otherwise, if it is <b>false</b> or <b>nil</b>,
	8031	then there is no replacement
	8032	(that is, the original match is kept in the string).
	8033
	8034
	8035	<p>
	8036	Here are some examples:
	8037
	8038	<pre>
	8039	x = string.gsub("hello world", "(%w+)", "%1 %1")
	8040	--> x="hello hello world world"
	8041
	8042	x = string.gsub("hello world", "%w+", "%0 %0", 1)
	8043	--> x="hello hello world"
	8044
	8045	x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
	8046	--> x="world hello Lua from"
	8047
	8048	x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
	8049	--> x="home = /home/roberto, user = roberto"
	8050
	8051	x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
	8052	return load(s)()
	8053	end)
	8054	--> x="4+5 = 9"
	8055
	8056	local t = {name="lua", version="5.2"}
	8057	x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
	8058	--> x="lua-5.2.tar.gz"
	8059	</pre>
	8060
	8061
	8062
	8063	<p>
	8064	<hr><h3><a name="pdf-string.len"><code>string.len (s)</code></a></h3>
	8065	Receives a string and returns its length.
	8066	The empty string <code>""</code> has length 0.
	8067	Embedded zeros are counted,
	8068	so <code>"a\000bc\000"</code> has length 5.
	8069
	8070
	8071
	8072
	8073	<p>
	8074	<hr><h3><a name="pdf-string.lower"><code>string.lower (s)</code></a></h3>
	8075	Receives a string and returns a copy of this string with all
	8076	uppercase letters changed to lowercase.
	8077	All other characters are left unchanged.
	8078	The definition of what an uppercase letter is depends on the current locale.
	8079
	8080
	8081
	8082
	8083	<p>
	8084	<hr><h3><a name="pdf-string.match"><code>string.match (s, pattern [, init])</code></a></h3>
	8085	Looks for the first <em>match</em> of
	8086	<code>pattern</code> in the string <code>s</code>.
	8087	If it finds one, then <code>match</code> returns
	8088	the captures from the pattern;
	8089	otherwise it returns <b>nil</b>.
	8090	If <code>pattern</code> specifies no captures,
	8091	then the whole match is returned.
	8092	A third, optional numerical argument <code>init</code> specifies
	8093	where to start the search;
	8094	its default value is 1 and can be negative.
	8095
	8096
	8097
	8098
	8099	<p>
	8100	<hr><h3><a name="pdf-string.rep"><code>string.rep (s, n [, sep])</code></a></h3>
	8101	Returns a string that is the concatenation of <code>n</code> copies of
	8102	the string <code>s</code> separated by the string <code>sep</code>.
	8103	The default value for <code>sep</code> is the empty string
	8104	(that is, no separator).
	8105
	8106
	8107
	8108
	8109	<p>
	8110	<hr><h3><a name="pdf-string.reverse"><code>string.reverse (s)</code></a></h3>
	8111	Returns a string that is the string <code>s</code> reversed.
	8112
	8113
	8114
	8115
	8116	<p>
	8117	<hr><h3><a name="pdf-string.sub"><code>string.sub (s, i [, j])</code></a></h3>
	8118	Returns the substring of <code>s</code> that
	8119	starts at <code>i</code> and continues until <code>j</code>;
	8120	<code>i</code> and <code>j</code> can be negative.
	8121	If <code>j</code> is absent, then it is assumed to be equal to -1
	8122	(which is the same as the string length).
	8123	In particular,
	8124	the call <code>string.sub(s,1,j)</code> returns a prefix of <code>s</code>
	8125	with length <code>j</code>,
	8126	and <code>string.sub(s, -i)</code> returns a suffix of <code>s</code>
	8127	with length <code>i</code>.
	8128
	8129
	8130	<p>
	8131	If, after the translation of negative indices,
	8132	<code>i</code> is less than 1,
	8133	it is corrected to 1.
	8134	If <code>j</code> is greater than the string length,
	8135	it is corrected to that length.
	8136	If, after these corrections,
	8137	<code>i</code> is greater than <code>j</code>,
	8138	the function returns the empty string.
	8139
	8140
	8141
	8142
	8143	<p>
	8144	<hr><h3><a name="pdf-string.upper"><code>string.upper (s)</code></a></h3>
	8145	Receives a string and returns a copy of this string with all
	8146	lowercase letters changed to uppercase.
	8147	All other characters are left unchanged.
	8148	The definition of what a lowercase letter is depends on the current locale.
	8149
	8150
	8151
	8152	<h3>6.4.1 – <a name="6.4.1">Patterns</a></h3>
	8153
	8154
	8155	<h4>Character Class:</h4><p>
	8156	A <em>character class</em> is used to represent a set of characters.
	8157	The following combinations are allowed in describing a character class:
	8158
	8159	<ul>
	8160
	8161	<li><b><em>x</em>: </b>
	8162	(where <em>x</em> is not one of the <em>magic characters</em>
	8163	<code>^$()%.[]*+-?</code>)
	8164	represents the character <em>x</em> itself.
	8165	</li>
	8166
	8167	<li><b><code>.</code>: </b> (a dot) represents all characters.</li>
	8168
	8169	<li><b><code>%a</code>: </b> represents all letters.</li>
	8170
	8171	<li><b><code>%c</code>: </b> represents all control characters.</li>
	8172
	8173	<li><b><code>%d</code>: </b> represents all digits.</li>
	8174
	8175	<li><b><code>%g</code>: </b> represents all printable characters except space.</li>
	8176
	8177	<li><b><code>%l</code>: </b> represents all lowercase letters.</li>
	8178
	8179	<li><b><code>%p</code>: </b> represents all punctuation characters.</li>
	8180
	8181	<li><b><code>%s</code>: </b> represents all space characters.</li>
	8182
	8183	<li><b><code>%u</code>: </b> represents all uppercase letters.</li>
	8184
	8185	<li><b><code>%w</code>: </b> represents all alphanumeric characters.</li>
	8186
	8187	<li><b><code>%x</code>: </b> represents all hexadecimal digits.</li>
	8188
	8189	<li><b><code>%<em>x</em></code>: </b> (where <em>x</em> is any non-alphanumeric character)
	8190	represents the character <em>x</em>.
	8191	This is the standard way to escape the magic characters.
	8192	Any punctuation character (even the non magic)
	8193	can be preceded by a '<code>%</code>'
	8194	when used to represent itself in a pattern.
	8195	</li>
	8196
	8197	<li><b><code>[<em>set</em>]</code>: </b>
	8198	represents the class which is the union of all
	8199	characters in <em>set</em>.
	8200	A range of characters can be specified by
	8201	separating the end characters of the range,
	8202	in ascending order, with a '<code>-</code>',
	8203	All classes <code>%</code><em>x</em> described above can also be used as
	8204	components in <em>set</em>.
	8205	All other characters in <em>set</em> represent themselves.
	8206	For example, <code>[%w_]</code> (or <code>[_%w]</code>)
	8207	represents all alphanumeric characters plus the underscore,
	8208	<code>[0-7]</code> represents the octal digits,
	8209	and <code>[0-7%l%-]</code> represents the octal digits plus
	8210	the lowercase letters plus the '<code>-</code>' character.
	8211
	8212
	8213	<p>
	8214	The interaction between ranges and classes is not defined.
	8215	Therefore, patterns like <code>[%a-z]</code> or <code>[a-%%]</code>
	8216	have no meaning.
	8217	</li>
	8218
	8219	<li><b><code>[^<em>set</em>]</code>: </b>
	8220	represents the complement of <em>set</em>,
	8221	where <em>set</em> is interpreted as above.
	8222	</li>
	8223
	8224	</ul><p>
	8225	For all classes represented by single letters (<code>%a</code>, <code>%c</code>, etc.),
	8226	the corresponding uppercase letter represents the complement of the class.
	8227	For instance, <code>%S</code> represents all non-space characters.
	8228
	8229
	8230	<p>
	8231	The definitions of letter, space, and other character groups
	8232	depend on the current locale.
	8233	In particular, the class <code>[a-z]</code> may not be equivalent to <code>%l</code>.
	8234
	8235
	8236
	8237
	8238
	8239	<h4>Pattern Item:</h4><p>
	8240	A <em>pattern item</em> can be
	8241
	8242	<ul>
	8243
	8244	<li>
	8245	a single character class,
	8246	which matches any single character in the class;
	8247	</li>
	8248
	8249	<li>
	8250	a single character class followed by '<code>*</code>',
	8251	which matches 0 or more repetitions of characters in the class.
	8252	These repetition items will always match the longest possible sequence;
	8253	</li>
	8254
	8255	<li>
	8256	a single character class followed by '<code>+</code>',
	8257	which matches 1 or more repetitions of characters in the class.
	8258	These repetition items will always match the longest possible sequence;
	8259	</li>
	8260
	8261	<li>
	8262	a single character class followed by '<code>-</code>',
	8263	which also matches 0 or more repetitions of characters in the class.
	8264	Unlike '<code>*</code>',
	8265	these repetition items will always match the shortest possible sequence;
	8266	</li>
	8267
	8268	<li>
	8269	a single character class followed by '<code>?</code>',
	8270	which matches 0 or 1 occurrence of a character in the class;
	8271	</li>
	8272
	8273	<li>
	8274	<code>%<em>n</em></code>, for <em>n</em> between 1 and 9;
	8275	such item matches a substring equal to the <em>n</em>-th captured string
	8276	(see below);
	8277	</li>
	8278
	8279	<li>
	8280	<code>%b<em>xy</em></code>, where <em>x</em> and <em>y</em> are two distinct characters;
	8281	such item matches strings that start with <em>x</em>, end with <em>y</em>,
	8282	and where the <em>x</em> and <em>y</em> are <em>balanced</em>.
	8283	This means that, if one reads the string from left to right,
	8284	counting <em>+1</em> for an <em>x</em> and <em>-1</em> for a <em>y</em>,
	8285	the ending <em>y</em> is the first <em>y</em> where the count reaches 0.
	8286	For instance, the item <code>%b()</code> matches expressions with
	8287	balanced parentheses.
	8288	</li>
	8289
	8290	<li>
	8291	<code>%f[<em>set</em>]</code>, a <em>frontier pattern</em>;
	8292	such item matches an empty string at any position such that
	8293	the next character belongs to <em>set</em>
	8294	and the previous character does not belong to <em>set</em>.
	8295	The set <em>set</em> is interpreted as previously described.
	8296	The beginning and the end of the subject are handled as if
	8297	they were the character '<code>\0</code>'.
	8298	</li>
	8299
	8300	</ul>
	8301
	8302
	8303
	8304
	8305	<h4>Pattern:</h4><p>
	8306	A <em>pattern</em> is a sequence of pattern items.
	8307	A caret '<code>^</code>' at the beginning of a pattern anchors the match at the
	8308	beginning of the subject string.
	8309	A '<code>$</code>' at the end of a pattern anchors the match at the
	8310	end of the subject string.
	8311	At other positions,
	8312	'<code>^</code>' and '<code>$</code>' have no special meaning and represent themselves.
	8313
	8314
	8315
	8316
	8317
	8318	<h4>Captures:</h4><p>
	8319	A pattern can contain sub-patterns enclosed in parentheses;
	8320	they describe <em>captures</em>.
	8321	When a match succeeds, the substrings of the subject string
	8322	that match captures are stored (<em>captured</em>) for future use.
	8323	Captures are numbered according to their left parentheses.
	8324	For instance, in the pattern <code>"(a(.)%w(%s))"</code>,
	8325	the part of the string matching <code>"a(.)%w(%s)"</code> is
	8326	stored as the first capture (and therefore has number 1);
	8327	the character matching "<code>.</code>" is captured with number 2,
	8328	and the part matching "<code>%s*</code>" has number 3.
	8329
	8330
	8331	<p>
	8332	As a special case, the empty capture <code>()</code> captures
	8333	the current string position (a number).
	8334	For instance, if we apply the pattern <code>"()aa()"</code> on the
	8335	string <code>"flaaap"</code>, there will be two captures: 3 and 5.
	8336
	8337
	8338
	8339
	8340
	8341
	8342
	8343
	8344
	8345
	8346
	8347	<h2>6.5 – <a name="6.5">Table Manipulation</a></h2>
	8348
	8349	<p>
	8350	This library provides generic functions for table manipulation.
	8351	It provides all its functions inside the table <a name="pdf-table"><code>table</code></a>.
	8352
	8353
	8354	<p>
	8355	Remember that, whenever an operation needs the length of a table,
	8356	the table should be a proper sequence
	8357	or have a <code>__len</code> metamethod (see <a href="#3.4.6">§3.4.6</a>).
	8358	All functions ignore non-numeric keys
	8359	in tables given as arguments.
	8360
	8361
	8362	<p>
	8363	For performance reasons,
	8364	all table accesses (get/set) performed by these functions are raw.
	8365
	8366
	8367	<p>
	8368	<hr><h3><a name="pdf-table.concat"><code>table.concat (list [, sep [, i [, j]]])</code></a></h3>
	8369
	8370
	8371	<p>
	8372	Given a list where all elements are strings or numbers,
	8373	returns the string <code>list[i]..sep..list[i+1] ··· sep..list[j]</code>.
	8374	The default value for <code>sep</code> is the empty string,
	8375	the default for <code>i</code> is 1,
	8376	and the default for <code>j</code> is <code>#list</code>.
	8377	If <code>i</code> is greater than <code>j</code>, returns the empty string.
	8378
	8379
	8380
	8381
	8382	<p>
	8383	<hr><h3><a name="pdf-table.insert"><code>table.insert (list, [pos,] value)</code></a></h3>
	8384
	8385
	8386	<p>
	8387	Inserts element <code>value</code> at position <code>pos</code> in <code>list</code>,
	8388	shifting up the elements
	8389	<code>list[pos], list[pos+1], ···, list[#list]</code>.
	8390	The default value for <code>pos</code> is <code>#list+1</code>,
	8391	so that a call <code>table.insert(t,x)</code> inserts <code>x</code> at the end
	8392	of list <code>t</code>.
	8393
	8394
	8395
	8396
	8397	<p>
	8398	<hr><h3><a name="pdf-table.pack"><code>table.pack (···)</code></a></h3>
	8399
	8400
	8401	<p>
	8402	Returns a new table with all parameters stored into keys 1, 2, etc.
	8403	and with a field "<code>n</code>" with the total number of parameters.
	8404	Note that the resulting table may not be a sequence.
	8405
	8406
	8407
	8408
	8409	<p>
	8410	<hr><h3><a name="pdf-table.remove"><code>table.remove (list [, pos])</code></a></h3>
	8411
	8412
	8413	<p>
	8414	Removes from <code>list</code> the element at position <code>pos</code>,
	8415	returning the value of the removed element.
	8416	When <code>pos</code> is an integer between 1 and <code>#list</code>,
	8417	it shifts down the elements
	8418	<code>list[pos+1], list[pos+2], ···, list[#list]</code>
	8419	and erases element <code>list[#list]</code>;
	8420	The index <code>pos</code> can also be 0 when <code>#list</code> is 0,
	8421	or <code>#list + 1</code>;
	8422	in those cases, the function erases the element <code>list[pos]</code>.
	8423
	8424
	8425	<p>
	8426	The default value for <code>pos</code> is <code>#list</code>,
	8427	so that a call <code>table.remove(t)</code> removes the last element
	8428	of list <code>t</code>.
	8429
	8430
	8431
	8432
	8433	<p>
	8434	<hr><h3><a name="pdf-table.sort"><code>table.sort (list [, comp])</code></a></h3>
	8435
	8436
	8437	<p>
	8438	Sorts list elements in a given order, <em>in-place</em>,
	8439	from <code>list[1]</code> to <code>list[#list]</code>.
	8440	If <code>comp</code> is given,
	8441	then it must be a function that receives two list elements
	8442	and returns true when the first element must come
	8443	before the second in the final order
	8444	(so that <code>not comp(list[i+1],list[i])</code> will be true after the sort).
	8445	If <code>comp</code> is not given,
	8446	then the standard Lua operator <code><</code> is used instead.
	8447
	8448
	8449	<p>
	8450	The sort algorithm is not stable;
	8451	that is, elements considered equal by the given order
	8452	may have their relative positions changed by the sort.
	8453
	8454
	8455
	8456
	8457	<p>
	8458	<hr><h3><a name="pdf-table.unpack"><code>table.unpack (list [, i [, j]])</code></a></h3>
	8459
	8460
	8461	<p>
	8462	Returns the elements from the given table.
	8463	This function is equivalent to
	8464
	8465	<pre>
	8466	return list[i], list[i+1], ···, list[j]
	8467	</pre><p>
	8468	By default, <code>i</code> is 1 and <code>j</code> is <code>#list</code>.
	8469
	8470
	8471
	8472
	8473
	8474
	8475
	8476	<h2>6.6 – <a name="6.6">Mathematical Functions</a></h2>
	8477
	8478	<p>
	8479	This library is an interface to the standard C math library.
	8480	It provides all its functions inside the table <a name="pdf-math"><code>math</code></a>.
	8481
	8482
	8483	<p>
	8484	<hr><h3><a name="pdf-math.abs"><code>math.abs (x)</code></a></h3>
	8485
	8486
	8487	<p>
	8488	Returns the absolute value of <code>x</code>.
	8489
	8490
	8491
	8492
	8493	<p>
	8494	<hr><h3><a name="pdf-math.acos"><code>math.acos (x)</code></a></h3>
	8495
	8496
	8497	<p>
	8498	Returns the arc cosine of <code>x</code> (in radians).
	8499
	8500
	8501
	8502
	8503	<p>
	8504	<hr><h3><a name="pdf-math.asin"><code>math.asin (x)</code></a></h3>
	8505
	8506
	8507	<p>
	8508	Returns the arc sine of <code>x</code> (in radians).
	8509
	8510
	8511
	8512
	8513	<p>
	8514	<hr><h3><a name="pdf-math.atan"><code>math.atan (x)</code></a></h3>
	8515
	8516
	8517	<p>
	8518	Returns the arc tangent of <code>x</code> (in radians).
	8519
	8520
	8521
	8522
	8523	<p>
	8524	<hr><h3><a name="pdf-math.atan2"><code>math.atan2 (y, x)</code></a></h3>
	8525
	8526
	8527	<p>
	8528	Returns the arc tangent of <code>y/x</code> (in radians),
	8529	but uses the signs of both parameters to find the
	8530	quadrant of the result.
	8531	(It also handles correctly the case of <code>x</code> being zero.)
	8532
	8533
	8534
	8535
	8536	<p>
	8537	<hr><h3><a name="pdf-math.ceil"><code>math.ceil (x)</code></a></h3>
	8538
	8539
	8540	<p>
	8541	Returns the smallest integer larger than or equal to <code>x</code>.
	8542
	8543
	8544
	8545
	8546	<p>
	8547	<hr><h3><a name="pdf-math.cos"><code>math.cos (x)</code></a></h3>
	8548
	8549
	8550	<p>
	8551	Returns the cosine of <code>x</code> (assumed to be in radians).
	8552
	8553
	8554
	8555
	8556	<p>
	8557	<hr><h3><a name="pdf-math.cosh"><code>math.cosh (x)</code></a></h3>
	8558
	8559
	8560	<p>
	8561	Returns the hyperbolic cosine of <code>x</code>.
	8562
	8563
	8564
	8565
	8566	<p>
	8567	<hr><h3><a name="pdf-math.deg"><code>math.deg (x)</code></a></h3>
	8568
	8569
	8570	<p>
	8571	Returns the angle <code>x</code> (given in radians) in degrees.
	8572
	8573
	8574
	8575
	8576	<p>
	8577	<hr><h3><a name="pdf-math.exp"><code>math.exp (x)</code></a></h3>
	8578
	8579
	8580	<p>
	8581	Returns the value <em>e<sup>x</sup></em>.
	8582
	8583
	8584
	8585
	8586	<p>
	8587	<hr><h3><a name="pdf-math.floor"><code>math.floor (x)</code></a></h3>
	8588
	8589
	8590	<p>
	8591	Returns the largest integer smaller than or equal to <code>x</code>.
	8592
	8593
	8594
	8595
	8596	<p>
	8597	<hr><h3><a name="pdf-math.fmod"><code>math.fmod (x, y)</code></a></h3>
	8598
	8599
	8600	<p>
	8601	Returns the remainder of the division of <code>x</code> by <code>y</code>
	8602	that rounds the quotient towards zero.
	8603
	8604
	8605
	8606
	8607	<p>
	8608	<hr><h3><a name="pdf-math.frexp"><code>math.frexp (x)</code></a></h3>
	8609
	8610
	8611	<p>
	8612	Returns <code>m</code> and <code>e</code> such that <em>x = m2<sup>e</sup></em>,
	8613	<code>e</code> is an integer and the absolute value of <code>m</code> is
	8614	in the range <em>[0.5, 1)</em>
	8615	(or zero when <code>x</code> is zero).
	8616
	8617
	8618
	8619
	8620	<p>
	8621	<hr><h3><a name="pdf-math.huge"><code>math.huge</code></a></h3>
	8622
	8623
	8624	<p>
	8625	The value <code>HUGE_VAL</code>,
	8626	a value larger than or equal to any other numerical value.
	8627
	8628
	8629
	8630
	8631	<p>
	8632	<hr><h3><a name="pdf-math.ldexp"><code>math.ldexp (m, e)</code></a></h3>
	8633
	8634
	8635	<p>
	8636	Returns <em>m2<sup>e</sup></em> (<code>e</code> should be an integer).
	8637
	8638
	8639
	8640
	8641	<p>
	8642	<hr><h3><a name="pdf-math.log"><code>math.log (x [, base])</code></a></h3>
	8643
	8644
	8645	<p>
	8646	Returns the logarithm of <code>x</code> in the given base.
	8647	The default for <code>base</code> is <em>e</em>
	8648	(so that the function returns the natural logarithm of <code>x</code>).
	8649
	8650
	8651
	8652
	8653	<p>
	8654	<hr><h3><a name="pdf-math.max"><code>math.max (x, ···)</code></a></h3>
	8655
	8656
	8657	<p>
	8658	Returns the maximum value among its arguments.
	8659
	8660
	8661
	8662
	8663	<p>
	8664	<hr><h3><a name="pdf-math.min"><code>math.min (x, ···)</code></a></h3>
	8665
	8666
	8667	<p>
	8668	Returns the minimum value among its arguments.
	8669
	8670
	8671
	8672
	8673	<p>
	8674	<hr><h3><a name="pdf-math.modf"><code>math.modf (x)</code></a></h3>
	8675
	8676
	8677	<p>
	8678	Returns two numbers,
	8679	the integral part of <code>x</code> and the fractional part of <code>x</code>.
	8680
	8681
	8682
	8683
	8684	<p>
	8685	<hr><h3><a name="pdf-math.pi"><code>math.pi</code></a></h3>
	8686
	8687
	8688	<p>
	8689	The value of <em>π</em>.
	8690
	8691
	8692
	8693
	8694	<p>
	8695	<hr><h3><a name="pdf-math.pow"><code>math.pow (x, y)</code></a></h3>
	8696
	8697
	8698	<p>
	8699	Returns <em>x<sup>y</sup></em>.
	8700	(You can also use the expression <code>x^y</code> to compute this value.)
	8701
	8702
	8703
	8704
	8705	<p>
	8706	<hr><h3><a name="pdf-math.rad"><code>math.rad (x)</code></a></h3>
	8707
	8708
	8709	<p>
	8710	Returns the angle <code>x</code> (given in degrees) in radians.
	8711
	8712
	8713
	8714
	8715	<p>
	8716	<hr><h3><a name="pdf-math.random"><code>math.random ([m [, n]])</code></a></h3>
	8717
	8718
	8719	<p>
	8720	This function is an interface to the simple
	8721	pseudo-random generator function <code>rand</code> provided by Standard C.
	8722	(No guarantees can be given for its statistical properties.)
	8723
	8724
	8725	<p>
	8726	When called without arguments,
	8727	returns a uniform pseudo-random real number
	8728	in the range <em>[0,1)</em>.
	8729	When called with an integer number <code>m</code>,
	8730	<code>math.random</code> returns
	8731	a uniform pseudo-random integer in the range <em>[1, m]</em>.
	8732	When called with two integer numbers <code>m</code> and <code>n</code>,
	8733	<code>math.random</code> returns a uniform pseudo-random
	8734	integer in the range <em>[m, n]</em>.
	8735
	8736
	8737
	8738
	8739	<p>
	8740	<hr><h3><a name="pdf-math.randomseed"><code>math.randomseed (x)</code></a></h3>
	8741
	8742
	8743	<p>
	8744	Sets <code>x</code> as the "seed"
	8745	for the pseudo-random generator:
	8746	equal seeds produce equal sequences of numbers.
	8747
	8748
	8749
	8750
	8751	<p>
	8752	<hr><h3><a name="pdf-math.sin"><code>math.sin (x)</code></a></h3>
	8753
	8754
	8755	<p>
	8756	Returns the sine of <code>x</code> (assumed to be in radians).
	8757
	8758
	8759
	8760
	8761	<p>
	8762	<hr><h3><a name="pdf-math.sinh"><code>math.sinh (x)</code></a></h3>
	8763
	8764
	8765	<p>
	8766	Returns the hyperbolic sine of <code>x</code>.
	8767
	8768
	8769
	8770
	8771	<p>
	8772	<hr><h3><a name="pdf-math.sqrt"><code>math.sqrt (x)</code></a></h3>
	8773
	8774
	8775	<p>
	8776	Returns the square root of <code>x</code>.
	8777	(You can also use the expression <code>x^0.5</code> to compute this value.)
	8778
	8779
	8780
	8781
	8782	<p>
	8783	<hr><h3><a name="pdf-math.tan"><code>math.tan (x)</code></a></h3>
	8784
	8785
	8786	<p>
	8787	Returns the tangent of <code>x</code> (assumed to be in radians).
	8788
	8789
	8790
	8791
	8792	<p>
	8793	<hr><h3><a name="pdf-math.tanh"><code>math.tanh (x)</code></a></h3>
	8794
	8795
	8796	<p>
	8797	Returns the hyperbolic tangent of <code>x</code>.
	8798
	8799
	8800
	8801
	8802
	8803
	8804
	8805	<h2>6.7 – <a name="6.7">Bitwise Operations</a></h2>
	8806
	8807	<p>
	8808	This library provides bitwise operations.
	8809	It provides all its functions inside the table <a name="pdf-bit32"><code>bit32</code></a>.
	8810
	8811
	8812	<p>
	8813	Unless otherwise stated,
	8814	all functions accept numeric arguments in the range
	8815	<em>(-2<sup>51</sup>,+2<sup>51</sup>)</em>;
	8816	each argument is normalized to
	8817	the remainder of its division by <em>2<sup>32</sup></em>
	8818	and truncated to an integer (in some unspecified way),
	8819	so that its final value falls in the range <em>[0,2<sup>32</sup> - 1]</em>.
	8820	Similarly, all results are in the range <em>[0,2<sup>32</sup> - 1]</em>.
	8821	Note that <code>bit32.bnot(0)</code> is <code>0xFFFFFFFF</code>,
	8822	which is different from <code>-1</code>.
	8823
	8824
	8825	<p>
	8826	<hr><h3><a name="pdf-bit32.arshift"><code>bit32.arshift (x, disp)</code></a></h3>
	8827
	8828
	8829	<p>
	8830	Returns the number <code>x</code> shifted <code>disp</code> bits to the right.
	8831	The number <code>disp</code> may be any representable integer.
	8832	Negative displacements shift to the left.
	8833
	8834
	8835	<p>
	8836	This shift operation is what is called arithmetic shift.
	8837	Vacant bits on the left are filled
	8838	with copies of the higher bit of <code>x</code>;
	8839	vacant bits on the right are filled with zeros.
	8840	In particular,
	8841	displacements with absolute values higher than 31
	8842	result in zero or <code>0xFFFFFFFF</code> (all original bits are shifted out).
	8843
	8844
	8845
	8846
	8847	<p>
	8848	<hr><h3><a name="pdf-bit32.band"><code>bit32.band (···)</code></a></h3>
	8849
	8850
	8851	<p>
	8852	Returns the bitwise <em>and</em> of its operands.
	8853
	8854
	8855
	8856
	8857	<p>
	8858	<hr><h3><a name="pdf-bit32.bnot"><code>bit32.bnot (x)</code></a></h3>
	8859
	8860
	8861	<p>
	8862	Returns the bitwise negation of <code>x</code>.
	8863	For any integer <code>x</code>,
	8864	the following identity holds:
	8865
	8866	<pre>
	8867	assert(bit32.bnot(x) == (-1 - x) % 2^32)
	8868	</pre>
	8869
	8870
	8871
	8872	<p>
	8873	<hr><h3><a name="pdf-bit32.bor"><code>bit32.bor (···)</code></a></h3>
	8874
	8875
	8876	<p>
	8877	Returns the bitwise <em>or</em> of its operands.
	8878
	8879
	8880
	8881
	8882	<p>
	8883	<hr><h3><a name="pdf-bit32.btest"><code>bit32.btest (···)</code></a></h3>
	8884
	8885
	8886	<p>
	8887	Returns a boolean signaling
	8888	whether the bitwise <em>and</em> of its operands is different from zero.
	8889
	8890
	8891
	8892
	8893	<p>
	8894	<hr><h3><a name="pdf-bit32.bxor"><code>bit32.bxor (···)</code></a></h3>
	8895
	8896
	8897	<p>
	8898	Returns the bitwise <em>exclusive or</em> of its operands.
	8899
	8900
	8901
	8902
	8903	<p>
	8904	<hr><h3><a name="pdf-bit32.extract"><code>bit32.extract (n, field [, width])</code></a></h3>
	8905
	8906
	8907	<p>
	8908	Returns the unsigned number formed by the bits
	8909	<code>field</code> to <code>field + width - 1</code> from <code>n</code>.
	8910	Bits are numbered from 0 (least significant) to 31 (most significant).
	8911	All accessed bits must be in the range <em>[0, 31]</em>.
	8912
	8913
	8914	<p>
	8915	The default for <code>width</code> is 1.
	8916
	8917
	8918
	8919
	8920	<p>
	8921	<hr><h3><a name="pdf-bit32.replace"><code>bit32.replace (n, v, field [, width])</code></a></h3>
	8922
	8923
	8924	<p>
	8925	Returns a copy of <code>n</code> with
	8926	the bits <code>field</code> to <code>field + width - 1</code>
	8927	replaced by the value <code>v</code>.
	8928	See <a href="#pdf-bit32.extract"><code>bit32.extract</code></a> for details about <code>field</code> and <code>width</code>.
	8929
	8930
	8931
	8932
	8933	<p>
	8934	<hr><h3><a name="pdf-bit32.lrotate"><code>bit32.lrotate (x, disp)</code></a></h3>
	8935
	8936
	8937	<p>
	8938	Returns the number <code>x</code> rotated <code>disp</code> bits to the left.
	8939	The number <code>disp</code> may be any representable integer.
	8940
	8941
	8942	<p>
	8943	For any valid displacement,
	8944	the following identity holds:
	8945
	8946	<pre>
	8947	assert(bit32.lrotate(x, disp) == bit32.lrotate(x, disp % 32))
	8948	</pre><p>
	8949	In particular,
	8950	negative displacements rotate to the right.
	8951
	8952
	8953
	8954
	8955	<p>
	8956	<hr><h3><a name="pdf-bit32.lshift"><code>bit32.lshift (x, disp)</code></a></h3>
	8957
	8958
	8959	<p>
	8960	Returns the number <code>x</code> shifted <code>disp</code> bits to the left.
	8961	The number <code>disp</code> may be any representable integer.
	8962	Negative displacements shift to the right.
	8963	In any direction, vacant bits are filled with zeros.
	8964	In particular,
	8965	displacements with absolute values higher than 31
	8966	result in zero (all bits are shifted out).
	8967
	8968
	8969	<p>
	8970	For positive displacements,
	8971	the following equality holds:
	8972
	8973	<pre>
	8974	assert(bit32.lshift(b, disp) == (b * 2^disp) % 2^32)
	8975	</pre>
	8976
	8977
	8978
	8979	<p>
	8980	<hr><h3><a name="pdf-bit32.rrotate"><code>bit32.rrotate (x, disp)</code></a></h3>
	8981
	8982
	8983	<p>
	8984	Returns the number <code>x</code> rotated <code>disp</code> bits to the right.
	8985	The number <code>disp</code> may be any representable integer.
	8986
	8987
	8988	<p>
	8989	For any valid displacement,
	8990	the following identity holds:
	8991
	8992	<pre>
	8993	assert(bit32.rrotate(x, disp) == bit32.rrotate(x, disp % 32))
	8994	</pre><p>
	8995	In particular,
	8996	negative displacements rotate to the left.
	8997
	8998
	8999
	9000
	9001	<p>
	9002	<hr><h3><a name="pdf-bit32.rshift"><code>bit32.rshift (x, disp)</code></a></h3>
	9003
	9004
	9005	<p>
	9006	Returns the number <code>x</code> shifted <code>disp</code> bits to the right.
	9007	The number <code>disp</code> may be any representable integer.
	9008	Negative displacements shift to the left.
	9009	In any direction, vacant bits are filled with zeros.
	9010	In particular,
	9011	displacements with absolute values higher than 31
	9012	result in zero (all bits are shifted out).
	9013
	9014
	9015	<p>
	9016	For positive displacements,
	9017	the following equality holds:
	9018
	9019	<pre>
	9020	assert(bit32.rshift(b, disp) == math.floor(b % 2^32 / 2^disp))
	9021	</pre>
	9022
	9023	<p>
	9024	This shift operation is what is called logical shift.
	9025
	9026
	9027
	9028
	9029
	9030
	9031
	9032	<h2>6.8 – <a name="6.8">Input and Output Facilities</a></h2>
	9033
	9034	<p>
	9035	The I/O library provides two different styles for file manipulation.
	9036	The first one uses implicit file descriptors;
	9037	that is, there are operations to set a default input file and a
	9038	default output file,
	9039	and all input/output operations are over these default files.
	9040	The second style uses explicit file descriptors.
	9041
	9042
	9043	<p>
	9044	When using implicit file descriptors,
	9045	all operations are supplied by table <a name="pdf-io"><code>io</code></a>.
	9046	When using explicit file descriptors,
	9047	the operation <a href="#pdf-io.open"><code>io.open</code></a> returns a file descriptor
	9048	and then all operations are supplied as methods of the file descriptor.
	9049
	9050
	9051	<p>
	9052	The table <code>io</code> also provides
	9053	three predefined file descriptors with their usual meanings from C:
	9054	<a name="pdf-io.stdin"><code>io.stdin</code></a>, <a name="pdf-io.stdout"><code>io.stdout</code></a>, and <a name="pdf-io.stderr"><code>io.stderr</code></a>.
	9055	The I/O library never closes these files.
	9056
	9057
	9058	<p>
	9059	Unless otherwise stated,
	9060	all I/O functions return <b>nil</b> on failure
	9061	(plus an error message as a second result and
	9062	a system-dependent error code as a third result)
	9063	and some value different from <b>nil</b> on success.
	9064	On non-Posix systems,
	9065	the computation of the error message and error code
	9066	in case of errors
	9067	may be not thread safe,
	9068	because they rely on the global C variable <code>errno</code>.
	9069
	9070
	9071	<p>
	9072	<hr><h3><a name="pdf-io.close"><code>io.close ([file])</code></a></h3>
	9073
	9074
	9075	<p>
	9076	Equivalent to <code>file:close()</code>.
	9077	Without a <code>file</code>, closes the default output file.
	9078
	9079
	9080
	9081
	9082	<p>
	9083	<hr><h3><a name="pdf-io.flush"><code>io.flush ()</code></a></h3>
	9084
	9085
	9086	<p>
	9087	Equivalent to <code>io.output():flush()</code>.
	9088
	9089
	9090
	9091
	9092	<p>
	9093	<hr><h3><a name="pdf-io.input"><code>io.input ([file])</code></a></h3>
	9094
	9095
	9096	<p>
	9097	When called with a file name, it opens the named file (in text mode),
	9098	and sets its handle as the default input file.
	9099	When called with a file handle,
	9100	it simply sets this file handle as the default input file.
	9101	When called without parameters,
	9102	it returns the current default input file.
	9103
	9104
	9105	<p>
	9106	In case of errors this function raises the error,
	9107	instead of returning an error code.
	9108
	9109
	9110
	9111
	9112	<p>
	9113	<hr><h3><a name="pdf-io.lines"><code>io.lines ([filename ···])</code></a></h3>
	9114
	9115
	9116	<p>
	9117	Opens the given file name in read mode
	9118	and returns an iterator function that
	9119	works like <code>file:lines(···)</code> over the opened file.
	9120	When the iterator function detects the end of file,
	9121	it returns <b>nil</b> (to finish the loop) and automatically closes the file.
	9122
	9123
	9124	<p>
	9125	The call <code>io.lines()</code> (with no file name) is equivalent
	9126	to <code>io.input():lines()</code>;
	9127	that is, it iterates over the lines of the default input file.
	9128	In this case it does not close the file when the loop ends.
	9129
	9130
	9131	<p>
	9132	In case of errors this function raises the error,
	9133	instead of returning an error code.
	9134
	9135
	9136
	9137
	9138	<p>
	9139	<hr><h3><a name="pdf-io.open"><code>io.open (filename [, mode])</code></a></h3>
	9140
	9141
	9142	<p>
	9143	This function opens a file,
	9144	in the mode specified in the string <code>mode</code>.
	9145	It returns a new file handle,
	9146	or, in case of errors, <b>nil</b> plus an error message.
	9147
	9148
	9149	<p>
	9150	The <code>mode</code> string can be any of the following:
	9151
	9152	<ul>
	9153	<li><b>"<code>r</code>": </b> read mode (the default);</li>
	9154	<li><b>"<code>w</code>": </b> write mode;</li>
	9155	<li><b>"<code>a</code>": </b> append mode;</li>
	9156	<li><b>"<code>r+</code>": </b> update mode, all previous data is preserved;</li>
	9157	<li><b>"<code>w+</code>": </b> update mode, all previous data is erased;</li>
	9158	<li><b>"<code>a+</code>": </b> append update mode, previous data is preserved,
	9159	writing is only allowed at the end of file.</li>
	9160	</ul><p>
	9161	The <code>mode</code> string can also have a '<code>b</code>' at the end,
	9162	which is needed in some systems to open the file in binary mode.
	9163
	9164
	9165
	9166
	9167	<p>
	9168	<hr><h3><a name="pdf-io.output"><code>io.output ([file])</code></a></h3>
	9169
	9170
	9171	<p>
	9172	Similar to <a href="#pdf-io.input"><code>io.input</code></a>, but operates over the default output file.
	9173
	9174
	9175
	9176
	9177	<p>
	9178	<hr><h3><a name="pdf-io.popen"><code>io.popen (prog [, mode])</code></a></h3>
	9179
	9180
	9181	<p>
	9182	This function is system dependent and is not available
	9183	on all platforms.
	9184
	9185
	9186	<p>
	9187	Starts program <code>prog</code> in a separated process and returns
	9188	a file handle that you can use to read data from this program
	9189	(if <code>mode</code> is <code>"r"</code>, the default)
	9190	or to write data to this program
	9191	(if <code>mode</code> is <code>"w"</code>).
	9192
	9193
	9194
	9195
	9196	<p>
	9197	<hr><h3><a name="pdf-io.read"><code>io.read (···)</code></a></h3>
	9198
	9199
	9200	<p>
	9201	Equivalent to <code>io.input():read(···)</code>.
	9202
	9203
	9204
	9205
	9206	<p>
	9207	<hr><h3><a name="pdf-io.tmpfile"><code>io.tmpfile ()</code></a></h3>
	9208
	9209
	9210	<p>
	9211	Returns a handle for a temporary file.
	9212	This file is opened in update mode
	9213	and it is automatically removed when the program ends.
	9214
	9215
	9216
	9217
	9218	<p>
	9219	<hr><h3><a name="pdf-io.type"><code>io.type (obj)</code></a></h3>
	9220
	9221
	9222	<p>
	9223	Checks whether <code>obj</code> is a valid file handle.
	9224	Returns the string <code>"file"</code> if <code>obj</code> is an open file handle,
	9225	<code>"closed file"</code> if <code>obj</code> is a closed file handle,
	9226	or <b>nil</b> if <code>obj</code> is not a file handle.
	9227
	9228
	9229
	9230
	9231	<p>
	9232	<hr><h3><a name="pdf-io.write"><code>io.write (···)</code></a></h3>
	9233
	9234
	9235	<p>
	9236	Equivalent to <code>io.output():write(···)</code>.
	9237
	9238
	9239
	9240
	9241	<p>
	9242	<hr><h3><a name="pdf-file:close"><code>file:close ()</code></a></h3>
	9243
	9244
	9245	<p>
	9246	Closes <code>file</code>.
	9247	Note that files are automatically closed when
	9248	their handles are garbage collected,
	9249	but that takes an unpredictable amount of time to happen.
	9250
	9251
	9252	<p>
	9253	When closing a file handle created with <a href="#pdf-io.popen"><code>io.popen</code></a>,
	9254	<a href="#pdf-file:close"><code>file:close</code></a> returns the same values
	9255	returned by <a href="#pdf-os.execute"><code>os.execute</code></a>.
	9256
	9257
	9258
	9259
	9260	<p>
	9261	<hr><h3><a name="pdf-file:flush"><code>file:flush ()</code></a></h3>
	9262
	9263
	9264	<p>
	9265	Saves any written data to <code>file</code>.
	9266
	9267
	9268
	9269
	9270	<p>
	9271	<hr><h3><a name="pdf-file:lines"><code>file:lines (···)</code></a></h3>
	9272
	9273
	9274	<p>
	9275	Returns an iterator function that,
	9276	each time it is called,
	9277	reads the file according to the given formats.
	9278	When no format is given,
	9279	uses "*l" as a default.
	9280	As an example, the construction
	9281
	9282	<pre>
	9283	for c in file:lines(1) do <em>body</em> end
	9284	</pre><p>
	9285	will iterate over all characters of the file,
	9286	starting at the current position.
	9287	Unlike <a href="#pdf-io.lines"><code>io.lines</code></a>, this function does not close the file
	9288	when the loop ends.
	9289
	9290
	9291	<p>
	9292	In case of errors this function raises the error,
	9293	instead of returning an error code.
	9294
	9295
	9296
	9297
	9298	<p>
	9299	<hr><h3><a name="pdf-file:read"><code>file:read (···)</code></a></h3>
	9300
	9301
	9302	<p>
	9303	Reads the file <code>file</code>,
	9304	according to the given formats, which specify what to read.
	9305	For each format,
	9306	the function returns a string (or a number) with the characters read,
	9307	or <b>nil</b> if it cannot read data with the specified format.
	9308	When called without formats,
	9309	it uses a default format that reads the next line
	9310	(see below).
	9311
	9312
	9313	<p>
	9314	The available formats are
	9315
	9316	<ul>
	9317
	9318	<li><b>"<code>*n</code>": </b>
	9319	reads a number;
	9320	this is the only format that returns a number instead of a string.
	9321	</li>
	9322
	9323	<li><b>"<code>*a</code>": </b>
	9324	reads the whole file, starting at the current position.
	9325	On end of file, it returns the empty string.
	9326	</li>
	9327
	9328	<li><b>"<code>*l</code>": </b>
	9329	reads the next line skipping the end of line,
	9330	returning <b>nil</b> on end of file.
	9331	This is the default format.
	9332	</li>
	9333
	9334	<li><b>"<code>*L</code>": </b>
	9335	reads the next line keeping the end of line (if present),
	9336	returning <b>nil</b> on end of file.
	9337	</li>
	9338
	9339	<li><b><em>number</em>: </b>
	9340	reads a string with up to this number of bytes,
	9341	returning <b>nil</b> on end of file.
	9342	If number is zero,
	9343	it reads nothing and returns an empty string,
	9344	or <b>nil</b> on end of file.
	9345	</li>
	9346
	9347	</ul>
	9348
	9349
	9350
	9351	<p>
	9352	<hr><h3><a name="pdf-file:seek"><code>file:seek ([whence [, offset]])</code></a></h3>
	9353
	9354
	9355	<p>
	9356	Sets and gets the file position,
	9357	measured from the beginning of the file,
	9358	to the position given by <code>offset</code> plus a base
	9359	specified by the string <code>whence</code>, as follows:
	9360
	9361	<ul>
	9362	<li><b>"<code>set</code>": </b> base is position 0 (beginning of the file);</li>
	9363	<li><b>"<code>cur</code>": </b> base is current position;</li>
	9364	<li><b>"<code>end</code>": </b> base is end of file;</li>
	9365	</ul><p>
	9366	In case of success, <code>seek</code> returns the final file position,
	9367	measured in bytes from the beginning of the file.
	9368	If <code>seek</code> fails, it returns <b>nil</b>,
	9369	plus a string describing the error.
	9370
	9371
	9372	<p>
	9373	The default value for <code>whence</code> is <code>"cur"</code>,
	9374	and for <code>offset</code> is 0.
	9375	Therefore, the call <code>file:seek()</code> returns the current
	9376	file position, without changing it;
	9377	the call <code>file:seek("set")</code> sets the position to the
	9378	beginning of the file (and returns 0);
	9379	and the call <code>file:seek("end")</code> sets the position to the
	9380	end of the file, and returns its size.
	9381
	9382
	9383
	9384
	9385	<p>
	9386	<hr><h3><a name="pdf-file:setvbuf"><code>file:setvbuf (mode [, size])</code></a></h3>
	9387
	9388
	9389	<p>
	9390	Sets the buffering mode for an output file.
	9391	There are three available modes:
	9392
	9393	<ul>
	9394
	9395	<li><b>"<code>no</code>": </b>
	9396	no buffering; the result of any output operation appears immediately.
	9397	</li>
	9398
	9399	<li><b>"<code>full</code>": </b>
	9400	full buffering; output operation is performed only
	9401	when the buffer is full or when
	9402	you explicitly <code>flush</code> the file (see <a href="#pdf-io.flush"><code>io.flush</code></a>).
	9403	</li>
	9404
	9405	<li><b>"<code>line</code>": </b>
	9406	line buffering; output is buffered until a newline is output
	9407	or there is any input from some special files
	9408	(such as a terminal device).
	9409	</li>
	9410
	9411	</ul><p>
	9412	For the last two cases, <code>size</code>
	9413	specifies the size of the buffer, in bytes.
	9414	The default is an appropriate size.
	9415
	9416
	9417
	9418
	9419	<p>
	9420	<hr><h3><a name="pdf-file:write"><code>file:write (···)</code></a></h3>
	9421
	9422
	9423	<p>
	9424	Writes the value of each of its arguments to <code>file</code>.
	9425	The arguments must be strings or numbers.
	9426
	9427
	9428	<p>
	9429	In case of success, this function returns <code>file</code>.
	9430	Otherwise it returns <b>nil</b> plus a string describing the error.
	9431
	9432
	9433
	9434
	9435
	9436
	9437
	9438	<h2>6.9 – <a name="6.9">Operating System Facilities</a></h2>
	9439
	9440	<p>
	9441	This library is implemented through table <a name="pdf-os"><code>os</code></a>.
	9442
	9443
	9444	<p>
	9445	<hr><h3><a name="pdf-os.clock"><code>os.clock ()</code></a></h3>
	9446
	9447
	9448	<p>
	9449	Returns an approximation of the amount in seconds of CPU time
	9450	used by the program.
	9451
	9452
	9453
	9454
	9455	<p>
	9456	<hr><h3><a name="pdf-os.date"><code>os.date ([format [, time]])</code></a></h3>
	9457
	9458
	9459	<p>
	9460	Returns a string or a table containing date and time,
	9461	formatted according to the given string <code>format</code>.
	9462
	9463
	9464	<p>
	9465	If the <code>time</code> argument is present,
	9466	this is the time to be formatted
	9467	(see the <a href="#pdf-os.time"><code>os.time</code></a> function for a description of this value).
	9468	Otherwise, <code>date</code> formats the current time.
	9469
	9470
	9471	<p>
	9472	If <code>format</code> starts with '<code>!</code>',
	9473	then the date is formatted in Coordinated Universal Time.
	9474	After this optional character,
	9475	if <code>format</code> is the string "<code>*t</code>",
	9476	then <code>date</code> returns a table with the following fields:
	9477	<code>year</code> (four digits), <code>month</code> (1–12), <code>day</code> (1–31),
	9478	<code>hour</code> (0–23), <code>min</code> (0–59), <code>sec</code> (0–61),
	9479	<code>wday</code> (weekday, Sunday is 1),
	9480	<code>yday</code> (day of the year),
	9481	and <code>isdst</code> (daylight saving flag, a boolean).
	9482	This last field may be absent
	9483	if the information is not available.
	9484
	9485
	9486	<p>
	9487	If <code>format</code> is not "<code>*t</code>",
	9488	then <code>date</code> returns the date as a string,
	9489	formatted according to the same rules as the ANSI C function <code>strftime</code>.
	9490
	9491
	9492	<p>
	9493	When called without arguments,
	9494	<code>date</code> returns a reasonable date and time representation that depends on
	9495	the host system and on the current locale
	9496	(that is, <code>os.date()</code> is equivalent to <code>os.date("%c")</code>).
	9497
	9498
	9499	<p>
	9500	On non-Posix systems,
	9501	this function may be not thread safe
	9502	because of its reliance on C function <code>gmtime</code> and C function <code>localtime</code>.
	9503
	9504
	9505
	9506
	9507	<p>
	9508	<hr><h3><a name="pdf-os.difftime"><code>os.difftime (t2, t1)</code></a></h3>
	9509
	9510
	9511	<p>
	9512	Returns the number of seconds from time <code>t1</code> to time <code>t2</code>.
	9513	In POSIX, Windows, and some other systems,
	9514	this value is exactly <code>t2</code><em>-</em><code>t1</code>.
	9515
	9516
	9517
	9518
	9519	<p>
	9520	<hr><h3><a name="pdf-os.execute"><code>os.execute ([command])</code></a></h3>
	9521
	9522
	9523	<p>
	9524	This function is equivalent to the ANSI C function <code>system</code>.
	9525	It passes <code>command</code> to be executed by an operating system shell.
	9526	Its first result is <b>true</b>
	9527	if the command terminated successfully,
	9528	or <b>nil</b> otherwise.
	9529	After this first result
	9530	the function returns a string and a number,
	9531	as follows:
	9532
	9533	<ul>
	9534
	9535	<li><b>"<code>exit</code>": </b>
	9536	the command terminated normally;
	9537	the following number is the exit status of the command.
	9538	</li>
	9539
	9540	<li><b>"<code>signal</code>": </b>
	9541	the command was terminated by a signal;
	9542	the following number is the signal that terminated the command.
	9543	</li>
	9544
	9545	</ul>
	9546
	9547	<p>
	9548	When called without a <code>command</code>,
	9549	<code>os.execute</code> returns a boolean that is true if a shell is available.
	9550
	9551
	9552
	9553
	9554	<p>
	9555	<hr><h3><a name="pdf-os.exit"><code>os.exit ([code [, close])</code></a></h3>
	9556
	9557
	9558	<p>
	9559	Calls the ANSI C function <code>exit</code> to terminate the host program.
	9560	If <code>code</code> is <b>true</b>,
	9561	the returned status is <code>EXIT_SUCCESS</code>;
	9562	if <code>code</code> is <b>false</b>,
	9563	the returned status is <code>EXIT_FAILURE</code>;
	9564	if <code>code</code> is a number,
	9565	the returned status is this number.
	9566	The default value for <code>code</code> is <b>true</b>.
	9567
	9568
	9569	<p>
	9570	If the optional second argument <code>close</code> is true,
	9571	closes the Lua state before exiting.
	9572
	9573
	9574
	9575
	9576	<p>
	9577	<hr><h3><a name="pdf-os.getenv"><code>os.getenv (varname)</code></a></h3>
	9578
	9579
	9580	<p>
	9581	Returns the value of the process environment variable <code>varname</code>,
	9582	or <b>nil</b> if the variable is not defined.
	9583
	9584
	9585
	9586
	9587	<p>
	9588	<hr><h3><a name="pdf-os.remove"><code>os.remove (filename)</code></a></h3>
	9589
	9590
	9591	<p>
	9592	Deletes the file (or empty directory, on POSIX systems)
	9593	with the given name.
	9594	If this function fails, it returns <b>nil</b>,
	9595	plus a string describing the error and the error code.
	9596
	9597
	9598
	9599
	9600	<p>
	9601	<hr><h3><a name="pdf-os.rename"><code>os.rename (oldname, newname)</code></a></h3>
	9602
	9603
	9604	<p>
	9605	Renames file or directory named <code>oldname</code> to <code>newname</code>.
	9606	If this function fails, it returns <b>nil</b>,
	9607	plus a string describing the error and the error code.
	9608
	9609
	9610
	9611
	9612	<p>
	9613	<hr><h3><a name="pdf-os.setlocale"><code>os.setlocale (locale [, category])</code></a></h3>
	9614
	9615
	9616	<p>
	9617	Sets the current locale of the program.
	9618	<code>locale</code> is a system-dependent string specifying a locale;
	9619	<code>category</code> is an optional string describing which category to change:
	9620	<code>"all"</code>, <code>"collate"</code>, <code>"ctype"</code>,
	9621	<code>"monetary"</code>, <code>"numeric"</code>, or <code>"time"</code>;
	9622	the default category is <code>"all"</code>.
	9623	The function returns the name of the new locale,
	9624	or <b>nil</b> if the request cannot be honored.
	9625
	9626
	9627	<p>
	9628	If <code>locale</code> is the empty string,
	9629	the current locale is set to an implementation-defined native locale.
	9630	If <code>locale</code> is the string "<code>C</code>",
	9631	the current locale is set to the standard C locale.
	9632
	9633
	9634	<p>
	9635	When called with <b>nil</b> as the first argument,
	9636	this function only returns the name of the current locale
	9637	for the given category.
	9638
	9639
	9640	<p>
	9641	This function may be not thread safe
	9642	because of its reliance on C function <code>setlocale</code>.
	9643
	9644
	9645
	9646
	9647	<p>
	9648	<hr><h3><a name="pdf-os.time"><code>os.time ([table])</code></a></h3>
	9649
	9650
	9651	<p>
	9652	Returns the current time when called without arguments,
	9653	or a time representing the date and time specified by the given table.
	9654	This table must have fields <code>year</code>, <code>month</code>, and <code>day</code>,
	9655	and may have fields
	9656	<code>hour</code> (default is 12),
	9657	<code>min</code> (default is 0),
	9658	<code>sec</code> (default is 0),
	9659	and <code>isdst</code> (default is <b>nil</b>).
	9660	For a description of these fields, see the <a href="#pdf-os.date"><code>os.date</code></a> function.
	9661
	9662
	9663	<p>
	9664	The returned value is a number, whose meaning depends on your system.
	9665	In POSIX, Windows, and some other systems,
	9666	this number counts the number
	9667	of seconds since some given start time (the "epoch").
	9668	In other systems, the meaning is not specified,
	9669	and the number returned by <code>time</code> can be used only as an argument to
	9670	<a href="#pdf-os.date"><code>os.date</code></a> and <a href="#pdf-os.difftime"><code>os.difftime</code></a>.
	9671
	9672
	9673
	9674
	9675	<p>
	9676	<hr><h3><a name="pdf-os.tmpname"><code>os.tmpname ()</code></a></h3>
	9677
	9678
	9679	<p>
	9680	Returns a string with a file name that can
	9681	be used for a temporary file.
	9682	The file must be explicitly opened before its use
	9683	and explicitly removed when no longer needed.
	9684
	9685
	9686	<p>
	9687	On POSIX systems,
	9688	this function also creates a file with that name,
	9689	to avoid security risks.
	9690	(Someone else might create the file with wrong permissions
	9691	in the time between getting the name and creating the file.)
	9692	You still have to open the file to use it
	9693	and to remove it (even if you do not use it).
	9694
	9695
	9696	<p>
	9697	When possible,
	9698	you may prefer to use <a href="#pdf-io.tmpfile"><code>io.tmpfile</code></a>,
	9699	which automatically removes the file when the program ends.
	9700
	9701
	9702
	9703
	9704
	9705
	9706
	9707	<h2>6.10 – <a name="6.10">The Debug Library</a></h2>
	9708
	9709	<p>
	9710	This library provides
	9711	the functionality of the debug interface (<a href="#4.9">§4.9</a>) to Lua programs.
	9712	You should exert care when using this library.
	9713	Several of its functions
	9714	violate basic assumptions about Lua code
	9715	(e.g., that variables local to a function
	9716	cannot be accessed from outside;
	9717	that userdata metatables cannot be changed by Lua code;
	9718	that Lua programs do not crash)
	9719	and therefore can compromise otherwise secure code.
	9720	Moreover, some functions in this library may be slow.
	9721
	9722
	9723	<p>
	9724	All functions in this library are provided
	9725	inside the <a name="pdf-debug"><code>debug</code></a> table.
	9726	All functions that operate over a thread
	9727	have an optional first argument which is the
	9728	thread to operate over.
	9729	The default is always the current thread.
	9730
	9731
	9732	<p>
	9733	<hr><h3><a name="pdf-debug.debug"><code>debug.debug ()</code></a></h3>
	9734
	9735
	9736	<p>
	9737	Enters an interactive mode with the user,
	9738	running each string that the user enters.
	9739	Using simple commands and other debug facilities,
	9740	the user can inspect global and local variables,
	9741	change their values, evaluate expressions, and so on.
	9742	A line containing only the word <code>cont</code> finishes this function,
	9743	so that the caller continues its execution.
	9744
	9745
	9746	<p>
	9747	Note that commands for <code>debug.debug</code> are not lexically nested
	9748	within any function and so have no direct access to local variables.
	9749
	9750
	9751
	9752
	9753	<p>
	9754	<hr><h3><a name="pdf-debug.gethook"><code>debug.gethook ([thread])</code></a></h3>
	9755
	9756
	9757	<p>
	9758	Returns the current hook settings of the thread, as three values:
	9759	the current hook function, the current hook mask,
	9760	and the current hook count
	9761	(as set by the <a href="#pdf-debug.sethook"><code>debug.sethook</code></a> function).
	9762
	9763
	9764
	9765
	9766	<p>
	9767	<hr><h3><a name="pdf-debug.getinfo"><code>debug.getinfo ([thread,] f [, what])</code></a></h3>
	9768
	9769
	9770	<p>
	9771	Returns a table with information about a function.
	9772	You can give the function directly
	9773	or you can give a number as the value of <code>f</code>,
	9774	which means the function running at level <code>f</code> of the call stack
	9775	of the given thread:
	9776	level 0 is the current function (<code>getinfo</code> itself);
	9777	level 1 is the function that called <code>getinfo</code>
	9778	(except for tail calls, which do not count on the stack);
	9779	and so on.
	9780	If <code>f</code> is a number larger than the number of active functions,
	9781	then <code>getinfo</code> returns <b>nil</b>.
	9782
	9783
	9784	<p>
	9785	The returned table can contain all the fields returned by <a href="#lua_getinfo"><code>lua_getinfo</code></a>,
	9786	with the string <code>what</code> describing which fields to fill in.
	9787	The default for <code>what</code> is to get all information available,
	9788	except the table of valid lines.
	9789	If present,
	9790	the option '<code>f</code>'
	9791	adds a field named <code>func</code> with the function itself.
	9792	If present,
	9793	the option '<code>L</code>'
	9794	adds a field named <code>activelines</code> with the table of
	9795	valid lines.
	9796
	9797
	9798	<p>
	9799	For instance, the expression <code>debug.getinfo(1,"n").name</code> returns
	9800	a table with a name for the current function,
	9801	if a reasonable name can be found,
	9802	and the expression <code>debug.getinfo(print)</code>
	9803	returns a table with all available information
	9804	about the <a href="#pdf-print"><code>print</code></a> function.
	9805
	9806
	9807
	9808
	9809	<p>
	9810	<hr><h3><a name="pdf-debug.getlocal"><code>debug.getlocal ([thread,] f, local)</code></a></h3>
	9811
	9812
	9813	<p>
	9814	This function returns the name and the value of the local variable
	9815	with index <code>local</code> of the function at level <code>f</code> of the stack.
	9816	This function accesses not only explicit local variables,
	9817	but also parameters, temporaries, etc.
	9818
	9819
	9820	<p>
	9821	The first parameter or local variable has index 1, and so on,
	9822	until the last active variable.
	9823	Negative indices refer to vararg parameters;
	9824	-1 is the first vararg parameter.
	9825	The function returns <b>nil</b> if there is no variable with the given index,
	9826	and raises an error when called with a level out of range.
	9827	(You can call <a href="#pdf-debug.getinfo"><code>debug.getinfo</code></a> to check whether the level is valid.)
	9828
	9829
	9830	<p>
	9831	Variable names starting with '<code>(</code>' (open parenthesis)
	9832	represent internal variables
	9833	(loop control variables, temporaries, varargs, and C function locals).
	9834
	9835
	9836	<p>
	9837	The parameter <code>f</code> may also be a function.
	9838	In that case, <code>getlocal</code> returns only the name of function parameters.
	9839
	9840
	9841
	9842
	9843	<p>
	9844	<hr><h3><a name="pdf-debug.getmetatable"><code>debug.getmetatable (value)</code></a></h3>
	9845
	9846
	9847	<p>
	9848	Returns the metatable of the given <code>value</code>
	9849	or <b>nil</b> if it does not have a metatable.
	9850
	9851
	9852
	9853
	9854	<p>
	9855	<hr><h3><a name="pdf-debug.getregistry"><code>debug.getregistry ()</code></a></h3>
	9856
	9857
	9858	<p>
	9859	Returns the registry table (see <a href="#4.5">§4.5</a>).
	9860
	9861
	9862
	9863
	9864	<p>
	9865	<hr><h3><a name="pdf-debug.getupvalue"><code>debug.getupvalue (f, up)</code></a></h3>
	9866
	9867
	9868	<p>
	9869	This function returns the name and the value of the upvalue
	9870	with index <code>up</code> of the function <code>f</code>.
	9871	The function returns <b>nil</b> if there is no upvalue with the given index.
	9872
	9873
	9874
	9875
	9876	<p>
	9877	<hr><h3><a name="pdf-debug.getuservalue"><code>debug.getuservalue (u)</code></a></h3>
	9878
	9879
	9880	<p>
	9881	Returns the Lua value associated to <code>u</code>.
	9882	If <code>u</code> is not a userdata,
	9883	returns <b>nil</b>.
	9884
	9885
	9886
	9887
	9888	<p>
	9889	<hr><h3><a name="pdf-debug.sethook"><code>debug.sethook ([thread,] hook, mask [, count])</code></a></h3>
	9890
	9891
	9892	<p>
	9893	Sets the given function as a hook.
	9894	The string <code>mask</code> and the number <code>count</code> describe
	9895	when the hook will be called.
	9896	The string mask may have the following characters,
	9897	with the given meaning:
	9898
	9899	<ul>
	9900	<li><b>'<code>c</code>': </b> the hook is called every time Lua calls a function;</li>
	9901	<li><b>'<code>r</code>': </b> the hook is called every time Lua returns from a function;</li>
	9902	<li><b>'<code>l</code>': </b> the hook is called every time Lua enters a new line of code.</li>
	9903	</ul><p>
	9904	With a <code>count</code> different from zero,
	9905	the hook is called after every <code>count</code> instructions.
	9906
	9907
	9908	<p>
	9909	When called without arguments,
	9910	<a href="#pdf-debug.sethook"><code>debug.sethook</code></a> turns off the hook.
	9911
	9912
	9913	<p>
	9914	When the hook is called, its first parameter is a string
	9915	describing the event that has triggered its call:
	9916	<code>"call"</code> (or <code>"tail call"</code>),
	9917	<code>"return"</code>,
	9918	<code>"line"</code>, and <code>"count"</code>.
	9919	For line events,
	9920	the hook also gets the new line number as its second parameter.
	9921	Inside a hook,
	9922	you can call <code>getinfo</code> with level 2 to get more information about
	9923	the running function
	9924	(level 0 is the <code>getinfo</code> function,
	9925	and level 1 is the hook function).
	9926
	9927
	9928
	9929
	9930	<p>
	9931	<hr><h3><a name="pdf-debug.setlocal"><code>debug.setlocal ([thread,] level, local, value)</code></a></h3>
	9932
	9933
	9934	<p>
	9935	This function assigns the value <code>value</code> to the local variable
	9936	with index <code>local</code> of the function at level <code>level</code> of the stack.
	9937	The function returns <b>nil</b> if there is no local
	9938	variable with the given index,
	9939	and raises an error when called with a <code>level</code> out of range.
	9940	(You can call <code>getinfo</code> to check whether the level is valid.)
	9941	Otherwise, it returns the name of the local variable.
	9942
	9943
	9944	<p>
	9945	See <a href="#pdf-debug.getlocal"><code>debug.getlocal</code></a> for more information about
	9946	variable indices and names.
	9947
	9948
	9949
	9950
	9951	<p>
	9952	<hr><h3><a name="pdf-debug.setmetatable"><code>debug.setmetatable (value, table)</code></a></h3>
	9953
	9954
	9955	<p>
	9956	Sets the metatable for the given <code>value</code> to the given <code>table</code>
	9957	(which can be <b>nil</b>).
	9958	Returns <code>value</code>.
	9959
	9960
	9961
	9962
	9963	<p>
	9964	<hr><h3><a name="pdf-debug.setupvalue"><code>debug.setupvalue (f, up, value)</code></a></h3>
	9965
	9966
	9967	<p>
	9968	This function assigns the value <code>value</code> to the upvalue
	9969	with index <code>up</code> of the function <code>f</code>.
	9970	The function returns <b>nil</b> if there is no upvalue
	9971	with the given index.
	9972	Otherwise, it returns the name of the upvalue.
	9973
	9974
	9975
	9976
	9977	<p>
	9978	<hr><h3><a name="pdf-debug.setuservalue"><code>debug.setuservalue (udata, value)</code></a></h3>
	9979
	9980
	9981	<p>
	9982	Sets the given <code>value</code> as
	9983	the Lua value associated to the given <code>udata</code>.
	9984	<code>value</code> must be a table or <b>nil</b>;
	9985	<code>udata</code> must be a full userdata.
	9986
	9987
	9988	<p>
	9989	Returns <code>udata</code>.
	9990
	9991
	9992
	9993
	9994	<p>
	9995	<hr><h3><a name="pdf-debug.traceback"><code>debug.traceback ([thread,] [message [, level]])</code></a></h3>
	9996
	9997
	9998	<p>
	9999	If <code>message</code> is present but is neither a string nor <b>nil</b>,
	10000	this function returns <code>message</code> without further processing.
	10001	Otherwise,
	10002	it returns a string with a traceback of the call stack.
	10003	An optional <code>message</code> string is appended
	10004	at the beginning of the traceback.
	10005	An optional <code>level</code> number tells at which level
	10006	to start the traceback
	10007	(default is 1, the function calling <code>traceback</code>).
	10008
	10009
	10010
	10011
	10012	<p>
	10013	<hr><h3><a name="pdf-debug.upvalueid"><code>debug.upvalueid (f, n)</code></a></h3>
	10014
	10015
	10016	<p>
	10017	Returns an unique identifier (as a light userdata)
	10018	for the upvalue numbered <code>n</code>
	10019	from the given function.
	10020
	10021
	10022	<p>
	10023	These unique identifiers allow a program to check whether different
	10024	closures share upvalues.
	10025	Lua closures that share an upvalue
	10026	(that is, that access a same external local variable)
	10027	will return identical ids for those upvalue indices.
	10028
	10029
	10030
	10031
	10032	<p>
	10033	<hr><h3><a name="pdf-debug.upvaluejoin"><code>debug.upvaluejoin (f1, n1, f2, n2)</code></a></h3>
	10034
	10035
	10036	<p>
	10037	Make the <code>n1</code>-th upvalue of the Lua closure <code>f1</code>
	10038	refer to the <code>n2</code>-th upvalue of the Lua closure <code>f2</code>.
	10039
	10040
	10041
	10042
	10043
	10044
	10045
	10046	<h1>7 – <a name="7">Lua Standalone</a></h1>
	10047
	10048	<p>
	10049	Although Lua has been designed as an extension language,
	10050	to be embedded in a host C program,
	10051	it is also frequently used as a standalone language.
	10052	An interpreter for Lua as a standalone language,
	10053	called simply <code>lua</code>,
	10054	is provided with the standard distribution.
	10055	The standalone interpreter includes
	10056	all standard libraries, including the debug library.
	10057	Its usage is:
	10058
	10059	<pre>
	10060	lua [options] [script [args]]
	10061	</pre><p>
	10062	The options are:
	10063
	10064	<ul>
	10065	<li><b><code>-e <em>stat</em></code>: </b> executes string <em>stat</em>;</li>
	10066	<li><b><code>-l <em>mod</em></code>: </b> "requires" <em>mod</em>;</li>
	10067	<li><b><code>-i</code>: </b> enters interactive mode after running <em>script</em>;</li>
	10068	<li><b><code>-v</code>: </b> prints version information;</li>
	10069	<li><b><code>-E</code>: </b> ignores environment variables;</li>
	10070	<li><b><code>--</code>: </b> stops handling options;</li>
	10071	<li><b><code>-</code>: </b> executes <code>stdin</code> as a file and stops handling options.</li>
	10072	</ul><p>
	10073	After handling its options, <code>lua</code> runs the given <em>script</em>,
	10074	passing to it the given <em>args</em> as string arguments.
	10075	When called without arguments,
	10076	<code>lua</code> behaves as <code>lua -v -i</code>
	10077	when the standard input (<code>stdin</code>) is a terminal,
	10078	and as <code>lua -</code> otherwise.
	10079
	10080
	10081	<p>
	10082	When called without option <code>-E</code>,
	10083	the interpreter checks for an environment variable <a name="pdf-LUA_INIT_5_2"><code>LUA_INIT_5_2</code></a>
	10084	(or <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a> if it is not defined)
	10085	before running any argument.
	10086	If the variable content has the format <code>@<em>filename</em></code>,
	10087	then <code>lua</code> executes the file.
	10088	Otherwise, <code>lua</code> executes the string itself.
	10089
	10090
	10091	<p>
	10092	When called with option <code>-E</code>,
	10093	besides ignoring <code>LUA_INIT</code>,
	10094	Lua also ignores
	10095	the values of <code>LUA_PATH</code> and <code>LUA_CPATH</code>,
	10096	setting the values of
	10097	<a href="#pdf-package.path"><code>package.path</code></a> and <a href="#pdf-package.cpath"><code>package.cpath</code></a>
	10098	with the default paths defined in <code>luaconf.h</code>.
	10099
	10100
	10101	<p>
	10102	All options are handled in order, except <code>-i</code> and <code>-E</code>.
	10103	For instance, an invocation like
	10104
	10105	<pre>
	10106	$ lua -e'a=1' -e 'print(a)' script.lua
	10107	</pre><p>
	10108	will first set <code>a</code> to 1, then print the value of <code>a</code>,
	10109	and finally run the file <code>script.lua</code> with no arguments.
	10110	(Here <code>$</code> is the shell prompt. Your prompt may be different.)
	10111
	10112
	10113	<p>
	10114	Before starting to run the script,
	10115	<code>lua</code> collects all arguments in the command line
	10116	in a global table called <code>arg</code>.
	10117	The script name is stored at index 0,
	10118	the first argument after the script name goes to index 1,
	10119	and so on.
	10120	Any arguments before the script name
	10121	(that is, the interpreter name plus the options)
	10122	go to negative indices.
	10123	For instance, in the call
	10124
	10125	<pre>
	10126	$ lua -la b.lua t1 t2
	10127	</pre><p>
	10128	the interpreter first runs the file <code>a.lua</code>,
	10129	then creates a table
	10130
	10131	<pre>
	10132	arg = { [-2] = "lua", [-1] = "-la",
	10133	[0] = "b.lua",
	10134	[1] = "t1", [2] = "t2" }
	10135	</pre><p>
	10136	and finally runs the file <code>b.lua</code>.
	10137	The script is called with <code>arg[1]</code>, <code>arg[2]</code>, ...
	10138	as arguments;
	10139	it can also access these arguments with the vararg expression '<code>...</code>'.
	10140
	10141
	10142	<p>
	10143	In interactive mode,
	10144	if you write an incomplete statement,
	10145	the interpreter waits for its completion
	10146	by issuing a different prompt.
	10147
	10148
	10149	<p>
	10150	In case of unprotected errors in the script,
	10151	the interpreter reports the error to the standard error stream.
	10152	If the error object is a string,
	10153	the interpreter adds a stack traceback to it.
	10154	Otherwise, if the error object has a metamethod <code>__tostring</code>,
	10155	the interpreter calls this metamethod to produce the final message.
	10156	Finally, if the error object is <b>nil</b>,
	10157	the interpreter does not report the error.
	10158
	10159
	10160	<p>
	10161	When finishing normally,
	10162	the interpreter closes its main Lua state
	10163	(see <a href="#lua_close"><code>lua_close</code></a>).
	10164	The script can avoid this step by
	10165	calling <a href="#pdf-os.exit"><code>os.exit</code></a> to terminate.
	10166
	10167
	10168	<p>
	10169	To allow the use of Lua as a
	10170	script interpreter in Unix systems,
	10171	the standalone interpreter skips
	10172	the first line of a chunk if it starts with <code>#</code>.
	10173	Therefore, Lua scripts can be made into executable programs
	10174	by using <code>chmod +x</code> and the <code>#!</code> form,
	10175	as in
	10176
	10177	<pre>
	10178	#!/usr/local/bin/lua
	10179	</pre><p>
	10180	(Of course,
	10181	the location of the Lua interpreter may be different in your machine.
	10182	If <code>lua</code> is in your <code>PATH</code>,
	10183	then
	10184
	10185	<pre>
	10186	#!/usr/bin/env lua
	10187	</pre><p>
	10188	is a more portable solution.)
	10189
	10190
	10191
	10192	<h1>8 – <a name="8">Incompatibilities with the Previous Version</a></h1>
	10193
	10194	<p>
	10195	Here we list the incompatibilities that you may find when moving a program
	10196	from Lua 5.1 to Lua 5.2.
	10197	You can avoid some incompatibilities by compiling Lua with
	10198	appropriate options (see file <code>luaconf.h</code>).
	10199	However,
	10200	all these compatibility options will be removed in the next version of Lua.
	10201	Similarly,
	10202	all features marked as deprecated in Lua 5.1
	10203	have been removed in Lua 5.2.
	10204
	10205
	10206
	10207	<h2>8.1 – <a name="8.1">Changes in the Language</a></h2>
	10208	<ul>
	10209
	10210	<li>
	10211	The concept of <em>environment</em> changed.
	10212	Only Lua functions have environments.
	10213	To set the environment of a Lua function,
	10214	use the variable <code>_ENV</code> or the function <a href="#pdf-load"><code>load</code></a>.
	10215
	10216
	10217	<p>
	10218	C functions no longer have environments.
	10219	Use an upvalue with a shared table if you need to keep
	10220	shared state among several C functions.
	10221	(You may use <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a> to open a C library
	10222	with all functions sharing a common upvalue.)
	10223
	10224
	10225	<p>
	10226	To manipulate the "environment" of a userdata
	10227	(which is now called user value),
	10228	use the new functions
	10229	<a href="#lua_getuservalue"><code>lua_getuservalue</code></a> and <a href="#lua_setuservalue"><code>lua_setuservalue</code></a>.
	10230	</li>
	10231
	10232	<li>
	10233	Lua identifiers cannot use locale-dependent letters.
	10234	</li>
	10235
	10236	<li>
	10237	Doing a step or a full collection in the garbage collector
	10238	does not restart the collector if it has been stopped.
	10239	</li>
	10240
	10241	<li>
	10242	Weak tables with weak keys now perform like <em>ephemeron tables</em>.
	10243	</li>
	10244
	10245	<li>
	10246	The event <em>tail return</em> in debug hooks was removed.
	10247	Instead, tail calls generate a special new event,
	10248	<em>tail call</em>, so that the debugger can know that
	10249	there will not be a corresponding return event.
	10250	</li>
	10251
	10252	<li>
	10253	Equality between function values has changed.
	10254	Now, a function definition may not create a new value;
	10255	it may reuse some previous value if there is no
	10256	observable difference to the new function.
	10257	</li>
	10258
	10259	</ul>
	10260
	10261
	10262
	10263
	10264	<h2>8.2 – <a name="8.2">Changes in the Libraries</a></h2>
	10265	<ul>
	10266
	10267	<li>
	10268	Function <code>module</code> is deprecated.
	10269	It is easy to set up a module with regular Lua code.
	10270	Modules are not expected to set global variables.
	10271	</li>
	10272
	10273	<li>
	10274	Functions <code>setfenv</code> and <code>getfenv</code> were removed,
	10275	because of the changes in environments.
	10276	</li>
	10277
	10278	<li>
	10279	Function <code>math.log10</code> is deprecated.
	10280	Use <a href="#pdf-math.log"><code>math.log</code></a> with 10 as its second argument, instead.
	10281	</li>
	10282
	10283	<li>
	10284	Function <code>loadstring</code> is deprecated.
	10285	Use <code>load</code> instead; it now accepts string arguments
	10286	and are exactly equivalent to <code>loadstring</code>.
	10287	</li>
	10288
	10289	<li>
	10290	Function <code>table.maxn</code> is deprecated.
	10291	Write it in Lua if you really need it.
	10292	</li>
	10293
	10294	<li>
	10295	Function <code>os.execute</code> now returns <b>true</b> when command
	10296	terminates successfully and <b>nil</b> plus error information
	10297	otherwise.
	10298	</li>
	10299
	10300	<li>
	10301	Function <code>unpack</code> was moved into the table library
	10302	and therefore must be called as <a href="#pdf-table.unpack"><code>table.unpack</code></a>.
	10303	</li>
	10304
	10305	<li>
	10306	Character class <code>%z</code> in patterns is deprecated,
	10307	as now patterns may contain '<code>\0</code>' as a regular character.
	10308	</li>
	10309
	10310	<li>
	10311	The table <code>package.loaders</code> was renamed <code>package.searchers</code>.
	10312	</li>
	10313
	10314	<li>
	10315	Lua does not have bytecode verification anymore.
	10316	So, all functions that load code
	10317	(<a href="#pdf-load"><code>load</code></a> and <a href="#pdf-loadfile"><code>loadfile</code></a>)
	10318	are potentially insecure when loading untrusted binary data.
	10319	(Actually, those functions were already insecure because
	10320	of flaws in the verification algorithm.)
	10321	When in doubt,
	10322	use the <code>mode</code> argument of those functions
	10323	to restrict them to loading textual chunks.
	10324	</li>
	10325
	10326	<li>
	10327	The standard paths in the official distribution may
	10328	change between versions.
	10329	</li>
	10330
	10331	</ul>
	10332
	10333
	10334
	10335
	10336	<h2>8.3 – <a name="8.3">Changes in the API</a></h2>
	10337	<ul>
	10338
	10339	<li>
	10340	Pseudoindex <code>LUA_GLOBALSINDEX</code> was removed.
	10341	You must get the global environment from the registry
	10342	(see <a href="#4.5">§4.5</a>).
	10343	</li>
	10344
	10345	<li>
	10346	Pseudoindex <code>LUA_ENVIRONINDEX</code>
	10347	and functions <code>lua_getfenv</code>/<code>lua_setfenv</code>
	10348	were removed,
	10349	as C functions no longer have environments.
	10350	</li>
	10351
	10352	<li>
	10353	Function <code>luaL_register</code> is deprecated.
	10354	Use <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a> so that your module does not create globals.
	10355	(Modules are not expected to set global variables anymore.)
	10356	</li>
	10357
	10358	<li>
	10359	The <code>osize</code> argument to the allocation function
	10360	may not be zero when creating a new block,
	10361	that is, when <code>ptr</code> is <code>NULL</code>
	10362	(see <a href="#lua_Alloc"><code>lua_Alloc</code></a>).
	10363	Use only the test <code>ptr == NULL</code> to check whether
	10364	the block is new.
	10365	</li>
	10366
	10367	<li>
	10368	Finalizers (<code>__gc</code> metamethods) for userdata are called in the
	10369	reverse order that they were marked for finalization,
	10370	not that they were created (see <a href="#2.5.1">§2.5.1</a>).
	10371	(Most userdata are marked immediately after they are created.)
	10372	Moreover,
	10373	if the metatable does not have a <code>__gc</code> field when set,
	10374	the finalizer will not be called,
	10375	even if it is set later.
	10376	</li>
	10377
	10378	<li>
	10379	<code>luaL_typerror</code> was removed.
	10380	Write your own version if you need it.
	10381	</li>
	10382
	10383	<li>
	10384	Function <code>lua_cpcall</code> is deprecated.
	10385	You can simply push the function with <a href="#lua_pushcfunction"><code>lua_pushcfunction</code></a>
	10386	and call it with <a href="#lua_pcall"><code>lua_pcall</code></a>.
	10387	</li>
	10388
	10389	<li>
	10390	Functions <code>lua_equal</code> and <code>lua_lessthan</code> are deprecated.
	10391	Use the new <a href="#lua_compare"><code>lua_compare</code></a> with appropriate options instead.
	10392	</li>
	10393
	10394	<li>
	10395	Function <code>lua_objlen</code> was renamed <a href="#lua_rawlen"><code>lua_rawlen</code></a>.
	10396	</li>
	10397
	10398	<li>
	10399	Function <a href="#lua_load"><code>lua_load</code></a> has an extra parameter, <code>mode</code>.
	10400	Pass <code>NULL</code> to simulate the old behavior.
	10401	</li>
	10402
	10403	<li>
	10404	Function <a href="#lua_resume"><code>lua_resume</code></a> has an extra parameter, <code>from</code>.
	10405	Pass <code>NULL</code> or the thread doing the call.
	10406	</li>
	10407
	10408	</ul>
	10409
	10410
	10411
	10412
	10413	<h1>9 – <a name="9">The Complete Syntax of Lua</a></h1>
	10414
	10415	<p>
	10416	Here is the complete syntax of Lua in extended BNF.
	10417	(It does not describe operator precedences.)
	10418
	10419
	10420
	10421
	10422	<pre>
	10423
	10424	chunk ::= block
	10425
	10426	block ::= {stat} [retstat]
	10427
	10428	stat ::= ‘<b>;</b>’ \|
	10429	varlist ‘<b>=</b>’ explist \|
	10430	functioncall \|
	10431	label \|
	10432	<b>break</b> \|
	10433	<b>goto</b> Name \|
	10434	<b>do</b> block <b>end</b> \|
	10435	<b>while</b> exp <b>do</b> block <b>end</b> \|
	10436	<b>repeat</b> block <b>until</b> exp \|
	10437	<b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b> \|
	10438	<b>for</b> Name ‘<b>=</b>’ exp ‘<b>,</b>’ exp [‘<b>,</b>’ exp] <b>do</b> block <b>end</b> \|
	10439	<b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b> \|
	10440	<b>function</b> funcname funcbody \|
	10441	<b>local</b> <b>function</b> Name funcbody \|
	10442	<b>local</b> namelist [‘<b>=</b>’ explist]
	10443
	10444	retstat ::= <b>return</b> [explist] [‘<b>;</b>’]
	10445
	10446	label ::= ‘<b>::</b>’ Name ‘<b>::</b>’
	10447
	10448	funcname ::= Name {‘<b>.</b>’ Name} [‘<b>:</b>’ Name]
	10449
	10450	varlist ::= var {‘<b>,</b>’ var}
	10451
	10452	var ::= Name \| prefixexp ‘<b>[</b>’ exp ‘<b>]</b>’ \| prefixexp ‘<b>.</b>’ Name
	10453
	10454	namelist ::= Name {‘<b>,</b>’ Name}
	10455
	10456	explist ::= exp {‘<b>,</b>’ exp}
	10457
	10458	exp ::= <b>nil</b> \| <b>false</b> \| <b>true</b> \| Number \| String \| ‘<b>...</b>’ \| functiondef \|
	10459	prefixexp \| tableconstructor \| exp binop exp \| unop exp
	10460
	10461	prefixexp ::= var \| functioncall \| ‘<b>(</b>’ exp ‘<b>)</b>’
	10462
	10463	functioncall ::= prefixexp args \| prefixexp ‘<b>:</b>’ Name args
	10464
	10465	args ::= ‘<b>(</b>’ [explist] ‘<b>)</b>’ \| tableconstructor \| String
	10466
	10467	functiondef ::= <b>function</b> funcbody
	10468
	10469	funcbody ::= ‘<b>(</b>’ [parlist] ‘<b>)</b>’ block <b>end</b>
	10470
	10471	parlist ::= namelist [‘<b>,</b>’ ‘<b>...</b>’] \| ‘<b>...</b>’
	10472
	10473	tableconstructor ::= ‘<b>{</b>’ [fieldlist] ‘<b>}</b>’
	10474
	10475	fieldlist ::= field {fieldsep field} [fieldsep]
	10476
	10477	field ::= ‘<b>[</b>’ exp ‘<b>]</b>’ ‘<b>=</b>’ exp \| Name ‘<b>=</b>’ exp \| exp
	10478
	10479	fieldsep ::= ‘<b>,</b>’ \| ‘<b>;</b>’
	10480
	10481	binop ::= ‘<b>+</b>’ \| ‘<b>-</b>’ \| ‘<b>*</b>’ \| ‘<b>/</b>’ \| ‘<b>^</b>’ \| ‘<b>%</b>’ \| ‘<b>..</b>’ \|
	10482	‘<b><</b>’ \| ‘<b><=</b>’ \| ‘<b>></b>’ \| ‘<b>>=</b>’ \| ‘<b>==</b>’ \| ‘<b>~=</b>’ \|
	10483	<b>and</b> \| <b>or</b>
	10484
	10485	unop ::= ‘<b>-</b>’ \| <b>not</b> \| ‘<b>#</b>’
	10486
	10487	</pre>
	10488
	10489	<p>
	10490
	10491
	10492
	10493
	10494
	10495
	10496
	10497	<HR>
	10498	<SMALL CLASS="footer">
	10499	Last update:
	10500	Thu Mar 21 12:58:59 BRT 2013
	10501	</SMALL>
	10502	<!--
	10503	Last change: revised for Lua 5.2.2
	10504	-->
	10505
	10506	</body></html>
	10507

Note: See TracBrowser for help on using the repository browser.

Download in other formats: