Mercurial Hosting > luan
annotate website/src/manual.html.luan @ 465:47c7de1f2322
documentation work
| author | Franklin Schmidt <fschmidt@gmail.com> |
|---|---|
| date | Thu, 07 May 2015 22:10:45 -0600 |
| parents | eddf7c73373b |
| children | 9b51e2413cab |
| rev | line source |
|---|---|
|
386
db23f654f87d
make all of website use luan
Franklin Schmidt <fschmidt@gmail.com>
parents:
382
diff
changeset
|
1 local Io = require "luan:Io" |
|
db23f654f87d
make all of website use luan
Franklin Schmidt <fschmidt@gmail.com>
parents:
382
diff
changeset
|
2 local Html = require "luan:Html" |
|
db23f654f87d
make all of website use luan
Franklin Schmidt <fschmidt@gmail.com>
parents:
382
diff
changeset
|
3 local Http = require "luan:web/Http" |
|
387
23d075ce1e48
add website/src/Shared.luan
Franklin Schmidt <fschmidt@gmail.com>
parents:
386
diff
changeset
|
4 local Shared = require "site:/Shared" |
|
386
db23f654f87d
make all of website use luan
Franklin Schmidt <fschmidt@gmail.com>
parents:
382
diff
changeset
|
5 |
|
db23f654f87d
make all of website use luan
Franklin Schmidt <fschmidt@gmail.com>
parents:
382
diff
changeset
|
6 |
|
db23f654f87d
make all of website use luan
Franklin Schmidt <fschmidt@gmail.com>
parents:
382
diff
changeset
|
7 function service() |
|
db23f654f87d
make all of website use luan
Franklin Schmidt <fschmidt@gmail.com>
parents:
382
diff
changeset
|
8 Io.stdout = Http.response.text_writer() |
|
391
2f5cc9c2cbf0
replace Html.simply_html_page with simply_html_head and simply_html_body_bottom
Franklin Schmidt <fschmidt@gmail.com>
parents:
389
diff
changeset
|
9 %> |
|
2f5cc9c2cbf0
replace Html.simply_html_page with simply_html_head and simply_html_body_bottom
Franklin Schmidt <fschmidt@gmail.com>
parents:
389
diff
changeset
|
10 <html> |
|
2f5cc9c2cbf0
replace Html.simply_html_page with simply_html_head and simply_html_body_bottom
Franklin Schmidt <fschmidt@gmail.com>
parents:
389
diff
changeset
|
11 <head> |
|
2f5cc9c2cbf0
replace Html.simply_html_page with simply_html_head and simply_html_body_bottom
Franklin Schmidt <fschmidt@gmail.com>
parents:
389
diff
changeset
|
12 <% Html.simply_html_head() %> |
|
2f5cc9c2cbf0
replace Html.simply_html_page with simply_html_head and simply_html_body_bottom
Franklin Schmidt <fschmidt@gmail.com>
parents:
389
diff
changeset
|
13 <title>Luan Reference Manual</title> |
|
2f5cc9c2cbf0
replace Html.simply_html_page with simply_html_head and simply_html_body_bottom
Franklin Schmidt <fschmidt@gmail.com>
parents:
389
diff
changeset
|
14 </head> |
|
2f5cc9c2cbf0
replace Html.simply_html_page with simply_html_head and simply_html_body_bottom
Franklin Schmidt <fschmidt@gmail.com>
parents:
389
diff
changeset
|
15 <body> |
|
386
db23f654f87d
make all of website use luan
Franklin Schmidt <fschmidt@gmail.com>
parents:
382
diff
changeset
|
16 |
| 372 | 17 <div container> |
|
387
23d075ce1e48
add website/src/Shared.luan
Franklin Schmidt <fschmidt@gmail.com>
parents:
386
diff
changeset
|
18 <% Shared.header() %> |
| 372 | 19 |
| 20 <h1>Luan Reference Manual</h1> | |
| 21 | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
22 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
23 <small> |
| 372 | 24 Original copyright © 2015 Lua.org, PUC-Rio. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
25 Freely available under the terms of the |
| 372 | 26 <a href="http://www.lua.org/license.html">Lua license</a>. |
| 27 Modified for Luan. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
28 </small> |
| 372 | 29 </p> |
| 30 | |
| 31 <hr/> | |
| 32 | |
| 33 <h2>Contents</h2> | |
| 34 | |
| 35 <div margin-bottom="1em"><a href="#intro">Introduction</a></div> | |
| 36 | |
| 373 | 37 <div margin-bottom="1em"> |
| 38 <a href="#basic">Basic Concepts</a> | |
| 39 <ul> | |
| 40 <li><a href="#types">Values and Types</a></li> | |
| 41 <li><a href="#env">Environments</a></li> | |
| 42 <li><a href="#error">Error Handling</a></li> | |
| 43 <li><a href="#meta">Metatables and Metamethods</a></li> | |
| 380 | 44 <li><a href="#gc">Garbage Collection</a></li> |
| 45 </ul> | |
| 46 </div> | |
| 47 | |
| 48 <div margin-bottom="1em"> | |
| 49 <a href="#lang">The Language</a> | |
| 50 <ul> | |
| 51 <li><a href="#lex">Lexical Conventions</a></li> | |
| 52 <li><a href="#vars">Variables</a></li> | |
| 389 | 53 <li> |
| 54 <a href="#stmts">Statements</a> | |
| 55 <ul> | |
| 56 <li><a href="#blocks">Blocks</a></li> | |
| 395 | 57 <li><a href="#chunks">Chunks</a></li> |
| 58 <li><a href="#assignment">Assignment</a></li> | |
| 59 <li><a href="#control">Control Structures</a></li> | |
| 60 <li><a href="#for">For Statement</a></li> | |
| 61 <li><a href="#fn_stmt">Function Calls as Statements</a></li> | |
| 62 <li><a href="#local_stmt">Local Declarations</a></li> | |
| 465 | 63 <li><a href="#template_stmt">Template Statements</a></li> |
| 395 | 64 </ul> |
| 65 </li> | |
| 66 <li> | |
| 67 <a href="#expressions">Expressions</a> | |
| 68 <ul> | |
| 69 <li><a href="#arithmetic">Arithmetic Operators</a></li> | |
| 396 | 70 <li><a href="#conversions">Coercions and Conversions</a></li> |
| 71 <li><a href="#relational">Relational Operators</a></li> | |
| 72 <li><a href="#logical_ops">Logical Operators</a></li> | |
| 73 <li><a href="#concatenation">Concatenation</a></li> | |
| 74 <li><a href="#length">The Length Operator</a></li> | |
| 75 <li><a href="#precedence">Precedence</a></li> | |
| 76 <li><a href="#constructors">Table Constructors</a></li> | |
| 417 | 77 <li><a href="#fn_calls">Function Calls</a></li> |
| 78 <li><a href="#fn_def">Function Definitions</a></li> | |
| 465 | 79 <li><a href="#template_expr">Template Expressions</a></li> |
| 389 | 80 </ul> |
| 81 </li> | |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
82 <li><a href="#visibility">Visibility Rules</a></li> |
| 373 | 83 </ul> |
| 84 </div> | |
| 85 | |
| 372 | 86 <hr/> |
| 87 | |
| 373 | 88 |
| 372 | 89 <h2 margin-top="1em"><a name="intro">Introduction</a></h2> |
| 90 | |
| 91 <p>Luan is a high level programming language based on <a href="http://www.lua.org">Lua</a>. A great strength of Lua is its simplicity and Luan takes this even further, being even simpler than Lua. The goal is to provide a simple programming language for the casual programmer with as few concepts as possible so that one can quickly learn the language and then easily understand any code written in Luan.</p> | |
| 92 | |
| 93 <p>Luan is implemented in Java and is tightly coupled with Java. So it makes a great scripting language for Java programmers.</p> | |
| 94 | |
| 95 <p>Unlike Lua which is meant to be embedded, Luan is meant to be a full scripting language. This done not by adding feature to Luan, but rather by providing a complete set of libraries.</p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
96 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
97 |
| 373 | 98 <h2 margin-top="1em"><a name="basic">Basic Concepts</a></h2> |
| 99 | |
| 100 <p>This section describes the basic concepts of the language.</p> | |
| 101 | |
| 102 <h3 margin-top="1em"><a name="types">Values and Types</a></h3> | |
| 103 | |
| 104 <p> | |
| 105 Luan is a <i>dynamically typed language</i>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
106 This means that |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
107 variables do not have types; only values do. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
108 There are no type definitions in the language. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
109 All values carry their own type. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
110 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
111 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
112 <p> |
| 373 | 113 All values in Luan are <i>first-class values</i>. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
114 This means that all values can be stored in variables, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
115 passed as arguments to other functions, and returned as results. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
116 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
117 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
118 <p> |
| 373 | 119 There are eight basic types in Luan: |
| 120 <i>nil</i>, <i>boolean</i>, <i>number</i>, | |
| 121 <i>string</i>, <i>binary</i>, <i>function</i>, <i>userdata</i>, | |
| 122 and <i>table</i>. | |
| 123 <i>Nil</i> is the type of the value <b>nil</b>, | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
124 whose main property is to be different from any other value; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
125 it usually represents the absence of a useful value. |
| 373 | 126 <i>Nil</i> is implemented as the Java value <i>null</i>. |
| 127 <i>Boolean</i> is the type of the values <b>false</b> and <b>true</b>. | |
| 128 <i>Boolean</i> is implemented as the Java class <i>Boolean</i>. | |
| 129 <i>Number</i> represents both | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
130 integer numbers and real (floating-point) numbers. |
| 373 | 131 <i>Number</i> is implemented as the Java class <i>Number</i>. Any Java subclass of <i>Number</i> is allowed and this is invisible to the Luan user. Operations on numbers follow the same rules of |
| 132 the underlying Java implementation. | |
| 133 | |
| 134 <i>String</i> is implemented as the Java class <i>String</i>. | |
| 135 <i>Binary</i> is implemented as the Java type <i>byte[]</i>. | |
| 136 | |
| 137 | |
| 138 <p> | |
| 139 Luan can call (and manipulate) functions written in Luan and | |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
140 functions written in Java (see <a href="#fn_calls">Function Calls</a>). |
| 373 | 141 Both are represented by the type <i>function</i>. |
| 142 | |
| 143 | |
| 144 <p> | |
| 145 The type <i>userdata</i> is provided to allow arbitrary Java objects to | |
| 146 be stored in Luan variables. | |
| 147 A userdata value is a Java object that isn't one of the standard Luan types. | |
| 148 Userdata has no predefined operations in Luan, | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
149 except assignment and identity test. |
| 373 | 150 Userdata is useful then Java access is enabled in Luan |
| 151 | |
| 152 | |
| 153 | |
| 154 <p> | |
| 155 The type <i>table</i> implements associative arrays, | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
156 that is, arrays that can be indexed not only with numbers, |
| 373 | 157 but with any Luan value except <b>nil</b>. |
| 158 Tables can be <i>heterogeneous</i>; | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
159 that is, they can contain values of all types (except <b>nil</b>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
160 Any key with value <b>nil</b> is not considered part of the table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
161 Conversely, any key that is not part of a table has |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
162 an associated value <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
163 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
164 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
165 <p> |
| 373 | 166 Tables are the sole data-structuring mechanism in Luan; |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
167 they can be used to represent ordinary arrays, sequences, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
168 symbol tables, sets, records, graphs, trees, etc. |
| 373 | 169 To represent records, Luan uses the field name as an index. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
170 The language supports this representation by |
| 373 | 171 providing <tt>a.name</tt> as syntactic sugar for <tt>a["name"]</tt>. |
| 172 There are several convenient ways to create tables in Luan | |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
173 (see <a href="#constructors">Table Constructors</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
174 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
175 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
176 <p> |
| 373 | 177 We use the term <i>sequence</i> to denote a table where |
| 178 the set of all positive numeric keys is equal to {1..<i>n</i>} | |
| 179 for some non-negative integer <i>n</i>, | |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
180 which is called the length of the sequence (see <a href="#length">The Length Operator</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
181 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
182 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
183 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
184 Like indices, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
185 the values of table fields can be of any type. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
186 In particular, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
187 because functions are first-class values, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
188 table fields can contain functions. |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
189 Thus tables can also carry <i>methods</i> (see <a href="#fn_def">Function Definitions</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
190 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
191 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
192 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
193 The indexing of tables follows |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
194 the definition of raw equality in the language. |
| 373 | 195 The expressions <tt>a[i]</tt> and <tt>a[j]</tt> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
196 denote the same table element |
| 373 | 197 if and only if <tt>i</tt> and <tt>j</tt> are raw equal |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
198 (that is, equal without metamethods). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
199 In particular, floats with integral values |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
200 are equal to their respective integers |
| 373 | 201 (e.g., <tt>1.0 == 1</tt>). |
| 202 | |
| 203 | |
| 204 <p> | |
| 205 Luan values are <i>objects</i>: | |
| 206 variables do not actually <i>contain</i> values, | |
| 207 only <i>references</i> to them. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
208 Assignment, parameter passing, and function returns |
| 373 | 209 always manipulate references to values; |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
210 these operations do not imply any kind of copy. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
211 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
212 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
213 <p> |
| 373 | 214 The library function <a href="#pdf-type"><tt>Luan.type</tt></a> returns a string describing the type |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
215 of a given value (see <a href="#6.1">§6.1</a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
216 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
217 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
218 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
219 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
220 |
| 373 | 221 <h3 margin-top="1em"><a name="env">Environments</a></h3> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
222 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
223 <p> |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
224 As will be discussed in <a href="#vars">Variables</a> and <a href=#assignment">Assignment</a>, |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
225 any reference to a free name |
| 373 | 226 (that is, a name not bound to any declaration) <tt>var</tt> |
| 227 is syntactically translated to <tt>_ENV.var</tt>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
228 Moreover, every chunk is compiled in the scope of |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
229 an external local variable named <tt>_ENV</tt> (see <a href="#chunks">Chunks</a>), |
| 373 | 230 so <tt>_ENV</tt> itself is never a free name in a chunk. |
| 231 | |
| 232 | |
| 233 <p> | |
| 234 Despite the existence of this external <tt>_ENV</tt> variable and | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
235 the translation of free names, |
| 373 | 236 <tt>_ENV</tt> is a completely regular name. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
237 In particular, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
238 you can define new variables and parameters with that name. |
| 373 | 239 Each reference to a free name uses the <tt>_ENV</tt> that is |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
240 visible at that point in the program, |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
241 following the usual visibility rules of Luan (see <a href="#visibility">Visibility Rules</a>). |
| 373 | 242 |
| 243 | |
| 244 <p> | |
| 245 Any table used as the value of <tt>_ENV</tt> is called an <i>environment</i>. | |
| 246 | |
| 247 | |
| 248 <p> | |
| 249 When Luan loads a chunk, | |
| 250 the default value for its <tt>_ENV</tt> is an empty table. | |
| 251 | |
| 252 <p> | |
| 253 Luan also provides all chunks with two other local values: <tt>require</tt> and <tt>java</tt>. These are functions used to load and access libraries and other modules. | |
| 254 | |
| 255 | |
| 256 | |
| 257 | |
| 258 <h3 margin-top="1em"><a name="error">Error Handling</a></h3> | |
| 259 | |
| 260 <p> | |
| 261 Luan code can explicitly generate an error by calling the | |
| 262 <a href="#pdf-error"><tt>error</tt></a> function. | |
| 263 If you need to catch errors in Luan, | |
| 264 you can use <a href="#pdf-pcall"><tt>pcall</tt></a> or <a href="#pdf-xpcall"><tt>try</tt></a> | |
| 265 to call a given function in <i>protected mode</i>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
266 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
267 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
268 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
269 Whenever there is an error, |
| 373 | 270 an <i>error object</i> (also called an <i>error message</i>) |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
271 is propagated with information about the error. |
| 373 | 272 Luan itself only generates errors whose error object is a string, |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
273 but programs may generate errors with |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
274 any value as the error object. |
| 373 | 275 It is up to the Luan program or its host to handle such error objects. |
| 276 | |
| 277 | |
| 278 | |
| 279 | |
| 280 | |
| 281 <h3 margin-top="1em"><a name="meta">Metatables and Metamethods</a></h3> | |
| 282 | |
| 283 <p> | |
| 284 Every table in Luan can have a <i>metatable</i>. | |
| 285 This <i>metatable</i> is an ordinary Luan table | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
286 that defines the behavior of the original value |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
287 under certain special operations. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
288 You can change several aspects of the behavior |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
289 of operations over a value by setting specific fields in its metatable. |
| 373 | 290 For instance, when a table is the operand of an addition, |
| 291 Luan checks for a function in the field "<tt>__add</tt>" of the table's metatable. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
292 If it finds one, |
| 373 | 293 Luan calls this function to perform the addition. |
| 294 | |
| 295 | |
| 296 <p> | |
| 297 The keys in a metatable are derived from the <i>event</i> names; | |
| 298 the corresponding values are called <ii>metamethods</i>. | |
| 299 In the previous example, the event is <tt>"add"</tt> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
300 and the metamethod is the function that performs the addition. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
301 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
302 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
303 <p> |
| 373 | 304 You can query the metatable of any table |
| 305 using the <a href="#pdf-getmetatable"><tt>get_metatable</tt></a> function. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
306 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
307 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
308 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
309 You can replace the metatable of tables |
| 373 | 310 using the <a href="#pdf-setmetatable"><tt>set_metatable</tt></a> function. |
| 311 | |
| 312 | |
| 313 <p> | |
| 314 A metatable controls how a table behaves in | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
315 arithmetic operations, bitwise operations, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
316 order comparisons, concatenation, length operation, calls, and indexing. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
317 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
318 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
319 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
320 A detailed list of events controlled by metatables is given next. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
321 Each operation is identified by its corresponding event name. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
322 The key for each event is a string with its name prefixed by |
| 373 | 323 two underscores, '<tt>__</tt>'; |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
324 for instance, the key for operation "add" is the |
| 373 | 325 string "<tt>__add</tt>". |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
326 Note that queries for metamethods are always raw; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
327 the access to a metamethod does not invoke other metamethods. |
| 373 | 328 You can emulate how Luan queries a metamethod for an object <tt>obj</tt> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
329 with the following code: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
330 |
| 382 | 331 <p><tt><pre> |
| 373 | 332 raw_get(get_metatable(obj) or {}, "__" .. event_name) |
| 382 | 333 </pre></tt></p> |
| 373 | 334 |
| 335 <p> | |
| 336 Here are the events: | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
337 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
338 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
339 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
340 <li><b>"add": </b> |
| 373 | 341 the <tt>+</tt> operation. |
| 342 | |
| 343 If any operand for an addition is a table, | |
| 344 Luan will try to call a metamethod. | |
| 345 First, Luan will check the first operand (even if it is valid). | |
| 346 If that operand does not define a metamethod for the "<tt>__add</tt>" event, | |
| 347 then Luan will check the second operand. | |
| 348 If Luan can find a metamethod, | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
349 it calls the metamethod with the two operands as arguments, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
350 and the result of the call |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
351 (adjusted to one value) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
352 is the result of the operation. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
353 Otherwise, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
354 it raises an error. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
355 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
356 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
357 <li><b>"sub": </b> |
| 373 | 358 the <tt>-</tt> operation. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
359 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
360 Behavior similar to the "add" operation. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
361 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
362 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
363 <li><b>"mul": </b> |
| 373 | 364 the <tt>*</tt> operation. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
365 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
366 Behavior similar to the "add" operation. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
367 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
368 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
369 <li><b>"div": </b> |
| 373 | 370 the <tt>/</tt> operation. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
371 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
372 Behavior similar to the "add" operation. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
373 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
374 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
375 <li><b>"mod": </b> |
| 373 | 376 the <tt>%</tt> operation. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
377 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
378 Behavior similar to the "add" operation. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
379 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
380 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
381 <li><b>"pow": </b> |
| 373 | 382 the <tt>^</tt> (exponentiation) operation. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
383 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
384 Behavior similar to the "add" operation. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
385 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
386 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
387 <li><b>"unm": </b> |
| 373 | 388 the <tt>-</tt> (unary minus) operation. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
389 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
390 Behavior similar to the "add" operation. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
391 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
392 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
393 <li><b>"concat": </b> |
| 373 | 394 the <tt>..</tt> (concatenation) operation. |
| 395 | |
| 396 Behavior similar to the "add" operation. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
397 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
398 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
399 <li><b>"len": </b> |
| 373 | 400 the <tt>#</tt> (length) operation. |
| 401 | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
402 If there is a metamethod, |
| 373 | 403 Luan calls it with the object as argument, |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
404 and the result of the call |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
405 (always adjusted to one value) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
406 is the result of the operation. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
407 If there is no metamethod but the object is a table, |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
408 then Luan uses the table length operation (see <a href="#length">The Length Operator</a>). |
| 373 | 409 Otherwise, Luan raises an error. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
410 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
411 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
412 <li><b>"eq": </b> |
| 373 | 413 the <tt>==</tt> (equal) operation. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
414 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
415 Behavior similar to the "add" operation, |
| 373 | 416 except that Luan will try a metamethod only when the values |
| 417 being compared are both tables | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
418 and they are not primitively equal. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
419 The result of the call is always converted to a boolean. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
420 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
421 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
422 <li><b>"lt": </b> |
| 373 | 423 the <tt><</tt> (less than) operation. |
| 424 | |
| 425 Behavior similar to the "add" operation. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
426 The result of the call is always converted to a boolean. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
427 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
428 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
429 <li><b>"le": </b> |
| 373 | 430 the <tt><=</tt> (less equal) operation. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
431 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
432 Unlike other operations, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
433 The less-equal operation can use two different events. |
| 373 | 434 First, Luan looks for the "<tt>__le</tt>" metamethod in both operands, |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
435 like in the "lt" operation. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
436 If it cannot find such a metamethod, |
| 373 | 437 then it will try the "<tt>__lt</tt>" event, |
| 438 assuming that <tt>a <= b</tt> is equivalent to <tt>not (b < a)</tt>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
439 As with the other comparison operators, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
440 the result is always a boolean. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
441 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
442 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
443 <li><b>"index": </b> |
| 373 | 444 The indexing access <tt>table[key]</tt>. |
| 445 | |
| 446 This event happens | |
| 447 when <tt>key</tt> is not present in <tt>table</tt>. | |
| 448 The metamethod is looked up in <tt>table</tt>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
449 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
450 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
451 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
452 Despite the name, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
453 the metamethod for this event can be either a function or a table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
454 If it is a function, |
| 373 | 455 it is called with <tt>table</tt> and <tt>key</tt> as arguments. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
456 If it is a table, |
| 373 | 457 the final result is the result of indexing this table with <tt>key</tt>. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
458 (This indexing is regular, not raw, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
459 and therefore can trigger another metamethod.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
460 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
461 |
|
428
df95199ca4c0
rename __newindex to __new_index
Franklin Schmidt <fschmidt@gmail.com>
parents:
418
diff
changeset
|
462 <li><b>"new_index": </b> |
| 373 | 463 The indexing assignment <tt>table[key] = value</tt>. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
464 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
465 Like the index event, |
| 373 | 466 this event happens when |
| 467 when <tt>key</tt> is not present in <tt>table</tt>. | |
| 468 The metamethod is looked up in <tt>table</tt>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
469 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
470 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
471 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
472 Like with indexing, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
473 the metamethod for this event can be either a function or a table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
474 If it is a function, |
| 373 | 475 it is called with <tt>table</tt>, <tt>key</tt>, and <tt>value</tt> as arguments. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
476 If it is a table, |
| 373 | 477 Luan does an indexing assignment to this table with the same key and value. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
478 (This assignment is regular, not raw, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
479 and therefore can trigger another metamethod.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
480 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
481 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
482 <p> |
|
428
df95199ca4c0
rename __newindex to __new_index
Franklin Schmidt <fschmidt@gmail.com>
parents:
418
diff
changeset
|
483 Whenever there is a "new_index" metamethod, |
| 373 | 484 Luan does not perform the primitive assignment. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
485 (If necessary, |
| 373 | 486 the metamethod itself can call <a href="#pdf-rawset"><tt>raw_set</tt></a> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
487 to do the assignment.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
488 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
489 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
490 <li><b>"call": </b> |
| 373 | 491 The call operation <tt>func(args)</tt>. |
| 492 | |
| 493 This event happens when Luan tries to call a table. | |
| 494 The metamethod is looked up in <tt>func</tt>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
495 If present, |
| 373 | 496 the metamethod is called with <tt>func</tt> as its first argument, |
| 497 followed by the arguments of the original call (<tt>args</tt>). | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
498 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
499 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
500 </ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
501 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
502 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
503 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
504 |
| 380 | 505 <h3 margin-top="1em"><a name="gc">Garbage Collection</a></h3> |
| 506 | |
| 507 <p> | |
| 508 Luan uses Java's garbage collection. | |
| 509 | |
| 510 | |
| 511 | |
| 512 | |
| 513 | |
| 514 <h2 margin-top="1em"><a name="lang">The Language</a></h2> | |
| 515 | |
| 516 <p> | |
| 517 This section describes the lexis, the syntax, and the semantics of Luan. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
518 In other words, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
519 this section describes |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
520 which tokens are valid, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
521 how they can be combined, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
522 and what their combinations mean. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
523 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
524 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
525 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
526 Language constructs will be explained using the usual extended BNF notation, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
527 in which |
| 380 | 528 {<i>a</i>} means 0 or more <i>a</i>'s, and |
| 529 [<i>a</i>] means an optional <i>a</i>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
530 Non-terminals are shown like non-terminal, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
531 keywords are shown like <b>kword</b>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
532 and other terminal symbols are shown like ‘<b>=</b>’. |
| 380 | 533 The complete syntax of Luan can be found in <a href="#9">§9</a> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
534 at the end of this manual. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
535 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
536 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
537 |
| 380 | 538 <h3 margin-top="1em"><a name="lex">Lexical Conventions</a></h3> |
| 539 | |
| 540 <p> | |
| 541 Luan ignores spaces and comments | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
542 between lexical elements (tokens), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
543 except as delimiters between names and keywords. |
| 380 | 544 Luan generally considers the end of a line to be the end of a statement. This catches errors and encourages readability. The exception to this is in paranthesis ( <i>(...)</i>, <i>[...]</i>, and <i>{...}</i> ) where the end of line is treated as white space. |
| 545 | |
| 546 <p> | |
| 547 <i>Names</i> | |
| 548 (also called <i>identifiers</i>) | |
| 549 in Luan can be any string of letters, | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
550 digits, and underscores, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
551 not beginning with a digit. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
552 Identifiers are used to name variables, table fields, and labels. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
553 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
554 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
555 <p> |
| 380 | 556 The following <i>keywords</i> are reserved |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
557 and cannot be used as names: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
558 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
559 |
| 389 | 560 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
561 and break do else elseif end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
562 false for function goto if in |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
563 local nil not or repeat return |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
564 then true until while |
| 389 | 565 </pre></tt></p> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
566 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
567 <p> |
| 380 | 568 Luan is a case-sensitive language: |
| 569 <tt>and</tt> is a reserved word, but <tt>And</tt> and <tt>AND</tt> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
570 are two different, valid names. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
571 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
572 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
573 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
574 The following strings denote other tokens: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
575 |
| 389 | 576 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
577 + - * / % ^ # |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
578 & ~ | << >> // |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
579 == ~= <= >= < > = |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
580 ( ) { } [ ] :: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
581 ; : , . .. ... |
| 389 | 582 </pre></tt></p> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
583 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
584 <p> |
| 380 | 585 <i>Literal strings</i> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
586 can be delimited by matching single or double quotes, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
587 and can contain the following C-like escape sequences: |
| 380 | 588 '<tt>\a</tt>' (bell), |
| 589 '<tt>\b</tt>' (backspace), | |
| 590 '<tt>\f</tt>' (form feed), | |
| 591 '<tt>\n</tt>' (newline), | |
| 592 '<tt>\r</tt>' (carriage return), | |
| 593 '<tt>\t</tt>' (horizontal tab), | |
| 594 '<tt>\v</tt>' (vertical tab), | |
| 595 '<tt>\\</tt>' (backslash), | |
| 596 '<tt>\"</tt>' (quotation mark [double quote]), | |
| 597 and '<tt>\'</tt>' (apostrophe [single quote]). | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
598 A backslash followed by a real newline |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
599 results in a newline in the string. |
| 380 | 600 The escape sequence '<tt>\z</tt>' skips the following span |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
601 of white-space characters, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
602 including line breaks; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
603 it is particularly useful to break and indent a long literal string |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
604 into multiple lines without adding the newlines and spaces |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
605 into the string contents. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
606 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
607 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
608 <p> |
| 380 | 609 Luan can specify any character in a literal string by its numerical value. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
610 This can be done |
| 380 | 611 with the escape sequence <tt>\x<i>XX</i></tt>, |
| 612 where <i>XX</i> is a sequence of exactly two hexadecimal digits, | |
| 613 or with the escape sequence <tt>\<i>ddd</i></tt>, | |
| 614 where <i>ddd</i> is a sequence of up to three decimal digits. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
615 (Note that if a decimal escape sequence is to be followed by a digit, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
616 it must be expressed using exactly three digits.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
617 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
618 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
619 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
620 Literal strings can also be defined using a long format |
| 380 | 621 enclosed by <i>long brackets</i>. |
| 622 We define an <i>opening long bracket of level <i>n</i></i> as an opening | |
| 623 square bracket followed by <i>n</i> equal signs followed by another | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
624 opening square bracket. |
| 380 | 625 So, an opening long bracket of level 0 is written as <tt>[[</tt>, |
| 626 an opening long bracket of level 1 is written as <tt>[=[</tt>, | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
627 and so on. |
| 380 | 628 A <i>closing long bracket</i> is defined similarly; |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
629 for instance, |
| 380 | 630 a closing long bracket of level 4 is written as <tt>]====]</tt>. |
| 631 A <i>long literal</i> starts with an opening long bracket of any level and | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
632 ends at the first closing long bracket of the same level. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
633 It can contain any text except a closing bracket of the same level. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
634 Literals in this bracketed form can run for several lines, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
635 do not interpret any escape sequences, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
636 and ignore long brackets of any other level. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
637 Any kind of end-of-line sequence |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
638 (carriage return, newline, carriage return followed by newline, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
639 or newline followed by carriage return) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
640 is converted to a simple newline. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
641 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
642 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
643 <p> |
| 380 | 644 Any character in a literal string not |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
645 explicitly affected by the previous rules represents itself. |
| 380 | 646 However, Luan opens files for parsing in text mode, |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
647 and the system file functions may have problems with |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
648 some control characters. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
649 So, it is safer to represent |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
650 non-text data as a quoted literal with |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
651 explicit escape sequences for non-text characters. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
652 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
653 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
654 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
655 For convenience, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
656 when the opening long bracket is immediately followed by a newline, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
657 the newline is not included in the string. |
| 380 | 658 As an example |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
659 the five literal strings below denote the same string: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
660 |
| 389 | 661 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
662 a = 'alo\n123"' |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
663 a = "alo\n123\"" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
664 a = '\97lo\10\04923"' |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
665 a = [[alo |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
666 123"]] |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
667 a = [==[ |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
668 alo |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
669 123"]==] |
| 389 | 670 </pre></tt></p> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
671 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
672 <p> |
| 380 | 673 A <i>numerical constant</i> (or <i>numeral</i>) |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
674 can be written with an optional fractional part |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
675 and an optional decimal exponent, |
| 380 | 676 marked by a letter '<tt>e</tt>' or '<tt>E</tt>'. |
| 677 Luan also accepts hexadecimal constants, | |
| 678 which start with <tt>0x</tt> or <tt>0X</tt>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
679 Hexadecimal constants also accept an optional fractional part |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
680 plus an optional binary exponent, |
| 380 | 681 marked by a letter '<tt>p</tt>' or '<tt>P</tt>'. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
682 A numeric constant with a fractional dot or an exponent |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
683 denotes a float; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
684 otherwise it denotes an integer. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
685 Examples of valid integer constants are |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
686 |
| 389 | 687 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
688 3 345 0xff 0xBEBADA |
| 389 | 689 </pre></tt></p> |
| 382 | 690 |
| 691 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
692 Examples of valid float constants are |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
693 |
| 389 | 694 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
695 3.0 3.1416 314.16e-2 0.31416E1 34e1 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
696 0x0.1E 0xA23p-4 0X1.921FB54442D18P+1 |
| 389 | 697 </pre></tt></p> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
698 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
699 <p> |
| 380 | 700 A <i>comment</i> starts with a double hyphen (<tt>--</tt>) |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
701 anywhere outside a string. |
| 380 | 702 If the text immediately after <tt>--</tt> is not an opening long bracket, |
| 703 the comment is a <i>short comment</i>, | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
704 which runs until the end of the line. |
| 380 | 705 Otherwise, it is a <i>long comment</i>, |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
706 which runs until the corresponding closing long bracket. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
707 Long comments are frequently used to disable code temporarily. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
708 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
709 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
710 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
711 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
712 |
| 380 | 713 <h3 margin-top="1em"><a name="vars">Variables</a></h3> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
714 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
715 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
716 Variables are places that store values. |
| 380 | 717 There are three kinds of variables in Luan: |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
718 global variables, local variables, and table fields. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
719 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
720 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
721 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
722 A single name can denote a global variable or a local variable |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
723 (or a function's formal parameter, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
724 which is a particular kind of local variable): |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
725 |
| 389 | 726 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
727 var ::= Name |
| 389 | 728 </pre></tt></p> |
| 382 | 729 |
| 730 <p> | |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
731 Name denotes identifiers, as defined in <a href="#lex">Lexical Conventions</a>. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
732 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
733 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
734 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
735 Any variable name is assumed to be global unless explicitly declared |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
736 as a local (see <a href="#local_stmt">Local Declarations</a>). |
| 380 | 737 Local variables are <i>lexically scoped</i>: |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
738 local variables can be freely accessed by functions |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
739 defined inside their scope (see <a href="#visibility">Visibility Rules</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
740 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
741 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
742 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
743 Before the first assignment to a variable, its value is <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
744 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
745 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
746 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
747 Square brackets are used to index a table: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
748 |
| 389 | 749 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
750 var ::= prefixexp ‘<b>[</b>’ exp ‘<b>]</b>’ |
| 389 | 751 </pre></tt></p> |
| 382 | 752 |
| 753 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
754 The meaning of accesses to table fields can be changed via metatables. |
| 380 | 755 An access to an indexed variable <tt>t[i]</tt> is equivalent to |
| 756 a call <tt>gettable_event(t,i)</tt>. | |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
757 (See <a href="#meta">Metatables and Metamethods</a> for a complete description of the |
| 380 | 758 <tt>gettable_event</tt> function. |
| 759 This function is not defined or callable in Luan. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
760 We use it here only for explanatory purposes.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
761 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
762 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
763 <p> |
| 380 | 764 The syntax <tt>var.Name</tt> is just syntactic sugar for |
| 765 <tt>var["Name"]</tt>: | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
766 |
| 389 | 767 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
768 var ::= prefixexp ‘<b>.</b>’ Name |
| 389 | 769 </pre></tt></p> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
770 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
771 <p> |
| 380 | 772 An access to a global variable <tt>x</tt> |
| 773 is equivalent to <tt>_ENV.x</tt>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
774 Due to the way that chunks are compiled, |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
775 <tt>_ENV</tt> is never a global name (see <a href="#env">Environments</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
776 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
777 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
778 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
779 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
780 |
| 389 | 781 <h3 margin-top="1em"><a name="stmts">Statements</a></h3> |
| 782 | |
| 783 <p> | |
| 784 Luan supports an almost conventional set of statements, | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
785 similar to those in Pascal or C. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
786 This set includes |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
787 assignments, control structures, function calls, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
788 and variable declarations. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
789 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
790 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
791 |
| 395 | 792 <h4 margin-top="1em"><a name="blocks">Blocks</a></h4> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
793 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
794 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
795 A block is a list of statements, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
796 which are executed sequentially: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
797 |
| 389 | 798 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
799 block ::= {stat} |
| 389 | 800 </pre></tt></p> |
| 801 | |
| 802 <p> | |
| 803 Luan has <i>empty statements</i> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
804 that allow you to separate statements with semicolons, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
805 start a block with a semicolon |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
806 or write two semicolons in sequence: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
807 |
| 389 | 808 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
809 stat ::= ‘<b>;</b>’ |
| 389 | 810 </pre></tt></p> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
811 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
812 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
813 A block can be explicitly delimited to produce a single statement: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
814 |
| 389 | 815 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
816 stat ::= <b>do</b> block <b>end</b> |
| 389 | 817 </pre></tt></p> |
| 818 | |
| 819 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
820 Explicit blocks are useful |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
821 to control the scope of variable declarations. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
822 Explicit blocks are also sometimes used to |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
823 add a <b>return</b> statement in the middle |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
824 of another block (see <a href="#control">Control Structures</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
825 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
826 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
827 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
828 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
829 |
| 395 | 830 <h4 margin-top="1em"><a name="chunks">Chunks</a></h4> |
| 831 | |
| 832 <p> | |
| 833 The unit of compilation of Luan is called a <i>chunk</i>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
834 Syntactically, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
835 a chunk is simply a block: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
836 |
| 395 | 837 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
838 chunk ::= block |
| 395 | 839 </pre></tt></p> |
| 840 | |
| 841 <p> | |
| 842 Luan handles a chunk as the body of an anonymous function | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
843 with a variable number of arguments |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
844 (see <a href="#fn_def">Function Definitions</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
845 As such, chunks can define local variables, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
846 receive arguments, and return values. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
847 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
848 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
849 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
850 A chunk can be stored in a file or in a string inside the host program. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
851 To execute a chunk, |
| 395 | 852 Luan first <i>loads</i> it, |
| 853 compiling the chunk's code, | |
| 854 and then Luan executes the compiled code. | |
| 855 | |
| 856 | |
| 857 | |
| 858 | |
| 859 | |
| 860 <h4 margin-top="1em"><a name="assignment">Assignment</a></h4> | |
| 861 | |
| 862 <p> | |
| 863 Luan allows multiple assignments. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
864 Therefore, the syntax for assignment |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
865 defines a list of variables on the left side |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
866 and a list of expressions on the right side. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
867 The elements in both lists are separated by commas: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
868 |
| 395 | 869 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
870 stat ::= varlist ‘<b>=</b>’ explist |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
871 varlist ::= var {‘<b>,</b>’ var} |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
872 explist ::= exp {‘<b>,</b>’ exp} |
| 395 | 873 </pre></tt></p> |
| 874 | |
| 875 <p> | |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
876 Expressions are discussed in <a href="#expressions">Expressions</a>. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
877 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
878 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
879 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
880 Before the assignment, |
| 395 | 881 the list of values is <i>adjusted</i> to the length of |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
882 the list of variables. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
883 If there are more values than needed, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
884 the excess values are thrown away. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
885 If there are fewer values than needed, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
886 the list is extended with as many <b>nil</b>'s as needed. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
887 If the list of expressions ends with a function call, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
888 then all values returned by that call enter the list of values, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
889 before the adjustment |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
890 (except when the call is enclosed in parentheses; see <a href="#expressions">Expressions</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
891 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
892 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
893 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
894 The assignment statement first evaluates all its expressions |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
895 and only then the assignments are performed. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
896 Thus the code |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
897 |
| 395 | 898 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
899 i = 3 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
900 i, a[i] = i+1, 20 |
| 395 | 901 </pre></tt></p> |
| 902 | |
| 903 <p> | |
| 904 sets <tt>a[3]</tt> to 20, without affecting <tt>a[4]</tt> | |
| 905 because the <tt>i</tt> in <tt>a[i]</tt> is evaluated (to 3) | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
906 before it is assigned 4. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
907 Similarly, the line |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
908 |
| 395 | 909 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
910 x, y = y, x |
| 395 | 911 </pre></tt></p> |
| 912 | |
| 913 <p> | |
| 914 exchanges the values of <tt>x</tt> and <tt>y</tt>, | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
915 and |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
916 |
| 395 | 917 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
918 x, y, z = y, z, x |
| 395 | 919 </pre></tt></p> |
| 920 | |
| 921 <p> | |
| 922 cyclically permutes the values of <tt>x</tt>, <tt>y</tt>, and <tt>z</tt>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
923 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
924 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
925 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
926 The meaning of assignments to global variables |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
927 and table fields can be changed via metatables. |
| 395 | 928 An assignment to an indexed variable <tt>t[i] = val</tt> is equivalent to |
| 929 <tt>settable_event(t,i,val)</tt>. | |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
930 (See <a href="#meta">Metatables and Metamethods</a> for a complete description of the |
| 395 | 931 <tt>settable_event</tt> function. |
| 932 This function is not defined or callable in Luan. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
933 We use it here only for explanatory purposes.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
934 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
935 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
936 <p> |
| 395 | 937 An assignment to a global name <tt>x = val</tt> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
938 is equivalent to the assignment |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
939 <tt>_ENV.x = val</tt> (see <a href="#env">Environments</a>). |
| 395 | 940 |
| 941 | |
| 942 | |
| 943 | |
| 944 <h4 margin-top="1em"><a name="control">Control Structures</a></h4> | |
| 945 | |
| 946 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
947 The control structures |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
948 <b>if</b>, <b>while</b>, and <b>repeat</b> have the usual meaning and |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
949 familiar syntax: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
950 |
| 395 | 951 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
952 stat ::= <b>while</b> exp <b>do</b> block <b>end</b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
953 stat ::= <b>repeat</b> block <b>until</b> exp |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
954 stat ::= <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b> |
| 395 | 955 </pre></tt></p> |
| 956 | |
| 957 <p> | |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
958 Luan also has a <b>for</b> statement (see <a href="#for">For Statement</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
959 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
960 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
961 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
962 The condition expression of a |
| 395 | 963 control structure must be a boolean. |
| 964 Any other value type will produce an error. | |
| 965 This helps catch errors and makes code more readable. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
966 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
967 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
968 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
969 In the <b>repeat</b>–<b>until</b> loop, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
970 the inner block does not end at the <b>until</b> keyword, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
971 but only after the condition. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
972 So, the condition can refer to local variables |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
973 declared inside the loop block. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
974 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
975 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
976 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
977 The <b>break</b> statement terminates the execution of a |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
978 <b>while</b>, <b>repeat</b>, or <b>for</b> loop, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
979 skipping to the next statement after the loop: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
980 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
981 |
| 395 | 982 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
983 stat ::= <b>break</b> |
| 395 | 984 </pre></tt></p> |
| 985 | |
| 986 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
987 A <b>break</b> ends the innermost enclosing loop. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
988 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
989 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
990 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
991 The <b>return</b> statement is used to return values |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
992 from a function or a chunk |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
993 (which is an anonymous function). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
994 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
995 Functions can return more than one value, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
996 so the syntax for the <b>return</b> statement is |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
997 |
| 395 | 998 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
999 stat ::= <b>return</b> [explist] [‘<b>;</b>’] |
| 395 | 1000 </pre></tt></p> |
| 1001 | |
| 1002 | |
| 1003 | |
| 1004 | |
| 1005 <h4 margin-top="1em"><a name="for">For Statement</a></h4> | |
| 1006 | |
| 1007 <p> | |
| 1008 The <b>for</b> statement works over functions, | |
| 1009 called <i>iterators</i>. | |
| 1010 On each iteration, the iterator function is called to produce a new value, | |
| 1011 stopping when this new value is <b>nil</b>. | |
| 1012 The <b>for</b> loop has the following syntax: | |
| 1013 | |
| 1014 <p><tt><pre> | |
| 1015 stat ::= <b>for</b> namelist <b>in</b> exp <b>do</b> block <b>end</b> | |
| 1016 namelist ::= Name {‘<b>,</b>’ Name} | |
| 1017 </pre></tt></p> | |
| 1018 | |
| 1019 <p> | |
| 1020 A <b>for</b> statement like | |
| 1021 | |
| 1022 <p><tt><pre> | |
| 1023 for <i>var_1</i>, ···, <i>var_n</i> in <i>exp</i> do <i>block</i> end | |
| 1024 </pre></tt></p> | |
| 1025 | |
| 1026 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1027 is equivalent to the code: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1028 |
| 395 | 1029 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1030 do |
| 395 | 1031 local <i>f</i> = <i>exp</i> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1032 while true do |
| 395 | 1033 local <i>var_1</i>, ···, <i>var_n</i> = <i>f</i>() |
| 1034 if <i>var_1</i> == nil then break end | |
| 1035 <i>block</i> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1036 end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1037 end |
| 395 | 1038 </pre></tt></p> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1039 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1040 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1041 Note the following: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1042 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1043 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1044 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1045 <li> |
| 395 | 1046 <tt><i>exp</i></tt> is evaluated only once. |
| 1047 Its result is an <i>iterator</i> function. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1048 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1049 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1050 <li> |
| 395 | 1051 <tt><i>f</i></tt> is an invisible variable. |
| 1052 The name is here for explanatory purposes only. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1053 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1054 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1055 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1056 You can use <b>break</b> to exit a <b>for</b> loop. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1057 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1058 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1059 <li> |
| 395 | 1060 The loop variables <tt><i>var_i</i></tt> are local to the loop; |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1061 you cannot use their values after the <b>for</b> ends. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1062 If you need these values, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1063 then assign them to other variables before breaking or exiting the loop. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1064 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1065 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1066 </ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1067 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1068 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1069 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1070 |
| 395 | 1071 <h4 margin-top="1em"><a name="fn_stmt">Function Calls as Statements</a></h4> |
| 1072 | |
| 1073 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1074 To allow possible side-effects, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1075 function calls can be executed as statements: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1076 |
| 395 | 1077 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1078 stat ::= functioncall |
| 395 | 1079 </pre></tt></p> |
| 1080 | |
| 1081 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1082 In this case, all returned values are thrown away. |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1083 Function calls are explained in <a href="#fn_calls">Function Calls</a>. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1084 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1085 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1086 |
| 395 | 1087 <h4 margin-top="1em"><a name="local_stmt">Local Declarations</a></h4> |
| 1088 | |
| 1089 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1090 Local variables can be declared anywhere inside a block. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1091 The declaration can include an initial assignment: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1092 |
| 395 | 1093 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1094 stat ::= <b>local</b> namelist [‘<b>=</b>’ explist] |
| 395 | 1095 </pre></tt></p> |
| 1096 | |
| 1097 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1098 If present, an initial assignment has the same semantics |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1099 of a multiple assignment (see <a href="#assignment">Assignment</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1100 Otherwise, all variables are initialized with <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1101 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1102 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1103 <p> |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1104 A chunk is also a block (see <a href="#chunks">Chunks</a>), |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1105 and so local variables can be declared in a chunk outside any explicit block. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1106 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1107 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1108 <p> |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1109 The visibility rules for local variables are explained in <a href="#visibility">Visibility Rules</a>. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1110 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1111 |
| 465 | 1112 <h4 margin-top="1em"><a name="template_stmt">Template Statements</a></h4> |
| 1113 | |
| 1114 <p>Template statements are based on <a href="#template_expr">template exressions</a> and provide the full equivalent of <a href="http://en.wikipedia.org/wiki/JavaServer_Pages">JSP</a> but in a general way. Template statements write the equivalent template exression to standard output. For example:</p> | |
| 1115 | |
| 1116 <p><tt><pre><%=Html.encode[[ | |
| 1117 local name = "Bob" | |
| 1118 %> | |
| 1119 Hello <%=name%>! | |
| 1120 Bye <%=name%>. | |
| 1121 <% | |
| 1122 ]]%></pre></tt></p> | |
| 1123 | |
| 1124 <p>is equivalent to the code:</p> | |
| 1125 | |
| 1126 <p><tt><pre><%=Html.encode[[ | |
| 1127 local name = "Bob" | |
| 1128 require("luan:Io").stdout.write( %> | |
| 1129 Hello <%=name%>! | |
| 1130 Bye <%=name%>. | |
| 1131 <% ) | |
| 1132 ]]%></pre></tt></p> | |
| 1133 | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1134 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1135 |
| 395 | 1136 <h3 margin-top="1em"><a name="expressions">Expressions</a></h3> |
| 1137 | |
| 1138 <p> | |
| 1139 The basic expressions in Luan are the following: | |
| 1140 | |
| 1141 <p><tt><pre> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1142 exp ::= prefixexp |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1143 exp ::= <b>nil</b> | <b>false</b> | <b>true</b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1144 exp ::= Numeral |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1145 exp ::= LiteralString |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1146 exp ::= functiondef |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1147 exp ::= tableconstructor |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1148 exp ::= ‘<b>...</b>’ |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1149 exp ::= exp binop exp |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1150 exp ::= unop exp |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1151 prefixexp ::= var | functioncall | ‘<b>(</b>’ exp ‘<b>)</b>’ |
| 395 | 1152 </pre></tt></p> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1153 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1154 <p> |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1155 Numerals and literal strings are explained in <a href="#lex">Lexical Conventions</a>; |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1156 variables are explained in <a href="#vars">Variables</a>; |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1157 function definitions are explained in <a href="#fn_def">Function Definitions</a>; |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1158 function calls are explained in <a href="#fn_calls">Function Calls</a>; |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1159 table constructors are explained in <a href="#constructors">Table Constructors</a>. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1160 Vararg expressions, |
| 395 | 1161 denoted by three dots ('<tt>...</tt>'), can only be used when |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1162 directly inside a vararg function; |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1163 they are explained in <a href="#fn_def">Function Definitions</a>. |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1164 |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1165 |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1166 <p> |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1167 Binary operators comprise arithmetic operators (see <a href="#arithmetic">Arithmetic Operators</a>), |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1168 relational operators (see <a href="#relational">Relational Operators</a>), logical operators (see <a href="#logical_ops">Logical Operators</a>), |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1169 and the concatenation operator (see <a href="#concatenation">Concatenation</a>). |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1170 Unary operators comprise the unary minus (see <a href="#arithmetic">Arithmetic Operators</a>), |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1171 the unary logical <b>not</b> (see <a href="#logical_ops">Logical Operators</a>), |
|
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1172 and the unary <em>length operator</em> (see <a href="#length">The Length Operator</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1173 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1174 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1175 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1176 Both function calls and vararg expressions can result in multiple values. |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1177 If a function call is used as a statement (see <a href="#fn_stmt">Function Calls as Statements</a>), |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1178 then its return list is adjusted to zero elements, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1179 thus discarding all returned values. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1180 If an expression is used as the last (or the only) element |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1181 of a list of expressions, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1182 then no adjustment is made |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1183 (unless the expression is enclosed in parentheses). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1184 In all other contexts, |
| 395 | 1185 Luan adjusts the result list to one element, |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1186 either discarding all values except the first one |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1187 or adding a single <b>nil</b> if there are no values. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1188 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1189 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1190 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1191 Here are some examples: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1192 |
| 395 | 1193 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1194 f() -- adjusted to 0 results |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1195 g(f(), x) -- f() is adjusted to 1 result |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1196 g(x, f()) -- g gets x plus all results from f() |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1197 a,b,c = f(), x -- f() is adjusted to 1 result (c gets nil) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1198 a,b = ... -- a gets the first vararg parameter, b gets |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1199 -- the second (both a and b can get nil if there |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1200 -- is no corresponding vararg parameter) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1201 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1202 a,b,c = x, f() -- f() is adjusted to 2 results |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1203 a,b,c = f() -- f() is adjusted to 3 results |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1204 return f() -- returns all results from f() |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1205 return ... -- returns all received vararg parameters |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1206 return x,y,f() -- returns x, y, and all results from f() |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1207 {f()} -- creates a list with all results from f() |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1208 {...} -- creates a list with all vararg parameters |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1209 {f(), nil} -- f() is adjusted to 1 result |
| 395 | 1210 </pre></tt></p> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1211 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1212 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1213 Any expression enclosed in parentheses always results in only one value. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1214 Thus, |
| 395 | 1215 <tt>(f(x,y,z))</tt> is always a single value, |
| 1216 even if <tt>f</tt> returns several values. | |
| 1217 (The value of <tt>(f(x,y,z))</tt> is the first value returned by <tt>f</tt> | |
| 1218 or <b>nil</b> if <tt>f</tt> does not return any values.) | |
| 1219 | |
| 1220 | |
| 1221 | |
| 1222 <h4 margin-top="1em"><a name="arithmetic">Arithmetic Operators</a></h4> | |
| 1223 | |
| 1224 <p> | |
| 1225 Luan supports the following arithmetic operators: | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1226 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1227 <ul> |
| 395 | 1228 <li><b><tt>+</tt>: </b>addition</li> |
| 1229 <li><b><tt>-</tt>: </b>subtraction</li> | |
| 1230 <li><b><tt>*</tt>: </b>multiplication</li> | |
| 1231 <li><b><tt>/</tt>: </b>division</li> | |
| 1232 <li><b><tt>%</tt>: </b>modulo</li> | |
| 1233 <li><b><tt>^</tt>: </b>exponentiation</li> | |
| 1234 <li><b><tt>-</tt>: </b>unary minus</li> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1235 </ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1236 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1237 <p> |
| 395 | 1238 Addition, subtraction, multiplication, division, and unary minus are the same as these operators in Java. Exponentiation uses Java's <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Math.html#pow(double,%20double)">Math.pow</a> function. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1239 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1240 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1241 Modulo is defined as the remainder of a division |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1242 that rounds the quotient towards minus infinite (floor division). |
| 395 | 1243 (The Java modulo operator is not used.) |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1244 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1245 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1246 |
| 396 | 1247 <h4 margin-top="1em"><a name="conversions">Coercions and Conversions</a></h4> |
| 1248 | |
| 1249 <p> | |
| 465 | 1250 Luan generally avoids automatic conversions. |
| 1251 String concatenation automatically converts all of its arguments to strings. | |
| 1252 | |
| 1253 <p> | |
| 1254 Luan provides library functions for explicit type conversions. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1255 |
| 396 | 1256 |
| 1257 | |
| 1258 | |
| 1259 <h4 margin-top="1em"><a name="relational">Relational Operators</a></h4> | |
| 1260 | |
| 1261 <p> | |
| 1262 Luan supports the following relational operators: | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1263 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1264 <ul> |
| 396 | 1265 <li><b><tt>==</tt>: </b>equality</li> |
| 1266 <li><b><tt>~=</tt>: </b>inequality</li> | |
| 1267 <li><b><tt><</tt>: </b>less than</li> | |
| 1268 <li><b><tt>></tt>: </b>greater than</li> | |
| 1269 <li><b><tt><=</tt>: </b>less or equal</li> | |
| 1270 <li><b><tt>>=</tt>: </b>greater or equal</li> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1271 </ul><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1272 These operators always result in <b>false</b> or <b>true</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1273 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1274 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1275 <p> |
| 396 | 1276 Equality (<tt>==</tt>) first compares the type of its operands. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1277 If the types are different, then the result is <b>false</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1278 Otherwise, the values of the operands are compared. |
| 396 | 1279 Strings, numbers, and binary values are compared in the obvious way (by value). |
| 1280 | |
| 1281 <p> | |
| 1282 Tables | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1283 are compared by reference: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1284 two objects are considered equal only if they are the same object. |
| 396 | 1285 Every time you create a new table, |
| 1286 it is different from any previously existing table. | |
| 1287 Closures are also compared by reference. | |
| 1288 | |
| 1289 <p> | |
| 417 | 1290 You can change the way that Luan compares tables |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1291 by using the "eq" metamethod (see <a href="#meta">Metatables and Metamethods</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1292 |
| 396 | 1293 <p> |
| 1294 Userdata are Java objects. They are compared for equality with the Java <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)"><tt>equals</tt></a> method. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1295 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1296 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1297 Equality comparisons do not convert strings to numbers |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1298 or vice versa. |
| 396 | 1299 Thus, <tt>"0"==0</tt> evaluates to <b>false</b>, |
| 1300 and <tt>t[0]</tt> and <tt>t["0"]</tt> denote different | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1301 entries in a table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1302 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1303 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1304 <p> |
| 396 | 1305 The operator <tt>~=</tt> is exactly the negation of equality (<tt>==</tt>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1306 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1307 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1308 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1309 The order operators work as follows. |
| 396 | 1310 |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1311 If both arguments are numbers, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1312 then they are compared following |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1313 the usual rule for binary operations. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1314 Otherwise, if both arguments are strings, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1315 then their values are compared according to the current locale. |
| 396 | 1316 Otherwise, Luan tries to call the "lt" or the "le" |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1317 metamethod (see <a href="#meta">Metatables and Metamethods</a>). |
| 396 | 1318 A comparison <tt>a > b</tt> is translated to <tt>b < a</tt> |
| 1319 and <tt>a >= b</tt> is translated to <tt>b <= a</tt>. | |
| 1320 | |
| 1321 | |
| 1322 | |
| 1323 | |
| 1324 | |
| 1325 <h4 margin-top="1em"><a name="logical_ops">Logical Operators</a></h4> | |
| 1326 | |
| 1327 <p> | |
| 1328 The logical operators in Luan are | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1329 <b>and</b>, <b>or</b>, and <b>not</b>. |
| 396 | 1330 The <b>and</b> and <b>or</b> operators consider both <b>false</b> and <b>nil</b> as false |
| 1331 and anything else as true. | |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1332 Like the control structures (see <a href="#control">Control Structures</a>), |
| 396 | 1333 the <b>not</b> operator requires a boolean value. |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1334 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1335 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1336 The negation operator <b>not</b> always returns <b>false</b> or <b>true</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1337 The conjunction operator <b>and</b> returns its first argument |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1338 if this value is <b>false</b> or <b>nil</b>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1339 otherwise, <b>and</b> returns its second argument. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1340 The disjunction operator <b>or</b> returns its first argument |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1341 if this value is different from <b>nil</b> and <b>false</b>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1342 otherwise, <b>or</b> returns its second argument. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1343 Both <b>and</b> and <b>or</b> use short-circuit evaluation; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1344 that is, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1345 the second operand is evaluated only if necessary. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1346 Here are some examples: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1347 |
| 396 | 1348 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1349 10 or 20 --> 10 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1350 10 or error() --> 10 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1351 nil or "a" --> "a" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1352 nil and 10 --> nil |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1353 false and error() --> false |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1354 false and nil --> false |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1355 false or nil --> nil |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1356 10 and 20 --> 20 |
| 396 | 1357 </pre></tt></p> |
| 1358 | |
| 1359 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1360 (In this manual, |
| 396 | 1361 <tt>--></tt> indicates the result of the preceding expression.) |
| 1362 | |
| 1363 | |
| 1364 | |
| 1365 <h4 margin-top="1em"><a name="concatenation">Concatenation</a></h4> | |
| 1366 | |
| 1367 <p> | |
| 1368 The string concatenation operator in Luan is | |
| 1369 denoted by two dots ('<tt>..</tt>'). | |
| 1370 All operands are converted to strings. | |
| 1371 | |
| 1372 | |
| 1373 | |
| 1374 <h4 margin-top="1em"><a name="length">The Length Operator</a></h4> | |
| 1375 | |
| 1376 <p> | |
| 1377 The length operator is denoted by the unary prefix operator <tt>#</tt>. | |
| 1378 The length of a string is its number of characters. | |
| 1379 The length of a binary is its number of bytes. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1380 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1381 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1382 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1383 A program can modify the behavior of the length operator for |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1384 any table through the <tt>__len</tt> metamethod (see <a href="#meta">Metatables and Metamethods</a>). |
| 396 | 1385 |
| 1386 | |
| 1387 <p> | |
| 1388 Unless a <tt>__len</tt> metamethod is given, | |
| 1389 the length of a table <tt>t</tt> is defined | |
| 1390 as the number of elements in <em>sequence</em>, | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1391 that is, |
| 396 | 1392 the size of the set of its positive numeric keys is equal to <em>{1..n}</em> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1393 for some non-negative integer <em>n</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1394 In that case, <em>n</em> is its length. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1395 Note that a table like |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1396 |
| 396 | 1397 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1398 {10, 20, nil, 40} |
| 396 | 1399 </pre></tt></p> |
| 1400 | |
| 1401 <p> | |
| 1402 has a length of <tt>2</tt>, because that is the last key in sequence. | |
| 1403 | |
| 1404 | |
| 1405 | |
| 1406 | |
| 1407 | |
| 1408 <h4 margin-top="1em"><a name="precedence">Precedence</a></h4> | |
| 1409 | |
| 1410 <p> | |
| 1411 Operator precedence in Luan follows the table below, | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1412 from lower to higher priority: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1413 |
| 396 | 1414 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1415 or |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1416 and |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1417 < > <= >= ~= == |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1418 .. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1419 + - |
| 396 | 1420 * / % |
| 1421 unary operators (not # -) | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1422 ^ |
| 396 | 1423 </pre></tt></p> |
| 1424 | |
| 1425 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1426 As usual, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1427 you can use parentheses to change the precedences of an expression. |
| 396 | 1428 The concatenation ('<tt>..</tt>') and exponentiation ('<tt>^</tt>') |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1429 operators are right associative. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1430 All other binary operators are left associative. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1431 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1432 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1433 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1434 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1435 |
| 396 | 1436 <h4 margin-top="1em"><a name="constructors">Table Constructors</a></h4> |
| 1437 | |
| 1438 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1439 Table constructors are expressions that create tables. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1440 Every time a constructor is evaluated, a new table is created. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1441 A constructor can be used to create an empty table |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1442 or to create a table and initialize some of its fields. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1443 The general syntax for constructors is |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1444 |
| 396 | 1445 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1446 tableconstructor ::= ‘<b>{</b>’ [fieldlist] ‘<b>}</b>’ |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1447 fieldlist ::= field {fieldsep field} [fieldsep] |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1448 field ::= ‘<b>[</b>’ exp ‘<b>]</b>’ ‘<b>=</b>’ exp | Name ‘<b>=</b>’ exp | exp |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1449 fieldsep ::= ‘<b>,</b>’ | ‘<b>;</b>’ |
| 396 | 1450 </pre></tt></p> |
| 1451 | |
| 1452 <p> | |
| 1453 Each field of the form <tt>[exp1] = exp2</tt> adds to the new table an entry | |
| 1454 with key <tt>exp1</tt> and value <tt>exp2</tt>. | |
| 1455 A field of the form <tt>name = exp</tt> is equivalent to | |
| 1456 <tt>["name"] = exp</tt>. | |
| 1457 Finally, fields of the form <tt>exp</tt> are equivalent to | |
| 1458 <tt>[i] = exp</tt>, where <tt>i</tt> are consecutive integers | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1459 starting with 1. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1460 Fields in the other formats do not affect this counting. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1461 For example, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1462 |
| 396 | 1463 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1464 a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 } |
| 396 | 1465 </pre></tt></p> |
| 1466 | |
| 1467 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1468 is equivalent to |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1469 |
| 396 | 1470 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1471 do |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1472 local t = {} |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1473 t[f(1)] = g |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1474 t[1] = "x" -- 1st exp |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1475 t[2] = "y" -- 2nd exp |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1476 t.x = 1 -- t["x"] = 1 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1477 t[3] = f(x) -- 3rd exp |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1478 t[30] = 23 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1479 t[4] = 45 -- 4th exp |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1480 a = t |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1481 end |
| 396 | 1482 </pre></tt></p> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1483 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1484 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1485 The order of the assignments in a constructor is undefined. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1486 (This order would be relevant only when there are repeated keys.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1487 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1488 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1489 <p> |
| 396 | 1490 If the last field in the list has the form <tt>exp</tt> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1491 and the expression is a function call or a vararg expression, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1492 then all values returned by this expression enter the list consecutively |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1493 (see <a href="#fn_calls">Function Calls</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1494 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1495 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1496 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1497 The field list can have an optional trailing separator, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1498 as a convenience for machine-generated code. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1499 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1500 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1501 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1502 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1503 |
| 417 | 1504 <h4 margin-top="1em"><a name="fn_calls">Function Calls</a></h4> |
| 1505 | |
| 1506 <p> | |
| 1507 A function call in Luan has the following syntax: | |
| 1508 | |
| 1509 <p><tt><pre> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1510 functioncall ::= prefixexp args |
| 417 | 1511 </pre></tt></p> |
| 1512 | |
| 1513 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1514 In a function call, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1515 first prefixexp and args are evaluated. |
| 417 | 1516 If the value of prefixexp has type <i>function</i>, |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1517 then this function is called |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1518 with the given arguments. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1519 Otherwise, the prefixexp "call" metamethod is called, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1520 having as first parameter the value of prefixexp, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1521 followed by the original call arguments |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1522 (see <a href="#meta">Metatables and Metamethods</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1523 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1524 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1525 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1526 Arguments have the following syntax: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1527 |
| 417 | 1528 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1529 args ::= ‘<b>(</b>’ [explist] ‘<b>)</b>’ |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1530 args ::= tableconstructor |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1531 args ::= LiteralString |
| 417 | 1532 </pre></tt></p> |
| 1533 | |
| 1534 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1535 All argument expressions are evaluated before the call. |
| 417 | 1536 A call of the form <tt>f{<i>fields</i>}</tt> is |
| 1537 syntactic sugar for <tt>f({<i>fields</i>})</tt>; | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1538 that is, the argument list is a single new table. |
| 417 | 1539 A call of the form <tt>f'<i>string</i>'</tt> |
| 1540 (or <tt>f"<i>string</i>"</tt> or <tt>f[[<i>string</i>]]</tt>) | |
| 1541 is syntactic sugar for <tt>f('<i>string</i>')</tt>; | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1542 that is, the argument list is a single literal string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1543 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1544 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1545 <p> |
| 417 | 1546 A call of the form <tt>return <i>functioncall</i></tt> is called |
| 1547 a <i>tail call</i>. | |
| 1548 Luan implements <i>proper tail calls</i> | |
| 1549 (or <i>proper tail recursion</i>): | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1550 in a tail call, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1551 the called function reuses the stack entry of the calling function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1552 Therefore, there is no limit on the number of nested tail calls that |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1553 a program can execute. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1554 However, a tail call erases any debug information about the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1555 calling function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1556 Note that a tail call only happens with a particular syntax, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1557 where the <b>return</b> has one single function call as argument; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1558 this syntax makes the calling function return exactly |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1559 the returns of the called function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1560 So, none of the following examples are tail calls: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1561 |
| 417 | 1562 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1563 return (f(x)) -- results adjusted to 1 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1564 return 2 * f(x) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1565 return x, f(x) -- additional results |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1566 f(x); return -- results discarded |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1567 return x or f(x) -- results adjusted to 1 |
| 417 | 1568 </pre></tt></p> |
| 1569 | |
| 1570 | |
| 1571 | |
| 1572 | |
| 1573 <h4 margin-top="1em"><a name="fn_def">Function Definitions</a></h4> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1574 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1575 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1576 The syntax for function definition is |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1577 |
| 417 | 1578 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1579 functiondef ::= <b>function</b> funcbody |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1580 funcbody ::= ‘<b>(</b>’ [parlist] ‘<b>)</b>’ block <b>end</b> |
| 417 | 1581 </pre></tt></p> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1582 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1583 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1584 The following syntactic sugar simplifies function definitions: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1585 |
| 417 | 1586 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1587 stat ::= <b>function</b> funcname funcbody |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1588 stat ::= <b>local</b> <b>function</b> Name funcbody |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1589 funcname ::= Name {‘<b>.</b>’ Name} [‘<b>:</b>’ Name] |
| 417 | 1590 </pre></tt></p> |
| 1591 | |
| 1592 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1593 The statement |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1594 |
| 417 | 1595 <p><tt><pre> |
| 1596 function f () <i>body</i> end | |
| 1597 </pre></tt></p> | |
| 1598 | |
| 1599 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1600 translates to |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1601 |
| 417 | 1602 <p><tt><pre> |
| 1603 f = function () <i>body</i> end | |
| 1604 </pre></tt></p> | |
| 1605 | |
| 1606 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1607 The statement |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1608 |
| 417 | 1609 <p><tt><pre> |
| 1610 function t.a.b.c.f () <i>body</i> end | |
| 1611 </pre></tt></p> | |
| 1612 | |
| 1613 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1614 translates to |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1615 |
| 417 | 1616 <p><tt><pre> |
| 1617 t.a.b.c.f = function () <i>body</i> end | |
| 1618 </pre></tt></p> | |
| 1619 | |
| 1620 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1621 The statement |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1622 |
| 417 | 1623 <p><tt><pre> |
| 1624 local function f () <i>body</i> end | |
| 1625 </pre></tt></p> | |
| 1626 | |
| 1627 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1628 translates to |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1629 |
| 417 | 1630 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1631 local f; f = function () <em>body</em> end |
| 417 | 1632 </pre></tt></p> |
| 1633 | |
| 1634 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1635 not to |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1636 |
| 417 | 1637 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1638 local f = function () <em>body</em> end |
| 417 | 1639 </pre></tt></p> |
| 1640 | |
| 1641 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1642 (This only makes a difference when the body of the function |
| 417 | 1643 contains references to <tt>f</tt>.) |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1644 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1645 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1646 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1647 A function definition is an executable expression, |
| 417 | 1648 whose value has type <i>function</i>. |
| 1649 When Luan precompiles a chunk, | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1650 all its function bodies are precompiled too. |
| 417 | 1651 Then, whenever Luan executes the function definition, |
| 1652 the function is <i>instantiated</i> (or <i>closed</i>). | |
| 1653 This function instance (or <i>closure</i>) | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1654 is the final value of the expression. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1655 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1656 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1657 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1658 Parameters act as local variables that are |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1659 initialized with the argument values: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1660 |
| 417 | 1661 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1662 parlist ::= namelist [‘<b>,</b>’ ‘<b>...</b>’] | ‘<b>...</b>’ |
| 417 | 1663 </pre></tt></p> |
| 1664 | |
| 1665 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1666 When a function is called, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1667 the list of arguments is adjusted to |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1668 the length of the list of parameters, |
| 417 | 1669 unless the function is a <i>vararg function</i>, |
| 1670 which is indicated by three dots ('<tt>...</tt>') | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1671 at the end of its parameter list. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1672 A vararg function does not adjust its argument list; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1673 instead, it collects all extra arguments and supplies them |
| 417 | 1674 to the function through a <i>vararg expression</i>, |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1675 which is also written as three dots. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1676 The value of this expression is a list of all actual extra arguments, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1677 similar to a function with multiple results. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1678 If a vararg expression is used inside another expression |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1679 or in the middle of a list of expressions, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1680 then its return list is adjusted to one element. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1681 If the expression is used as the last element of a list of expressions, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1682 then no adjustment is made |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1683 (unless that last expression is enclosed in parentheses). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1684 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1685 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1686 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1687 As an example, consider the following definitions: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1688 |
| 417 | 1689 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1690 function f(a, b) end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1691 function g(a, b, ...) end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1692 function r() return 1,2,3 end |
| 417 | 1693 </pre></tt></p> |
| 1694 | |
| 1695 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1696 Then, we have the following mapping from arguments to parameters and |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1697 to the vararg expression: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1698 |
| 417 | 1699 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1700 CALL PARAMETERS |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1701 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1702 f(3) a=3, b=nil |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1703 f(3, 4) a=3, b=4 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1704 f(3, 4, 5) a=3, b=4 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1705 f(r(), 10) a=1, b=10 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1706 f(r()) a=1, b=2 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1707 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1708 g(3) a=3, b=nil, ... --> (nothing) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1709 g(3, 4) a=3, b=4, ... --> (nothing) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1710 g(3, 4, 5, 8) a=3, b=4, ... --> 5 8 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1711 g(5, r()) a=5, b=1, ... --> 2 3 |
| 417 | 1712 </pre></tt></p> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1713 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1714 <p> |
|
464
eddf7c73373b
fix references in the manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
429
diff
changeset
|
1715 Results are returned using the <b>return</b> statement (see <a href="#control">Control Structures</a>). |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1716 If control reaches the end of a function |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1717 without encountering a <b>return</b> statement, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1718 then the function returns with no results. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1719 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1720 |
| 465 | 1721 <h4 margin-top="1em"><a name="template_expr">Template Expressions</a></h4> |
| 1722 | |
| 1723 <p>Luan template expression are based on <a href="http://en.wikipedia.org/wiki/JavaServer_Pages">JSP</a>. Template expressions return multiple values. Here is an example:</p> | |
| 1724 | |
| 1725 <p><tt><pre><%=Html.encode[[ | |
| 1726 local name = "Bob" | |
| 1727 write( %>Hello <%=name%>!<% ) | |
| 1728 ]]%></pre></tt></p> | |
| 1729 | |
| 1730 <p>This is equivalent to the code:</p> | |
| 1731 | |
| 1732 <p><tt><pre> | |
| 1733 local name = "Bob" | |
| 1734 write( "Hello ", name, "!" ) | |
| 1735 </pre></tt></p> | |
| 1736 | |
| 1737 <p>The strings in template expressions may be multiple lines.</p> | |
| 1738 | |
| 417 | 1739 |
| 1740 | |
| 1741 <h3 margin-top="1em"><a name="visibility">Visibility Rules</a></h3> | |
| 1742 | |
| 1743 <p> | |
| 1744 Luan is a lexically scoped language. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1745 The scope of a local variable begins at the first statement after |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1746 its declaration and lasts until the last non-void statement |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1747 of the innermost block that includes the declaration. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1748 Consider the following example: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1749 |
| 417 | 1750 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1751 x = 10 -- global variable |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1752 do -- new block |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1753 local x = x -- new 'x', with value 10 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1754 print(x) --> 10 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1755 x = x+1 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1756 do -- another block |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1757 local x = x+1 -- another 'x' |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1758 print(x) --> 12 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1759 end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1760 print(x) --> 11 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1761 end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1762 print(x) --> 10 (the global one) |
| 417 | 1763 </pre></tt></p> |
| 1764 | |
| 1765 <p> | |
| 1766 Notice that, in a declaration like <tt>local x = x</tt>, | |
| 1767 the new <tt>x</tt> being declared is not in scope yet, | |
| 1768 and so the second <tt>x</tt> refers to the outside variable. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1769 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1770 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1771 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1772 Because of the lexical scoping rules, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1773 local variables can be freely accessed by functions |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1774 defined inside their scope. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1775 A local variable used by an inner function is called |
| 417 | 1776 an <i>upvalue</i>, or <i>external local variable</i>, |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1777 inside the inner function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1778 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1779 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1780 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1781 Notice that each execution of a <b>local</b> statement |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1782 defines new local variables. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1783 Consider the following example: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1784 |
| 417 | 1785 <p><tt><pre> |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1786 a = {} |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1787 local x = 20 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1788 for i=1,10 do |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1789 local y = 0 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1790 a[i] = function () y=y+1; return x+y end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1791 end |
| 417 | 1792 </pre></tt></p> |
| 1793 | |
| 1794 <p> | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1795 The loop creates ten closures |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1796 (that is, ten instances of the anonymous function). |
| 417 | 1797 Each of these closures uses a different <tt>y</tt> variable, |
| 1798 while all of them share the same <tt>x</tt>. | |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1799 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1800 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1801 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1802 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1803 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1804 <h1>6 – <a name="6">Standard Libraries</a></h1> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1805 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1806 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1807 The standard Lua libraries provide useful functions |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1808 that are implemented directly through the C API. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1809 Some of these functions provide essential services to the language |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1810 (e.g., <a href="#pdf-type"><code>type</code></a> and <a href="#pdf-getmetatable"><code>getmetatable</code></a>); |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1811 others provide access to "outside" services (e.g., I/O); |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1812 and others could be implemented in Lua itself, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1813 but are quite useful or have critical performance requirements that |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1814 deserve an implementation in C (e.g., <a href="#pdf-table.sort"><code>table.sort</code></a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1815 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1816 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1817 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1818 All libraries are implemented through the official C API |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1819 and are provided as separate C modules. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1820 Currently, Lua has the following standard libraries: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1821 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1822 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1823 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1824 <li>basic library (<a href="#6.1">§6.1</a>);</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1825 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1826 <li>coroutine library (<a href="#6.2">§6.2</a>);</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1827 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1828 <li>package library (<a href="#6.3">§6.3</a>);</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1829 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1830 <li>string manipulation (<a href="#6.4">§6.4</a>);</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1831 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1832 <li>basic UTF-8 support (<a href="#6.5">§6.5</a>);</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1833 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1834 <li>table manipulation (<a href="#6.6">§6.6</a>);</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1835 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1836 <li>mathematical functions (<a href="#6.7">§6.7</a>) (sin, log, etc.);</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1837 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1838 <li>input and output (<a href="#6.8">§6.8</a>);</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1839 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1840 <li>operating system facilities (<a href="#6.9">§6.9</a>);</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1841 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1842 <li>debug facilities (<a href="#6.10">§6.10</a>).</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1843 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1844 </ul><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1845 Except for the basic and the package libraries, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1846 each library provides all its functions as fields of a global table |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1847 or as methods of its objects. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1848 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1849 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1850 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1851 To have access to these libraries, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1852 the C host program should call the <a href="#luaL_openlibs"><code>luaL_openlibs</code></a> function, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1853 which opens all standard libraries. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1854 Alternatively, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1855 the host program can open them individually by using |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1856 <a href="#luaL_requiref"><code>luaL_requiref</code></a> to call |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1857 <a name="pdf-luaopen_base"><code>luaopen_base</code></a> (for the basic library), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1858 <a name="pdf-luaopen_package"><code>luaopen_package</code></a> (for the package library), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1859 <a name="pdf-luaopen_coroutine"><code>luaopen_coroutine</code></a> (for the coroutine library), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1860 <a name="pdf-luaopen_string"><code>luaopen_string</code></a> (for the string library), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1861 <a name="pdf-luaopen_utf8"><code>luaopen_utf8</code></a> (for the UTF8 library), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1862 <a name="pdf-luaopen_table"><code>luaopen_table</code></a> (for the table library), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1863 <a name="pdf-luaopen_math"><code>luaopen_math</code></a> (for the mathematical library), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1864 <a name="pdf-luaopen_io"><code>luaopen_io</code></a> (for the I/O library), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1865 <a name="pdf-luaopen_os"><code>luaopen_os</code></a> (for the operating system library), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1866 and <a name="pdf-luaopen_debug"><code>luaopen_debug</code></a> (for the debug library). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1867 These functions are declared in <a name="pdf-lualib.h"><code>lualib.h</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1868 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1869 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1870 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1871 <h2>6.1 – <a name="6.1">Basic Functions</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1872 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1873 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1874 The basic library provides core functions to Lua. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1875 If you do not include this library in your application, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1876 you should check carefully whether you need to provide |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1877 implementations for some of its facilities. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1878 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1879 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1880 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1881 <hr><h3><a name="pdf-assert"><code>assert (v [, message])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1882 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1883 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1884 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1885 Calls <a href="#pdf-error"><code>error</code></a> if |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1886 the value of its argument <code>v</code> is false (i.e., <b>nil</b> or <b>false</b>); |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1887 otherwise, returns all its arguments. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1888 In case of error, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1889 <code>message</code> is the error object; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1890 when absent, it defaults to "<code>assertion failed!</code>" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1891 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1892 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1893 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1894 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1895 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1896 <hr><h3><a name="pdf-collectgarbage"><code>collectgarbage ([opt [, arg]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1897 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1898 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1899 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1900 This function is a generic interface to the garbage collector. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1901 It performs different functions according to its first argument, <code>opt</code>: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1902 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1903 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1904 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1905 <li><b>"<code>collect</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1906 performs a full garbage-collection cycle. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1907 This is the default option. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1908 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1909 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1910 <li><b>"<code>stop</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1911 stops automatic execution of the garbage collector. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1912 The collector will run only when explicitly invoked, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1913 until a call to restart it. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1914 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1915 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1916 <li><b>"<code>restart</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1917 restarts automatic execution of the garbage collector. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1918 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1919 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1920 <li><b>"<code>count</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1921 returns the total memory in use by Lua in Kbytes. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1922 The value has a fractional part, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1923 so that it multiplied by 1024 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1924 gives the exact number of bytes in use by Lua |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1925 (except for overflows). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1926 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1927 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1928 <li><b>"<code>step</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1929 performs a garbage-collection step. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1930 The step "size" is controlled by <code>arg</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1931 With a zero value, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1932 the collector will perform one basic (indivisible) step. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1933 For non-zero values, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1934 the collector will perform as if that amount of memory |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1935 (in KBytes) had been allocated by Lua. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1936 Returns <b>true</b> if the step finished a collection cycle. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1937 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1938 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1939 <li><b>"<code>setpause</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1940 sets <code>arg</code> as the new value for the <em>pause</em> of |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1941 the collector (see <a href="#2.5">§2.5</a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1942 Returns the previous value for <em>pause</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1943 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1944 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1945 <li><b>"<code>setstepmul</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1946 sets <code>arg</code> as the new value for the <em>step multiplier</em> of |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1947 the collector (see <a href="#2.5">§2.5</a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1948 Returns the previous value for <em>step</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1949 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1950 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1951 <li><b>"<code>isrunning</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1952 returns a boolean that tells whether the collector is running |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1953 (i.e., not stopped). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1954 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1955 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1956 </ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1957 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1958 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1959 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1960 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1961 <hr><h3><a name="pdf-dofile"><code>dofile ([filename])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1962 Opens the named file and executes its contents as a Lua chunk. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1963 When called without arguments, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1964 <code>dofile</code> executes the contents of the standard input (<code>stdin</code>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1965 Returns all values returned by the chunk. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1966 In case of errors, <code>dofile</code> propagates the error |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1967 to its caller (that is, <code>dofile</code> does not run in protected mode). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1968 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1969 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1970 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1971 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1972 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1973 <hr><h3><a name="pdf-error"><code>error (message [, level])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1974 Terminates the last protected function called |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1975 and returns <code>message</code> as the error object. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1976 Function <code>error</code> never returns. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1977 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1978 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1979 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1980 Usually, <code>error</code> adds some information about the error position |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1981 at the beginning of the message, if the message is a string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1982 The <code>level</code> argument specifies how to get the error position. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1983 With level 1 (the default), the error position is where the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1984 <code>error</code> function was called. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1985 Level 2 points the error to where the function |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1986 that called <code>error</code> was called; and so on. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1987 Passing a level 0 avoids the addition of error position information |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1988 to the message. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1989 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1990 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1991 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1992 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1993 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1994 <hr><h3><a name="pdf-_G"><code>_G</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1995 A global variable (not a function) that |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1996 holds the global environment (see <a href="#2.2">§2.2</a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1997 Lua itself does not use this variable; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1998 changing its value does not affect any environment, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
1999 nor vice versa. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2000 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2001 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2002 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2003 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2004 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2005 <hr><h3><a name="pdf-getmetatable"><code>getmetatable (object)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2006 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2007 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2008 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2009 If <code>object</code> does not have a metatable, returns <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2010 Otherwise, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2011 if the object's metatable has a <code>"__metatable"</code> field, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2012 returns the associated value. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2013 Otherwise, returns the metatable of the given object. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2014 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2015 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2016 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2017 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2018 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2019 <hr><h3><a name="pdf-ipairs"><code>ipairs (t)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2020 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2021 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2022 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2023 Returns three values (an iterator function, the table <code>t</code>, and 0) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2024 so that the construction |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2025 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2026 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2027 for i,v in ipairs(t) do <em>body</em> end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2028 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2029 will iterate over the key–value pairs |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2030 (<code>1,t[1]</code>), (<code>2,t[2]</code>), ..., |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2031 up to the first nil value. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2032 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2033 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2034 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2035 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2036 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2037 <hr><h3><a name="pdf-load"><code>load (chunk [, chunkname [, mode [, env]]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2038 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2039 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2040 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2041 Loads a chunk. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2042 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2043 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2044 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2045 If <code>chunk</code> is a string, the chunk is this string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2046 If <code>chunk</code> is a function, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2047 <code>load</code> calls it repeatedly to get the chunk pieces. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2048 Each call to <code>chunk</code> must return a string that concatenates |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2049 with previous results. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2050 A return of an empty string, <b>nil</b>, or no value signals the end of the chunk. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2051 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2052 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2053 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2054 If there are no syntactic errors, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2055 returns the compiled chunk as a function; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2056 otherwise, returns <b>nil</b> plus the error message. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2057 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2058 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2059 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2060 If the resulting function has upvalues, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2061 the first upvalue is set to the value of <code>env</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2062 if that parameter is given, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2063 or to the value of the global environment. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2064 Other upvalues are initialized with <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2065 (When you load a main chunk, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2066 the resulting function will always have exactly one upvalue, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2067 the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2068 However, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2069 when you load a binary chunk created from a function (see <a href="#pdf-string.dump"><code>string.dump</code></a>), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2070 the resulting function can have an arbitrary number of upvalues.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2071 All upvalues are fresh, that is, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2072 they are not shared with any other function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2073 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2074 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2075 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2076 <code>chunkname</code> is used as the name of the chunk for error messages |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2077 and debug information (see <a href="#4.9">§4.9</a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2078 When absent, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2079 it defaults to <code>chunk</code>, if <code>chunk</code> is a string, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2080 or to "<code>=(load)</code>" otherwise. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2081 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2082 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2083 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2084 The string <code>mode</code> controls whether the chunk can be text or binary |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2085 (that is, a precompiled chunk). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2086 It may be the string "<code>b</code>" (only binary chunks), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2087 "<code>t</code>" (only text chunks), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2088 or "<code>bt</code>" (both binary and text). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2089 The default is "<code>bt</code>". |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2090 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2091 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2092 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2093 Lua does not check the consistency of binary chunks. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2094 Maliciously crafted binary chunks can crash |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2095 the interpreter. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2096 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2097 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2098 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2099 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2100 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2101 <hr><h3><a name="pdf-loadfile"><code>loadfile ([filename [, mode [, env]]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2102 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2103 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2104 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2105 Similar to <a href="#pdf-load"><code>load</code></a>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2106 but gets the chunk from file <code>filename</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2107 or from the standard input, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2108 if no file name is given. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2109 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2110 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2111 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2112 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2113 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2114 <hr><h3><a name="pdf-next"><code>next (table [, index])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2115 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2116 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2117 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2118 Allows a program to traverse all fields of a table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2119 Its first argument is a table and its second argument |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2120 is an index in this table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2121 <code>next</code> returns the next index of the table |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2122 and its associated value. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2123 When called with <b>nil</b> as its second argument, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2124 <code>next</code> returns an initial index |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2125 and its associated value. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2126 When called with the last index, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2127 or with <b>nil</b> in an empty table, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2128 <code>next</code> returns <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2129 If the second argument is absent, then it is interpreted as <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2130 In particular, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2131 you can use <code>next(t)</code> to check whether a table is empty. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2132 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2133 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2134 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2135 The order in which the indices are enumerated is not specified, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2136 <em>even for numeric indices</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2137 (To traverse a table in numeric order, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2138 use a numerical <b>for</b>.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2139 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2140 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2141 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2142 The behavior of <code>next</code> is undefined if, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2143 during the traversal, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2144 you assign any value to a non-existent field in the table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2145 You may however modify existing fields. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2146 In particular, you may clear existing fields. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2147 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2148 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2149 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2150 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2151 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2152 <hr><h3><a name="pdf-pairs"><code>pairs (t)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2153 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2154 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2155 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2156 If <code>t</code> has a metamethod <code>__pairs</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2157 calls it with <code>t</code> as argument and returns the first three |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2158 results from the call. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2159 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2160 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2161 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2162 Otherwise, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2163 returns three values: the <a href="#pdf-next"><code>next</code></a> function, the table <code>t</code>, and <b>nil</b>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2164 so that the construction |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2165 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2166 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2167 for k,v in pairs(t) do <em>body</em> end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2168 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2169 will iterate over all key–value pairs of table <code>t</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2170 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2171 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2172 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2173 See function <a href="#pdf-next"><code>next</code></a> for the caveats of modifying |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2174 the table during its traversal. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2175 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2176 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2177 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2178 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2179 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2180 <hr><h3><a name="pdf-pcall"><code>pcall (f [, arg1, ···])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2181 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2182 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2183 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2184 Calls function <code>f</code> with |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2185 the given arguments in <em>protected mode</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2186 This means that any error inside <code>f</code> is not propagated; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2187 instead, <code>pcall</code> catches the error |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2188 and returns a status code. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2189 Its first result is the status code (a boolean), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2190 which is true if the call succeeds without errors. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2191 In such case, <code>pcall</code> also returns all results from the call, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2192 after this first result. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2193 In case of any error, <code>pcall</code> returns <b>false</b> plus the error message. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2194 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2195 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2196 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2197 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2198 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2199 <hr><h3><a name="pdf-print"><code>print (···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2200 Receives any number of arguments |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2201 and prints their values to <code>stdout</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2202 using the <a href="#pdf-tostring"><code>tostring</code></a> function to convert each argument to a string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2203 <code>print</code> is not intended for formatted output, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2204 but only as a quick way to show a value, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2205 for instance for debugging. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2206 For complete control over the output, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2207 use <a href="#pdf-string.format"><code>string.format</code></a> and <a href="#pdf-io.write"><code>io.write</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2208 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2209 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2210 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2211 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2212 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2213 <hr><h3><a name="pdf-rawequal"><code>rawequal (v1, v2)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2214 Checks whether <code>v1</code> is equal to <code>v2</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2215 without invoking any metamethod. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2216 Returns a boolean. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2217 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2218 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2219 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2220 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2221 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2222 <hr><h3><a name="pdf-rawget"><code>rawget (table, index)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2223 Gets the real value of <code>table[index]</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2224 without invoking any metamethod. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2225 <code>table</code> must be a table; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2226 <code>index</code> may be any value. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2227 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2228 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2229 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2230 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2231 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2232 <hr><h3><a name="pdf-rawlen"><code>rawlen (v)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2233 Returns the length of the object <code>v</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2234 which must be a table or a string, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2235 without invoking any metamethod. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2236 Returns an integer. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2237 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2238 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2239 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2240 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2241 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2242 <hr><h3><a name="pdf-rawset"><code>rawset (table, index, value)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2243 Sets the real value of <code>table[index]</code> to <code>value</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2244 without invoking any metamethod. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2245 <code>table</code> must be a table, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2246 <code>index</code> any value different from <b>nil</b> and NaN, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2247 and <code>value</code> any Lua value. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2248 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2249 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2250 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2251 This function returns <code>table</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2252 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2253 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2254 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2255 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2256 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2257 <hr><h3><a name="pdf-select"><code>select (index, ···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2258 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2259 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2260 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2261 If <code>index</code> is a number, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2262 returns all arguments after argument number <code>index</code>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2263 a negative number indexes from the end (-1 is the last argument). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2264 Otherwise, <code>index</code> must be the string <code>"#"</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2265 and <code>select</code> returns the total number of extra arguments it received. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2266 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2267 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2268 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2269 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2270 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2271 <hr><h3><a name="pdf-setmetatable"><code>setmetatable (table, metatable)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2272 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2273 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2274 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2275 Sets the metatable for the given table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2276 (You cannot change the metatable of other types from Lua, only from C.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2277 If <code>metatable</code> is <b>nil</b>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2278 removes the metatable of the given table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2279 If the original metatable has a <code>"__metatable"</code> field, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2280 raises an error. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2281 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2282 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2283 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2284 This function returns <code>table</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2285 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2286 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2287 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2288 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2289 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2290 <hr><h3><a name="pdf-tonumber"><code>tonumber (e [, base])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2291 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2292 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2293 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2294 When called with no <code>base</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2295 <code>tonumber</code> tries to convert its argument to a number. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2296 If the argument is already a number or |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2297 a string convertible to a number, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2298 then <code>tonumber</code> returns this number; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2299 otherwise, it returns <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2300 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2301 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2302 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2303 The conversion of strings can result in integers or floats, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2304 according to the lexical conventions of Lua (see <a href="#3.1">§3.1</a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2305 (The string may have leading and trailing spaces and a sign.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2306 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2307 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2308 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2309 When called with <code>base</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2310 then <code>e</code> must be a string to be interpreted as |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2311 an integer numeral in that base. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2312 The base may be any integer between 2 and 36, inclusive. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2313 In bases above 10, the letter '<code>A</code>' (in either upper or lower case) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2314 represents 10, '<code>B</code>' represents 11, and so forth, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2315 with '<code>Z</code>' representing 35. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2316 If the string <code>e</code> is not a valid numeral in the given base, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2317 the function returns <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2318 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2319 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2320 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2321 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2322 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2323 <hr><h3><a name="pdf-tostring"><code>tostring (v)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2324 Receives a value of any type and |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2325 converts it to a string in a human-readable format. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2326 Floats always produce strings with some |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2327 floating-point indication (either a decimal dot or an exponent). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2328 (For complete control of how numbers are converted, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2329 use <a href="#pdf-string.format"><code>string.format</code></a>.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2330 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2331 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2332 <p> |
|
429
e3a6d9dbd694
rename __tostring to __to_string
Franklin Schmidt <fschmidt@gmail.com>
parents:
428
diff
changeset
|
2333 If the metatable of <code>v</code> has a <code>"__to_string"</code> field, |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2334 then <code>tostring</code> calls the corresponding value |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2335 with <code>v</code> as argument, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2336 and uses the result of the call as its result. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2337 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2338 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2339 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2340 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2341 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2342 <hr><h3><a name="pdf-type"><code>type (v)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2343 Returns the type of its only argument, coded as a string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2344 The possible results of this function are |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2345 "<code>nil</code>" (a string, not the value <b>nil</b>), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2346 "<code>number</code>", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2347 "<code>string</code>", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2348 "<code>boolean</code>", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2349 "<code>table</code>", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2350 "<code>function</code>", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2351 "<code>thread</code>", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2352 and "<code>userdata</code>". |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2353 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2354 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2355 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2356 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2357 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2358 <hr><h3><a name="pdf-_VERSION"><code>_VERSION</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2359 A global variable (not a function) that |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2360 holds a string containing the current interpreter version. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2361 The current value of this variable is "<code>Lua 5.3</code>". |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2362 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2363 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2364 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2365 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2366 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2367 <hr><h3><a name="pdf-xpcall"><code>xpcall (f, msgh [, arg1, ···])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2368 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2369 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2370 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2371 This function is similar to <a href="#pdf-pcall"><code>pcall</code></a>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2372 except that it sets a new message handler <code>msgh</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2373 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2374 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2375 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2376 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2377 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2378 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2379 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2380 <h2>6.2 – <a name="6.2">Coroutine Manipulation</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2381 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2382 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2383 The operations related to coroutines comprise a sub-library of |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2384 the basic library and come inside the table <a name="pdf-coroutine"><code>coroutine</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2385 See <a href="#2.6">§2.6</a> for a general description of coroutines. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2386 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2387 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2388 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2389 <hr><h3><a name="pdf-coroutine.create"><code>coroutine.create (f)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2390 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2391 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2392 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2393 Creates a new coroutine, with body <code>f</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2394 <code>f</code> must be a Lua function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2395 Returns this new coroutine, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2396 an object with type <code>"thread"</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2397 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2398 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2399 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2400 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2401 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2402 <hr><h3><a name="pdf-coroutine.isyieldable"><code>coroutine.isyieldable ()</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2403 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2404 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2405 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2406 Returns true when the running coroutine can yield. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2407 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2408 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2409 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2410 A running coroutine is yieldable if it is not the main thread and |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2411 it is not inside a non-yieldable C function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2412 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2413 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2414 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2415 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2416 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2417 <hr><h3><a name="pdf-coroutine.resume"><code>coroutine.resume (co [, val1, ···])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2418 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2419 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2420 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2421 Starts or continues the execution of coroutine <code>co</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2422 The first time you resume a coroutine, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2423 it starts running its body. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2424 The values <code>val1</code>, ... are passed |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2425 as the arguments to the body function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2426 If the coroutine has yielded, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2427 <code>resume</code> restarts it; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2428 the values <code>val1</code>, ... are passed |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2429 as the results from the yield. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2430 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2431 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2432 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2433 If the coroutine runs without any errors, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2434 <code>resume</code> returns <b>true</b> plus any values passed to <code>yield</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2435 (when the coroutine yields) or any values returned by the body function |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2436 (when the coroutine terminates). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2437 If there is any error, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2438 <code>resume</code> returns <b>false</b> plus the error message. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2439 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2440 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2441 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2442 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2443 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2444 <hr><h3><a name="pdf-coroutine.running"><code>coroutine.running ()</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2445 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2446 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2447 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2448 Returns the running coroutine plus a boolean, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2449 true when the running coroutine is the main one. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2450 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2451 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2452 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2453 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2454 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2455 <hr><h3><a name="pdf-coroutine.status"><code>coroutine.status (co)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2456 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2457 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2458 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2459 Returns the status of coroutine <code>co</code>, as a string: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2460 <code>"running"</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2461 if the coroutine is running (that is, it called <code>status</code>); |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2462 <code>"suspended"</code>, if the coroutine is suspended in a call to <code>yield</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2463 or if it has not started running yet; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2464 <code>"normal"</code> if the coroutine is active but not running |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2465 (that is, it has resumed another coroutine); |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2466 and <code>"dead"</code> if the coroutine has finished its body function, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2467 or if it has stopped with an error. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2468 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2469 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2470 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2471 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2472 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2473 <hr><h3><a name="pdf-coroutine.wrap"><code>coroutine.wrap (f)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2474 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2475 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2476 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2477 Creates a new coroutine, with body <code>f</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2478 <code>f</code> must be a Lua function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2479 Returns a function that resumes the coroutine each time it is called. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2480 Any arguments passed to the function behave as the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2481 extra arguments to <code>resume</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2482 Returns the same values returned by <code>resume</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2483 except the first boolean. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2484 In case of error, propagates the error. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2485 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2486 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2487 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2488 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2489 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2490 <hr><h3><a name="pdf-coroutine.yield"><code>coroutine.yield (···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2491 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2492 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2493 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2494 Suspends the execution of the calling coroutine. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2495 Any arguments to <code>yield</code> are passed as extra results to <code>resume</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2496 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2497 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2498 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2499 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2500 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2501 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2502 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2503 <h2>6.3 – <a name="6.3">Modules</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2504 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2505 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2506 The package library provides basic |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2507 facilities for loading modules in Lua. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2508 It exports one function directly in the global environment: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2509 <a href="#pdf-require"><code>require</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2510 Everything else is exported in a table <a name="pdf-package"><code>package</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2511 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2512 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2513 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2514 <hr><h3><a name="pdf-require"><code>require (modname)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2515 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2516 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2517 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2518 Loads the given module. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2519 The function starts by looking into the <a href="#pdf-package.loaded"><code>package.loaded</code></a> table |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2520 to determine whether <code>modname</code> is already loaded. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2521 If it is, then <code>require</code> returns the value stored |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2522 at <code>package.loaded[modname]</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2523 Otherwise, it tries to find a <em>loader</em> for the module. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2524 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2525 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2526 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2527 To find a loader, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2528 <code>require</code> is guided by the <a href="#pdf-package.searchers"><code>package.searchers</code></a> sequence. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2529 By changing this sequence, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2530 we can change how <code>require</code> looks for a module. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2531 The following explanation is based on the default configuration |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2532 for <a href="#pdf-package.searchers"><code>package.searchers</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2533 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2534 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2535 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2536 First <code>require</code> queries <code>package.preload[modname]</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2537 If it has a value, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2538 this value (which must be a function) is the loader. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2539 Otherwise <code>require</code> searches for a Lua loader using the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2540 path stored in <a href="#pdf-package.path"><code>package.path</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2541 If that also fails, it searches for a C loader using the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2542 path stored in <a href="#pdf-package.cpath"><code>package.cpath</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2543 If that also fails, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2544 it tries an <em>all-in-one</em> loader (see <a href="#pdf-package.searchers"><code>package.searchers</code></a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2545 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2546 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2547 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2548 Once a loader is found, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2549 <code>require</code> calls the loader with two arguments: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2550 <code>modname</code> and an extra value dependent on how it got the loader. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2551 (If the loader came from a file, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2552 this extra value is the file name.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2553 If the loader returns any non-nil value, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2554 <code>require</code> assigns the returned value to <code>package.loaded[modname]</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2555 If the loader does not return a non-nil value and |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2556 has not assigned any value to <code>package.loaded[modname]</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2557 then <code>require</code> assigns <b>true</b> to this entry. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2558 In any case, <code>require</code> returns the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2559 final value of <code>package.loaded[modname]</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2560 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2561 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2562 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2563 If there is any error loading or running the module, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2564 or if it cannot find any loader for the module, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2565 then <code>require</code> raises an error. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2566 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2567 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2568 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2569 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2570 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2571 <hr><h3><a name="pdf-package.config"><code>package.config</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2572 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2573 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2574 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2575 A string describing some compile-time configurations for packages. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2576 This string is a sequence of lines: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2577 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2578 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2579 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2580 <li>The first line is the directory separator string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2581 Default is '<code>\</code>' for Windows and '<code>/</code>' for all other systems.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2582 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2583 <li>The second line is the character that separates templates in a path. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2584 Default is '<code>;</code>'.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2585 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2586 <li>The third line is the string that marks the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2587 substitution points in a template. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2588 Default is '<code>?</code>'.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2589 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2590 <li>The fourth line is a string that, in a path in Windows, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2591 is replaced by the executable's directory. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2592 Default is '<code>!</code>'.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2593 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2594 <li>The fifth line is a mark to ignore all text after it |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2595 when building the <code>luaopen_</code> function name. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2596 Default is '<code>-</code>'.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2597 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2598 </ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2599 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2600 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2601 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2602 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2603 <hr><h3><a name="pdf-package.cpath"><code>package.cpath</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2604 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2605 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2606 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2607 The path used by <a href="#pdf-require"><code>require</code></a> to search for a C loader. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2608 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2609 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2610 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2611 Lua initializes the C path <a href="#pdf-package.cpath"><code>package.cpath</code></a> in the same way |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2612 it initializes the Lua path <a href="#pdf-package.path"><code>package.path</code></a>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2613 using the environment variable <a name="pdf-LUA_CPATH_5_3"><code>LUA_CPATH_5_3</code></a> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2614 or the environment variable <a name="pdf-LUA_CPATH"><code>LUA_CPATH</code></a> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2615 or a default path defined in <code>luaconf.h</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2616 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2617 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2618 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2619 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2620 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2621 <hr><h3><a name="pdf-package.loaded"><code>package.loaded</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2622 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2623 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2624 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2625 A table used by <a href="#pdf-require"><code>require</code></a> to control which |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2626 modules are already loaded. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2627 When you require a module <code>modname</code> and |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2628 <code>package.loaded[modname]</code> is not false, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2629 <a href="#pdf-require"><code>require</code></a> simply returns the value stored there. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2630 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2631 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2632 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2633 This variable is only a reference to the real table; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2634 assignments to this variable do not change the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2635 table used by <a href="#pdf-require"><code>require</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2636 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2637 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2638 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2639 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2640 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2641 <hr><h3><a name="pdf-package.loadlib"><code>package.loadlib (libname, funcname)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2642 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2643 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2644 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2645 Dynamically links the host program with the C library <code>libname</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2646 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2647 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2648 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2649 If <code>funcname</code> is "<code>*</code>", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2650 then it only links with the library, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2651 making the symbols exported by the library |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2652 available to other dynamically linked libraries. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2653 Otherwise, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2654 it looks for a function <code>funcname</code> inside the library |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2655 and returns this function as a C function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2656 So, <code>funcname</code> must follow the <a href="#lua_CFunction"><code>lua_CFunction</code></a> prototype |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2657 (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2658 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2659 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2660 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2661 This is a low-level function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2662 It completely bypasses the package and module system. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2663 Unlike <a href="#pdf-require"><code>require</code></a>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2664 it does not perform any path searching and |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2665 does not automatically adds extensions. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2666 <code>libname</code> must be the complete file name of the C library, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2667 including if necessary a path and an extension. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2668 <code>funcname</code> must be the exact name exported by the C library |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2669 (which may depend on the C compiler and linker used). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2670 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2671 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2672 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2673 This function is not supported by Standard C. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2674 As such, it is only available on some platforms |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2675 (Windows, Linux, Mac OS X, Solaris, BSD, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2676 plus other Unix systems that support the <code>dlfcn</code> standard). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2677 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2678 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2679 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2680 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2681 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2682 <hr><h3><a name="pdf-package.path"><code>package.path</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2683 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2684 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2685 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2686 The path used by <a href="#pdf-require"><code>require</code></a> to search for a Lua loader. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2687 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2688 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2689 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2690 At start-up, Lua initializes this variable with |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2691 the value of the environment variable <a name="pdf-LUA_PATH_5_3"><code>LUA_PATH_5_3</code></a> or |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2692 the environment variable <a name="pdf-LUA_PATH"><code>LUA_PATH</code></a> or |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2693 with a default path defined in <code>luaconf.h</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2694 if those environment variables are not defined. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2695 Any "<code>;;</code>" in the value of the environment variable |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2696 is replaced by the default path. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2697 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2698 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2699 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2700 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2701 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2702 <hr><h3><a name="pdf-package.preload"><code>package.preload</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2703 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2704 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2705 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2706 A table to store loaders for specific modules |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2707 (see <a href="#pdf-require"><code>require</code></a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2708 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2709 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2710 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2711 This variable is only a reference to the real table; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2712 assignments to this variable do not change the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2713 table used by <a href="#pdf-require"><code>require</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2714 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2715 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2716 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2717 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2718 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2719 <hr><h3><a name="pdf-package.searchers"><code>package.searchers</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2720 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2721 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2722 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2723 A table used by <a href="#pdf-require"><code>require</code></a> to control how to load modules. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2724 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2725 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2726 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2727 Each entry in this table is a <em>searcher function</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2728 When looking for a module, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2729 <a href="#pdf-require"><code>require</code></a> calls each of these searchers in ascending order, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2730 with the module name (the argument given to <a href="#pdf-require"><code>require</code></a>) as its |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2731 sole parameter. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2732 The function can return another function (the module <em>loader</em>) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2733 plus an extra value that will be passed to that loader, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2734 or a string explaining why it did not find that module |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2735 (or <b>nil</b> if it has nothing to say). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2736 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2737 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2738 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2739 Lua initializes this table with four searcher functions. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2740 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2741 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2742 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2743 The first searcher simply looks for a loader in the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2744 <a href="#pdf-package.preload"><code>package.preload</code></a> table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2745 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2746 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2747 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2748 The second searcher looks for a loader as a Lua library, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2749 using the path stored at <a href="#pdf-package.path"><code>package.path</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2750 The search is done as described in function <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2751 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2752 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2753 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2754 The third searcher looks for a loader as a C library, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2755 using the path given by the variable <a href="#pdf-package.cpath"><code>package.cpath</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2756 Again, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2757 the search is done as described in function <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2758 For instance, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2759 if the C path is the string |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2760 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2761 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2762 "./?.so;./?.dll;/usr/local/?/init.so" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2763 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2764 the searcher for module <code>foo</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2765 will try to open the files <code>./foo.so</code>, <code>./foo.dll</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2766 and <code>/usr/local/foo/init.so</code>, in that order. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2767 Once it finds a C library, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2768 this searcher first uses a dynamic link facility to link the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2769 application with the library. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2770 Then it tries to find a C function inside the library to |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2771 be used as the loader. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2772 The name of this C function is the string "<code>luaopen_</code>" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2773 concatenated with a copy of the module name where each dot |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2774 is replaced by an underscore. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2775 Moreover, if the module name has a hyphen, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2776 its suffix after (and including) the first hyphen is removed. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2777 For instance, if the module name is <code>a.b.c-v2.1</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2778 the function name will be <code>luaopen_a_b_c</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2779 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2780 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2781 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2782 The fourth searcher tries an <em>all-in-one loader</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2783 It searches the C path for a library for |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2784 the root name of the given module. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2785 For instance, when requiring <code>a.b.c</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2786 it will search for a C library for <code>a</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2787 If found, it looks into it for an open function for |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2788 the submodule; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2789 in our example, that would be <code>luaopen_a_b_c</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2790 With this facility, a package can pack several C submodules |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2791 into one single library, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2792 with each submodule keeping its original open function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2793 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2794 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2795 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2796 All searchers except the first one (preload) return as the extra value |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2797 the file name where the module was found, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2798 as returned by <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2799 The first searcher returns no extra value. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2800 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2801 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2802 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2803 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2804 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2805 <hr><h3><a name="pdf-package.searchpath"><code>package.searchpath (name, path [, sep [, rep]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2806 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2807 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2808 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2809 Searches for the given <code>name</code> in the given <code>path</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2810 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2811 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2812 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2813 A path is a string containing a sequence of |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2814 <em>templates</em> separated by semicolons. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2815 For each template, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2816 the function replaces each interrogation mark (if any) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2817 in the template with a copy of <code>name</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2818 wherein all occurrences of <code>sep</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2819 (a dot, by default) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2820 were replaced by <code>rep</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2821 (the system's directory separator, by default), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2822 and then tries to open the resulting file name. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2823 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2824 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2825 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2826 For instance, if the path is the string |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2827 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2828 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2829 "./?.lua;./?.lc;/usr/local/?/init.lua" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2830 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2831 the search for the name <code>foo.a</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2832 will try to open the files |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2833 <code>./foo/a.lua</code>, <code>./foo/a.lc</code>, and |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2834 <code>/usr/local/foo/a/init.lua</code>, in that order. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2835 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2836 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2837 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2838 Returns the resulting name of the first file that it can |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2839 open in read mode (after closing the file), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2840 or <b>nil</b> plus an error message if none succeeds. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2841 (This error message lists all file names it tried to open.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2842 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2843 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2844 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2845 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2846 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2847 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2848 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2849 <h2>6.4 – <a name="6.4">String Manipulation</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2850 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2851 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2852 This library provides generic functions for string manipulation, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2853 such as finding and extracting substrings, and pattern matching. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2854 When indexing a string in Lua, the first character is at position 1 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2855 (not at 0, as in C). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2856 Indices are allowed to be negative and are interpreted as indexing backwards, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2857 from the end of the string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2858 Thus, the last character is at position -1, and so on. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2859 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2860 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2861 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2862 The string library provides all its functions inside the table |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2863 <a name="pdf-string"><code>string</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2864 It also sets a metatable for strings |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2865 where the <code>__index</code> field points to the <code>string</code> table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2866 Therefore, you can use the string functions in object-oriented style. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2867 For instance, <code>string.byte(s,i)</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2868 can be written as <code>s:byte(i)</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2869 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2870 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2871 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2872 The string library assumes one-byte character encodings. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2873 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2874 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2875 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2876 <hr><h3><a name="pdf-string.byte"><code>string.byte (s [, i [, j]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2877 Returns the internal numerical codes of the characters <code>s[i]</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2878 <code>s[i+1]</code>, ..., <code>s[j]</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2879 The default value for <code>i</code> is 1; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2880 the default value for <code>j</code> is <code>i</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2881 These indices are corrected |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2882 following the same rules of function <a href="#pdf-string.sub"><code>string.sub</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2883 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2884 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2885 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2886 Numerical codes are not necessarily portable across platforms. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2887 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2888 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2889 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2890 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2891 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2892 <hr><h3><a name="pdf-string.char"><code>string.char (···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2893 Receives zero or more integers. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2894 Returns a string with length equal to the number of arguments, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2895 in which each character has the internal numerical code equal |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2896 to its corresponding argument. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2897 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2898 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2899 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2900 Numerical codes are not necessarily portable across platforms. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2901 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2902 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2903 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2904 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2905 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2906 <hr><h3><a name="pdf-string.dump"><code>string.dump (function [, strip])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2907 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2908 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2909 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2910 Returns a string containing a binary representation |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2911 (a <em>binary chunk</em>) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2912 of the given function, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2913 so that a later <a href="#pdf-load"><code>load</code></a> on this string returns |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2914 a copy of the function (but with new upvalues). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2915 If <code>strip</code> is a true value, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2916 the binary representation is created without debug information |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2917 about the function |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2918 (local variable names, lines, etc.). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2919 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2920 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2921 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2922 Functions with upvalues have only their number of upvalues saved. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2923 When (re)loaded, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2924 those upvalues receive fresh instances containing <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2925 (You can use the debug library to serialize |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2926 and reload the upvalues of a function |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2927 in a way adequate to your needs.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2928 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2929 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2930 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2931 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2932 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2933 <hr><h3><a name="pdf-string.find"><code>string.find (s, pattern [, init [, plain]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2934 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2935 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2936 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2937 Looks for the first match of |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2938 <code>pattern</code> (see <a href="#6.4.1">§6.4.1</a>) in the string <code>s</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2939 If it finds a match, then <code>find</code> returns the indices of <code>s</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2940 where this occurrence starts and ends; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2941 otherwise, it returns <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2942 A third, optional numerical argument <code>init</code> specifies |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2943 where to start the search; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2944 its default value is 1 and can be negative. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2945 A value of <b>true</b> as a fourth, optional argument <code>plain</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2946 turns off the pattern matching facilities, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2947 so the function does a plain "find substring" operation, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2948 with no characters in <code>pattern</code> being considered magic. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2949 Note that if <code>plain</code> is given, then <code>init</code> must be given as well. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2950 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2951 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2952 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2953 If the pattern has captures, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2954 then in a successful match |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2955 the captured values are also returned, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2956 after the two indices. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2957 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2958 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2959 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2960 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2961 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2962 <hr><h3><a name="pdf-string.format"><code>string.format (formatstring, ···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2963 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2964 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2965 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2966 Returns a formatted version of its variable number of arguments |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2967 following the description given in its first argument (which must be a string). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2968 The format string follows the same rules as the ISO C function <code>sprintf</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2969 The only differences are that the options/modifiers |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2970 <code>*</code>, <code>h</code>, <code>L</code>, <code>l</code>, <code>n</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2971 and <code>p</code> are not supported |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2972 and that there is an extra option, <code>q</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2973 The <code>q</code> option formats a string between double quotes, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2974 using escape sequences when necessary to ensure that |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2975 it can safely be read back by the Lua interpreter. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2976 For instance, the call |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2977 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2978 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2979 string.format('%q', 'a string with "quotes" and \n new line') |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2980 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2981 may produce the string: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2982 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2983 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2984 "a string with \"quotes\" and \ |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2985 new line" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2986 </pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2987 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2988 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2989 Options |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2990 <code>A</code> and <code>a</code> (when available), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2991 <code>E</code>, <code>e</code>, <code>f</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2992 <code>G</code>, and <code>g</code> all expect a number as argument. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2993 Options <code>c</code>, <code>d</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2994 <code>i</code>, <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2995 expect an integer. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2996 Option <code>q</code> expects a string; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2997 option <code>s</code> expects a string without embedded zeros. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2998 If the argument to option <code>s</code> is not a string, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
2999 it is converted to one following the same rules of <a href="#pdf-tostring"><code>tostring</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3000 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3001 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3002 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3003 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3004 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3005 <hr><h3><a name="pdf-string.gmatch"><code>string.gmatch (s, pattern)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3006 Returns an iterator function that, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3007 each time it is called, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3008 returns the next captures from <code>pattern</code> (see <a href="#6.4.1">§6.4.1</a>) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3009 over the string <code>s</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3010 If <code>pattern</code> specifies no captures, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3011 then the whole match is produced in each call. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3012 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3013 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3014 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3015 As an example, the following loop |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3016 will iterate over all the words from string <code>s</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3017 printing one per line: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3018 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3019 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3020 s = "hello world from Lua" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3021 for w in string.gmatch(s, "%a+") do |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3022 print(w) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3023 end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3024 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3025 The next example collects all pairs <code>key=value</code> from the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3026 given string into a table: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3027 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3028 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3029 t = {} |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3030 s = "from=world, to=Lua" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3031 for k, v in string.gmatch(s, "(%w+)=(%w+)") do |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3032 t[k] = v |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3033 end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3034 </pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3035 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3036 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3037 For this function, a caret '<code>^</code>' at the start of a pattern does not |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3038 work as an anchor, as this would prevent the iteration. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3039 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3040 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3041 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3042 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3043 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3044 <hr><h3><a name="pdf-string.gsub"><code>string.gsub (s, pattern, repl [, n])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3045 Returns a copy of <code>s</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3046 in which all (or the first <code>n</code>, if given) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3047 occurrences of the <code>pattern</code> (see <a href="#6.4.1">§6.4.1</a>) have been |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3048 replaced by a replacement string specified by <code>repl</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3049 which can be a string, a table, or a function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3050 <code>gsub</code> also returns, as its second value, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3051 the total number of matches that occurred. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3052 The name <code>gsub</code> comes from <em>Global SUBstitution</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3053 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3054 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3055 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3056 If <code>repl</code> is a string, then its value is used for replacement. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3057 The character <code>%</code> works as an escape character: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3058 any sequence in <code>repl</code> of the form <code>%<em>d</em></code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3059 with <em>d</em> between 1 and 9, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3060 stands for the value of the <em>d</em>-th captured substring. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3061 The sequence <code>%0</code> stands for the whole match. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3062 The sequence <code>%%</code> stands for a single <code>%</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3063 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3064 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3065 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3066 If <code>repl</code> is a table, then the table is queried for every match, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3067 using the first capture as the key. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3068 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3069 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3070 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3071 If <code>repl</code> is a function, then this function is called every time a |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3072 match occurs, with all captured substrings passed as arguments, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3073 in order. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3074 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3075 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3076 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3077 In any case, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3078 if the pattern specifies no captures, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3079 then it behaves as if the whole pattern was inside a capture. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3080 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3081 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3082 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3083 If the value returned by the table query or by the function call |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3084 is a string or a number, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3085 then it is used as the replacement string; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3086 otherwise, if it is <b>false</b> or <b>nil</b>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3087 then there is no replacement |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3088 (that is, the original match is kept in the string). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3089 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3090 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3091 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3092 Here are some examples: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3093 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3094 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3095 x = string.gsub("hello world", "(%w+)", "%1 %1") |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3096 --> x="hello hello world world" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3097 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3098 x = string.gsub("hello world", "%w+", "%0 %0", 1) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3099 --> x="hello hello world" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3100 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3101 x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1") |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3102 --> x="world hello Lua from" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3103 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3104 x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3105 --> x="home = /home/roberto, user = roberto" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3106 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3107 x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3108 return load(s)() |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3109 end) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3110 --> x="4+5 = 9" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3111 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3112 local t = {name="lua", version="5.3"} |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3113 x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3114 --> x="lua-5.3.tar.gz" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3115 </pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3116 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3117 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3118 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3119 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3120 <hr><h3><a name="pdf-string.len"><code>string.len (s)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3121 Receives a string and returns its length. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3122 The empty string <code>""</code> has length 0. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3123 Embedded zeros are counted, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3124 so <code>"a\000bc\000"</code> has length 5. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3125 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3126 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3127 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3128 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3129 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3130 <hr><h3><a name="pdf-string.lower"><code>string.lower (s)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3131 Receives a string and returns a copy of this string with all |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3132 uppercase letters changed to lowercase. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3133 All other characters are left unchanged. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3134 The definition of what an uppercase letter is depends on the current locale. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3135 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3136 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3137 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3138 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3139 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3140 <hr><h3><a name="pdf-string.match"><code>string.match (s, pattern [, init])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3141 Looks for the first <em>match</em> of |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3142 <code>pattern</code> (see <a href="#6.4.1">§6.4.1</a>) in the string <code>s</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3143 If it finds one, then <code>match</code> returns |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3144 the captures from the pattern; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3145 otherwise it returns <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3146 If <code>pattern</code> specifies no captures, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3147 then the whole match is returned. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3148 A third, optional numerical argument <code>init</code> specifies |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3149 where to start the search; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3150 its default value is 1 and can be negative. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3151 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3152 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3153 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3154 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3155 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3156 <hr><h3><a name="pdf-string.pack"><code>string.pack (fmt, v1, v2, ···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3157 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3158 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3159 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3160 Returns a binary string containing the values <code>v1</code>, <code>v2</code>, etc. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3161 packed (that is, serialized in binary form) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3162 according to the format string <code>fmt</code> (see <a href="#6.4.2">§6.4.2</a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3163 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3164 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3165 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3166 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3167 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3168 <hr><h3><a name="pdf-string.packsize"><code>string.packsize (fmt)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3169 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3170 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3171 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3172 Returns the size of a string resulting from <a href="#pdf-string.pack"><code>string.pack</code></a> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3173 with the given format. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3174 The format string cannot have the variable-length options |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3175 '<code>s</code>' or '<code>z</code>' (see <a href="#6.4.2">§6.4.2</a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3176 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3177 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3178 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3179 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3180 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3181 <hr><h3><a name="pdf-string.rep"><code>string.rep (s, n [, sep])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3182 Returns a string that is the concatenation of <code>n</code> copies of |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3183 the string <code>s</code> separated by the string <code>sep</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3184 The default value for <code>sep</code> is the empty string |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3185 (that is, no separator). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3186 Returns the empty string if <code>n</code> is not positive. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3187 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3188 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3189 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3190 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3191 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3192 <hr><h3><a name="pdf-string.reverse"><code>string.reverse (s)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3193 Returns a string that is the string <code>s</code> reversed. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3194 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3195 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3196 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3197 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3198 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3199 <hr><h3><a name="pdf-string.sub"><code>string.sub (s, i [, j])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3200 Returns the substring of <code>s</code> that |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3201 starts at <code>i</code> and continues until <code>j</code>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3202 <code>i</code> and <code>j</code> can be negative. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3203 If <code>j</code> is absent, then it is assumed to be equal to -1 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3204 (which is the same as the string length). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3205 In particular, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3206 the call <code>string.sub(s,1,j)</code> returns a prefix of <code>s</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3207 with length <code>j</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3208 and <code>string.sub(s, -i)</code> returns a suffix of <code>s</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3209 with length <code>i</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3210 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3211 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3212 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3213 If, after the translation of negative indices, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3214 <code>i</code> is less than 1, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3215 it is corrected to 1. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3216 If <code>j</code> is greater than the string length, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3217 it is corrected to that length. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3218 If, after these corrections, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3219 <code>i</code> is greater than <code>j</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3220 the function returns the empty string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3221 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3222 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3223 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3224 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3225 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3226 <hr><h3><a name="pdf-string.unpack"><code>string.unpack (fmt, s [, pos])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3227 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3228 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3229 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3230 Returns the values packed in string <code>s</code> (see <a href="#pdf-string.pack"><code>string.pack</code></a>) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3231 according to the format string <code>fmt</code> (see <a href="#6.4.2">§6.4.2</a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3232 An optional <code>pos</code> marks where |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3233 to start reading in <code>s</code> (default is 1). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3234 After the read values, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3235 this function also returns the index of the first unread byte in <code>s</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3236 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3237 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3238 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3239 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3240 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3241 <hr><h3><a name="pdf-string.upper"><code>string.upper (s)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3242 Receives a string and returns a copy of this string with all |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3243 lowercase letters changed to uppercase. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3244 All other characters are left unchanged. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3245 The definition of what a lowercase letter is depends on the current locale. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3246 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3247 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3248 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3249 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3250 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3251 <h3>6.4.1 – <a name="6.4.1">Patterns</a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3252 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3253 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3254 Patterns in Lua are described by regular strings, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3255 which are interpreted as patterns by the pattern-matching functions |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3256 <a href="#pdf-string.find"><code>string.find</code></a>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3257 <a href="#pdf-string.gmatch"><code>string.gmatch</code></a>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3258 <a href="#pdf-string.gsub"><code>string.gsub</code></a>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3259 and <a href="#pdf-string.match"><code>string.match</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3260 This section describes the syntax and the meaning |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3261 (that is, what they match) of these strings. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3262 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3263 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3264 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3265 <h4>Character Class:</h4><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3266 A <em>character class</em> is used to represent a set of characters. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3267 The following combinations are allowed in describing a character class: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3268 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3269 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3270 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3271 <li><b><em>x</em>: </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3272 (where <em>x</em> is not one of the <em>magic characters</em> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3273 <code>^$()%.[]*+-?</code>) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3274 represents the character <em>x</em> itself. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3275 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3276 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3277 <li><b><code>.</code>: </b> (a dot) represents all characters.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3278 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3279 <li><b><code>%a</code>: </b> represents all letters.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3280 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3281 <li><b><code>%c</code>: </b> represents all control characters.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3282 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3283 <li><b><code>%d</code>: </b> represents all digits.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3284 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3285 <li><b><code>%g</code>: </b> represents all printable characters except space.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3286 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3287 <li><b><code>%l</code>: </b> represents all lowercase letters.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3288 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3289 <li><b><code>%p</code>: </b> represents all punctuation characters.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3290 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3291 <li><b><code>%s</code>: </b> represents all space characters.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3292 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3293 <li><b><code>%u</code>: </b> represents all uppercase letters.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3294 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3295 <li><b><code>%w</code>: </b> represents all alphanumeric characters.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3296 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3297 <li><b><code>%x</code>: </b> represents all hexadecimal digits.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3298 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3299 <li><b><code>%<em>x</em></code>: </b> (where <em>x</em> is any non-alphanumeric character) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3300 represents the character <em>x</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3301 This is the standard way to escape the magic characters. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3302 Any non-alphanumeric character |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3303 (including all punctuations, even the non-magical) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3304 can be preceded by a '<code>%</code>' |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3305 when used to represent itself in a pattern. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3306 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3307 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3308 <li><b><code>[<em>set</em>]</code>: </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3309 represents the class which is the union of all |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3310 characters in <em>set</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3311 A range of characters can be specified by |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3312 separating the end characters of the range, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3313 in ascending order, with a '<code>-</code>'. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3314 All classes <code>%</code><em>x</em> described above can also be used as |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3315 components in <em>set</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3316 All other characters in <em>set</em> represent themselves. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3317 For example, <code>[%w_]</code> (or <code>[_%w]</code>) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3318 represents all alphanumeric characters plus the underscore, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3319 <code>[0-7]</code> represents the octal digits, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3320 and <code>[0-7%l%-]</code> represents the octal digits plus |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3321 the lowercase letters plus the '<code>-</code>' character. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3322 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3323 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3324 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3325 The interaction between ranges and classes is not defined. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3326 Therefore, patterns like <code>[%a-z]</code> or <code>[a-%%]</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3327 have no meaning. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3328 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3329 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3330 <li><b><code>[^<em>set</em>]</code>: </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3331 represents the complement of <em>set</em>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3332 where <em>set</em> is interpreted as above. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3333 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3334 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3335 </ul><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3336 For all classes represented by single letters (<code>%a</code>, <code>%c</code>, etc.), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3337 the corresponding uppercase letter represents the complement of the class. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3338 For instance, <code>%S</code> represents all non-space characters. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3339 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3340 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3341 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3342 The definitions of letter, space, and other character groups |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3343 depend on the current locale. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3344 In particular, the class <code>[a-z]</code> may not be equivalent to <code>%l</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3345 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3346 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3347 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3348 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3349 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3350 <h4>Pattern Item:</h4><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3351 A <em>pattern item</em> can be |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3352 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3353 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3354 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3355 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3356 a single character class, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3357 which matches any single character in the class; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3358 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3359 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3360 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3361 a single character class followed by '<code>*</code>', |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3362 which matches zero or more repetitions of characters in the class. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3363 These repetition items will always match the longest possible sequence; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3364 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3365 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3366 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3367 a single character class followed by '<code>+</code>', |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3368 which matches one or more repetitions of characters in the class. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3369 These repetition items will always match the longest possible sequence; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3370 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3371 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3372 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3373 a single character class followed by '<code>-</code>', |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3374 which also matches zero or more repetitions of characters in the class. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3375 Unlike '<code>*</code>', |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3376 these repetition items will always match the shortest possible sequence; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3377 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3378 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3379 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3380 a single character class followed by '<code>?</code>', |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3381 which matches zero or one occurrence of a character in the class. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3382 It always matches one occurrence if possible; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3383 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3384 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3385 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3386 <code>%<em>n</em></code>, for <em>n</em> between 1 and 9; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3387 such item matches a substring equal to the <em>n</em>-th captured string |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3388 (see below); |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3389 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3390 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3391 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3392 <code>%b<em>xy</em></code>, where <em>x</em> and <em>y</em> are two distinct characters; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3393 such item matches strings that start with <em>x</em>, end with <em>y</em>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3394 and where the <em>x</em> and <em>y</em> are <em>balanced</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3395 This means that, if one reads the string from left to right, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3396 counting <em>+1</em> for an <em>x</em> and <em>-1</em> for a <em>y</em>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3397 the ending <em>y</em> is the first <em>y</em> where the count reaches 0. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3398 For instance, the item <code>%b()</code> matches expressions with |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3399 balanced parentheses. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3400 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3401 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3402 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3403 <code>%f[<em>set</em>]</code>, a <em>frontier pattern</em>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3404 such item matches an empty string at any position such that |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3405 the next character belongs to <em>set</em> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3406 and the previous character does not belong to <em>set</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3407 The set <em>set</em> is interpreted as previously described. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3408 The beginning and the end of the subject are handled as if |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3409 they were the character '<code>\0</code>'. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3410 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3411 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3412 </ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3413 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3414 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3415 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3416 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3417 <h4>Pattern:</h4><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3418 A <em>pattern</em> is a sequence of pattern items. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3419 A caret '<code>^</code>' at the beginning of a pattern anchors the match at the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3420 beginning of the subject string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3421 A '<code>$</code>' at the end of a pattern anchors the match at the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3422 end of the subject string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3423 At other positions, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3424 '<code>^</code>' and '<code>$</code>' have no special meaning and represent themselves. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3425 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3426 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3427 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3428 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3429 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3430 <h4>Captures:</h4><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3431 A pattern can contain sub-patterns enclosed in parentheses; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3432 they describe <em>captures</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3433 When a match succeeds, the substrings of the subject string |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3434 that match captures are stored (<em>captured</em>) for future use. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3435 Captures are numbered according to their left parentheses. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3436 For instance, in the pattern <code>"(a*(.)%w(%s*))"</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3437 the part of the string matching <code>"a*(.)%w(%s*)"</code> is |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3438 stored as the first capture (and therefore has number 1); |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3439 the character matching "<code>.</code>" is captured with number 2, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3440 and the part matching "<code>%s*</code>" has number 3. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3441 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3442 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3443 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3444 As a special case, the empty capture <code>()</code> captures |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3445 the current string position (a number). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3446 For instance, if we apply the pattern <code>"()aa()"</code> on the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3447 string <code>"flaaap"</code>, there will be two captures: 3 and 5. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3448 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3449 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3450 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3451 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3452 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3453 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3454 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3455 <h3>6.4.2 – <a name="6.4.2">Format Strings for Pack and Unpack</a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3456 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3457 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3458 The first argument to <a href="#pdf-string.pack"><code>string.pack</code></a>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3459 <a href="#pdf-string.packsize"><code>string.packsize</code></a>, and <a href="#pdf-string.unpack"><code>string.unpack</code></a> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3460 is a format string, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3461 which describes the layout of the structure being created or read. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3462 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3463 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3464 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3465 A format string is a sequence of conversion options. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3466 The conversion options are as follows: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3467 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3468 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3469 <li><b><code><</code>: </b>sets little endian</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3470 <li><b><code>></code>: </b>sets big endian</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3471 <li><b><code>=</code>: </b>sets native endian</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3472 <li><b><code>![<em>n</em>]</code>: </b>sets maximum alignment to <code>n</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3473 (default is native alignment)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3474 <li><b><code>b</code>: </b>a signed byte (<code>char</code>)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3475 <li><b><code>B</code>: </b>an unsigned byte (<code>char</code>)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3476 <li><b><code>h</code>: </b>a signed <code>short</code> (native size)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3477 <li><b><code>H</code>: </b>an unsigned <code>short</code> (native size)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3478 <li><b><code>l</code>: </b>a signed <code>long</code> (native size)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3479 <li><b><code>L</code>: </b>an unsigned <code>long</code> (native size)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3480 <li><b><code>j</code>: </b>a <code>lua_Integer</code></li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3481 <li><b><code>J</code>: </b>a <code>lua_Unsigned</code></li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3482 <li><b><code>T</code>: </b>a <code>size_t</code> (native size)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3483 <li><b><code>i[<em>n</em>]</code>: </b>a signed <code>int</code> with <code>n</code> bytes |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3484 (default is native size)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3485 <li><b><code>I[<em>n</em>]</code>: </b>an unsigned <code>int</code> with <code>n</code> bytes |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3486 (default is native size)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3487 <li><b><code>f</code>: </b>a <code>float</code> (native size)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3488 <li><b><code>d</code>: </b>a <code>double</code> (native size)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3489 <li><b><code>n</code>: </b>a <code>lua_Number</code></li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3490 <li><b><code>c<em>n</em></code>: </b>a fixed-sized string with <code>n</code> bytes</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3491 <li><b><code>z</code>: </b>a zero-terminated string</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3492 <li><b><code>s[<em>n</em>]</code>: </b>a string preceded by its length |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3493 coded as an unsigned integer with <code>n</code> bytes |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3494 (default is a <code>size_t</code>)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3495 <li><b><code>x</code>: </b>one byte of padding</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3496 <li><b><code>X<em>op</em></code>: </b>an empty item that aligns |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3497 according to option <code>op</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3498 (which is otherwise ignored)</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3499 <li><b>'<code> </code>': </b>(empty space) ignored</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3500 </ul><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3501 (A "<code>[<em>n</em>]</code>" means an optional integral numeral.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3502 Except for padding, spaces, and configurations |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3503 (options "<code>xX <=>!</code>"), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3504 each option corresponds to an argument (in <a href="#pdf-string.pack"><code>string.pack</code></a>) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3505 or a result (in <a href="#pdf-string.unpack"><code>string.unpack</code></a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3506 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3507 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3508 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3509 For options "<code>!<em>n</em></code>", "<code>s<em>n</em></code>", "<code>i<em>n</em></code>", and "<code>I<em>n</em></code>", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3510 <code>n</code> can be any integer between 1 and 16. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3511 All integral options check overflows; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3512 <a href="#pdf-string.pack"><code>string.pack</code></a> checks whether the given value fits in the given size; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3513 <a href="#pdf-string.unpack"><code>string.unpack</code></a> checks whether the read value fits in a Lua integer. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3514 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3515 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3516 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3517 Any format string starts as if prefixed by "<code>!1=</code>", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3518 that is, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3519 with maximum alignment of 1 (no alignment) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3520 and native endianness. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3521 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3522 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3523 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3524 Alignment works as follows: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3525 For each option, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3526 the format gets extra padding until the data starts |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3527 at an offset that is a multiple of the minimum between the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3528 option size and the maximum alignment; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3529 this minimum must be a power of 2. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3530 Options "<code>c</code>" and "<code>z</code>" are not aligned; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3531 option "<code>s</code>" follows the alignment of its starting integer. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3532 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3533 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3534 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3535 All padding is filled with zeros by <a href="#pdf-string.pack"><code>string.pack</code></a> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3536 (and ignored by <a href="#pdf-string.unpack"><code>string.unpack</code></a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3537 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3538 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3539 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3540 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3541 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3542 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3543 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3544 <h2>6.5 – <a name="6.5">UTF-8 Support</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3545 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3546 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3547 This library provides basic support for UTF-8 encoding. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3548 It provides all its functions inside the table <a name="pdf-utf8"><code>utf8</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3549 This library does not provide any support for Unicode other |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3550 than the handling of the encoding. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3551 Any operation that needs the meaning of a character, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3552 such as character classification, is outside its scope. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3553 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3554 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3555 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3556 Unless stated otherwise, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3557 all functions that expect a byte position as a parameter |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3558 assume that the given position is either the start of a byte sequence |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3559 or one plus the length of the subject string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3560 As in the string library, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3561 negative indices count from the end of the string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3562 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3563 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3564 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3565 <hr><h3><a name="pdf-utf8.char"><code>utf8.char (···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3566 Receives zero or more integers, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3567 converts each one to its corresponding UTF-8 byte sequence |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3568 and returns a string with the concatenation of all these sequences. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3569 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3570 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3571 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3572 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3573 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3574 <hr><h3><a name="pdf-utf8.charpattern"><code>utf8.charpattern</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3575 The pattern (a string, not a function) "<code>[\0-\x7F\xC2-\xF4][\x80-\xBF]*</code>" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3576 (see <a href="#6.4.1">§6.4.1</a>), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3577 which matches exactly one UTF-8 byte sequence, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3578 assuming that the subject is a valid UTF-8 string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3579 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3580 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3581 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3582 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3583 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3584 <hr><h3><a name="pdf-utf8.codes"><code>utf8.codes (s)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3585 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3586 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3587 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3588 Returns values so that the construction |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3589 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3590 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3591 for p, c in utf8.codes(s) do <em>body</em> end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3592 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3593 will iterate over all characters in string <code>s</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3594 with <code>p</code> being the position (in bytes) and <code>c</code> the code point |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3595 of each character. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3596 It raises an error if it meets any invalid byte sequence. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3597 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3598 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3599 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3600 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3601 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3602 <hr><h3><a name="pdf-utf8.codepoint"><code>utf8.codepoint (s [, i [, j]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3603 Returns the codepoints (as integers) from all characters in <code>s</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3604 that start between byte position <code>i</code> and <code>j</code> (both included). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3605 The default for <code>i</code> is 1 and for <code>j</code> is <code>i</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3606 It raises an error if it meets any invalid byte sequence. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3607 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3608 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3609 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3610 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3611 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3612 <hr><h3><a name="pdf-utf8.len"><code>utf8.len (s [, i [, j]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3613 Returns the number of UTF-8 characters in string <code>s</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3614 that start between positions <code>i</code> and <code>j</code> (both inclusive). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3615 The default for <code>i</code> is 1 and for <code>j</code> is -1. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3616 If it finds any invalid byte sequence, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3617 returns a false value plus the position of the first invalid byte. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3618 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3619 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3620 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3621 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3622 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3623 <hr><h3><a name="pdf-utf8.offset"><code>utf8.offset (s, n [, i])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3624 Returns the position (in bytes) where the encoding of the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3625 <code>n</code>-th character of <code>s</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3626 (counting from position <code>i</code>) starts. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3627 A negative <code>n</code> gets characters before position <code>i</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3628 The default for <code>i</code> is 1 when <code>n</code> is non-negative |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3629 and <code>#s + 1</code> otherwise, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3630 so that <code>utf8.offset(s, -n)</code> gets the offset of the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3631 <code>n</code>-th character from the end of the string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3632 If the specified character is neither in the subject |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3633 nor right after its end, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3634 the function returns <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3635 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3636 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3637 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3638 As a special case, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3639 when <code>n</code> is 0 the function returns the start of the encoding |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3640 of the character that contains the <code>i</code>-th byte of <code>s</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3641 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3642 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3643 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3644 This function assumes that <code>s</code> is a valid UTF-8 string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3645 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3646 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3647 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3648 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3649 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3650 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3651 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3652 <h2>6.6 – <a name="6.6">Table Manipulation</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3653 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3654 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3655 This library provides generic functions for table manipulation. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3656 It provides all its functions inside the table <a name="pdf-table"><code>table</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3657 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3658 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3659 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3660 Remember that, whenever an operation needs the length of a table, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3661 the table must be a proper sequence |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3662 or have a <code>__len</code> metamethod (see <a href="#3.4.7">§3.4.7</a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3663 All functions ignore non-numeric keys |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3664 in the tables given as arguments. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3665 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3666 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3667 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3668 <hr><h3><a name="pdf-table.concat"><code>table.concat (list [, sep [, i [, j]]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3669 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3670 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3671 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3672 Given a list where all elements are strings or numbers, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3673 returns the string <code>list[i]..sep..list[i+1] ··· sep..list[j]</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3674 The default value for <code>sep</code> is the empty string, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3675 the default for <code>i</code> is 1, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3676 and the default for <code>j</code> is <code>#list</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3677 If <code>i</code> is greater than <code>j</code>, returns the empty string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3678 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3679 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3680 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3681 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3682 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3683 <hr><h3><a name="pdf-table.insert"><code>table.insert (list, [pos,] value)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3684 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3685 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3686 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3687 Inserts element <code>value</code> at position <code>pos</code> in <code>list</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3688 shifting up the elements |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3689 <code>list[pos], list[pos+1], ···, list[#list]</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3690 The default value for <code>pos</code> is <code>#list+1</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3691 so that a call <code>table.insert(t,x)</code> inserts <code>x</code> at the end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3692 of list <code>t</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3693 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3694 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3695 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3696 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3697 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3698 <hr><h3><a name="pdf-table.move"><code>table.move (a1, f, e, t [,a2])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3699 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3700 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3701 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3702 Moves elements from table <code>a1</code> to table <code>a2</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3703 This function performs the equivalent to the following |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3704 multiple assignment: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3705 <code>a2[t],··· = a1[f],···,a1[e]</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3706 The default for <code>a2</code> is <code>a1</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3707 The destination range can overlap with the source range. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3708 Index <code>f</code> must be positive. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3709 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3710 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3711 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3712 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3713 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3714 <hr><h3><a name="pdf-table.pack"><code>table.pack (···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3715 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3716 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3717 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3718 Returns a new table with all parameters stored into keys 1, 2, etc. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3719 and with a field "<code>n</code>" with the total number of parameters. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3720 Note that the resulting table may not be a sequence. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3721 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3722 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3723 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3724 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3725 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3726 <hr><h3><a name="pdf-table.remove"><code>table.remove (list [, pos])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3727 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3728 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3729 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3730 Removes from <code>list</code> the element at position <code>pos</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3731 returning the value of the removed element. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3732 When <code>pos</code> is an integer between 1 and <code>#list</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3733 it shifts down the elements |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3734 <code>list[pos+1], list[pos+2], ···, list[#list]</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3735 and erases element <code>list[#list]</code>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3736 The index <code>pos</code> can also be 0 when <code>#list</code> is 0, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3737 or <code>#list + 1</code>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3738 in those cases, the function erases the element <code>list[pos]</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3739 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3740 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3741 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3742 The default value for <code>pos</code> is <code>#list</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3743 so that a call <code>table.remove(l)</code> removes the last element |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3744 of list <code>l</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3745 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3746 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3747 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3748 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3749 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3750 <hr><h3><a name="pdf-table.sort"><code>table.sort (list [, comp])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3751 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3752 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3753 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3754 Sorts list elements in a given order, <em>in-place</em>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3755 from <code>list[1]</code> to <code>list[#list]</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3756 If <code>comp</code> is given, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3757 then it must be a function that receives two list elements |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3758 and returns true when the first element must come |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3759 before the second in the final order |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3760 (so that <code>not comp(list[i+1],list[i])</code> will be true after the sort). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3761 If <code>comp</code> is not given, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3762 then the standard Lua operator <code><</code> is used instead. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3763 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3764 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3765 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3766 The sort algorithm is not stable; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3767 that is, elements considered equal by the given order |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3768 may have their relative positions changed by the sort. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3769 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3770 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3771 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3772 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3773 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3774 <hr><h3><a name="pdf-table.unpack"><code>table.unpack (list [, i [, j]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3775 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3776 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3777 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3778 Returns the elements from the given list. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3779 This function is equivalent to |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3780 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3781 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3782 return list[i], list[i+1], ···, list[j] |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3783 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3784 By default, <code>i</code> is 1 and <code>j</code> is <code>#list</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3785 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3786 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3787 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3788 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3789 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3790 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3791 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3792 <h2>6.7 – <a name="6.7">Mathematical Functions</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3793 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3794 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3795 This library provides basic mathematical functions. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3796 It provides all its functions and constants inside the table <a name="pdf-math"><code>math</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3797 Functions with the annotation "<code>integer/float</code>" give |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3798 integer results for integer arguments |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3799 and float results for float (or mixed) arguments. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3800 Rounding functions |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3801 (<a href="#pdf-math.ceil"><code>math.ceil</code></a>, <a href="#pdf-math.floor"><code>math.floor</code></a>, and <a href="#pdf-math.modf"><code>math.modf</code></a>) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3802 return an integer when the result fits in the range of an integer, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3803 or a float otherwise. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3804 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3805 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3806 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3807 <hr><h3><a name="pdf-math.abs"><code>math.abs (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3808 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3809 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3810 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3811 Returns the absolute value of <code>x</code>. (integer/float) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3812 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3813 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3814 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3815 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3816 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3817 <hr><h3><a name="pdf-math.acos"><code>math.acos (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3818 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3819 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3820 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3821 Returns the arc cosine of <code>x</code> (in radians). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3822 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3823 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3824 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3825 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3826 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3827 <hr><h3><a name="pdf-math.asin"><code>math.asin (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3828 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3829 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3830 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3831 Returns the arc sine of <code>x</code> (in radians). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3832 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3833 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3834 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3835 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3836 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3837 <hr><h3><a name="pdf-math.atan"><code>math.atan (y [, x])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3838 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3839 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3840 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3841 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3842 Returns the arc tangent of <code>y/x</code> (in radians), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3843 but uses the signs of both parameters to find the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3844 quadrant of the result. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3845 (It also handles correctly the case of <code>x</code> being zero.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3846 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3847 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3848 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3849 The default value for <code>x</code> is 1, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3850 so that the call <code>math.atan(y)</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3851 returns the arc tangent of <code>y</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3852 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3853 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3854 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3855 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3856 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3857 <hr><h3><a name="pdf-math.ceil"><code>math.ceil (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3858 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3859 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3860 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3861 Returns the smallest integral value larger than or equal to <code>x</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3862 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3863 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3864 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3865 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3866 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3867 <hr><h3><a name="pdf-math.cos"><code>math.cos (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3868 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3869 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3870 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3871 Returns the cosine of <code>x</code> (assumed to be in radians). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3872 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3873 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3874 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3875 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3876 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3877 <hr><h3><a name="pdf-math.deg"><code>math.deg (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3878 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3879 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3880 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3881 Converts the angle <code>x</code> from radians to degrees. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3882 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3883 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3884 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3885 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3886 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3887 <hr><h3><a name="pdf-math.exp"><code>math.exp (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3888 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3889 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3890 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3891 Returns the value <em>e<sup>x</sup></em> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3892 (where <code>e</code> is the base of natural logarithms). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3893 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3894 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3895 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3896 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3897 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3898 <hr><h3><a name="pdf-math.floor"><code>math.floor (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3899 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3900 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3901 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3902 Returns the largest integral value smaller than or equal to <code>x</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3903 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3904 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3905 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3906 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3907 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3908 <hr><h3><a name="pdf-math.fmod"><code>math.fmod (x, y)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3909 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3910 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3911 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3912 Returns the remainder of the division of <code>x</code> by <code>y</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3913 that rounds the quotient towards zero. (integer/float) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3914 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3915 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3916 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3917 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3918 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3919 <hr><h3><a name="pdf-math.huge"><code>math.huge</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3920 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3921 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3922 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3923 The float value <code>HUGE_VAL</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3924 a value larger than any other numerical value. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3925 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3926 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3927 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3928 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3929 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3930 <hr><h3><a name="pdf-math.log"><code>math.log (x [, base])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3931 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3932 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3933 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3934 Returns the logarithm of <code>x</code> in the given base. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3935 The default for <code>base</code> is <em>e</em> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3936 (so that the function returns the natural logarithm of <code>x</code>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3937 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3938 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3939 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3940 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3941 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3942 <hr><h3><a name="pdf-math.max"><code>math.max (x, ···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3943 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3944 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3945 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3946 Returns the argument with the maximum value, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3947 according to the Lua operator <code><</code>. (integer/float) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3948 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3949 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3950 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3951 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3952 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3953 <hr><h3><a name="pdf-math.maxinteger"><code>math.maxinteger</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3954 An integer with the maximum value for an integer. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3955 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3956 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3957 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3958 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3959 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3960 <hr><h3><a name="pdf-math.min"><code>math.min (x, ···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3961 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3962 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3963 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3964 Returns the argument with the minimum value, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3965 according to the Lua operator <code><</code>. (integer/float) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3966 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3967 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3968 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3969 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3970 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3971 <hr><h3><a name="pdf-math.mininteger"><code>math.mininteger</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3972 An integer with the minimum value for an integer. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3973 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3974 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3975 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3976 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3977 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3978 <hr><h3><a name="pdf-math.modf"><code>math.modf (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3979 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3980 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3981 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3982 Returns the integral part of <code>x</code> and the fractional part of <code>x</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3983 Its second result is always a float. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3984 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3985 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3986 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3987 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3988 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3989 <hr><h3><a name="pdf-math.pi"><code>math.pi</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3990 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3991 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3992 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3993 The value of <em>π</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3994 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3995 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3996 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3997 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3998 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
3999 <hr><h3><a name="pdf-math.rad"><code>math.rad (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4000 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4001 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4002 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4003 Converts the angle <code>x</code> from degrees to radians. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4004 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4005 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4006 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4007 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4008 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4009 <hr><h3><a name="pdf-math.random"><code>math.random ([m [, n]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4010 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4011 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4012 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4013 When called without arguments, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4014 returns a pseudo-random float with uniform distribution |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4015 in the range <em>[0,1)</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4016 When called with two integers <code>m</code> and <code>n</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4017 <code>math.random</code> returns a pseudo-random integer |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4018 with uniform distribution in the range <em>[m, n]</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4019 (The value <em>m-n</em> cannot be negative and must fit in a Lua integer.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4020 The call <code>math.random(n)</code> is equivalent to <code>math.random(1,n)</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4021 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4022 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4023 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4024 This function is an interface to the underling |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4025 pseudo-random generator function provided by C. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4026 No guarantees can be given for its statistical properties. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4027 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4028 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4029 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4030 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4031 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4032 <hr><h3><a name="pdf-math.randomseed"><code>math.randomseed (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4033 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4034 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4035 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4036 Sets <code>x</code> as the "seed" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4037 for the pseudo-random generator: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4038 equal seeds produce equal sequences of numbers. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4039 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4040 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4041 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4042 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4043 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4044 <hr><h3><a name="pdf-math.sin"><code>math.sin (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4045 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4046 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4047 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4048 Returns the sine of <code>x</code> (assumed to be in radians). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4049 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4050 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4051 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4052 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4053 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4054 <hr><h3><a name="pdf-math.sqrt"><code>math.sqrt (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4055 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4056 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4057 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4058 Returns the square root of <code>x</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4059 (You can also use the expression <code>x^0.5</code> to compute this value.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4060 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4061 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4062 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4063 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4064 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4065 <hr><h3><a name="pdf-math.tan"><code>math.tan (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4066 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4067 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4068 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4069 Returns the tangent of <code>x</code> (assumed to be in radians). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4070 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4071 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4072 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4073 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4074 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4075 <hr><h3><a name="pdf-math.tointeger"><code>math.tointeger (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4076 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4077 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4078 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4079 If the value <code>x</code> is convertible to an integer, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4080 returns that integer. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4081 Otherwise, returns <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4082 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4083 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4084 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4085 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4086 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4087 <hr><h3><a name="pdf-math.type"><code>math.type (x)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4088 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4089 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4090 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4091 Returns "<code>integer</code>" if <code>x</code> is an integer, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4092 "<code>float</code>" if it is a float, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4093 or <b>nil</b> if <code>x</code> is not a number. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4094 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4095 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4096 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4097 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4098 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4099 <hr><h3><a name="pdf-math.ult"><code>math.ult (m, n)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4100 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4101 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4102 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4103 Returns a boolean, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4104 true if integer <code>m</code> is below integer <code>n</code> when |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4105 they are compared as unsigned integers. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4106 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4107 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4108 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4109 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4110 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4111 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4112 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4113 <h2>6.8 – <a name="6.8">Input and Output Facilities</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4114 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4115 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4116 The I/O library provides two different styles for file manipulation. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4117 The first one uses implicit file handles; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4118 that is, there are operations to set a default input file and a |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4119 default output file, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4120 and all input/output operations are over these default files. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4121 The second style uses explicit file handles. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4122 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4123 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4124 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4125 When using implicit file handles, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4126 all operations are supplied by table <a name="pdf-io"><code>io</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4127 When using explicit file handles, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4128 the operation <a href="#pdf-io.open"><code>io.open</code></a> returns a file handle |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4129 and then all operations are supplied as methods of the file handle. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4130 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4131 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4132 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4133 The table <code>io</code> also provides |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4134 three predefined file handles with their usual meanings from C: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4135 <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>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4136 The I/O library never closes these files. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4137 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4138 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4139 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4140 Unless otherwise stated, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4141 all I/O functions return <b>nil</b> on failure |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4142 (plus an error message as a second result and |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4143 a system-dependent error code as a third result) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4144 and some value different from <b>nil</b> on success. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4145 On non-POSIX systems, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4146 the computation of the error message and error code |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4147 in case of errors |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4148 may be not thread safe, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4149 because they rely on the global C variable <code>errno</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4150 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4151 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4152 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4153 <hr><h3><a name="pdf-io.close"><code>io.close ([file])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4154 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4155 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4156 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4157 Equivalent to <code>file:close()</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4158 Without a <code>file</code>, closes the default output file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4159 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4160 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4161 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4162 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4163 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4164 <hr><h3><a name="pdf-io.flush"><code>io.flush ()</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4165 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4166 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4167 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4168 Equivalent to <code>io.output():flush()</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4169 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4170 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4171 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4172 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4173 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4174 <hr><h3><a name="pdf-io.input"><code>io.input ([file])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4175 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4176 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4177 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4178 When called with a file name, it opens the named file (in text mode), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4179 and sets its handle as the default input file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4180 When called with a file handle, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4181 it simply sets this file handle as the default input file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4182 When called without parameters, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4183 it returns the current default input file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4184 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4185 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4186 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4187 In case of errors this function raises the error, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4188 instead of returning an error code. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4189 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4190 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4191 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4192 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4193 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4194 <hr><h3><a name="pdf-io.lines"><code>io.lines ([filename ···])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4195 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4196 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4197 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4198 Opens the given file name in read mode |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4199 and returns an iterator function that |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4200 works like <code>file:lines(···)</code> over the opened file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4201 When the iterator function detects the end of file, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4202 it returns no values (to finish the loop) and automatically closes the file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4203 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4204 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4205 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4206 The call <code>io.lines()</code> (with no file name) is equivalent |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4207 to <code>io.input():lines("*l")</code>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4208 that is, it iterates over the lines of the default input file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4209 In this case it does not close the file when the loop ends. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4210 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4211 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4212 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4213 In case of errors this function raises the error, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4214 instead of returning an error code. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4215 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4216 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4217 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4218 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4219 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4220 <hr><h3><a name="pdf-io.open"><code>io.open (filename [, mode])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4221 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4222 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4223 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4224 This function opens a file, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4225 in the mode specified in the string <code>mode</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4226 It returns a new file handle, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4227 or, in case of errors, <b>nil</b> plus an error message. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4228 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4229 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4230 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4231 The <code>mode</code> string can be any of the following: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4232 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4233 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4234 <li><b>"<code>r</code>": </b> read mode (the default);</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4235 <li><b>"<code>w</code>": </b> write mode;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4236 <li><b>"<code>a</code>": </b> append mode;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4237 <li><b>"<code>r+</code>": </b> update mode, all previous data is preserved;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4238 <li><b>"<code>w+</code>": </b> update mode, all previous data is erased;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4239 <li><b>"<code>a+</code>": </b> append update mode, previous data is preserved, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4240 writing is only allowed at the end of file.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4241 </ul><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4242 The <code>mode</code> string can also have a '<code>b</code>' at the end, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4243 which is needed in some systems to open the file in binary mode. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4244 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4245 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4246 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4247 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4248 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4249 <hr><h3><a name="pdf-io.output"><code>io.output ([file])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4250 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4251 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4252 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4253 Similar to <a href="#pdf-io.input"><code>io.input</code></a>, but operates over the default output file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4254 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4255 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4256 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4257 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4258 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4259 <hr><h3><a name="pdf-io.popen"><code>io.popen (prog [, mode])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4260 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4261 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4262 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4263 This function is system dependent and is not available |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4264 on all platforms. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4265 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4266 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4267 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4268 Starts program <code>prog</code> in a separated process and returns |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4269 a file handle that you can use to read data from this program |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4270 (if <code>mode</code> is <code>"r"</code>, the default) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4271 or to write data to this program |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4272 (if <code>mode</code> is <code>"w"</code>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4273 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4274 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4275 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4276 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4277 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4278 <hr><h3><a name="pdf-io.read"><code>io.read (···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4279 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4280 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4281 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4282 Equivalent to <code>io.input():read(···)</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4283 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4284 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4285 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4286 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4287 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4288 <hr><h3><a name="pdf-io.tmpfile"><code>io.tmpfile ()</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4289 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4290 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4291 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4292 Returns a handle for a temporary file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4293 This file is opened in update mode |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4294 and it is automatically removed when the program ends. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4295 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4296 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4297 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4298 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4299 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4300 <hr><h3><a name="pdf-io.type"><code>io.type (obj)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4301 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4302 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4303 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4304 Checks whether <code>obj</code> is a valid file handle. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4305 Returns the string <code>"file"</code> if <code>obj</code> is an open file handle, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4306 <code>"closed file"</code> if <code>obj</code> is a closed file handle, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4307 or <b>nil</b> if <code>obj</code> is not a file handle. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4308 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4309 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4310 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4311 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4312 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4313 <hr><h3><a name="pdf-io.write"><code>io.write (···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4314 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4315 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4316 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4317 Equivalent to <code>io.output():write(···)</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4318 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4319 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4320 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4321 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4322 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4323 <hr><h3><a name="pdf-file:close"><code>file:close ()</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4324 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4325 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4326 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4327 Closes <code>file</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4328 Note that files are automatically closed when |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4329 their handles are garbage collected, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4330 but that takes an unpredictable amount of time to happen. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4331 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4332 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4333 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4334 When closing a file handle created with <a href="#pdf-io.popen"><code>io.popen</code></a>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4335 <a href="#pdf-file:close"><code>file:close</code></a> returns the same values |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4336 returned by <a href="#pdf-os.execute"><code>os.execute</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4337 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4338 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4339 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4340 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4341 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4342 <hr><h3><a name="pdf-file:flush"><code>file:flush ()</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4343 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4344 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4345 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4346 Saves any written data to <code>file</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4347 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4348 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4349 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4350 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4351 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4352 <hr><h3><a name="pdf-file:lines"><code>file:lines (···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4353 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4354 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4355 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4356 Returns an iterator function that, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4357 each time it is called, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4358 reads the file according to the given formats. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4359 When no format is given, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4360 uses "<code>l</code>" as a default. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4361 As an example, the construction |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4362 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4363 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4364 for c in file:lines(1) do <em>body</em> end |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4365 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4366 will iterate over all characters of the file, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4367 starting at the current position. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4368 Unlike <a href="#pdf-io.lines"><code>io.lines</code></a>, this function does not close the file |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4369 when the loop ends. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4370 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4371 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4372 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4373 In case of errors this function raises the error, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4374 instead of returning an error code. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4375 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4376 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4377 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4378 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4379 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4380 <hr><h3><a name="pdf-file:read"><code>file:read (···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4381 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4382 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4383 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4384 Reads the file <code>file</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4385 according to the given formats, which specify what to read. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4386 For each format, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4387 the function returns a string or a number with the characters read, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4388 or <b>nil</b> if it cannot read data with the specified format. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4389 (In this latter case, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4390 the function does not read subsequent formats.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4391 When called without formats, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4392 it uses a default format that reads the next line |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4393 (see below). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4394 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4395 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4396 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4397 The available formats are |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4398 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4399 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4400 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4401 <li><b>"<code>n</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4402 reads a numeral and returns it as a float or an integer, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4403 following the lexical conventions of Lua. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4404 (The numeral may have leading spaces and a sign.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4405 This format always reads the longest input sequence that |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4406 is a valid prefix for a number; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4407 if that prefix does not form a valid number |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4408 (e.g., an empty string, "<code>0x</code>", or "<code>3.4e-</code>"), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4409 it is discarded and the function returns <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4410 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4411 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4412 <li><b>"<code>i</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4413 reads an integral number and returns it as an integer. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4414 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4415 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4416 <li><b>"<code>a</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4417 reads the whole file, starting at the current position. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4418 On end of file, it returns the empty string. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4419 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4420 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4421 <li><b>"<code>l</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4422 reads the next line skipping the end of line, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4423 returning <b>nil</b> on end of file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4424 This is the default format. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4425 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4426 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4427 <li><b>"<code>L</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4428 reads the next line keeping the end-of-line character (if present), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4429 returning <b>nil</b> on end of file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4430 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4431 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4432 <li><b><em>number</em>: </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4433 reads a string with up to this number of bytes, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4434 returning <b>nil</b> on end of file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4435 If <code>number</code> is zero, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4436 it reads nothing and returns an empty string, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4437 or <b>nil</b> on end of file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4438 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4439 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4440 </ul><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4441 The formats "<code>l</code>" and "<code>L</code>" should be used only for text files. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4442 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4443 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4444 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4445 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4446 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4447 <hr><h3><a name="pdf-file:seek"><code>file:seek ([whence [, offset]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4448 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4449 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4450 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4451 Sets and gets the file position, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4452 measured from the beginning of the file, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4453 to the position given by <code>offset</code> plus a base |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4454 specified by the string <code>whence</code>, as follows: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4455 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4456 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4457 <li><b>"<code>set</code>": </b> base is position 0 (beginning of the file);</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4458 <li><b>"<code>cur</code>": </b> base is current position;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4459 <li><b>"<code>end</code>": </b> base is end of file;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4460 </ul><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4461 In case of success, <code>seek</code> returns the final file position, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4462 measured in bytes from the beginning of the file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4463 If <code>seek</code> fails, it returns <b>nil</b>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4464 plus a string describing the error. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4465 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4466 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4467 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4468 The default value for <code>whence</code> is <code>"cur"</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4469 and for <code>offset</code> is 0. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4470 Therefore, the call <code>file:seek()</code> returns the current |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4471 file position, without changing it; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4472 the call <code>file:seek("set")</code> sets the position to the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4473 beginning of the file (and returns 0); |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4474 and the call <code>file:seek("end")</code> sets the position to the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4475 end of the file, and returns its size. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4476 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4477 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4478 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4479 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4480 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4481 <hr><h3><a name="pdf-file:setvbuf"><code>file:setvbuf (mode [, size])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4482 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4483 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4484 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4485 Sets the buffering mode for an output file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4486 There are three available modes: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4487 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4488 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4489 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4490 <li><b>"<code>no</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4491 no buffering; the result of any output operation appears immediately. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4492 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4493 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4494 <li><b>"<code>full</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4495 full buffering; output operation is performed only |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4496 when the buffer is full or when |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4497 you explicitly <code>flush</code> the file (see <a href="#pdf-io.flush"><code>io.flush</code></a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4498 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4499 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4500 <li><b>"<code>line</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4501 line buffering; output is buffered until a newline is output |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4502 or there is any input from some special files |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4503 (such as a terminal device). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4504 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4505 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4506 </ul><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4507 For the last two cases, <code>size</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4508 specifies the size of the buffer, in bytes. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4509 The default is an appropriate size. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4510 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4511 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4512 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4513 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4514 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4515 <hr><h3><a name="pdf-file:write"><code>file:write (···)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4516 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4517 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4518 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4519 Writes the value of each of its arguments to <code>file</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4520 The arguments must be strings or numbers. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4521 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4522 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4523 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4524 In case of success, this function returns <code>file</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4525 Otherwise it returns <b>nil</b> plus a string describing the error. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4526 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4527 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4528 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4529 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4530 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4531 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4532 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4533 <h2>6.9 – <a name="6.9">Operating System Facilities</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4534 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4535 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4536 This library is implemented through table <a name="pdf-os"><code>os</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4537 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4538 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4539 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4540 <hr><h3><a name="pdf-os.clock"><code>os.clock ()</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4541 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4542 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4543 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4544 Returns an approximation of the amount in seconds of CPU time |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4545 used by the program. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4546 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4547 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4548 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4549 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4550 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4551 <hr><h3><a name="pdf-os.date"><code>os.date ([format [, time]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4552 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4553 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4554 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4555 Returns a string or a table containing date and time, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4556 formatted according to the given string <code>format</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4557 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4558 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4559 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4560 If the <code>time</code> argument is present, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4561 this is the time to be formatted |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4562 (see the <a href="#pdf-os.time"><code>os.time</code></a> function for a description of this value). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4563 Otherwise, <code>date</code> formats the current time. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4564 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4565 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4566 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4567 If <code>format</code> starts with '<code>!</code>', |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4568 then the date is formatted in Coordinated Universal Time. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4569 After this optional character, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4570 if <code>format</code> is the string "<code>*t</code>", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4571 then <code>date</code> returns a table with the following fields: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4572 <code>year</code> (four digits), <code>month</code> (1–12), <code>day</code> (1–31), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4573 <code>hour</code> (0–23), <code>min</code> (0–59), <code>sec</code> (0–61), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4574 <code>wday</code> (weekday, Sunday is 1), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4575 <code>yday</code> (day of the year), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4576 and <code>isdst</code> (daylight saving flag, a boolean). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4577 This last field may be absent |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4578 if the information is not available. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4579 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4580 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4581 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4582 If <code>format</code> is not "<code>*t</code>", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4583 then <code>date</code> returns the date as a string, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4584 formatted according to the same rules as the ISO C function <code>strftime</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4585 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4586 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4587 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4588 When called without arguments, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4589 <code>date</code> returns a reasonable date and time representation that depends on |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4590 the host system and on the current locale |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4591 (that is, <code>os.date()</code> is equivalent to <code>os.date("%c")</code>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4592 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4593 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4594 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4595 On non-POSIX systems, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4596 this function may be not thread safe |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4597 because of its reliance on C function <code>gmtime</code> and C function <code>localtime</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4598 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4599 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4600 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4601 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4602 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4603 <hr><h3><a name="pdf-os.difftime"><code>os.difftime (t2, t1)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4604 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4605 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4606 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4607 Returns the difference, in seconds, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4608 from time <code>t1</code> to time <code>t2</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4609 (where the times are values returned by <a href="#pdf-os.time"><code>os.time</code></a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4610 In POSIX, Windows, and some other systems, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4611 this value is exactly <code>t2</code><em>-</em><code>t1</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4612 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4613 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4614 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4615 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4616 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4617 <hr><h3><a name="pdf-os.execute"><code>os.execute ([command])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4618 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4619 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4620 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4621 This function is equivalent to the ISO C function <code>system</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4622 It passes <code>command</code> to be executed by an operating system shell. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4623 Its first result is <b>true</b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4624 if the command terminated successfully, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4625 or <b>nil</b> otherwise. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4626 After this first result |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4627 the function returns a string plus a number, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4628 as follows: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4629 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4630 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4631 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4632 <li><b>"<code>exit</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4633 the command terminated normally; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4634 the following number is the exit status of the command. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4635 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4636 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4637 <li><b>"<code>signal</code>": </b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4638 the command was terminated by a signal; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4639 the following number is the signal that terminated the command. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4640 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4641 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4642 </ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4643 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4644 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4645 When called without a <code>command</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4646 <code>os.execute</code> returns a boolean that is true if a shell is available. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4647 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4648 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4649 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4650 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4651 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4652 <hr><h3><a name="pdf-os.exit"><code>os.exit ([code [, close]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4653 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4654 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4655 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4656 Calls the ISO C function <code>exit</code> to terminate the host program. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4657 If <code>code</code> is <b>true</b>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4658 the returned status is <code>EXIT_SUCCESS</code>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4659 if <code>code</code> is <b>false</b>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4660 the returned status is <code>EXIT_FAILURE</code>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4661 if <code>code</code> is a number, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4662 the returned status is this number. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4663 The default value for <code>code</code> is <b>true</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4664 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4665 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4666 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4667 If the optional second argument <code>close</code> is true, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4668 closes the Lua state before exiting. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4669 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4670 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4671 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4672 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4673 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4674 <hr><h3><a name="pdf-os.getenv"><code>os.getenv (varname)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4675 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4676 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4677 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4678 Returns the value of the process environment variable <code>varname</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4679 or <b>nil</b> if the variable is not defined. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4680 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4681 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4682 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4683 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4684 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4685 <hr><h3><a name="pdf-os.remove"><code>os.remove (filename)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4686 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4687 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4688 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4689 Deletes the file (or empty directory, on POSIX systems) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4690 with the given name. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4691 If this function fails, it returns <b>nil</b>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4692 plus a string describing the error and the error code. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4693 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4694 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4695 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4696 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4697 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4698 <hr><h3><a name="pdf-os.rename"><code>os.rename (oldname, newname)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4699 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4700 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4701 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4702 Renames file or directory named <code>oldname</code> to <code>newname</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4703 If this function fails, it returns <b>nil</b>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4704 plus a string describing the error and the error code. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4705 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4706 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4707 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4708 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4709 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4710 <hr><h3><a name="pdf-os.setlocale"><code>os.setlocale (locale [, category])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4711 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4712 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4713 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4714 Sets the current locale of the program. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4715 <code>locale</code> is a system-dependent string specifying a locale; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4716 <code>category</code> is an optional string describing which category to change: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4717 <code>"all"</code>, <code>"collate"</code>, <code>"ctype"</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4718 <code>"monetary"</code>, <code>"numeric"</code>, or <code>"time"</code>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4719 the default category is <code>"all"</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4720 The function returns the name of the new locale, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4721 or <b>nil</b> if the request cannot be honored. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4722 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4723 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4724 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4725 If <code>locale</code> is the empty string, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4726 the current locale is set to an implementation-defined native locale. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4727 If <code>locale</code> is the string "<code>C</code>", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4728 the current locale is set to the standard C locale. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4729 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4730 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4731 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4732 When called with <b>nil</b> as the first argument, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4733 this function only returns the name of the current locale |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4734 for the given category. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4735 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4736 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4737 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4738 This function may be not thread safe |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4739 because of its reliance on C function <code>setlocale</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4740 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4741 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4742 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4743 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4744 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4745 <hr><h3><a name="pdf-os.time"><code>os.time ([table])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4746 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4747 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4748 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4749 Returns the current time when called without arguments, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4750 or a time representing the date and time specified by the given table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4751 This table must have fields <code>year</code>, <code>month</code>, and <code>day</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4752 and may have fields |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4753 <code>hour</code> (default is 12), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4754 <code>min</code> (default is 0), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4755 <code>sec</code> (default is 0), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4756 and <code>isdst</code> (default is <b>nil</b>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4757 For a description of these fields, see the <a href="#pdf-os.date"><code>os.date</code></a> function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4758 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4759 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4760 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4761 The returned value is a number, whose meaning depends on your system. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4762 In POSIX, Windows, and some other systems, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4763 this number counts the number |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4764 of seconds since some given start time (the "epoch"). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4765 In other systems, the meaning is not specified, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4766 and the number returned by <code>time</code> can be used only as an argument to |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4767 <a href="#pdf-os.date"><code>os.date</code></a> and <a href="#pdf-os.difftime"><code>os.difftime</code></a>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4768 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4769 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4770 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4771 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4772 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4773 <hr><h3><a name="pdf-os.tmpname"><code>os.tmpname ()</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4774 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4775 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4776 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4777 Returns a string with a file name that can |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4778 be used for a temporary file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4779 The file must be explicitly opened before its use |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4780 and explicitly removed when no longer needed. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4781 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4782 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4783 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4784 On POSIX systems, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4785 this function also creates a file with that name, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4786 to avoid security risks. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4787 (Someone else might create the file with wrong permissions |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4788 in the time between getting the name and creating the file.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4789 You still have to open the file to use it |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4790 and to remove it (even if you do not use it). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4791 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4792 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4793 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4794 When possible, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4795 you may prefer to use <a href="#pdf-io.tmpfile"><code>io.tmpfile</code></a>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4796 which automatically removes the file when the program ends. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4797 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4798 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4799 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4800 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4801 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4802 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4803 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4804 <h2>6.10 – <a name="6.10">The Debug Library</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4805 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4806 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4807 This library provides |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4808 the functionality of the debug interface (<a href="#4.9">§4.9</a>) to Lua programs. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4809 You should exert care when using this library. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4810 Several of its functions |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4811 violate basic assumptions about Lua code |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4812 (e.g., that variables local to a function |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4813 cannot be accessed from outside; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4814 that userdata metatables cannot be changed by Lua code; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4815 that Lua programs do not crash) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4816 and therefore can compromise otherwise secure code. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4817 Moreover, some functions in this library may be slow. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4818 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4819 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4820 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4821 All functions in this library are provided |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4822 inside the <a name="pdf-debug"><code>debug</code></a> table. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4823 All functions that operate over a thread |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4824 have an optional first argument which is the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4825 thread to operate over. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4826 The default is always the current thread. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4827 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4828 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4829 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4830 <hr><h3><a name="pdf-debug.debug"><code>debug.debug ()</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4831 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4832 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4833 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4834 Enters an interactive mode with the user, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4835 running each string that the user enters. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4836 Using simple commands and other debug facilities, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4837 the user can inspect global and local variables, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4838 change their values, evaluate expressions, and so on. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4839 A line containing only the word <code>cont</code> finishes this function, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4840 so that the caller continues its execution. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4841 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4842 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4843 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4844 Note that commands for <code>debug.debug</code> are not lexically nested |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4845 within any function and so have no direct access to local variables. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4846 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4847 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4848 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4849 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4850 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4851 <hr><h3><a name="pdf-debug.gethook"><code>debug.gethook ([thread])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4852 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4853 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4854 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4855 Returns the current hook settings of the thread, as three values: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4856 the current hook function, the current hook mask, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4857 and the current hook count |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4858 (as set by the <a href="#pdf-debug.sethook"><code>debug.sethook</code></a> function). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4859 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4860 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4861 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4862 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4863 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4864 <hr><h3><a name="pdf-debug.getinfo"><code>debug.getinfo ([thread,] f [, what])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4865 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4866 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4867 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4868 Returns a table with information about a function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4869 You can give the function directly |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4870 or you can give a number as the value of <code>f</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4871 which means the function running at level <code>f</code> of the call stack |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4872 of the given thread: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4873 level 0 is the current function (<code>getinfo</code> itself); |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4874 level 1 is the function that called <code>getinfo</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4875 (except for tail calls, which do not count on the stack); |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4876 and so on. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4877 If <code>f</code> is a number larger than the number of active functions, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4878 then <code>getinfo</code> returns <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4879 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4880 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4881 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4882 The returned table can contain all the fields returned by <a href="#lua_getinfo"><code>lua_getinfo</code></a>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4883 with the string <code>what</code> describing which fields to fill in. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4884 The default for <code>what</code> is to get all information available, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4885 except the table of valid lines. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4886 If present, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4887 the option '<code>f</code>' |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4888 adds a field named <code>func</code> with the function itself. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4889 If present, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4890 the option '<code>L</code>' |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4891 adds a field named <code>activelines</code> with the table of |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4892 valid lines. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4893 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4894 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4895 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4896 For instance, the expression <code>debug.getinfo(1,"n").name</code> returns |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4897 a table with a name for the current function, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4898 if a reasonable name can be found, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4899 and the expression <code>debug.getinfo(print)</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4900 returns a table with all available information |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4901 about the <a href="#pdf-print"><code>print</code></a> function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4902 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4903 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4904 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4905 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4906 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4907 <hr><h3><a name="pdf-debug.getlocal"><code>debug.getlocal ([thread,] f, local)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4908 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4909 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4910 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4911 This function returns the name and the value of the local variable |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4912 with index <code>local</code> of the function at level <code>f</code> of the stack. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4913 This function accesses not only explicit local variables, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4914 but also parameters, temporaries, etc. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4915 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4916 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4917 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4918 The first parameter or local variable has index 1, and so on, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4919 following the order that they are declared in the code, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4920 counting only the variables that are active |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4921 in the current scope of the function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4922 Negative indices refer to vararg parameters; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4923 -1 is the first vararg parameter. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4924 The function returns <b>nil</b> if there is no variable with the given index, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4925 and raises an error when called with a level out of range. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4926 (You can call <a href="#pdf-debug.getinfo"><code>debug.getinfo</code></a> to check whether the level is valid.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4927 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4928 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4929 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4930 Variable names starting with '<code>(</code>' (open parenthesis) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4931 represent variables with no known names |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4932 (internal variables such as loop control variables, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4933 and variables from chunks saved without debug information). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4934 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4935 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4936 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4937 The parameter <code>f</code> may also be a function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4938 In that case, <code>getlocal</code> returns only the name of function parameters. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4939 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4940 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4941 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4942 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4943 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4944 <hr><h3><a name="pdf-debug.getmetatable"><code>debug.getmetatable (value)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4945 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4946 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4947 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4948 Returns the metatable of the given <code>value</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4949 or <b>nil</b> if it does not have a metatable. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4950 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4951 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4952 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4953 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4954 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4955 <hr><h3><a name="pdf-debug.getregistry"><code>debug.getregistry ()</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4956 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4957 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4958 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4959 Returns the registry table (see <a href="#4.5">§4.5</a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4960 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4961 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4962 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4963 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4964 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4965 <hr><h3><a name="pdf-debug.getupvalue"><code>debug.getupvalue (f, up)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4966 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4967 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4968 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4969 This function returns the name and the value of the upvalue |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4970 with index <code>up</code> of the function <code>f</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4971 The function returns <b>nil</b> if there is no upvalue with the given index. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4972 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4973 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4974 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4975 Variable names starting with '<code>(</code>' (open parenthesis) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4976 represent variables with no known names |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4977 (variables from chunks saved without debug information). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4978 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4979 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4980 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4981 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4982 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4983 <hr><h3><a name="pdf-debug.getuservalue"><code>debug.getuservalue (u)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4984 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4985 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4986 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4987 Returns the Lua value associated to <code>u</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4988 If <code>u</code> is not a userdata, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4989 returns <b>nil</b>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4990 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4991 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4992 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4993 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4994 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4995 <hr><h3><a name="pdf-debug.sethook"><code>debug.sethook ([thread,] hook, mask [, count])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4996 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4997 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4998 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
4999 Sets the given function as a hook. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5000 The string <code>mask</code> and the number <code>count</code> describe |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5001 when the hook will be called. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5002 The string mask may have any combination of the following characters, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5003 with the given meaning: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5004 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5005 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5006 <li><b>'<code>c</code>': </b> the hook is called every time Lua calls a function;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5007 <li><b>'<code>r</code>': </b> the hook is called every time Lua returns from a function;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5008 <li><b>'<code>l</code>': </b> the hook is called every time Lua enters a new line of code.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5009 </ul><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5010 Moreover, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5011 with a <code>count</code> different from zero, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5012 the hook is called also after every <code>count</code> instructions. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5013 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5014 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5015 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5016 When called without arguments, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5017 <a href="#pdf-debug.sethook"><code>debug.sethook</code></a> turns off the hook. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5018 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5019 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5020 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5021 When the hook is called, its first parameter is a string |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5022 describing the event that has triggered its call: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5023 <code>"call"</code> (or <code>"tail call"</code>), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5024 <code>"return"</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5025 <code>"line"</code>, and <code>"count"</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5026 For line events, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5027 the hook also gets the new line number as its second parameter. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5028 Inside a hook, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5029 you can call <code>getinfo</code> with level 2 to get more information about |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5030 the running function |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5031 (level 0 is the <code>getinfo</code> function, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5032 and level 1 is the hook function). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5033 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5034 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5035 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5036 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5037 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5038 <hr><h3><a name="pdf-debug.setlocal"><code>debug.setlocal ([thread,] level, local, value)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5039 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5040 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5041 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5042 This function assigns the value <code>value</code> to the local variable |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5043 with index <code>local</code> of the function at level <code>level</code> of the stack. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5044 The function returns <b>nil</b> if there is no local |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5045 variable with the given index, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5046 and raises an error when called with a <code>level</code> out of range. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5047 (You can call <code>getinfo</code> to check whether the level is valid.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5048 Otherwise, it returns the name of the local variable. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5049 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5050 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5051 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5052 See <a href="#pdf-debug.getlocal"><code>debug.getlocal</code></a> for more information about |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5053 variable indices and names. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5054 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5055 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5056 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5057 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5058 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5059 <hr><h3><a name="pdf-debug.setmetatable"><code>debug.setmetatable (value, table)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5060 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5061 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5062 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5063 Sets the metatable for the given <code>value</code> to the given <code>table</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5064 (which can be <b>nil</b>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5065 Returns <code>value</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5066 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5067 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5068 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5069 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5070 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5071 <hr><h3><a name="pdf-debug.setupvalue"><code>debug.setupvalue (f, up, value)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5072 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5073 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5074 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5075 This function assigns the value <code>value</code> to the upvalue |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5076 with index <code>up</code> of the function <code>f</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5077 The function returns <b>nil</b> if there is no upvalue |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5078 with the given index. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5079 Otherwise, it returns the name of the upvalue. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5080 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5081 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5082 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5083 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5084 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5085 <hr><h3><a name="pdf-debug.setuservalue"><code>debug.setuservalue (udata, value)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5086 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5087 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5088 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5089 Sets the given <code>value</code> as |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5090 the Lua value associated to the given <code>udata</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5091 <code>udata</code> must be a full userdata. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5092 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5093 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5094 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5095 Returns <code>udata</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5096 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5097 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5098 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5099 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5100 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5101 <hr><h3><a name="pdf-debug.traceback"><code>debug.traceback ([thread,] [message [, level]])</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5102 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5103 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5104 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5105 If <code>message</code> is present but is neither a string nor <b>nil</b>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5106 this function returns <code>message</code> without further processing. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5107 Otherwise, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5108 it returns a string with a traceback of the call stack. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5109 The optional <code>message</code> string is appended |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5110 at the beginning of the traceback. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5111 An optional <code>level</code> number tells at which level |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5112 to start the traceback |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5113 (default is 1, the function calling <code>traceback</code>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5114 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5115 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5116 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5117 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5118 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5119 <hr><h3><a name="pdf-debug.upvalueid"><code>debug.upvalueid (f, n)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5120 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5121 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5122 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5123 Returns a unique identifier (as a light userdata) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5124 for the upvalue numbered <code>n</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5125 from the given function. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5126 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5127 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5128 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5129 These unique identifiers allow a program to check whether different |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5130 closures share upvalues. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5131 Lua closures that share an upvalue |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5132 (that is, that access a same external local variable) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5133 will return identical ids for those upvalue indices. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5134 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5135 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5136 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5137 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5138 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5139 <hr><h3><a name="pdf-debug.upvaluejoin"><code>debug.upvaluejoin (f1, n1, f2, n2)</code></a></h3> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5140 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5141 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5142 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5143 Make the <code>n1</code>-th upvalue of the Lua closure <code>f1</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5144 refer to the <code>n2</code>-th upvalue of the Lua closure <code>f2</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5145 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5146 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5147 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5148 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5149 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5150 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5151 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5152 <h1>7 – <a name="7">Lua Standalone</a></h1> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5153 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5154 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5155 Although Lua has been designed as an extension language, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5156 to be embedded in a host C program, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5157 it is also frequently used as a standalone language. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5158 An interpreter for Lua as a standalone language, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5159 called simply <code>lua</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5160 is provided with the standard distribution. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5161 The standalone interpreter includes |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5162 all standard libraries, including the debug library. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5163 Its usage is: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5164 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5165 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5166 lua [options] [script [args]] |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5167 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5168 The options are: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5169 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5170 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5171 <li><b><code>-e <em>stat</em></code>: </b> executes string <em>stat</em>;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5172 <li><b><code>-l <em>mod</em></code>: </b> "requires" <em>mod</em>;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5173 <li><b><code>-i</code>: </b> enters interactive mode after running <em>script</em>;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5174 <li><b><code>-v</code>: </b> prints version information;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5175 <li><b><code>-E</code>: </b> ignores environment variables;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5176 <li><b><code>--</code>: </b> stops handling options;</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5177 <li><b><code>-</code>: </b> executes <code>stdin</code> as a file and stops handling options.</li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5178 </ul><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5179 After handling its options, <code>lua</code> runs the given <em>script</em>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5180 When called without arguments, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5181 <code>lua</code> behaves as <code>lua -v -i</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5182 when the standard input (<code>stdin</code>) is a terminal, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5183 and as <code>lua -</code> otherwise. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5184 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5185 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5186 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5187 When called without option <code>-E</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5188 the interpreter checks for an environment variable <a name="pdf-LUA_INIT_5_3"><code>LUA_INIT_5_3</code></a> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5189 (or <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a> if the versioned name is not defined) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5190 before running any argument. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5191 If the variable content has the format <code>@<em>filename</em></code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5192 then <code>lua</code> executes the file. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5193 Otherwise, <code>lua</code> executes the string itself. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5194 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5195 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5196 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5197 When called with option <code>-E</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5198 besides ignoring <code>LUA_INIT</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5199 Lua also ignores |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5200 the values of <code>LUA_PATH</code> and <code>LUA_CPATH</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5201 setting the values of |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5202 <a href="#pdf-package.path"><code>package.path</code></a> and <a href="#pdf-package.cpath"><code>package.cpath</code></a> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5203 with the default paths defined in <code>luaconf.h</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5204 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5205 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5206 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5207 All options are handled in order, except <code>-i</code> and <code>-E</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5208 For instance, an invocation like |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5209 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5210 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5211 $ lua -e'a=1' -e 'print(a)' script.lua |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5212 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5213 will first set <code>a</code> to 1, then print the value of <code>a</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5214 and finally run the file <code>script.lua</code> with no arguments. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5215 (Here <code>$</code> is the shell prompt. Your prompt may be different.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5216 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5217 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5218 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5219 Before running any code, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5220 <code>lua</code> collects all command-line arguments |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5221 in a global table called <code>arg</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5222 The script name goes to index 0, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5223 the first argument after the script name goes to index 1, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5224 and so on. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5225 Any arguments before the script name |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5226 (that is, the interpreter name plus its options) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5227 go to negative indices. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5228 For instance, in the call |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5229 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5230 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5231 $ lua -la b.lua t1 t2 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5232 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5233 the table is like this: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5234 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5235 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5236 arg = { [-2] = "lua", [-1] = "-la", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5237 [0] = "b.lua", |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5238 [1] = "t1", [2] = "t2" } |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5239 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5240 If there is no script in the call, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5241 the interpreter name goes to index 0, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5242 followed by the other arguments. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5243 For instance, the call |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5244 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5245 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5246 $ lua -e "print(arg[1])" |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5247 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5248 will print "<code>-e</code>". |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5249 If there is a script, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5250 the script is called with parameters |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5251 <code>arg[1]</code>, ···, <code>arg[#arg]</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5252 (Like all chunks in Lua, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5253 the script is compiled as a vararg function.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5254 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5255 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5256 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5257 In interactive mode, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5258 Lua repeatedly prompts and waits for a line. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5259 After reading a line, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5260 Lua first try to interpret the line as an expression. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5261 If it succeeds, it prints its value. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5262 Otherwise, it interprets the line as a statement. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5263 If you write an incomplete statement, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5264 the interpreter waits for its completion |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5265 by issuing a different prompt. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5266 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5267 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5268 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5269 In case of unprotected errors in the script, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5270 the interpreter reports the error to the standard error stream. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5271 If the error object is not a string but |
|
429
e3a6d9dbd694
rename __tostring to __to_string
Franklin Schmidt <fschmidt@gmail.com>
parents:
428
diff
changeset
|
5272 has a metamethod <code>__to_string</code>, |
|
371
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5273 the interpreter calls this metamethod to produce the final message. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5274 Otherwise, the interpreter converts the error object to a string |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5275 and adds a stack traceback to it. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5276 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5277 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5278 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5279 When finishing normally, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5280 the interpreter closes its main Lua state |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5281 (see <a href="#lua_close"><code>lua_close</code></a>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5282 The script can avoid this step by |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5283 calling <a href="#pdf-os.exit"><code>os.exit</code></a> to terminate. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5284 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5285 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5286 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5287 To allow the use of Lua as a |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5288 script interpreter in Unix systems, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5289 the standalone interpreter skips |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5290 the first line of a chunk if it starts with <code>#</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5291 Therefore, Lua scripts can be made into executable programs |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5292 by using <code>chmod +x</code> and the <code>#!</code> form, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5293 as in |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5294 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5295 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5296 #!/usr/local/bin/lua |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5297 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5298 (Of course, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5299 the location of the Lua interpreter may be different in your machine. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5300 If <code>lua</code> is in your <code>PATH</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5301 then |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5302 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5303 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5304 #!/usr/bin/env lua |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5305 </pre><p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5306 is a more portable solution.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5307 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5308 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5309 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5310 <h1>8 – <a name="8">Incompatibilities with the Previous Version</a></h1> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5311 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5312 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5313 Here we list the incompatibilities that you may find when moving a program |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5314 from Lua 5.2 to Lua 5.3. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5315 You can avoid some incompatibilities by compiling Lua with |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5316 appropriate options (see file <code>luaconf.h</code>). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5317 However, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5318 all these compatibility options will be removed in the future. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5319 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5320 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5321 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5322 Lua versions can always change the C API in ways that |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5323 do not imply source-code changes in a program, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5324 such as the numeric values for constants |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5325 or the implementation of functions as macros. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5326 Therefore, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5327 you should not assume that binaries are compatible between |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5328 different Lua versions. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5329 Always recompile clients of the Lua API when |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5330 using a new version. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5331 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5332 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5333 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5334 Similarly, Lua versions can always change the internal representation |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5335 of precompiled chunks; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5336 precompiled chunks are not compatible between different Lua versions. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5337 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5338 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5339 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5340 The standard paths in the official distribution may |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5341 change between versions. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5342 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5343 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5344 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5345 <h2>8.1 – <a name="8.1">Changes in the Language</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5346 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5347 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5348 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5349 The main difference between Lua 5.2 and Lua 5.3 is the |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5350 introduction of an integer subtype for numbers. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5351 Although this change should not affect "normal" computations, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5352 some computations |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5353 (mainly those that involve some kind of overflow) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5354 can give different results. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5355 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5356 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5357 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5358 You can fix these differences by forcing a number to be a float |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5359 (in Lua 5.2 all numbers were float), |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5360 in particular writing constants with an ending <code>.0</code> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5361 or using <code>x = x + 0.0</code> to convert a variable. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5362 (This recommendation is only for a quick fix |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5363 for an occasional incompatibility; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5364 it is not a general guideline for good programming. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5365 For good programming, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5366 use floats where you need floats |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5367 and integers where you need integers.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5368 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5369 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5370 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5371 The conversion of a float to a string now adds a <code>.0</code> suffix |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5372 to the result if it looks like an integer. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5373 (For instance, the float 2.0 will be printed as <code>2.0</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5374 not as <code>2</code>.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5375 You should always use an explicit format |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5376 when you need a specific format for numbers. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5377 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5378 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5379 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5380 (Formally this is not an incompatibility, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5381 because Lua does not specify how numbers are formatted as strings, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5382 but some programs assumed a specific format.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5383 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5384 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5385 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5386 The generational mode for the garbage collector was removed. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5387 (It was an experimental feature in Lua 5.2.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5388 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5389 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5390 </ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5391 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5392 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5393 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5394 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5395 <h2>8.2 – <a name="8.2">Changes in the Libraries</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5396 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5397 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5398 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5399 The <code>bit32</code> library has been deprecated. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5400 It is easy to require a compatible external library or, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5401 better yet, to replace its functions with appropriate bitwise operations. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5402 (Keep in mind that <code>bit32</code> operates on 32-bit integers, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5403 while the bitwise operators in standard Lua operate on 64-bit integers.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5404 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5405 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5406 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5407 The Table library now respects metamethods |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5408 for setting and getting elements. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5409 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5410 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5411 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5412 The <a href="#pdf-ipairs"><code>ipairs</code></a> iterator now respects metamethods and |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5413 its <code>__ipairs</code> metamethod has been deprecated. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5414 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5415 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5416 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5417 Option names in <a href="#pdf-io.read"><code>io.read</code></a> do not have a starting '<code>*</code>' anymore. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5418 For compatibility, Lua will continue to ignore this character. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5419 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5420 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5421 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5422 The following functions were deprecated in the mathematical library: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5423 <code>atan2</code>, <code>cosh</code>, <code>sinh</code>, <code>tanh</code>, <code>pow</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5424 <code>frexp</code>, and <code>ldexp</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5425 You can replace <code>math.pow(x,y)</code> with <code>x^y</code>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5426 you can replace <code>math.atan2</code> with <code>math.atan</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5427 which now accepts one or two parameters; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5428 you can replace <code>math.ldexp(x,exp)</code> with <code>x * 2.0^exp</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5429 For the other operations, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5430 you can either use an external library or |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5431 implement them in Lua. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5432 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5433 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5434 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5435 The searcher for C loaders used by <a href="#pdf-require"><code>require</code></a> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5436 changed the way it handles versioned names. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5437 Now, the version should come after the module name |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5438 (as is usual in most other tools). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5439 For compatibility, that searcher still tries the old format |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5440 if it cannot find an open function according to the new style. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5441 (Lua 5.2 already worked that way, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5442 but it did not document the change.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5443 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5444 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5445 </ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5446 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5447 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5448 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5449 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5450 <h2>8.3 – <a name="8.3">Changes in the API</a></h2> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5451 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5452 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5453 <ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5454 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5455 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5456 Continuation functions now receive as parameters what they needed |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5457 to get through <code>lua_getctx</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5458 so <code>lua_getctx</code> has been removed. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5459 Adapt your code accordingly. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5460 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5461 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5462 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5463 Function <a href="#lua_dump"><code>lua_dump</code></a> has an extra parameter, <code>strip</code>. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5464 Use 0 as the value of this parameter to get the old behavior. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5465 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5466 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5467 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5468 Functions to inject/project unsigned integers |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5469 (<code>lua_pushunsigned</code>, <code>lua_tounsigned</code>, <code>lua_tounsignedx</code>, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5470 <code>luaL_checkunsigned</code>, <code>luaL_optunsigned</code>) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5471 were deprecated. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5472 Use their signed equivalents with a type cast. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5473 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5474 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5475 <li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5476 Macros to project non-default integer types |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5477 (<code>luaL_checkint</code>, <code>luaL_optint</code>, <code>luaL_checklong</code>, <code>luaL_optlong</code>) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5478 were deprecated. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5479 Use their equivalent over <a href="#lua_Integer"><code>lua_Integer</code></a> with a type cast |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5480 (or, when possible, use <a href="#lua_Integer"><code>lua_Integer</code></a> in your code). |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5481 </li> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5482 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5483 </ul> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5484 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5485 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5486 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5487 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5488 <h1>9 – <a name="9">The Complete Syntax of Lua</a></h1> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5489 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5490 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5491 Here is the complete syntax of Lua in extended BNF. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5492 As usual in extended BNF, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5493 {A} means 0 or more As, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5494 and [A] means an optional A. |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5495 (For operator precedences, see <a href="#3.4.8">§3.4.8</a>; |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5496 for a description of the terminals |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5497 Name, Numeral, |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5498 and LiteralString, see <a href="#3.1">§3.1</a>.) |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5499 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5500 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5501 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5502 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5503 <pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5504 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5505 chunk ::= block |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5506 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5507 block ::= {stat} [retstat] |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5508 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5509 stat ::= ‘<b>;</b>’ | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5510 varlist ‘<b>=</b>’ explist | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5511 functioncall | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5512 label | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5513 <b>break</b> | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5514 <b>goto</b> Name | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5515 <b>do</b> block <b>end</b> | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5516 <b>while</b> exp <b>do</b> block <b>end</b> | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5517 <b>repeat</b> block <b>until</b> exp | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5518 <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b> | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5519 <b>for</b> Name ‘<b>=</b>’ exp ‘<b>,</b>’ exp [‘<b>,</b>’ exp] <b>do</b> block <b>end</b> | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5520 <b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b> | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5521 <b>function</b> funcname funcbody | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5522 <b>local</b> <b>function</b> Name funcbody | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5523 <b>local</b> namelist [‘<b>=</b>’ explist] |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5524 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5525 retstat ::= <b>return</b> [explist] [‘<b>;</b>’] |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5526 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5527 label ::= ‘<b>::</b>’ Name ‘<b>::</b>’ |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5528 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5529 funcname ::= Name {‘<b>.</b>’ Name} [‘<b>:</b>’ Name] |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5530 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5531 varlist ::= var {‘<b>,</b>’ var} |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5532 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5533 var ::= Name | prefixexp ‘<b>[</b>’ exp ‘<b>]</b>’ | prefixexp ‘<b>.</b>’ Name |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5534 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5535 namelist ::= Name {‘<b>,</b>’ Name} |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5536 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5537 explist ::= exp {‘<b>,</b>’ exp} |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5538 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5539 exp ::= <b>nil</b> | <b>false</b> | <b>true</b> | Numeral | LiteralString | ‘<b>...</b>’ | functiondef | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5540 prefixexp | tableconstructor | exp binop exp | unop exp |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5541 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5542 prefixexp ::= var | functioncall | ‘<b>(</b>’ exp ‘<b>)</b>’ |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5543 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5544 functioncall ::= prefixexp args | prefixexp ‘<b>:</b>’ Name args |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5545 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5546 args ::= ‘<b>(</b>’ [explist] ‘<b>)</b>’ | tableconstructor | LiteralString |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5547 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5548 functiondef ::= <b>function</b> funcbody |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5549 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5550 funcbody ::= ‘<b>(</b>’ [parlist] ‘<b>)</b>’ block <b>end</b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5551 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5552 parlist ::= namelist [‘<b>,</b>’ ‘<b>...</b>’] | ‘<b>...</b>’ |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5553 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5554 tableconstructor ::= ‘<b>{</b>’ [fieldlist] ‘<b>}</b>’ |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5555 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5556 fieldlist ::= field {fieldsep field} [fieldsep] |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5557 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5558 field ::= ‘<b>[</b>’ exp ‘<b>]</b>’ ‘<b>=</b>’ exp | Name ‘<b>=</b>’ exp | exp |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5559 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5560 fieldsep ::= ‘<b>,</b>’ | ‘<b>;</b>’ |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5561 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5562 binop ::= ‘<b>+</b>’ | ‘<b>-</b>’ | ‘<b>*</b>’ | ‘<b>/</b>’ | ‘<b>//</b>’ | ‘<b>^</b>’ | ‘<b>%</b>’ | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5563 ‘<b>&</b>’ | ‘<b>~</b>’ | ‘<b>|</b>’ | ‘<b>>></b>’ | ‘<b><<</b>’ | ‘<b>..</b>’ | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5564 ‘<b><</b>’ | ‘<b><=</b>’ | ‘<b>></b>’ | ‘<b>>=</b>’ | ‘<b>==</b>’ | ‘<b>~=</b>’ | |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5565 <b>and</b> | <b>or</b> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5566 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5567 unop ::= ‘<b>-</b>’ | <b>not</b> | ‘<b>#</b>’ | ‘<b>~</b>’ |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5568 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5569 </pre> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5570 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5571 <p> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5572 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5573 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5574 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5575 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5576 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5577 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5578 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5579 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5580 <HR> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5581 <SMALL CLASS="footer"> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5582 Last update: |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5583 Fri Jan 16 00:58:20 BRST 2015 |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5584 </SMALL> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5585 <!-- |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5586 Last change: minor edit |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5587 --> |
|
e01cddba3433
add manual.html as copy of Lua 5.3 Reference Manual
Franklin Schmidt <fschmidt@gmail.com>
parents:
diff
changeset
|
5588 |
| 372 | 5589 </div> |
|
386
db23f654f87d
make all of website use luan
Franklin Schmidt <fschmidt@gmail.com>
parents:
382
diff
changeset
|
5590 |
|
391
2f5cc9c2cbf0
replace Html.simply_html_page with simply_html_head and simply_html_body_bottom
Franklin Schmidt <fschmidt@gmail.com>
parents:
389
diff
changeset
|
5591 <% Html.simply_html_body_bottom() %> |
|
2f5cc9c2cbf0
replace Html.simply_html_page with simply_html_head and simply_html_body_bottom
Franklin Schmidt <fschmidt@gmail.com>
parents:
389
diff
changeset
|
5592 </body> |
|
2f5cc9c2cbf0
replace Html.simply_html_page with simply_html_head and simply_html_body_bottom
Franklin Schmidt <fschmidt@gmail.com>
parents:
389
diff
changeset
|
5593 </html> |
|
2f5cc9c2cbf0
replace Html.simply_html_page with simply_html_head and simply_html_body_bottom
Franklin Schmidt <fschmidt@gmail.com>
parents:
389
diff
changeset
|
5594 <% |
|
386
db23f654f87d
make all of website use luan
Franklin Schmidt <fschmidt@gmail.com>
parents:
382
diff
changeset
|
5595 end |