标签：

Lua 5.1参考手册

?一个版权?2006 A￠A€“2012 Lua.org,银行业者。免费的根据Lua许可证。

内容一个?·指数一个?·其他版本一个?·英语一个?·portuguA?Aa年代一个?·espaA?A±ol

1 A￠A€“介绍

Lua是一个扩展编程语言设计的支持一般过程式编程与数据描述设施。它还提供了很好的支持面向对象编程,函数式编程,数据驱动的编程。Lua是打算作为一个强大的、轻量级的对任何程序,需要一个脚本语言。Lua是实现为一个库,编写的清洁C(也就是说,在共同的子集ANSIA?C和c++)。

作为一个扩展语言,Lua没有概念的“主要”计划:它只工作嵌入式在客户端,被称为嵌入程序或者简单地主机。这个主程序可以调用函数来执行一个Lua代码,可以写和读Lua变量,和CA?可以注册一个函数调用Lua代码。通过使用CA?功能,Lua可以增强应对各种不同的领域,因此创建定制编程语言共享一个语法框架。Lua分布包含一个示例主程序调用lua,它使用Lua库提供一个完整的、独立的Lua解释器。

Lua是免费软件,像往常一样没有提供担保,如上所述的许可证。本手册中所描述的实现在Lua的官方网站,www.lua.org。

像任何其他参考手册,本文档是干燥的地方。讨论决定的背后Lua的设计,在Lua看到可用的技术论文的网站。的详细介绍在Lua编程,看到罗伯特的书,在Lua编程(第二版)。

2 A￠A€“的语言

本节描述的词汇、语法和语义的Lua。换句话说,本节描述令牌是有效的,他们如何可以组合,和他们的组合的意思。

语言结构将解释使用通常的扩展的BNF符号,在这{一个}一个意味着??0或更多一个的年代,(一个?一个可选的一种手段一个。非终结符显示非终结符,关键字如所示kword,和其他终端符号显示“=?′。Lua中可以找到的完整语法?§8在本手册的结束。

￠A€2.1”词法约定

的名字(也称为标识符)在Lua中可以是任何字符串的信件,数字和下划线,没有一个数字开始。这个名字在大多数语言的定义是一致的。(字母的定义取决于当前语言环境:任何字符是字母由当前的语言环境可以使用一个标识符)。标识符用于变量和表字段名称。

以下关键字保留和不能使用的名字:

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while

Lua是一个区分大小写的语言:和是一个保留字,但和和和是两个不同的有效名称。作为一个惯例,之后下划线开头的名称大写字母(如_VERSION)是留给内部Lua使用的全局变量。

以下字符串表示其他标记:

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     ..    ...

字符串字面量可以被匹配的单引号或双引号分隔,并可以包含以下c转义序列:”、一个‘(贝尔)” b”(退格),”\ f(换页),” n(换行),”r \‘(回车)” t”(水平选项卡),”v \”(垂直制表符),” \”(反斜杠),”\””(引号(双引号)),和“ ‘撇号(单引号)。此外,一个反斜杠紧随其后的是一个真正的换行符结果在一个换行符的字符串。一个字符在字符串也可以指定的数值使用转义序列\ddd,在哪里ddd是一个序列的三个小数位数。(注意,如果一个数值逃脱,后跟一个数字,它必须使用完全表达了三位数)。在Lua字符串可以包含任何8位值,包括嵌入式零,可以指定为“ 0”。

字符串也可以使用很长一段定义格式包围长支架。我们定义一个打开长支架的水平n作为一个开放方括号紧随其后n平等其次是另一个迹象方括号。所以,开放长支架levelA?写成一个0[[,开放长支架levelA?写成1(=(,等等。一个关闭长支架类似的定义;例如,关闭长支架levelA?写成4)= = = =)。一个长字符串从一个开放和支架的水平结束于第一次关闭长支架的同一水平。文字在这个括号形式可以运行几行,不解释任何转义序列,而忽略长支架的其他级别。它们可以包含除了括号的适当水平。

为了方便起见,当打开长支架立即后跟换行,不包括换行符的字符串。作为一个例子,在一个系统使用ASCII(“一个编码asA?97,换行符编码asA?10,1是编码asA?49),下面的五个字符串表示相同的字符串:

     a = ‘alo\n123"‘
     a = "alo\n123\""
     a = ‘\97lo\10\04923"‘
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]

一个数值常数和一个可选的小数部分可以写吗和一个可选的十进制指数。Lua还接受整数16进制的常量,通过加上前缀0 x。有效的数值常量的例子

     3   3.0   3.1416   314.16e-2   0.31416E1   0xff   0x56

一个评论开始于一个双连字符(- - -)以外的任何一个字符串。如果文本后立即- - -不是一个开放长支架,评论是一种简短的评论,运行,直到行结束。否则,这是一个长时间的评论,运行,直到相应的关闭长支架。长评论常用暂时禁用代码。

￠A€2.2”值和类型

Lua是一个动态类型语言。这意味着变量没有类型,只有价值观。没有类型定义语言。携带自己的所有值类型。

在Lua中所有值一流的值。这意味着所有的值都可以存储在变量中,作为参数传递给其他函数,作为结果返回。

在Lua中有八个基本类型:零,布尔,数量,字符串,函数,用户数据,线程,表。零值的类型吗零,其主要属性是不同于任何其他值;它通常代表缺乏有用的价值。布尔值的类型吗假和真正的。这两个零和假使条件错误;任何其他值使它正确。数量代表真正的双精度浮点数字。(很容易构建使用其他的Lua解释器内部表示的数字,如单精度浮点数或长整数;看到文件luaconf.h)。字符串表示的字符数组。Lua是8位清洁:字符串可以包含任何8位字符,包括嵌入式零(‘ 0”)(见?§2.1)。

Lua可以调用函数用Lua编写和(和操作)用C编写的函数(见一个?§2.5.8)。

类型用户数据允许任意的CA?数据提供吗被存储在Lua变量。这种类型对应于原始内存块在Lua中,没有预定义的业务,除了任务和身份测试。但是,通过使用元表,程序员可以定义用户数据值的操作(见?§2.8)。在Lua中不能创建或修改用户数据值,只有通过CA?API。这保证数据由主机程序的完整性。

类型线程代表独立线程的执行用于实现协同程序(见?§2.11)。不要混淆Lua与操作系统线程的线程。Lua支持协同程序在所有系统上,即使是那些不支持线程。

类型表实现关联数组,即数组可以被索引不仅与数字,但任何值(除了零)。表可以异构;也就是说,它们可以包含所有类型的值(除了零)。表是唯一在Lua中数据组织机制;它们可以用来代表普通数组,符号表、设置、记录、图形、树木等。代表记录,Lua使用字段名作为索引。支持这种语言表示提供a.name作为语法糖(“名称”)。有几个在Lua中方便的方法来创建表(见一个?§2.5.7)。

等指标,一个表字段的值可以是任何类型(除了零)。特别是,因为功能一流的价值观,表字段可以包含函数。因此表可以携带方法(见一个?§2.5.9)。

表、函数、线程和用户数据值(完整)对象:变量实际上并没有包含这些值,只有引用给他们。赋值、参数传递和函数返回总是操作引用这样的价值观;这些操作并不意味着任何类型的副本。

的库函数类型返回一个字符串描述类型一个给定的值。

2.2.1￠A€“强迫

Lua之间提供了自动转换字符串和数字值在运行时。任何试图把算术运算应用到一个字符串后一个数字,这个字符串通常的转换规则。相反,当一个数字预计使用一个字符串,数字转换为字符串,在一个合理的格式。为完全控制数字转换为字符串,使用格式从字符串库函数(见string.format)。

￠A€2.3”变量

变量是存储值的地方。有三种变量在Lua中:全局变量,局部变量,和表字段。

一个名字可以表示全局变量和局部变量(或一个函数的形式参数,这是一种特殊的局部变量):

	var ::= Name

名字表示标识符,如中定义?§2.1。

任何变量被认为是全球性的,除非显式声明作为一个本地(见一个?§2.4.7)。局部变量在词法上确定范围:局部变量可以自由访问功能在他们的范围(见定义?§2.6)。

之前第一次赋值给一个变量,它的值是多少零。

使用方括号索引表:

	var ::= prefixexp `[′ exp `]′

访问全局变量的意义通过元表和表字段可以更改。一个访问索引变量t[我]相当于一个电话gettable_event(t,我)。(见?§2.8的完整描述gettable_event函数。这个函数没有定义或调用Lua。我们在这里使用它仅用于说明的目的。)

的语法var.Name只是语法糖var(“名称”):

	var ::= prefixexp `.′ Name

全局变量一样生活所有字段在普通Lua表,被称为环境表或者简单地环境(见?§2.9)。每个函数都有自己的引用一个环境,所以这个函数所有的全局变量将引用这个环境表。创建一个函数时,它继承了环境创建它的功能。环境一个Lua函数表,你叫getfenv。来代替它,你叫setfenv。(你只能操作环境的CA?功能通过调试库;(见?§5.9))。

一个全局变量的访问x相当于_env.x,进而相当于吗

     gettable_event(_env, "x")

在哪里_env环境的运行功能。(见?§2.8的完整描述gettable_event函数。这个函数没有定义或调用Lua。类似地,_env在Lua变量没有定义。我们在这里使用它们仅用于说明的目的。)

￠A€2.4”语句

Lua支持一组几乎传统的语句,类似Pascal和C。这组包括作业,控制结构,函数调用,和变量声明。

2.4.1￠A€“块

Lua称为的执行单位块。一块是一个简单的语句序列,顺序执行。每个语句可以选择由分号结尾:

	chunk ::= {stat [`;′]}

没有空语句,因此“;;”是不合法的。

Lua处理一块作为一个匿名函数的身体具有数量可变的参数(见一个?§2.5.9)。因此,块可以定义局部变量,接收参数和返回值。

一块可以存储在一个文件或一个字符串在主程序。执行一个块,第一次预编译Lua块为一个虚拟机指令,然后执行编译后的代码虚拟机的译员。

块也可以预编译成二进制形式;看到程序luac获取详细信息。项目源代码和编译的形式是可以互换的。Lua自动检测的文件类型和相应的行为。

2.4.2￠A€“块

块语句的列表;语法,一块一块是一样的:

	block ::= chunk

一块可以明确分隔出一个声明:

	stat ::= do block end

明确的块是有用的控制变量声明的范围。有时也用来明确的块添加一个返回或打破声明在中间另一个块(见?§2.4.4)。

2.4.3￠A€“赋值

Lua允许多个作业。因此,语法任务定义了一个变量在左边的列表和右边表达式的列表。两个列表中的元素之间用逗号分隔:

	stat ::= varlist `=′ explist
	varlist ::= var {`,′ var}
	explist ::= exp {`,′ exp}

表达式讨论了?§2.5。

在作业之前,值的列表调整的长度变量的列表。如果有比所需值,扔掉多余的值。如果有更少的比所需值,与尽可能多的扩展列表零根据需要的。如果表达式的列表以一个函数调用,然后调用返回的所有值输入值的列表,调整前的(除了当调用被括在括号里,看到的?§2.5)。

赋值语句首先评估它的表达式也只有到那时正在执行的作业。因此,代码

     i = 3
     i, a[i] = i+1, 20

集一个[3]20日,在不影响一个[4]因为我在(我)评价(3)之前assignedA?4。同样,行

     x, y = y, x

交流的值x和y,和

     x, y, z = y, z, x

周期性排列的值x,y,z。

分配给全局变量的意义通过元表和表字段可以更改。一个索引变量赋值t[我]=瓦尔相当于settable_event(t,我,val)。(见?§2.8的完整描述settable_event函数。这个函数没有定义或调用Lua。我们在这里使用它仅用于说明的目的。)

一个全局变量的赋值x =瓦尔相当于赋值_env。 x =瓦尔,进而相当于吗

     settable_event(_env, "x", val)

在哪里_env环境的运行功能。(_env在Lua变量没有定义。我们在这里使用它仅用于说明的目的。)

2.4.4￠A€“控制结构

控制结构如果,而,重复通常的意义和吗熟悉的语法:

	stat ::= while exp do block end
	stat ::= repeat block until exp
	stat ::= if exp then block {elseif exp then block} [else block] end

Lua也有一个为语句,在两种一个?§2.4.5)。

条件表达式的控制结构可以返回任何值。这两个假和零被认为是错误的。所有的值不同零和假被认为是真的(尤其是数字0和空字符串也是如此)。

在重复￠A€“直到循环,内部块不会结束的直到关键字,但只有在条件。所以,条件可以参考本地变量宣布在循环块。

的返回语句用于返回值从一个函数或一块(也就是一个函数)。功能块可以返回多个值,所以的语法返回语句是

	stat ::= return [explist]

的打破语句用于终止执行而,重复,或为循环,跳转到下一个语句后循环:

	stat ::= break

一个打破最里面的封闭循环结束。

的返回和打破语句只能写成的去年语句块。如果确有必要返回或打破在一块,然后可以使用显式内块,的成语做返回结束和做休息结束,因为现在返回和打破最后一个语句吗(内部)块。

2.4.5￠A€“For语句

的为声明有两种形式:一个数字和一个通用的。

数字为循环重复的代码块,而控制变量贯穿一个等差数列。它有以下语法:

	stat ::= for Name `=′ exp `,′ exp [`,′ exp] do block end

的块是重复的的名字开始的价值第一个经验值第二,直到通过经验值的步骤第三经验值。更准确地说,一个为语句

     for v = e1, e2, e3 do block end

相当于代码:

     do
       local var, limit, step = tonumber(e1), tonumber(e2), tonumber(e3)
       if not (var and limit and step) then error() end
       while (step > 0 and var <= limit) or (step <= 0 and var >= limit) do
         local v = var
         block
         var = var + step
       end
     end

请注意以下几点:

• 这三个控制表达式只计算一次,在循环开始之前。他们必须所有导致数字。
• var,限制,一步是看不见的变量。这里显示的名字仅用于说明的目的。
• 如果表达式(第三步)缺席,然后使用步骤?一个1。
• 您可以使用打破退出一个为循环。
• 循环变量v是本地循环;你不能使用后其价值为结束或坏了。如果你需要这个值,前将其分配给另一个变量或退出循环。

通用为在函数声明作品,被称为迭代器。在每一次迭代,迭代器函数被调用时产生一个新值,这个新值时停止零。通用为循环有以下语法:

	stat ::= for namelist in explist do block end
	namelist ::= Name {`,′ Name}

一个为语句

     for var_1, ···, var_n in explist do block end

相当于代码:

     do
       local f, s, var = explist
       while true do
         local var_1, ···, var_n = f(s, var)
         var = var_1
         if var == nil then break end
         block
       end
     end

请注意以下几点:

• explist评估一次。其结果是一个迭代器函数,一个状态,和一个初始值迭代器变量。
• f,年代,var是看不见的变量。这里的名字是仅供说明目的。
• 您可以使用打破退出一个为循环。
• 循环变量var_i是当地的循环;你不能使用后他们的价值观为结束。如果你需要这些值,然后将它们分配给其他变量前或退出循环。

2.4.6￠A€“函数调用语句

让可能的副作用,函数调用语句可以执行:

	stat ::= functioncall

在这种情况下,返回值都扔掉。函数调用中解释一个?§2.5.8。

2.4.7￠A€“局部声明

局部变量可以声明一个街区内的任何地方。宣言可以包括一个初始的任务:

	stat ::= local namelist [`=′ explist]

