LUA插件制作小常识 相关搜索: 学习, 制作, 游戏, 教程, LUA

1 – 介绍
2 Y( f# f+ A1 H0 u& o6 u6 w4 h8 i5 f6 E# X% v9 D/ i
/ g+ E$ L* P3 [) W/ A
Lua 是一个扩展式程序设计语言，它被设计成支持通用的过程式编程，并有相关数据描述的设施。 Lua 也能对面向对象编程，函数式编程，数据驱动式编程提供很好的支持。它可以作为一个强大、轻量的脚本语言，供任何需要的程序使用。 Lua 以一个用 clean C 写成的库形式提供。（所谓 Clean C ，指的 ANSI C 和 C++ 中共通的一个子集）
. s1 K9 y2 U3 I9 L, m) U( B4 b1 h6 B

% z8 }- Q’ J0 N6 u* v6 t作为一个扩展式语言，Lua 没有 "main" 程序的概念：它只能 嵌入 一个宿主程序中工作，这个宿主程序被称作 embedding program+ ]; n7 F’ K* P* u! p8 p! J” k* l

‘ @* }$ |0 B/ K( M9 O% q. W7 i或简称为 host
7 h% _  W6 S” Z6 X: b* F
: P4 D8 u. l/ H. H* w- h。宿主程序可以通过调用函数执行一小段 Lua 代码，可以读写 Lua 变量，可以注入 C 函数让 Lua 代码调用。这些扩展的 C 函数，可以大大的扩展了 Lua 可以处理事务的领域，这样就可以订制出各种语言，而它们共享一个统一的句法格式的框架。 Lua 的官方发布版就包含了一个叫做 lua 的简单的宿主程序，它用 Lua 库提供了一个保证独立的 Lua 解释器。 3 M- p  N. H: x
0 f% U. q& X. b9 j. H: y

$ i: s0 G” N” }% H+ CLua 是一个自由软件，它的使用许可决定了对它的使用过程一般没有任何保证。这份手册中描述的东西的实现，可以在 Lua 的官方网站 www.lua.org 找到， 7 }% o. ]) @& i! m! s

5 S8 U# ( K; I3 @) p” i( K( s: ^- a: ?: u3 U# _7 g) ?4 x
跟其它的许多参考手册一样，这份文档有些地方比较枯燥。关于 Lua 的设计想法的探讨，可以看看 Lua 网站上提供的技术论文。有关用 Lua 编程的细节介绍，可以读一下 Roberto 的书，Programming in Lua (Second Edition)
# p. u; w8 a0 T( o. c/ r2 g- x8 `# b$ H
2 – 语言
( T; `” m% l6 o2 t这一节从词法、语法、句法上描述 Lua 。换句话说，这一节描述了哪些 token （符记）是有效的，它们如何被组合起来，这些组合方式有什么含义。
# @( ?0 s! }9 X关于语言的构成概念将用常见的扩展 BNF 表达式写出。也就是这个样子： {a} 意思是 0 或多个 a ， [a] 意思是一个可选的 a 。非最终的符号会保留原来的样子，关键字则看起来像这样 kword ，其它最终的符号则写成 `=′ 。完整的 Lua 语法可以在本手册最后找到。
! ~” l: D# s2 p0 a( K+ y, I2.1 – 词法约定9 E” ?  L0 n( M  z0 Y
Lua 中用到的 名字（也称作 标识符）可以是任何非数字开头的字母、数字、下划线组成的字符串。这符合几乎所有编程语言中关于名字的定义。（字母的定义依赖于当前环境：系统环境中定义的字母表中的字母都可以被用于标识符。）标识符用来命名变量，或作为表的域名。
) a7 [- }2 ~$ U# y  _3 @下面的关键字是保留的，不能用作名字： & d4 T’ {( N2 O; A; R’ h- ?
     and       break     do        else      elseif# q# D; g” e7 q; r
     end       false     for       function  if– f9 Y+ |6 M& M6 V* o
     in        local     nil       not       or  `$ ~2 z: h9 z( K2 g
     repeat    return    then      true      until     while% ]* @5 x0 [; A9 n7 `4 K
Lua 是一个大小写敏感的语言： and 是一个保留字，但是 And 和 AND 则是两个不同的合法的名字。一般约定，以下划线开头连接一串大写字母的名字（比如 _VERSION）被保留用于 Lua 内部全局变量。
% x) ]0 # D0 E” i下面这些是其它的 token ：
) n: I4 u# L/ h     +     –     *     /     %     ^     #9 `+ N5 o2 2 `, |- S- N5 I! {
     ==    ~=    <=    >=    <     >     =1 c% b2 Q& u- v2 S6 X! Q
     (     )     {     }     [     ]# S$ u% i8 g: r7 u+ s
     ;     :     ,     .     ..    …
