| blob | b125c13d881f56073fd81e8d24064e6f2972d5db |
2 <html>
4 <head>
9 </head>
11 <body>
13 <hr>
14 <h1>
16 Lua 5.1 Reference Manual
17 </h1>
19 by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
20 <p>
21 <small>
23 Freely available under the terms of the
25 </small>
26 <hr>
27 <p>
30 ·
33 <!-- ====================================================================== -->
34 <p>
36 <!-- $Id: manual.of,v 1.45 2008/01/19 00:17:30 roberto Exp $ -->
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, light-weight
50 scripting language for any program that needs one.
52 (that is, in the common subset of ANSI C and C++).
55 <p>
56 Being an extension language, Lua has no notion of a "main" program:
59 This 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.
66 which uses the Lua library to offer a complete, stand-alone Lua interpreter.
69 <p>
70 Lua is free software,
71 and is provided as usual with no guarantees,
72 as stated in its license.
73 The implementation described in this manual is available
77 <p>
78 Like any other reference manual,
79 this document is dry in places.
80 For a discussion of the decisions behind the design of Lua,
81 see the technical papers available at Lua's web site.
82 For a detailed introduction to programming in Lua,
89 <p>
90 This section describes the lexis, the syntax, and the semantics of Lua.
91 In other words,
92 this section describes
93 which tokens are valid,
94 how they can be combined,
95 and what their combinations mean.
98 <p>
99 The language constructs will be explained using the usual extended BNF notation,
100 in which
103 Non-terminals are shown like non-terminal,
106 The complete syntax of Lua can be found at the end of this manual.
112 <p>
115 in Lua can be any string of letters,
116 digits, and underscores,
117 not beginning with a digit.
118 This coincides with the definition of names in most languages.
119 (The definition of letter depends on the current locale:
120 any character considered alphabetic by the current locale
121 can be used in an identifier.)
122 Identifiers are used to name variables and table fields.
125 <p>
127 and cannot be used as names:
130 <pre>
131 and break do else elseif
132 end false for function if
133 in local nil not or
134 repeat return then true until while
135 </pre>
137 <p>
138 Lua is a case-sensitive language:
140 are two different, valid names.
141 As a convention, names starting with an underscore followed by
143 are reserved for internal global variables used by Lua.
146 <p>
147 The following strings denote other tokens:
149 <pre>
150 + - * / % ^ #
152 ( ) { } [ ]
153 ; : , . .. ...
154 </pre>
156 <p>
158 can be delimited by matching single or double quotes,
159 and can contain the following C-like escape sequences:
169 and '<code>\'</code>' (apostrophe [single quote]).
170 Moreover, a backslash followed by a real newline
171 results in a newline in the string.
172 A character in a string may also be specified by its numerical value
173 using the escape sequence <code>\<em>ddd</em></code>,
174 where <em>ddd</em> is a sequence of up to three decimal digits.
175 (Note that if a numerical escape is to be followed by a digit,
176 it must be expressed using exactly three digits.)
177 Strings in Lua may contain any 8-bit value, including embedded zeros,
178 which can be specified as '<code>\0</code>'.
181 <p>
182 To put a double (single) quote, a newline, a backslash,
183 a carriage return,
184 or an embedded zero
185 inside a literal string enclosed by double (single) quotes
186 you must use an escape sequence.
187 Any other character may be directly inserted into the literal.
188 (Some control characters may cause problems for the file system,
189 but Lua has no problem with them.)
192 <p>
193 Literal strings can also be defined using a long format
194 enclosed by <em>long brackets</em>.
195 We define an <em>opening long bracket of level <em>n</em></em> as an opening
196 square bracket followed by <em>n</em> equal signs followed by another
197 opening square bracket.
198 So, an opening long bracket of level 0 is written as <code>[[</code>,
199 an opening long bracket of level 1 is written as <code>[=[</code>,
200 and so on.
201 A <em>closing long bracket</em> is defined similarly;
202 for instance, a closing long bracket of level 4 is written as <code>]====]</code>.
203 A long string starts with an opening long bracket of any level and
204 ends at the first closing long bracket of the same level.
205 Literals in this bracketed form may run for several lines,
206 do not interpret any escape sequences,
207 and ignore long brackets of any other level.
208 They may contain anything except a closing bracket of the proper level.
211 <p>
212 For convenience,
213 when the opening long bracket is immediately followed by a newline,
214 the newline is not included in the string.
215 As an example, in a system using ASCII
216 (in which '<code>a</code>' is coded as 97,
217 newline is coded as 10, and '<code>1</code>' is coded as 49),
218 the five literals below denote the same string:
220 <pre>
221 a = 'alo\n123"'
223 a = '\97lo\10\04923"'
224 a = [[alo
226 a = [==[
227 alo
228 123"]==]
229 </pre>
231 <p>
233 and an optional decimal exponent.
234 Lua also accepts integer hexadecimal constants,
236 Examples of valid numerical constants are
238 <pre>
240 </pre>
242 <p>
244 anywhere outside a string.
247 which runs until the end of the line.
249 which runs until the corresponding closing long bracket.
250 Long comments are frequently used to disable code temporarily.
258 <p>
260 This means that
261 variables do not have types; only values do.
262 There are no type definitions in the language.
263 All values carry their own type.
266 <p>
268 This means that all values can be stored in variables,
269 passed as arguments to other functions, and returned as results.
272 <p>
273 There are eight basic types in Lua:
278 whose main property is to be different from any other value;
279 it usually represents the absence of a useful value.
282 any other value makes it true.
284 (It is easy to build Lua interpreters that use other
285 internal representations for numbers,
286 such as single-precision float or long integers;
290 Lua is 8-bit clean:
291 strings may contain any 8-bit character,
295 <p>
296 Lua can call (and manipulate) functions written in Lua and
297 functions written in C
301 <p>
303 be stored in Lua variables.
304 This type corresponds to a block of raw memory
305 and has no pre-defined operations in Lua,
306 except assignment and identity test.
308 the programmer can define operations for userdata values
310 Userdata values cannot be created or modified in Lua,
311 only through the C API.
312 This guarantees the integrity of data owned by the host program.
315 <p>
318 Do not confuse Lua threads with operating-system threads.
319 Lua supports coroutines on all systems,
320 even those that do not support threads.
323 <p>
325 that is, arrays that can be indexed not only with numbers,
329 Tables are the sole data structuring mechanism in Lua;
330 they may be used to represent ordinary arrays,
331 symbol tables, sets, records, graphs, trees, etc.
332 To represent records, Lua uses the field name as an index.
333 The language supports this representation by
335 There are several convenient ways to create tables in Lua
339 <p>
340 Like indices,
342 In particular,
343 because functions are first-class values,
344 table fields may contain functions.
348 <p>
352 Assignment, parameter passing, and function returns
353 always manipulate references to such values;
354 these operations do not imply any kind of copy.
357 <p>
358 The library function <a href="#pdf-type"><code>type</code></a> returns a string describing the type
359 of a given value.
365 <p>
366 Lua provides automatic conversion between
367 string and number values at run time.
368 Any arithmetic operation applied to a string tries to convert
369 this string to a number, following the usual conversion rules.
370 Conversely, whenever a number is used where a string is expected,
371 the number is converted to a string, in a reasonable format.
372 For complete control over how numbers are converted to strings,
384 <p>
385 Variables are places that store values.
387 There are three kinds of variables in Lua:
388 global variables, local variables, and table fields.
391 <p>
392 A single name can denote a global variable or a local variable
393 (or a function's formal parameter,
394 which is a particular kind of local variable):
396 <pre>
397 var ::= Name
398 </pre><p>
402 <p>
403 Any variable is assumed to be global unless explicitly declared
406 local variables can be freely accessed by functions
410 <p>
414 <p>
415 Square brackets are used to index a table:
417 <pre>
419 </pre><p>
420 The meaning of accesses to global variables
421 and table fields can be changed via metatables.
426 This function is not defined or callable in Lua.
427 We use it here only for explanatory purposes.)
430 <p>
434 <pre>
436 </pre>
438 <p>
439 All global variables live as fields in ordinary Lua tables,
442 Each function has its own reference to an environment,
443 so that all global variables in this function
444 will refer to this environment table.
445 When a function is created,
446 it inherits the environment from the function that created it.
447 To get the environment table of a Lua function,
449 To replace it,
451 (You can only manipulate the environment of C functions
455 <p>
458 which in turn is equivalent to
460 <pre>
461 gettable_event(_env, "x")
462 </pre><p>
466 This function is not defined or callable in Lua.
468 We use them here only for explanatory purposes.)
476 <p>
477 Lua supports an almost conventional set of statements,
478 similar to those in Pascal or C.
479 This set includes
480 assignment, control structures, function calls,
481 and variable declarations.
487 <p>
489 A chunk is simply a sequence of statements,
490 which are executed sequentially.
491 Each statement can be optionally followed by a semicolon:
493 <pre>
495 </pre><p>
499 <p>
500 Lua handles a chunk as the body of an anonymous function
501 with a variable number of arguments
503 As such, chunks can define local variables,
504 receive arguments, and return values.
507 <p>
508 A chunk may be stored in a file or in a string inside the host program.
509 When a chunk is executed, first it is pre-compiled into instructions for
510 a virtual machine,
511 and then the compiled code is executed
512 by an interpreter for the virtual machine.
515 <p>
516 Chunks may also be pre-compiled into binary form;
518 Programs in source and compiled forms are interchangeable;
519 Lua automatically detects the file type and acts accordingly.
527 A block is a list of statements;
528 syntactically, a block is the same as a chunk:
530 <pre>
531 block ::= chunk
532 </pre>
534 <p>
535 A block may be explicitly delimited to produce a single statement:
537 <pre>
539 </pre><p>
540 Explicit blocks are useful
541 to control the scope of variable declarations.
542 Explicit blocks are also sometimes used to
552 <p>
553 Lua allows multiple assignment.
554 Therefore, the syntax for assignment
555 defines a list of variables on the left side
556 and a list of expressions on the right side.
557 The elements in both lists are separated by commas:
559 <pre>
563 </pre><p>
567 <p>
568 Before the assignment,
570 the list of variables.
571 If there are more values than needed,
572 the excess values are thrown away.
573 If there are fewer values than needed,
575 If the list of expressions ends with a function call,
576 then all values returned by this call enter in the list of values,
577 before the adjustment
581 <p>
582 The assignment statement first evaluates all its expressions
583 and only then are the assignments performed.
584 Thus the code
586 <pre>
587 i = 3
589 </pre><p>
593 Similarly, the line
595 <pre>
596 x, y = y, x
597 </pre><p>
601 <p>
602 The meaning of assignments to global variables
603 and table fields can be changed via metatables.
608 This function is not defined or callable in Lua.
609 We use it here only for explanatory purposes.)
612 <p>
614 is equivalent to the assignment
616 which in turn is equivalent to
618 <pre>
619 settable_event(_env, "x", val)
620 </pre><p>
623 We use it here only for explanatory purposes.)
630 The control structures
632 familiar syntax:
637 <pre>
640 stat ::= <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b>
641 </pre><p>
645 <p>
646 The condition expression of a
647 control structure may return any value.
650 (in particular, the number 0 and the empty string are also true).
653 <p>
656 but only after the condition.
657 So, the condition can refer to local variables
658 declared inside the loop block.
661 <p>
663 from a function or a chunk (which is just a function).
665 Functions and chunks may return more than one value,
668 <pre>
670 </pre>
672 <p>
675 skipping to the next statement after the loop:
678 <pre>
680 </pre><p>
684 <p>
688 middle of a block,
689 then an explicit inner block can be used,
690 as in the idioms
693 their (inner) blocks.
701 <p>
704 one numeric and one generic.
707 <p>
709 control variable runs through an arithmetic progression.
710 It has the following syntax:
712 <pre>
713 stat ::= <b>for</b> Name `<b>=</b>´ exp `<b>,</b>´ exp [`<b>,</b>´ exp] <b>do</b> block <b>end</b>
714 </pre><p>
720 <pre>
722 </pre><p>
723 is equivalent to the code:
725 <pre>
726 do
727 local <em>var</em>, <em>limit</em>, <em>step</em> = tonumber(<em>e1</em>), tonumber(<em>e2</em>), tonumber(<em>e3</em>)
729 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
733 end
734 end
735 </pre><p>
736 Note the following:
738 <ul>
740 <li>
741 All three control expressions are evaluated only once,
742 before the loop starts.
743 They must all result in numbers.
744 </li>
746 <li>
747 <code><em>var</em></code>, <code><em>limit</em></code>, and <code><em>step</em></code> are invisible variables.
748 The names are here for explanatory purposes only.
749 </li>
751 <li>
752 If the third expression (the step) is absent,
754 </li>
756 <li>
758 </li>
760 <li>
763 If you need this value,
764 assign it to another variable before breaking or exiting the loop.
765 </li>
767 </ul>
769 <p>
772 On each iteration, the iterator function is called to produce a new value,
776 <pre>
779 </pre><p>
782 <pre>
783 for <em>var_1</em>, ···, <em>var_n</em> in <em>explist</em> do <em>block</em> end
784 </pre><p>
785 is equivalent to the code:
787 <pre>
788 do
790 while true do
791 local <em>var_1</em>, ···, <em>var_n</em> = <em>f</em>(<em>s</em>, <em>var</em>)
795 end
796 end
797 </pre><p>
798 Note the following:
800 <ul>
802 <li>
807 </li>
809 <li>
810 <code><em>f</em></code>, <code><em>s</em></code>, and <code><em>var</em></code> are invisible variables.
811 The names are here for explanatory purposes only.
812 </li>
814 <li>
816 </li>
818 <li>
821 If you need these values,
822 then assign them to other variables before breaking or exiting the loop.
823 </li>
825 </ul>
831 To allow possible side-effects,
832 function calls can be executed as statements:
834 <pre>
835 stat ::= functioncall
836 </pre><p>
837 In this case, all returned values are thrown away.
845 Local variables may be declared anywhere inside a block.
846 The declaration may include an initial assignment:
848 <pre>
850 </pre><p>
851 If present, an initial assignment has the same semantics
856 <p>
858 and so local variables can be declared in a chunk outside any explicit block.
859 The scope of such local variables extends until the end of the chunk.
862 <p>
873 <p>
874 The basic expressions in Lua are the following:
876 <pre>
877 exp ::= prefixexp
879 exp ::= Number
880 exp ::= String
881 exp ::= function
882 exp ::= tableconstructor
884 exp ::= exp binop exp
885 exp ::= unop exp
887 </pre>
889 <p>
895 Vararg expressions,
897 directly inside a vararg function;
901 <p>
903 relational operators (see <a href="#2.5.2">§2.5.2</a>), logical operators (see <a href="#2.5.3">§2.5.3</a>),
910 <p>
911 Both function calls and vararg expressions may result in multiple values.
913 (only possible for function calls),
914 then its return list is adjusted to zero elements,
915 thus discarding all returned values.
916 If the expression is used as the last (or the only) element
917 of a list of expressions,
918 then no adjustment is made
919 (unless the call is enclosed in parentheses).
920 In all other contexts,
921 Lua adjusts the result list to one element,
922 discarding all values except the first one.
925 <p>
926 Here are some examples:
928 <pre>
929 f() -- adjusted to 0 results
930 g(f(), x) -- f() is adjusted to 1 result
931 g(x, f()) -- g gets x plus all results from f()
932 a,b,c = f(), x -- f() is adjusted to 1 result (c gets nil)
933 a,b = ... -- a gets the first vararg parameter, b gets
934 -- the second (both a and b may get nil if there
935 -- is no corresponding vararg parameter)
937 a,b,c = x, f() -- f() is adjusted to 2 results
938 a,b,c = f() -- f() is adjusted to 3 results
939 return f() -- returns all results from f()
940 return ... -- returns all received vararg parameters
941 return x,y,f() -- returns x, y, and all results from f()
942 {f()} -- creates a list with all results from f()
943 {...} -- creates a list with all vararg parameters
944 {f(), nil} -- f() is adjusted to 1 result
945 </pre>
947 <p>
948 An expression enclosed in parentheses always results in only one value.
949 Thus,
958 Lua supports the usual arithmetic operators:
963 If the operands are numbers, or strings that can be converted to
965 then all operations have the usual meaning.
966 Exponentiation works for any exponent.
968 Modulo is defined as
970 <pre>
971 a % b == a - math.floor(a/b)*b
972 </pre><p>
973 That is, it is the remainder of a division that rounds
974 the quotient towards minus infinity.
981 The relational operators in Lua are
983 <pre>
985 </pre><p>
989 <p>
992 Otherwise, the values of the operands are compared.
993 Numbers and strings are compared in the usual way.
994 Objects (tables, userdata, threads, and functions)
997 Every time you create a new object
998 (a table, userdata, thread, or function),
999 this new object is different from any previously existing object.
1002 <p>
1003 You can change the way that Lua compares tables and userdata
1007 <p>
1012 entries in a table.
1015 <p>
1019 <p>
1020 The order operators work as follows.
1021 If both arguments are numbers, then they are compared as such.
1022 Otherwise, if both arguments are strings,
1023 then their values are compared according to the current locale.
1032 The logical operators in Lua are
1036 and anything else as true.
1039 <p>
1048 that is,
1049 the second operand is evaluated only if necessary.
1050 Here are some examples:
1052 <pre>
1057 false and error() --> false
1058 false and nil --> false
1059 false or nil --> nil
1061 </pre><p>
1062 (In this manual,
1063 --> indicates the result of the preceding expression.)
1070 The string concatenation operator in Lua is
1072 If both operands are strings or numbers, then they are converted to
1082 <p>
1084 The length of a string is its number of bytes
1085 (that is, the usual meaning of string length when each
1086 character is one byte).
1089 <p>
1096 the index of its last value.
1097 If the array has "holes"
1102 the array).
1109 Operator precedence in Lua follows the table below,
1110 from lower to higher priority:
1112 <pre>
1113 or
1114 and
1116 ..
1117 + -
1118 * / %
1119 not # - (unary)
1120 ^
1121 </pre><p>
1122 As usual,
1123 you can use parentheses to change the precedences of an expression.
1125 operators are right associative.
1126 All other binary operators are left associative.
1133 Table constructors are expressions that create tables.
1134 Every time a constructor is evaluated, a new table is created.
1135 Constructors can be used to create empty tables,
1136 or to create a table and initialize some of its fields.
1137 The general syntax for constructors is
1139 <pre>
1141 fieldlist ::= field {fieldsep field} [fieldsep]
1142 field ::= `<b>[</b>´ exp `<b>]</b>´ `<b>=</b>´ exp | Name `<b>=</b>´ exp | exp
1144 </pre>
1146 <p>
1153 starting with 1.
1154 Fields in the other formats do not affect this counting.
1155 For example,
1157 <pre>
1159 </pre><p>
1160 is equivalent to
1162 <pre>
1163 do
1164 local t = {}
1165 t[f(1)] = g
1172 a = t
1173 end
1174 </pre>
1176 <p>
1178 and the expression is a function call or a vararg expression,
1179 then all values returned by this expression enter the list consecutively
1181 To avoid this,
1182 enclose the function call (or the vararg expression)
1186 <p>
1187 The field list may have an optional trailing separator,
1188 as a convenience for machine-generated code.
1195 A function call in Lua has the following syntax:
1197 <pre>
1198 functioncall ::= prefixexp args
1199 </pre><p>
1200 In a function call,
1201 first prefixexp and args are evaluated.
1203 then this function is called
1204 with the given arguments.
1205 Otherwise, the prefixexp "call" metamethod is called,
1206 having as first parameter the value of prefixexp,
1207 followed by the original call arguments
1211 <p>
1212 The form
1214 <pre>
1216 </pre><p>
1217 can be used to call "methods".
1223 <p>
1224 Arguments have the following syntax:
1226 <pre>
1228 args ::= tableconstructor
1229 args ::= String
1230 </pre><p>
1231 All argument expressions are evaluated before the call.
1234 that is, the argument list is a single new table.
1238 that is, the argument list is a single literal string.
1241 <p>
1242 As an exception to the free-format syntax of Lua,
1244 This restriction avoids some ambiguities in the language.
1245 If you write
1247 <pre>
1248 a = f
1249 (g).x(a)
1250 </pre><p>
1252 So, if you want two statements, you must add a semi-colon between them.
1257 <p>
1262 in a tail call,
1263 the called function reuses the stack entry of the calling function.
1264 Therefore, there is no limit on the number of nested tail calls that
1265 a program can execute.
1266 However, a tail call erases any debug information about the
1267 calling function.
1268 Note that a tail call only happens with a particular syntax,
1270 this syntax makes the calling function return exactly
1271 the returns of the called function.
1272 So, none of the following examples are tail calls:
1274 <pre>
1275 return (f(x)) -- results adjusted to 1
1276 return 2 * f(x)
1277 return x, f(x) -- additional results
1278 f(x); return -- results discarded
1279 return x or f(x) -- results adjusted to 1
1280 </pre>
1287 <p>
1288 The syntax for function definition is
1290 <pre>
1293 </pre>
1295 <p>
1296 The following syntactic sugar simplifies function definitions:
1298 <pre>
1302 </pre><p>
1303 The statement
1305 <pre>
1307 </pre><p>
1308 translates to
1310 <pre>
1312 </pre><p>
1313 The statement
1315 <pre>
1317 </pre><p>
1318 translates to
1320 <pre>
1322 </pre><p>
1323 The statement
1325 <pre>
1327 </pre><p>
1328 translates to
1330 <pre>
1332 </pre><p>
1335 <pre>
1337 </pre><p>
1338 (This only makes a difference when the body of the function
1342 <p>
1343 A function definition is an executable expression,
1345 When Lua pre-compiles a chunk,
1346 all its function bodies are pre-compiled too.
1347 Then, whenever Lua executes the function definition,
1350 is the final value of the expression.
1351 Different instances of the same function
1352 may refer to different external local variables
1353 and may have different environment tables.
1356 <p>
1357 Parameters act as local variables that are
1358 initialized with the argument values:
1360 <pre>
1362 </pre><p>
1363 When a function is called,
1364 the list of arguments is adjusted to
1365 the length of the list of parameters,
1367 which is
1369 A vararg function does not adjust its argument list;
1370 instead, it collects all extra arguments and supplies them
1372 which is also written as three dots.
1373 The value of this expression is a list of all actual extra arguments,
1374 similar to a function with multiple results.
1375 If a vararg expression is used inside another expression
1376 or in the middle of a list of expressions,
1377 then its return list is adjusted to one element.
1378 If the expression is used as the last element of a list of expressions,
1379 then no adjustment is made
1380 (unless the call is enclosed in parentheses).
1383 <p>
1384 As an example, consider the following definitions:
1386 <pre>
1387 function f(a, b) end
1388 function g(a, b, ...) end
1390 </pre><p>
1391 Then, we have the following mapping from arguments to parameters and
1392 to the vararg expression:
1394 <pre>
1395 CALL PARAMETERS
1407 </pre>
1409 <p>
1411 If control reaches the end of a function
1413 then the function returns with no results.
1416 <p>
1420 Thus, the statement
1422 <pre>
1424 </pre><p>
1425 is syntactic sugar for
1427 <pre>
1429 </pre>
1438 <p>
1440 Lua is a lexically scoped language.
1442 their declaration and lasts until the end of the innermost block that
1443 includes the declaration.
1444 Consider the following example:
1446 <pre>
1447 x = 10 -- global variable
1448 do -- new block
1449 local x = x -- new 'x', with value 10
1451 x = x+1
1452 do -- another block
1453 local x = x+1 -- another 'x'
1455 end
1457 end
1459 </pre>
1461 <p>
1467 <p>
1468 Because of the lexical scoping rules,
1469 local variables can be freely accessed by functions
1470 defined inside their scope.
1471 A local variable used by an inner function is called
1473 inside the inner function.
1476 <p>
1478 defines new local variables.
1479 Consider the following example:
1481 <pre>
1482 a = {}
1483 local x = 20
1485 local y = 0
1486 a[i] = function () y=y+1; return x+y end
1487 end
1488 </pre><p>
1489 The loop creates ten closures
1490 (that is, ten instances of the anonymous function).
1500 <p>
1501 Because Lua is an embedded extension language,
1502 all Lua actions start from C code in the host program
1504 Whenever an error occurs during Lua compilation or execution,
1505 control returns to C,
1506 which can take appropriate measures
1507 (such as printing an error message).
1510 <p>
1511 Lua code can explicitly generate an error by calling the
1513 If you need to catch errors in Lua,
1522 <p>
1525 that defines the behavior of the original value
1526 under certain special operations.
1527 You can change several aspects of the behavior
1528 of operations over a value by setting specific fields in its metatable.
1529 For instance, when a non-numeric value is the operand of an addition,
1531 If it finds one,
1532 Lua calls this function to perform the addition.
1535 <p>
1539 and the metamethod is the function that performs the addition.
1542 <p>
1543 You can query the metatable of any value
1547 <p>
1548 You can replace the metatable of tables
1550 function.
1551 You cannot change the metatable of other types from Lua
1552 (except using the debug library);
1553 you must use the C API for that.
1556 <p>
1557 Tables and full userdata have individual metatables
1558 (although multiple tables and userdata can share their metatables);
1559 values of all other types share one single metatable per type.
1560 So, there is one single metatable for all numbers,
1561 one for all strings, etc.
1564 <p>
1565 A metatable may control how an object behaves in arithmetic operations,
1566 order comparisons, concatenation, length operation, and indexing.
1567 A metatable can also define a function to be called when a userdata
1568 is garbage collected.
1569 For each of these operations Lua associates a specific key
1571 When Lua performs one of these operations over a value,
1572 it checks whether this value has a metatable with the corresponding event.
1573 If so, the value associated with that key (the metamethod)
1574 controls how Lua will perform the operation.
1577 <p>
1578 Metatables control the operations listed next.
1579 Each operation is identified by its corresponding name.
1580 The key for each operation is a string with its name prefixed by
1582 for instance, the key for operation "add" is the
1584 The semantics of these operations is better explained by a Lua function
1585 describing how the interpreter executes the operation.
1588 <p>
1589 The code shown here in Lua is only illustrative;
1590 the real behavior is hard coded in the interpreter
1591 and it is much more efficient than this simulation.
1592 All functions used in these descriptions
1593 (<a href="#pdf-rawget"><code>rawget</code></a>, <a href="#pdf-tonumber"><code>tonumber</code></a>, etc.)
1595 In particular, to retrieve the metamethod of a given object,
1596 we use the expression
1598 <pre>
1599 metatable(obj)[event]
1600 </pre><p>
1601 This should be read as
1603 <pre>
1604 rawget(getmetatable(obj) or {}, event)
1605 </pre><p>
1607 That is, the access to a metamethod does not invoke other metamethods,
1608 and the access to objects with no metatables does not fail
1613 <ul>
1620 <p>
1622 for a binary operation.
1623 First, Lua tries the first operand.
1624 If its type does not define a handler for the operation,
1625 then Lua tries the second operand.
1627 <pre>
1628 function getbinhandler (op1, op2, event)
1629 return metatable(op1)[event] or metatable(op2)[event]
1630 end
1631 </pre><p>
1632 By using this function,
1635 <pre>
1636 function add_event (op1, op2)
1637 local o1, o2 = tonumber(op1), tonumber(op2)
1638 if o1 and o2 then -- both operands are numeric?
1639 return o1 + o2 -- '+' here is the primitive 'add'
1640 else -- at least one of the operands is not numeric
1641 local h = getbinhandler(op1, op2, "__add")
1642 if h then
1643 -- call the handler with both operands
1644 return (h(op1, op2))
1645 else -- no handler available: default behavior
1646 error(···)
1647 end
1648 end
1649 end
1650 </pre><p>
1651 </li>
1656 Behavior similar to the "add" operation.
1657 </li>
1662 Behavior similar to the "add" operation.
1663 </li>
1668 Behavior similar to the "add" operation.
1669 </li>
1674 Behavior similar to the "add" operation,
1675 with the operation
1677 </li>
1682 Behavior similar to the "add" operation,
1684 as the primitive operation.
1685 </li>
1691 <pre>
1692 function unm_event (op)
1693 local o = tonumber(op)
1694 if o then -- operand is numeric?
1695 return -o -- '-' here is the primitive 'unm'
1696 else -- the operand is not numeric.
1697 -- Try to get a handler from the operand
1698 local h = metatable(op).__unm
1699 if h then
1700 -- call the handler with the operand
1701 return (h(op))
1702 else -- no handler available: default behavior
1703 error(···)
1704 end
1705 end
1706 end
1707 </pre><p>
1708 </li>
1714 <pre>
1715 function concat_event (op1, op2)
1718 return op1 .. op2 -- primitive string concatenation
1719 else
1720 local h = getbinhandler(op1, op2, "__concat")
1721 if h then
1722 return (h(op1, op2))
1723 else
1724 error(···)
1725 end
1726 end
1727 end
1728 </pre><p>
1729 </li>
1735 <pre>
1736 function len_event (op)
1737 if type(op) == "string" then
1738 return strlen(op) -- primitive string length
1739 elseif type(op) == "table" then
1740 return #op -- primitive table length
1741 else
1742 local h = metatable(op).__len
1743 if h then
1744 -- call the handler with the operand
1745 return (h(op))
1746 else -- no handler available: default behavior
1747 error(···)
1748 end
1749 end
1750 end
1751 </pre><p>
1753 </li>
1759 for comparison operators.
1760 A metamethod only is selected when both objects
1761 being compared have the same type
1762 and the same metamethod for the selected operation.
1764 <pre>
1765 function getcomphandler (op1, op2, event)
1766 if type(op1) ~= type(op2) then return nil end
1767 local mm1 = metatable(op1)[event]
1768 local mm2 = metatable(op2)[event]
1769 if mm1 == mm2 then return mm1 else return nil end
1770 end
1771 </pre><p>
1772 The "eq" event is defined as follows:
1774 <pre>
1775 function eq_event (op1, op2)
1776 if type(op1) ~= type(op2) then -- different types?
1777 return false -- different objects
1778 end
1779 if op1 == op2 then -- primitive equal?
1780 return true -- objects are equal
1781 end
1782 -- try metamethod
1783 local h = getcomphandler(op1, op2, "__eq")
1784 if h then
1785 return (h(op1, op2))
1786 else
1787 return false
1788 end
1789 end
1790 </pre><p>
1792 </li>
1798 <pre>
1799 function lt_event (op1, op2)
1801 return op1 < op2 -- numeric comparison
1803 return op1 < op2 -- lexicographic comparison
1804 else
1805 local h = getcomphandler(op1, op2, "__lt")
1806 if h then
1807 return (h(op1, op2))
1808 else
1809 error(···);
1810 end
1811 end
1812 end
1813 </pre><p>
1815 </li>
1821 <pre>
1822 function le_event (op1, op2)
1824 return op1 <= op2 -- numeric comparison
1826 return op1 <= op2 -- lexicographic comparison
1827 else
1828 local h = getcomphandler(op1, op2, "__le")
1829 if h then
1830 return (h(op1, op2))
1831 else
1832 h = getcomphandler(op1, op2, "__lt")
1833 if h then
1834 return not h(op2, op1)
1835 else
1836 error(···);
1837 end
1838 end
1839 end
1840 end
1841 </pre><p>
1843 Note that, in the absence of a "le" metamethod,
1846 </li>
1852 <pre>
1853 function gettable_event (table, key)
1854 local h
1855 if type(table) == "table" then
1856 local v = rawget(table, key)
1857 if v ~= nil then return v end
1858 h = metatable(table).__index
1859 if h == nil then return nil end
1860 else
1861 h = metatable(table).__index
1862 if h == nil then
1863 error(···);
1864 end
1865 end
1866 if type(h) == "function" then
1867 return (h(table, key)) -- call the handler
1868 else return h[key] -- or repeat operation on it
1869 end
1870 end
1871 </pre><p>
1872 </li>
1878 <pre>
1879 function settable_event (table, key, value)
1880 local h
1881 if type(table) == "table" then
1882 local v = rawget(table, key)
1883 if v ~= nil then rawset(table, key, value); return end
1884 h = metatable(table).__newindex
1885 if h == nil then rawset(table, key, value); return end
1886 else
1887 h = metatable(table).__newindex
1888 if h == nil then
1889 error(···);
1890 end
1891 end
1892 if type(h) == "function" then
1893 h(table, key,value) -- call the handler
1894 else h[key] = value -- or repeat operation on it
1895 end
1896 end
1897 </pre><p>
1898 </li>
1901 called when Lua calls a value.
1904 <pre>
1905 function function_event (func, ...)
1906 if type(func) == "function" then
1907 return func(...) -- primitive call
1908 else
1909 local h = metatable(func).__call
1910 if h then
1911 return h(func, ...)
1912 else
1913 error(···)
1914 end
1915 end
1916 end
1917 </pre><p>
1918 </li>
1920 </ul>
1927 <p>
1928 Besides metatables,
1929 objects of types thread, function, and userdata
1930 have another table associated with them,
1932 Like metatables, environments are regular tables and
1933 multiple objects can share the same environment.
1936 <p>
1937 Environments associated with userdata have no meaning for Lua.
1938 It is only a convenience feature for programmers to associate a table to
1939 a userdata.
1942 <p>
1943 Environments associated with threads are called
1945 They are used as the default environment for their threads and
1946 non-nested functions created by the thread
1947 (through <a href="#pdf-loadfile"><code>loadfile</code></a>, <a href="#pdf-loadstring"><code>loadstring</code></a> or <a href="#pdf-load"><code>load</code></a>)
1951 <p>
1952 Environments associated with C functions can be directly
1954 They are used as the default environment for other C functions
1955 created by the function.
1958 <p>
1959 Environments associated with Lua functions are used to resolve
1961 They are used as the default environment for other Lua functions
1962 created by the function.
1965 <p>
1966 You can change the environment of a Lua function or the
1968 You can get the environment of a Lua function or the running thread
1970 To manipulate the environment of other objects
1971 (userdata, C functions, other threads) you must
1972 use the C API.
1980 <p>
1981 Lua performs automatic memory management.
1982 This means that
1983 you have to worry neither about allocating memory for new objects
1984 nor about freeing it when the objects are no longer needed.
1985 Lua manages memory automatically by running
1988 (that is, these objects that are no longer accessible from Lua).
1989 All objects in Lua are subject to automatic management:
1990 tables, userdata, functions, threads, and strings.
1993 <p>
1994 Lua implements an incremental mark-and-sweep collector.
1995 It uses two numbers to control its garbage-collection cycles:
2000 <p>
2001 The garbage-collector pause
2002 controls how long the collector waits before starting a new cycle.
2003 Larger values make the collector less aggressive.
2004 Values smaller than 1 mean the collector will not wait to
2005 start a new cycle.
2006 A value of 2 means that the collector waits for the total memory in use
2007 to double before starting a new cycle.
2010 <p>
2011 The step multiplier
2012 controls the relative speed of the collector relative to
2013 memory allocation.
2014 Larger values make the collector more aggressive but also increase
2015 the size of each incremental step.
2016 Values smaller than 1 make the collector too slow and
2017 may result in the collector never finishing a cycle.
2019 the speed of memory allocation.
2022 <p>
2025 Both get percentage points as arguments
2027 With these functions you can also control
2028 the collector directly (e.g., stop and restart it).
2034 <p>
2035 Using the C API,
2038 Finalizers allow you to coordinate Lua's garbage collection
2039 with external resource management
2040 (such as closing files, network or database connections,
2041 or freeing your own memory).
2044 <p>
2046 collected immediately by the garbage collector.
2047 Instead, Lua puts them in a list.
2048 After the collection,
2049 Lua does the equivalent of the following function
2050 for each userdata in that list:
2052 <pre>
2053 function gc_event (udata)
2054 local h = metatable(udata).__gc
2055 if h then
2056 h(udata)
2057 end
2058 end
2059 </pre>
2061 <p>
2062 At the end of each garbage-collection cycle,
2064 order of their creation,
2065 among those collected in that cycle.
2066 That is, the first finalizer to be called is the one associated
2067 with the userdata created last in the program.
2068 The userdata itself is freed only in the next garbage-collection cycle.
2076 <p>
2079 A weak reference is ignored by the garbage collector.
2080 In other words,
2081 if the only references to an object are weak references,
2082 then the garbage collector will collect this object.
2085 <p>
2086 A weak table can have weak keys, weak values, or both.
2087 A table with weak keys allows the collection of its keys,
2088 but prevents the collection of its values.
2089 A table with both weak keys and weak values allows the collection of
2090 both keys and values.
2091 In any case, if either the key or the value is collected,
2092 the whole pair is removed from the table.
2093 The weakness of a table is controlled by the
2096 the keys in the table are weak.
2098 the values in the table are weak.
2101 <p>
2102 After you use a table as a metatable,
2104 Otherwise, the weak behavior of the tables controlled by this
2105 metatable is undefined.
2115 <p>
2116 Lua supports coroutines,
2118 A coroutine in Lua represents an independent thread of execution.
2119 Unlike threads in multithread systems, however,
2120 a coroutine only suspends its execution by explicitly calling
2121 a yield function.
2124 <p>
2125 You create a coroutine with a call to <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>.
2126 Its sole argument is a function
2127 that is the main function of the coroutine.
2130 it does not start the coroutine execution.
2133 <p>
2135 passing as its first argument
2137 the coroutine starts its execution,
2138 at the first line of its main function.
2139 Extra arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> are passed on
2140 to the coroutine main function.
2141 After the coroutine starts running,
2145 <p>
2146 A coroutine can terminate its execution in two ways:
2147 normally, when its main function returns
2148 (explicitly or implicitly, after the last instruction);
2149 and abnormally, if there is an unprotected error.
2150 In the first case, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>true</b>,
2151 plus any values returned by the coroutine main function.
2152 In case of errors, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>false</b>
2153 plus an error message.
2156 <p>
2158 When a coroutine yields,
2159 the corresponding <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns immediately,
2160 even if the yield happens inside nested function calls
2161 (that is, not in the main function,
2162 but in a function directly or indirectly called by the main function).
2163 In the case of a yield, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> also returns <b>true</b>,
2165 The next time you resume the same coroutine,
2166 it continues its execution from the point where it yielded,
2167 with the call to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a> returning any extra
2171 <p>
2173 the <a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> function also creates a coroutine,
2174 but instead of returning the coroutine itself,
2175 it returns a function that, when called, resumes the coroutine.
2176 Any arguments passed to this function
2178 <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>,
2179 except the first one (the boolean error code).
2182 any error is propagated to the caller.
2185 <p>
2186 As an example,
2187 consider the following code:
2189 <pre>
2190 function foo (a)
2191 print("foo", a)
2192 return coroutine.yield(2*a)
2193 end
2195 co = coroutine.create(function (a,b)
2196 print("co-body", a, b)
2197 local r = foo(a+1)
2198 print("co-body", r)
2199 local r, s = coroutine.yield(a+b, a-b)
2200 print("co-body", r, s)
2201 return b, "end"
2202 end)
2208 </pre><p>
2209 When you run it, it produces the following output:
2211 <pre>
2212 co-body 1 10
2213 foo 2
2215 main true 4
2216 co-body r
2218 co-body x y
2219 main true 10 end
2220 main false cannot resume dead coroutine
2221 </pre>
2228 <p>
2230 This section describes the C API for Lua, that is,
2231 the set of C functions available to the host program to communicate
2232 with Lua.
2233 All API functions and related types and constants
2237 <p>
2238 Even when we use the term "function",
2239 any facility in the API may be provided as a macro instead.
2240 All such macros use each of their arguments exactly once
2241 (except for the first argument, which is always a Lua state),
2242 and so do not generate any hidden side-effects.
2245 <p>
2246 As in most C libraries,
2247 the Lua API functions do not check their arguments for validity or consistency.
2248 However, you can change this behavior by compiling Lua
2249 with a proper definition for the macro <a name="pdf-luai_apicheck"><code>luai_apicheck</code></a>,
2256 <p>
2258 Each element in this stack represents a Lua value
2262 <p>
2263 Whenever Lua calls C, the called function gets a new stack,
2264 which is independent of previous stacks and of stacks of
2265 C functions that are still active.
2266 This stack initially contains any arguments to the C function
2267 and it is where the C function pushes its results
2271 <p>
2272 For convenience,
2273 most query operations in the API do not follow a strict stack discipline.
2274 Instead, they can refer to any element in the stack
2281 (that is, the element that was pushed onto the stack first)
2282 and
2285 (that is, the element at the top)
2298 <p>
2299 When you interact with Lua API,
2300 you are responsible for ensuring consistency.
2301 In particular,
2304 to grow the stack size.
2307 <p>
2308 Whenever Lua calls C,
2309 it ensures that at least <a name="pdf-LUA_MINSTACK"><code>LUA_MINSTACK</code></a> stack positions are available.
2311 so that usually you do not have to worry about stack space
2312 unless your code has loops pushing elements onto the stack.
2315 <p>
2316 Most query functions accept as indices any value inside the
2317 available stack space, that is, indices up to the maximum stack size
2321 as follows:
2323 <pre>
2326 </pre><p>
2327 Note that 0 is never an acceptable index.
2335 <p>
2336 Unless otherwise noted,
2337 any function that accepts valid indices can also be called with
2339 which represent some Lua values that are accessible to C code
2340 but which are not in the stack.
2341 Pseudo-indices are used to access the thread environment,
2342 the function environment,
2343 the registry,
2347 <p>
2348 The thread environment (where global variables live) is
2350 The environment of the running C function is always
2354 <p>
2355 To access and change the value of global variables,
2356 you can use regular table operations over an environment table.
2357 For instance, to access the value of a global variable, do
2359 <pre>
2360 lua_getfield(L, LUA_GLOBALSINDEX, varname);
2361 </pre>
2368 <p>
2369 When a C function is created,
2370 it is possible to associate some values with it,
2373 accessible to the function whenever it is called
2377 <p>
2378 Whenever a C function is called,
2379 its upvalues are located at specific pseudo-indices.
2380 These pseudo-indices are produced by the macro
2382 The first value associated with a function is at position
2386 current function,
2387 produces an acceptable (but invalid) index.
2395 <p>
2397 a pre-defined table that can be used by any C code to
2398 store whatever Lua value it needs to store.
2399 This table is always located at pseudo-index
2401 Any C library can store data into this table,
2402 but it should take care to choose keys different from those used
2403 by other libraries, to avoid collisions.
2404 Typically, you should use as key a string containing your library name
2405 or a light userdata with the address of a C object in your code.
2408 <p>
2409 The integer keys in the registry are used by the reference mechanism,
2410 implemented by the auxiliary library,
2411 and therefore should not be used for other purposes.
2419 <p>
2421 (You can also choose to use exceptions if you use C++;
2423 When Lua faces any error
2424 (such as memory allocation errors, type errors, syntax errors,
2425 and runtime errors)
2427 that is, it does a long jump.
2429 to set a recover point;
2430 any error jumps to the most recent active recover point.
2433 <p>
2434 Most functions in the API may throw an error,
2435 for instance due to a memory allocation error.
2436 The documentation for each function indicates whether
2437 it can throw errors.
2440 <p>
2441 Inside a C function you can throw an error by calling <a href="#lua_error"><code>lua_error</code></a>.
2449 <p>
2450 Here we list all functions and types from the C API in
2451 alphabetical order.
2452 Each function has an indicator like this:
2456 <p>
2458 is how many elements the function pops from the stack.
2460 is how many elements the function pushes onto the stack.
2461 (Any function always pushes its results after popping its arguments.)
2464 depending on the situation;
2466 we cannot know how many elements the function pops/pushes
2467 by looking only at its arguments
2468 (e.g., they may depend on what is on the stack).
2470 tells whether the function may throw errors:
2473 only due to not enough memory;
2480 <pre>typedef void * (*lua_Alloc) (void *ud,
2481 void *ptr,
2482 size_t osize,
2483 size_t nsize);</pre>
2485 <p>
2486 The type of the memory-allocation function used by Lua states.
2487 The allocator function must provide a
2489 but not exactly the same.
2490 Its arguments are
2491 <code>ud</code>, an opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>;
2500 if and only if it cannot fill the request.
2505 Lua assumes that the allocator never fails when
2509 <p>
2510 Here is a simple implementation for the allocator function.
2511 It is used in the auxiliary library by <a href="#luaL_newstate"><code>luaL_newstate</code></a>.
2513 <pre>
2514 static void *l_alloc (void *ud, void *ptr, size_t osize,
2515 size_t nsize) {
2516 (void)ud; (void)osize; /* not used */
2517 if (nsize == 0) {
2518 free(ptr);
2519 return NULL;
2520 }
2521 else
2522 return realloc(ptr, nsize);
2523 }
2524 </pre><p>
2525 This code assumes
2528 ANSI C ensures both behaviors.
2538 <p>
2539 Sets a new panic function and returns the old one.
2542 <p>
2543 If an error happens outside any protected environment,
2546 thus exiting the host application.
2547 Your panic function may avoid this exit by
2548 never returning (e.g., doing a long jump).
2551 <p>
2552 The panic function can access the error message at the top of the stack.
2562 <p>
2563 Calls a function.
2566 <p>
2567 To call a function you must use the following protocol:
2568 first, the function to be called is pushed onto the stack;
2569 then, the arguments to the function are pushed
2570 in direct order;
2571 that is, the first argument is pushed first.
2574 All arguments and the function value are popped from the stack
2575 when the function is called.
2576 The function results are pushed onto the stack when the function returns.
2580 Lua takes care that the returned values fit into the stack space.
2581 The function results are pushed onto the stack in direct order
2582 (the first result is pushed first),
2583 so that after the call the last result is on the top of the stack.
2586 <p>
2587 Any error inside the called function is propagated upwards
2591 <p>
2592 The following example shows how the host program may do the
2593 equivalent to this Lua code:
2595 <pre>
2597 </pre><p>
2598 Here it is in C:
2600 <pre>
2601 lua_getfield(L, LUA_GLOBALSINDEX, "f"); /* function to be called */
2603 lua_getfield(L, LUA_GLOBALSINDEX, "t"); /* table to be indexed */
2605 lua_remove(L, -2); /* remove 't' from the stack */
2608 lua_setfield(L, LUA_GLOBALSINDEX, "a"); /* set global 'a' */
2609 </pre><p>
2610 Note that the code above is "balanced":
2611 at its end, the stack is back to its original configuration.
2612 This is considered good programming practice.
2621 <p>
2622 Type for C functions.
2625 <p>
2626 In order to communicate properly with Lua,
2627 a C function must use the following protocol,
2628 which defines the way parameters and results are passed:
2629 a C function receives its arguments from Lua in its stack
2630 in direct order (the first argument is pushed first).
2631 So, when the function starts,
2633 The first argument (if any) is at index 1
2635 To return values to Lua, a C function just pushes them onto the stack,
2636 in direct order (the first result is pushed first),
2637 and returns the number of results.
2638 Any other value in the stack below the results will be properly
2639 discarded by Lua.
2640 Like a Lua function, a C function called by Lua can also return
2641 many results.
2644 <p>
2645 As an example, the following function receives a variable number
2646 of numerical arguments and returns their average and sum:
2648 <pre>
2649 static int foo (lua_State *L) {
2650 int n = lua_gettop(L); /* number of arguments */
2651 lua_Number sum = 0;
2652 int i;
2654 if (!lua_isnumber(L, i)) {
2655 lua_pushstring(L, "incorrect argument");
2656 lua_error(L);
2657 }
2658 sum += lua_tonumber(L, i);
2659 }
2660 lua_pushnumber(L, sum/n); /* first result */
2661 lua_pushnumber(L, sum); /* second result */
2662 return 2; /* number of results */
2663 }
2664 </pre>
2673 <p>
2675 It returns false if it cannot grow the stack to that size.
2676 This function never shrinks the stack;
2677 if the stack is already larger than the new size,
2678 it is left unchanged.
2688 <p>
2689 Destroys all objects in the given Lua state
2690 (calling the corresponding garbage-collection metamethods, if any)
2691 and frees all dynamic memory used by this state.
2692 On several platforms, you may not need to call this function,
2693 because all resources are naturally released when the host program ends.
2694 On the other hand, long-running programs,
2695 such as a daemon or a web server,
2696 might need to release states as soon as they are not needed,
2697 to avoid growing too large.
2707 <p>
2709 pops them, and leaves the result at the top.
2711 (that is, the function does nothing);
2713 Concatenation is performed following the usual semantics of Lua
2724 <p>
2728 In case of errors,
2729 <a href="#lua_cpcall"><code>lua_cpcall</code></a> returns the same error codes as <a href="#lua_pcall"><code>lua_pcall</code></a>,
2730 plus the error object on the top of the stack;
2731 otherwise, it returns zero, and does not change the stack.
2742 <p>
2743 Creates a new empty table and pushes it onto the stack.
2744 The new table has space pre-allocated
2746 This pre-allocation is useful when you know exactly how many elements
2747 the table will have.
2758 <p>
2759 Dumps a function as a binary chunk.
2760 Receives a Lua function on the top of the stack
2761 and produces a binary chunk that,
2762 if loaded again,
2763 results in a function equivalent to the one dumped.
2764 As it produces parts of the chunk,
2765 <a href="#lua_dump"><code>lua_dump</code></a> calls function <code>writer</code> (see <a href="#lua_Writer"><code>lua_Writer</code></a>)
2767 to write them.
2770 <p>
2771 The value returned is the error code returned by the last
2772 call to the writer;
2776 <p>
2777 This function does not pop the Lua function from the stack.
2787 <p>
2791 (that is, may call metamethods).
2803 <p>
2804 Generates a Lua error.
2805 The error message (which can actually be a Lua value of any type)
2806 must be on the stack top.
2807 This function does a long jump,
2808 and therefore never returns.
2819 <p>
2820 Controls the garbage collector.
2823 <p>
2824 This function performs several tasks,
2827 <ul>
2830 stops the garbage collector.
2831 </li>
2834 restarts the garbage collector.
2835 </li>
2838 performs a full garbage-collection cycle.
2839 </li>
2842 returns the current amount of memory (in Kbytes) in use by Lua.
2843 </li>
2846 returns the remainder of dividing the current amount of bytes of
2847 memory in use by Lua by 1024.
2848 </li>
2851 performs an incremental step of garbage collection.
2853 (larger values mean more steps) in a non-specified way.
2854 If you want to control the step size
2856 The function returns 1 if the step finished a
2857 garbage-collection cycle.
2858 </li>
2863 The function returns the previous value of the pause.
2864 </li>
2869 The function returns the previous value of the step multiplier.
2870 </li>
2872 </ul>
2881 <p>
2882 Returns the memory-allocation function of a given state.
2894 <p>
2895 Pushes onto the stack the environment table of
2896 the value at the given index.
2906 <p>
2909 As in Lua, this function may trigger a metamethod
2920 <p>
2922 It is defined as a macro:
2924 <pre>
2925 #define lua_getglobal(L,s) lua_getfield(L, LUA_GLOBALSINDEX, s)
2926 </pre>
2935 <p>
2936 Pushes onto the stack the metatable of the value at the given
2937 acceptable index.
2938 If the index is not valid,
2939 or if the value does not have a metatable,
2950 <p>
2956 <p>
2957 This function pops the key from the stack
2958 (putting the resulting value in its place).
2959 As in Lua, this function may trigger a metamethod
2970 <p>
2971 Returns the index of the top element in the stack.
2973 this result is equal to the number of elements in the stack
2984 <p>
2985 Moves the top element into the given valid index,
2986 shifting up the elements above this index to open space.
2987 Cannot be called with a pseudo-index,
2988 because a pseudo-index is not an actual stack position.
2997 <p>
2998 The type used by the Lua API to represent integral values.
3001 <p>
3003 which is usually the largest signed integral type the machine handles
3004 "comfortably".
3014 <p>
3015 Returns 1 if the value at the given acceptable index has type boolean,
3026 <p>
3038 <p>
3039 Returns 1 if the value at the given acceptable index is a function
3050 <p>
3051 Returns 1 if the value at the given acceptable index is a light userdata,
3062 <p>
3074 <p>
3075 Returns 1 if the given acceptable index is not valid
3076 (that is, it refers to an element outside the current stack),
3087 <p>
3088 Returns 1 if the given acceptable index is not valid
3089 (that is, it refers to an element outside the current stack)
3101 <p>
3102 Returns 1 if the value at the given acceptable index is a number
3103 or a string convertible to a number,
3114 <p>
3115 Returns 1 if the value at the given acceptable index is a string
3116 or a number (which is always convertible to a string),
3127 <p>
3128 Returns 1 if the value at the given acceptable index is a table,
3139 <p>
3140 Returns 1 if the value at the given acceptable index is a thread,
3151 <p>
3152 Returns 1 if the value at the given acceptable index is a userdata
3163 <p>
3167 (that is, may call metamethods).
3177 <pre>int lua_load (lua_State *L,
3178 lua_Reader reader,
3179 void *data,
3180 const char *chunkname);</pre>
3182 <p>
3183 Loads a Lua chunk.
3184 If there are no errors,
3186 function on top of the stack.
3187 Otherwise, it pushes an error message.
3190 <ul>
3195 syntax error during pre-compilation;</li>
3198 memory allocation error.</li>
3200 </ul>
3202 <p>
3203 This function only loads a chunk;
3204 it does not run it.
3207 <p>
3208 <a href="#lua_load"><code>lua_load</code></a> automatically detects whether the chunk is text or binary,
3212 <p>
3213 The <a href="#lua_load"><code>lua_load</code></a> function uses a user-supplied <code>reader</code> function
3218 <p>
3230 <p>
3231 Creates a new, independent state.
3233 (due to lack of memory).
3235 Lua does all memory allocation for this state through this function.
3237 simply passes to the allocator in every call.
3247 <p>
3248 Creates a new empty table and pushes it onto the stack.
3259 <p>
3260 Creates a new thread, pushes it on the stack,
3261 and returns a pointer to a <a href="#lua_State"><code>lua_State</code></a> that represents this new thread.
3262 The new state returned by this function shares with the original state
3263 all global objects (such as tables),
3264 but has an independent execution stack.
3267 <p>
3268 There is no explicit function to close or to destroy a thread.
3269 Threads are subject to garbage collection,
3270 like any Lua object.
3280 <p>
3281 This function allocates a new block of memory with the given size,
3282 pushes onto the stack a new full userdata with the block address,
3283 and returns this address.
3286 <p>
3287 Userdata represent C values in Lua.
3289 It is an object (like a table):
3290 you must create it, it can have its own metatable,
3291 and you can detect when it is being collected.
3292 A full userdata is only equal to itself (under raw equality).
3295 <p>
3297 Lua calls the metamethod and marks the userdata as finalized.
3298 When this userdata is collected again then
3299 Lua frees its corresponding memory.
3309 <p>
3310 Pops a key from the stack,
3311 and pushes a key-value pair from the table at the given index
3312 (the "next" pair after the given key).
3313 If there are no more elements in the table,
3317 <p>
3318 A typical traversal looks like this:
3320 <pre>
3321 /* table is in the stack at index 't' */
3322 lua_pushnil(L); /* first key */
3323 while (lua_next(L, t) != 0) {
3325 printf("%s - %s\n",
3326 lua_typename(L, lua_type(L, -2)),
3327 lua_typename(L, lua_type(L, -1)));
3328 /* removes 'value'; keeps 'key' for next iteration */
3329 lua_pop(L, 1);
3330 }
3331 </pre>
3333 <p>
3334 While traversing a table,
3336 unless you know that the key is actually a string.
3338 the value at the given index;
3348 <p>
3349 The type of numbers in Lua.
3353 <p>
3354 Through the configuration file you can change
3355 Lua to operate with another type for numbers (e.g., float or long).
3365 <p>
3366 Returns the "length" of the value at the given acceptable index:
3367 for strings, this is the string length;
3369 for userdata, this is the size of the block of memory allocated
3370 for the userdata;
3381 <p>
3382 Calls a function in protected mode.
3385 <p>
3388 If there are no errors during the call,
3389 <a href="#lua_pcall"><code>lua_pcall</code></a> behaves exactly like <a href="#lua_call"><code>lua_call</code></a>.
3390 However, if there is any error,
3392 pushes a single value on the stack (the error message),
3393 and returns an error code.
3396 and its arguments from the stack.
3399 <p>
3401 then the error message returned on the stack
3402 is exactly the original error message.
3405 (In the current implementation, this index cannot be a pseudo-index.)
3406 In case of runtime errors,
3407 this function will be called with the error message
3408 and its return value will be the message returned on the stack by <a href="#lua_pcall"><code>lua_pcall</code></a>.
3411 <p>
3412 Typically, the error handler function is used to add more debug
3413 information to the error message, such as a stack traceback.
3414 Such information cannot be gathered after the return of <a href="#lua_pcall"><code>lua_pcall</code></a>,
3415 since by then the stack has unwound.
3418 <p>
3420 or one of the following error codes
3423 <ul>
3426 a runtime error.
3427 </li>
3430 memory allocation error.
3431 For such errors, Lua does not call the error handler function.
3432 </li>
3435 error while running the error handler function.
3436 </li>
3438 </ul>
3447 <p>
3458 <p>
3469 <p>
3470 Pushes a new C closure onto the stack.
3473 <p>
3474 When a C function is created,
3475 it is possible to associate some values with it,
3477 these values are then accessible to the function whenever it is called.
3478 To associate values with a C function,
3479 first these values should be pushed onto the stack
3480 (when there are multiple values, the first value is pushed first).
3482 is called to create and push the C function onto the stack,
3484 associated with the function.
3485 <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a> also pops these values from the stack.
3495 <p>
3496 Pushes a C function onto the stack.
3497 This function receives a pointer to a C function
3499 when called, invokes the corresponding C function.
3502 <p>
3503 Any function to be registered in Lua must
3504 follow the correct protocol to receive its parameters
3508 <p>
3511 <pre>
3512 #define lua_pushcfunction(L,f) lua_pushcclosure(L,f,0)
3513 </pre>
3522 <p>
3523 Pushes onto the stack a formatted string
3524 and returns a pointer to this string.
3526 but has some important differences:
3528 <ul>
3530 <li>
3531 You do not have to allocate space for the result:
3532 the result is a Lua string and Lua takes care of memory allocation
3533 (and deallocation, through garbage collection).
3534 </li>
3536 <li>
3537 The conversion specifiers are quite restricted.
3538 There are no flags, widths, or precisions.
3539 The conversion specifiers can only be
3546 </li>
3548 </ul>
3557 <p>
3568 <p>
3569 Pushes a light userdata onto the stack.
3572 <p>
3573 Userdata represent C values in Lua.
3575 It is a value (like a number):
3576 you do not create it, it has no individual metatable,
3577 and it is not collected (as it was never created).
3578 A light userdata is equal to "any"
3579 light userdata with the same C address.
3589 <p>
3592 In these cases, it automatically provides the string length.
3602 <p>
3604 onto the stack.
3605 Lua makes (or reuses) an internal copy of the given string,
3607 the function returns.
3608 The string can contain embedded zeros.
3618 <p>
3619 Pushes a nil value onto the stack.
3629 <p>
3640 <p>
3642 onto the stack.
3643 Lua makes (or reuses) an internal copy of the given string,
3645 the function returns.
3646 The string cannot contain embedded zeros;
3647 it is assumed to end at the first zero.
3657 <p>
3659 Returns 1 if this thread is the main thread of its state.
3669 <p>
3670 Pushes a copy of the element at the given valid index
3671 onto the stack.
3679 <pre>const char *lua_pushvfstring (lua_State *L,
3680 const char *fmt,
3681 va_list argp);</pre>
3683 <p>
3684 Equivalent to <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>, except that it receives a <code>va_list</code>
3685 instead of a variable number of arguments.
3695 <p>
3698 (that is, without calling metamethods).
3710 <p>
3712 (i.e., without metamethods).
3722 <p>
3725 The access is raw;
3726 that is, it does not invoke metamethods.
3736 <p>
3738 (i.e., without metamethods).
3748 <p>
3754 <p>
3755 This function pops the value from the stack.
3756 The assignment is raw;
3757 that is, it does not invoke metamethods.
3764 <pre>typedef const char * (*lua_Reader) (lua_State *L,
3765 void *data,
3766 size_t *size);</pre>
3768 <p>
3770 Every time it needs another piece of the chunk,
3773 The reader must return a pointer to a block of memory
3774 with a new piece of the chunk
3776 The block must exist until the reader function is called again.
3778 The reader function may return pieces of any size greater than zero.
3786 <pre>void lua_register (lua_State *L,
3787 const char *name,
3788 lua_CFunction f);</pre>
3790 <p>
3792 It is defined as a macro:
3794 <pre>
3795 #define lua_register(L,n,f) \
3796 (lua_pushcfunction(L, f), lua_setglobal(L, n))
3797 </pre>
3806 <p>
3807 Removes the element at the given valid index,
3808 shifting down the elements above this index to fill the gap.
3809 Cannot be called with a pseudo-index,
3810 because a pseudo-index is not an actual stack position.
3820 <p>
3821 Moves the top element into the given position (and pops it),
3822 without shifting any element
3823 (therefore replacing the value at the given position).
3833 <p>
3834 Starts and resumes a coroutine in a given thread.
3837 <p>
3838 To start a coroutine, you first create a new thread
3840 then you push onto its stack the main function plus any arguments;
3843 This call returns when the coroutine suspends or finishes its execution.
3844 When it returns, the stack contains all values passed to <a href="#lua_yield"><code>lua_yield</code></a>,
3845 or all values returned by the body function.
3848 0 if the coroutine finishes its execution
3849 without errors,
3851 In case of errors,
3852 the stack is not unwound,
3853 so you can use the debug API over it.
3854 The error message is on the top of the stack.
3855 To restart a coroutine, you put on its stack only the values to
3867 <p>
3879 <p>
3880 Pops a table from the stack and sets it as
3881 the new environment for the value at the given index.
3882 If the value at the given index is
3883 neither a function nor a thread nor a userdata,
3885 Otherwise it returns 1.
3895 <p>
3901 <p>
3902 This function pops the value from the stack.
3903 As in Lua, this function may trigger a metamethod
3914 <p>
3915 Pops a value from the stack and
3917 It is defined as a macro:
3919 <pre>
3920 #define lua_setglobal(L,s) lua_setfield(L, LUA_GLOBALSINDEX, s)
3921 </pre>
3930 <p>
3931 Pops a table from the stack and
3932 sets it as the new metatable for the value at the given
3933 acceptable index.
3943 <p>
3950 <p>
3951 This function pops both the key and the value from the stack.
3952 As in Lua, this function may trigger a metamethod
3963 <p>
3965 and sets the stack top to this index.
3966 If the new top is larger than the old one,
3977 <p>
3978 Opaque structure that keeps the whole state of a Lua interpreter.
3979 The Lua library is fully reentrant:
3980 it has no global variables.
3981 All information about a state is kept in this structure.
3984 <p>
3985 A pointer to this state must be passed as the first argument to
3986 every function in the library, except to <a href="#lua_newstate"><code>lua_newstate</code></a>,
3987 which creates a Lua state from scratch.
3997 <p>
4001 <p>
4002 The status can be 0 for a normal thread,
4003 an error code if the thread finished its execution with an error,
4014 <p>
4015 Converts the Lua value at the given acceptable index to a C boolean
4017 Like all tests in Lua,
4020 otherwise it returns 0.
4021 It also returns 0 when called with a non-valid index.
4022 (If you want to accept only actual boolean values,
4033 <p>
4034 Converts a value at the given acceptable index to a C function.
4035 That value must be a C function;
4046 <p>
4047 Converts the Lua value at the given acceptable index
4049 The Lua value must be a number or a string convertible to a number
4054 <p>
4055 If the number is not an integer,
4056 it is truncated in some non-specified way.
4066 <p>
4067 Converts the Lua value at the given acceptable index to a C string.
4070 The Lua value must be a string or a number;
4072 If the value is a number,
4076 when <a href="#lua_tolstring"><code>lua_tolstring</code></a> is applied to keys during a table traversal.)
4079 <p>
4081 to a string inside the Lua state.
4083 after its last character (as in C),
4084 but may contain other zeros in its body.
4085 Because Lua has garbage collection,
4086 there is no guarantee that the pointer returned by <a href="#lua_tolstring"><code>lua_tolstring</code></a>
4087 will be valid after the corresponding value is removed from the stack.
4097 <p>
4098 Converts the Lua value at the given acceptable index
4099 to the C type <a href="#lua_Number"><code>lua_Number</code></a> (see <a href="#lua_Number"><code>lua_Number</code></a>).
4100 The Lua value must be a number or a string convertible to a number
4112 <p>
4113 Converts the value at the given acceptable index to a generic
4115 The value may be a userdata, a table, a thread, or a function;
4117 Different objects will give different pointers.
4118 There is no way to convert the pointer back to its original value.
4121 <p>
4122 Typically this function is used only for debug information.
4132 <p>
4133 Equivalent to <a href="#lua_tolstring"><code>lua_tolstring</code></a> with <code>len</code> equal to <code>NULL</code>.
4143 <p>
4144 Converts the value at the given acceptable index to a Lua thread
4146 This value must be a thread;
4157 <p>
4158 If the value at the given acceptable index is a full userdata,
4159 returns its block address.
4160 If the value is a light userdata,
4161 returns its pointer.
4172 <p>
4173 Returns the type of the value in the given acceptable index,
4175 (that is, an index to an "empty" stack position).
4176 The types returned by <a href="#lua_type"><code>lua_type</code></a> are coded by the following constants
4186 and
4197 <p>
4206 <pre>typedef int (*lua_Writer) (lua_State *L,
4207 const void* p,
4208 size_t sz,
4209 void* ud);</pre>
4211 <p>
4213 Every time it produces another piece of chunk,
4220 <p>
4221 The writer returns an error code:
4224 calling the writer again.
4234 <p>
4238 <p>
4250 <p>
4251 Yields a coroutine.
4254 <p>
4255 This function should only be called as the
4256 return expression of a C function, as follows:
4258 <pre>
4259 return lua_yield (L, nresults);
4260 </pre><p>
4262 the running coroutine suspends its execution,
4263 and the call to <a href="#lua_resume"><code>lua_resume</code></a> that started this coroutine returns.
4275 <p>
4276 Lua has no built-in debugging facilities.
4277 Instead, it offers a special interface
4279 This interface allows the construction of different
4280 kinds of debuggers, profilers, and other tools
4281 that need "inside information" from the interpreter.
4286 <pre>typedef struct lua_Debug {
4287 int event;
4288 const char *name; /* (n) */
4289 const char *namewhat; /* (n) */
4290 const char *what; /* (S) */
4291 const char *source; /* (S) */
4292 int currentline; /* (l) */
4293 int nups; /* (u) number of upvalues */
4294 int linedefined; /* (S) */
4295 int lastlinedefined; /* (S) */
4296 char short_src[LUA_IDSIZE]; /* (S) */
4297 /* private part */
4299 } lua_Debug;</pre>
4301 <p>
4302 A structure used to carry different pieces of
4303 information about an active function.
4305 of this structure, for later use.
4306 To fill the other fields of <a href="#lua_Debug"><code>lua_Debug</code></a> with useful information,
4310 <p>
4313 <ul>
4316 If the function was defined in a string,
4318 If the function was defined in a file,
4320 </li>
4324 </li>
4327 the line number where the definition of the function starts.
4328 </li>
4331 the line number where the definition of the function ends.
4332 </li>
4339 In the latter case,
4340 Lua has no other information about the function.
4341 </li>
4344 the current line where the given function is executing.
4345 When no line information is available,
4347 </li>
4350 a reasonable name for the given function.
4351 Because functions in Lua are first-class values,
4352 they do not have a fixed name:
4353 some functions may be the value of multiple global variables,
4354 while others may be stored only in a table field.
4356 called to find a suitable name.
4357 If it cannot find a name,
4359 </li>
4366 according to how the function was called.
4367 (Lua uses the empty string when no other option seems to apply.)
4368 </li>
4371 the number of upvalues of the function.
4372 </li>
4374 </ul>
4383 <p>
4384 Returns the current hook function.
4394 <p>
4395 Returns the current hook count.
4405 <p>
4406 Returns the current hook mask.
4416 <p>
4417 Returns information about a specific function or function invocation.
4420 <p>
4421 To get information about a function invocation,
4427 <p>
4428 To get information about a function you push it onto the stack
4430 (In that case,
4433 you can write the following code:
4435 <pre>
4436 lua_Debug ar;
4437 lua_getfield(L, LUA_GLOBALSINDEX, "f"); /* get global 'f' */
4439 printf("%d\n", ar.linedefined);
4440 </pre>
4442 <p>
4445 a value to be pushed on the stack:
4447 <ul>
4450 </li>
4455 </li>
4458 </li>
4461 </li>
4464 pushes onto the stack the function that is
4465 running at the given level;
4466 </li>
4469 pushes onto the stack a table whose indices are the
4470 numbers of the lines that are valid on the function.
4472 that is, a line where you can put a break point.
4473 Non-valid lines include empty lines and comments.)
4474 </li>
4476 </ul>
4478 <p>
4479 This function returns 0 on error
4490 <p>
4491 Gets information about a local variable of a given activation record.
4496 (1 is the first parameter or active local variable, and so on,
4497 until the last active local variable).
4498 <a href="#lua_getlocal"><code>lua_getlocal</code></a> pushes the variable's value onto the stack
4499 and returns its name.
4502 <p>
4504 represent internal variables
4505 (loop control variables, temporaries, and C function locals).
4508 <p>
4510 when the index is greater than
4511 the number of active local variables.
4521 <p>
4522 Get information about the interpreter runtime stack.
4525 <p>
4528 of the function executing at a given level.
4532 when called with a level greater than the stack depth,
4533 it returns 0.
4543 <p>
4544 Gets information about a closure's upvalue.
4545 (For Lua functions,
4546 upvalues are the external local variables that the function uses,
4547 and that are consequently included in its closure.)
4548 <a href="#lua_getupvalue"><code>lua_getupvalue</code></a> gets the index <code>n</code> of an upvalue,
4549 pushes the upvalue's value onto the stack,
4550 and returns its name.
4552 (Upvalues have no particular order,
4553 as they are active through the whole function.
4554 So, they are numbered in an arbitrary order.)
4557 <p>
4559 when the index is greater than the number of upvalues.
4561 as a name for all upvalues.
4570 <p>
4571 Type for debugging hook functions.
4574 <p>
4577 Lua identifies these events with the following constants:
4578 <a name="pdf-LUA_HOOKCALL"><code>LUA_HOOKCALL</code></a>, <a name="pdf-LUA_HOOKRET"><code>LUA_HOOKRET</code></a>,
4579 <a name="pdf-LUA_HOOKTAILRET"><code>LUA_HOOKTAILRET</code></a>, <a name="pdf-LUA_HOOKLINE"><code>LUA_HOOKLINE</code></a>,
4586 In the latter case, Lua is simulating a return from
4587 a function that did a tail call;
4591 <p>
4592 While Lua is running a hook, it disables other calls to hooks.
4593 Therefore, if a hook calls back Lua to execute a function or a chunk,
4594 this execution occurs without any calls to hooks.
4604 <p>
4605 Sets the debugging hook function.
4608 <p>
4611 it is formed by a bitwise or of the constants
4618 For each event, the hook is called as explained below:
4620 <ul>
4623 The hook is called just after Lua enters the new function,
4624 before the function gets its arguments.
4625 </li>
4628 The hook is called just before Lua leaves the function.
4629 You have no access to the values to be returned by the function.
4630 </li>
4633 start the execution of a new line of code,
4634 or when it jumps back in the code (even to the same line).
4635 (This event only happens while Lua is executing a Lua function.)
4636 </li>
4640 (This event only happens while Lua is executing a Lua function.)
4641 </li>
4643 </ul>
4645 <p>
4656 <p>
4657 Sets the value of a local variable of a given activation record.
4658 Parameters <code>ar</code> and <code>n</code> are as in <a href="#lua_getlocal"><code>lua_getlocal</code></a>
4660 <a href="#lua_setlocal"><code>lua_setlocal</code></a> assigns the value at the top of the stack
4661 to the variable and returns its name.
4662 It also pops the value from the stack.
4665 <p>
4667 when the index is greater than
4668 the number of active local variables.
4678 <p>
4679 Sets the value of a closure's upvalue.
4680 It assigns the value at the top of the stack
4681 to the upvalue and returns its name.
4682 It also pops the value from the stack.
4683 Parameters <code>funcindex</code> and <code>n</code> are as in the <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>
4687 <p>
4689 when the index is greater than the number of upvalues.
4699 <p>
4702 to interface C with Lua.
4703 While the basic API provides the primitive functions for all
4704 interactions between C and Lua,
4705 the auxiliary library provides higher-level functions for some
4706 common tasks.
4709 <p>
4710 All functions from the auxiliary library
4715 <p>
4716 All functions in the auxiliary library are built on
4717 top of the basic API,
4718 and so they provide nothing that cannot be done with this API.
4721 <p>
4722 Several functions in the auxiliary library are used to
4723 check C function arguments.
4725 All of these functions throw an error if the check is not satisfied.
4726 Because the error message is formatted for arguments
4727 (e.g., "<code>bad argument #1</code>"),
4728 you should not use these functions for other stack values.
4734 <p>
4735 Here we list all functions and types from the auxiliary library
4736 in alphabetical order.
4744 <p>
4756 <p>
4760 The string may contain embedded zeros.
4770 <p>
4783 <p>
4787 The string may not contain embedded zeros.
4797 <p>
4798 Adds the value at the top of the stack
4801 Pops the value.
4804 <p>
4805 This is the only function on string buffers that can (and must)
4806 be called with an extra element on the stack,
4807 which is the value to be added to the buffer.
4815 <pre>void luaL_argcheck (lua_State *L,
4816 int cond,
4817 int narg,
4818 const char *extramsg);</pre>
4820 <p>
4822 If not, raises an error with the following message,
4825 <pre>
4827 </pre>
4836 <p>
4837 Raises an error with the following message,
4840 <pre>
4842 </pre>
4844 <p>
4845 This function never returns,
4846 but it is an idiom to use it in C functions
4856 <p>
4860 <p>
4861 A string buffer allows C code to build Lua strings piecemeal.
4862 Its pattern of use is as follows:
4864 <ul>
4866 <li>First you declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>
4870 <li>
4871 Then you add string pieces to the buffer calling any of
4873 </li>
4875 <li>
4877 This call leaves the final string on the top of the stack.
4878 </li>
4880 </ul>
4882 <p>
4883 During its normal operation,
4884 a string buffer uses a variable number of stack slots.
4885 So, while using a buffer, you cannot assume that you know where
4886 the top of the stack is.
4887 You can use the stack between successive calls to buffer operations
4888 as long as that use is balanced;
4889 that is,
4890 when you call a buffer operation,
4891 the stack is at the same level
4892 it was immediately after the previous buffer operation.
4894 After calling <a href="#luaL_pushresult"><code>luaL_pushresult</code></a> the stack is back to its
4895 level when the buffer was initialized,
4896 plus the final string on its top.
4906 <p>
4908 This function does not allocate any space;
4909 the buffer must be declared as a variable
4920 <p>
4921 Calls a metamethod.
4924 <p>
4927 this function calls this field and passes the object as its only argument.
4928 In this case this function returns 1 and pushes onto the
4929 stack the value returned by the call.
4930 If there is no metatable or no metamethod,
4931 this function returns 0 (without pushing any value on the stack).
4941 <p>
4942 Checks whether the function has an argument
4953 <p>
4965 <p>
4977 <p>
4989 <p>
4991 and returns this string;
4993 with the string's length.
4996 <p>
4998 so all conversions and caveats of that function apply here.
5008 <p>
5010 and returns this number.
5018 <pre>int luaL_checkoption (lua_State *L,
5019 int narg,
5020 const char *def,
5021 const char *const lst[]);</pre>
5023 <p>
5026 (which must be NULL-terminated).
5027 Returns the index in the array where the string was found.
5028 Raises an error if the argument is not a string or
5029 if the string cannot be found.
5032 <p>
5038 <p>
5039 This is a useful function for mapping strings to C enums.
5040 (The usual convention in Lua libraries is
5041 to use strings instead of numbers to select options.)
5051 <p>
5053 raising an error if the stack cannot grow to that size.
5064 <p>
5066 and returns this string.
5069 <p>
5071 so all conversions and caveats of that function apply here.
5081 <p>
5083 See <a href="#lua_type"><code>lua_type</code></a> for the encoding of types for <code>t</code>.
5093 <p>
5095 of the type <code>tname</code> (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
5105 <p>
5106 Loads and runs the given file.
5107 It is defined as the following macro:
5109 <pre>
5111 </pre><p>
5112 It returns 0 if there are no errors
5113 or 1 in case of errors.
5123 <p>
5124 Loads and runs the given string.
5125 It is defined as the following macro:
5127 <pre>
5129 </pre><p>
5130 It returns 0 if there are no errors
5131 or 1 in case of errors.
5141 <p>
5142 Raises an error.
5144 plus any extra arguments,
5146 It also adds at the beginning of the message the file name and
5147 the line number where the error occurred,
5148 if this information is available.
5151 <p>
5152 This function never returns,
5153 but it is an idiom to use it in C functions
5164 <p>
5167 If the object does not have a metatable,
5168 or if the metatable does not have this field,
5169 returns 0 and pushes nothing.
5179 <p>
5189 <pre>const char *luaL_gsub (lua_State *L,
5190 const char *s,
5191 const char *p,
5192 const char *r);</pre>
5194 <p>
5198 Pushes the resulting string on the stack and returns it.
5206 <pre>int luaL_loadbuffer (lua_State *L,
5207 const char *buff,
5208 size_t sz,
5209 const char *name);</pre>
5211 <p>
5212 Loads a buffer as a Lua chunk.
5217 <p>
5220 used for debug information and error messages.
5230 <p>
5231 Loads a file as a Lua chunk.
5235 then it loads from the standard input.
5239 <p>
5242 if it cannot open/read the file.
5245 <p>
5247 it does not run it.
5257 <p>
5258 Loads a string as a Lua chunk.
5263 <p>
5267 <p>
5269 it does not run it.
5279 <p>
5281 returns 0.
5282 Otherwise,
5283 creates a new table to be used as a metatable for userdata,
5285 and returns 1.
5288 <p>
5289 In both cases pushes onto the stack the final value associated
5300 <p>
5301 Creates a new Lua state.
5304 and then sets a panic function (see <a href="#lua_atpanic"><code>lua_atpanic</code></a>) that prints
5305 an error message to the standard error output in case of fatal
5306 errors.
5309 <p>
5310 Returns the new state,
5321 <p>
5322 Opens all standard Lua libraries into the given state.
5332 <p>
5337 Otherwise, raises an error.
5345 <pre>lua_Integer luaL_optinteger (lua_State *L,
5346 int narg,
5347 lua_Integer d);</pre>
5349 <p>
5354 Otherwise, raises an error.
5364 <p>
5369 Otherwise, raises an error.
5377 <pre>const char *luaL_optlstring (lua_State *L,
5378 int narg,
5379 const char *d,
5380 size_t *l);</pre>
5382 <p>
5384 returns this string.
5387 Otherwise, raises an error.
5390 <p>
5402 <p>
5404 returns this number.
5407 Otherwise, raises an error.
5415 <pre>const char *luaL_optstring (lua_State *L,
5416 int narg,
5417 const char *d);</pre>
5419 <p>
5421 returns this string.
5424 Otherwise, raises an error.
5434 <p>
5435 Returns an address to a space of size <a name="pdf-LUAL_BUFFERSIZE"><code>LUAL_BUFFERSIZE</code></a>
5438 After copying the string into this space you must call
5439 <a href="#luaL_addsize"><code>luaL_addsize</code></a> with the size of the string to actually add
5440 it to the buffer.
5450 <p>
5452 the top of the stack.
5462 <p>
5465 for the object at the top of the stack (and pops the object).
5468 <p>
5469 A reference is a unique integer key.
5474 Function <a href="#luaL_unref"><code>luaL_unref</code></a> frees a reference and its associated object.
5477 <p>
5479 <a href="#luaL_ref"><code>luaL_ref</code></a> returns the constant <a name="pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>.
5488 <pre>typedef struct luaL_Reg {
5489 const char *name;
5490 lua_CFunction func;
5491 } luaL_Reg;</pre>
5493 <p>
5494 Type for arrays of functions to be registered by
5497 the function.
5507 <pre>void luaL_register (lua_State *L,
5508 const char *libname,
5509 const luaL_Reg *l);</pre>
5511 <p>
5512 Opens a library.
5515 <p>
5521 <p>
5529 reuses this table instead of creating a new one.
5532 <p>
5533 In any case the function leaves the table
5534 on the top of the stack.
5544 <p>
5545 Returns the name of the type of the value at the given index.
5555 <p>
5556 Generates an error with a message like the following:
5558 <pre>
5559 <em>location</em>: bad argument <em>narg</em> to '<em>func</em>' (<em>tname</em> expected, got <em>rt</em>)
5560 </pre><p>
5561 where <code><em>location</em></code> is produced by <a href="#luaL_where"><code>luaL_where</code></a>,
5573 <p>
5576 The entry is removed from the table,
5577 so that the referred object can be collected.
5581 <p>
5582 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>,
5593 <p>
5594 Pushes onto the stack a string identifying the current position
5596 Typically this string has the following format:
5598 <pre>
5600 </pre><p>
5603 etc.
5606 <p>
5607 This function is used to build a prefix for error messages.
5617 <p>
5618 The standard Lua libraries provide useful functions
5619 that are implemented directly through the C API.
5620 Some of these functions provide essential services to the language
5621 (e.g., <a href="#pdf-type"><code>type</code></a> and <a href="#pdf-getmetatable"><code>getmetatable</code></a>);
5622 others provide access to "outside" services (e.g., I/O);
5623 and others could be implemented in Lua itself,
5624 but are quite useful or have critical performance requirements that
5628 <p>
5629 All libraries are implemented through the official C API
5630 and are provided as separate C modules.
5631 Currently, Lua has the following standard libraries:
5633 <ul>
5651 </ul><p>
5652 Except for the basic and package libraries,
5653 each library provides all its functions as fields of a global table
5654 or as methods of its objects.
5657 <p>
5658 To have access to these libraries,
5659 the C host program should call the <a href="#luaL_openlibs"><code>luaL_openlibs</code></a> function,
5660 which opens all standard libraries.
5661 Alternatively,
5662 it can open them individually by calling
5672 and should not be called directly:
5673 you must call them like any other Lua C function,
5680 <p>
5681 The basic library provides some core functions to Lua.
5682 If you do not include this library in your application,
5683 you should check carefully whether you need to provide
5684 implementations for some of its facilities.
5687 <p>
5689 Issues an error when
5691 otherwise, returns all its arguments.
5693 when absent, it defaults to "assertion failed!"
5698 <p>
5702 <p>
5703 This function is a generic interface to the garbage collector.
5706 <ul>
5709 stops the garbage collector.
5710 </li>
5713 restarts the garbage collector.
5714 </li>
5717 performs a full garbage-collection cycle.
5718 </li>
5721 returns the total memory in use by Lua (in Kbytes).
5722 </li>
5725 performs a garbage-collection step.
5727 (larger values mean more steps) in a non-specified way.
5728 If you want to control the step size
5731 </li>
5736 </li>
5741 </li>
5743 </ul>
5747 <p>
5749 Opens the named file and executes its contents as a Lua chunk.
5750 When called without arguments,
5752 Returns all values returned by the chunk.
5759 <p>
5761 Terminates the last protected function called
5766 <p>
5768 at the beginning of the message.
5775 to the message.
5780 <p>
5782 A global variable (not a function) that
5784 Lua itself does not use this variable;
5785 changing its value does not affect any environment,
5786 nor vice-versa.
5792 <p>
5794 Returns the current environment in use by the function.
5796 that specifies the function at that stack level:
5798 If the given function is not a Lua function,
5806 <p>
5810 <p>
5812 Otherwise,
5814 returns the associated value.
5815 Otherwise, returns the metatable of the given object.
5820 <p>
5824 <p>
5826 so that the construction
5828 <pre>
5830 </pre><p>
5831 will iterate over the pairs (<code>1,t[1]</code>), (<code>2,t[2]</code>), ···,
5832 up to the first integer key absent from the table.
5837 <p>
5841 <p>
5844 with previous results.
5848 <p>
5849 If there are no errors,
5850 returns the compiled chunk as a function;
5852 The environment of the returned function is the global environment.
5855 <p>
5857 and debug information.
5858 When absent,
5859 it defaults to "<code>=(load)</code>".
5864 <p>
5868 <p>
5871 or from the standard input,
5872 if no file name is given.
5877 <p>
5881 <p>
5883 but gets the chunk from the given string.
5886 <p>
5887 To load and run a given string, use the idiom
5889 <pre>
5890 assert(loadstring(s))()
5891 </pre>
5893 <p>
5894 When absent,
5900 <p>
5904 <p>
5905 Allows a program to traverse all fields of a table.
5906 Its first argument is a table and its second argument
5907 is an index in this table.
5909 and its associated value.
5912 and its associated value.
5913 When called with the last index,
5917 In particular,
5921 <p>
5922 The order in which the indices are enumerated is not specified,
5924 (To traverse a table in numeric order,
5928 <p>
5930 during the traversal,
5931 you assign any value to a non-existent field in the table.
5932 You may however modify existing fields.
5933 In particular, you may clear existing fields.
5938 <p>
5942 <p>
5943 Returns three values: the <a href="#pdf-next"><code>next</code></a> function, the table <code>t</code>, and <b>nil</b>,
5944 so that the construction
5946 <pre>
5948 </pre><p>
5952 <p>
5954 the table during its traversal.
5959 <p>
5963 <p>
5968 and returns a status code.
5969 Its first result is the status code (a boolean),
5970 which is true if the call succeeds without errors.
5972 after this first result.
5978 <p>
5980 Receives any number of arguments,
5982 using the <a href="#pdf-tostring"><code>tostring</code></a> function to convert them to strings.
5984 but only as a quick way to show a value,
5985 typically for debugging.
5991 <p>
5994 without invoking any metamethod.
5995 Returns a boolean.
6000 <p>
6003 without invoking any metamethod.
6010 <p>
6013 without invoking any metamethod.
6019 <p>
6025 <p>
6029 <p>
6038 <p>
6042 <p>
6043 Sets the environment to be used by the given function.
6045 that specifies the function at that stack level:
6050 <p>
6052 the environment of the running thread.
6058 <p>
6062 <p>
6063 Sets the metatable for the given table.
6064 (You cannot change the metatable of other types from Lua, only from C.)
6066 removes the metatable of the given table.
6068 raises an error.
6071 <p>
6077 <p>
6079 Tries to convert its argument to a number.
6080 If the argument is already a number or a string convertible
6085 <p>
6086 An optional argument specifies the base to interpret the numeral.
6091 In base 10 (the default), the number may have a decimal part,
6093 In other bases, only unsigned integers are accepted.
6098 <p>
6100 Receives an argument of any type and
6101 converts it to a string in a reasonable format.
6102 For complete control of how numbers are converted,
6106 <p>
6110 and uses the result of the call as its result.
6115 <p>
6117 Returns the type of its only argument, coded as a string.
6118 The possible results of this function are
6120 "<code>number</code>",
6121 "<code>string</code>",
6122 "<code>boolean</code>",
6123 "<code>table</code>",
6124 "<code>function</code>",
6125 "<code>thread</code>",
6126 and "<code>userdata</code>".
6131 <p>
6133 Returns the elements from the given table.
6134 This function is equivalent to
6136 <pre>
6138 </pre><p>
6139 except that the above code can be written only for a fixed number
6140 of elements.
6147 <p>
6149 A global variable (not a function) that
6150 holds a string containing the current interpreter version.
6151 The current contents of this variable is "<code>Lua 5.1</code>".
6156 <p>
6160 <p>
6162 except that you can set a new error handler.
6165 <p>
6171 and returns a status code.
6172 Its first result is the status code (a boolean),
6173 which is true if the call succeeds without errors.
6175 after this first result.
6176 In case of any error,
6187 <p>
6188 The operations related to coroutines comprise a sub-library of
6189 the basic library and come inside the table <a name="pdf-coroutine"><code>coroutine</code></a>.
6193 <p>
6197 <p>
6200 Returns this new coroutine,
6206 <p>
6207 <hr><h3><a name="pdf-coroutine.resume"><code>coroutine.resume (co [, val1, ···])</code></a></h3>
6210 <p>
6212 The first time you resume a coroutine,
6213 it starts running its body.
6215 as the arguments to the body function.
6216 If the coroutine has yielded,
6219 as the results from the yield.
6222 <p>
6223 If the coroutine runs without any errors,
6225 (if the coroutine yields) or any values returned by the body function
6226 (if the coroutine terminates).
6227 If there is any error,
6233 <p>
6237 <p>
6238 Returns the running coroutine,
6244 <p>
6248 <p>
6253 or if it has not started running yet;
6255 (that is, it has resumed another coroutine);
6257 or if it has stopped with an error.
6262 <p>
6266 <p>
6269 Returns a function that resumes the coroutine each time it is called.
6270 Any arguments passed to the function behave as the
6273 except the first boolean.
6274 In case of error, propagates the error.
6279 <p>
6280 <hr><h3><a name="pdf-coroutine.yield"><code>coroutine.yield (···)</code></a></h3>
6283 <p>
6284 Suspends the execution of the calling coroutine.
6285 The coroutine cannot be running a C function,
6286 a metamethod, or an iterator.
6297 <p>
6298 The package library provides basic
6299 facilities for loading and building modules in Lua.
6300 It exports two of its functions directly in the global environment:
6301 <a href="#pdf-require"><code>require</code></a> and <a href="#pdf-module"><code>module</code></a>.
6305 <p>
6309 <p>
6310 Creates a module.
6312 this table is the module.
6314 this table is the module.
6321 (the full module name minus last component; see below).
6327 <p>
6329 (that is, one with components separated by dots),
6331 tables for each component.
6337 <p>
6339 the module name,
6340 where each option is a function to be applied over the module.
6345 <p>
6349 <p>
6350 Loads the given module.
6351 The function starts by looking into the <a href="#pdf-package.loaded"><code>package.loaded</code></a> table
6358 <p>
6359 To find a loader,
6360 <code>require</code> is guided by the <a href="#pdf-package.loaders"><code>package.loaders</code></a> array.
6361 By changing this array,
6363 The following explanation is based on the default configuration
6367 <p>
6369 If it has a value,
6370 this value (which should be a function) is the loader.
6373 If that also fails, it searches for a C loader using the
6375 If that also fails,
6376 it tries an <em>all-in-one</em> loader (see <a href="#pdf-package.loaders"><code>package.loaders</code></a>).
6379 <p>
6380 Once a loader is found,
6382 If the loader returns any value,
6384 If the loader returns no value and
6391 <p>
6392 If there is any error loading or running the module,
6393 or if it cannot find any loader for the module,
6399 <p>
6403 <p>
6404 The path used by <a href="#pdf-require"><code>require</code></a> to search for a C loader.
6407 <p>
6408 Lua initializes the C path <a href="#pdf-package.cpath"><code>package.cpath</code></a> in the same way
6416 <p>
6421 <p>
6423 modules are already loaded.
6431 <p>
6435 <p>
6436 A table used by <a href="#pdf-require"><code>require</code></a> to control how to load modules.
6439 <p>
6441 When looking for a module,
6442 <a href="#pdf-require"><code>require</code></a> calls each of these searchers in ascending order,
6443 with the module name (the argument given to <a href="#pdf-require"><code>require</code></a>) as its
6444 sole parameter.
6446 or a string explaining why it did not find that module
6448 Lua initializes this table with four functions.
6451 <p>
6452 The first searcher simply looks for a loader in the
6456 <p>
6457 The second searcher looks for a loader as a Lua library,
6460 For each template,
6461 the searcher will change each interrogation
6463 which is the module name with each dot replaced by a
6465 then it will try to open the resulting file name.
6466 So, for instance, if the Lua path is the string
6468 <pre>
6469 "./?.lua;./?.lc;/usr/local/?/init.lua"
6470 </pre><p>
6472 will try to open the files
6477 <p>
6478 The third searcher looks for a loader as a C library,
6479 using the path given by the variable <a href="#pdf-package.cpath"><code>package.cpath</code></a>.
6480 For instance,
6481 if the C path is the string
6483 <pre>
6484 "./?.so;./?.dll;/usr/local/?/init.so"
6485 </pre><p>
6489 Once it finds a C library,
6490 this searcher first uses a dynamic link facility to link the
6491 application with the library.
6492 Then it tries to find a C function inside the library to
6493 be used as the loader.
6495 concatenated with a copy of the module name where each dot
6496 is replaced by an underscore.
6497 Moreover, if the module name has a hyphen,
6498 its prefix up to (and including) the first hyphen is removed.
6503 <p>
6505 It searches the C path for a library for
6506 the root name of the given module.
6509 If found, it looks into it for an open function for
6510 the submodule;
6512 With this facility, a package can pack several C submodules
6513 into one single library,
6514 with each submodule keeping its original open function.
6519 <p>
6520 <hr><h3><a name="pdf-package.loadlib"><code>package.loadlib (libname, funcname)</code></a></h3>
6523 <p>
6526 and returns this function as a C function.
6527 (So, <code>funcname</code> must follow the protocol (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>)).
6530 <p>
6531 This is a low-level function.
6532 It completely bypasses the package and module system.
6534 it does not perform any path searching and
6535 does not automatically adds extensions.
6537 including if necessary a path and extension.
6539 (which may depend on the C compiler and linker used).
6542 <p>
6543 This function is not supported by ANSI C.
6544 As such, it is only available on some platforms
6545 (Windows, Linux, Mac OS X, Solaris, BSD,
6551 <p>
6555 <p>
6559 <p>
6560 At start-up, Lua initializes this variable with
6563 if the environment variable is not defined.
6564 Any "<code>;;</code>" in the value of the environment variable
6565 is replaced by the default path.
6570 <p>
6574 <p>
6575 A table to store loaders for specific modules
6581 <p>
6585 <p>
6588 so that this module inherits values
6589 from the global environment.
6600 <p>
6601 This library provides generic functions for string manipulation,
6602 such as finding and extracting substrings, and pattern matching.
6605 Indices are allowed to be negative and are interpreted as indexing backwards,
6606 from the end of the string.
6607 Thus, the last character is at position -1, and so on.
6610 <p>
6611 The string library provides all its functions inside the table
6613 It also sets a metatable for strings
6615 Therefore, you can use the string functions in object-oriented style.
6620 <p>
6628 <p>
6629 Note that numerical codes are not necessarily portable across platforms.
6634 <p>
6636 Receives zero or more integers.
6637 Returns a string with length equal to the number of arguments,
6638 in which each character has the internal numerical code equal
6639 to its corresponding argument.
6642 <p>
6643 Note that numerical codes are not necessarily portable across platforms.
6648 <p>
6652 <p>
6653 Returns a string containing a binary representation of the given function,
6655 a copy of the function.
6661 <p>
6662 <hr><h3><a name="pdf-string.find"><code>string.find (s, pattern [, init [, plain]])</code></a></h3>
6663 Looks for the first match of
6666 where this occurrence starts and ends;
6669 where to start the search;
6672 turns off the pattern matching facilities,
6673 so the function does a plain "find substring" operation,
6678 <p>
6679 If the pattern has captures,
6680 then in a successful match
6681 the captured values are also returned,
6682 after the two indices.
6687 <p>
6688 <hr><h3><a name="pdf-string.format"><code>string.format (formatstring, ···)</code></a></h3>
6689 Returns a formatted version of its variable number of arguments
6690 following the description given in its first argument (which must be a string).
6692 standard C functions.
6693 The only differences are that the options/modifiers
6698 back by the Lua interpreter:
6699 the string is written between double quotes,
6700 and all double quotes, newlines, embedded zeros,
6701 and backslashes in the string
6702 are correctly escaped when written.
6703 For instance, the call
6705 <pre>
6706 string.format('%q', 'a string with "quotes" and \n new line')
6707 </pre><p>
6708 will produce the string:
6710 <pre>
6712 new line"
6713 </pre>
6715 <p>
6717 <code>g</code>, <code>G</code>, <code>i</code>, <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code> all
6718 expect a number as argument,
6722 <p>
6723 This function does not accept string values
6724 containing embedded zeros,
6730 <p>
6732 Returns an iterator function that,
6733 each time it is called,
6736 then the whole match is produced in each call.
6739 <p>
6740 As an example, the following loop
6742 <pre>
6743 s = "hello world from Lua"
6744 for w in string.gmatch(s, "%a+") do
6745 print(w)
6746 end
6747 </pre><p>
6749 printing one per line.
6751 given string into a table:
6753 <pre>
6754 t = {}
6755 s = "from=world, to=Lua"
6756 for k, v in string.gmatch(s, "(%w+)=(%w+)") do
6757 t[k] = v
6758 end
6759 </pre>
6761 <p>
6763 work as an anchor, as this would prevent the iteration.
6768 <p>
6774 which may be a string, a table, or a function.
6776 the total number of matches that occurred.
6779 <p>
6789 <p>
6791 using the first capture as the key;
6792 if the pattern specifies no captures,
6793 then the whole match is used as the key.
6796 <p>
6798 match occurs, with all captured substrings passed as arguments,
6799 in order;
6800 if the pattern specifies no captures,
6801 then the whole match is passed as a sole argument.
6804 <p>
6805 If the value returned by the table query or by the function call
6806 is a string or a number,
6807 then it is used as the replacement string;
6809 then there is no replacement
6810 (that is, the original match is kept in the string).
6813 <p>
6814 Here are some examples:
6816 <pre>
6830 return loadstring(s)()
6831 end)
6837 </pre>
6841 <p>
6843 Receives a string and returns its length.
6845 Embedded zeros are counted,
6851 <p>
6853 Receives a string and returns a copy of this string with all
6854 uppercase letters changed to lowercase.
6855 All other characters are left unchanged.
6856 The definition of what an uppercase letter is depends on the current locale.
6861 <p>
6866 the captures from the pattern;
6869 then the whole match is returned.
6871 where to start the search;
6877 <p>
6885 <p>
6892 <p>
6898 (which is the same as the string length).
6899 In particular,
6908 <p>
6910 Receives a string and returns a copy of this string with all
6911 lowercase letters changed to uppercase.
6912 All other characters are left unchanged.
6913 The definition of what a lowercase letter is depends on the current locale.
6922 The following combinations are allowed in describing a character class:
6924 <ul>
6930 </li>
6956 This is the standard way to escape the magic characters.
6957 Any punctuation character (even the non magic)
6959 when used to represent itself in a pattern.
6960 </li>
6963 represents the class which is the union of all
6965 A range of characters may be specified by
6971 represents all alphanumeric characters plus the underscore,
6977 <p>
6978 The interaction between ranges and classes is not defined.
6980 have no meaning.
6981 </li>
6986 </li>
6988 </ul><p>
6990 the corresponding uppercase letter represents the complement of the class.
6994 <p>
6995 The definitions of letter, space, and other character groups
6996 depend on the current locale.
7006 <ul>
7008 <li>
7009 a single character class,
7010 which matches any single character in the class;
7011 </li>
7013 <li>
7015 which matches 0 or more repetitions of characters in the class.
7016 These repetition items will always match the longest possible sequence;
7017 </li>
7019 <li>
7021 which matches 1 or more repetitions of characters in the class.
7022 These repetition items will always match the longest possible sequence;
7023 </li>
7025 <li>
7027 which also matches 0 or more repetitions of characters in the class.
7030 </li>
7032 <li>
7035 </li>
7037 <li>
7040 (see below);
7041 </li>
7043 <li>
7047 This means that, if one reads the string from left to right,
7051 balanced parentheses.
7052 </li>
7054 </ul>
7062 beginning of the subject string.
7064 end of the subject string.
7065 At other positions,
7073 A pattern may contain sub-patterns enclosed in parentheses;
7075 When a match succeeds, the substrings of the subject string
7077 Captures are numbered according to their left parentheses.
7085 <p>
7087 the current string position (a number).
7092 <p>
7106 This library provides generic functions for table manipulation.
7110 <p>
7111 Most functions in the table library assume that the table
7112 represents an array or a list.
7113 For these functions, when we talk about the "length" of a table
7114 we mean the result of the length operator.
7117 <p>
7118 <hr><h3><a name="pdf-table.concat"><code>table.concat (table [, sep [, i [, j]]])</code></a></h3>
7119 Given an array where all elements are strings or numbers,
7129 <p>
7133 <p>
7135 shifting up other elements to open space, if necessary.
7144 <p>
7148 <p>
7149 Returns the largest positive numerical index of the given table,
7150 or zero if the table has no positive numerical indices.
7151 (To do its job this function does a linear traversal of
7152 the whole table.)
7157 <p>
7161 <p>
7163 shifting down other elements to close the space, if necessary.
7164 Returns the value of the removed element.
7173 <p>
7179 then it must be a function that receives two table elements,
7180 and returns true
7181 when the first is less than the second
7187 <p>
7188 The sort algorithm is not stable;
7189 that is, elements considered equal by the given order
7190 may have their relative positions changed by the sort.
7200 <p>
7201 This library is an interface to the standard C math library.
7205 <p>
7209 <p>
7215 <p>
7219 <p>
7225 <p>
7229 <p>
7235 <p>
7239 <p>
7245 <p>
7249 <p>
7251 but uses the signs of both parameters to find the
7252 quadrant of the result.
7258 <p>
7262 <p>
7268 <p>
7272 <p>
7278 <p>
7282 <p>
7288 <p>
7292 <p>
7298 <p>
7302 <p>
7308 <p>
7312 <p>
7318 <p>
7322 <p>
7328 <p>
7332 <p>
7341 <p>
7345 <p>
7347 a value larger than or equal to any other numerical value.
7352 <p>
7356 <p>
7362 <p>
7366 <p>
7372 <p>
7376 <p>
7382 <p>
7386 <p>
7387 Returns the maximum value among its arguments.
7392 <p>
7396 <p>
7397 Returns the minimum value among its arguments.
7402 <p>
7406 <p>
7407 Returns two numbers,
7413 <p>
7417 <p>
7423 <p>
7427 <p>
7434 <p>
7438 <p>
7444 <p>
7448 <p>
7449 This function is an interface to the simple
7451 (No guarantees can be given for its statistical properties.)
7454 <p>
7455 When called without arguments,
7456 returns a uniform pseudo-random real number
7468 <p>
7472 <p>
7474 for the pseudo-random generator:
7475 equal seeds produce equal sequences of numbers.
7480 <p>
7484 <p>
7490 <p>
7494 <p>
7500 <p>
7504 <p>
7511 <p>
7515 <p>
7521 <p>
7525 <p>
7536 <p>
7537 The I/O library provides two different styles for file manipulation.
7538 The first one uses implicit file descriptors;
7539 that is, there are operations to set a default input file and a
7540 default output file,
7541 and all input/output operations are over these default files.
7542 The second style uses explicit file descriptors.
7545 <p>
7546 When using implicit file descriptors,
7548 When using explicit file descriptors,
7550 and then all operations are supplied as methods of the file descriptor.
7553 <p>
7555 three predefined file descriptors with their usual meanings from C:
7556 <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>.
7557 The I/O library never closes these files.
7560 <p>
7561 Unless otherwise stated,
7563 (plus an error message as a second result and
7564 a system-dependent error code as a third result)
7568 <p>
7572 <p>
7579 <p>
7583 <p>
7589 <p>
7593 <p>
7594 When called with a file name, it opens the named file (in text mode),
7595 and sets its handle as the default input file.
7596 When called with a file handle,
7597 it simply sets this file handle as the default input file.
7598 When called without parameters,
7599 it returns the current default input file.
7602 <p>
7603 In case of errors this function raises the error,
7604 instead of returning an error code.
7609 <p>
7613 <p>
7614 Opens the given file name in read mode
7615 and returns an iterator function that,
7616 each time it is called,
7617 returns a new line from the file.
7618 Therefore, the construction
7620 <pre>
7622 </pre><p>
7623 will iterate over all lines of the file.
7624 When the iterator function detects the end of file,
7628 <p>
7631 that is, it iterates over the lines of the default input file.
7632 In this case it does not close the file when the loop ends.
7637 <p>
7641 <p>
7642 This function opens a file,
7644 It returns a new file handle,
7648 <p>
7651 <ul>
7658 writing is only allowed at the end of file.</li>
7659 </ul><p>
7661 which is needed in some systems to open the file in binary mode.
7662 This string is exactly what is used in the
7668 <p>
7672 <p>
7673 Similar to <a href="#pdf-io.input"><code>io.input</code></a>, but operates over the default output file.
7678 <p>
7682 <p>
7684 a file handle that you can use to read data from this program
7686 or to write data to this program
7690 <p>
7691 This function is system dependent and is not available
7692 on all platforms.
7697 <p>
7701 <p>
7707 <p>
7711 <p>
7712 Returns a handle for a temporary file.
7713 This file is opened in update mode
7714 and it is automatically removed when the program ends.
7719 <p>
7723 <p>
7732 <p>
7736 <p>
7742 <p>
7746 <p>
7748 Note that files are automatically closed when
7749 their handles are garbage collected,
7750 but that takes an unpredictable amount of time to happen.
7755 <p>
7759 <p>
7765 <p>
7769 <p>
7770 Returns an iterator function that,
7771 each time it is called,
7772 returns a new line from the file.
7773 Therefore, the construction
7775 <pre>
7777 </pre><p>
7778 will iterate over all lines of the file.
7779 (Unlike <a href="#pdf-io.lines"><code>io.lines</code></a>, this function does not close the file
7780 when the loop ends.)
7785 <p>
7789 <p>
7791 according to the given formats, which specify what to read.
7792 For each format,
7793 the function returns a string (or a number) with the characters read,
7795 When called without formats,
7796 it uses a default format that reads the entire next line
7797 (see below).
7800 <p>
7801 The available formats are
7803 <ul>
7806 reads a number;
7807 this is the only format that returns a number instead of a string.
7808 </li>
7811 reads the whole file, starting at the current position.
7812 On end of file, it returns the empty string.
7813 </li>
7816 reads the next line (skipping the end of line),
7818 This is the default format.
7819 </li>
7822 reads a string with up to this number of characters,
7824 If number is zero,
7825 it reads nothing and returns an empty string,
7827 </li>
7829 </ul>
7833 <p>
7837 <p>
7838 Sets and gets the file position,
7839 measured from the beginning of the file,
7843 <ul>
7847 </ul><p>
7849 measured in bytes from the beginning of the file.
7851 plus a string describing the error.
7854 <p>
7858 file position, without changing it;
7860 beginning of the file (and returns 0);
7862 end of the file, and returns its size.
7867 <p>
7871 <p>
7872 Sets the buffering mode for an output file.
7873 There are three available modes:
7875 <ul>
7878 no buffering; the result of any output operation appears immediately.
7879 </li>
7882 full buffering; output operation is performed only
7885 </li>
7888 line buffering; output is buffered until a newline is output
7889 or there is any input from some special files
7890 (such as a terminal device).
7891 </li>
7893 </ul><p>
7895 specifies the size of the buffer, in bytes.
7896 The default is an appropriate size.
7901 <p>
7905 <p>
7906 Writes the value of each of its arguments to
7908 The arguments must be strings or numbers.
7909 To write other values,
7910 use <a href="#pdf-tostring"><code>tostring</code></a> or <a href="#pdf-string.format"><code>string.format</code></a> before <code>write</code>.
7920 <p>
7924 <p>
7928 <p>
7929 Returns an approximation of the amount in seconds of CPU time
7930 used by the program.
7935 <p>
7939 <p>
7940 Returns a string or a table containing date and time,
7944 <p>
7946 this is the time to be formatted
7947 (see the <a href="#pdf-os.time"><code>os.time</code></a> function for a description of this value).
7951 <p>
7953 then the date is formatted in Coordinated Universal Time.
7954 After this optional character,
7964 <p>
7970 <p>
7971 When called without arguments,
7973 the host system and on the current locale
7979 <p>
7983 <p>
7985 In POSIX, Windows, and some other systems,
7991 <p>
7995 <p>
7998 It returns a status code, which is system-dependent.
8000 and zero otherwise.
8005 <p>
8009 <p>
8012 to terminate the host program.
8018 <p>
8022 <p>
8029 <p>
8033 <p>
8034 Deletes the file or directory with the given name.
8035 Directories must be empty to be removed.
8037 plus a string describing the error.
8042 <p>
8046 <p>
8049 plus a string describing the error.
8054 <p>
8058 <p>
8059 Sets the current locale of the program.
8065 The function returns the name of the new locale,
8069 <p>
8071 the current locale is set to an implementation-defined native locale.
8073 the current locale is set to the standard C locale.
8076 <p>
8078 this function only returns the name of the current locale
8079 for the given category.
8084 <p>
8088 <p>
8089 Returns the current time when called without arguments,
8090 or a time representing the date and time specified by the given table.
8092 and may have fields <code>hour</code>, <code>min</code>, <code>sec</code>, and <code>isdst</code>
8093 (for a description of these fields, see the <a href="#pdf-os.date"><code>os.date</code></a> function).
8096 <p>
8097 The returned value is a number, whose meaning depends on your system.
8098 In POSIX, Windows, and some other systems, this number counts the number
8099 of seconds since some given start time (the "epoch").
8100 In other systems, the meaning is not specified,
8107 <p>
8111 <p>
8112 Returns a string with a file name that can
8113 be used for a temporary file.
8114 The file must be explicitly opened before its use
8115 and explicitly removed when no longer needed.
8125 <p>
8126 This library provides
8127 the functionality of the debug interface to Lua programs.
8128 You should exert care when using this library.
8129 The functions provided here should be used exclusively for debugging
8130 and similar tasks, such as profiling.
8131 Please resist the temptation to use them as a
8132 usual programming tool:
8133 they can be very slow.
8134 Moreover, several of these functions
8135 violate some assumptions about Lua code
8136 (e.g., that variables local to a function
8137 cannot be accessed from outside or
8138 that userdata metatables cannot be changed by Lua code)
8139 and therefore can compromise otherwise secure code.
8142 <p>
8143 All functions in this library are provided
8145 All functions that operate over a thread
8146 have an optional first argument which is the
8147 thread to operate over.
8148 The default is always the current thread.
8151 <p>
8155 <p>
8156 Enters an interactive mode with the user,
8157 running each string that the user enters.
8158 Using simple commands and other debug facilities,
8159 the user can inspect global and local variables,
8160 change their values, evaluate expressions, and so on.
8162 so that the caller continues its execution.
8165 <p>
8167 within any function, and so have no direct access to local variables.
8172 <p>
8179 <p>
8183 <p>
8184 Returns the current hook settings of the thread, as three values:
8185 the current hook function, the current hook mask,
8186 and the current hook count
8192 <p>
8193 <hr><h3><a name="pdf-debug.getinfo"><code>debug.getinfo ([thread,] function [, what])</code></a></h3>
8196 <p>
8197 Returns a table with information about a function.
8198 You can give the function directly,
8201 of the given thread:
8204 and so on.
8209 <p>
8210 The returned table may contain all the fields returned by <a href="#lua_getinfo"><code>lua_getinfo</code></a>,
8213 except the table of valid lines.
8214 If present,
8217 If present,
8220 valid lines.
8223 <p>
8225 a table with a name for the current function,
8226 if a reasonable name can be found,
8228 returns a table with all available information
8234 <p>
8235 <hr><h3><a name="pdf-debug.getlocal"><code>debug.getlocal ([thread,] level, local)</code></a></h3>
8238 <p>
8239 This function returns the name and the value of the local variable
8242 until the last active local variable.)
8244 variable with the given index,
8246 (You can call <a href="#pdf-debug.getinfo"><code>debug.getinfo</code></a> to check whether the level is valid.)
8249 <p>
8251 represent internal variables
8252 (loop control variables, temporaries, and C function locals).
8257 <p>
8261 <p>
8268 <p>
8272 <p>
8278 <p>
8282 <p>
8283 This function returns the name and the value of the upvalue
8290 <p>
8294 <p>
8301 <p>
8302 <hr><h3><a name="pdf-debug.sethook"><code>debug.sethook ([thread,] hook, mask [, count])</code></a></h3>
8305 <p>
8306 Sets the given function as a hook.
8308 when the hook will be called.
8309 The string mask may have the following characters,
8310 with the given meaning:
8312 <ul>
8316 </ul><p>
8321 <p>
8322 When called without arguments,
8326 <p>
8327 When the hook is called, its first parameter is a string
8328 describing the event that has triggered its call:
8331 For line events,
8332 the hook also gets the new line number as its second parameter.
8333 Inside a hook,
8335 the running function
8339 In this case, Lua is only simulating the return,
8345 <p>
8346 <hr><h3><a name="pdf-debug.setlocal"><code>debug.setlocal ([thread,] level, local, value)</code></a></h3>
8349 <p>
8353 variable with the given index,
8356 Otherwise, it returns the name of the local variable.
8361 <p>
8362 <hr><h3><a name="pdf-debug.setmetatable"><code>debug.setmetatable (object, table)</code></a></h3>
8365 <p>
8372 <p>
8373 <hr><h3><a name="pdf-debug.setupvalue"><code>debug.setupvalue (func, up, value)</code></a></h3>
8376 <p>
8380 with the given index.
8381 Otherwise, it returns the name of the upvalue.
8386 <p>
8387 <hr><h3><a name="pdf-debug.traceback"><code>debug.traceback ([thread,] [message] [, level])</code></a></h3>
8390 <p>
8391 Returns a string with a traceback of the call stack.
8393 at the beginning of the traceback.
8395 to start the traceback
8406 <p>
8407 Although Lua has been designed as an extension language,
8408 to be embedded in a host C program,
8409 it is also frequently used as a stand-alone language.
8410 An interpreter for Lua as a stand-alone language,
8412 is provided with the standard distribution.
8413 The stand-alone interpreter includes
8414 all standard libraries, including the debug library.
8415 Its usage is:
8417 <pre>
8418 lua [options] [script [args]]
8419 </pre><p>
8420 The options are:
8422 <ul>
8428 <li><b><code>-</code>:</b> executes <code>stdin</code> as a file and stops handling options.</li>
8429 </ul><p>
8432 When called without arguments,
8438 <p>
8439 Before running any argument,
8440 the interpreter checks for an environment variable <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a>.
8446 <p>
8448 For instance, an invocation like
8450 <pre>
8451 $ lua -e'a=1' -e 'print(a)' script.lua
8452 </pre><p>
8453 will first set <code>a</code> to 1, then print the value of <code>a</code> (which is '<code>1</code>'),
8458 <p>
8459 Before starting to run the script,
8462 The script name is stored at index 0,
8463 the first argument after the script name goes to index 1,
8464 and so on.
8465 Any arguments before the script name
8466 (that is, the interpreter name plus the options)
8467 go to negative indices.
8468 For instance, in the call
8470 <pre>
8471 $ lua -la b.lua t1 t2
8472 </pre><p>
8474 then creates a table
8476 <pre>
8480 </pre><p>
8483 as arguments;
8487 <p>
8488 In interactive mode,
8489 if you write an incomplete statement,
8490 the interpreter waits for its completion
8491 by issuing a different prompt.
8494 <p>
8496 then its value is used as the prompt.
8497 Similarly, if the global variable <a name="pdf-_PROMPT2"><code>_PROMPT2</code></a> contains a string,
8498 its value is used as the secondary prompt
8499 (issued during incomplete statements).
8500 Therefore, both prompts can be changed directly on the command line
8502 See the next example:
8504 <pre>
8505 $ lua -e"_PROMPT='myprompt> '" -i
8506 </pre><p>
8507 (The outer pair of quotes is for the shell,
8508 the inner pair is for Lua.)
8510 otherwise,
8511 the program would just end silently
8515 <p>
8516 To allow the use of Lua as a
8517 script interpreter in Unix systems,
8518 the stand-alone interpreter skips
8520 Therefore, Lua scripts can be made into executable programs
8522 as in
8524 <pre>
8525 #!/usr/local/bin/lua
8526 </pre><p>
8527 (Of course,
8528 the location of the Lua interpreter may be different in your machine.
8530 then
8532 <pre>
8533 #!/usr/bin/env lua
8534 </pre><p>
8535 is a more portable solution.)
8541 <p>
8542 Here we list the incompatibilities that you may find when moving a program
8544 You can avoid most of the incompatibilities compiling Lua with
8546 However,
8547 all these compatibility options will be removed in the next version of Lua.
8552 <ul>
8554 <li>
8556 table with the extra arguments to the vararg expression.
8558 </li>
8560 <li>
8561 There was a subtle change in the scope of the implicit
8563 </li>
8565 <li>
8567 does not allow nesting.
8570 </li>
8572 </ul>
8578 <ul>
8580 <li>
8581 Function <code>string.gfind</code> was renamed <a href="#pdf-string.gmatch"><code>string.gmatch</code></a>.
8583 </li>
8585 <li>
8587 third argument,
8589 replacement string is the whole match,
8590 instead of the empty string.
8591 </li>
8593 <li>
8597 use the operator instead of the function.
8599 </li>
8601 <li>
8602 Function <code>loadlib</code> was renamed <a href="#pdf-package.loadlib"><code>package.loadlib</code></a>.
8604 </li>
8606 <li>
8607 Function <code>math.mod</code> was renamed <a href="#pdf-math.fmod"><code>math.fmod</code></a>.
8609 </li>
8611 <li>
8614 </li>
8616 <li>
8617 There were substantial changes in function <a href="#pdf-require"><code>require</code></a> due to
8618 the new module system.
8619 However, the new behavior is mostly compatible with the old,
8620 but <code>require</code> gets the path from <a href="#pdf-package.path"><code>package.path</code></a> instead
8622 </li>
8624 <li>
8625 Function <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> has different arguments.
8628 </li>
8630 </ul>
8636 <ul>
8638 <li>
8640 cannot be called directly,
8641 like a regular C function.
8642 They must be called through Lua,
8643 like a Lua function.
8644 </li>
8646 <li>
8647 Function <code>lua_open</code> was replaced by <a href="#lua_newstate"><code>lua_newstate</code></a> to
8648 allow the user to set a memory-allocation function.
8649 You can use <a href="#luaL_newstate"><code>luaL_newstate</code></a> from the standard library to
8650 create a state with a standard allocation function
8652 </li>
8654 <li>
8656 (from the auxiliary library) are deprecated.
8659 </li>
8661 <li>
8662 Function <code>luaL_openlib</code> was replaced by <a href="#luaL_register"><code>luaL_register</code></a>.
8663 </li>
8665 <li>
8667 is not a userdata of the expected type.
8669 </li>
8671 </ul>
8678 <p>
8679 Here is the complete syntax of Lua in extended BNF.
8680 (It does not describe operator precedences.)
8685 <pre>
8689 block ::= chunk
8692 functioncall |
8696 <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b> |
8697 <b>for</b> Name `<b>=</b>´ exp `<b>,</b>´ exp [`<b>,</b>´ exp] <b>do</b> block <b>end</b> |
8709 var ::= Name | prefixexp `<b>[</b>´ exp `<b>]</b>´ | prefixexp `<b>.</b>´ Name
8715 exp ::= <b>nil</b> | <b>false</b> | <b>true</b> | Number | String | `<b>...</b>´ | function |
8716 prefixexp | tableconstructor | exp binop exp | unop exp
8732 fieldlist ::= field {fieldsep field} [fieldsep]
8734 field ::= `<b>[</b>´ exp `<b>]</b>´ `<b>=</b>´ exp | Name `<b>=</b>´ exp | exp
8738 binop ::= `<b>+</b>´ | `<b>-</b>´ | `<b>*</b>´ | `<b>/</b>´ | `<b>^</b>´ | `<b>%</b>´ | `<b>..</b>´ |
8739 `<b><</b>´ | `<b><=</b>´ | `<b>></b>´ | `<b>>=</b>´ | `<b>==</b>´ | `<b>~=</b>´ |
8744 </pre>
8746 <p>
8754 <HR>
8755 <SMALL>
8756 Last update:
8758 </SMALL>
8759 <!--
8760 Last change: revised for Lua 5.1.3
8761 -->
8763 </body></html>