如果存在,一个初始赋值具有相同的语义多个赋值(见?§2.4.3)。否则,所有的变量初始化零。

一块也是一块(见?§2.4.1),所以一块中声明的局部变量可以外任何显式的块。这种局部变量的范围延伸到最后的块。

解释局部变量的可见性规则?§2.6。

￠A€2.5”表达式

Lua的基本表达式如下:

	exp ::= prefixexp
	exp ::= nil | false | true
	exp ::= Number
	exp ::= String
	exp ::= function
	exp ::= tableconstructor
	exp ::= `...′
	exp ::= exp binop exp
	exp ::= unop exp
	prefixexp ::= var | functioncall | `(′ exp `)′

数字和字符串中解释?§2.1;变量的解释?§2.3;函数定义的解释一个?§2.5.9;函数调用中解释一个?§2.5.8;表的构造函数中解释一个?§2.5.7。变量参数表达式,用三个点(‘…”),只能时使用直接在一个可变长度函数;他们解释说一个?§2.5.9。

二元操作符包括算术运算符(见一个?§2.5.1),关系运算符(见一个?§2.5.2),逻辑运算符(见一个?§2.5.3),和连接操作符(见?2.5.4§)。一元操作符组成一元-(见一个?§2.5.1),一元的不(见一个?§2.5.3),和一元长度操作符(见一个?§2.5.5)。

函数调用和可变长度的表达式都可以导致多个值。如果使用一个表达式语句(只有函数调用(参见一个?§2.4.6)),然后它返回列表调整为零元素,因此丢弃所有返回值。如果一个表达式用作最后(或唯一的)元素的表达式的列表,然后没有调整(除非被括在括号里)的调用。在所有其他情况下,Lua调整结果列表的一个元素,丢弃所有值除了第一个。

下面是一些例子:

     f()                -- adjusted to 0 results
     g(f(), x)          -- f() is adjusted to 1 result
     g(x, f())          -- g gets x plus all results from f()
     a,b,c = f(), x     -- f() is adjusted to 1 result (c gets nil)
     a,b = ...          -- a gets the first vararg parameter, b gets
                        -- the second (both a and b can get nil if there
                        -- is no corresponding vararg parameter)
     
     a,b,c = x, f()     -- f() is adjusted to 2 results
     a,b,c = f()        -- f() is adjusted to 3 results
     return f()         -- returns all results from f()
     return ...         -- returns all received vararg parameters
     return x,y,f()     -- returns x, y, and all results from f()
     {f()}              -- creates a list with all results from f()
     {...}              -- creates a list with all vararg parameters
     {f(), nil}         -- f() is adjusted to 1 result

括号中的任何表达式总是在只有一个结果值。因此,(f(x,y,z))总是一个值,即使f返回多个值。的值((f(x,y,z))返回的第一个值吗f或零如果f不返回任何值。)

2.5.1￠A€“算术运算符

Lua支持常见的算术运算符:二进制+(添加),- - - - - -(减法),*(乘法),/(部门),%(模),^(求幂);和一元- - - - - -(否定)。如果操作数数字,或可以转换为字符串数字(见?§2.2.1),然后所有操作有通常的意义。求幂适用于任何指数。例如,x ^(-0.5)计算的平方根的倒数x。模的定义是

     a % b == a - math.floor(a/b)*b

也就是说,它是其余轮的一个部门商向负无穷。

2.5.2￠A€“关系运算符

在Lua中关系运算符

     ==    ~=    <     >     <=    >=

这些操作符总是导致假或真正的。

平等(= =首先比较其操作数的类型。如果类型是不同的,那么结果是假。否则,操作数的值进行了比较。数字和字符串比较常见的方式。对象(表、用户数据、线程、和功能)比较了参考:两个物体只有在被认为是相等的相同对象。每次你创建一个新的对象(表、用户数据、线程或函数),这个新对象不同于任何以前存在的对象。

你可以改变Lua的方式比较表和用户数据通过使用“情商”元方法(见?§2.8)。

的转换规则?§2.2.1不适用于平等的比较。因此,“0”= = 0计算结果为假,和t[0]和t(“0”)表示不同的表中的条目。

操作员~ =是完全平等(的否定= =)。

运营商的工作顺序如下。如果两个参数是数字,然后进行比较。否则,如果这两个参数都是字符串,然后根据当前语言环境比较他们的价值观。否则,Lua试图调用“lt”或“乐”元方法(见?§2.8)。一个比较a >是翻译b <和a > =是翻译b < =。

2.5.3￠A€“逻辑运算符

在Lua中逻辑运算符和,或,不。控制结构(见?§2.4.4),所有的逻辑运算符同时考虑假和零是错误的和什么是真实的。

否定算子不总是返回假或真正的。连接运算符和返回其第一个参数如果这个值是假或零;否则,和返回其第二个参数。分离操作符或返回其第一个参数如果这个值是不同的零和假;否则,或返回其第二个参数。这两个和和或使用捷径评价;也就是说,第二个操作数是评价只有必要的。下面是一些例子:

     10 or 20            --> 10
     10 or error()       --> 10
     nil or "a"          --> "a"
     nil and 10          --> nil
     false and error()   --> false
     false and nil       --> false
     false or nil        --> nil
     10 and 20           --> 20

(在本手册,- - >表示前面的表达式的结果)。

2.5.4￠A€“连接

在Lua字符串连接操作符用两个点(‘. .”)。如果两个操作数都是字符串或数字,然后转换为根据规则中提到的字符串?§2.2.1。否则,“concat”元方法叫(见?§2.8)。

2.5.5￠A€“算子长度

操作者用一元运算符#。一个字符串的长度是它的字节数(即通常意义的字符串长度性格是一个字节)。

一个表的长度t定义是什么整数指数n这样t[n]不是零和t(n + 1)是零;此外,如果t[1]是零,n可以是零。一个常规数组中,非nil值从1到给定值n,它的长度n,最后一个值的指数。如果数组“洞”(即,零其他非nil值值之间的值),然后# t可以是任何的指标吗直接在零价值(也就是说,它可以考虑任何这样的零作为最后的价值数组)。

2.5.6￠A€“优先级

运算符优先级在Lua中遵循下表,从低到更高的优先级:

     or
     and
     <     >     <=    >=    ~=    ==
     ..
     +     -
     *     /     %
     not   #     - (unary)
     ^

像往常一样,您可以使用括号来改变表达式的判例。连接(“. .”)和乘方(‘^”)运营商是正确的关联。所有其他二元操作符都离开联想。

2.5.7￠A€“表的构造函数

创建表的表构造函数表达式。每次评估一个构造函数,创建一个新表。构造函数可以用来创建一个空表或者创建一个表,初始化它的一些字段。一般的语法构造函数

	tableconstructor ::= `{′ [fieldlist] `}′
	fieldlist ::= field {fieldsep field} [fieldsep]
	field ::= `[′ exp `]′ `=′ exp | Name `=′ exp | exp
	fieldsep ::= `,′ | `;′

每个字段的表单[exp1]= exp2增加了新表条目与关键exp1和价值exp2。一个字段的表单name =经验相当于["名称"]=实验。最后,表单的字段经验值相当于[我]=实验,在那里我是连续数值的整数,从1开始。其他格式中的字段不影响这个计数。例如,

     a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }

相当于

     do
       local t = {}
       t[f(1)] = g
       t[1] = "x"         -- 1st exp
       t[2] = "y"         -- 2nd exp
       t.x = 1            -- t["x"] = 1
       t[3] = f(x)        -- 3rd exp
       t[30] = 23
       t[4] = 45          -- 4th exp
       a = t
     end

如果最后一个字段列表中的形式经验值和函数调用表达式或变量参数表达式,然后这个表达式返回的所有值连续输入列表(见一个?§2.5.8)。为了避免这种情况,将函数调用或可变长度的表达式在括号中(见?§2.5)。

字段列表中可以有一个可选的分隔符,作为一个方便机器生成的代码。

2.5.8￠A€“函数调用

在Lua函数调用语法如下:

	functioncall ::= prefixexp args

在一个函数调用,第一个prefixexp和参数评估。如果prefixexp的价值类型函数,这个函数被调用用给定的参数。否则,prefixexp”称之为“元方法被调用时,作为第一个参数prefixexp的价值,其次是原始调用参数(见?§2.8)。

表单

	functioncall ::= prefixexp `:′ Name args

可用于所谓的“方法”。一个电话v:名称(arg游戏)是语法糖v.name(v,arg游戏),除了v评估一次。

参数有以下语法:

	args ::= `(′ [explist] `)′
	args ::= tableconstructor
	args ::= String

所有参数表达式是评估之前调用。一个电话的形式f {字段}是语法糖f({字段});也就是说,参数列表是一个新表。一个电话的形式f ‘字符串”(或f”字符串”或f[[字符串]])是语法糖f(‘字符串”);也就是说,参数列表是一个文字字符串。

作为例外,Lua的自由格式语法,你不能把一个换行符之前的(在一个函数调用。这个限制可以避免一些模棱两可的语言。如果你写

     a = f
     (g).x(a)

Lua会发现作为一个单独的语句,一个= f(g)方式(一)。所以,如果你想要两个语句,您必须添加一个分号。如果你真的想打电话f,你必须删除换行符(g)。

一个电话的形式返回functioncall被称为一个尾部调用。Lua实现适当的尾部调用(或适当的尾递归):在尾部调用,被调用的函数重用堆栈调用函数的入口。因此,没有限制嵌套尾部调用的数量一个程序可以执行。然而,尾部调用擦除任何调试信息调用函数。注意,尾部调用只发生在一个特定的语法,在哪里返回有一个函数调用的参数;这个语法准确调用函数返回被调用的函数的返回。所以,没有尾调用下面的例子:

     return (f(x))        -- results adjusted to 1
     return 2 * f(x)
     return x, f(x)       -- additional results
     f(x); return         -- results discarded
     return x or f(x)     -- results adjusted to 1

2.5.9￠A€“函数定义

函数定义的语法

	function ::= function funcbody
	funcbody ::= `(′ [parlist] `)′ block end

以下语法简化函数定义:

	stat ::= function funcname funcbody
	stat ::= local function Name funcbody
	funcname ::= Name {`.′ Name} [`:′ Name]

该声明

     function f () body end

翻译为

     f = function () body end

该声明

     function t.a.b.c.f () body end

翻译为

     t.a.b.c.f = function () body end

该声明

     local function f () body end

翻译为

     local f; f = function () body end

不来

     local f = function () body end

(这只会让不同的身体功能包含引用f)。

函数定义是一个可执行的表达式,值的类型函数。Lua预编译一个块时,其所有功能的身体也是预编译。然后,每当Lua执行函数定义,函数是实例化(或关闭)。这个函数(或实例关闭)是最终的表达式的值。相同的功能的不同实例可以参考不同的外部局部变量和环境可以有不同的表。

参数作为局部变量初始化参数值:

	parlist ::= namelist [`,′ `...′] | `...′

当一个函数被调用时,调整的参数列表参数列表的长度,除非是一个可变或函数可变长度的函数,这是由三个点(‘…”)结束时,它的参数列表。一个可变长度函数不调整其参数列表;相反,它收集所有额外的参数和物资通过一个函数可变长度的表达式,这也是写成三个点。这个表达式的值是一个列表的所有实际的额外的参数,类似于一个函数有多个结果。如果使用一个变量参数表达式在另一个表达式或表达式的列表中,然后它返回一个元素调整列表。如果表达式作为一列表达式的最后一个元素,然后没有调整(除非最后括号中的表达式)。

作为一个例子,考虑以下定义:

     function f(a, b) end
     function g(a, b, ...) end
     function r() return 1,2,3 end

然后,我们有以下参数和参数的映射可变长度的表达式:

     CALL            PARAMETERS
     
     f(3)             a=3, b=nil
     f(3, 4)          a=3, b=4
     f(3, 4, 5)       a=3, b=4
     f(r(), 10)       a=1, b=10
     f(r())           a=1, b=2
     
     g(3)             a=3, b=nil, ... -->  (nothing)
     g(3, 4)          a=3, b=4,   ... -->  (nothing)
     g(3, 4, 5, 8)    a=3, b=4,   ... -->  5  8
     g(5, r())        a=5, b=1,   ... -->  2  3

结果返回使用返回声明(见?§2.4.4)。如果控制达到一个函数的结束没有遇到一个返回声明中,然后函数返回任何结果。

的结肠语法用于定义方法,也就是说,有一个隐含的附加参数的函数自我。因此,声明

     function t.a.b.c:f (params) body end

是语法糖

     t.a.b.c.f = function (self, params) body end

￠A€2.6”可见性规则

Lua是一个词法作用域的语言。在第一个声明变量的范围开始后他们的声明和持续到最里面的块的结束包括声明。考虑下面的例子:

     x = 10                -- global variable
     do                    -- new block
       local x = x         -- new ‘x‘, with value 10
       print(x)            --> 10
       x = x+1
       do                  -- another block
         local x = x+1     -- another ‘x‘
         print(x)          --> 12
       end
       print(x)            --> 11
     end
     print(x)              --> 10  (the global one)

注意,在一个声明当地x = x,新x声明是没有范围,所以第二个x是指外部变量。

由于词法范围规则,局部变量可以自由访问功能他们的范围内定义的。一个局部变量使用的内部函数一个upvalue,或外部本地变量,在内部函数。

注意,每个执行当地的声明定义了新的局部变量。考虑下面的例子:

     a = {}
     local x = 20
     for i=1,10 do
       local y = 0
       a[i] = function () y=y+1; return x+y end
     end

循环创建十闭包(即10匿名函数的实例)。这些闭包使用不同y变量,尽管它们共享相同的x。

￠A€2.7”错误处理

因为Lua是一种嵌入式扩展语言,Lua的所有行动从CA?主程序代码从Lua调用一个函数库(见lua_pcall)。当一个错误发生在Lua编译或执行,控制返回到C,可以采取适当的措施(如打印错误消息)。

Lua代码可以通过调用显式地生成一个错误错误函数。如果您需要捕获错误在Lua中,您可以使用pcall函数。

￠A€2.8”元表

Lua中的每个值都可以元表。这元表是一个普通的Lua表吗定义的行为的原始值在某些特殊的操作。你可以改变的几个方面的行为的操作在一个值通过设置特定字段元表。例如,当一个非数字值的操作数是一个,Lua函数检查“__add”元表。如果找到一个,Lua调用这个函数来执行的。

我们称之为元表中的键事件和值元方法。在上一个示例中,事件“添加”元方法是执行的函数。

您可以查询任何值的元表通过getmetatable函数。

你可以换表的元表通过setmetatable函数。你不能改变其他类型的元表从Lua(通过使用调试库除外);你必须使用CA?API。

表个人元表和完整的用户数据(尽管多个表和用户数据可以共享他们的元表)。所有其他类型共享一个单一的值元表每类型;也就是说,有一个单元表为所有数字,一个用于所有字符串等。

在算术运算元表控制一个对象的行为,订单比较、连接长度操作,和索引。元表也可以定义一个函数被称为用户数据是垃圾收集。对于每个这些操作Lua associates的一个特定的关键被称为事件。当Lua执行一个操作在一个值,它会检查这个值是否有元表对应的事件。如果是这样,与该密钥关联的值(元方法)控制Lua将如何执行操作。

元表列出的操作控制。每一个操作都是由其对应的名称标识。每个操作的关键是一个字符串名称前缀两个下划线,__”;例如,“添加”的关键操作字符串“__add”。这些操作的语义解释为一个Lua函数要好描述如何解释器执行操作。

在Lua代码只是说明;真正的翻译行为是硬编码的它是比这更有效的模拟。这些描述中使用的所有功能(rawget,当时等)。介绍了?§5.1。特别是,检索一个给定对象的元方法,我们使用的表达式

     metatable(obj)[event]

这应该是阅读

     rawget(getmetatable(obj) or {}, event)

即访问元方法不能调用其他元方法,和访问对象没有元表并不失败(只是结果零)。

• “添加”:的+操作。

  这个函数getbinhandler下面定义了Lua如何选择一个处理程序二元运算。首先,Lua尝试第一个操作数。如果它的类型没有定义处理程序操作,然后Lua尝试第二个操作数。

       function getbinhandler (op1, op2, event)
         return metatable(op1)[event] or metatable(op2)[event]
       end
  

  通过使用这个函数,的行为op1 + op2是

       function add_event (op1, op2)
         local o1, o2 = tonumber(op1), tonumber(op2)
         if o1 and o2 then  -- both operands are numeric?
           return o1 + o2   -- ‘+‘ here is the primitive ‘add‘
         else  -- at least one of the operands is not numeric
           local h = getbinhandler(op1, op2, "__add")
           if h then
             -- call the handler with both operands
             return (h(op1, op2))
           else  -- no handler available: default behavior
             error(···)
           end
         end
       end
  

• “子”:的- - - - - -操作。行为类似于“添加”操作。
• “mul”:的*操作。行为类似于“添加”操作。
• " div ":的/操作。行为类似于“添加”操作。
• “国防部”:的%操作。行为类似于“添加”操作,与操作o1 -地板(o1 / o2)* o2原始的操作。
• “战俘”:的^(求幂)操作。行为类似于“添加”操作,与函数战俘(从CA?数学库)原始的操作。
• “在野”:一元的- - - - - -操作。

       function unm_event (op)
         local o = tonumber(op)
         if o then  -- operand is numeric?
           return -o  -- ‘-‘ here is the primitive ‘unm‘
         else  -- the operand is not numeric.
           -- Try to get a handler from the operand
           local h = metatable(op).__unm
           if h then
             -- call the handler with the operand
             return (h(op))
           else  -- no handler available: default behavior
             error(···)
           end
         end
       end
  

• “concat”:的. .(连接)的操作。

       function concat_event (op1, op2)
         if (type(op1) == "string" or type(op1) == "number") and
            (type(op2) == "string" or type(op2) == "number") then
           return op1 .. op2  -- primitive string concatenation
         else
           local h = getbinhandler(op1, op2, "__concat")
           if h then
             return (h(op1, op2))
           else
             error(···)
           end
         end
       end
  

• “兰”:的#操作。

       function len_event (op)
         if type(op) == "string" then
           return strlen(op)         -- primitive string length
         elseif type(op) == "table" then
           return #op                -- primitive table length
         else
           local h = metatable(op).__len
           if h then
             -- call the handler with the operand
             return (h(op))
           else  -- no handler available: default behavior
             error(···)
           end
         end
       end
  

  看到一个?§2.5.5描述的一个表的长度。

• “情商”:的= =操作。这个函数getcomphandler定义了如何Lua选择元方法比较运算符。选择元方法只有当两个对象相比较具有相同的类型和相同的元方法对所选的操作。

       function getcomphandler (op1, op2, event)
         if type(op1) ~= type(op2) then return nil end
         local mm1 = metatable(op1)[event]
         local mm2 = metatable(op2)[event]
         if mm1 == mm2 then return mm1 else return nil end
       end
  

  “情商”事件被定义如下:

       function eq_event (op1, op2)
         if type(op1) ~= type(op2) then  -- different types?
           return false   -- different objects
         end
         if op1 == op2 then   -- primitive equal?
           return true   -- objects are equal
         end
         -- try metamethod
         local h = getcomphandler(op1, op2, "__eq")
         if h then
           return (h(op1, op2))
         else
           return false
         end
       end
  

  ~ = b相当于(a = =)。

• “lt”:的<操作。

       function lt_event (op1, op2)
         if type(op1) == "number" and type(op2) == "number" then
           return op1 < op2   -- numeric comparison
         elseif type(op1) == "string" and type(op2) == "string" then
           return op1 < op2   -- lexicographic comparison
         else
           local h = getcomphandler(op1, op2, "__lt")
           if h then
             return (h(op1, op2))
           else
             error(···)
           end
         end
       end
  

  a >相当于b <。

• “勒”:的< =操作。

       function le_event (op1, op2)
         if type(op1) == "number" and type(op2) == "number" then
           return op1 <= op2   -- numeric comparison
         elseif type(op1) == "string" and type(op2) == "string" then
           return op1 <= op2   -- lexicographic comparison
         else
           local h = getcomphandler(op1, op2, "__le")
           if h then
             return (h(op1, op2))
           else
             h = getcomphandler(op1, op2, "__lt")
             if h then
               return not h(op2, op1)
             else
               error(···)
             end
           end
         end
       end
  

  a > =相当于b < =。注意,在缺乏“勒”元方法,Lua尝试“lt”,假设< = b是相当于不是(b <)。

• “指数”:索引访问表(例子)。

       function gettable_event (table, key)
         local h
         if type(table) == "table" then
           local v = rawget(table, key)
           if v ~= nil then return v end
           h = metatable(table).__index
           if h == nil then return nil end
         else
           h = metatable(table).__index
           if h == nil then
             error(···)
           end
         end
         if type(h) == "function" then
           return (h(table, key))     -- call the handler
         else return h[key]           -- or repeat operation on it
         end
       end
  

• “newindex”:索引分配表(例子)=价值。

       function settable_event (table, key, value)
         local h
         if type(table) == "table" then
           local v = rawget(table, key)
           if v ~= nil then rawset(table, key, value); return end
           h = metatable(table).__newindex
           if h == nil then rawset(table, key, value); return end
         else
           h = metatable(table).__newindex
           if h == nil then
             error(···)
           end
         end
         if type(h) == "function" then
           h(table, key,value)           -- call the handler
         else h[key] = value             -- or repeat operation on it
         end
       end
  

• “电话”:时调用Lua调用一个值。

       function function_event (func, ...)
         if type(func) == "function" then
           return func(...)   -- primitive call
         else
           local h = metatable(func).__call
           if h then
             return h(func, ...)
           else
             error(···)
           end
         end
       end
  

￠A€2.9”环境

除了元表,线程的对象类型,功能和用户数据具有与其相关联的另一个表,称他们环境。像元表,是普通表和环境多个对象可以共享相同的环境。

线程是共享的环境创建线程创建的。用户数据和CA?函数创建共享环境创建的CA?一个函数。Non-nested Lua函数(由loadfile,loadstring或负载)在创建线程创建共享的环境。嵌套的Lua函数创建共享的环境创建Lua函数。

环境对Lua与用户数据没有意义。只有一个方便的特性为程序员关联表用户数据。

环境与线程相关联全球环境。使用它们作为默认线程和环境non-nested Lua函数创建的线程,可以直接访问CA?代码(见?§3.3)。

环境与CA?可以直接的函数访问CA?代码(见?§3.3)。它被用作默认环境其他CA?功能和用户数据创建的函数。

环境与Lua函数用于解析所有访问全局变量在函数(见?§2.3)。使用它们作为默认环境嵌套Lua函数创建的函数。

你可以改变的环境或者一个Lua函数运行的线程通过调用setfenv。你可以得到一个Lua函数的环境或运行的线程通过调用getfenv。其他对象的操作环境(用户数据、CA?功能,其他线程)你必须使用CA?一个API。

￠A€2.10”垃圾收集

Lua执行自动内存管理。这意味着你必须既不担心为新对象分配内存也没有关于释放时不再需要的对象。Lua自动管理内存运行一个垃圾收集器不时地收集所有死对象(即对象不再从Lua访问)。所有内存使用Lua受到自动管理:表、用户数据、函数、线程、字符串等等。

Lua实现增量标记和清扫收集器。它使用两个数字来控制它的垃圾收集周期:的垃圾收集器暂停和的垃圾收集器一步乘数。都是用百分比作为单位(这样的值100表示内部1)的价值。

垃圾收集器暂停控制收集器等待多久才能开始一个新的周期。较大的值使收集器不那么咄咄逼人。值小于100意味着收集器不会等待开始一个新的周期。值200意味着收集器等使用的内存总量在开始一个新的循环翻倍。

一步乘数收集器的相对速度相对于控件内存分配。较大的值使收集器更激进的但也增加每一增量步的大小。值小于100使收集器太慢,可能导致收集器从来没有完成一个循环。200年违约,意味着收集器运行在“两次”内存分配的速度。

你可以改变这些数字通过调用lua_gc在C语言中或collectgarbage在Lua中。与这些功能还可以控制(如直接收集器。 停止并重新启动它)。

2.10.1￠A€“垃圾收集元方法

使用CA?API,你可以设置为用户数据(见垃圾收集器元方法?§2.8)。这些元方法也称为终结器。终结器允许您协调Lua的垃圾收集与外部资源管理(比如关闭文件、网络或数据库连接或释放自己的内存)。

垃圾用户数据字段__gc在他们的元表立即被垃圾收集器收集。相反,Lua使他们在一个列表。集合后,Lua相当于以下函数为每个用户数据列表:

     function gc_event (udata)
       local h = metatable(udata).__gc
       if h then
         h(udata)
       end
     end

在每一个垃圾收集周期结束时,用户数据被称为的终结器反向订单的创建、那些收集周期。也就是说,第一个终结器被称为是相关联的与去年在程序中创建的用户数据。用户数据本身释放下一个垃圾收集周期。

2.10.2￠A€“弱的表

一个弱的表表的元素是什么弱引用。弱引用由垃圾收集器将被忽略。换句话说,如果只弱引用引用一个对象,垃圾收集器将收集该对象。

表可以有弱弱键,弱的价值观,或两者兼而有之。一个表的弱键允许收集钥匙,但防止其值的集合。一个表与弱键和弱值允许的集合这两个键和值。在任何情况下,如果键或值收集,整个就会从表中删除。表的弱点是控制的__mode元表的字段。如果__mode字段是一个字符串包含characterA?“k”,表中的键较弱。如果__mode包含的v”,表中的值弱。

使用一个表作为元表之后,你不应该改变它的值__mode字段。否则,弱者的行为控制的表元表是未定义的。

￠A€2.11”协同程序

Lua支持协同程序,也被称为协作的多线程。在Lua中协同程序代表一个独立的线程中执行的。然而,与线程在多流系统中,通过显式地调用协同程序只暂停其执行一个屈服函数。

您创建一个协同程序调用coroutine.create。其唯一的参数是一个函数这是协同程序的主要功能。的创建只有创建一个新的协同程序和函数返回一个句柄(一种类型的对象线程);它不启动协同程序执行。

当你第一次叫coroutine.resume,作为第一个参数一个线程返回的coroutine.create,协同程序开始执行,在第一行的主要功能。额外的参数传递给coroutine.resume通过在协同程序的主要功能。协同程序开始运行后,它运行,直到终止或者收益率。

协同程序可以终止执行在两个方面:通常情况下,当它的主要函数返回(直接或间接地在最后一个指令);异常,如果有一个不受保护的错误。在第一种情况下,coroutine.resume返回真正的,+协同程序主要功能返回的任何值。在错误的情况下,coroutine.resume返回假加上一条错误消息。

一个协同程序通过调用coroutine.yield。当一个协同程序的收益率,相应的coroutine.resume立即返回,即使收益率发生内嵌套的函数调用(也就是说,不是在主函数,但在一个函数直接或间接地由主函数调用)。在收益率的情况下,coroutine.resume同样的回报真正的,加任何值传递给coroutine.yield。下次你的简历相同的协同程序,它继续执行的地方了,与调用coroutine.yield返回任何额外的参数传递给coroutine.resume。

就像coroutine.create,的coroutine.wrap函数还创建了一个协同程序,而是返回协同程序本身,它返回一个函数,调用时,简历协同程序。任何参数传递给该函数作为额外的参数coroutine.resume。coroutine.wrap返回所有返回的值coroutine.resume,除了第一个(布尔错误代码)。不像coroutine.resume,coroutine.wrap不捕获错误;任何错误传播给调用者。

作为一个例子,考虑下面的代码:

     function foo (a)
       print("foo", a)
       return coroutine.yield(2*a)
     end
     
     co = coroutine.create(function (a,b)
           print("co-body", a, b)
           local r = foo(a+1)
           print("co-body", r)
           local r, s = coroutine.yield(a+b, a-b)
           print("co-body", r, s)
           return b, "end"
     end)
            
     print("main", coroutine.resume(co, 1, 10))
     print("main", coroutine.resume(co, "r"))
     print("main", coroutine.resume(co, "x", "y"))
     print("main", coroutine.resume(co, "x", "y"))

当你运行它时,它将生成以下输出:

     co-body 1       10
     foo     2
     
     main    true    4
     co-body r
     main    true    11      -9
     co-body x       y
     main    true    10      end
     main    false   cannot resume dead coroutine

3 A￠A€“应用程序接口

本节描述CA?Lua的API,也就是说,CA?函数的设置可以沟通的主程序Lua。所有API函数和相关类型和常量头文件中声明吗lua.h。

即使我们使用术语“函数”,API的任何设施可能是作为一个宏提供。所有这些宏使用每个他们的论点完全一次(除了第一个参数,这一直是一个Lua状态),所以不生成任何隐藏的副作用。

在大多数CA?库,Lua API函数不检查他们的论点有效性和一致性。但是,你可以改变这种行为通过编译Lua用一个合适的宏定义luai_apicheck,在文件luaconf.h。

￠A€3.1”堆栈

Lua使用虚拟堆栈通过与C值。这个堆栈中的每个元素表示一个Lua的价值(零、数字、字符串,等等)。

每当Lua调用C调用函数得到一个新的堆栈,这是独立的以前的栈和堆的CA?功能仍然活跃。这个堆栈首先包含任何CA?一个函数的参数这就是CA?函数将其结果(见返回给调用者lua_CFunction)。

为了方便起见,大多数查询操作的API堆栈不遵循一个严格的纪律。相反,他们可以引用任何元素的堆栈通过使用一个指数:一个积极的指标代表了绝对堆栈的位置(atA?1开始);一个消极的指数代表了抵消相对于堆栈的顶部。更具体地说,如果栈n元素,然后indexA?1代表第一个元素(即元素被压入堆栈第一)和indexA?一n表示最后一个元素;indexA?1也表示最后一个元素(即元素在西娅?最高)和索引- n代表第一个元素。我们说一个索引有效的如果?之间的谎言1和堆栈的顶部(也就是说,如果1一个￠‰¤abs(指数)一个￠‰¤)。

￠A€3.2”堆栈大小

当你与Lua API交互,你负责保证一致性。特别是,你是负责控制堆栈溢出。您可以使用函数lua_checkstack堆栈大小。

每当Lua调用C,至少它确保LUA_MINSTACK堆栈的位置是可用的。LUA_MINSTACK被定义为20,通常你不需要担心堆栈空间除非你的代码循环推动元素压入堆栈。

大多数查询函数接受指数内的任何值可用的堆栈空间,即指数最大堆栈大小你将通过lua_checkstack。这些指标被称为可接受的指标。更正式,我们定义一个可接受的指数如下:

     (index < 0 && abs(index) <= top) ||
     (index > 0 && index <= stackspace)

注意,0是不可以接受的指数。

￠A€3.3”Pseudo-Indices

除非另外注明,任何函数,它接受有效的指标也可以使用pseudo-indices,这代表了Lua值访问CA?代码但不是在堆栈。Pseudo-indices用于访问线程环境,这个函数的环境,注册表,和CA的upvalues?一个函数(见?§3.4)。

线程环境(全局变量居住)总是在pseudo-indexLUA_GLOBALSINDEX。的环境运行CA?总是一个函数在pseudo-indexLUA_ENVIRONINDEX。

访问和改变全局变量的值,您可以使用常规表操作在一个环境表。例如,访问一个全局变量的值,

     lua_getfield(L, LUA_GLOBALSINDEX, varname);

￠A€3.4”C闭包

当一个CA?创建一个函数时,可以把一些值,因此创建一个CA?闭包;这些值被称为upvalues并无论何时调用访问函数(见lua_pushcclosure)。

每当一个CA?函数被调用时,其upvalues位于特定pseudo-indices。这些pseudo-indices产生的宏lua_upvalueindex。第一个值与位置的函数lua_upvalueindex(1),等等。任何访问lua_upvalueindex(n),在哪里n的数量大于upvalues的吗当前函数(但不大于256),产生一个可接受的(但无效)指数。

￠A€3.5”注册表

Lua提供了一个注册表,一个预定义的表,可以使用任何CA?代码它需要存储中存储任何Lua的值。这张桌子总是位于pseudo-indexLUA_REGISTRYINDEX。任何CA?图书馆可以将数据存储到此表中,但它应该小心选择密钥不同于使用其他库,避免碰撞。通常,您应该使用关键字符串包含库名称光或用户数据与CA?对象的地址在您的代码中。

使用的整数键在注册表中引用机制,由辅助实现图书馆,因此不应该用于其他用途。

￠A€3.6”C中的错误处理

在内部,Lua使用Clongjmp设施来处理错误。(你也可以选择使用如果您使用c++异常;看到文件luaconf.h)。当Lua面临任何错误(如内存分配错误,输入错误,语法错误,和运行时错误)它提出了一个错误;也就是说,它是跳远。一个保护环境使用setjmp设置一个恢复点;任何错误跳到最近的积极恢复点。

大多数功能的API可以抛出一个错误,例如由于内存分配错误。每个函数的文档表明是否它可以把错误。

在CA?通过调用函数可以抛出一个错误lua_error。

￠A€3.7”函数和类型

在这里我们列出所有CA?API的功能和类型字母顺序排列。每个函数都有一个指标:[+ p - o,x]

第一个字段,o,有多少元素函数从堆栈中弹出。第二个字段,p,有多少元素功能推到堆栈。(任何函数总是将其结果弹出后参数。)一个字段在表单中x y |意味着函数可以推动(或流行)x或y元素,根据不同的情况;一个问号吗?”意味着我们无法知道有多少元素函数弹出/推通过只看其参数(如。 ,他们可能取决于是在堆栈上)。第三个字段,x,告诉是否函数可能抛出错误:”- - - - - -”意味着函数不会抛出任何错误;”米意味着函数可能抛出一个错误由于没有足够的内存;”e意味着函数可能抛出其他类型的错误;”v意味着函数可能抛出一个错误。

lua_Alloc

typedef void * (*lua_Alloc) (void *ud,
                             void *ptr,
                             size_t osize,
                             size_t nsize);

体的类型函数使用Lua状态。必须提供一个分配器功能功能类似于realloc,但不是完全一样。它的参数是ud,一个不透明的指针传递给lua_newstate;ptr被分配一个指针,块/重新分配/释放;osize原始大小的块;nsize,新块的大小。ptr是零当且仅当osize是零。当nsize是零,分配器必须返回零;如果osize不为零,它应该自由块指出ptr。当nsize不为零,分配器返回零当且仅当它不能填补这一请求。当nsize不为零,osize是零,分配器应该像malloc。当nsize和osize不为零,分配器像realloc。Lua假设分配器从来没有失败的时候osize > = nsize。

这是一个简单的实现分配器的功能。它用于辅助库luaL_newstate。

     static void *l_alloc (void *ud, void *ptr, size_t osize,
                                                size_t nsize) {
       (void)ud;  (void)osize;  /* not used */
       if (nsize == 0) {
         free(ptr);
         return NULL;
       }
       else
         return realloc(ptr, nsize);
     }

这段代码假设那免费(空)这没有影响呢realloc(NULL,大小)相当于malloc(大小)。ANSIA?C保证行为。

lua_atpanic

(0 + 0- - - - - -]

lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);

设置一个新的恐慌函数并返回旧的。

如果一个错误发生了任何保护环境外,Lua调用一个恐慌的功能,然后调用退出(EXIT_FAILURE),因此退出主机应用程序。你的恐慌函数可以避免这个出口从来没有返回(如。 ,做一个跳远)。

恐慌函数可以访问错误消息在堆栈的顶部。

lua_call

【——+ nresults(娜戈+ 1)e]

void lua_call (lua_State *L, int nargs, int nresults);

调用一个函数。

要调用一个函数必须使用以下协议:首先,函数被称为推到堆栈;然后,将函数的参数在直接命令;也就是说,第一个参数是第一。最后你叫lua_call;娜戈参数的数量,你推到堆栈。所有参数和函数值从堆栈中弹出当函数被调用。函数结果推到堆栈时,函数返回。结果调整的数量nresults,除非nresults是LUA_MULTRET。在这种情况下,所有函数的结果。Lua负责返回的值放入堆栈空间。函数结果推到堆栈直接订单(第一个结果是推动第一),这叫后最后的结果是在堆栈的顶部。

任何错误在调用函数向上传播(longjmp)。

下面的例子显示了如何主机程序可以做这相当于Lua代码:

     a = f("how", t.x, 14)

这是在?C:

     lua_getfield(L, LUA_GLOBALSINDEX, "f"); /* function to be called */
     lua_pushstring(L, "how");                        /* 1st argument */
     lua_getfield(L, LUA_GLOBALSINDEX, "t");   /* table to be indexed */
     lua_getfield(L, -1, "x");        /* push result of t.x (2nd arg) */
     lua_remove(L, -2);                  /* remove ‘t‘ from the stack */
     lua_pushinteger(L, 14);                          /* 3rd argument */
     lua_call(L, 3, 1);     /* call ‘f‘ with 3 arguments and 1 result */
     lua_setfield(L, LUA_GLOBALSINDEX, "a");        /* set global ‘a‘ */

请注意,上面的代码是“平衡”:在战争结束后,栈是回到原来的配置。这被认为是良好的编程实践。

lua_CFunction

typedef int (*lua_CFunction) (lua_State *L);

CA?函数类型。

为了正确地与Lua沟通,CA?一个函数必须使用以下协议,它定义了参数和结果传递方式:CA?从Lua函数接收其参数在堆栈在直接命令(第一个参数是推动第一)。所以,当函数开始,lua_gettop(左)返回接收到的参数数量的函数。第一个参数(如果有的话)是在指数1和最后的论点是在索引lua_gettop(左)。返回值Lua,CA?一个函数只是把他们放入堆栈中,在直接命令(第一个结果是推动第一),并返回结果的数量。任何其他值在下面的堆栈将正确的结果Lua丢弃。像一个Lua函数,CA?调用Lua函数也可以返回许多结果。

作为一个例子,下面的函数接收一个变量数数值参数并返回他们的平均金额:

     static int foo (lua_State *L) {
       int n = lua_gettop(L);    /* number of arguments */
       lua_Number sum = 0;
       int i;
       for (i = 1; i <= n; i++) {
         if (!lua_isnumber(L, i)) {
           lua_pushstring(L, "incorrect argument");
           lua_error(L);
         }
         sum += lua_tonumber(L, i);
       }
       lua_pushnumber(L, sum/n);        /* first result */
       lua_pushnumber(L, sum);         /* second result */
       return 2;                   /* number of results */
     }

lua_checkstack

(0 + 0米]

int lua_checkstack (lua_State *L, int extra);

确保至少有额外的堆栈的栈槽自由。它返回false如果不能生长的堆栈大小。这个函数没有收缩堆栈;如果栈已经大于新大小,这是保持不变。

lua_close

(0 + 0- - - - - -]

void lua_close (lua_State *L);

摧毁所有对象在给定的Lua状态(调用相应的垃圾收集元方法,如果有的话)和释放所有动态内存使用的这种状态。在一些平台上,你可能不需要调用这个函数,因为所有自然资源主机程序结束的时候发布的。另一方面,长时间运行的程序,如守护进程或一个web服务器,可能需要释放状态就不需要,为了避免太大增长。

lua_concat

(- n + 1,e]

void lua_concat (lua_State *L, int n);

连接的n值在堆栈的顶部,持久性有机污染物,叶子顶部的结果。如果n一个isA??1,结果是堆栈上的单一值(即函数没有);如果n是0,结果是空字符串。连接完成后,通常的Lua的语义(见?2.5.4§)。

lua_cpcall

[0,+(0 | 1),- - - - - -]

int lua_cpcall (lua_State *L, lua_CFunction func, void *ud);

调用CA?一个函数函数在保护模式。函数开始只有一个元素的堆栈,轻用户数据包含ud。在错误的情况下,lua_cpcall返回的错误代码lua_pcall,加上错误对象在堆栈的顶部;否则,它将返回零,不会改变栈。返回的所有值函数被丢弃。

lua_createtable

(0,+ 1,米]

void lua_createtable (lua_State *L, int narr, int nrec);

创建一个新的空表,把它压入堆栈。预先分配的新表空间为narr数组元素和nrec非数组元素。这个预先分配是非常有用的,当你知道有多少元素表会。否则你可以使用函数lua_newtable。

lua_dump

(0 + 0米]

int lua_dump (lua_State *L, lua_Writer writer, void *data);

转储函数作为二进制块。收到一个Lua函数在堆栈的顶部并产生一个二进制块,如果加载一次,结果在一个函数中相当于一个倾倒。生产部分的一部分,lua_dump调用函数作家(见lua_Writer)用给定的数据写他们。

返回的值是返回的错误代码调用作家;0?意味着没有错误。

这个函数并不流行Lua函数的堆栈。

lua_equal

(0 + 0e]

int lua_equal (lua_State *L, int index1, int index2);

返回1,如果两个值在可接受的指标index1和index2是相等的,Lua的语义= =操作符(即可以叫元方法)。否则returnsA?0。还returnsA?0如果任何指标是非有效的。

lua_error

(1 + 0v]

int lua_error (lua_State *L);

生成一个Lua错误。错误消息(可以是任何类型的Lua价值)必须在堆栈上。这个函数是跳远,因此没有回报。(见luaL_error)。

lua_gc

(0 + 0e]

int lua_gc (lua_State *L, int what, int data);

控制垃圾收集器。

这个函数执行一些任务,根据参数的值什么:

• LUA_GCSTOP:停止垃圾收集器。
• LUA_GCRESTART:重新启动垃圾收集器。
• LUA_GCCOLLECT:执行一个完整的垃圾收集周期。
• LUA_GCCOUNT:返回当前的内存使用Lua(kb)。
• LUA_GCCOUNTB:返回的其余部分将当前的字节的数量在1024年使用Lua的记忆。
• LUA_GCSTEP:执行增量步的垃圾收集。这一步是由“大小”数据(大值意味着更多的步骤)不特定的方式。如果你想控制步长你必须通过实验优化的价值数据。如果步骤完成一个函数返回1垃圾收集周期。
• LUA_GCSETPAUSE:集数据随着新值为暂停的收集器(见?§2.10)。函数返回之前的停顿。
• LUA_GCSETSTEPMUL:集数据的新值一步乘数的收集器(见?§2.10)。的函数返回之前的价值乘数。

lua_getallocf

(0 + 0- - - - - -]

lua_Alloc lua_getallocf (lua_State *L, void **ud);

返回给定状态的所有功能。如果ud不是零,Lua商店* ud的不透明的指针传递给lua_newstate。

lua_getfenv

(0,+ 1,- - - - - -]

void lua_getfenv (lua_State *L, int index);

推到堆栈的环境表在给定的索引值。

lua_getfield

(0,+ 1,e]

void lua_getfield (lua_State *L, int index, const char *k);

推到堆栈的价值t[k],在哪里t是在给定的有效指数的值。在Lua中,这个函数可能会触发一个元方法(见“指数”事件?§2.8)。

lua_getglobal

(0,+ 1,e]

void lua_getglobal (lua_State *L, const char *name);

推到堆栈全球的价值的名字。它被定义为一个宏:

     #define lua_getglobal(L,s)  lua_getfield(L, LUA_GLOBALSINDEX, s)

lua_getmetatable

[0,+(0 | 1),- - - - - -]

int lua_getmetatable (lua_State *L, int index);

推到堆栈的元表在给定的值可接受的指数。如果索引是无效的,或者如果没有元表的值,函数returnsA?0和推到栈上。

lua_gettable

(1 + 1e]

void lua_gettable (lua_State *L, int index);

推到堆栈的价值t[k],在哪里t值在给定的有效指数吗和k是在堆栈的顶部的值。

这个函数从堆栈中持久性有机污染物的关键(把得到的值在其位置)。在Lua中,这个函数可能会触发一个元方法(见“指数”事件?§2.8)。

lua_gettop

(0 + 0- - - - - -]

int lua_gettop (lua_State *L);

返回堆栈顶部元素的索引。因为指数开始atA?1,这个结果等于栈中元素的数量(所以0?意味着一个空栈)。

lua_insert

(1 + 1- - - - - -]

void lua_insert (lua_State *L, int index);

顶部元素移动到给定的有效指数,上面的元素这个指数转向开放空间。不能被称为pseudo-index,因为pseudo-index不是一个实际的堆栈的位置。

lua_Integer

typedef ptrdiff_t lua_Integer;

Lua API所使用的类型来表示积分值。

在默认情况下这是一个ptrdiff,通常签署的最大整型机处理“舒适”。

lua_isboolean

(0 + 0- - - - - -]

int lua_isboolean (lua_State *L, int index);

1如果返回值在给定的可接受的指数型布尔,和0?否则。

lua_iscfunction

(0 + 0- - - - - -]

int lua_iscfunction (lua_State *L, int index);

1如果返回值在给定的可接受的指数是一个CA?一个函数,和0?否则。

lua_isfunction

(0 + 0- - - - - -]

int lua_isfunction (lua_State *L, int index);

1如果返回值在给定的可接受的指数函数(Lua或C)和0?否则。

lua_islightuserdata

(0 + 0- - - - - -]

int lua_islightuserdata (lua_State *L, int index);

1如果返回值在给定的可接受的指数是一个用户数据,和0?否则。

lua_isnil

(0 + 0- - - - - -]

int lua_isnil (lua_State *L, int index);

1如果返回值在给定的可接受的指数零,和0?否则。

lua_isnone

(0 + 0- - - - - -]

int lua_isnone (lua_State *L, int index);

返回1如果给定的可接受的指数是无效的(也就是说,它是指一种元素在当前堆栈),和0?否则。

lua_isnoneornil

(0 + 0- - - - - -]

int lua_isnoneornil (lua_State *L, int index);

返回1如果给定的可接受的指数是无效的(也就是说,它是指一种元素在当前栈)或者在这个索引值零,和0?否则。

lua_isnumber

(0 + 0- - - - - -]

int lua_isnumber (lua_State *L, int index);

1如果返回值在给定的可接受的指数是一个数字或字符串转换到一个数字,和0?否则。

lua_isstring

(0 + 0- - - - - -]

int lua_isstring (lua_State *L, int index);

1如果返回值在给定的可接受的指数是一个字符串或数量(总是可转换字符串),和0?否则。

lua_istable

(0 + 0- - - - - -]

int lua_istable (lua_State *L, int index);

1如果返回值在给定的可接受的索引是一个表,和0?否则。

lua_isthread

(0 + 0- - - - - -]

int lua_isthread (lua_State *L, int index);

1如果返回值在给定的可接受的指数是一个线程,和0?否则。

lua_isuserdata

(0 + 0- - - - - -]

int lua_isuserdata (lua_State *L, int index);

1如果返回值在给定的可接受的指数是一个用户数据(全部或光线),0?否则。

lua_lessthan

(0 + 0e]

int lua_lessthan (lua_State *L, int index1, int index2);

如果可接受的价值指数返回1index1更小比可接受的价值指数index2,Lua的语义<操作符(即可以叫元方法)。否则returnsA?0。还returnsA?0如果任何指标是非有效的。

lua_load

(0,+ 1,- - - - - -]

int lua_load (lua_State *L,
              lua_Reader reader,
              void *data,
              const char *chunkname);

加载一个Lua块。如果没有错误,lua_load将编译Lua块函数的堆栈。否则,它将一个错误消息。的返回值lua_load是:

• 0:没有错误;
• LUA_ERRSYNTAX:语法错误在pre-compilation;
• LUA_ERRMEM:内存分配错误。

这个函数只加载一块;它不运行它。

lua_load自动检测是否文本或二进制块,和装载它相应的程序luac)。

的lua_load函数使用一个用户提供的读者函数读取块(见lua_Reader)。的数据参数是一个不透明的价值传递给读者的功能。

的chunkname参数块给了一个名字,用于错误信息和调试信息(看到了吗?§3.8)。

lua_newstate

(0 + 0- - - - - -]

lua_State *lua_newstate (lua_Alloc f, void *ud);

创建一个新的、独立的国家。返回零如果不能创建状态(由于缺乏内存)。这个论点f分配器的功能;Lua是这个州的所有内存分配通过这个函数。第二个参数,ud是一个不透明的指针,Lua仅仅通过在每次调用分配器。

lua_newtable

(0,+ 1,米]

void lua_newtable (lua_State *L);

创建一个新的空表,把它压入堆栈。它相当于lua_createtable(L,0,0)。

lua_newthread

(0,+ 1,米]

lua_State *lua_newthread (lua_State *L);

创建一个新的线程,把它在堆栈上,并返回一个指针lua_State代表这个新线程。这个函数返回的新国家股票与原来的状态所有全局对象(例如表),但有一个独立的执行堆栈。

没有显式的函数来关闭或摧毁一个线程。线程是垃圾收集,像任何Lua对象。

lua_newuserdata

(0,+ 1,米]

void *lua_newuserdata (lua_State *L, size_t size);

这个函数分配一个新的块与给定的内存大小,推到堆栈中一个新的完整的用户数据块地址,并返回这个地址。

在Lua中用户数据表示CA?值。一个完整的用户数据代表一个内存块。它是一个对象(如表):你必须创建它,它可以有自己的元表,你可以检测时被收集。只等于一个完整的用户数据本身(在原始平等)。

当Lua收集一个完整的用户数据gc元方法,Lua调用元方法和标志着用户数据最终确定。当这个然后再次收集用户数据Lua释放相应的内存。

lua_next

(1 +(2 | 0)e]

int lua_next (lua_State *L, int index);

从堆栈中弹出一键,和从表中按一个键-值对给定的索引(“下一个”对给定的键)。如果没有其他元素表中,然后lua_next返回0(什么也推)。

一个典型的遍历看起来像这样:

     /* table is in the stack at index ‘t‘ */
     lua_pushnil(L);  /* first key */
     while (lua_next(L, t) != 0) {
       /* uses ‘key‘ (at index -2) and ‘value‘ (at index -1) */
       printf("%s - %s\n",
              lua_typename(L, lua_type(L, -2)),
              lua_typename(L, lua_type(L, -1)));
       /* removes ‘value‘; keeps ‘key‘ for next iteration */
       lua_pop(L, 1);
     }

遍历一个表时,不叫lua_tolstring直接在一个键,除非你知道关键实际上是一个字符串。回想一下,lua_tolstring变化在给定索引值;这混淆了下一个调用lua_next。

lua_Number

typedef double lua_Number;

在Lua中数据的类型。默认情况下,它是两倍,但可以改变luaconf.h。

通过配置文件你可以改变Lua与对数字的另一种类型(如操作。 、浮动或长)。

lua_objlen

(0 + 0- - - - - -]

size_t lua_objlen (lua_State *L, int index);

返回的“长度”的值在给定的可接受的指数:为字符串,这个字符串长度;表,这是长度的结果操作符(“#”);对于用户数据,这是分配的内存块的大小用户数据;其他值,isA?0。

lua_pcall

(-(娜戈+ 1)+(nresults | 1),- - - - - -]

int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);

在保护模式调用一个函数。

这两个娜戈和nresults有相同的意思吗在lua_call。如果没有错误在通话过程中,lua_pcall表现完全一样lua_call。然而,如果有任何错误,lua_pcall抓住它,把一个值在堆栈上(错误信息),并返回一个错误代码。就像lua_call,lua_pcall总是删除功能从堆栈中及其参数。

如果errfunc是0,错误消息返回到栈上就是原来的错误消息。否则,errfunc堆栈的指数吗错误处理函数。(在当前实现中,该指数不能pseudo-index)。在运行时错误的情况下,这个函数将调用的错误消息和它的返回值将消息返回到栈上lua_pcall。

通常,错误处理程序函数是用来添加更多的调试信息的错误消息,如堆栈回溯。这些信息不能被收集后的回归lua_pcall,自那时以来,堆栈解除。

的lua_pcall函数返回0的成功或者下面的错误代码(定义在lua.h):

• LUA_ERRRUN:一个运行时错误。
• LUA_ERRMEM:内存分配错误。对于这样的错误,Lua不调用错误处理程序函数。
• LUA_ERRERR:错误在运行错误处理函数。

lua_pop

(- n + 0,- - - - - -]

void lua_pop (lua_State *L, int n);

持久性有机污染物n从堆栈中元素。

lua_pushboolean

(0,+ 1,- - - - - -]

void lua_pushboolean (lua_State *L, int b);

把一个布尔值与值b压入堆栈。

lua_pushcclosure

(- n + 1,米]

void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);

推动一个新的CA?闭包压入堆栈。

当一个CA?创建一个函数时,可以把一些值,因此创建一个CA?一个闭包(见?§3.4);这些值可以无论何时调用的函数。把值和CA?一个函数,首先这些值应该被推到堆栈上(当有多个值,第一个值是推动第一)。然后lua_pushcclosure被称为创造和推动CA?函数放入堆栈中,与参数n应该告诉多少值相关的函数。lua_pushcclosure也从堆栈中弹出这些值。

的最大价值n是255。

lua_pushcfunction

(0,+ 1,米]

void lua_pushcfunction (lua_State *L, lua_CFunction f);

将CA?一个函数在堆栈。这个函数接收一个C函数指针并推到堆栈Lua的价值类型函数那当调用时,调用相应的CA?一个函数。

任何函数注册在Lua中必须的遵循正确的协议来接收它的参数并返回它的结果(见lua_CFunction)。

lua_pushcfunction被定义为一个宏:

     #define lua_pushcfunction(L,f)  lua_pushcclosure(L,f,0)

lua_pushfstring

(0,+ 1,米]

const char *lua_pushfstring (lua_State *L, const char *fmt, ...);

推到堆栈一个格式化的字符串并返回一个指向该字符串的指针。它类似于CA?一个函数sprintf,但是有一些重要的区别:

• 你不需要分配空间的结果:结果是一个Lua字符串和Lua负责内存分配通过垃圾回收(回收)。
• 转换说明符是相当限制。没有旗帜、宽度或精度。转换说明符只能”% %(插入的%字符串),”% s(插入一个字符串作为字符串,没有大小限制),”% f(插入一个lua_Number),”% p(插入一个十六进制数字指针),”% d(插入一个int),”% c(插入一个int作为一个字符)。

lua_pushinteger

(0,+ 1,- - - - - -]

void lua_pushinteger (lua_State *L, lua_Integer n);

把数字值n压入堆栈。

lua_pushlightuserdata

(0,+ 1,- - - - - -]

void lua_pushlightuserdata (lua_State *L, void *p);

推光用户数据压入堆栈。

在Lua中用户数据表示CA?值。一个轻用户数据代表一个指针。这是一个价值(如数量):您没有创建它,它没有单独的元表,和它不是收集(因为它从来没有创建)。轻用户数据等于“任何”光CA?地址相同的用户数据。

lua_pushliteral

(0,+ 1,米]

void lua_pushliteral (lua_State *L, const char *s);

这个宏是等价的lua_pushlstring,但只有当可以使用年代是一个文本字符串。在这些情况下,它会自动提供字符串长度。

lua_pushlstring

(0,+ 1,米]

void lua_pushlstring (lua_State *L, const char *s, size_t len);

把字符串指向年代与大小len压入堆栈。Lua是(或重用)内部给定字符串的副本,所以的记忆年代后立即可以释放或重用函数返回。字符串可以包含嵌入式零。

lua_pushnil

(0,+ 1,- - - - - -]

void lua_pushnil (lua_State *L);

把一个零值压入堆栈。

lua_pushnumber

(0,+ 1,- - - - - -]

void lua_pushnumber (lua_State *L, lua_Number n);

把数字值n压入堆栈。

lua_pushstring

(0,+ 1,米]

void lua_pushstring (lua_State *L, const char *s);

将字符串作为字符串指出年代压入堆栈。Lua是(或重用)内部给定字符串的副本,所以的记忆年代后立即可以释放或重用函数返回。字符串不能包含嵌入式零;它假定结束在第一个零。

lua_pushthread

(0,+ 1,- - - - - -]

int lua_pushthread (lua_State *L);

将线程为代表l压入堆栈。返回1如果这个线程是主要的线程的状态。

lua_pushvalue

(0,+ 1,- - - - - -]

void lua_pushvalue (lua_State *L, int index);

把元素的副本在给定的有效指标压入堆栈。

lua_pushvfstring

(0,+ 1,米]

const char *lua_pushvfstring (lua_State *L,
                              const char *fmt,
                              va_list argp);

相当于lua_pushfstring,除了它接收va_list而不是数量可变的参数。

lua_rawequal

(0 + 0- - - - - -]

int lua_rawequal (lua_State *L, int index1, int index2);

返回1,如果两个值在可接受的指标index1和index2原本是平等的(即,没有调用元方法)。否则returnsA?0。也returnsA?0如果任何指标的非有效。

lua_rawget

(1 + 1- - - - - -]

void lua_rawget (lua_State *L, int index);

类似于lua_gettable,但是一个原始访问(即。 ,没有元方法)。

lua_rawgeti

(0,+ 1,- - - - - -]

void lua_rawgeti (lua_State *L, int index, int n);

推到堆栈的价值t[n],在哪里t是在给定的有效指数的值。访问原始;也就是说,它不会调用元方法。

lua_rawset

[2 + 0米]

void lua_rawset (lua_State *L, int index);

类似于lua_settable,但原始任务(即。 ,没有元方法)。

lua_rawseti

(1 + 0米]

void lua_rawseti (lua_State *L, int index, int n);

的等效t[n]= v,在哪里t值在给定的有效指数吗和v是在堆栈的顶部的值。

这个函数值从堆栈中弹出。任务是生;也就是说,它不会调用元方法。

lua_Reader

typedef const char * (*lua_Reader) (lua_State *L,
                                    void *data,
                                    size_t *size);

读者所使用的函数lua_load。每次需要另一块的块,lua_load调用读者,通过在其数据参数。读者必须返回一个指针指向一块内存用一个新的块并设置大小块大小。块必须存在,直到读者函数被调用一次。信号的最后一部分,读者必须返回零或一组大小为零。读者函数可以返回任何大小的块大于零。

lua_register

(0 + 0e]

void lua_register (lua_State *L,
                   const char *name,
                   lua_CFunction f);

设置了C函数f作为全球的新值的名字。它被定义为一个宏:

     #define lua_register(L,n,f)             (lua_pushcfunction(L, f), lua_setglobal(L, n))

lua_remove

(1 + 0- - - - - -]

void lua_remove (lua_State *L, int index);

删除的元素在给定的有效指数,将上面的元素这个索引来填补这一缺口。不能被称为pseudo-index,因为pseudo-index不是一个实际的堆栈的位置。

lua_replace

(1 + 0- - - - - -]

void lua_replace (lua_State *L, int index);

顶部元素移动到指定位置(弹出),没有改变任何元素(因此替换值在给定的位置)。

lua_resume

[- ? 、+ ?- - - - - -]

int lua_resume (lua_State *L, int narg);

启动和恢复协同程序在给定线程。

开始协同程序时,您首先创建一个新线程(见lua_newthread);然后你推到堆栈主要功能加任何参数;然后你叫lua_resume,与娜戈参数的数量。这个调用返回时,协同程序暂停或结束其执行。它返回时,堆栈包含传递给所有值lua_yield,或返回的所有值的身体功能。lua_resume返回LUA_YIELD如果协同程序的收益率,0如果协同程序完成其执行没有错误,或一个错误代码的错误(见lua_pcall)。在错误的情况下,堆栈不解除,所以你可以使用调试API。错误消息在堆栈的顶部。重新启动协同程序,你把堆栈唯一的值结果获得通过收益率,然后调用lua_resume。

lua_setallocf

(0 + 0- - - - - -]

void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);

改变给定的分配器功能状态f与用户数据ud。

lua_setfenv

(1 + 0- - - - - -]

int lua_setfenv (lua_State *L, int index);

从堆栈中弹出一个表,并设置它在给定索引值的新环境。如果该值在给定的索引一个函数和一个线程和用户数据,lua_setfenv返回0。否则,它将返回1。

lua_setfield

(1 + 0e]

void lua_setfield (lua_State *L, int index, const char *k);

这相当于t[k]= v,在哪里t值在给定的有效指数吗和v是在堆栈的顶部的值。

这个函数值从堆栈中弹出。在Lua中,这个函数可能会触发一个元方法(见“newindex”事件?§2.8)。

lua_setglobal

(1 + 0e]

void lua_setglobal (lua_State *L, const char *name);

从堆栈中弹出一个值使它作为全球的新值的名字。它被定义为一个宏:

     #define lua_setglobal(L,s)   lua_setfield(L, LUA_GLOBALSINDEX, s)

lua_setmetatable

(1 + 0- - - - - -]

int lua_setmetatable (lua_State *L, int index);

从堆栈中弹出一个表使它作为新的元表为在给定的值可接受的指数。

lua_settable

[2 + 0e]

void lua_settable (lua_State *L, int index);

这相当于t[k]= v,在哪里t在给定的值有效的索引,v是在堆栈的顶部,和k是略低于前的值。

这个函数弹出键和值从堆栈。在Lua中,这个函数可能会触发一个元方法(见“newindex”事件?§2.8)。

lua_settop

[- ? 、+ ?- - - - - -]

void lua_settop (lua_State *L, int index);

接受任何可接受的指数,奥拉?0,并设置堆栈上到这个索引。如果新的比旧的大,新元素充满了零。如果指数isA?0,那么所有栈元素移除。

lua_State

typedef struct lua_State lua_State;

不透明的结构,使整个一个Lua解释器状态。Lua库是完全可重入:它没有全局变量。所有的信息保存在这个结构状态。

一个指向这个状态必须作为第一个参数传递每一个函数在图书馆,除了lua_newstate,从头开始创建一个Lua状态。

lua_status

(0 + 0- - - - - -]

int lua_status (lua_State *L);

返回该线程的状态l。

为一个正常的线程状态可以是0,一个错误代码如果线程执行完一个错误,或LUA_YIELD如果线程被挂起。

lua_toboolean

(0 + 0- - - - - -]

int lua_toboolean (lua_State *L, int index);

Lua值在给定的可接受的指标转化为CA?一个布尔值值(0?orA?一1)。在Lua中,像所有的测试lua_toboolean返回任何Lua值1不同于假和零;否则返回0。它还返回0时,称为无效的指数。(如果你想只接受实际的布尔值,使用lua_isboolean测试值的类型)。

lua_tocfunction

(0 + 0- - - - - -]

lua_CFunction lua_tocfunction (lua_State *L, int index);

将一个值在给定的可接受的指标转换为CA?一个函数。该值必须是一个CA?函数;否则,返回零。

lua_tointeger

(0 + 0- - - - - -]

lua_Integer lua_tointeger (lua_State *L, int index);

转换Lua值在给定的可接受的指数签名积分类型lua_Integer。Lua的值必须是一个数字或字符串转换数字(见?§2.2.1);否则,lua_tointegerreturnsA?0。

如果数量不是一个整数,这是截一些不特定的方式。

lua_tolstring

(0 + 0米]

const char *lua_tolstring (lua_State *L, int index, size_t *len);

Lua值在给定的可接受的指标转化为CA?一个字符串。如果len不是零,它还设置*兰字符串长度。Lua的值必须是一个字符串或一个数字;否则,函数返回零。如果该值是一个数字,然后lua_tolstring也变化的实际值栈一个字符串。(这种变化混淆lua_next当lua_tolstring应用在一个表遍历键。)

lua_tolstring返回一个指针完全一致一个字符串在Lua状态。这个字符串总是有一个零(‘ 0”)后最后一个字符(inA)?C),但在它的身体可以包含其他的0。因为Lua垃圾收集,没有保证返回的指针lua_tolstring有效期后相应的值从堆栈中删除。

lua_tonumber

(0 + 0- - - - - -]

lua_Number lua_tonumber (lua_State *L, int index);

转换Lua值在给定的可接受的指数CA?类型lua_Number(见lua_Number)。Lua的值必须是一个数字或字符串转换数字(见?§2.2.1);否则,lua_tonumberreturnsA?0。

lua_topointer

(0 + 0- - - - - -]

const void *lua_topointer (lua_State *L, int index);

转换值在给定的可接受的通用指标CA?一个指针(void *)。的值可以是一个用户数据,一张桌子,一个线程,或一个函数;否则,lua_topointer返回零。不同的对象会给不同的指针。没有办法的指针转换回原来的值。

通常这个函数仅用于调试信息。

lua_tostring

(0 + 0米]

const char *lua_tostring (lua_State *L, int index);

相当于lua_tolstring与len等于零。

lua_tothread

(0 + 0- - - - - -]

lua_State *lua_tothread (lua_State *L, int index);

转换值在给定的可接受的索引一个Lua线程(表示为lua_State *)。这个值必须是一个线程;否则,函数返回零。

lua_touserdata

(0 + 0- - - - - -]

void *lua_touserdata (lua_State *L, int index);

如果该值在给定的可接受的指数是一个完整的用户数据,返回其块地址。如果该值是一个用户数据,返回的指针。否则,返回零。

lua_type

(0 + 0- - - - - -]

int lua_type (lua_State *L, int index);

返回值的类型在给定的可接受的指数,或LUA_TNONE对于一个无效的指数(即,一个索引一个“空”的堆栈的位置)。返回的类型lua_type编码由以下常量中定义的lua.h:LUA_TNIL,LUA_TNUMBER,LUA_TBOOLEAN,LUA_TSTRING,LUA_TTABLE,LUA_TFUNCTION,LUA_TUSERDATA,LUA_TTHREAD,和LUA_TLIGHTUSERDATA。

lua_typename

(0 + 0- - - - - -]

const char *lua_typename  (lua_State *L, int tp);

返回类型的编码值的名称tp,必须一个返回的值lua_type。

lua_Writer

typedef int (*lua_Writer) (lua_State *L,
                           const void* p,
                           size_t sz,
                           void* ud);

作者所使用的函数的类型lua_dump。每次它产生另一个块,lua_dump所谓的作家,传递缓冲区写(p),它的大小(深圳),和数据参数提供给lua_dump。

作者返回一个错误代码:0?意味着没有错误;任何其他值意味着一个错误并停止lua_dump从再打电话给作者。

lua_xmove

[- ? 、+ ?- - - - - -]

void lua_xmove (lua_State *from, lua_State *to, int n);

不同线程之间的交换值相同全局状态。

这个函数会n值从堆栈从,并把他们压入堆栈来。

lua_yield

[- ? 、+ ?- - - - - -]

int lua_yield  (lua_State *L, int nresults);

产生一个协同程序。

这个函数应该只被称为返回表达式的CA?一个函数,如下:

     return lua_yield (L, nresults);

当CA?一个函数调用lua_yield通过这种方式,正在运行的协同程序暂停其执行,和调用lua_resume开始这个协同程序返回。的参数nresults值从堆栈的数量吗作为结果传递给lua_resume。

￠A€3.8”调试接口

Lua没有内置的调试设备。相反,它提供了一个特殊的接口通过功能和钩子。这个接口允许不同的建设类型的调试器,分析器和其他工具需要翻译的“内幕信息”。

lua_Debug

typedef struct lua_Debug {
  int event;
  const char *name;           /* (n) */
  const char *namewhat;       /* (n) */
  const char *what;           /* (S) */
  const char *source;         /* (S) */
  int currentline;            /* (l) */
  int nups;                   /* (u) number of upvalues */
  int linedefined;            /* (S) */
  int lastlinedefined;        /* (S) */
  char short_src[LUA_IDSIZE]; /* (S) */
  /* private part */
  other fields
} lua_Debug;

用于携带不同的结构一个活跃的功能的信息。lua_getstack填充只有私营部分这个结构,供以后使用。填补的其他领域lua_Debug有用的信息,调用lua_getinfo。

等领域的lua_Debug有以下的意义:

• 源:如果函数是定义在一个字符串,然后源是字符串。如果函数是定义在一个文件中,然后源从“@其次是文件名。
• short_src:“打印”的版本源,用于错误消息。
• linedefined:函数的定义开始的行号。
• lastlinedefined:函数的定义的行号结束。
• 什么:的字符串“Lua”如果函数是一个Lua函数,“C”如果它是一个CA?一个函数,“主要”如果它是一块的主要部分,和“尾巴”如果是做了尾部调用一个函数。在后一种情况下,Lua没有其他的信息功能。
• currentline:给定的函数执行的当前行。当没有行信息是可用的,currentline设置为1。
• 的名字:一个合理的为给定的函数名称。因为函数在Lua中是一流的值,他们没有一个固定的名称:有些功能可以多个全局变量的值,而其他人只能存储一个表中的字段。的lua_getinfo功能检查的功能找到一个合适的名称。如果不能找到一个名字,然后的名字被设置为零。
• namewhat:解释了的名字字段。的价值namewhat可以“全球”,“本地”,“方法”,“字段”,“upvalue”,或”“(空字符串),根据函数被调用的方式。(Lua使用空字符串时,似乎没有其他选择适用。)
• 国家联盟:函数的upvalues的数量。

lua_gethook

(0 + 0- - - - - -]

lua_Hook lua_gethook (lua_State *L);

返回当前的钩子函数。

lua_gethookcount

(0 + 0- - - - - -]

int lua_gethookcount (lua_State *L);

返回当前钩数。

lua_gethookmask

(0 + 0- - - - - -]

int lua_gethookmask (lua_State *L);

返回当前钩面具。

lua_getinfo

[-(0 | 1)+(0 | 1 | 2),米]

int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);

返回关于一个特定的函数或函数调用的信息。

一个函数调用的信息,的参数基于“增大化现实”技术必须是一个有效的活动记录,是吗由前一个调用lua_getstack或给一个钩子(见作为参数lua_Hook)。

函数的信息你把它压入堆栈并启动什么字符串与字符的>”。(在这种情况下,lua_getinfo持久性有机污染物中的函数堆栈的顶部)。例如,知道线的一个函数f被定义,您可以编写下面的代码:

     lua_Debug ar;
     lua_getfield(L, LUA_GLOBALSINDEX, "f");  /* get global ‘f‘ */
     lua_getinfo(L, ">S", &ar);
     printf("%d\n", ar.linedefined);

字符串中的每个字符什么选择一些字段的结构基于“增大化现实”技术填充或被推到栈上的值:

• ”n”:填补了该领域的的名字和namewhat;
• ”年代”:填充字段源,short_src,linedefined,lastlinedefined,什么;
• ”l”:填补了该领域的currentline;
• ”u”:填补了该领域的国家联盟;
• ”f”:推到堆栈的功能在给定的水平;
• ”l”:推到堆栈一个表的索引数字上的线是有效的功能。(一个有效的行是一个与一些相关的代码,也就是说,一条线,你可以把一个断点。无效的行包括空行和注释)。

这个函数返回0错误(例如,一个无效的选项什么)。

lua_getlocal

[0,+(0 | 1),- - - - - -]

const char *lua_getlocal (lua_State *L, lua_Debug *ar, int n);

得到一个局部变量信息的一个给定的活动记录。的参数基于“增大化现实”技术必须是一个有效的活动记录,是吗由前一个调用lua_getstack或给一个钩子(见作为参数lua_Hook)。该指数n选择本地变量检查(1是第一个参数或活跃的本地变量,等等,直到最后一个局部变量)。lua_getlocal将变量值压入堆栈并返回它的名字。

变量名开始的((打开括号)代表内部变量(循环控制变量、临时变量和CA?一个当地人)的函数。

返回零(什么也推)当该指数大于活跃的本地变量的数量。

lua_getstack

(0 + 0- - - - - -]

int lua_getstack (lua_State *L, int level, lua_Debug *ar);

解释器运行时堆栈信息。

这个函数的填充部分lua_Debug结构的识别活动记录函数的执行在一个给定的水平。LevelA?0是当前运行的函数,而水平n + 1的函数被称为水平n。当没有错误,lua_getstack返回1;当称为水平大于堆栈深度,它返回0。

lua_getupvalue

[0,+(0 | 1),- - - - - -]

const char *lua_getupvalue (lua_State *L, int funcindex, int n);

被关闭的upvalue信息。(Lua函数,upvalues外部局部变量,函数使用,,因此包含在其关闭。)lua_getupvalue得到了指数nupvalue,推动upvalue值压入堆栈,并返回它的名字。funcindex指向堆栈的闭包。(Upvalues没有特定的顺序,他们活跃在整个函数。所以,他们以任意顺序编号。)

返回零(什么也推)当该指数大于upvalues的数量。CA?一个函数,这个函数使用空字符串”“作为一个为所有upvalues名称。

lua_Hook

typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);

类型调试钩子函数。

每当一个钩子,它基于“增大化现实”技术观点有其领域事件设置为特定事件,引发了钩。Lua确定这些事件与以下常量:LUA_HOOKCALL,LUA_HOOKRET,LUA_HOOKTAILRET,LUA_HOOKLINE,和LUA_HOOKCOUNT。此外,对线事件currentline也是集。得到任何其他字段的值基于“增大化现实”技术,钩必须调用lua_getinfo。对返回的事件,事件可以LUA_HOOKRET,正常的价值,或LUA_HOOKTAILRET。在后一种情况下,Lua是模拟一个回来做了尾部调用的函数;在这种情况下,它是无用的lua_getinfo。

Lua是运行时一个钩子,它禁用其他调用钩子。因此,如果一个钩子调用Lua来执行一个函数或一块,这种执行发生没有任何调用钩子。

lua_sethook

(0 + 0- - - - - -]

int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);

设置调试钩子函数。

论点f钩子函数。面具指定的事件钩子将被称为:它是由一位或常量LUA_MASKCALL,LUA_MASKRET,LUA_MASKLINE,和LUA_MASKCOUNT。的数论点面具时才有意义包括LUA_MASKCOUNT。对于每个事件,钩叫做如下解释:

• 调用挂钩:时调用解释器调用一个函数。调用钩子Lua刚刚进入新功能,在函数的参数。
• 返回连接:时调用解释器从函数返回。调用钩子之前Lua函数。您没有访问返回的值函数。
• 线钩:被称为当翻译是吗开始新的一行代码的执行,或者当它跳回代码(甚至相同的线)。(这个事件只发生在Lua是执行一个Lua函数。)
• 计数看点:解释器执行每一个后被称为数指令。(这个事件只发生在Lua是执行一个Lua函数。)

通过设置一个钩子是禁用的面具为零。

lua_setlocal

【——+ 0(0 | 1)- - - - - -]

const char *lua_setlocal (lua_State *L, lua_Debug *ar, int n);

设置一个局部变量的值的一个给定的活动记录。参数基于“增大化现实”技术和n是在lua_getlocal(见lua_getlocal)。lua_setlocal价值分配在堆栈的顶部变量和返回它的名称。也就值从堆栈。

返回零(和持久性有机污染物)当该指数大于活跃的本地变量的数量。

lua_setupvalue

【——+ 0(0 | 1)- - - - - -]

const char *lua_setupvalue (lua_State *L, int funcindex, int n);

集闭包的upvalue的价值。它分配在堆栈的顶部的值upvalue并返回它的名称。也就值从堆栈。参数funcindex和n一样的lua_getupvalue(见lua_getupvalue)。

返回零(和持久性有机污染物)当该指数大于upvalues的数量。

4 A￠A€“辅助图书馆

的辅助图书馆提供了一些方便的功能用Lua C接口。虽然基本API提供的原始功能C和Lua之间的相互作用,辅助库提供了一些更高级的功能常见的任务。

所有功能的辅助图书馆在头文件中定义lauxlib.h和有一个前缀luaL_。

辅助库中的所有功能都是建立在基本API之上,所以他们提供什么,不能用这个API。

几个功能用于辅助库检查CA?函数参数。他们的名字总是luaL_check *或luaL_opt *。所有这些函数抛出一个错误如果检查不满意。因为错误消息被格式化参数(如。 ”,坏的论点# 1”),你不应该为其他堆栈使用这些函数值。

￠A€4.1”函数和类型

在这里我们列出所有辅助的功能和类型库按字母顺序排列的。

luaL_addchar

(0 + 0米]

void luaL_addchar (luaL_Buffer *B, char c);

添加角色c到缓冲区B(见luaL_Buffer)。

luaL_addlstring

(0 + 0米]

void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);

添加字符串指出年代长度为l来缓冲B(见luaL_Buffer)。字符串可以包含嵌入式零。

luaL_addsize

(0 + 0米]

void luaL_addsize (luaL_Buffer *B, size_t n);

增加了缓冲B(见luaL_Buffer)一个字符串的长度n之前复制到缓冲区(见luaL_prepbuffer)。

luaL_addstring

(0 + 0米]

void luaL_addstring (luaL_Buffer *B, const char *s);

添加字符串作为字符串指出年代到缓冲区B(见luaL_Buffer)。字符串可能不包含嵌入式零。

luaL_addvalue

(1 + 0米]

void luaL_addvalue (luaL_Buffer *B);

堆栈的顶部添加价值到缓冲区B(见luaL_Buffer)。持久性有机污染物的价值。

这是唯一在字符串缓冲区函数,可以(也必须)与一个额外的元素被称为堆栈,的值被添加到缓冲区。

luaL_argcheck

(0 + 0v]

void luaL_argcheck (lua_State *L,
                    int cond,
                    int narg,
                    const char *extramsg);

检查是否气孔导度是真的。如果没有,使用以下信息,提出了一个错误在哪里函数从调用堆栈中检索:

     bad argument #<narg> to <func> (<extramsg>)

luaL_argerror

(0 + 0v]

int luaL_argerror (lua_State *L, int narg, const char *extramsg);

使用以下信息,提出了一个错误在哪里函数从调用堆栈中检索:

     bad argument #<narg> to <func> (<extramsg>)

这个函数没有返回,但这是一个成语的CA?函数中使用它作为返回luaL_argerror(arg游戏)。

luaL_Buffer

typedef struct luaL_Buffer luaL_Buffer;

类型一个字符串缓冲区。

一个字符串缓冲区允许CA?代码构建零碎的Lua字符串。它的使用模式如下:

• 首先声明一个变量b类型的luaL_Buffer。
• 然后调用初始化它luaL_buffinit(L,直到。
• 然后你调用任何字符串块添加到缓冲区的luaL_add *功能。
• 你完成通过调用luaL_pushresult(乙)。这叫叶子最终字符串在堆栈的顶部。

在正常操作期间,一个字符串缓冲区使用一个变量的堆栈名额。所以,当使用一个缓冲,你不能假定你知道堆栈的顶部。您可以使用堆栈缓冲区操作的两次调用之间只要使用平衡;也就是说,当你调用一个缓冲操作,栈是在同一水平这是前面的缓冲后立即操作。(唯一的例外是luaL_addvalue)。后调用luaL_pushresult栈已经回到了水平缓冲初始化时,加上最终字符串。

luaL_buffinit

(0 + 0- - - - - -]

void luaL_buffinit (lua_State *L, luaL_Buffer *B);

初始化一个缓冲区B。这个函数不分配任何空间;缓冲区必须声明为一个变量(见luaL_Buffer)。

luaL_callmeta

[0,+(0 | 1),e]

int luaL_callmeta (lua_State *L, int obj, const char *e);

元方法。

如果索引的对象obj元表,这个吗元表有一个字段e,这个函数调用这个字段,并将对象作为其唯一的参数。在这种情况下,推到这个函数返回1堆栈调用所返回的值。如果没有元表或没有元方法,这个函数返回0(没有推栈上的任何值)。

luaL_checkany

(0 + 0v]

void luaL_checkany (lua_State *L, int narg);

检查是否该函数有一个参数(包括任何类型零)位置娜戈。

luaL_checkint

(0 + 0v]

int luaL_checkint (lua_State *L, int narg);

检查是否函数参数娜戈是一个数字并返回这个数字的int。

luaL_checkinteger

(0 + 0v]

lua_Integer luaL_checkinteger (lua_State *L, int narg);

检查是否函数参数娜戈是一个数字并返回这个数字的lua_Integer。

luaL_checklong

(0 + 0v]

long luaL_checklong (lua_State *L, int narg);

检查是否函数参数娜戈是一个数字并返回这个数字的长。

luaL_checklstring

(0 + 0v]

const char *luaL_checklstring (lua_State *L, int narg, size_t *l);

检查是否函数参数娜戈是一个字符串并返回此字符串;如果l不是零填满* l字符串的长度。

这个函数使用lua_tolstring其结果,所有函数的转换和警告也适用于此处。

luaL_checknumber

(0 + 0v]

lua_Number luaL_checknumber (lua_State *L, int narg);

检查是否函数参数娜戈是一个数字并返回这个数字。

luaL_checkoption

(0 + 0v]

int luaL_checkoption (lua_State *L,
                      int narg,
                      const char *def,
                      const char *const lst[]);

检查是否函数参数娜戈是一个字符串,搜索这个字符串数组中低水位体系域(必须以null结尾)。返回数组中的索引的字符串被发现。提出了一个错误,如果参数不是一个字符串或如果无法找到的字符串。

如果def不是零,这个函数使用def时一个默认值没有参数娜戈如果这个论点零。

这是一个有用的函数将字符串映射到CA?枚举。(通常的惯例是Lua库使用字符串,而不是数字选择选项。)

luaL_checkstack

(0 + 0v]

void luaL_checkstack (lua_State *L, int sz, const char *msg);

增加堆栈大小前+深圳元素,提高一个错误如果堆栈不能种植规模。味精是一个附加的文本进入错误消息。

luaL_checkstring

(0 + 0v]

const char *luaL_checkstring (lua_State *L, int narg);

检查是否函数参数娜戈是一个字符串并返回此字符串。

这个函数使用lua_tolstring其结果,所有函数的转换和警告也适用于此处。

luaL_checktype

(0 + 0v]

void luaL_checktype (lua_State *L, int narg, int t);

检查是否函数参数娜戈有类型t。看到lua_type的编码类型t。

luaL_checkudata

(0 + 0v]

void *luaL_checkudata (lua_State *L, int narg, const char *tname);

检查是否函数参数娜戈是一个用户数据的类型tname(见luaL_newmetatable)。

luaL_dofile

(0,+ ?米]

int luaL_dofile (lua_State *L, const char *filename);

加载并运行给定的文件。它被定义为以下宏:

     (luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))

如果没有错误则返回0或1的错误。

luaL_dostring

(0,+ ?米]

int luaL_dostring (lua_State *L, const char *str);

加载并运行给定的字符串。它被定义为以下宏:

     (luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))

如果没有错误则返回0或1的错误。

luaL_error

(0 + 0v]

int luaL_error (lua_State *L, const char *fmt, ...);

提出了一个错误。是由错误消息格式fmt加任何额外的参数,遵循同样的规则lua_pushfstring。它还增加了消息文件名和的开始发生错误的行号,如果这个信息是可用的。

这个函数没有返回,但这是一个成语的CA?函数中使用它作为返回luaL_error(arg游戏)。

luaL_getmetafield

[0,+(0 | 1),米]

int luaL_getmetafield (lua_State *L, int obj, const char *e);

推压入堆栈e从元表对象的索引obj。如果对象没有元表,或者如果元表没有这个字段,返回0和推动。

luaL_getmetatable

(0,+ 1,- - - - - -]

void luaL_getmetatable (lua_State *L, const char *tname);

推到堆栈与名字相关的元表tname在注册表中(见luaL_newmetatable)。

luaL_gsub

(0,+ 1,米]

const char *luaL_gsub (lua_State *L,
                       const char *s,
                       const char *p,
                       const char *r);

创建一个字符串的副本年代通过替换任何出现的字符串p的字符串r。栈上的推动产生的字符串并返回它。

luaL_loadbuffer

(0,+ 1,米]

int luaL_loadbuffer (lua_State *L,
                     const char *buff,
                     size_t sz,
                     const char *name);

加载一个Lua块缓冲区。这个函数使用lua_load加载的块缓冲指出,由迷与大小深圳。

这个函数返回相同的结果lua_load。的名字是块名,用于调试信息和错误消息。

luaL_loadfile

(0,+ 1,米]

int luaL_loadfile (lua_State *L, const char *filename);

加载一个文件作为一个Lua块。这个函数使用lua_load加载文件中的一部分命名文件名。如果文件名是零,它从标准输入。文件中的第一行是忽略了如果它开始#。

这个函数返回相同的结果lua_load,但是它有一个额外的错误代码LUA_ERRFILE如果不能打开/阅读该文件。

作为lua_load,这个函数只加载块;它不运行它。

luaL_loadstring

(0,+ 1,米]

int luaL_loadstring (lua_State *L, const char *s);

加载一个字符串作为Lua块。这个函数使用lua_load加载块字符串作为字符串年代。

这个函数返回相同的结果lua_load。

也是lua_load,这个函数只加载块;它不运行它。

luaL_newmetatable

(0,+ 1,米]

int luaL_newmetatable (lua_State *L, const char *tname);

如果注册表已经的关键tname,返回0。否则,创建一个新表用作元表对用户数据,将其添加到注册表与关键tname,并返回1。

在这两种情况下推到堆栈相关联的最终值与tname在注册表中。

luaL_newstate

(0 + 0- - - - - -]

lua_State *luaL_newstate (void);

创建一个新的Lua状态。它调用lua_newstate与一个基于standardA分配器?Crealloc函数然后设置一个恐慌函数(见lua_atpanic),打印一个错误消息到标准错误输出的致命的错误。

返回这个新国家,或零如果有一个内存分配错误。

luaL_openlibs

(0 + 0米]

void luaL_openlibs (lua_State *L);

打开所有标准Lua库到给定的状态。

luaL_optint

(0 + 0v]

int luaL_optint (lua_State *L, int narg, int d);

如果函数参数娜戈是一个数字,返回这个数字的int。如果这个论点或缺席零,返回d。否则,引发了一个错误。

luaL_optinteger

(0 + 0v]

lua_Integer luaL_optinteger (lua_State *L,
                             int narg,
                             lua_Integer d);

如果函数参数娜戈是一个数字,返回这个数字的lua_Integer。如果这个论点或缺席零,返回d。否则,引发了一个错误。

luaL_optlong

(0 + 0v]

long luaL_optlong (lua_State *L, int narg, long d);

如果函数参数娜戈是一个数字,返回这个数字的长。如果这个论点或缺席零,返回d。否则,引发了一个错误。

luaL_optlstring

(0 + 0v]

const char *luaL_optlstring (lua_State *L,
                             int narg,
                             const char *d,
                             size_t *l);

如果函数参数娜戈是一个字符串,返回此字符串。如果这个论点或缺席零,返回d。否则,引发了一个错误。

如果l不是零,填补这个职位* l结果的长度。

luaL_optnumber

(0 + 0v]

lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number d);

如果函数参数娜戈是一个数字,返回这个数字。如果这个论点或缺席零,返回d。否则,引发了一个错误。

luaL_optstring

(0 + 0v]

const char *luaL_optstring (lua_State *L,
                            int narg,
                            const char *d);

如果函数参数娜戈是一个字符串,返回此字符串。如果这个论点或缺席零,返回d。否则,引发了一个错误。

luaL_prepbuffer

(0 + 0- - - - - -]

char *luaL_prepbuffer (luaL_Buffer *B);

返回一个地址空间的大小LUAL_BUFFERSIZE你可以复制一个字符串添加到缓冲B(见luaL_Buffer)。字符串复制到这个空间之后你必须调用luaL_addsize添加字符串的大小缓冲区。

luaL_pushresult

[- ? + 1,米]

void luaL_pushresult (luaL_Buffer *B);

完成使用缓冲区B离开最后一个字符串堆栈的顶部。

luaL_ref

(1 + 0米]

int luaL_ref (lua_State *L, int t);

创建并返回一个参考,在索引表中t,的对象在堆栈的顶部(和持久性有机污染物的对象)。

是一个独特的整数键的引用。只要你不手动整数键添加到表中t,luaL_ref确保关键它返回的独特性。您可以检索对象引用r通过调用lua_rawgeti(L、t r)。函数luaL_unref释放及其相关对象的引用。

如果对象在堆栈的顶部零,luaL_ref返回常数LUA_REFNIL。常数LUA_NOREF保证是不同的吗从任何引用返回的luaL_ref。

luaL_Reg

typedef struct luaL_Reg {
  const char *name;
  lua_CFunction func;
} luaL_Reg;

类型的数组函数来注册luaL_register。的名字函数名和吗函数是一个指针这个函数。任何的数组luaL_Reg和一个哨兵条目必须结束吗在这两个的名字和函数是零。

luaL_register

【——+ 1(0 | 1)米]

void luaL_register (lua_State *L,
                    const char *libname,
                    const luaL_Reg *l);

打开一个图书馆。

当被称为库名等于零,它只是寄存器列表中的所有功能l(见luaL_Reg)表在堆栈的顶部。

当被称为非空库名,luaL_register创建一个新表t,设置全局变量的值库名,使它的价值package.loaded[库名],和寄存器列表中的所有功能l。如果有一个表package.loaded[库名]或在变量库名,重用这个表而不是创建一个新的。

在任何情况下功能叶表堆栈的顶部。

luaL_typename

(0 + 0- - - - - -]

const char *luaL_typename (lua_State *L, int index);

返回值的类型的名字在给定的索引。

luaL_typerror

(0 + 0v]

int luaL_typerror (lua_State *L, int narg, const char *tname);

生成一个错误消息如下:

     location: bad argument narg to ‘func‘ (tname expected, got rt)

在哪里位置是由luaL_where,函数是当前函数的名字,和rt是实际的类型名称参数。

luaL_unref

(0 + 0- - - - - -]

void luaL_unref (lua_State *L, int t, int ref);

发布参考裁判表的索引t(见luaL_ref)。从表中删除条目,所以称为对象可以收集。参考裁判也释放了被再次使用。

如果裁判是LUA_NOREF或LUA_REFNIL,luaL_unref什么也不做。

luaL_where

(0,+ 1,米]

void luaL_where (lua_State *L, int lvl);

推到堆栈字符串确定当前位置控制的水平级在调用堆栈。通常这个字符串具有以下格式:

     chunkname:currentline:

LevelA?0是运行函数,levelA?1的函数被称为运行功能,等。

这个函数是用来构建一个前缀的错误消息。

5 A￠A€“标准库

标准的Lua库提供有用的功能实现直接通过CA?API。其中的一些语言功能提供基本服务(例如,类型和getmetatable);别人提供“外”服务(如 、I / O);和其他人可以实现在Lua中本身,但非常有用或关键性能要求应该用C实现(例如,table.sort)。

库都是通过官方CA?API实现的并作为单独的CA?模块提供。目前,Lua有以下标准库:

• 基础库,包括协同程序sub-library;
• 包库;
• 字符串操作;
• 表操作;
• 数学函数(罪恶,日志等);
• 输入和输出;
• 操作系统设施;
• 调试设备。

除了基本的和包库,每个库提供了所有的函数作为全球的字段表或作为其对象的方法。

访问这些库,CA?主机程序应该调用luaL_openlibs函数,打开所有的标准库。另外,它可以单独通过调用打开它们luaopen_base(基本的库),luaopen_package(包库)luaopen_string(字符串库),luaopen_table(表库),luaopen_math(数学库),luaopen_io(用于I / O库),luaopen_os(操作系统库),和luaopen_debug(用于调试库)。这些函数中声明lualib.h不应该直接调用:你必须叫他们像其他任何Lua CA?一个函数,如。 ,通过使用lua_call。

￠A€5.1”基本功能

Lua的基本库提供了一些核心功能。如果你在应用程序中不包含这个库,你应该仔细检查你是否需要提供实现它的一些设施。

断言(v[信息])

collectgarbage([选择[arg]])

这个函数是一个通用的接口来垃圾收集器。根据它的第一个参数,它执行不同的功能选择:

• “收集”:执行一个完整的垃圾收集周期。这是默认选项。
• “停止”:停止垃圾收集器。
• “重启”:重新启动垃圾收集器。
• “数”:返回的总内存使用Lua(kb)。
• “步骤”:执行垃圾收集的步骤。这一步是由“大小”参数(大值意味着更多的步骤)不特定的方式。如果你想控制步长你必须通过实验优化的价值参数。返回真正的如果一步完成收集周期。
• “setpause”:集参数的新值暂停的收集器(见?§2.10)。返回前一个值暂停。
• “setstepmul”:集参数的新值一步乘数的收集器(见?§2.10)。返回前一个值一步。

dofile((文件名))

错误(消息[,])

通常情况下,错误增加了一些信息错误的位置初的消息。的水平参数指定了如何获得错误的位置。与levelA?1(默认),错误的位置错误函数被调用。LevelA?2点错误的功能,被称为错误被称为;等等。通过levelA?0可以避免的错误位置信息到消息。

_G

getfenv([f])

getmetatable(对象)

如果对象没有元表,返回零。否则,如果对象的元表“__metatable”领域,返回相关的值。否则,返回给定对象的元表。

ipairs(t)

返回三个值:一个迭代器函数,表t,0,所以建设

     for i,v in ipairs(t) do body end

将迭代双(1、t[1]),(2,t[2]),一个??一···?,第一个整数键不在桌子上。

负载(func(chunkname])

使用函数加载一块函数其作品。每次调用函数必须返回一个字符串,该字符串连接与之前的结果。返回一个空字符串,零,或没有价值的信号块的结束。

如果没有错误,返回编译块作为一个功能;否则,返回零加上错误消息。返回的函数的环境是全球环境。

chunkname用作错误消息块的名字吗和调试信息。当缺席,它默认为“=(负载)”。

loadfile((文件名))

类似于负载,但文件的一部分文件名或者从标准输入,如果没有给出文件名。

,chunkname loadstring(string[])

类似于负载,但得到给定字符串的一部分。

加载并运行一个给定的字符串,使用习语

     assert(loadstring(s))()

当缺席,chunkname默认为给定的字符串。

下一个(表、索引)

允许一个程序遍历表的所有字段。它的第一个参数是一个表和它的第二个参数在这个表的索引。下一个返回下一个索引的表及其相关的值。当被称为零为第二个参数,下一个返回一个初始索引及其相关的值。当叫最后一个指数,或与零在一个空表,下一个返回零。如果第二个参数是缺席的,那么它是解释为零。特别是,您可以使用下一个(t)检查表是否为空。

的顺序索引没有指定枚举,即使对于数字指标。(按照数字顺序遍历表,使用一个数值为或者是ipairs函数)。

的行为下一个是未定义的如果,在遍历,你表中的任何值分配给一个不存在的字段。不过你可以修改现有的字段。特别是,您可以清除现有油田。

双(t)

返回三个值:下一个函数,表t,零,所以建设

     for k,v in pairs(t) do body end

将遍历所有keyA￠A€“表的值对吗t。

看到函数下一个修改的说明表在遍历。

pcall(f __arg1?·??一个…)

调用函数f与在给定的参数保护模式。这意味着任何错误insideA?f不是传播;相反,pcall捕获的错误并返回一个状态码。它的第一个结果是状态代码(布尔),这是事实,如果调用成功,没有错误。在这种情况下,pcall也从调用返回所有结果,后第一个结果。在任何错误的情况下,pcall返回假加上错误消息。

打印(?·??一个…)

rawequal(v1、v2)

rawget(表,索引)

rawset(表、索引值)

这个函数返回表。

选择(指数,?·??一个…)

如果指数是一个数字,返回所有参数在参数数量指数。否则,指数必须是字符串“#”,和选择返回额外的参数收到的总数。

setfenv(f,表)

集环境使用给定的函数。f可以是一个Lua函数或一个号码吗指定的函数在堆栈级别:LevelA?1的函数调用setfenv。setfenv返回给定的函数。

作为一个特例,当f是0setfenv变化环境运行的线程。在这种情况下,setfenv不返回任何值。

元表setmetatable(表)

设置为给定的表元表。(你不能改变其他类型的元表Lua,只有从?c .)如果元表是零,删除给定表的元表。如果最初的元表“__metatable”领域,提出了一个错误。

这个函数返回表。

当时(e[,])

一个可选参数指定数字的基本解释。基地可能之间的任何整数2和36岁的包容性。在基地将?10,信的一个”(大写或小写)representsA?10”,B“representsA?11,等等,与“Z35的代表。在基地10(默认),可以有一个小数部分,以及一个可选的指数(见部分?§2.1)。在其他基地,只接受无符号整数。

tostring(e)

如果元表e有一个“__tostring”领域,然后tostring调用相应的价值与e作为参数,并使用调用的结果作为其结果。

类型(v)

解压缩(列表,我[j]])

     return list[i], list[i+1], ···, list[j]

除了上面的代码可以只写一个固定的数字的元素。默认情况下,我isA?1和j列表的长度,作为操作符(见定义的长度一个?§2.5.5)。

_VERSION

xpcall(f,犯错)

这个函数类似pcall,除了,你可以设定一个新的错误处理程序。

xpcall调用函数f在保护模式下,使用犯错错误处理程序。任何错误在里面f不是传播;相反,xpcall有错误,调用犯错函数与原错误对象,并返回一个状态码。它的第一个结果是状态代码(布尔),这是事实,如果调用成功,没有错误。在这种情况下,xpcall也从调用返回所有结果,后第一个结果。在任何错误的情况下,xpcall返回假加的结果犯错。

￠A€5.2”协同程序操作

相关的业务协同程序组成的sub-library基本的库和表内协同程序。看到?§2.11对于一般的协同程序的描述。

协同程序。 创建(f)

创建一个新的协同程序,身体f。f必须是一个Lua函数。返回这个新协同程序,一个对象的类型“线程”。

协同程序。 简历(co(val1,一个?·??一个…))

开始或继续协同程序的执行有限公司。第一次你简历一个协同程序,它开始运行它的身体。的值val1,一个?·?·?·传递身体的函数的参数。如果协同程序产生了,的简历重新启动;的值val1,一个?·?·?·传递产生的结果。

如果协同程序运行没有任何错误,的简历返回真正的加任何值传递给收益率(如果协同程序收益率)或任何身体函数返回的值(如果协同程序终止)。如果有任何错误,的简历返回假加上错误消息。

协同程序。 运行()

返回正在运行的协同程序,或零当由主线程调用。

协同程序。 状态(有限公司)

返回协同程序的状态有限公司,作为一个字符串:“运行”,如果协同程序正在运行(也就是说,它被称为状态);“暂停”,如果协同程序是悬浮在调用收益率,或者如果它尚未开始运行;“正常”如果协同程序积极但不运行(也就是说,它已经恢复另一个协同程序);和“死亡”如果协同程序完成其身体机能,或者如果它已经停止与一个错误。

协同程序。 包装(f)

创建一个新的协同程序,身体f。f必须是一个Lua函数。每次返回一个函数,简历协同程序调用它。任何参数传递给函数的行为额外的参数的简历。返回的返回相同的值的简历,除了第一个布尔。在错误的情况下,传播错误。

协同程序。 收益率(?·??一个…)

暂停调用协同程序的执行。协同程序不能运行一个CA?一个函数,元方法,或者迭代器。任何参数收益率作为额外的结果传递给吗的简历。

￠A€5.3”模块

包库提供了基础在Lua中加载和设施建设模块。直接出口的两个函数在全局环境中:需要和模块。其他的都是表中导出的包。

模块(名称[,?·??一个…))

创建一个模块。如果有一个表package.loaded[名称],这张桌子是模块。否则,如果有一个全球性的桌子t用给定的名称,这张桌子是模块。否则创建一个新表t和集全球的价值的名字和的价值package.loaded[名称]。这个函数也初始化t._NAME用给定的名称,t._M模块(t本身),和t._PACKAGE与包名(完整的模块名称-最后一个组件,见下文)。最后,模块集t随着新环境当前函数的新值package.loaded[名称],这需要返回t。

如果的名字是一个复合名称(即一个组件由点),模块创建(或重用,如果他们已经存在)表为每个组件。例如,如果的名字是a.b.c,然后模块表中字段存储模块c的场b全球一个。

这个函数可以接受可选选项后模块的名称,其中每个选项是一个函数应用模块。

要求(modname)

加载模块。函数首先调查package.loaded表以确定是否modname已经加载。如果是,那么需要返回值的存储在package.loaded[modname]。否则,它试图找到一个加载程序的模块。

找到一个装载机,需要引导的package.loaders数组中。通过改变这个数组,我们可以改变需要寻找一个模块。下面的解释是基于缺省配置为package.loaders。

第一个需要查询package.preload[modname]。如果它有一个值,这个值(这应该是一个函数)是装载机。否则需要搜索一个Lua加载程序使用路径存储在package.path。如果这也失败了,它搜索一个CA?装载机使用路径存储在package.cpath。如果这也失败了,这试一个一体化的加载程序(见package.loaders)。

一旦找到装载机,需要调用一个参数的装载机,modname。如果加载程序返回任何值,需要指定返回的值package.loaded[modname]。如果加载程序不返回任何值没有分配任何价值吗package.loaded[modname],然后需要分配真正的这个条目。在任何情况下,需要返回最终的价值package.loaded[modname]。

如果有任何错误在装载或运行模块,或者如果它不能找到任何模块加载器,然后需要一个错误的信号。

package.cpath

使用的路径需要寻找一个CA?加载程序。

Lua初始化CA?路径package.cpath以同样的方式它初始化Lua路径package.path,使用环境变量LUA_CPATH或一个默认路径中定义luaconf.h。

package.loaded

使用的表需要来控制的模块已经加载。当您需要一个模块modname和package.loaded[modname]不是假的,需要简单的返回值存储在那里。

package.loaders

使用的表需要控制如何加载模块。

这个表中的每个条目是一个搜索功能。当寻找一个模块,需要调用每一个搜索者以升序排序,模块名称(给的论证需要),其唯一的参数。函数可以返回另一个函数(模块加载程序)或字符串解释为什么它没有发现模块(或零如果没有说)。Lua初始化这个表有四个功能。

第一个搜索器简单地寻找的装载机package.preload表。

第二个搜索者寻找装载机作为一个Lua库,使用存储的路径package.path。一条路径是一个序列模板用分号分隔。对于每一个模板,搜索者会改变每个审讯马克在模板文件名,这是每个点的模块名称所取代(如“目录分隔符/“在Unix);然后它将尝试打开结果文件的名字。所以,例如,如果路径是Lua字符串

     "./?.lua;./?.lc;/usr/local/?/init.lua"

寻找一个Lua文件模块喷火将尝试打开文件吗。/ foo.lua,。/ foo.lc,/usr/local/foo/init.lua,在这个秩序。

第三个搜索者寻找装载机CA?一个图书馆,使用的路径变量package.cpath。例如,如果CA?路径字符串

     "./?.so;./?.dll;/usr/local/?/init.so"

的搜索器模块喷火将尝试打开文件吗。/ foo.so,。/ foo.dll,和/usr/local/foo/init.so,在这个秩序。一旦它找到一个CA?库,这个搜索器首先使用一个动态链接设备连接应用程序库。然后它试图找到一个CA?在库的函数作为加载程序。这个CA?一个函数的名称字符串“luaopen_”连接模块名称的一个副本,每个点替换为下划线。此外,如果模块名称有一个连字符,其前缀(并包括)第一个字符被删除。例如,如果模块名称a.v1-b.c,函数名luaopen_b_c。

第四个搜索器一个一体化的装载机。它会搜索CA?库路径根给定的模块的名称。例如,当要求a.b.c,它将搜索一个CA?图书馆一个。如果发现,看起来到开放的功能子模块;在我们的示例中,这将是luaopen_a_b_c。使用这种设备,一个包可以装几个CA?子到一个库,每个子模块保持原来的开放功能。

包中。 loadlib(库名,funcname)

动态链接主程序与CA?一个图书馆库名。在这个图书馆,寻找一个函数funcname并返回该函数作为一个CA?一个函数。(所以,funcname必须遵守协议(看到了吗lua_CFunction))。

这是一个低级别的功能。它完全绕过了包和模块系统。不像需要,它不执行任何搜索和路径不自动添加扩展。库名必须的完整文件名CA?一个图书馆,包括必要的路径和扩展。funcname必须准确的名字出口的CA?图书馆吗(这可能取决于CA?一个编译器和链接器使用)。

这个函数不支持ANSI C。因此,只有在一些平台上可用(Windows、Linux、Mac OS X、Solaris,BSD,加上其他Unix系统支持dlfcn标准)。

package.path

使用的路径需要寻找一个Lua加载程序。

在启动,Lua初始化这个变量环境变量的值LUA_PATH或中定义的默认路径luaconf.h,如果环境变量没有定义。任何“;;“在环境变量的值取而代之的是默认路径。

package.preload

一个表来存储加载器对特定模块(见需要)。

包中。 seeall(模块)

集的元表模块与它的__index指的是全球环境领域,所以这个模块继承值从全球环境。作为一个选择函数模块。

￠A€5.4”字符串操作

这个库提供了通用的字符串处理函数,如发现和提取子字符串和模式匹配。在Lua字符串索引时,第一个字符是positionA?1(非atA?0,如C)。索引可以是负的,解释为索引向后,从字符串的结束。因此,最后一个字符是在位置1,等等。

表内的字符串库提供了所有的函数字符串。它还设置字符串的元表在哪里__index字段指向字符串表。因此,您可以使用字符串函数在面向对象风格。例如,字符串。 字节(年代,我)可以写成s:字节(我)。