& f& h- b) j( E5 p$ n字符串既可以用一对单引号引起，也可以是双引号，里面还可以包含类似 C 的转义符： ‘a’ （响铃）， ‘b’ （退格）， ‘f’ （表单）， ‘n’ （换行）， ‘r’ （回车）， ‘t’ （横向制表）， ‘v’ （纵向制表）， ‘\’ （反斜杠）， ‘"’ （双引号），以及 ”’ （单引号)。而且，如果在一个反斜杠后跟了一个真正的换行符，其结果就是在字符串中产生一个换行符。我们还可以用反斜杠加数字的形式 ddd 来描述一个字符。这里， ddd 是一串最多三位的十进制数字。（注意，如果需要在这种描述方法后接一个是数字的字符，那么反斜杠后必须写满三个数字。）Lua 中的字符串可以包含任何 8 位的值。包括用 ‘’ 表示的零。
9 G# v” i- ?+ g” ?只有在你需要把不同的引号、换行、反斜杠、或是零结束符这些字符置入字符串时，你才必须使用转义符。别的任何字符都可以直接写在文本里。（一些控制符可以会影响文件系统造成某些问题，但是不会引起 Lua 的任何问题。） 4 Y) j6 k5 V  x%
字符串还可以用一种长括号括起来的方式定义。我们把两个正的方括号间插入 n 个等号定义为第 n 级正长括号。就是说，0 级正的长括号写作 [[ ，一级正的长括号写作 [=[ ，如此等等。反的长扩展也作类似定义；举个例子，4 级反的长括号写作 ]====] 。一个长字符串可以由任何一级的正的长括号开始，而由第一个碰到的同级反的长括号结束。整个词法分析过程将不受分行限制，不处理任何转意符，并且忽略掉任何不同级别的长括号。这种方式描述的字符串可以包含任何东西，当然特定级别的反长括号除外。
3 I1 e6 @’ t/ L5 d& o; C. g+ d另一个约定是，当正的长括号后面立即跟了一个换行符，这个换行符就不包含在这个字符串内。举个例子，假设一个系统使用 ASCII 码（这时，’a’ 编码为 97 ，换行符编码为 10 ，’1′ 编码为 49 ），下面五种方式描述了完全相同的字符串： 1 Q% Q  b2 ?, n( _. i* r/ _; ^
     a = ‘alon123"’
7 e) _4 k8 U4 S1 q; X1 G     a = "alon123""
  P! ?- i% v! T+ X2 T     a = ’97lo104923"’1 l% `0 w# [. a. r
     a = [[alo6 V’ T! i- U8 K5 B; t
     123"]]3 ]” m- h4 K* Q0 w: Z7 y
     a = [==[
+ ~5 g1 i/ ^5 z, L     alo
‘ Y8 V0 X5 p7 ^, Y. f. u4 `     123"]==]$ G+ R% _4 B0 b7 y, p7 Z7 X6 K
数字常量可以分两部分写，十进制底数部分和十进制的指数部分。指数部分是可选的。 Lua 也支持十六进制整数常量，只需要在前面加上前缀 0x 。下面是一些合法的数字常量的例子： # X; B7 I* {0 l’ z4 T
     3   3.0   3.1416   314.16e-2   0.31416E1   0xff   0x56
% K- Y! Z- D6 U$ j9 W. e3 g注释可以在除字符串内的任何地方是以两横 (–) 开始。如果跟在两横后面的不是一个长括号，这就是一个短注释，它的作用范围直到行末；否则就是一个长注释，其作用范围直到遇到反的长括号。长注释通常被用来临时屏蔽代码块。 – q% z’ `+ ]# – i6 o5 ^8 z
2.2 – 值与类型
, z’ a7 F  P6 h, @+ q. l4 dLua 是一种 动态类型语言。这意味着变量没有类型，只有值才有类型。语言中不存在类型定义。而所有的值本身携带它们自己的类型信息。
4 g- _% b. g/ D; f7 eLua 中的所有值都是一致 (first-class) 的。这意味着所有的值都可以被放在变量里，当作参数传递到另一个函数中，并被函数作为结果manbet网页登录。
6 k1 L0 X” [* g$ ?. sLua 中有八种基本类型： nil, boolean, number, string, function, userdata, thread, and table. Nil 类型只有一种值 nil ，它的主要用途用于标表识和别的任何值的差异；通常，当需要描述一个无意义的值时会用到它。 Boolean 类型只有两种值：false 和 true。 nil 和 false 都能导致条件为假；而另外所有的值都被当作真。 Number 表示实数（双精度浮点数）。（编译一个其它内部数字类型的 Lua 解释器是件很容易的事；比如把内部数字类型改作单精度浮点数或长整型。参见文件 luaconf.h 。） String 表示一串字符的数组。 Lua 是 8-bit clean 的：字符串可以包含任何 8 位字符，包括零结束符 (‘’) （参见 §2.1）。 4 |! s7 X” }9 ?. w
Lua 可以调用（和处理）用 Lua 写的函数以及用 C 写的函数（参见 §2.5.8）. / y. u6 ?9 B% ^& n
userdata 类型用来将任意 C 数据保存在 Lua 变量中。这个类型相当于一块原生的内存，除了赋值和相同性判断，Lua 没有为之预定义任何操作。然而，通过使用 metatable （元表） ，程序员可以为 userdata 自定义一组操作（参见 §2.8）。 userdata 不能在 Lua 中创建出来，也不能在 Lua 中修改。这样的操作只能通过 C API。这一点保证了宿主程序完全掌管其中的数据。
( y1 l- Q0 M, E’ wthread 类型用来区别独立的执行线程，它被用来实现 coroutine （协同例程）（参见 §2.11）。不要把 Lua 线程跟操作系统的线程搞混。 Lua 可以在所有的系统上提供对 coroutine 的支持，即使系统并不支持线程。 – `! V- X2 B# P. I9 _/ b2 b* R2 i
table 类型实现了一个关联数组。也就是说，数组可以用任何东西（除了nil）做索引，而不限于数字。 table 可以以不同类型的值构成；它可以包含所有的类型的值（除 nil 外）。 table 是 lua 中唯一的一种数据结构；它可以用来描述原始的数组、符号表、集合、记录、图、树、等等。用于表述记录时，lua 使用域名作为索引。语言本身采用一种语法糖，支持以 a.name 的形式表示 a["name"]。有很多形式用于在 lua 中创建一个 table （参见 §2.5.7）。
, L  K1 g( V4 A1 Z. Z跟索引一样， table 每个域中的值也可以是任何类型（除 nil外）。特别的，因为函数本身也是值，所以 table 的域中也可以放函数。这样 table 中就可以有一些 methods 了 （参见see §2.5.9）。
2 P1 f+ G- ]6 m) J0 rtable， function ，thread ，和 (full) userdata 这些类型的值是所谓的对象：变量本身并不会真正的存放它们的值，而只是放了一个对对象的引用。赋值，参数传递，函数manbet网页登录，都是对这些对象的引用进行操作；这些操作不会做暗地里做任何性质的拷贝。 9 n+ w7 g” V4 ~
库函数 type 可以manbet网页登录一个描述给定值的类型的字符串。
5 h, e/ P. N’ j  E$ x  w5 _2.2.1 – 强制转换
0 F( Z) z1 b% XLua 提供运行时字符串到数字的自动转换。任何对字符串的数学运算操作都会尝试用一般的转换规则把这个字符串转换成一个数字。相反，无论何时，一个数字需要作为字符串来使用时，数字都会以合理的格式转换为字符串。需要完全控制数字怎样转换为字符串，可以使用字符串库中的 format 函数（参见 string.format）。 ” Z: p/ O4 ~” L8 l4 x
2.3 – 变量” [4 }& ^& a7 G( b
写上变量的地方意味着当以其保存的值来替代之。 Lua 中有三类变量：全局变量，局部变量，还有 table 的域。
& `1 n2 $ M0 S, ?% ]. O一个单一的名字可以表示一个全局变量，也可以表示一个局部变量 （或者是一个函数的参数，这是一种特殊形式的局部变量）：
7 B  P$ X. P7 r- Z3 f( Q        var ::= Name5 i# ~1 U# M  k0 {5 ~
Name 就是 §2.1 中所定义的标识符。
1 G5 k” D& n5 I% D: {3 G, L任何变量都被假定为全局变量，除非显式的以 local 修饰定义 （参见 §2.4.7）。局部变量有其作用范围：局部变量可以被定义在它作用范围中的函数自由使用（参见 §2.6）。
‘ w, [8 I” Q1 b# e3 R1 t在变量的首次赋值之前，变量的值均为 nil。
; p” v# S8 _3 K1 X$ f) n4 U方括号被用来对 table 作索引：
# R/ }) Z’ A( 2 N- d        var ::= prefixexp `[′ exp `]′( y* H’ l0 U5 n% X* u1 D+ h
对全局变量以及 table 域之访问的含义可以通过 metatable 来改变。以取一个变量下标指向的量 t 等价于调用 gettable_event(t,i)。（参见 §2.8 ，有一份完整的关于 gettable_event 函数的说明。这个函数并没有在 lua 中定义出来，也不能在 lua 中调用。这里我们把它列出来只是方便说明。） ‘ [( K6 p% ?+ ]! b$ s8 _/ @
var.Name 这种语法只是一个语法糖，用来表示 var["Name"]： ( ~3 l0 V5 S5 y5 A: N
        var ::= prefixexp `.′ Name
8 W7 B0 A% `” G2 R9 c  M所有的全局变量都是放在一个特定 lua table 的诸个域中，这个特定的 table 叫作 environment （环境）table 或者简称为 环境 （参见 §2.9）。每个函数都有对一个环境的引用，所以一个函数中可见的所有全局变量都放在这个函数所引用的环境表（environment table）中。当一个函数被创建出来，它会从创建它的函数中继承其环境，你可以调用 getfenv 取得其环境。如果想改变环境，可以调用 setfenv。（对于 C 函数，你只能通过 debug 库来改变其环境；参见 §5.9）。
& p# q” z! m% n1 J  a( B” h对一个全局变量 x 的访问等价于 _env.x，而这又可以等价于 5 G$ u! v! o8 s
     gettable_event(_env, "x")
9 Q; T. a’ V1 E. T这里，_env 是当前运行的函数的环境。（函数 gettable_event 的完整说明参见 §2.8。这个函数并没有在 lua 中定义出来，也不能调用。当然，_env 这个变量也同样没有在 Lua 中定义出来。我们在这里使用它们，仅仅只是方便解释而已。） % S4 p: C: O$ f- L2 j
2.4 – 语句段（Statement）
” q: c; h+ R’ q+ [( dLua 支持惯例形式的语句段，它和 Pascal 或是 C 很相象。这个集合包括赋值，控制结构，函数调用，还有变量声明。 1 |( A. P( W. R
2.4.1 – Chunk（语句组）1 b7 W/ _  y- [
Lua 的一个执行单元被称作 chunk。一个 chunk 就是一串语句段，它们会被循序的执行。每个语句段可以以一个分号结束： ! V7 p, g( q4 O0 J
        chunk ::= {stat [`;′]}
. g- t$ a9 ?( J# O: n这儿不允许有空的语句段，所以 ‘;;’ 是非法的。 9 V8 a% H! _% F6 d) f” [
lua 把一个 chunk 当作一个拥有不定参数的匿名函数（参见 §2.5.9）处理。正是这样，chunk 内可以定义局部变量，接收参数，并且manbet网页登录值。 : ]5 s5 P, D+ U
chunk 可以被保存在一个文件中，也可以保存在宿主程序的一个字符串中。当一个 chunk 被执行，首先它会被预编译成虚拟机中的指令序列，然后被虚拟机解释运行这些指令。
* ^$ F; S; c1 x’ [4 [1 vchunk 也可以被预编译成二进制形式；细节参考程序 luac。用源码形式提供的程序和被编译过的二进制形式的程序是可以相互替换的； Lua 会自动识别文件类型并做正确的处理。
# i% g$ T* L/ f5 M  `/ V2.4.2 – 语句块
/ O/ ]- F. {4 w: |, m8 T语句块是一列语句段；从语法上来说，一个语句块跟一个 chunk 相同：
. W6 {# L, O/ e; X) B        block ::= chunk$ r9 O% 1 q! v4 N$
一个语句块可以被显式的写成一个单独的语句段：
# n% M. J/ c8 D/ k’ I& U        stat ::= do block end& k9 M/ A& Z% O0 h+ C
显式的语句块对于控制变量的作用范围很有用。有时候，显式的语句块被用来在另一个语句块中插入 return 或是 break （参见 §2.4.4）。 2 D6 x4 ?7 k3 W
2.4.3 – 赋值( U# {, ^) V3 e6 G’ r; }-
Lua 允许多重赋值。因此，赋值的语法定义是等号左边放一系列变量，而等号右边放一系列的表达式。两边的元素都用逗号间开： 2 {$ P7 a! E* ! M8 y2 V
        stat ::= varlist1 `=′ explist1
: Z# L3 L5 l/ n# Q# _: L- s, |        varlist1 ::= var {`,′ var}
% a# b; I. F4 {7 ]        explist1 ::= exp {`,′ exp}‘ t+ q- ]  W/ h
表达式放在 §2.5 里讨论。
: X. w’ I9 V5 P% O  u6 x在作赋值操作之前，那一系列的右值会被对齐到左边变量需要的个数。如果右值比需要的更多的话，多余的值就被扔掉。如果右值的数量不够需求，将会按所需扩展若干个 nil。如果表达式列表以一个函数调用结束，这个函数所manbet网页登录的所有值都会在对齐操作之前被置入右值序列中。（除非这个函数调用被用括号括了起来；参见 §2.5）。 – G* e% h’ y, t) q; w( V  m2 [
赋值段首先会做运算完所有的表达式，然后仅仅做赋值操作。因此，下面这段代码 $ Q8 m0 G” h2 G# y1 [8 H) e  J
     i = 3
4 S8 B6 c4 }’ X# Q     i, a = i+1, 20
) Q” u5 F1 Y8 U0 R( @( l会把 a[3] 设置为 20，而不会影响到 a[4] 。这是因为 a 中的 i 在被赋值为 4 之前就被拿出来了（那时是 3 ）。简单说 ，这样一行
‘ l0 X- `2 H  h3 g. v+ H3 S     x, y = y, x
3 A0 r8 F$ ~9 Z0 T! L$ g$ @- s可以用来交换 x 和 y 中的值。
8 R0 ]# t, I  g对全局变量以及 table 中的域的赋值操作的含义可以通过 metatable 来改变。对变量下标指向的赋值，即 t = val 等价于 settable_event(t,i,val)。（关于函数 settable_event 的详细说明，参见 §2.8。这个函数并没有在 Lua 中定义出来，也不可以被调用。这里我们列出来，仅仅出于方便解释的目的） % D& u( O# f7 I
对于全局变量的赋值 x = val 等价于 _env.x = val，这个又可以等价于
% j, ( D, f% Y- g. O     settable_event(_env, "x", val)” y; a$ D’ X$ B/ x) `
这里，_env 指的是正在运行中的函数的环境。（变量 _env 并没有在 Lua 中定义出来。我们仅仅出于解释的目的在这里写出来。） – }( S+ Z+ X8 C! E
2.4.4 – 控制结构
5 t” A6 A2 S, s- Lif、 while、以及 repeat 这些控制结构符合通常的意义，而且也有类似的语法： – N. T4 j/ Q& m9 a+ w
        stat ::= while exp do block end
  a9 l0 G’ ~3 h        stat ::= repeat block until exp” V* E  c  u. b8 s, @8 S+ _
        stat ::= if exp then block {elseif exp then block} [else block] end
! T. L3 P+ s1 S/ ?8 e7 YLua 也有一个 for 语句，它有两种形式（参见 §2.4.5）。 + g! W) M1 S) H$ M6 Y! p+ z1 E5 q  g
控制结构中的条件表达式可以manbet网页登录任何值。 false 和 nil 两者都被认为是假条件。所有不同于 nil 和 false 的其它值都被认为是真（特别需要注意的是，数字 0 和空字符串也被认为是真）。
: X  [) B/ x’ e! |* s$ }  x0 Z! K在 repeat–until 循环中，内部语句块的结束点不是在 until 这个关键字处，它还包括了其后的条件表达式。因此，条件表达式中可以使用循环内部语句块中的定义的局部变量。 0 B* i0 E$ |) p7 X* e/ ^+ U
return 被用于从函数或是 chunk（其实它就是一个函数）中manbet网页登录值。 函数和 chunk 可以manbet网页登录不只一个值，所以 return 的语法为
7 c1 c7 A5 A; a- h# X& Z9 `        stat ::= return [explist1]. n  * e/ f) G9 g! Y
break 被用来结束 while、 repeat、或 for 循环，它将忽略掉循环中下面的语句段的运行： 0 e& F& d( u7 m) [
        stat ::= break
8 ! `# x! N  n; S& Qbreak 跳出最内层的循环。 ; q4 S( s+ c3 h’ y1 U
return 和 break 只能被写在一个语句块的最后一句。如果你真的需要从语句块的中间 return 或是 break ，你可以使用显式的声名一个内部语句块。一般写作 do return end 或是 do break end，可以这样写是因为现在 return 或 break 都成了一个语句块的最后一句了。 0 L1 t” _; l% t
2.4.5 – For 语句
$ l- Y/ F8 H$ [5 _* A8 ^for 有两种形式：一种是数字形式，另一种是一般形式。 0 i7 M/ ?: q# A6 R+ j  M: [
数字形式的 for 循环，通过一个数学运算不断的运行内部的代码块。下面是它的语法：
9 o$ N9 F# P’ p9 ]$ k+ @, j5 x1 d        stat ::= for Name `=′ exp `,′ exp [`,′ exp] do block end
6 L4 s8 Q) k4 u’ A: a1 S2 K# ublock 将把 name 作循环变量。从第一个 exp 开始起，直到第二个 exp 的值为止，其步长为第三个 exp 。更确切的说，一个 for 循环看起来是这个样子
. U1 Y( ]* |  p     for v = e1, e2, e3 do block end
8 X1 n: m1 c$ X这等价于代码： 6 b1 u! {/ H$ V8 Z# N
     do‘ S# Z’ Q- [* k  x7 j8 S
       local var, limit, step = tonumber(e1), tonumber(e2), tonumber(e3)
# l3 K8 W7 j- E( |5 A5 l6 @       if not (var and limit and step) then error() end8 M8 ?’ `5 |’ f& f0 B
       while (step > 0 and var <= limit) or (step <= 0 and var >= limit) do: U8 V6 L  b6 * z. e% _0 i2 p
         local v = var
/ m: Q. t. J( p& U9 I: B& x’ h         block
; H( O9 V8 b6 f* q1 j, }3 C         var = var + step
. i0 t6 ]8 e& t5 K/ ?       end
+ q- L& x+ h6 W8 l. z3 l; P     end# B” L! c0 z* i5 a
注意下面这几点： # [8 Z& ]: P6 K; G% ; _
?        所有三个控制表达式都只被运算一次，表达式的计算在循环开始之前。这些表达式的结果必须是数字。
: x+ j8 ?; l’ P/ {- `& C# [+ e?        var 、limit 、以及 step 都是一些不可见的变量。这里给它们起的名字都仅仅用于解释方便。
. j” @) ^” F$ E?        如果第三个表达式（步长）没有给出，会把步长设为 1 。
6 p. o8 M5 m3 ^” p- f?        你可以用 break 来退出 for 循环。 * m1 ^/ _! K5 k& ?* K( H8 y+ B9 I
?        循环变量 v 是一个循环内部的局部变量；当 for 循环结束后，你就不能在使用它。如果你需要这个值，在退出循环前把它赋给另一个变量。
6 I’ V$ @7 U) d* I- `$ u8 q一般形式的 for 通过一个叫作叠代器（iterators）的函数工作。每次叠代，叠代器函数都会被调用以产生一个新的值，当这个值为 nil 时，循环停止。一般形式的 for 循环的语法如下：
$ o3 6 G, p! S4 C! c        stat ::= for namelist in explist1 do block end
5 Z5 Z6 K: G2 B” T. w; c9 e        namelist ::= Name {`,′ Name}
/ J) `6 f” s  Tfor 语句好似这样 + r/ R/ x; x9 I& [” J: L
     for var_1, ???, var_n in explist do block end
; 8 Q5 ]” L$ F7 J+ O$ F它等价于这样一段代码：   N6 D2 m+ A/ j; ]9 d9 a
     do( v9 O: d& M9 o$ [7 k
       local f, s, var = explist
4 v” h( F0 ^6 d3 l  z& B- k# ]       while true do/ D) ]3 y0 `9 Y’ J/ o8 Z” K
         local var_1, ???, var_n = f(s, var)5 ?+ K9 Z6 P0 H3 f
         var = var_1$ C( f. m, g/ L’ b/ y’ N* w
         if var == nil then break end) H9 d. v5 Z7 Z* D. r’ K
         block
: L8 |7 G. F3 M7 ?4 R( c4 t       end( H1 b3 K& L3 h+ ! V0 n
     end
+ a% F& / e- l% r” _- F1 c注意以下几点： $ m  e4 I” r” z$ h* w
?        explist 只会被计算一次。它manbet网页登录三个值， 一个叠代器函数，一个状态，一个叠代器的初始值。
2 U4 z6 Q& F’ S( Z) w?        f、 s、 以及 var 都是不可见的变量。这里给它们起的名字都只是为了解说方便。 6 l8 + a! W9 E! ]/ k  f6 T
?        你可以使用 break 来跳出 for 循环。
: f. W0 ; P  }- h?        循环变量 var_i 对于循环来说是一个局部变量；你不可以在 for 循环结束后继续使用。如果你需要保留这些值，那么就在循环结束前赋值到别的变量里去。 3 l9 |) q  n) ]% T1 D; J
2.4.6 – 把函数调用作为语句段
+ f+ Y* r; h; M4 }# a/ F5 i. I为了允许使用可能的副作用，函数调用可以被作为一个语句段执行： / 4 c3 Z: M5 B# [
        stat ::= functioncall2 ?7 H” z6 q8 z, X$ p* c( @1 H” S
在这种情况下，所有的manbet网页登录值都被舍弃。函数调用在 §2.5.8 中解释。
* a1 J7 R* U5 {) M% Z4 g  H2.4.7 – 局部变量声名1 Y’ A: X5 g” N) z4 P; j. J
局部变量可以在语句块中任何地方声名。声名可以包含一个初始化赋值操作： . h” h6 Y6 _” d  ^9 p4 y& Q2 Y
        stat ::= local namelist [`=′ explist1]
‘ K, C; v! m# P/ p& m% [如果有的话，初始化赋值操作的行为等同于赋值操作（参见 §2.4.3）。否则，所有的变量将被初始化为 nil。 # }9 w/ _  G& f4 I  u/ ^5 |( X
一个 chunk 同时也是一个语句块（参见 §2.4.1），所以局部变量可以放在 chunk 中那些显式注明的语句块之外。这些局部变量的作用范围从声明起一直延伸到 chunk 末尾。
– D, U- Z$ B: ^” w局部变量的可见规则在 §2.6 中解释。
) C7 q% y1 h% t2.5 – 表达式; a2 ~! S* b) O8 y7 P
Lua 中有这些基本表达式：
4 D” `& C9 N7 b# f’ N- a/ [1 [7 R        exp ::= prefixexp! f( y- r0 N& K# M. ]# W
        exp ::= nil | false | true& a: H% z, J: q. k8 f
        exp ::= Number0 U6 }; G, |’ A
        exp ::= String/ i. D3 P7 B$ s0 X* J
        exp ::= function; b! U3 t4 4 e
        exp ::= tableconstructor
6 w# D4 J0 z) V  {; }5 H9 ]5 ]        exp ::= `…′
% A) ?) m/ ]% a- V* T7 _1 w        exp ::= exp binop exp– R; V0 c1 ! O! c’ s6 i; T’ g
        exp ::= unop exp# K4 }+ ]- [/ 6 G2 E6 W) y% }
        prefixexp ::= var | functioncall | `(′ exp `)′+ N9 n$ r0 i1 E; z4 D
数字和字符串在 §2.1 中解释；变量在 §2.3 中解释；函数定义在 §2.5.9 中解释；函数调用在 §2.5.8 中解释； table 的构造在 §2.5.7 中解释；可变参数的表达式写作三个点 (‘…’) ，它只能被用在有可变参数的函数中；这些在 §2.5.9 中解释。 ) |) y& H7 L8 g$ l/ n. e/ d  P3 z
二元操作符包含有数学运算操作符（参见 §2.5.1），比较操作符（参见 §2.5.2），逻辑操作符（参见 §2.5.3），以及连接操作符（参见 §2.5.4）。一元操作符包括负号（参见see §2.5.1），取反 not（参见 §2.5.3），和取长度操作符（参见 §2.5.5）。
‘ u( k’ Q) m6 n( Z- T: w0 ^函数调用和可变参数表达式都可以放在多重manbet网页登录值中。如果表达式作为一个独立语句段出现（参见 §2.4.6）（这只能是一个函数调用），它们的manbet网页登录列表将被对齐到零个元素，也就是忽略所有manbet网页登录值。如果表达式用于表达式列表的最后（或者是唯一）的元素，就不会有任何的对齐操作（除非函数调用用括号括起来）。在任何其它的情况下，Lua 将把表达式结果看成单一元素，忽略除第一个之外的任何值。
! F3 L& P+ L/ A# ^/ s这里有一些例子：
3 f’ I: z4 j. f( q9 r! A     f()                — 调整到 0 个结果
8 a” ; T4 u0 H/ J1 |$ r: x     g(f(), x)          — f() 被调整到一个结果! r+ Z2 ]- u! ” h. A
     g(x, f())          — g 被传入 x 加上所有 f() 的manbet网页登录值
: u3 ]  b$ A+ Q, u( l$ ?$ F# k9 u     a,b,c = f(), x     — f() 被调整到一个结果 （ c 在这里被赋为 nil ）& |# f- i) l0 j3 U2 Y
     a,b = …          — a 被赋值为可变参数中的第一个，; ]& {‘ {6 @5 o  q6 k8 C
                        — b 被赋值为第二个 （如果可变参数中并没有对应的值，
5 j: L% l8 `! |                                                — 这里 a 和 b 都有可能被赋为 nil）
6 m; h% a) A( B, A1 z& @# B/ r     7 d. U( y: {9 i) q* R2 K7 X2 c
     a,b,c = x, f()     — f() 被调整为两个结果
7 O. e- ]. l  g  {4 c+ Z     a,b,c = f()        — f() 被调整为三个结果) v” F. _8 g) C) ~$ {6 }
     return f()         — manbet网页登录 f() manbet网页登录的所有结果) d; G9 j7 C& `: R
     return …         — manbet网页登录所有从可变参数中接收来的值% M’ H7 V- S2 e; P& q. Z’ R
     return x,y,f()     — manbet网页登录 x, y, 以及所有 f() 的manbet网页登录值
: U9 M5 d6 d% b% O6 J     {f()}              — 用 f() 的所有manbet网页登录值创建一个列表
” d- |- W3 k, B3 k0 h     {…}              — 用可变参数中的所有值创建一个列表$ x! 2 E& F2 ]$ % ^8 h5 `( e
     {f(), nil}         — f() 被调整为一个结果; Q) e/ R1 [4 b+ X$ j
被括号括起来的表达式永远被当作一个值。所以， (f(x,y,z)) 即使 f manbet网页登录多个值，这个表达式永远是一个单一值。（(f(x,y,z)) 的值是 f manbet网页登录的第一个值。如果 f 不manbet网页登录值的话，那么它的值就是 nil 。） $ Z” X) G) W# H- Z
2.5.1 – 数学运算操作符1 K6 I1 X7 [9 C& m: F
Lua 支持常见的数学运算操作符：二元操作 + （加法）， – （减法），* （乘法）， / （除法）， % （取模），以及 ^ （幂）；和一元操作 – （取负）。如果对数字操作，或是可以转换为数字的字符串（参见 §2.2.1），所有这些操作都依赖它通常的含义。幂操作可以对任何幂值都正常工作。比如， x^(-0.5) 将计算出 x 的平方根。取模操作被定义为 $ ~2 F* O0 h% E; A2 ~
     a % b == a – math.floor(a/b)*b
/ ?3 c( m6 f” V, v0 m0 B这就是说，其结果是商相对负无穷圆整后的余数。（译注：负数对正数取模的结果为正数）
& s* M” V2 Y- ~2.5.2 – 比较操作符
& z. C) P- u& BLua 中的比较操作符有 / W7 @  J, ^/ T3 F5 @” i4 o
     ==    ~=    <     >     <=    >=
7 u7 C4 e” B1 f! T, U这些操作的结果不是 false 就是 true。 3 b8 y, l” h7 n( ^
等于操作 (==) 首先比较操作数的类型。如果类型不同，结果就是 false。否则，继续比较值。数字和字符串都用常规的方式比较。对象 （table ，userdata ，thread ，以及函数）以引用的形式比较：两个对象只有在它们指向同一个东西时才认为相等。每次你创建一个新对象（一个 table 或是 userdata ，thread 函数），它们都各不相同，即不同于上次创建的东西。
2 1 `’ a- v6 z! d+ {9 s% ^你可以改变 Lua 比较 table 和 userdata 的方式，这需要使用 "eq" 这个原方法（参见 §2.8）。
% Q& c$ y* Y3 v& L” v1 Q5 G, E$ ]+ q§2.2.1 中提及的转换规则并不作用于比较操作。所以， "0"==0 等于 false，而且 t[0] 和 t["0"] 描述的是 table 中不同的域。 / Q. h) X5 }, j4 w’ m
操作符 ~= 完全等价于 (==) 操作的反值。
9 u5 P6 i% a4 {1 q4 j4 q$ h大小比较操作以以下方式进行。如果参数都是数字，那么就直接做数字比较。否则，如果参数都是字符串，就用字符串比较的方式进行。再则，Lua 就试着调用 "lt" 或是 "le" 元方法（参见 §2.8）。
8 }9 t5 w; ~8 o; U$ v2.5.3 – 逻辑操作符% m- ~- f; [: _& X+ p. G$ p1 K7 A
Lua 中的逻辑操作符有 and, or, 以及 not。和控制结构（参见 §2.4.4）一样，所有的逻辑操作符把 false 和 nil 都作为假，而其它的一切都当作真。
% z# [2 C# r6 c9 p( V! Y: f3 C) e取反操作 not 总是manbet网页登录 false 或 true 中的一个。与操作符 and 在第一个参数为 false 或 nil 时manbet网页登录这第一个参数；否则，and manbet网页登录第二个参数。或操作符 or 在第一个参数不为 nil 也不为 false 时，manbet网页登录这第一个参数，否则manbet网页登录第二个参数。 and 和 or 都遵循短路规则；也就是说，第二个操作数只在需要的时候去求值。这里有一些例子：
6 O” j( p! Z: u& _’ y& |  S& P     10 or 20            –> 107 d+ X* r  [7 c( E$ l: Q6 A7 L* ! X
     10 or error()       –> 10
6 ~  a% a1 Z0 w     nil or "a"          –> "a"” y& P# z6 ^% k” {& k
     nil and 10          –> nil! y9 E& r% R* L” h1 }1 S; W
     false and error()   –> false
3 o  _  k) d# u     false and nil       –> false4 i1 y5 o( j7 M8 @8 N+ m
     false or nil        –> nil
6 c+ |’ L4 L9 O4 ], [0 E0 c  e     10 and 20           –> 20‘ E; Z; u$ G& [2 u
（在这本手册中， –> 指前面表达式的结果。） 4 W3 Z; ]9 Z6 O. P
2.5.4 – 连接符4 {1 {  D6 r2 x5 U% A3 V4 m9 s
Lua 中字符串的连接操作符写作两个点 (‘..’)。如果两个操作数都是字符串或都是数字，连接操作将以 §2.2.1 中提到的规则把其转换为字符串。否则，会取调用元方法 "concat" （参见 §2.8）。

2.5.5 – 取长度操作符3 m5 v, H, U% l+ f
取长度操作符写作一元操作 #。字符串的长度是它的字节数（就是以一个字符一个字节计算的字符串长度）。
* p/ l  E’ [; }0 F; C” x6 b) q! o6 Jtable t 的长度被定义成一个整数下标 n 。它满足 t[n] 不是 nil 而 t[n+1] 为 nil；此外，如果 t[1] 为 nil ，n 就可能是零。对于常规的数组，里面从 1 到 n 放着一些非空的值的时候，它的长度就精确的为 n，即最后一个值的下标。如果数组有一个“空洞” （就是说，nil 值被夹在非空值之间），那么 #t 可能是任何一个是 nil 值的位置的下标（就是说，任何一个 nil 值都有可能被当成数组的结束）。
& ~6 n’ _5 n9 _6 Y$ `% K2.5.6 – 优先级
5 `9 F2 o0 R8 V, {2 h+ W& d) A6 H8 ALua 中操作符的优先级写在下表中，从低到高优先级排序： * b) r, T, G6 a9
     or
1 b5 P# T- c0 e1 b) l8 L     and
– q! U6 P1 g’ `7 u’ m4 u     <     >     <=    >=    ~=    ==
. H: S# o, {- R’ t     ..; }1 E1 _/ j: b2 ]
     +     –2 z0 ]& a” i” z& P, g” C
     *     /     %# B) I$ }( Z. j$ j
     not   #     – (unary)# W$ A’ S/ Z, U6 V2 G6 G9 N
     ^/ `9 G/ ^! C2 Z; [6 d$ Z
通常，你可以用括号来改变运算次序。连接操作符 (‘..’) 和幂操作 (‘^’) 是从右至左的。其它所有的操作都是从左至右。 + b” e4 B, |) O/ a4 ~4 x
2.5.7 – Table 构造7 {5 |3 B6 z2 ^
table 构造子是一个构造 table 的表达式。每次构造子被执行，都会构造出一个新的 table 。构造子可以被用来构造一个空的 table，也可以用来构造一个 table 并初始化其中的一些域。一般的构造子的语法如下 8 a  g* T0 H+ y+ K
        tableconstructor ::= `{′ [fieldlist] `}′( e1 r. L% S2 @5 j; a  C! ^
        fieldlist ::= field {fieldsep field} [fieldsep]
: a# H9 y( ]8 I. X% `        field ::= `[′ exp `]′ `=′ exp | Name `=′ exp | exp
$ Y5 B0 x4 f6 _: L* k2 K        fieldsep ::= `,′ | `;′: a* k0 X& y4 |* u% I; |% V
每个形如 [exp1] = exp2 的域向 table 中增加新的一项，其键值为 exp1 而值为 exp2。形如 name = exp 的域等价于 ["name"] = exp。最后，形如 exp 的域等价于 = exp ， 这里的 i 是一个从 1 开始不断增长的数字。这这个格式中的其它域不会破坏其记数。举个例子： ! G5 B$ l3 w+ i; a6 M- e
     a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }0 O8 z, V: a8 l9 Q
等价于 ( S3 ~: I7 B! P  v( s
     do% B# X4 b1 a” U) v/ S
       local t = {}/ P4 ?7 r1 p% j
       t[f(1)] = g  d( Q) _  l* C” g; v’ s& x
       t[1] = "x"         — 1st exp
) N% c: M7 S9 a, {1 T       t[2] = "y"         — 2nd exp
; |! M- K6 k1 z9 L( M  N% G% S3 ~5 T       t.x = 1            — t["x"] = 1
! v% _# t/ [/ _1 k       t[3] = f(x)        — 3rd exp, j( K& r. _” }’ k( C
       t[30] = 23
5 n0 K$ ” G” L       t[4] = 45          — 4th exp
3 r4 ^9 V) G9 P8 e. O/ s8 S7 `       a = t
: a+ U7 S$ a9 ?8 n     end
% Q4 D. d- y$ a; D* W5 ~, j’ T如果表单中最后一个域的形式是 exp ，而且其表达式是一个函数调用或者是一个可变参数，那么这个表达式所有的manbet网页登录值将连续的进入列表（参见 §2.5.8）。为了避免这一点，你可以用括号把函数调用（或是可变参数）括起来（参见 §2.5）。
/ D* l* Y8 k$ z  g” x” r初始化域表可以在最后多一个分割符，这样设计可以方便由机器生成代码。
# x6 W: q- _$ F. U5 l2 E% `  ?2.5.8 – 函数调用7 i# ]* z” l. P$ c” ~* [
Lua 中的函数调用的语法如下： !   k1 A8 T, ~
        functioncall ::= prefixexp args6 y! N; o% }: p$ V2 s, ^
函数调用时，第一步，prefixexp 和 args 先被求值。如果 prefixexp 的值的类型是 function，那么这个函数就被用给出的参数调用。否则 prefixexp 的元方法 "call" 就被调用，第一个参数就是 prefixexp 的值，跟下来的是原来的调用参数（参见 §2.8）。 + N9 H8 R7 {4 H
这样的形式 4 j& f& x; y& C! d4 J) h9 p
        functioncall ::= prefixexp `:′ Name args
( h1 B% o  `( q* _可以用来调用 "方法"。这是 Lua 支持的一种语法糖。像 v:name(args) 这个样子，被解释成 v.name(v,args)，这里 v 只会被求值一次。
7 Q$ J( C/ y: B5 V2 ^+ G( T参数的语法如下： # l8 U; m+ }- q; e
        args ::= `(′ [explist1] `)′/ U7 e! e( m3 [/ ~6 A) H4 {
        args ::= tableconstructor
  S7 P+ }% V2 {0 i; S! y        args ::= String7 N( t) G. [, m+ a! E. d
所有参数的表达式求值都在函数调用之前。这样的调用形式 f{fields} 是一种语法糖用于表示 f({fields})；这里指参数列表是一个单一的新创建出来的列表。而这样的形式 f’string’ （或是 f"string" 亦或是 f[[string]]）也是一种语法糖，用于表示 f(‘string’)；这里指参数列表是一个单独的字符串。
7 C2 @, t# y. h” T% I因为表达式语法在 Lua 中比较自由，所以你不能在函数调用的 ‘(‘ 前换行。这个限制可以避免语言中的一些歧义。比如你这样写 + ~$ ]4 F# Z% @) c- m; S( I
     a = f
/ y( A3 d( x/ M1 j     (g).x(a)
+ d! t* w% G6 V) C6 T3 ?Lua 将把它当作一个单一语句段， a = f(g).x(a) 。因此，如果你真的想作为成两个语句段，你必须在它们之间写上一个分号。如果你真的想调用 f，你必须从 (g) 前移去换行。 9 S8 f) z$ s( J; X, |5 N
这样一种调用形式：return functioncall 将触发一个尾调用。 Lua 实现了适当的尾部调用（或是适当的尾递归）：在尾调用中，被调用的函数重用调用它的函数的堆栈项。因此，对于程序执行的嵌套尾调用的层数是没有限制的。然而，尾调用将删除调用它的函数的任何调试信息。注意，尾调用只发生在特定的语法下，这时， return 只有单一函数调用作为参数；这种语法使得调用函数的结果可以精确manbet网页登录。因此，下面这些例子都不是尾调用：
& e! j- L# F) o# B, R) a1 e& X     return (f(x))        — manbet网页登录值被调整为一个
! V+ Y1 u5 [/ `/ a1 H8 x5 n& H# S     return 2 * f(x)
2 y% n$ _7 }5 ]” H’ g8 b+ x     return x, f(x)       — 最加若干manbet网页登录值
+ m! O! i’ H$ C* o     f(x); return         — 无manbet网页登录值
5 i% }( r’ x% I1 d1 R’ c     return x or f(x)     — manbet网页登录值被调整为一个% Q’ ^  r4 R7 I& N” a, c4 h
2.5.9 – 函数定义
# M6 X0 S” d” H2 b函数定义的语法如下：
7 c8 ?0 X1 _” V! i; 1 M        function ::= function funcbody
) P’ G* H8 g* e        funcbody ::= `(′ [parlist1] `)′ block end
9 E( C# ~; I+ c2 Y另外定义了一些语法糖简化函数定义的写法：
8 j4 z1 i, W7 i- n; X; k  w+ P        stat ::= function funcname funcbody) x1 t1 z3 [* j: D& x# ]3 ]; X
        stat ::= local function Name funcbody$ b: K; W’ P* X9 ~# G5 g# J
        funcname ::= Name {`.′ Name} [`:′ Name]% q# w’ ^( |( c4 Z
这样的写法：
9 [* r( C+ @$ G” n, ~0 g9 }     function f () body end
. w5 Z4 e. ]5 e4 g6 m. ~9 A被转换成 ; `7 F6 E& E) m4 J# p” j
     f = function () body end; ^. I6 W1 V. M7 f# }6 M) {
这样的写法：   g! n* J& F/ ?0 O* Z) r
     function t.a.b.c.f () body end
2 V% ~$ I; K. I# @+ h被转换成
– l1 ^! H1 B” v9 {2 S     t.a.b.c.f = function () body end
0 ~& E* Q: T6 f- R: J: z这样的写法：
1 d) P7 E; s/ ?/ X4 F; E; 9 K     local function f () body end
! g3 z” Y’ j6 u- K  [8 P被转换成
6 E# c- o! @# f+ z     local f; f = function () body end‘ @5 C* l. o” E) J: y7 a’ X, V5 D
注意，并不是转换成 / g. a9 t- d/ [- y: G) F& ]3 g2 c
     local f = function () body end
: _1 O: Y1 f5 K) m’ |! D- v（这个差别只在函数体内需要引用 f 时才有。）
& S# e# y8 X” {4 e+ b) k’ W一个函数定义是一个可执行的表达式，执行结果是一个类型为 function 的值。当 Lua 预编译一个 chunk 的时候， chunk 作为一个函数，整个函数体也就被预编译了。那么，无论何时 Lua 执行了函数定义，这个函数本身就被实例化了（或者说是关闭了）。这个函数的实例（或者说是 closure（闭包））是表达式的最终值。相同函数的不同实例有可能引用不同的外部局部变量，也可能拥有不同的环境表。 ” @& / d9 T1 {2 Q’ a. W
形参（函数定义需要的参数）是一些由实参（实际传入参数）的值初始化的局部变量： 3 [5 o” B: s1 m, H9 r6 p( S5 F3 e
        parlist1 ::= namelist [`,′ `…′] | `…′+ f8 m7 ^+ |& ]2 R+ m& k6 a
当一个函数被调用，如果函数没有被定义为接收不定长参数，即在形参列表的末尾注明三个点 (‘…’)，那么实参列表就会被调整到形参列表的长度，变长参数函数不会调整实参列表；取而代之的是，它将把所有额外的参数放在一起通过变长参数表达式传递给函数，其写法依旧是三个点。这个表达式的值是一串实参值的列表，看起来就跟一个可以manbet网页登录多个结果的函数一样。如果一个变长参数表达式放在另一个表达式中使用，或是放在另一串表达式的中间，那么它的manbet网页登录值就会被调整为单个值。若这个表达式放在了一系列表达式的最后一个，就不会做调整了（除非用括号给括了起来）。
! z  K4 V# 1 f& v9 u  G. i我们先做如下定义，然后再来看一个例子： ) A2 Y; Q- J) c/ E3 F
     function f(a, b) end
1 v4 s” h3 e  o& l4 H6 R! F, _; q     function g(a, b, …) end
( c1 s’ j7 k4 f     function r() return 1,2,3 end8 w6 I9 [. p/ e” F  E
下面看看实参到形参数以及可变长参数的映射关系：
4 ]# S9 ?8 t! t$ q# Z     CALL            PARAMETERS
* I5 U& ~+ f8 Z5 u! E     
– r; E( # I! k, E” G; e2 h     f(3)             a=3, b=nil: q8 e( d9 I& o# c1 s
     f(3, 4)          a=3, b=4
/ ~9 l5 z+ m7 r9 S+ r: w! t; S! O5 V     f(3, 4, 5)       a=3, b=4
3 k. o, k* j6 P’ }0 z9 n     f(r(), 10)       a=1, b=10! E6 s7 d1 k, a8 H
     f(r())           a=1, b=2
$ e; V- b, f, a+ }# v9 h6 t       L& r” k& z% l5 f& y6 # g0 t$ B
     g(3)             a=3, b=nil, … –>  (nothing)
8 Z) l, I5 ^2 F- Y     g(3, 4)          a=3, b=4,   … –>  (nothing)
‘ j* U* S+ }1 Z! S” u$ m” Y7 y     g(3, 4, 5, 8)    a=3, b=4,   … –>  5  8. Z! c+ r; l. C” D  G, @
     g(5, r())        a=5, b=1,   … –>  2  3& G& A0 W$ k’ Z- f! C’ W  ?
结果由 return 来manbet网页登录（参见 §2.4.4）。如果执行到函数末尾依旧没有遇到任何 return 语句，函数就不会manbet网页登录任何结果。 3 c! G  }. N” W2 f8 u. F2 D
冒号语法可以用来定义方法，就是说，函数可以有一个隐式的形参 self。因此，如下写法： 6 Y! [( C) t9 @, d; {* D0 z
     function t.a.b.c:f (params) body end
0 F* ?3 P’ M; j) I( g是这样一种写法的语法糖： 6 V/ R: J# r: ?4 T+ h; |
     t.a.b.c.f = function (self, params) body end2 |. }5 C2 E4 h1 h  m
2.6 – 可视规则
4 |6 P# B! u7 c% ?( q# d: _, J! PLua 是一个有词法作用范围的语言。变量的作用范围开始于声明它们之后的第一个语句段，结束于包含这个声明的最内层语句块的结束点。看下面这些例子：
6 J2 |! a2 i! V  f  D8 o; i     x = 10                — 全局变量
4 K” d/ r; S( ^( H     do                    — 新的语句块! m/ c” F! q- ^. n) v3 b# m9 Z9 ?
       local x = x         — 新的一个 ‘x’, 它的值现在是 10
  L+ A2 C6 Y. {       print(x)            –> 10/ N6 ^; z  C# @7 }4 q  I
       x = x+1
  Y+ [, Y5 w( P8 x       do                  — 另一个语句块
) x- M# k0 ~% ^7 M+ |         local x = x+1     — 又一个 ‘x’
! N& ^: E# q4 g         print(x)          –> 123 v5 e$ ~: A( h9 l  i” I
       end$ j: S( O: W8 x! u! c4 R0 M
       print(x)            –> 11
# M2 z3 V9 a* Y+ H) E. c9 s     end
3 Y3 |2 A$ w! ?     print(x)              –> 10  （取到的是全局的那一个）2 |1 O) j2 g1 g) E8 k4 W
注意这里，类似 local x = x 这样的声明，新的 x 正在被声明，但是还没有进入它的作用范围，所以第二个 x 指向的是外面一层的变量。 3 a8 j( N- C” A& j/ S1 J
因为有这样一个词法作用范围的规则，所以可以在函数内部自由的定义局部变量并使用它们。当一个局部变量被更内层的函数中使用的时候，它被内层函数称作 upvalue（上值），或是 外部局部变量。
% i9 M& e” I- U1 l; u注意，每次执行到一个 local 语句都会定义出一个新的局部变量。看看这样一个例子：
! Y9 Y4 O1 Y9 f% R# |     a = {}2 t  v/ M. W9 Z” H& L6 N’ w7 E; F5 V
     local x = 203 c” e$ b& H! m- N, S+ V
     for i=1,10 do3 v# m2 K$ x2 P
       local y = 0
! N. o; M; q8 d* P” m2 j0 U8 w       a = function () y=y+1; return x+y end
# [‘ t” I2 {5 p& s8 z$ v’ s     end0 K4 X/ n; v$ M5 q0 ~: H, R, b6 w2 C2 w
这个循环创建了十个 closure（这指十个匿名函数的实例）。这些 closure 中的每一个都使用了不同的 y 变量，而它们又共享了同一份 x。
$ c3 {: B8 v” l: ?5 Y2.7 – 错误处理
0 _, x6 k- p/ D% f$ Q: D- T4 n( c+ W因为 Lua 是一个嵌入式的扩展语言，所有的 Lua 动作都是从宿主程序的 C 代码调用 Lua 库（参见 lua_pcall）中的一个函数开始的。在 Lua 编译或运行的任何时候发生了错误，控制权都会交还给 C ，而 C 可以来做一些恰当的措施（比如打印出一条错误信息）。
, d( X. i: A1 O0 a5 aLua 代码可以显式的调用 error 函数来产生一条错误。如果你需要在 Lua 中捕获发生的错误，你可以使用 pcall 函数。
‘ [/ M2 B4 |1 z2 I% {+ o) s( w% }2.8 – Metatable（元表）! s9 X& F3 J4 D0 l5 |
Lua 中的每个值都可以用一个 metatable。这个 metatable 就是一个原始的 Lua table ，它用来定义原始值在特定操作下的行为。你可以通过在 metatable 中的特定域设一些值来改变拥有这个 metatable 的值的指定操作之行为。举例来说，当一个非数字的值作加法操作的时候， Lua 会检查它的 metatable 中 "__add" 域中的是否有一个函数。如果有这么一个函数的话，Lua 调用这个函数来执行一次加法。 % w- Y$ `. V1 j3 c: E  M
我们叫 metatable 中的键名为 事件 (event) ，把其中的值叫作 元方法 (metamethod)。在上个例子中，事件是 "add" 而元方法就是那个执行加法操作的函数。
6 P) }5 b) G, c! j. L你可以通过 getmetatable 函数来查询到任何一个值的 metatable。
% [3 H6 I- R6 ~你可以通过 setmetatable 函数来替换掉 table 的 metatable 。你不能从 Lua 中改变其它任何类型的值的 metatable （使用 debug 库例外）；要这样做的话必须使用 C API 。 ; t1 K; h2 q” @3 S
每个 table 和 userdata 拥有独立的 metatable （当然多个 table 和 userdata 可以共享一个相同的表作它们的 metatable）；其它所有类型的值，每种类型都分别共享唯一的一个 metatable。因此，所有的数字一起只有一个 metatable ，所有的字符串也是，等等。 ; U1 d* U$ ^( c’ s” B* f
一个 metatable 可以控制一个对象做数学运算操作、比较操作、连接操作、取长度操作、取下标操作时的行为， metatable 中还可以定义一个函数，让 userdata 作垃圾收集时调用它。对于这些操作，Lua 都将其关联上一个被称作事件的指定健。当 Lua 需要对一个值发起这些操作中的一个时，它会去检查值中 metatable 中是否有对应事件。如果有的话，键名对应的值（元方法）将控制 Lua 怎样做这个操作。
: q0 y0 ?( H( l8 I! Tmetatable 可以控制的操作已在下面列出来。每个操作都用相应的名字区分。每个操作的键名都是用操作名字加上两个下划线 ‘__’ 前缀的字符串；举例来说，"add" 操作的键名就是字符串 "__add"。这些操作的语义用一个 Lua 函数来描述解释器如何执行更为恰当。
: L$ N/ _/ ( Z” w% p# . w* g这里展示的用 Lua 写的代码仅作解说用；实际的行为已经硬编码在解释器中，其执行效率要远高于这些模拟代码。这些用于描述的的代码中用到的函数（ rawget ， tonumber ，等等。）都可以在 §5.1 中找到。特别注意，我们使用这样一个表达式来从给定对象中提取元方法 % Q# s! g- A& U+ }
     metatable(obj)[event]
1 x$ s, l9 x’ j; 这个应该被解读作 $ v# I9 Z( s; l$ k, z” l
     rawget(getmetatable(obj) or {}, event)
9 V! }+ Q6 M- ]( g+ y  Q- P这就是说，访问一个元方法不再会触发任何的元方法，而且访问一个没有 metatable 的对象也不会失败（而只是简单manbet网页登录 nil）。 & l* @% u’ V! {3 W’ k8 Q5 l6 Q’ c
?        "add": + 操作。 9 Z& {5 D- Z  t0 A
下面这个 getbinhandler 函数定义了 Lua 怎样选择一个处理器来作二元操作。首先，Lua 尝试第一个操作数。如果这个东西的类型没有定义这个操作的处理器，然后 Lua 会尝试第二个操作数。
$ f- y4 I% U. Y5 {) _/ h- F     function getbinhandler (op1, op2, event)7 n$ ]% G* n; B1 P  ~2 k! F
       return metatable(op1)[event] or metatable(op2)[event]5 q4 U1 o$ f& _4 O, M
     end6 i4 V# a6 j, }3 A
通过这个函数， op1 + op2 的行为就是
/ F- a7 d7 @” F     function add_event (op1, op2)
5 A( Q! D  I6 |& D$ k4 V       local o1, o2 = tonumber(op1), tonumber(op2)
– |2 I7 T8 u’ _. }       if o1 and o2 then  — 两个操作数都是数字？/ D+ H$ s6 e$ R$ ~
         return o1 + o2   — 这里的 ‘+’ 是原生的 ‘add’6 _8 l3 @+ p9 `% N
       else  — 至少一个操作数不是数字时4 n: B4 [  K. T
         local h = getbinhandler(op1, op2, "__add")
0 d$ u/ M/ X& x# V! X/ L% X         if h then. D2 X8 j: H8 X
           — 以两个操作数来调用处理器
: p* n* U  p* W- F+ V; E$ T& p           return h(op1, op2)$ `, S, t! f. P
         else  — 没有处理器：缺省行为; m0 }$ ]1 k5 O’ `, z- e; B* P# y
           error(???)9 h” O: U7 F+ e1 L5 D$ E
         end
1 b, C# w2 C: l( t       end
+ }  e  i2 K1 E+ s4 c$ K; T” U     end% L% R2 L/ W% X
?        "sub": – 操作。 其行为类似于 "add" 操作。 : ~# b% B9 ( P
?        "mul": * 操作。 其行为类似于 "add" 操作。
  9 D0 G: G- r3 T# W  g?        "div": / 操作。 其行为类似于 "add" 操作。 ‘ W  i3 a4 s/ Z8 N
?        "mod": % 操作。 其行为类似于 "add" 操作，它的原生操作是这样的 o1 – floor(o1/o2)*o2 9 J# x’ X5 M1 h0 z; k
?        "pow": ^ （幂）操作。 其行为类似于 "add" 操作，它的原生操作是调用 pow 函数（通过 C math 库）。
& V’ D4 R% t/ b: ~( P2 e?        "unm": 一元 – 操作。 & A) }0 N# R. Y’ V
?             function unm_event (op)# d3 t6 C2 [4 ]  ~
?               local o = tonumber(op)
1 y” k( |% d! I- M! T2 y?               if o then  — 操作数是数字？
  z2 R3 ]- p2 C?                 return -o  — 这里的 ‘-‘ 是一个原生的 ‘unm’2 z1 b* l8 h. l5 t+ B8 B4 L’ J
?               else  — 操作数不是数字。2 |+ C/ b- q6 J  P
?                 — 尝试从操作数中得到处理器
7 b’ ?0 O0 l3 u% e5 Q( o?                 local h = metatable(op).__unm
  c# u% e’ e1 `  l5 t: ]3 Y?                 if h then
( o7 a9 @” A. n: k5 M?                   — 以操作数为参数调用处理器% _* }’ [+ e8 c” A
?                   return h(op)* l  @$ ?+ t1 E, t2 E* ]
?                 else  — 没有处理器：缺省行为. W2 G$ b+ H, t  Z
?                   error(???)
4 – [. x& ?2 T( [?                 end) F% i  v+ E) Z% c’ Z8 U) V; }5 B
?               end
) E) @1 f5 C+ r6 ~?             end
+ k& T- o/ v! t7 ^& y: `( L?        "concat": .. （连接）操作， 5 k) ]” ( l) A! g2 W( D: p
?             function concat_event (op1, op2)
/ i3 {( M- V7 w* _8 ^- S?               if (type(op1) == "string" or type(op1) == "number") and( b) _  @6 e: U# h& g
?                  (type(op2) == "string" or type(op2) == "number") then8 T# }. `, p- ~: L
?                 return op1 .. op2  — 原生字符串连接2 k! Z- f1 5 g/ `
?               else  f( r* n* D* U# G/ l/ c
?                 local h = getbinhandler(op1, op2, "__concat")
2 K% R+ Q1 `2 K0 @8 x+ V8 v$ t?                 if h then– |0 Z% {0 ^5 }1 R
?                   return h(op1, op2)1 C, B$ e- h3 }% m6 v; [9 Q
?                 else7 c4 @6 w3 I& {+ B! c
?                   error(???)* S0 X. j  Y8 Z% `# z9 v( b6 F
?                 end
/ O7 l9 X$ H; J. E2 r8 W9 k. P?               end
/ ^5 N* ^# f’ K. `. E?             end
4 v& J9 U7 f4 N* W8 C* u8 d?        "len": # 操作。
; z% ?% ^/ r% V# ^. p’ ?1 H. g?             function len_event (op)4 a1 j5 P’ T. k” ]: Q
?               if type(op) == "string" then: X& m# B- S# I” T
?                 return strlen(op)         — 原生的取字符串长度  K% r# h% ]6 C; A’ i  r
?               elseif type(op) == "table" then
  N7 R; c& [3 i& }. _; Q?                 return #op                — 原生的取 table 长度
* E5 S$ Q’ H$ @; m* n2 ~?               else( P& t$ G) 9 v6 H9 [2 _5 v
?                 local h = metatable(op).__len‘ }  ^” ?6 u# `. X6 q
?                 if h then) r8 p. D+ d3 s& u0 ^; v) M
?                   — 调用操作数的处理器6 W8 g’ C# s. r- Y
?                   return h(op)
2 I1 G, T9 B- @* `3 U?                 else  — 没有处理器：缺省行为
5 B’ ]; _7 r4 }9 A) d?                   error(???)
” f” D6 y2 E8 R?                 end
5 g0 B- R7 w! H4 z  Q$ Z?               end* u$ P0 M) V5 Z! p+ K* L! P
?             end7 }1 y2 U; R5 f( a. v” A
关于 table 的长度参见 §2.5.5 。 3 W! t* [2 M( N/ ~% f7 n) B3 D6 o
?        "eq": == 操作。 函数 getcomphandler 定义了 Lua 怎样选择一个处理器来作比较操作。元方法仅仅在参于比较的两个对象类型相同且有对应操作相同的元方法时才起效。
” P7 _- V5 b* o+ I3 W?             function getcomphandler (op1, op2, event)& b) a0 w5 ]$ M3 i; g
?               if type(op1) ~= type(op2) then return nil end
0 E9 I5 L% e( P! X& t  x) d?               local mm1 = metatable(op1)[event]
/ L% N’ {  x. k8 Z* C% H2 B?               local mm2 = metatable(op2)[event]
6 B# U’ i. f0 K& v, h! `?               if mm1 == mm2 then return mm1 else return nil end
‘ R. o( y! j. K?             end
3 |* v” q4 N8 O! j5 b’ t5 d# l"eq" 事件按如下方式定义： 6 ]2 k3 [2 k: g. Z( s
     function eq_event (op1, op2)4 r& Y1 t) s6 t6 x2 S4 |
       if type(op1) ~= type(op2) then  — 不同的类型？
% ?8 ], t” _; ^: R9 C         return false   — 不同的对象
0 S+ `# {. m  L0 v       end5 l’ j  U/ G* O# S- j
       if op1 == op2 then   — 原生的相等比较结果？
4 t’ `. [” T  u1 p2 M         return true   — 对象相等
5 G- J& k: k. l, p/ N5 q       end0 e& H+ k4 q/ D4 x” m! n6 d* Q$ K- o
       — 尝试使用元方法* L& w% 6 o! j. T/ }4 Q* z
       local h = getcomphandler(op1, op2, "__eq")8 h0 w; d; V  I  W$ K
       if h then
  @0 U$ r3 + ?$ t2 k         return h(op1, op2)1 F3 L+ ]7 K+ x
       else: t7 q8 z’ I7 h
         return false
/ X3 x# {3 L% G9 v       end
2 e2 R& ?# {* ^( ~: h! o3 J     end+ r! ?( }4 |7 r4 u, q
a ~= b 等价于 not (a == b) 。 . a9 n/ Y% q& W$ i3 }
?        "lt": < 操作。 0 G7 o: ]9 h4 x% N; t1 s! X/ ?5 V
?             function lt_event (op1, op2)
; M: W7 y0 j. O$ ]5 ^/ K  [?               if type(op1) == "number" and type(op2) == "number" then
: @” n+ M1 k” A?                 return op1 < op2   — 数字比较/ C: X% s- Y  Y% x” I, B+ N1 T
?               elseif type(op1) == "string" and type(op2) == "string" then
% T” h1 C0 Q- U( B” `; y?                 return op1 < op2   — 字符串按逐字符比较. [1 k: Y/ ?5 h2 ^; _1 n$ F
?               else
+ _( i- h* X# ~! ?# y1 G% a/ |?                 local h = getcomphandler(op1, op2, "__lt")
/ p) b8 C. v” O’ U?                 if h then. U5 T  {- L4 S. [8 B4 C
?                   return h(op1, op2)  [: T2 I: e& Q5 k
?                 else
# w; a% ]’ ?” G$ O% c?                   error(???);
9 i( c* U/ – C8 v” t” a?                 end+ _8 a3 v+ u% P9 V. X  + O* t5 a
?               end4 c+ z’ B3 R! J- ^$ * e. ^
?             end
  J- O8 X’ V. Y0 ha > b 等价于 b < a. 1 W4 N- @3 M* I
?        "le": <= 操作。
* k1 y% q. `- T2 w/ W5 W?             function le_event (op1, op2)” O5 H5 S9 ~: V7 I. D  h” p
?               if type(op1) == "number" and type(op2) == "number" then: Z, ~& g5 C% u) Y” r% x; v! ?
?                 return op1 <= op2   — 数字比较6 $ v4 j” D* i) r8 ?- F
?               elseif type(op1) == "string" and type(op2) == "string" then. V) ]& h, P3 ]” e8 D+ x$ `1 F
?                 return op1 <= op2   — 字符串按逐字符比较
) r( x4 @! D$ f! A6 T?               else5 W1 [7 A3 N) t6 c8 _: f
?                 local h = getcomphandler(op1, op2, "__le")! ~5 y” c% I” w4 @  K
?                 if h then
– v2 H& h* i2 {7 q. Y! U?                   return h(op1, op2)
( q8 l+ Y$ ~( E1 y$ m?                 else
4 N$ C& J% O3 J  x8 V?                   h = getcomphandler(op1, op2, "__lt")# Q) |& {, u% y8 f* Z1 _
?                   if h then
; a; s” @$ N* f& V0 ~?                     return not h(op2, op1)” Z3 ~9 b! n! J/ w, B- U” M! k  ]0 ~
?                   else7 m* x’ J: [# L6 x( |
?                     error(???);2 X3 f( d6 B9 {) i  H+ v
?                   end
+ o* T9 K( c, R4 `?                 end. ~$ N1 B. V+ K  |0 N+ ~0 u
?               end: N* l- V$ B4 [! X9 e9 w# d- u$ r& o
?             end
/ J% m( H5 R0 ~. J; }a >= b 等价于 b <= a 。注意，如果元方法 "le" 没有提供，Lua 就尝试 "lt" ，它假定 a <= b 等价于 not (b < a) 。 8 u# a3 V# P4 ]# P! {5 L1 u
?        "index": 取下标操作用于访问 table[key] 。 # u1 ~0 S) e8 z% M9 N” D% b
?             function gettable_event (table, key)$ [2 g” ?% O, K% }
?               local h2 {7 a0 M3 t$ n; N& I
?               if type(table) == "table" then
‘ J; q, N9 ) G?                 local v = rawget(table, key)
# u4 f, x2 [8 q0 l?                 if v ~= nil then return v end0 w0 C2 l* Z$ C8 d” S
?                 h = metatable(table).__index
, Y; b5 f” W) n2 y?                 if h == nil then return nil end
( l’ R  e- p; K. h2 J?               else6 L! f3 O7 H2 p
?                 h = metatable(table).__index$ e9 X’ }; M( k
?                 if h == nil then‘ d+ W7 O1 a. I; g3 T” p& M
?                   error(???);
2 T% V5 K, ~& W0 k, e  z?                 end: P9 |% W: P0 D  J5 X5 u
?               end
8 L& b& w/ ^# T* P8 L1 M6 x?               if type(h) == "function" then
) 2 ?! J+ f( i& V” i?                 return h(table, key)      — 调用处理器
$ f5 d% i# O4 `” O$ S( t) _?               else return h[key]          — 或是重复上述操作
‘ ]$ A/ ~0 ^3 ?+ R: e8 g?               end
+ ]# M$ B( _$ x. o- H. s?             end
7 z9 A  D7 M’ p2 J* T- l?        "newindex": 赋值给指定下标 table[key] = value 。 9 % ^) `5 h9 o1 X: x4 Y
?             function settable_event (table, key, value)0 s) R8 J2 i4 D; C; h
?               local h
, O” J$ M, D$ B3 w?               if type(table) == "table" then
5 S/ L: {$ z* O* [?                 local v = rawget(table, key)4 f8 w9 y1 e; A# Q5 O2 e# M
?                 if v ~= nil then rawset(table, key, value); return end
5 V( Y8 b7 _! T3 h2 G* T?                 h = metatable(table).__newindex# @- @/ s” N0 s2 C
?                 if h == nil then rawset(table, key, value); return end
) h9 D4 ^, h  Y- k- t; f?               else
: |5 d4 B; W, G# q$ $ ~9 G?                 h = metatable(table).__newindex
7 T2 l5 a* o% l. v?                 if h == nil then$ M/ }9 g6 W% `8 t, V. u
?                   error(???);* i/ U& I& B- {  f& z3 f
?                 end9 D* p& f” H( a/ Q2 j3 Y! B
?               end# t$ }’ H- O% k
?               if type(h) == "function" then
3 {2 ( b& `3 r, j?                 return h(table, key,value)    — 调用处理器
1 [* k  B” m+ n/ l?               else h[key] = value             — 或是重复上述操作5 @0 N& f0 I7 C’ I! Y
?               end
8 a” F# }& m1 p4 Q?             end
. g! y6 y! `2 d2 M” B?        "call": 当 Lua 调用一个值时调用。 0 ?( D6 E2 v9 a) ?+ j
?             function function_event (func, …)& A1 r! X. t7 O- s, X
?               if type(func) == "function" then
) n2 e& l% E( M7 ?! w/ K0 ]?                 return func(…)   — 原生的调用1 H: w+ J( @$ t” u2 x
?               else
% A: ]0 G2 V’ w- X# H?                 local h = metatable(func).__call‘ F- k* S’ k& d! }3 q# q9 Z
?                 if h then
‘ G( Q: ^8 u6 v0 g?                   return h(func, …)
! q& s/ @6 E) w: k: I” C?                 else
– |% W  O8 x# U0 j?                   error(???)
* z, s, L: Z# }! j2 X?                 end
0 }’ T0 c- _5 H: q?               end
6 C: j/ I, S9 H- M?             end
” ^- d6 L5 t/ B3 h2.9 – 环境
. g’ R% c; P7 X8 H类型为 thread ，function ，以及 userdata 的对象，除了 metatable 外还可以用另外一个与之关联的被称作它们的环境的一个表，像 metatable 一样，环境也是一个常规的 table ，多个对象可以共享同一个环境。 . K) _2 S: V5 I
userdata 的环境在 Lua 中没有意义。这个东西只是为了在程序员想把一个表关联到一个 userdata 上时提供便利。
/ V3 z6 @% v6 h) W8 i# z+ m关联在线程上的环境被称作全局环境。全局环境被用作它其中的线程以及线程创建的非嵌套函数（通过 loadfile ， loadstring 或是 load ）的缺省环境。而且它可以被 C 代码直接访问（参见 §3.3）。 ! C* v0 Y. e0 P2 I# ]; C! |, w7 ~: j
关联在 C 函数上的环境可以直接被 C 代码访问（参见 §3.3）。它们会作为这个 C 函数中创建的其它函数的缺省环境。
+ d3 _$ e0 t* _& n  D’ x( C( Y关联在 Lua 函数上的环境用来接管在函数内对全局变量（参见 §2.3）的所有访问。它们也会作为这个函数内创建的其它函数的缺省环境。
9 n; c) t) ~% ^% c1 4 t7 a你可以通过调用 setfenv 来改变一个 Lua 函数或是正在运行中的线程的环境。而想操控其它对象（userdata、C 函数、其它线程）的环境的话，就必须使用 C API 。
9 _3 K2 R4 l4 C’ e$ e! ‘ c7 X2.10 – 垃圾收集‘ T; w1 v0 X* d& r1 v4 I” [
Lua 提供了一个自动的内存管理。这就是说你不需要关心创建新对象的分配内存操作，也不需要在这些对象不再需要时的主动释放内存。 Lua 通过运行一个垃圾收集器来自动管理内存，以此一遍又一遍的回收死掉的对象（这是指 Lua 中不再访问的到的对象）占用的内存。 Lua 中所有对象都被自动管理，包括： table, userdata、 函数、线程、和字符串。 ; c* P8 y; ~’ @% g
Lua 实现了一个增量标记清除的收集器。它用两个数字来控制垃圾收集周期： garbage-collector pause 和 garbage-collector step multiplier 。 * S) }% D4 h’ S6 ]” Q$ Z
garbage-collector pause 控制了收集器在开始一个新的收集周期之前要等待多久。随着数字的增大就导致收集器工作工作的不那么主动。小于 1 的值意味着收集器在新的周期开始时不再等待。当值为 2 的时候意味着在总使用内存数量达到原来的两倍时再开启新的周期。
$ @- |# m; R( {4 L( Y, 5 qstep multiplier 控制了收集器相对内存分配的速度。更大的数字将导致收集器工作的更主动的同时，也使每步收集的尺寸增加。小于 1 的值会使收集器工作的非常慢，可能导致收集器永远都结束不了当前周期。缺省值为 2 ，这意味着收集器将以内存分配器的两倍速运行。
4 V$ S3 T$ w1 O# o6 {& e你可以通过在 C 中调用 lua_gc 或是在 Lua 中调用 collectgarbage 来改变这些数字。两者都接受百分比数值（因此传入参数 100 意味着实际值 1 ）。通过这些函数，你也可以直接控制收集器（例如，停止或是重启）。 2 S; u’ U” ]- f/ d. M
2.10.1 – 垃圾收集的元方法4 m9 m# L3 N8 `; J
使用 C API　，你可以给 userdata （参见 §2.8）设置一个垃圾收集的元方法。这个元方法也被称为结束子。结束子允许你用额外的资源管理器和 Lua 的内存管理器协同工作（比如关闭文件、网络连接、或是数据库连接，也可以说释放你自己的内存）。 ‘ B% v/ Q” ^7 `; O$ l
一个 userdata 可被回收，若它的 metatable 中有 __gc 这个域　，垃圾收集器就不立即收回它。取而代之的是，Lua 把它们放到一个列表中。最收集结束后，Lua 针对列表中的每个 userdata 执行了下面这个函数的等价操作：
4 H. K. v6 a! `: d7 |     function gc_event (udata)
0 T7 R* Y! l0 v7        local h = metatable(udata).__gc5 S! t2 ?.   }/ Y
       if h then
$ }9 F” e2 m- E         h(udata)5 B0 d4 C7 y) v0 o# P7 {& g” u
       end: @’ y5 a% U4 Q9 o; f% i’ |
     end4 x; g2 H& O” A7 I6 r
在每个垃圾收集周期的结尾，每个在当前周期被收集起来的 userdata 的结束子会以它们构造时的逆序依次调用。也就是说，收集列表中，最后一个在程序中被创建的 userdata 的结束子会被第一个调用。
& J. y- p  }3 p5 O2.10.2 – Weak Table（弱表）
7 u2 X0 O% h” Lweak table 是一个这样的 table，它其中的元素都被弱引用。弱引用将被垃圾收集器忽略掉，换句话说，如果对一个对象的引用只有弱引用，垃圾收集器将回收这个对象。 ” F6 }) }6 A7 y$ O  m
weak table 的键和值都可以是 weak 的。如果一个 table 只有键是 weak 的，那么将运行收集器回收它们的键，但是会阻止回收器回收对应的值。而一个 table 的键和值都是 weak 时，就即允许收集器回收键又允许收回值。任何情况下，如果键和值中任一个被回收了，整个键值对就会从 table 中拿掉。 table 的 weak 特性可以通过在它的 metatable 中设置 __mode 域来改变。如果 __mode 域中是一个包含有字符 ‘k’ 的字符串时， table 的键就是 weak 的。如果 __mode 域中是一个包含有字符 ‘v’ 的字符串时， table 的值就是 weak 的。
& I4 Q& }! @: F$ h7 q. R在你把一个 table 当作一个 metatable 使用之后，就不能再修改 __mode 域的值。否则，受这个 metatable 控制的 table 的 weak 行为就成了未定义的。
  / ~& T% S0 d/ V1 e2.11 – Coroutine （协同例程）” h  R5 T  U) v, M; d4 w
Lua 支持 coroutine ，这个东西也被称为协同式多线程 (collaborative multithreading)　。 Lua 为每个 coroutine 提供一个独立的运行线路。然而和多线程系统中的线程不同，coroutine 只在显式的调用了 yield 函数时才会挂起。
” g, a; x2 N/ }/ d1 w* 创建一个 coroutine 需要调用一次 coroutine.create 。它只接收单个参数，这个参数是 coroutine 的主函数。 create 函数仅仅创建一个新的 coroutine 然后manbet网页登录它的控制器（一个类型为 thread 的对象）；它并不会启动 coroutine 的运行。 6 y: o+ l9 Q1 k% P’ u
当你第一次调用 coroutine.resume 时，所需传入的第一个参数就是 coroutine.create 的manbet网页登录值。这时，coroutine 从主函数的第一行开始运行。接下来传入 coroutine.resume 的参数将被传进 coroutine 的主函数。在 coroutine 开始运行后，它讲运行到自身终止或是遇到一个 yields 。 7 E, S, Z( }7 b, K
coroutine 可以通过两种方式来终止运行：一种是正常退出，指它的主函数manbet网页登录（最后一条指令被运行后，无论有没有显式的manbet网页登录指令）; 另一种是非正常退出，它发生在未保护的错误发生的时候。第一种情况中， coroutine.resume manbet网页登录 true ，接下来会跟着 coroutine 主函数的一系列manbet网页登录值。第二种发生错误的情况下， coroutine.resume manbet网页登录 false ，紧接着是一条错误信息。
: J9 j0 |# |* S’ O” f7 X6 B! j7 |coroutine 中切换出去，可以调用 coroutine.yield。当 coroutine 切出，与之配合的 coroutine.resume 就立即manbet网页登录，甚至在 yield 发生在内层的函数调用中也可以（就是说，这不限于发生在主函数中，也可以是主函数直接或间接调用的某个函数里）。在 yield 的情况下，coroutine.resume 也是manbet网页登录 true，紧跟着那些被传入 coroutine.yield 的参数。等到下次你在继续同样的 coroutine ，将从调用 yield 的断点处运行下去。断点处 yield 的manbet网页登录值将是 coroutine.resume 传入的参数。
‘ y4 u1 Z, T7 W1 f2 Q) M类似 coroutine.create ， coroutine.wrap 这个函数也将创建一个 coroutine ，但是它并不manbet网页登录 coroutine 本身，而是manbet网页登录一个函数取而代之。一旦你调用这个manbet网页登录函数，就会切入 coroutine 运行。所有传入这个函数的参数等同于传入 coroutine.resume 的参数。 coroutine.wrap 会manbet网页登录所有应该由除第一个（错误代码的那个布尔量）之外的由 coroutine.resume manbet网页登录的值。和 coroutine.resume 不同， coroutine.wrap 不捕获任何错误；所有的错误都应该由调用者自己传递。
, ^1 |  p  G; a6 g” V9 [3 K看下面这段代码展示的一个例子：
! w; D1 S: ^3 W2 B9 l* ]# _$ H) t. U     function foo (a)
. t- V2 F* g! f) R’ [; z’ X! U! I5 W       print("foo", a)4 Q’ u& |8 ?  T3 J( m6 V
       return coroutine.yield(2*a)” {# V8 o4 ^, W& j7 i9 h1 j
     end
; f1 S* k# A: h3 |- J9 w’ _” f     0 ]6 b$ b3 v* ~$ / M
     co = coroutine.create(function (a,b)( h” X) s1 _8 F! m! _+ }( X
           print("co-body", a, b)5 ]/ v! |$ Q8 N7 ~/ |
           local r = foo(a+1)
, c5 `: b0 v2 u  H& M! A# V’ B           print("co-body", r)
( _  s  ~% @! W0 G7 r5 |( }           local r, s = coroutine.yield(a+b, a-b)
/ i) k” a. U( l7 [4 V           print("co-body", r, s)
6 T2 S. v0 f2 {6 f8 ?% Y5 K           return b, "end"
” S) j% ?8 ?9 E6 R8 l6 z1 `     end)
! W# H- m  I: G- ~3 q1 Z! j            4 l’ v$ Y4 P, G( t
     print("main", coroutine.resume(co, 1, 10))” L; T8 J, }2 n. _4 ~, e: H
     print("main", coroutine.resume(co, "r"))
& Q- @6 D% e* q( w$ ~) Z     print("main", coroutine.resume(co, "x", "y"))
0 e8 I% k* ?9 T, j0 e! [     print("main", coroutine.resume(co, "x", "y"))
% l’ z; B/ b9 R8 d0 ]当你运行它，将得到如下输出结果： * o% V& G1 A: B
     co-body 1       10: b, o. P4 P+ b0 G0 h$ }  P
     foo     2% Z3 V$ V4 N5 F1 K4 v7 a6 b
     0 Z- V$ j’ I$ % `* K” [
     main    true    4( A: }- R1 X0 ?2 f
     co-body r
9 `0 D” x. u2 M1 G& u     main    true    11      -9
& ~5 d4 e  ?; ^” M5 h     co-body x       y$ z”   V3 C( T9 k
     main    true    10      end
1 e2 L8 / U& w% ?3 y  s     main    false   cannot resume dead coroutine
& ~1 H; v% S( x3 I2 P0 b; M” J# Q3 – 程序接口（API）
3 b’ f& V/ N: c5 Q! |这个部分描述了 Lua 的 C API ，也就是宿主程序跟 Lua 通讯用的一组 C 函数。所有的 API 函数按相关的类型以及常量都声明在头文件 lua.h 中。
5 j5 c5 i, L: O; _; ; F虽然我们说的是“函数”，但一部分简单的 API 是以宏的形式提供的。所有的这些宏都只使用它们的参数一次（除了第一个参数，也就是 lua 状态机），因此你不需担心这些宏的展开会引起一些副作用。
0 f; p% I# z  L* R! Y* C% N# k3 U在所有的 C 库中，Lua API 函数都不去检查参数的有效性和坚固性。然而，你可以在编译 Lua 时加上打开一个宏开关来开启 luaconf.h 文件中的宏 luai_apicheck 以改变这个行为。
9 @6 i6 a3 X9 [5 o3.1 – 堆栈
1 B; w; g” |- xLua 使用一个虚拟栈来和 C 传递值。栈上的的每个元素都是一个 Lua 值（nil，数字，字符串，等等）。
) u% m) E, u1 X. _/ [无论何时 Lua 调用 C，被调用的函数都得到一个新的栈，这个栈独立于 C 函数本身的堆栈，也独立于以前的栈。（译注：在 C 函数里，用 Lua API 不能访问到 Lua 状态机中本次调用之外的堆栈中的数据）它里面包含了 Lua 传递给 C 函数的所有参数，而 C 函数则把要manbet网页登录的结果也放入堆栈以manbet网页登录给调用者（参见 lua_CFunction）。
– G4 m1 x* j* E: s方便起见，所有针对栈的 API 查询操作都不严格遵循栈的操作规则。而是可以用一个索引来指向栈上的任何元素：正的索引指的是栈上的绝对位置（从一开始）；负的索引则指从栈顶开始的偏移量。更详细的说明一下，如果堆栈有 n 个元素，那么索引 1 表示第一个元素（也就是最先被压入堆栈的元素）而索引 n 则指最后一个元素；索引 -1 也是指最后一个元素（即栈顶的元素），索引 -n 是指第一个元素。如果索引在 1 到栈顶之间（也就是，1 ≤ abs(index) ≤ top）我们就说这是个有效的索引。 ‘ n. ?; B. y! z5 M” K# Y8 `, n
3.2 – 堆栈尺寸
” G3 W# n. d1 H1 z’ W3 @0 Y& V0 ]- q当你使用 Lua API 时，就有责任保证其坚固性。特别需要注意的是，你有责任控制不要堆栈溢出。你可以使用 lua_checkstack 这个函数来扩大可用堆栈的尺寸。
– h+ F; W9 q1 |8 s4 p  [$ p无论何时 Lua 调用 C ，它都只保证 LUA_MINSTACK 这么多的堆栈空间可以使用。 LUA_MINSTACK 一般被定义为 20　，因此，只要你不是不断的把数据压栈，通常你不用关心堆栈大小。
3 1 E/ L6 i! g- e0 ^4 O* Z4 S所有的查询函数都可以接收一个索引，只要这个索引是任何栈提供的空间中的值。栈能提供的最大空间是通过 lua_checkstack 来设置的。这些索引被称作可接受的索引，通常我们把它定义为：
  9 ~) V/ , E6 P5 B, R* m” A     (index < 0 && abs(index) <= top) ||# u- F: ?  X# o. T) a, J% N( 4 G+ t
     (index > 0 && index <= stackspace)3 h+ q0 T’ ]: z; @8 S5 U
注意，0 永远都不是一个可接受的索引。（译注：下文中凡提到的索引，没有特别注明的话，都指可接受的索引。）
( v$ w: Q” b2 R2 y3.3 – 伪索引
‘ L. p! S+ m, D/ j7 v除了特别声明外，任何一个函数都可以接受另一种有效的索引，它们被称作“伪索引”。这个可以帮助 C 代码访问一些并不在栈上的 Lua 值。伪索引被用来访问线程的环境，函数的环境，注册表，还有 C 函数的 upvalue （参见 §3.4）。
% N’ b’ L2 f* Z3 i* H* Y线程的环境（也就是全局变量放的地方）通常在伪索引 LUA_GLOBALSINDEX 处。正在运行的 C 函数的环境则放在伪索引 LUA_ENVIRONINDEX 之处。
  ^* o  i9 s9 w5 H; q你可以用常规的 table 操作来访问和改变全局变量的值，只需要指定环境表的位置。举例而言，要访问全局变量的值，这样做：
% _  j& Y  K+ [3 t” ; K     lua_getfield(L, LUA_GLOBALSINDEX, varname);) w/ i) v+ t4 j* {3 |+ K’ m
3.4 – C Closure/ c+ f* w& h, ]” g
当 C 函数被创建出来，我们有可能会把一些值关联在一起，也就是创建一个 C closure ；这些被关联起来的值被叫做 upvalue ，它们可以在函数被调用的时候访问的到。（参见 lua_pushcclosure）。
” X4 ]” y* n9 c( }无论何时去调用 C 函数，函数的 upvalue 都被放在指定的伪索引处。我们可以用 lua_upvalueindex 这个宏来生成这些伪索引。第一个关联到函数的值放在 lua_upvalueindex(1) 位置处，依次类推。任何情况下都可以用 lua_upvalueindex(n) 产生一个 upvalue 的索引，即使　n 大于实际的 upvalue 数量也可以。它都可以产生一个可接受但不一定有效的索引。 , L3 ~! E6 Q3 w; s6 I
3.5 – 注册表
+ t9 j* d: W2 N8 VLua 提供了一个注册表，这是一个预定义出来的表，可以用来保存任何 C 代码想保存的 Lua 值。这个表可以用伪索引 LUA_REGISTRYINDEX 来定位。任何 C 库都可以在这张表里保存数据，为了防止冲突，你需要特别小心的选择键名。一般的用法是，你可以用一个包含你的库名的字符串做为键名，或者可以取你自己 C 代码中的一个地址，以 light userdata 的形式做键。 ‘ p* y, B0 O( i! K
注册表里的整数健被用于补充库中实现的引用系统的工作，一般说来不要把它们用于别的用途。 % B” q’ R; ]; }8 {/ u6 w5 _4 |9 n
3.6 – C 中的错误处理
‘ L* U# J+ H& _0 X在内部实现中，Lua 使用了 C 的 longjmp 机制来处理错误。（如果你使用 C++ 的话，也可以选择换用异常；参见 luaconf.h 文件。）当 Lua 碰到任何错误（比如内存分配错误、类型错误、语法错误、还有一些运行时错误）它都会产生一个错误出去；也就是调用一个 long jump 。在保护环境下，Lua 使用 setjmp 来设置一个恢复点；任何发生的错误都会激活最近的一个恢复点。
– p( R( b8 c( p: N5 ]2 O7 Z1 t& z3 Z几乎所有的 API 函数都可能产生错误，例如内存分配错误。但下面的一些函数运行在保护环境中（也就是说它们创建了一个保护环境再在其中运行），因此它们不会产生错误出来： lua_newstate, lua_close, lua_load, lua_pcall, and lua_cpcall。
! z3 [6 T3 L- b  l” V在 C 函数里，你也可以通过调用 lua_error 产生一个错误。 6 ?# Y  b3 m( P# W& r
3.7 – 函数和类型; b; h& j+ p. g# k% c: I, Q
在这里我们按字母次序列出了所有 C API 中的函数和类型。
5 E# y* q2 t0 @5 `# t& M________________________________________‘ Z5 r  O/ r) @1 p% U3 e: [  b
lua_Alloc‘ G( ~5 I6 Z5 W! `; e
typedef void * (*lua_Alloc) (void *ud,8 C4 ?6 U- z1 S& _
                             void *ptr,% |$ z- G2 ~1 K’ n& p) G
                             size_t osize,
6 W( L  B4 k  _                             size_t nsize);* l) k1 r$ a7 ~( t, ^’ R
Lua 状态机中使用的内存分配器函数的类型。内存分配函数必须提供一个功能类似于 realloc 但又不完全相同的函数。它的参数有 ud ，一个由 lua_newstate 传给它的指针； ptr ，一个指向已分配出来或是将被重新分配或是要释放的内存块指针； osize ，内存块原来的尺寸； nsize ，新内存块的尺寸。如果且只有 osize 是零时，ptr 为 NULL 。当 nsize 是零，分配器必须manbet网页登录 NULL；如果 osize 不是零，分配器应当释放掉 ptr 指向的内存块。当 nsize 不是零，若分配器不能满足请求时，分配器manbet网页登录 NULL 。当 nsize 不是零而 osize 是零时，分配器应该和 malloc 有相同的行为。当 nsize 和 osize 都不是零时，分配器则应和 realloc 保持一样的行为。 Lua 假设分配器在 osize >= nsize 时永远不会失败。
$ f- k/ b6 P3 P& s& q这里有一个简单的分配器函数的实现。这个实现被放在补充库中，由 luaL_newstate 提供。
; V9 m- o) n, m     static void *l_alloc (void *ud, void *ptr, size_t osize,
) S) W; v; m* v. h( Y2 [‘ [                                                size_t nsize) {2 h  x- ( J  F8 d/ w5 K9 n
       (void)ud;  (void)osize;  /* not used */
) ?/ e, D’ ^& D8 a       if (nsize == 0) {: _! M- {. n8 d’ P9 n; c1 }
         free(ptr);
( p6 r# V/ Y; m5 t9 i# t         return NULL;* Q) s% z. m; t  L
       }4 ?. X- h% ]) D: ~
       else4 w$ _) w; w+ |$ `$ w$ j/ [. P/ ?
         return realloc(ptr, nsize);, t! {7 b& j. o9 p! P
     }
/ v. A( d( J. z8 W% z这段代码假设 free(NULL) 啥也不影响，而且 realloc(NULL, size) 等价于 malloc(size)。这两点是 ANSI C 保证的行为。
0 c1 P; u; l! ~8 k” x________________________________________
) e2 d) {5 x5 D$ q! i! x9 k$ dlua_atpanic‘ @$ Z. m8 j* a! v; Q
lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);( H: e. e, v; ~0 U- n
设置一个新的 panic （恐慌） 函数，并manbet网页登录前一个。
, ~6 I3 |: j6 s- W5 j如果在保护环境之外发生了任何错误， Lua 就会调用一个 panic 函数，接着调用 exit(EXIT_FAILURE)，这样就开始退出宿主程序。你的 panic 函数可以永远不manbet网页登录（例如作一次长跳转）来避免程序退出。
– ~. ]8 V5 , k. ~* [panic 函数可以从栈顶取到出错信息。

lua_call– ~4 n9 O+ H. J, X* D
void lua_call (lua_State *L, int nargs, int nresults);+ I9 A” o- T1 B  v* W2 i( a
调用一个函数。 # |( ?’ : M8 U- `5 x” g% E
要调用一个函数请遵循以下协议：首先，要调用的函数应该被压入堆栈；接着，把需要传递给这个函数的参数按正序压栈；这是指第一个参数首先压栈。最后调用一下 lua_call； nargs 是你压入堆栈的参数个数。当函数调用完毕后，所有的参数以及函数本身都会出栈。而函数的manbet网页登录值这时则被压入堆栈。manbet网页登录值的个数将被调整为 nresults 个，除非 nresults 被设置成 LUA_MULTRET。在这种情况下，所有的manbet网页登录值都被压入堆栈中。 Lua 会保证manbet网页登录值都放入栈空间中。函数manbet网页登录值将按正序压栈（第一个manbet网页登录值首先压栈），因此在调用结束后，最后一个manbet网页登录值将被放在栈顶。 # }% o2 @! I7 q( n. [+ g
被调用函数内发生的错误将（通过 longjmp）一直上抛。
! K& z, B$ o6 Q! ?# |& M$ S1 p下面的例子中，这行 Lua 代码等价于在宿主程序用 C 代码做一些工作： – W’ S  g: @; b; }- V- r  g8 `” M, j
     a = f("how", t.x, 14)
: ]: X, Z1 W0 G+ M( l这里是 C 里的代码：
( p3 W8 z/ t. i+ u; e     lua_getfield(L, LUA_GLOBALSINDEX, "f");          /* 将调用的函数 */4 c# G2 s’ y7 ]8 e7 V( b” l
     lua_pushstring(L, "how");                          /* 第一个参数 */
. T/ T: |# i* Z& r; Q     lua_getfield(L, LUA_GLOBALSINDEX, "t");          /* table 的索引 */% W3 ], N( Y, E0 K! D
     lua_getfield(L, -1, "x");         /* 压入 t.x 的值（第 2 个参数）*/+ ?3 Z& x* d3 |# k6 R, k
     lua_remove(L, -2);                           /* 从堆栈中移去 ‘t’ */
* R# z0 O* O7 I’ q     lua_pushinteger(L, 14);                           /* 第 3 个参数 */
* H” k’ f9 g1 F; w$ ?7 Q       lua_call(L, 3, 1); /* 调用 ‘f’，传入 3 个参数，并索取 1 个manbet网页登录值 */
1 g) m# H) G: n- c+ B. f: Q     lua_setfield(L, LUA_GLOBALSINDEX, "a");      /* 设置全局变量 ‘a’ */  F% b: ?+ R. l8 l” w: j; R/ w’ `
注意上面这段代码是“平衡”的：到了最后，堆栈恢复成原由的配置。这是一种良好的编程习惯。 1 _- g” r) q- v: G4 a$ @3 S5 L
________________________________________
) K# I: R! C, Flua_CFunction
7 J; ?& q1 o( b4 ]+ ^9 Ntypedef int (*lua_CFunction) (lua_State *L);
! F1 h7 b’ w, L’ ]8 m0 RC 函数的类型。
5 A% {( {& Z. ?/ L为了正确的和 Lua 通讯，C 函数必须使用下列定义了参数以及manbet网页登录值传递方法的协议： C 函数通过 Lua 中的堆栈来接受参数，参数以正序入栈（第一个参数首先入栈）。因此，当函数开始的时候， lua_gettop(L) 可以manbet网页登录函数收到的参数个数。第一个参数（如果有的话）在索引 1 的地方，而最后一个参数在索引 lua_gettop(L) 处。当需要向 Lua manbet网页登录值的时候，C 函数只需要把它们以正序压到堆栈上（第一个manbet网页登录值最先压入），然后manbet网页登录这些manbet网页登录值的个数。在这些manbet网页登录值之下的，堆栈上的东西都会被 Lua 丢掉。和 Lua 函数一样，从 Lua 中调用 C 函数也可以有很多manbet网页登录值。
  X, W( ?7 k. w” ?* F下面这个例子中的函数将接收若干数字参数，并manbet网页登录它们的平均数与和：
0 a8 Y7 d# k, w( c- {     static int foo (lua_State *L) {
* j0 b. N1 i$ U- v” ]2 I       int n = lua_gettop(L);    /* 参数的个数 */
5 j7 l6 b6 ^* C: _; r       lua_Number sum = 0;
; p/ ^” k, s* H  k( ?2 N5 F7 t’ }       int i;– m$ Z9 I) D. _% v* J2 F/ l8 z
       for (i = 1; i <= n; i++) {: g8 x6 t9 L’ {2 H7 N. F4 j. r
         if (!lua_isnumber(L, i)) {& O* g8 v+ J% f9 U5 v4 ^0 ^
           lua_pushstring(L, "incorrect argument");9 B  O2 o& K! j% s* n7 C( O) I
           lua_error(L);$ C6 w+ @* G2 g0 H
         }) e&   c, S# u7 s
         sum += lua_tonumber(L, i);% K0 g9 a# E+ x8 M: H
       }0 N) `+ C1 F) _; s9 Z
       lua_pushnumber(L, sum/n);   /* 第一个manbet网页登录值 */; s! J: X9 ]! m
       lua_pushnumber(L, sum);     /* 第二个manbet网页登录值 */1 @0 T) C” p# |. t* [+ m
       return 2;                   /* manbet网页登录值的个数 */) s3 `3 [‘ `8 M6 a3 k5 j
     }
  F4 m. j. M+ f( ]: h________________________________________, u’ g) ^0 y# H’ c
lua_checkstack
. C7 {, b” D7 ?4 N! Qint lua_checkstack (lua_State *L, int extra);
. ]3 Y9 o1 @: Z, x6 J) e确保堆栈上至少有 extra 个空位。如果不能把堆栈扩展到相应的尺寸，函数manbet网页登录 false 。这个函数永远不会缩小堆栈；如果堆栈已经比需要的大了，那么就放在那里不会产生变化。 5 O1 R7 W$ W) P% a; a
________________________________________
3 n9 v6 f# f  lua_close
* h  U5 S. i: `void lua_close (lua_State *L);
& v$ [( F( L5 s; _销毁指定 Lua 状态机中的所有对象（如果有垃圾收集相关的元方法的话，会调用它们），并且释放状态机中使用的所有动态内存。在一些平台上，你可以不必调用这个函数，因为当宿主程序结束的时候，所有的资源就自然被释放掉了。另一方面，长期运行的程序，比如一个后台程序或是一个 web 服务器，当不再需要它们的时候就应该释放掉相关状态机。这样可以避免状态机扩张的过大。 3 m4 X1 Y+ g$ Y* a* D- p# |; ~# o& W
________________________________________/ M- l7 [( f5 Q; w6 F
lua_concat; O” n( {% E/ J$ s8 G: s’ r# 7 C
void lua_concat (lua_State *L, int n);8 F7 k8 L” O6 V- v* n1 r/ v” v* |  P
连接栈顶的 n 个值，然后将这些值出栈，并把结果放在栈顶。如果 n 为 1 ，结果就是一个字符串放在栈上（即，函数什么都不做）；如果 n 为 0 ，结果是一个空串。 连接依照 Lua 中创建语义完成（参见 §2.5.4 ）。 6 M& B) a8 O0 @
________________________________________4 w0 Z+ q% j# g0 G# M
lua_cpcall8 U5 g& B2 c9 M) s
int lua_cpcall (lua_State *L, lua_CFunction func, void *ud);/ B. a% f. p  q( M/ B. _
以保护模式调用 C 函数 func 。 func 只有能从堆栈上拿到一个参数，就是包含有 ud 的 light userdata。当有错误时， lua_cpcall manbet网页登录和 lua_pcall 相同的错误代码，并在栈顶留下错误对象；否则它manbet网页登录零，并不会修改堆栈。所有从 func 内manbet网页登录的值都会被扔掉。 4 q4 Y5 x7 ], E3 e8 q% ?: y) C/ A
________________________________________
# {+ O; x% o4 x2 c* Plua_createtable
. E  @& R” ]0 d- c$ ovoid lua_createtable (lua_State *L, int narr, int nrec);
% @- L$ d’ y& g/ d6 ?创建一个新的空 table 压入堆栈。这个新 table 将被预分配 narr 个元素的数组空间以及 nrec 个元素的非数组空间。当你明确知道表中需要多少个元素时，预分配就非常有用。如果你不知道，可以使用函数 lua_newtable。 $ N8 B: d: g8 O2 I0 {
________________________________________
) b6 J$ g& t3 ?5 e: b+ Clua_dump+ j$ u( w( f- w
int lua_dump (lua_State *L, lua_Writer writer, void *data);
– j’ u1 o/ ‘ c1 B/ ~” I! f把函数 dump 成二进制 chunk 。函数接收栈顶的 Lua 函数做参数，然后生成它的二进制 chunk 。若被 dump 出来的东西被再次加载，加载的结果就相当于原来的函数。当它在产生 chunk 的时候，lua_dump 通过调用函数 writer （参见 lua_Writer）来写入数据，后面的 data 参数会被传入 writer 。 : d3 [1 J+ D* n. ^7 R
最后一次由写入器 (writer) manbet网页登录值将作为这个函数的manbet网页登录值manbet网页登录； 0 表示没有错误。 7 W) |- t- X5 ‘ q) `
这个函数不会把 Lua manbet网页登录弹出堆栈。 . W’ Z1 W4 f’ }; u, Y+ U
________________________________________+ w1 [& ~# I2 c7 j’ j: L# _
lua_equal
4 p’ A. s7 v# T( Y( int lua_equal (lua_State *L, int index1, int index2);+ l- # P8 k5 , O$ K0 q
如果依照 Lua 中 == 操作符语义，索引 index1 和 index2 中的值相同的话，manbet网页登录 1 。否则manbet网页登录 0 。如果任何一个索引无效也会manbet网页登录 0。
( q* p% V! |% V1 C: H________________________________________‘ e, n; ^; ?” Y1 i/ S  B
lua_error
4 i+ N’ s* @( ^8 |! {” Y. Uint lua_error (lua_State *L);
: V& B& l+ f4 x6 S0 Y* }6 L产生一个 Lua 错误。错误信息（实际上可以是任何类型的 Lua 值）必须被置入栈顶。这个函数会做一次长跳转，因此它不会再manbet网页登录。（参见 luaL_error）。
; N9 P9 R. ]% R7 J1 y/ e6 I6 b________________________________________6 W8 h0 K& N+ P
lua_gc8 G8 b: q” q1 e0 |( m% X) }# L
int lua_gc (lua_State *L, int what, int data);; a0 i3 $ i# c# y1 F
控制垃圾收集器。
% O’ h. c- X% `0 x这个函数根据其参数 what 发起几种不同的任务：
8 Y7 z6 _! t& P?        LUA_GCSTOP: 停止垃圾收集器。
, R! C, n- I1 e5 |6 a’ c* b?        LUA_GCRESTART: 重启垃圾收集器。
3 v7 p3 h3 J: ~7 S?        LUA_GCCOLLECT: 发起一次完整的垃圾收集循环。
; }+ G$ K” R  J3 B?        LUA_GCCOUNT: manbet网页登录 Lua 使用的内存总量（以 K 字节为单位）。
0 h” [  A( ) N, v/ R) w- b) _?        LUA_GCCOUNTB: manbet网页登录当前内存使用量除以 1024 的余数。 & Q) h2 y  X( c+ Z0 E
?        LUA_GCSTEP: 发起一步增量垃圾收集。步数由 data 控制（越大的值意味着越多步），而其具体含义（具体数字表示了多少）并未标准化。如果你想控制这个步数，必须实验性的测试 data 的值。如果这一步结束了一个垃圾收集周期，manbet网页登录manbet网页登录 1 。 2 d2 P$ X2 f. o% G) B; K4 a
?        LUA_GCSETPAUSE: 把 data/100 设置为 garbage-collector pause 的新值（参见 §2.10）。函数manbet网页登录以前的值。 ; J3 W6 G! C3 @
?        LUA_GCSETSTEPMUL: 把 arg/100 设置成 step multiplier （参见 §2.10）。函数manbet网页登录以前的值。 % F9 ?5 u; j: |0 b9 A( W+ Y
________________________________________
, M1 H+ _. @4 L+ Hlua_getallocf
0 R% w( B- {4 @2 V$ e1 }lua_Alloc lua_getallocf (lua_State *L, void **ud);
2 m. E) T( E7 K+ W7 [2 L” V7 Jmanbet网页登录给定状态机的内存分配器函数。如果 ud 不是 NULL ，Lua 把调用 lua_newstate 时传入的那个指针放入 *ud 。 ; ?# l7 q/ X8 t! X
________________________________________+ p% K9 R/ F5 _
lua_getfenv7 h9 s9 N! {( n
void lua_getfenv (lua_State *L, int index);
( c9 L$ R) e( V2 r把索引处值的环境表压入堆栈。
2 I6 ^/ m$ o! q! p! w9 e5 P________________________________________
) M( |& u3 V$ G1 |7 T’ W2 ]3 lua_getfield5 H1 X. _: A/ J6 D’ r
void lua_getfield (lua_State *L, int index, const char *k);8 d1 W! N5 S$ x3 @
把 t[k] 值压入堆栈，这里的 t 是指有效索引 index 指向的值。在 Lua 中，这个函数可能触发对应 "index" 事件的元方法（参见 §2.8）。 # ~3 E7 l& |! w7 @
________________________________________
% C0 H! M- G2 M; h/ x0 Alua_getglobal! ?& J! u; |4 @7 I+ f: H
void lua_getglobal (lua_State *L, const char *name);% L, q7 L! l( ?+ {
把全局变量 name 里的值压入堆栈。这个是用一个宏定义出来的： 4 Q4 R$ e” * |* b7 K
     #define lua_getglobal(L,s)  lua_getfield(L, LUA_GLOBALSINDEX, s)  r: L$ s) u1 I5 a
________________________________________; d+ x8 [7 ^6 J% M$ `7 Q7 X2 {
lua_getmetatable% H; V# v: Z1 c# l! Q
int lua_getmetatable (lua_State *L, int index);% K8 @- w9 [/ Y’ U7 n4 H
把给定索引指向的值的元表压入堆栈。如果索引无效，或是这个值没有元表，函数将manbet网页登录 0 并且不会向栈上压任何东西。 – F+ Z% L9 ?; q9 w: b: }
________________________________________
! E0 o6 R8 A8 e) Y: Tlua_gettable
/ |7 z, M! o% [void lua_gettable (lua_State *L, int index);
+ t6 a- O’ h1 h) g把 t[k] 值压入堆栈，这里的 t 是指有效索引 index 指向的值，而 k 则是栈顶放的值。 4 S- B% m8 s: _8 e
这个函数会弹出堆栈上的 key （把结果放在栈上相同位置）。在 Lua 中，这个函数可能触发对应 "index" 事件的元方法（参见 §2.8）。 – i5 I7 J; O8 s
________________________________________& b, v” P- @’ s) [+ S
lua_gettop2 F2 k8 u  n: E* b$ i. I
int lua_gettop (lua_State *L);
. g7 F; ]% i( h2 Z) xmanbet网页登录栈顶元素的索引。因为索引是从 1 开始编号的，所以这个结果等于堆栈上的元素个数（因此manbet网页登录 0 表示堆栈为空）。 6 J0 {* C” . M  e) i% {
________________________________________
  `# S+ y8 `5 }( Jlua_insert# q, a” A( A7 ^8 _
void lua_insert (lua_State *L, int index);
% @- b8 p/ k3 ~3 H6 E9 c5 g把栈顶元素插入指定的有效索引处，并依次移动这个索引之上的元素。不要用伪索引来调用这个函数，因为伪索引不是真正指向堆栈上的位置。
2 i7 G5 [) t’ V6 B* G! o” Y6 i( A________________________________________
. A! s, a4 R3 Llua_Integer
) M( b- H, G7 R) E, [! btypedef ptrdiff_t lua_Integer;” L” k) g7 L- ?  T+ y; `& F
这个类型被用于 Lua API 接收整数值。 , g8 C3 f3 y7 v, K
缺省时这个被定义为 ptrdiff_t ，这个东西通常是机器能处理的最大整数类型。 6 A7 S# B6 C! ]3 i2 J( r- Y+ ~: y
________________________________________
# a; g* 9 l) jlua_isboolean4 ^: [5 N0 J! N  l- S” x! [
int lua_isboolean (lua_State *L, int index);7 O3 w! R2 a7 ?
当给定索引的值类型为 boolean 时，manbet网页登录 1 ，否则manbet网页登录 0 。 % J, T) S2 V- ]7 g3 D! I/ @
________________________________________, ?* p’ @* p/ n’ s) C& I  S1 Y) ?
lua_iscfunction
# B: S1 f) F! s5 T9 ^” oint lua_iscfunction (lua_State *L, int index);
* d* O4 N1 A* L: X( a& x* w; N/ G+ C3 h当给定索引的值是一个 C 函数时，manbet网页登录 1 ，否则manbet网页登录 0 。 1 t6 F+ N9 t# }
________________________________________) Q+ I9 t: O+ d
lua_isfunction
; ^0 K) y5 C3 b$ Uint lua_isfunction (lua_State *L, int index);– i# J$ W& , d! h  v& ~
当给定索引的值是一个函数（ C 或 Lua 函数均可）时，manbet网页登录 1 ，否则manbet网页登录 0 。
” A’ F$ k) `; P# f- {- Y________________________________________
$ V4 F5 Q# u” c# p  q1 Dlua_islightuserdata7 E. ?’ w1 F/ m
int lua_islightuserdata (lua_State *L, int index);
! N7 T* u5 b, g% V1 d4 I* s8 s当给定索引的值是一个 light userdata 时，manbet网页登录 1 ，否则manbet网页登录 0 。 ) M* ]& 7 ^0 p3 ]+ c’ m* a( P” z
________________________________________
2 V’ U+ m/ ?& o7 N” ^lua_isnil5 I% |1 [* {& ! S1 {- @; R1 Q, p
int lua_isnil (lua_State *L, int index);
+ X5 C- [6 I7 i$ M) z4 P当给定索引的值是 nil 时，manbet网页登录 1 ，否则manbet网页登录 0 。
  [6 B5 n4 M9 y+ A1 K* P% @$ J________________________________________
8 |! C& M# R, o6 l5 jlua_isnumber‘ a7 W9 u$ F” p2 `  ~0 P+ F: f
int lua_isnumber (lua_State *L, int index);
  F& R” I) v) h7 _” O当给定索引的值是一个数字，或是一个可转换为数字的字符串时，manbet网页登录 1 ，否则manbet网页登录 0 。
4 A! p, d: x* p’ I” ?________________________________________# * u4 Q- ]0 @3 T. S
lua_isstring/ U* B) S5 ~: C
int lua_isstring (lua_State *L, int index);
” J* D2 C# u/ l( x# p2 b当给定索引的值是一个字符串或是一个数字（数字总能转换成字符串）时，manbet网页登录 1 ，否则manbet网页登录 0 。 * u+ O6 N: {” M! ?; {/ e3 A
________________________________________# E  p: F” F* w” R
lua_istable5 m5 o’ }4 H- H” B1 S( [
int lua_istable (lua_State *L, int index);
4 {+ c2 P- x, A” R6 E当给定索引的值是一个 table 时，manbet网页登录 1 ，否则manbet网页登录 0 。
1 l6 ~* }- ^” d________________________________________‘ f* e, h, M# R  X( |) P! ^’ U0 |
lua_isthread5 W% q, Y: A6 a7 Q
int lua_isthread (lua_State *L, int index);9 Z6 m4 N3 X9 W3 A& H
当给定索引的值是一个 thread 时，manbet网页登录 1 ，否则manbet网页登录 0 。 & g4 `1 7 d- ~% _4 S
________________________________________
” X+ D8 E5 k! T7 G+ G* L! F% Clua_isuserdata2 B0 e* p( F( h1 R- M
int lua_isuserdata (lua_State *L, int index);7 S+ B  v( [‘ f’ Z# e3 h, d$ N
当给定索引的值是一个 userdata （无论是完整的 userdata 还是 light userdata ）时，manbet网页登录 1 ，否则manbet网页登录 0 。 ” E, i8 n2 K# e6 N2 t8 Y0 n
________________________________________! ?0 i0 ^( H- Z% K5 U7 p: c” e3 M5 U
lua_lessthan
* T7 A9 ~; t’ g  V8 n. i1 I* S2 ~int lua_lessthan (lua_State *L, int index1, int index2);6 W9 l% `” s4 c2 T7 g/ P
如果索引 index1 处的值小于索引 index2 处的值时，manbet网页登录 1 ；否则manbet网页登录 0 。其语义遵循 Lua 中的 < 操作符（就是说，有可能调用元方法）。如果任何一个索引无效，也会manbet网页登录 0 。
/ W8 V3 X4 y; n0 w  I2 C9 i________________________________________
) l7 P) i  T’ T! l& alua_load
! V: m9 v9 ?5 Z# U3 O% P/ e’ Aint lua_load (lua_State *L,+ Q/ K3 q. n6 M9 K/ s7 N7 P& p& x
              lua_Reader reader,
9 _! v, F7 u5 r’ Y” {& {              void *data,; b+ q5 `( V+ p  J$ P
              const char *chunkname);! u9 A- w, d. D
加载一个 Lua chunk 。如果没有错误， lua_load 把一个编译好的 chunk 作为一个 Lua 函数压入堆栈。否则，压入出错信息。 lua_load 的manbet网页登录值可以是：
* Z5 U: |9 _” D8 R?        0: 没有错误； 0 w6 w% z5 z  l* f
?        LUA_ERRSYNTAX: 在预编译时碰到语法错误；
0 m# v* I5 }/ Y# r0 p?        LUA_ERRMEM: 内存分配错误。 # r( U; h: f! {7 }
这个函数仅仅加栽 chunk ；而不会去运行它。
6 m9 A$ t9 I) b0 K9 ]0 m( V( L, d& slua_load 会自动检测 chunk 是文本的还是二进制的，然后做对应的加载操作（参见程序 luac）。
7 _1 R4 k$ x( Y2 ^/ x% llua_load 函数使用一个用户提供的 reader 函数来读取 chunk （参见 lua_Reader）。 data 参数会被传入读取器函数。 + j9 S7 }& o$ {- X  S7 ]
chunkname 这个参数可以赋予 chunk 一个名字，这个名字被用于出错信息和调试信息（参见 §3.8）。
9 k2 _4 7 v7 m: J3 W7 @________________________________________
* c- V$ B& x3 O7 f$ ]lua_newstate
% I4 A. _/ d8 ^3 K5 Nlua_State *lua_newstate (lua_Alloc f, void *ud);6 R” w, Z/ s# X2 A+ R
创建的一个新的独立的状态机。如果创建不了（因为内存问题）manbet网页登录 NULL 。参数 f 是一个分配器函数； Lua 将通过这个函数做状态机内所有的内存分配操作。第二个参数 ud ，这个指针将在每次调用分配器时被直接传入。 ( F) V- ]  P- m3 v6 U+ Y5 t
________________________________________! T% X1 ^. l’ S) [
lua_newtable3 t7 W5 }( g* J9 @# ]; V  B” I) J’ W$ K* C
void lua_newtable (lua_State *L);/ [1 T( K1 M) q) D6 I: S5 R
创建一个空 table ，并将之压入堆栈。它等价于 lua_createtable(L, 0, 0) 。 3 C; |0 I9 ~6 V% {, A0 [
________________________________________# w8 B5 q; g8 O  d
lua_newthread
: P$ f5 ^& I$ L7 x. T% Flua_State *lua_newthread (lua_State *L);4 m+ S- _5 R* `% # H! L$ x
创建一个新线程，并将其压入堆栈，并manbet网页登录维护这个线程的 lua_State 指针。这个函数manbet网页登录的新状态机共享原有状态机中的所有对象（比如一些 table），但是它有独立的执行堆栈。
# S- M5 v6 i5 q1 v# N1 a0 O+ a没有显式的函数可以用来关闭或销毁掉一个线程。线程跟其它 Lua 对象一样是垃圾收集的条目之一。
* r, j) L3 n8 |9 W. b# U* r% J________________________________________  u! x. T* Q& d! P’ v) |:
lua_newuserdata8 ]  W! G& v$ F* P! M( x” i6 ^
void *lua_newuserdata (lua_State *L, size_t size);
, N4 C+ h, T$ R( l# X- C7 s# T这个函数分配分配一块指定大小的内存块，把内存块地址作为一个完整的 userdata 压入堆栈，并manbet网页登录这个地址。 ” z# Q2 c- D5 |# F
userdata 代表 Lua 中的 C 值。完整的 userdata 代表一块内存。它是一个对象（就像 table 那样的对象）：你必须创建它，它有着自己的元表，而且它在被回收时，可以被监测到。一个完整的 userdata 只和它自己相等（在等于的原生作用下）。 % b# X+ W6 e& H0 s3 F  q
当 Lua 通过 gc 元方法回收一个完整的 userdata 时， Lua 调用这个元方法并把 userdata 标记为已终止。等到这个 userdata 再次被收集的时候，Lua 会释放掉相关的内存。
” Z9 `, Y8 X+ m. U# T- n________________________________________7 c8 x2 Z6 9 P  n/ M7 p’ q
lua_next
$ ]1 & `$ j$ S/ r6 r$ int lua_next (lua_State *L, int index);2 q; d9 z: Y: q
从栈上弹出一个 key（键），然后把索引指定的表中 key-value（健值）对压入堆栈（指定 key 后面的下一 (next) 对）。如果表中以无更多元素，那么 lua_next 将manbet网页登录 0 （什么也不压入堆栈）。
; k& V. Z% G7 y9 `典型的遍历方法是这样的：
4 y7 A$ z9 c/ l4 m     /* table 放在索引 ‘t’ 处 */
” l: X! u+ @* k     lua_pushnil(L);  /* 第一个 key */5 H5 ~” l5 R3 u’ i: W1 s
     while (lua_next(L, t) != 0) {% T. |/ Q8 ^0 ]9 r7 O6 f6 k) q  N
       /* 用一下 ‘key’ （在索引 -2 处） 和 ‘value’ （在索引 -1 处） */
” ?7 A0 l$ D4 s: W- b2 _       printf("%s – %sn",
0 , f; J, w4 k8 |              lua_typename(L, lua_type(L, -2)),$ q$ n* y  N% D0 R, S+ A
              lua_typename(L, lua_type(L, -1)));; X6 Z( f” N3 X+ l
       /* 移除 ‘value’ ；保留 ‘key’ 做下一次叠代 */
+ A1 c6 p% m- R, m       lua_pop(L, 1);
* N8 P/ y9 @’ i5 P1 E3 e     }! u9 N+ C5 u7 X3 U6 @* z) U
在遍历一张表的时候，不要直接对 key 调用 lua_tolstring ，除非你知道这个 key 一定是一个字符串。调用 lua_tolstring 有可能改变给定索引位置的值；这会对下一次调用 lua_next 造成影响。$ g  c6 ?% {9 {3 J: I- K% A
lua_Number
& O1 m’ n8 n7 u8 ?0 L0 Rtypedef double lua_Number;
” t2 {% M! h- D0 C: }4 W0 R# ULua 中数字的类型。确省是 double ，但是你可以在 luaconf.h 中修改它。
$ v9 U4 M! P% |) C+ }0 k通过修改配置文件你可以改变 Lua 让它操作其它数字类型（例如：float 或是 long ）。 * ! |% k. r” N$ c0 P
________________________________________
7 T& b7 z  U: f. {( A. ~2 [lua_objlen
0 G) j& s4 V% b  V/ ^size_t lua_objlen (lua_State *L, int index);1 c& p* G. W) O8 |4 P7 d$ ~2 m
manbet网页登录指定的索引处的值的长度。对于 string ，那就是字符串的长度；对于 table ，是取长度操作符 (‘#’) 的结果；对于 userdata ，就是为其分配的内存块的尺寸；对于其它值，为 0 。 8 M  S+ o3 y( S! _
________________________________________
4 S3 d# G# z3 V! g. _+ s2 l% q3 Wlua_pcall# m  {‘ X; [( B; y2 `’ W
lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);
% M5 C5 G& H1 ?1 Z3 q以保护模式调用一个函数。 0 ” v7 # }. v
nargs 和 nresults 的含义与 lua_call 中的相同。如果在调用过程中没有发生错误， lua_pcall 的行为和 lua_call 完全一致。但是，如果有错误发生的话， lua_pcall 会捕获它，然后把单一的值（错误信息）压入堆栈，然后manbet网页登录错误码。同 lua_call 一样， lua_pcall 总是把函数本身和它的参数从栈上移除。 # J4 r” P8 M  i8 O2 ]6 o; R
如果 errfunc 是 0 ，manbet网页登录在栈顶的错误信息就和原始错误信息完全一致。否则，errfunc 就被当成是错误处理函数在栈上的索引。（在当前的实现里，这个索引不能是伪索引。）在发生运行时错误时，这个函数会被调用而参数就是错误信息。错误处理函数的manbet网页登录值将被 lua_pcall 作为出错信息manbet网页登录在堆栈上。
) X: E! B  f, Z; k典型的用法中，错误处理函数被用来在出错信息上加上更多的调试信息，比如栈跟踪信息 (stack traceback) 。这些信息在 lua_pcall manbet网页登录后，因为栈已经展开 (unwound) ，所以收集不到了。 ” e2 d/ N( y7 f! M
lua_pcall 函数在调用成功时manbet网页登录 0 ，否则manbet网页登录以下（定义在 lua.h 中的）错误代码中的一个：
3 S( F6 l7 a7 ^5 F# X& J” q& }+ J- j?        LUA_ERRRUN: 运行时错误。
1 a, s5 @- K$ U: z5 N2 R?        LUA_ERRMEM: 内存分配错误。对于这种错，Lua 调用不了错误处理函数。
( P* E* E& b9 l?        LUA_ERRERR: 在运行错误处理函数时发生的错误。
– U* d2 r- Q) m0 O! d________________________________________
0 c( K0 Q: Z” f& Blua_pop
4 y: v& o/ ]3 v0 R  x& lvoid lua_pop (lua_State *L, int n);
5 e! A- ?& }3 b5 s从堆栈中弹出 n 个元素。
: Q: Y& O4 C& c________________________________________* C4 l% ^9 S+ I) ~6 X; _
lua_pushboolean$ }# M5 o0 t’ p  U
void lua_pushboolean (lua_State *L, int b);# P: {# m  |8 d% j& ]’ _! {
把 b 作为一个 boolean 值压入堆栈。 / {4 P. h) `. R* h
________________________________________0 U( X) ]: @3 [7 d4 ?) H* q
lua_pushcclosure
” @7 p; F& ; C0 x3 e: C5 Gvoid lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);6 p9 L$ o! j9 D( U& O2 y
把一个新的 C closure 压入堆栈。
* ]8 Q0 I. j; I7 q” & c当创建了一个 C 函数后，你可以给它关联一些值，这样就是在创建一个 C closure （参见 §3.4）；接下来无论函数何时被调用，这些值都可以被这个函数访问到。为了将一些值关联到一个 C 函数上，首先这些值需要先被压入堆栈（如果有多个值，第一个先压）。接下来调用 lua_pushcclosure 来创建出 closure 并把这个 C 函数压到堆栈上。参数 n 告之函数有多少个值需要关联到函数上。 lua_pushcclosure 也会把这些值从栈上弹出。
$ D. M8 C1 L! G  t& e________________________________________
) y0 H5 i% @) |3 alua_pushcfunction
# w4 o% R6 A9 1 U) m9 Mvoid lua_pushcfunction (lua_State *L, lua_CFunction f);8 l+ n4 R8 C. J
将一个 C 函数压入堆栈。这个函数接收一个 C 函数指针，并将一个类型为 function 的 Lua 值压入堆栈。当这个栈定的值被调用时，将触发对应的 C 函数。
; p  z, y7 `% i% A/ a5 [  J$ R7 }注册到 Lua 中的任何函数都必须遵循正确的协议来接收参数和manbet网页登录值（参见 lua_CFunction）。 4 [6 P! ?6 F’ H$ N3 F5 Q
lua_pushcfunction 是作为一个宏定义出现的： % C+ m5 a& h9 S! K
     #define lua_pushcfunction(L,f)  lua_pushcclosure(L,f,0)2 H+ y# d8 z, d! Y+ O
________________________________________
  V4 d- p3 x+ D” H! L5 V: `lua_pushfstring$ H$ |  K/ H8 n1 ^3 @: o” i% G( A’ V
const char *lua_pushfstring (lua_State *L, const char *fmt, …);5 c6 L0 s8 v4 V9 T’ `% ^
把一个格式化过的字符串压入堆栈，然后manbet网页登录这个字符串的指针。它和 C 函数 sprintf 比较像，不过有一些重要的区别：
– k9 f& }’ n1 {1 q% `?        摸你需要为结果分配空间：其结果是一个 Lua 字符串，由 Lua 来关心其内存分配（同时通过垃圾收集来释放内存）。
. f8 v5 o* o9 R2 ?” w% o5 ??        这个转换非常的受限。不支持 flag ，宽度，或是指定精度。它只支持下面这些： ‘%%’ （插入一个 ‘%’）， ‘%s’ （插入一个带零终止符的字符串，没有长度限制）， ‘%f’ （插入一个 lua_Number）， ‘%p’ （插入一个指针或是一个十六进制数）， ‘%d’ （插入一个 int)， ‘%c’ （把一个 int 作为一个字符插入）。 & e  u$ l8 E9 y$ a) X. Y9 C
________________________________________
6 i; j1 S& r. }% ~: j8 vlua_pushinteger
0 b: b& h” I& X/ J” d8 v. tvoid lua_pushinteger (lua_State *L, lua_Integer n);2 g: e6 Z/ W) @( p6 d% Z
把 n 作为一个数字压栈。 9 H: ]’ O& }$ O0 L/ ~! U& w
________________________________________7 H- I5 I# i  / {  F
lua_pushlightuserdata– [) }( X’ f6 t4 i$ S
void lua_pushlightuserdata (lua_State *L, void *p);
% ]8 T, m5 l’ h  X; t把一个 light userdata 压栈。 6 w. T; Q) t& `7 U, G
userdata 在 Lua 中表示一个 C 值。 light userdata 表示一个指针。它是一个像数字一样的值：你不需要专门创建它，它也没有独立的 metatable ，而且也不会被收集（因为从来不需要创建）。只要表示的 C 地址相同，两个 light userdata 就相等。
9 c6 X; g- j  [‘ Q________________________________________9 r# e: R’ r: v% p: t+ A- x. U
lua_pushlstring
% I, Y* f) m( I. J& O# a. V) n8 }: A0 gvoid lua_pushlstring (lua_State *L, const char *s, size_t len);3 s0 a3 _4 b# V- a, _7 r
把指针 s 指向的长度为 len 的字符串压栈。 Lua 对这个字符串做一次内存拷贝（或是复用一个拷贝），因此 s 处的内存在函数manbet网页登录后，可以释放掉或是重用于其它用途。字符串内可以保存有零字符。
6 {& Z& i8 ^* f________________________________________
) p+ Q6 E& S’ n  dlua_pushnil
* . X6 w’ o( X5 ?void lua_pushnil (lua_State *L);
5 z” E7 ~3 [# J% V/ S+ G& `; o. o把一个 nil 压栈。 6 @# I5 w, V
________________________________________  }) ?; y5 ^’ Q4 [1 r
lua_pushnumber
8 s7 `* E( k& O/ C  _void lua_pushnumber (lua_State *L, lua_Number n);# s6 B7 t/ u; w+ @
把一个数字 n 压栈。
7 n: Z* j0 ?6 U1 T________________________________________: X) N% Z# ?: P) j  K  a
lua_pushstring
7 e” B6 P( Q) L) K3 b” C8 Xvoid lua_pushstring (lua_State *L, const char *s);4 S+ N, K1 ~- T  q
把指针 s 指向的以零结尾的字符串压栈。 Lua 对这个字符串做一次内存拷贝（或是复用一个拷贝），因此 s 处的内存在函数manbet网页登录后，可以释放掉或是重用于其它用途。字符串中不能包含有零字符；第一个碰到的零字符会认为是字符串的结束。
) ^2 S& {) Y1 ]________________________________________
– |+ T6 H% 5 F2 h0 J4 Tlua_pushthread( f- M’ m) E6 d( Y1 F
int lua_pushthread (lua_State *L);! ]5 d. F; b2 a/ a
把 L 中提供的线程压栈。如果这个线程是当前状态机的主线程的话，manbet网页登录 1 。
! W) |0 P  `! J3 N- Z________________________________________
5 D  n& {5 e, b+ y+ h. [lua_pushvalue2 z. `! D& L0 Z6 J4 s  V( n
void lua_pushvalue (lua_State *L, int index);
5 w: j6 q/ ?& t9 M/ L, g把堆栈上给定有效处索引处的元素作一个拷贝压栈。
% [+ S8 I# {! V* k! F  A’ z________________________________________0 p: k* v  V% H. Z2 h# F$ y7 n’ a: W
lua_pushvfstring2 ?% H% Q! E6 `; j6 x
const char *lua_pushvfstring (lua_State *L,2 Y. o5 ]. ~( l2 ~4 [% o
                              const char *fmt,/ {/ w& q. K* Z
                              va_list argp);* [- s$ Q6 d; ]8 L
等价于 lua_pushfstring，不过是用 va_list 接收参数，而不是用可变数量的实际参数。 # ]/ n; X” f6 A$ i9 A+ o
________________________________________
* h- T: }! : P( Ilua_rawequal% A0 i4 W’ [4 Q9 f/ G0 p
int lua_rawequal (lua_State *L, int index1, int index2);
7 T4 }+ l( A8 c0 i- z如果两个索引 index1 和 index2 处的值简单地相等（不调用元方法）则manbet网页登录 1 。否则manbet网页登录 0 。如果任何一个索引无效也manbet网页登录 0 。
, P: O’ z! ]5 s4 ?) E( ” a________________________________________
0 z8 i  p  ?0 m# ylua_rawget
8 y8 U, D- u” w’ Kvoid lua_rawget (lua_State *L, int index);
7 c- g& i6 g+ x. u类似于 lua_gettable，但是作一次直接访问（不触发元方法）。
6 ?) A/ G6 r/ g0 g________________________________________* % K! [2 B; q3 R’ S0 l, [; B9 }
lua_rawgeti( j: H) P0 o) `( K
void lua_rawgeti (lua_State *L, int index, int n);+ ^6 B; J” h/ $ }/ I
把 t[n] 的值压栈，这里的 t 是指给定索引 index 处的一个值。这是一个直接访问；就是说，它不会触发元方法。
. [! V5 H  B1 @8 `; [5 p# o5 W________________________________________
/ S, h” o8 F+ U6 D3 g5 plua_rawset% `1 v7 h2 X’ G( [+ m
void lua_rawset (lua_State *L, int index);$ G0 C8 v+ i$ e9 ?
类似于 lua_settable，但是是作一个直接赋值（不触发元方法）。
3 u1 Z$ ~3 j( t0 H) O/ p4 S________________________________________
/ v6 H’ ^” O7 q, Z( O# Z7 Ylua_rawseti
* a2 ?’ `: s. W5 Bvoid lua_rawseti (lua_State *L, int index, int n);
; k* ~” {, J/ u+ p等价于 t[n] = v，这里的 t 是指给定索引 index 处的一个值，而 v 是栈定的值。
6 ~# L1 m7 S. G) H+ }- [0 D9 j函数将把这个值弹出栈。赋值操作是直接的；就是说，不会触发元方法。
‘ ?& x) A2 }6 D* U% K________________________________________8 g7 M; @2 A  k5 ^’ d) a* m8 o0 H
lua_Reader
2 j! D9 m+ t4 o3 I+ _typedef const char * (*lua_Reader) (lua_State *L,, H1 j6 G8 Y- q/ d’ m% ?
                                    void *data,
2 L3 @” O: B$ V4 + s/ D                                    size_t *size);
) ?* f# N: Y% i’ k& j6 V& }; zlua_load 用到的读取器函数，每次它需要一块新的 chunk 的时候， lua_load 就调用读取器，每次都会传入一个参数 data 。读取器需要manbet网页登录含有新的 chunk 的一块内存的指针，并把 size 设为这块内存的大小。内存块必须在下一次函数被调用之前一直存在。读取器可以通过manbet网页登录一个 NULL 来指示 chunk 结束。读取器可能manbet网页登录多个块，每个块可以有任意的大于零的尺寸。 8 g” k1 z’ V  I- G( [4 a! p
________________________________________
( H  z9 D5 v) ?& G( w2 Blua_register
. d8 k+ @” X! g: zvoid lua_register (lua_State *L,* r/ L, t” K& `9 g$ q
                   const char *name,
/ N; B) Y, N% g4 P                   lua_CFunction f);
  l$ @% J$ y# P. {% D! G0 x) n把 C 函数 f 设到全局变量 name 中。它通过一个宏定义： ! F3 [1 X; ]. v- q, K: [6 T
     #define lua_register(L,n,f) + w1 u  N+ g” }) Q) `
            (lua_pushcfunction(L, f), lua_setglobal(L, n))
! D1 k’ `1 a6 _________________________________________
– R+ ~’ A0 j’ W$ m- ]5 V  Clua_remove# P9 P, f” d9 N, _  v- }% W0 D0 t/ Y
void lua_remove (lua_State *L, int index);
) D. @# h5 D# C4 e从给定有效索引处移除一个元素，把这个索引之上的所有元素移下来填补上这个空隙。不能用伪索引来调用这个函数，因为伪索引并不指向真实的栈上的位置。 + R: V1 F6 c” [- o
________________________________________
( a9 s1 H0 Z1 Qlua_replace
* }# e% |! N; w1 c2 u& Cvoid lua_replace (lua_State *L, int index);) ^! R3 v% 6 h$ D3 I, ?
把栈定元素移动到给定位置（并且把这个栈定元素弹出），不移动任何元素（因此在那个位置处的值被覆盖掉）。
‘ c  d6 b3 R8 A6 f6 _/ ]________________________________________; j# X; Y7 z- n8 X
lua_resume
$ s2 y. L: c/ P% ( G$ uint lua_resume (lua_State *L, int narg);
2 g$ S7 W( ?9 b8 O; I+ J在给定线程中启动或继续一个 coroutine 。
& r+ U# n’ W5 r! B% N4 @6 Y要启动一个 coroutine 的话，首先你要创建一个新线程（参见 lua_newthread ）；然后把主函数和若干参数压到新线程的堆栈上；最后调用 lua_resume ，把 narg 设为参数的个数。这次调用会在 coroutine 挂起时或是结束运行后manbet网页登录。当函数manbet网页登录时，堆栈中会有传给 lua_yield 的所有值，或是主函数的所有manbet网页登录值。如果 coroutine 切换时，lua_resume manbet网页登录 LUA_YIELD ，而当 coroutine 结束运行且没有任何错误时，manbet网页登录 0 。如果有错则manbet网页登录错误代码（参见 lua_pcall）。在发生错误的情况下，堆栈没有展开，因此你可以使用 debug API 来处理它。出错信息放在栈顶。要继续运行一个 coroutine 的话，你把需要传给 yield 作结果的manbet网页登录值压入堆栈，然后调用 lua_resume 。   u4 f. s/ R’ ~. a2 C0 S6 f
________________________________________3 e9 ^4 O4 j% q9 F; * `
lua_setallocf
( h5 V7 Q  w- q5 h& t4 C# M) wvoid lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
+ ?: D  t1 u3 C/ v* O, {0 R$ a& W4 [‘ F把指定状态机的分配器函数换成带上指针 ud 的 f 。
+ A% v7 ~- H+ g. C! N” B2 v________________________________________
& d/ ~2 [& v. nlua_setfenv/ D/ U1 Q/ l  ~) t/ S
int lua_setfenv (lua_State *L, int index);
6 y% x- U8 m$ I& g1 Q: y8 P$ j3 Z4 s从堆栈上弹出一个 table 并把它设为指定索引处值的新环境。如果指定索引处的值即不是函数又不是线程或是 userdata ， lua_setfenv 会manbet网页登录 0 ，否则manbet网页登录 1 。 5 Y9 j0 K2 @2 `- V4 {
________________________________________
6 C4 d1 n+ i8 j0 j) e5 Dlua_setfield
& C$ P- e” |/ J9 U) R( zvoid lua_setfield (lua_State *L, int index, const char *k);
4 A  s4 p* t” e! T1 K- D9 O3 q做一个等价于 t[k] = v 的操作，这里 t 是给出的有效索引 index 处的值，而 v 是栈顶的那个值。
! W9 }’ T; o$ r2 N  E这个函数将把这个值弹出堆栈。跟在 Lua 中一样，这个函数可能触发一个 "newindex" 事件的元方法（参见 §2.8）。
& 5 b5 h5 ^’ l; O: U________________________________________
7 _  L% E7 R) }. v! ?# J8 xlua_setglobal! v0 e% D3 b/ }0 o1 S5 v+ A
void lua_setglobal (lua_State *L, const char *name);
5 C8 P/ d( u3 U0 Y5 f; @从堆栈上弹出一个值，并将其设到全局变量 name 中。它由一个宏定义出来： 9 M$ N9 J% Q+ Z9 r
     #define lua_setglobal(L,s)   lua_setfield(L, LUA_GLOBALSINDEX, s)# o, b$ j1 a: c# V; K: z. H
________________________________________
‘ ^% I’ H” ~) O” j2 `: r5 q% ulua_setmetatable& T, C: s! b. J6 e. b( H+ V2 m
int lua_setmetatable (lua_State *L, int index);8 X* W; N  {7 E6 j
把一个 table 弹出堆栈，并将其设为给定索引处的值的 metatable 。
; A# j! `3 i2 X________________________________________
$ U/ a) C3 i+ I9 S’ @) X/ Hlua_settable, G* S$ t- D’ n. N& U/ j) k
void lua_settable (lua_State *L, int index);
6 |/ r6 C; I1 u4 n4 F作一个等价于 t[k] = v 的操作，这里 t 是一个给定有效索引 index 处的值， v 指栈顶的值，而 k 是栈顶之下的那个值。 : x0 X1 B( v$ A4 T% V  T. b$ R: B
这个函数会把键和值都从堆栈中弹出。和在 Lua 中一样，这个函数可能触发 "newindex" 事件的元方法（参见 §2.8）。
; Q8 s’ T5 ~( ?, U________________________________________– j9 E- o2 T8 @. ~+ E, _$ F2 _( l* ^
lua_settop  k+ m: R0 N) S0 E# u, l9 R
void lua_settop (lua_State *L, int index);+ d1 Y2 C2 c# n7 h- z4 v
参数允许传入任何可接受的索引以及 0 。它将把堆栈的栈顶设为这个索引。如果新的栈顶比原来的大，超出部分的新元素将被填为 nil 。如果 index 为 0 ，把栈上所有元素移除。 6 ~5 s2 @$ o3 S) E1 |’ J9 R
________________________________________( S) w7 m6 G* g” T; u/ Y
lua_State
, R1 T) v* ?  O7 B9 a* Atypedef struct lua_State lua_State;
( N. g’ R+ U- s” W* v, E1 p一个不透明的结构，它保存了整个 Lua 解释器的状态。 Lua 库是完全可重入的：它没有任何全局变量。（译注：从 C 语法上来说，也不尽然。例如，在 table 的实现中用了一个静态全局变量 dummynode_ ，但这在正确使用时并不影响可重入性。只是万一你错误链接了 lua 库，不小心在同一进程空间中存在两份 lua 库实现的代码的话，多份 dummynode_ 不同的地址会导致一些问题。）所有的信息都保存在这个结构中。 + h1 H1 S! ]) ?- @8 K/ h$ z+ O
这个状态机的指针必须作为第一个参数传递给每一个库函数。 lua_newstate 是一个例外，这个函数会从头创建一个 Lua 状态机。 ” z& W1 }) ?’ e2 z+ d
________________________________________4 Z- E+ N” h8 [
lua_status
2 d- m- W9 R& ^int lua_status (lua_State *L);/ E! w( F- O; u3 t
manbet网页登录线程 L 的状态。 : ^# Y8 [7 F2 @8 X6 e
正常的线程状态是 0 。当线程执行完毕或发生一个错误时，状态值是错误码。如果线程被挂起，状态为 LUA_YIELD 。
3 H5 Z/ m” w0 S0 t) z/ ?( v! i________________________________________7 E( t: X0 N& x
lua_toboolean
2 S* h. Y) I’ m2 @. _! ~# jint lua_toboolean (lua_State *L, int index);
– f4 u  ~- [4 k5 d/ m把指定的索引处的的 Lua 值转换为一个 C 中的 boolean 值（ 0 或是 1 ）。和 Lua 中做的所有测试一样， lua_toboolean 会把任何不同于 false 和 nil 的值当作 1 manbet网页登录；否则就manbet网页登录 0 。如果用一个无效索引去调用也会manbet网页登录 0 。（如果你想只接收真正的 boolean 值，就需要使用 lua_isboolean 来测试值的类型。）
+ ( j. I# h: D/ t- i’ c________________________________________
# L+ w+ n  A  F3 Y) ~lua_tocfunction5 @” ?( D+ F8 G2 U’ v. x# t
lua_CFunction lua_tocfunction (lua_State *L, int index);
  @) d; ^’ k% P9 Q9 a把给定索引处的 Lua 值转换为一个 C 函数。这个值必须是一个 C 函数；如果不是就manbet网页登录 NULL 。 : X/ R+ K5 I0 x0 y$ M
________________________________________. T$ _) g: N1 u1 S8 m) R# @
lua_tointeger$ i’ n* W’ K( Q$ a
lua_Integer lua_tointeger (lua_State *L, int idx);: b( R$ f# u$ Z” M” V/ q’ U- q( w
把给定索引处的 Lua 值转换为 lua_Integer 这样一个有符号整数类型。这个 Lua 值必须是一个数字或是一个可以转换为数字的字符串（参见 §2.2.1）；否则，lua_tointeger manbet网页登录 0 。 & H. d9 o3 C. Y7 R. b. B’ F, ]# x
如果数字不是一个整数，截断小数部分的方式没有被明确定义。 ” e3 Q, ~9 O, D- ]: |
________________________________________
. i  A2 t& ]” R& d! ?lua_tolstring
9 L+ J, r! Q) R” {const char *lua_tolstring (lua_State *L, int index, size_t *len);6 Z2 R0 I( [8 j$ L6 o9 I0 q! i
把给定索引处的 Lua 值转换为一个 C 字符串。如果 len 不为 NULL ，它还把字符串长度设到 *len 中。这个 Lua 值必须是一个字符串或是一个数字；否则manbet网页登录manbet网页登录 NULL 。如果值是一个数字，lua_tolstring 还会把堆栈中的那个值的实际类型转换为一个字符串。（当遍历一个表的时候，把 lua_tolstring 作用在键上，这个转换有可能导致 lua_next 弄错。）
7 j& s) Q: I. O/ C” mlua_tolstring manbet网页登录 Lua 状态机中字符串的以对齐指针。这个字符串总能保证 （ C 要求的）最后一个字符为零 (‘’) ，而且它允许在字符串内包含多个这样的零。因为 Lua 中可能发生垃圾收集，所以不保证 lua_tolstring manbet网页登录的指针，在对应的值从堆栈中移除后依然有效。
9 ^0 l! ]; z2 ]+ E/ h! 9 `________________________________________
+ S4 K” }: E  r’ q( n( llua_tonumber/ Q! E/ o, H! b: m9 S. @
lua_Number lua_tonumber (lua_State *L, int index);2 i7 A8 x1 b! C. B2 N  ]9 [4 b- n
把给定索引处的 Lua 值转换为 lua_Number 这样一个 C 类型（参见 lua_Number ）。这个 Lua 值必须是一个数字或是一个可转换为数字的字符串（参见 §2.2.1 ）；否则，lua_tonumber manbet网页登录 0 。
# W& F’ [) V2 S________________________________________
5 }’ ?7 D” M4 [1 b( _4 * y/ clua_topointer
3 q7 @! I$ u! R$ }const void *lua_topointer (lua_State *L, int index);* V2 b0 k* g- N# ^
把给定索引处的值转换为一般的 C 指针 (void*) 。这个值可以是一个 userdata ，table ，thread 或是一个 function ；否则，lua_topointer manbet网页登录 NULL 。不同的对象有不同的指针。不存在把指针再转回原有类型的方法。 1 _: w, M/ a. T( M
这个函数通常只为产生 debug 信息用。 5 |+ }2 H0 q/ a/ ~
________________________________________% R# Q, p’ j5 M8 d- r
lua_tostring
* Z) }6 {, i3 k. |# r% Mconst char *lua_tostring (lua_State *L, int index);
‘ n; w* _0 ^* s9 i6 g# ]* w等价于 lua_tolstring ，而参数 len 设为 NULL 。 ( M6 f1 l$ [, W9 L7 n/ |0 E
________________________________________! c) T’ y9 p0 j8 F1 p’ j* T( C
lua_tothread
  t0 k” Q$ o$ h- P7 m1 vlua_State *lua_tothread (lua_State *L, int index);2 C7 ?$ F7 I  }1 ^2 j  X
把给定索引处的值转换为一个 Lua 线程（由 lua_State* 代表）。这个值必须是一个线程；否则函数manbet网页登录 NULL 。 8 a% x! Y+ K  f
________________________________________
9 I/ w6 e3 y3 T’ d0 Z! Flua_touserdata
. ~1 J7 t; M* D6 k( Jvoid *lua_touserdata (lua_State *L, int index);
# o2 l; ?. U5 a1 o- y( x9 m如果给定索引处的值是一个完整的 userdata ，函数manbet网页登录内存块的地址。如果值是一个 light userdata ，那么就manbet网页登录它表示的指针。否则，manbet网页登录 NULL 。 ‘ 9 T% a- k$ I’ k9 l0 X
________________________________________
4 P, e+ `8 h+ S) vlua_type
3 J# h$ r( {1 O) # Aint lua_type (lua_State *L, int index);
5 A+ y0 C+ T& R” M2 A& Rmanbet网页登录给定索引处的值的类型，当索引无效时则manbet网页登录 LUA_TNONE （那是指一个指向堆栈上的空位置的索引）。 lua_type manbet网页登录的类型是一些个在 lua.h 中定义的常量： LUA_TNIL ， LUA_TNUMBER ， LUA_TBOOLEAN ， LUA_TSTRING ， LUA_TTABLE ， LUA_TFUNCTION ， LUA_TUSERDATA ， LUA_TTHREAD ， LUA_TLIGHTUSERDATA 。 0 N$ b1 B’ Z: i” u: F3 M- }
________________________________________
! f; u* U9 U6 c- L” U8 N5 xlua_typename
* C2 k7 Z’ }! _” n. Cconst char *lua_typename  (lua_State *L, int tp);7 b$ A’ o’ F) j( D
manbet网页登录 tp 表示的类型名，这个 tp 必须是 lua_type 可能manbet网页登录的值中之一。
7 }7 }5 K) G) C$ a) j________________________________________
+ `# K# ]! P’ D, [lua_Writer0 c  y5 j2 p, R5 v’ ^: H
typedef int (*lua_Writer) (lua_State *L,
, a’ W: V: m7 l% U0 {+ Q  T) e                           const void* p,
: t) W. E/ j. B+ r& q& b                           size_t sz,
9 [# J: b/ S$ p# c% h% P                           void* ud);
& K, W: |” M& x由 lua_dump 用到的写入器函数。每次 lua_dump 产生了一块新的 chunk ，它都会调用写入器。传入要写入的缓存 (p) 和它的尺寸 (sz) ，还有 lua_dump 的参数 data 。 0 G2 q5 E* E/ ]’ ?0 D$ y
写入器会manbet网页登录一个错误码： 0 表示没有错误；别的值均表示一个错误，并且会让 lua_dump 停止再次调用写入器。
( g” {7 Y; P$ G2 `- h% P________________________________________; E* Q  Z+ w: z1 H, }* f; g. J
lua_xmove
8 D# J9 @& M. f6 ^  H! x8 |7 f+ N; {; xvoid lua_xmove (lua_State *from, lua_State *to, int n);, b0 G( j1 X, }2 B3 l
传递 同一个 全局状态机下不同线程中的值。 6 H, Q# e8 m$ W7 @! r& u2 x7 d8 p
这个函数会从 from 的堆栈中弹出 n 个值，然后把它们压入 to 的堆栈中。 ! A9 ?% e# B( {% q5 j
________________________________________
! Y3 K7 Z5 ^& Z2 hlua_yield2 C) l” L4 D0 j3 [
int lua_yield  (lua_State *L, int nresults);
3 T# k1 L. M7 M( C) m$ z% A8 u/ F( e切出一个 coroutine 。 + b. K9 g- z* e) F. J; y) + H$ z
这个函数只能在一个 C 函数的manbet网页登录表达式中调用。如下： – S! `5 O# z- F* c” ]
     return lua_yield (L, nresults);
7 `0 Y/ V5 g& u. n/ V  e当一个 C 函数这样调用 lua_yield ，正在运行中的 coroutine 将从运行中挂起，然后启动这个 coroutine 用的那次对 lua_resume 的调用就manbet网页登录了。参数 nresults 指的是堆栈中需要manbet网页登录的结果个数，这些manbet网页登录值将被传递给 lua_resume 。 – @1 l4 I  D0 l: C+ p5 U/ x
3.8 – 调试接口
. F8 {# u* @% `# Q, l; }Lua 没有内建的调试设施。取而代之的是提供了一些函数接口和钩子。利用这些接口，可以做出一些不同类型的调试器，性能分析器，或是其它一些需要从解释器中取到“内部信息”的工具。 3 k5 L0 m) ]/ ]. F
________________________________________
/ ]( f* w5 w$ h  h: Z. `0 Glua_Debug6 o” d) |* k# a’ l8 P
typedef struct lua_Debug {– Q, ]9 I3 s1 _; R$ T
  int event;( u, Q9 M% r, U- d” O. {
  const char *name;           /* (n) */& g( a2 C8 {2 i  P; }& T6 G) k. H
  const char *namewhat;       /* (n) */; K4 v9 5 p5 `- r
  const char *what;           /* (S) */  k; g4 C- ~4 |& f! {
  const char *source;         /* (S) */
; P+ m1 d3 G- G  int currentline;            /* (l) */
6 O0 m’ O( G6 M  Z$ z’ C  int nups;                   /* (u) upvalue 个数 */2 Z/ n” V$ u1 P4 @4 K% f5 K/ j
  int linedefined;            /* (S) */
7 E; Q” r5 T7 W8 J0 B& V& `  int lastlinedefined;        /* (S) */# {: f# W4 K” P; L  a’ W” q
  char short_src[LUA_IDSIZE]; /* (S) */
$ V/ `) D& q: A$ G  /* 私有部分 */5 z( X& w- 2 s$ O
  其它域$ P$ {” m% i, e; S# ]- Q$ y( N3 g
} lua_Debug;
1 H” m4 d; H8 [. H一个用来携带活动中函数的各种信息的结构。 lua_getstack 仅填写这个结构中的私有部分，这些部分以后会用到。调用 lua_getinfo 则可以填上 lua_Debug 中有用信息的那些域。
# r7 q4 ( d- g- g5 hlua_Debug 中的各个域有下列含义： : B  V4 ?8 x5 i- r+ Z* X
?        source: 如果函数是定义在一个字符串中，source 就是这个字符串。如果函数定义在一个文件中， source 是一个以 ‘@’ 开头的文件名。 8 f# o( ! @2 P$ J- P” }/ U
?        short_src: 一个“可打印版本”的 source，用于出错信息。
0 o” G  I8 M; @$ u/ x?        linedefined: 函数定义开始处的行号。
+ ” M( G+ x( j’ I& V  o1 A?        lastlinedefined: 函数定义结束处的行号。
! ?, `” l2 Y: n8 {- r?        what: 如果函数是一个 Lua 函数，则为一个字符串 "Lua" ；如果是一个 C 函数，则为 "C"；如果它是一个 chunk 的主体部分，则为 "main"；如果是一个作了尾调用的函数，则为 "tail" 。别的情况下，Lua 没有关于函数的别的信息。
5 J’ y* F. `& |) S$ h?        currentline: 给定函数正在执行的那一行。当提供不了行号信息的时候，currentline 被设为 -1 。
2 g( R& y, F* R0 U?        name: 给定函数的一个合理的名字。因为 Lua 中的函数也是一个值，所以它们没有固定的名字：一些函数可能是全局复合变量的值，另一些可能仅仅只是被保存在一个 table 中。 lua_getinfo 函数会检查函数是这样被调用的，以此来找到一个适合的名字。如果它找不到名字，name 就被设置为 NULL 。 $ r; ], h5 {/ u+ I1 c1 L- c
?        namewhat: 结实 name 域。 namewhat 的值可以是 "global", "local", "method", "field", "upvalue", 或是 "" （空串）。这取决于函数怎样被调用。（Lua 用空串表示其它选项都不符合）
( @8 p4 S! l0 x?        nups: 函数的 upvalue 的个数。 ) J& Q0 S$ k5 l2 V& A6 X8
________________________________________6 G5 i+ b, i* X3 R; q, q” k
lua_gethook
* v” e/ }: f0 Glua_Hook lua_gethook (lua_State *L);
” v1 z, Z2 ?3 s0 a! G, ~manbet网页登录当前的钩子函数。
# h; }3 h1 D; G% ?________________________________________
1 Y6 m& I% M; F+ E/ T* Z- v4 ]lua_gethookcount
, R: {7 v. l% H5 J2 t6 N7 O: Aint lua_gethookcount (lua_State *L);
5 T0 n7 Q) t4 N* d/ G1 s% – @manbet网页登录当前钩子记数。
‘ f5 _* }0 e2 l2 ________________________________________7 k. N1 `. F0 U( X0 P
lua_gethookmask: ]9 s, g/ p) _
int lua_gethookmask (lua_State *L);” c1 Z1 P) @$ k” ]- {. }% Z. b
manbet网页登录当前的钩子掩码 (mask) 。
( w; N5 B# e+ E, v8 f# z  m9 ~( S’ s________________________________________
( w* Y* d0 `9 Ilua_getinfo
2 C0 {. Y1 w2 P  i. Q, uint lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
/ ~$ R; D1 z/ G9 mmanbet网页登录一个指定的函数或函数调用的信息。 5 @! }’ Y: [* X
当用于取得一次函数调用的信息时，参数 ar 必须是一个有效的活动的记录。这条记录可以是前一次调用 lua_getstack 得到的，或是一个钩子 （参见 lua_Hook）得到的参数。
) R3 k” H( G8 s/ |, u用于获取一个函数的信息时，可以把这个函数压入堆栈，然后把 what 字符串以字符 ‘>’ 起头。（这个情况下，lua_getinfo 从栈顶上弹出函数。） 例如，想知道函数 f 在哪一行定义的，你可以下下列代码： * B3 P# s( o; S
     lua_Debug ar;7 K% W) R/ T* [& }* R+ N
     lua_getfield(L, LUA_GLOBALSINDEX, "f");  /* 取到全局变量 ‘f’ */
( q; g& 3 a# H% w% G3 _3 k     lua_getinfo(L, ">S", &ar);3 h’ g/ P7 ^) `* I$ {! q
     printf("%dn", ar.linedefined);
2 k, a9 v9 N. b4 Z4 owhat 字符串中的每个字符都筛选出结构 ar 结构中一些域用于填充，或是把一个值压入堆栈：
3 |/ [& L3 G9 o# M% S0 P?        ‘n’: 填充 name 及 namewhat 域； ” B$ a- w4 S2 E$ F
?        ‘S’: 填充 source， short_src， linedefined， lastlinedefined，以及 what 域； 9 ]# W  % D9 t& ?9 }
?        ‘l’: 填充 currentline 域；
2 [7 o/ [% b; C! q?        ‘u’: 填充 nups 域；
, ~$ [; @1 M9 Y7 L’ O9 M+ D?        ‘f’: 把正在运行中指定级别处函数压入堆栈；（译注：一般用于获取函数调用中的信息，级别是由 ar 中的私有部分来提供。如果用于获取静态函数，那么就直接把指定函数重新压回堆栈，但这样做通常无甚意义。）
( B7 f  ]5 w6 T% @’ I?        ‘L’: 压一个 table 入栈，这个 table 中的整数索引用于描述函数中哪些行是有效行。（有效行指有实际代码的行，即你可以置入断点的行。无效行包括空行和只有注释的行。）
; ]; i% Q+ ]  `8 Z这个函数出错会manbet网页登录 0 （例如，what 中有一个无效选项）。 * `5 E9 n* U( T$ R( E- w
________________________________________* V; D- ]6 v# D’ E/ D/ z( t% W
lua_getlocal
5 f: j4 O  W$ k3 Yconst char *lua_getlocal (lua_State *L, lua_Debug *ar, int n);8 I- J8 u; d6 c; a6 e2 n7 O3 y
从给定活动记录中获取一个局部变量的信息。参数 ar 必须是一个有效的活动的记录。这条记录可以是前一次调用 lua_getstack 得到的，或是一个钩子 （参见 lua_Hook）得到的参数。索引 n 用于选择要检阅哪个局部变量（ 1 表示第一个参数或是激活的第一个局部变量，以此类推，直到最后一个局部变量）。 lua_getlocal 把变量的值压入堆栈并manbet网页登录它的名字。
7 _’ P3 L9 a’ W9 P  g% C1 ^以 ‘(‘ （正小括号）开始的变量指内部变量（循环控制变量，临时变量，C 函数局部变量）。
0 R” i2 B0 H- n1 O/ y3 k, l当索引大于局部变量的个数时，manbet网页登录 NULL （什么也不压入）。 6 W/ E1 q” I- k3 C3 U
________________________________________4 r) R! _% o* z* q/ Z) l’ c1 [. }
lua_getstack
+ w& m, N% s: e9 k6 q: @3 R; pint lua_getstack (lua_State *L, int level, lua_Debug *ar);– Z4 ?’ v0 G’ r% O- @
获取解释器的运行时栈的信息。 ( r( J( @9 W, g
这个函数用正在运行中的给定级别处的函数的活动记录来填写 lua_Debug 结构的一部分。 0 级表示当前运行的函数，而 n+1 级处的函数就是调用第 n 级函数的那一个。如果没有错误，lua_getstack manbet网页登录 1 ；当调用传入的级别大于堆栈深度的时候，manbet网页登录 0 。 7 }% M/ h, * U) Z
________________________________________
) @9 o# I% q5 n5 llua_getupvalue
‘ Z- l4 |. b’ C4 G! Y. Z  U( }4 wconst char *lua_getupvalue (lua_State *L, int funcindex, int n);9 v$ C” P, I4 S
获取一个 closure 的 upvalue 信息。（对于 Lua 函数，upvalue 是函数需要使用的外部局部变量，因此这些变量被包含在 closure 中。） lua_getupvalue 获取第 n 个 upvalue ，把这个 upvalue 的值压入堆栈，并且manbet网页登录它的名字。 funcindex 指向堆栈上 closure 的位置。（ 因为 upvalue 在整个函数中都有效，所以它们没有特别的次序。因此，它们以字母次序来编号。）
1 n3 p2 $ M7 Z1 [1 G当索引号比 upvalue 数量大的时候，manbet网页登录 NULL （而且不会压入任何东西）对于 C 函数，这个函数用空串 "" 表示所有 upvalue 的名字。 , d1 P7 C3 g0 c2 p
________________________________________
5 g1 c’ i* _% }4 ?lua_Hook
! Z5 K8 w6 K9 Ztypedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
5 f* R8 S( C8 o, u” @$ g6 y用于调试的钩子函数类型。
7 [2 X’ x* {2 o4 m/ C无论何时钩子被调用，它的参数 ar 中的 event 域都被设为触发钩子的事件。 Lua 把这些事件定义为以下常量： LUA_HOOKCALL， LUA_HOOKRET, LUA_HOOKTAILRET， LUA_HOOKLINE， and LUA_HOOKCOUNT。除此之外，对于 line 事件，currentline 域也被设置。要想获得 ar 中的其他域，钩子必须调用 lua_getinfo。对于manbet网页登录事件，event 的正常值可能是 LUA_HOOKRET，或者是 LUA_HOOKTAILRET 。对于后一种情况，Lua 会对一个函数做的尾调用也模拟出一个manbet网页登录事件出来；对于这个模拟的manbet网页登录事件，调用 lua_getinfo 没有什么作用。
7 H- o6 z3 W. W5 T* b+ F当 Lua 运行在一个钩子内部时，它将屏蔽掉其它对钩子的调用。也就是说，如果一个钩子函数内再调回 Lua 来执行一个函数或是一个 chunk ，这个执行操作不会触发任何的钩子。 4 Z, H  @( z1 s
________________________________________/ W+ K% Y) B3 y& s
lua_sethook& n” ~2 `0 E9 f7 N
int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);
* ?2 y; l/ – L. H设置一个调试用钩子函数。 % G# }* x7 G! e’ c8 o/ P. R
参数 f 是钩子函数。 mask 指定在哪些事件时会调用：它由下列一组位常量构成 LUA_MASKCALL， LUA_MASKRET， LUA_MASKLINE，以及 LUA_MASKCOUNT。参数 count 只在 mask 中包含有 LUA_MASKCOUNT 才有意义。对于每个事件，钩子被调用的情况解释如下： * c# W3 N+ F( v  N” T+ ]0 Z7 R$ s( p
?        call hook: 在解释器调用一个函数时被调用。钩子将于 Lua 进入一个新函数后，函数获取参数前被调用。 . U# Y- _* i/ U$ d5 ^5 N0 G: g9 d
?        return hook: 在解释器从一个函数中manbet网页登录时调用。钩子将于 Lua 离开函数之前的那一刻被调用。你无权访问被函数manbet网页登录出去的那些值。 （译注：原文 (You have no access to the values to be returned by the function) 如此。但“无权访问”一词值得商榷。某些情况下你可以访问到一些被命名为 (*temporary) 的局部变量，那些索引被排在最后的 (*temporary) 变量指的就是manbet网页登录值。但是由于 Lua 对特殊情况做了一些优化，比如直接manbet网页登录一个被命名的局部变量，那么就找不到对应的 (*temporary) 变量了。本质上，manbet网页登录值一定存在于此刻的局部变量中，并且可以访问它，只是无法确定是哪些罢了。至于这个时候函数体内的其它局部变量，是不保证有效的。进入 return hook 的那一刻起，实际已经退出函数内部的运行环节，manbet网页登录值占用的局部变量空间以后的部分，都有可能因 hook 本身复用它们而改变。） # p+ I* O/ z, B- v!
?        line hook: 在解释器准备开始执行新的一行代码时，或是跳转到这行代码中时（即使在同一行内跳转）被调用。（这个事件仅仅在 Lua 执行一个 Lua 函数时发生。）
& g! V( {! Y0 z& ]; s7 v9 z% X$ r?        count hook: 在解释器每执行 count 条指令后被调用。（这个事件仅仅在 Lua 执行一个 Lua 函数时发生。）
4 ?1 Z7 r! Q/ w/ R; L; {: L- K钩子可以通过设置 mask 为零屏蔽。
, @# e% g# E5 _________________________________________  T3 l# s8 v# q+ Z
lua_setlocal/ c7 q6 z1 L7 F3 T
const char *lua_setlocal (lua_State *L, lua_Debug *ar, int n);6 l0 _5 ], }: e7 J, p; N
设置给定活动记录中的局部变量的值。参数 ar 与 n 和 lua_getlocal 中的一样（参见 lua_getlocal）。 lua_setlocal 把栈顶的值赋给变量然后manbet网页登录变量的名字。它会将值从栈顶弹出。 / F! u2 X3 x9 ]- e# l1 d
当索引大于局部变量的个数时，manbet网页登录 NULL （什么也不弹出）。! e” R1 C0 A# P9 q  j
///////////////漏洞与补丁齐飞  蓝屏共死机一色

3# 弗罗多 ! [1 I0 o) a& i8 h1 S5 o/ w

; v0 V6 |0 I+ u’ ^4 8 Y8 N最近我也在研究 lua,可能wow在这方面做的比较成熟。推荐几个网站
2 D) T” V3 S4 ~3 X2 a6 `https://wiki.cwowaddon.com/%E7%A8%8B%E5%BA%8F%E5%91%98%E5%BF%AB%E9%80%9F%E5%85%A5%E6%89%8B%E6%8C%87%E5%8D%97
. }1 f  C. R6 S& L同样是基于 lua开发的，希望能有所帮助